- 介绍
当我们在单片机上做类似 马里奥 的游戏时,常常有一张比oled屏幕大很多的背景图。当人物移动时,其实是背景在移动,也就是取背景图上的一部分显示在屏幕上。以我的48*84大小的屏幕为例。
这是函数声明:
/** Draw pic
*
* 输入的图像必须宽大于84像素,高大于48像素
* @param x0表示从图像的横坐标位置开始显示
* @param y0表示从图像的纵坐标位置开始显示
* @param nrowst图像的总宽度
* @param ncolst图像的总高度
* @param pic - 2Dt图像的输入指针
*/
void drawPic(int x0,
int y0,
int nrows,
int ncols,
char *pic);
这是函数定义:
void drawPic(int x0,
int y0,
int nrows,
int ncols,
char *pic)
{
if(ncols%8) //因为取模软件输出的是默认高为8的整数倍
{
ncols = (ncols/8 + 1) * 8;
}
if((nrows - x0) < 84) //这里是防止要显示的图像比屏幕小
x0 = nrows - 84;
if((ncols - y0) < 48) //这里是防止要显示的图像比屏幕小
y0 = ncols - 48;
for(int m = 0; m < 84; m++) //屏幕是垂直扫描,这里是屏幕的总宽度84像素
{
for(int n = 0; n < 6; n++) //这里是屏幕的总高度是48像素,每个字节包含了8个像素,所以循环6次
{
char pixels = 0;
//输入的图像是一维数组,我们根据要显示的图像位置坐标找到从图像的那个位置开始显示
int divisor = ((x0 + m) * ncols + (y0 + n * 8))/8;
//这里是求一个余数,就是要取当前字节remainder 位和下个字节8-remainder 位组合成一个字节
int remainder = ((x0 + m) * ncols + (y0 + n * 8))%8;
//组合的方法
pixels = ((pic[divisor] << remainder)) + ((pic[divisor+1] >> (8 - remainder)));
buffer[m][n] = pixels; //buffer是你的屏幕显示数据的缓冲区
}
}
}
这是最终的效果:
下面是以LPC1768为例的源码:
- N5110.h
#ifndef N5110_H
#define N5110_H
#include "mbed.h"
// Command Bytes - taken from Chris Yan's library
// More information can be found in the display datasheet
// H = 0 - Basic instructions
#define CMD_DC_CLEAR_DISPLAY 0x08
#define CMD_DC_NORMAL_MODE 0x0C
#define CMD_DC_FILL_DISPLAY 0x09
#define CMD_DC_INVERT_VIDEO 0x0D
#define CMD_FS_HORIZONTAL_MODE 0x00
#define CMD_FS_VERTICAL_MODE 0x02
#define CMD_FS_BASIC_MODE 0x00
#define CMD_FS_EXTENDED_MODE 0x01
#define CMD_FS_ACTIVE_MODE 0x00
#define CMD_FS_POWER_DOWN_MODE 0x04
// H = 1 - Extended instructions
#define CMD_TC_TEMP_0 0x04
#define CMD_TC_TEMP_1 0x05
#define CMD_TC_TEMP_2 0x06
#define CMD_TC_TEMP_3 0x07
#define CMD_BI_MUX_24 0x15
#define CMD_BI_MUX_48 0x13
#define CMD_BI_MUX_100 0x10
#define CMD_VOP_6V06 0xB2
#define CMD_VOP_7V38 0xC8
// number of pixels on display
#define WIDTH 84
#define HEIGHT 48
#define BANKS 6
/// Fill types for 2D shapes
enum FillType {
FILL_TRANSPARENT, ///< Transparent with outline
FILL_BLACK, ///< Filled black
FILL_WHITE, ///< Filled white (no outline)
};
class N5110
{
private:
// objects
SPI *_spi;
PwmOut *_led;
DigitalOut *_pwr;
DigitalOut *_sce;
DigitalOut *_rst;
DigitalOut *_dc;
// variables
unsigned char buffer[84][6]; // screen buffer - the 6 is for the banks - each one is 8 bits;
public:
/** Create a N5110 object connected to the specified pins
*
* @param pwr Pin connected to Vcc on the LCD display (pin 1)
* @param sce Pin connected to chip enable (pin 3)
* @param rst Pin connected to reset (pin 4)
* @param dc Pin connected to data/command select (pin 5)
* @param mosi Pin connected to data input (MOSI) (pin 6)
* @param sclk Pin connected to serial clock (SCLK) (pin 7)
* @param led Pin connected to LED backlight (must be PWM) (pin 8)
*
*/
N5110(PinName const pwrPin,
PinName const scePin,
PinName const rstPin,
PinName const dcPin,
PinName const mosiPin,
PinName const sclkPin,
PinName const ledPin);
/** Create a N5110 object connected to the specified pins (Vcc to +3V3)
*
* @param sce Pin connected to chip enable (pin 3)
* @param rst Pin connected to reset (pin 4)
* @param dc Pin connected to data/command select (pin 5)
* @param mosi Pin connected to data input (MOSI) (pin 6)
* @param sclk Pin connected to serial clock (SCLK) (pin 7)
* @param led Pin connected to LED backlight (must be PWM) (pin 8)
*
*/
N5110(PinName const scePin,
PinName const rstPin,
PinName const dcPin,
PinName const mosiPin,
PinName const sclkPin,
PinName const ledPin);
/**
* Free allocated memory when object goes out of scope
*/
~N5110();
/** Initialise display
*
* Powers up the display and turns on backlight (50% brightness default).
* Sets the display up in horizontal addressing mode and with normal video mode.
*/
void init();
/** Turn off
*
* Powers down the display and turns of the backlight.
* Needs to be reinitialised before being re-used.
*/
void turnOff();
/** Clear
*
* Clears the screen buffer.
*/
void clear();
/** Turn on normal video mode (default)
* Black on white
*/
void normalMode();
/** Turn on inverse video mode (default)
* White on black
*/
void inverseMode();
/** Set Brightness
*
* Sets brightness of LED backlight.
* @param brightness - float in range 0.0 to 1.0
*/
void setBrightness(float const brightness);
/** Print String
*
* Prints a string of characters to the screen buffer. String is cut-off after the 83rd pixel.
* @param x - the column number (0 to 83)
* @param y - the row number (0 to 5) - the display is split into 6 banks - each bank can be considered a row
*/
void printString(char const *str,
unsigned int const x,
unsigned int const y);
/** Print Character
*
* Sends a character to the screen buffer. Printed at the specified location. Character is cut-off after the 83rd pixel.
* @param c - the character to print. Can print ASCII as so printChar('C').
* @param x - the column number (0 to 83)
* @param y - the row number (0 to 5) - the display is split into 6 banks - each bank can be considered a row
*/
void printChar(char const c,
unsigned int const x,
unsigned int const y);
/** Set a Pixel
*
* This function sets a pixel in the screen buffer.
* @param x - the x co-ordinate of the pixel (0 to 83)
* @param y - the y co-ordinate of the pixel (0 to 47)
*/
void setPixel(unsigned int const x,
unsigned int const y);
/** Clear a Pixel
*
* This function clears pixel in the screen buffer
* @param x - the x co-ordinate of the pixel (0 to 83)
* @param y - the y co-ordinate of the pixel (0 to 47)
*/
void clearPixel(unsigned int const x,
unsigned int const y);
/** Get a Pixel
*
* This function gets the status of a pixel in the screen buffer.
* @param x - the x co-ordinate of the pixel (0 to 83)
* @param y - the y co-ordinate of the pixel (0 to 47)
* @returns
* 0 - pixel is clear
* 1 - pixel is set
*/
int getPixel(unsigned int const x,
unsigned int const y) const;
/** Refresh display
*
* This functions sends the screen buffer to the display.
*/
void refresh();
/** Randomise buffer
*
* This function fills the buffer with random data. Can be used to test the display.
* A call to refresh() must be made to update the display to reflect the change in pixels.
* The seed is not set and so the generated pattern will probably be the same each time.
* TODO: Randomise the seed - maybe using the noise on the AnalogIn pins.
*/
void randomiseBuffer();
/** Plot Array
*
* This function plots a one-dimensional array in the buffer.
* @param array[] - y values of the plot. Values should be normalised in the range 0.0 to 1.0. First 84 plotted.
*/
void plotArray(float const array[]);
/** Draw Circle
*
* This function draws a circle at the specified origin with specified radius in the screen buffer
* Uses the midpoint circle algorithm.
* @see http://en.wikipedia.org/wiki/Midpoint_circle_algorithm
* @param x0 - x-coordinate of centre
* @param y0 - y-coordinate of centre
* @param radius - radius of circle in pixels
* @param fill - fill-type for the shape
*/
void drawCircle(unsigned int const x0,
unsigned int const y0,
unsigned int const radius,
FillType const fill);
/** Draw Line
*
* This function draws a line between the specified points using linear interpolation.
* @param x0 - x-coordinate of first point
* @param y0 - y-coordinate of first point
* @param x1 - x-coordinate of last point
* @param y1 - y-coordinate of last point
* @param type - 0 white,1 black,2 dotted
*/
void drawLine(unsigned int const x0,
unsigned int const y0,
unsigned int const x1,
unsigned int const y1,
unsigned int const type);
/** Draw Rectangle
*
* This function draws a rectangle.
* @param x0 - x-coordinate of origin (top-left)
* @param y0 - y-coordinate of origin (top-left)
* @param width - width of rectangle
* @param height - height of rectangle
* @param fill - fill-type for the shape
*/
void drawRect(unsigned int const x0,
unsigned int const y0,
unsigned int const width,
unsigned int const height,
FillType const fill);
/** Draw Sprite
*
* This function draws a sprite as defined in a 2D array
* @param x0 - x-coordinate of origin (top-left)
* @param y0 - y-coordinate of origin (top-left)
* @param nrows - number of rows in sprite
* @param ncols - number of columns in sprite
* @param sprite - 2D array representing the sprite
*/
void drawSprite(int x0,
int y0,
int nrows,
int ncols,
int *sprite);
/** Draw pic
*
* 输入的图像必须宽大于84像素,高大于48像素
* @param x0表示从图像的横坐标位置开始显示
* @param y0表示从图像的纵坐标位置开始显示
* @param nrowst图像的总宽度
* @param ncolst图像的总高度
* @param pic - 2Dt图像的输入指针
*/
void drawPic(int x0,
int y0,
int nrows,
int ncols,
char *pic);
private:
// methods
void setXYAddress(unsigned int const x,
unsigned int const y);
void initSPI();
void turnOn();
void reset();
void clearRAM();
void sendCommand(unsigned char command);
void sendData(unsigned char data);
};
const unsigned char font5x7[480] = {
0x00, 0x00, 0x00, 0x00, 0x00,// (space)
0x00, 0x00, 0x5F, 0x00, 0x00,// !
0x00, 0x07, 0x00, 0x07, 0x00,// "
0x14, 0x7F, 0x14, 0x7F, 0x14,// #
0x24, 0x2A, 0x7F, 0x2A, 0x12,// $
0x23, 0x13, 0x08, 0x64, 0x62,// %
0x36, 0x49, 0x55, 0x22, 0x50,// &
0x00, 0x05, 0x03, 0x00, 0x00,// '
0x00, 0x1C, 0x22, 0x41, 0x00,// (
0x00, 0x41, 0x22, 0x1C, 0x00,// )
0x08, 0x2A, 0x1C, 0x2A, 0x08,// *
0x08, 0x08, 0x3E, 0x08, 0x08,// +
0x00, 0x50, 0x30, 0x00, 0x00,// ,
0x08, 0x08, 0x08, 0x08, 0x08,// -
0x00, 0x60, 0x60, 0x00, 0x00,// .
0x20, 0x10, 0x08, 0x04, 0x02,// /
0x3E, 0x51, 0x49, 0x45, 0x3E,// 0
0x00, 0x42, 0x7F, 0x40, 0x00,// 1
0x42, 0x61, 0x51, 0x49, 0x46,// 2
0x21, 0x41, 0x45, 0x4B, 0x31,// 3
0x18, 0x14, 0x12, 0x7F, 0x10,// 4
0x27, 0x45, 0x45, 0x45, 0x39,// 5
0x3C, 0x4A, 0x49, 0x49, 0x30,// 6
0x01, 0x71, 0x09, 0x05, 0x03,// 7
0x36, 0x49, 0x49, 0x49, 0x36,// 8
0x06, 0x49, 0x49, 0x29, 0x1E,// 9
0x00, 0x36, 0x36, 0x00, 0x00,// :
0x00, 0x56, 0x36, 0x00, 0x00,// ;
0x00, 0x08, 0x14, 0x22, 0x41,// <
0x14, 0x14, 0x14, 0x14, 0x14,// =
0x41, 0x22, 0x14, 0x08, 0x00,// >
0x02, 0x01, 0x51, 0x09, 0x06,// ?
0x32, 0x49, 0x79, 0x41, 0x3E,// @
0x7E, 0x11, 0x11, 0x11, 0x7E,// A
0x7F, 0x49, 0x49, 0x49, 0x36,// B
0x3E, 0x41, 0x41, 0x41, 0x22,// C
0x7F, 0x41, 0x41, 0x22, 0x1C,// D
0x7F, 0x49, 0x49, 0x49, 0x41,// E
0x7F, 0x09, 0x09, 0x01, 0x01,// F
0x3E, 0x41, 0x41, 0x51, 0x32,// G
0x7F, 0x08, 0x08, 0x08, 0x7F,// H
0x00, 0x41, 0x7F, 0x41, 0x00,// I
0x20, 0x40, 0x41, 0x3F, 0x01,// J
0x7F, 0x08, 0x14, 0x22, 0x41,// K
0x7F, 0x40, 0x40, 0x40, 0x40,// L
0x7F, 0x02, 0x04, 0x02, 0x7F,// M
0x7F, 0x04, 0x08, 0x10, 0x7F,// N
0x3E, 0x41, 0x41, 0x41, 0x3E,// O
0x7F, 0x09, 0x09, 0x09, 0x06,// P
0x3E, 0x41, 0x51, 0x21, 0x5E,// Q
0x7F, 0x09, 0x19, 0x29, 0x46,// R
0x46, 0x49, 0x49, 0x49, 0x31,// S
0x01, 0x01, 0x7F, 0x01, 0x01,// T
0x3F, 0x40, 0x40, 0x40, 0x3F,// U
0x1F, 0x20, 0x40, 0x20, 0x1F,// V
0x7F, 0x20, 0x18, 0x20, 0x7F,// W
0x63, 0x14, 0x08, 0x14, 0x63,// X
0x03, 0x04, 0x78, 0x04, 0x03,// Y
0x61, 0x51, 0x49, 0x45, 0x43,// Z
0x00, 0x00, 0x7F, 0x41, 0x41,// [
0x02, 0x04, 0x08, 0x10, 0x20,// "\"
0x41, 0x41, 0x7F, 0x00, 0x00,// ]
0x04, 0x02, 0x01, 0x02, 0x04,// ^
0x40, 0x40, 0x40, 0x40, 0x40,// _
0x00, 0x01, 0x02, 0x04, 0x00,// `
0x20, 0x54, 0x54, 0x54, 0x78,// a
0x7F, 0x48, 0x44, 0x44, 0x38,// b
0x38, 0x44, 0x44, 0x44, 0x20,// c
0x38, 0x44, 0x44, 0x48, 0x7F,// d
0x38, 0x54, 0x54, 0x54, 0x18,// e
0x08, 0x7E, 0x09, 0x01, 0x02,// f
0x08, 0x14, 0x54, 0x54, 0x3C,// g
0x7F, 0x08, 0x04, 0x04, 0x78,// h
0x00, 0x44, 0x7D, 0x40, 0x00,// i
0x20, 0x40, 0x44, 0x3D, 0x00,// j
0x00, 0x7F, 0x10, 0x28, 0x44,// k
0x00, 0x41, 0x7F, 0x40, 0x00,// l
0x7C, 0x04, 0x18, 0x04, 0x78,// m
0x7C, 0x08, 0x04, 0x04, 0x78,// n
0x38, 0x44, 0x44, 0x44, 0x38,// o
0x7C, 0x14, 0x14, 0x14, 0x08,// p
0x08, 0x14, 0x14, 0x18, 0x7C,// q
0x7C, 0x08, 0x04, 0x04, 0x08,// r
0x48, 0x54, 0x54, 0x54, 0x20,// s
0x04, 0x3F, 0x44, 0x40, 0x20,// t
0x3C, 0x40, 0x40, 0x20, 0x7C,// u
0x1C, 0x20, 0x40, 0x20, 0x1C,// v
0x3C, 0x40, 0x30, 0x40, 0x3C,// w
0x44, 0x28, 0x10, 0x28, 0x44,// x
0x0C, 0x50, 0x50, 0x50, 0x3C,// y
0x44, 0x64, 0x54, 0x4C, 0x44,// z
0x00, 0x08, 0x36, 0x41, 0x00,// {
0x00, 0x00, 0x7F, 0x00, 0x00,// |
0x00, 0x41, 0x36, 0x08, 0x00,// }
0x08, 0x08, 0x2A, 0x1C, 0x08,// ->
0x08, 0x1C, 0x2A, 0x08, 0x08 // <-
};
#endif
- N5110.cpp
#include "mbed.h"
#include "N5110.h"
// overloaded constructor includes power pin - LCD Vcc connected to GPIO pin
// this constructor works fine with LPC1768 - enough current sourced from GPIO
// to power LCD. Doesn't work well with K64F.
N5110::N5110(PinName const pwrPin,
PinName const scePin,
PinName const rstPin,
PinName const dcPin,
PinName const mosiPin,
PinName const sclkPin,
PinName const ledPin)
:
_spi(new SPI(mosiPin,NC,sclkPin)), // create new SPI instance and initialise
_led(new PwmOut(ledPin)),
_pwr(new DigitalOut(pwrPin)),
_sce(new DigitalOut(scePin)),
_rst(new DigitalOut(rstPin)),
_dc(new DigitalOut(dcPin))
{}
// overloaded constructor does not include power pin - LCD Vcc must be tied to +3V3
// Best to use this with K64F as the GPIO hasn't sufficient output current to reliably
// drive the LCD.
N5110::N5110(PinName const scePin,
PinName const rstPin,
PinName const dcPin,
PinName const mosiPin,
PinName const sclkPin,
PinName const ledPin)
:
_spi(new SPI(mosiPin,NC,sclkPin)), // create new SPI instance and initialise
_led(new PwmOut(ledPin)),
_pwr(NULL), // pwr not needed so null it to be safe
_sce(new DigitalOut(scePin)),
_rst(new DigitalOut(rstPin)),
_dc(new DigitalOut(dcPin))
{}
N5110::~N5110()
{
delete _spi;
if(_pwr) {
delete _pwr;
}
delete _led;
delete _sce;
delete _rst;
delete _dc;
}
// initialise function - powers up and sends the initialisation commands
void N5110::init()
{
turnOn(); // power up
reset(); // reset LCD - must be done within 100 ms
initSPI();
// function set - extended
sendCommand(0x20 | CMD_FS_ACTIVE_MODE | CMD_FS_HORIZONTAL_MODE | CMD_FS_EXTENDED_MODE);
// Don't completely understand these parameters - they seem to work as they are
// Consult the datasheet if you need to change them
sendCommand(CMD_VOP_7V38); // operating voltage - these values are from Chris Yan's Library
sendCommand(CMD_TC_TEMP_2); // temperature control
sendCommand(CMD_BI_MUX_48); // changing this can sometimes improve the contrast on some displays
// function set - basic
sendCommand(0x20 | CMD_FS_ACTIVE_MODE | CMD_FS_HORIZONTAL_MODE | CMD_FS_BASIC_MODE);
normalMode(); // normal video mode by default
sendCommand(CMD_DC_NORMAL_MODE); // black on white
clearRAM(); // RAM is undefined at power-up so clear
clear(); // clear buffer
setBrightness(0.5);
}
// sets normal video mode (black on white)
void N5110::normalMode()
{
sendCommand(CMD_DC_NORMAL_MODE);
}
// sets normal video mode (white on black)
void N5110::inverseMode()
{
sendCommand(CMD_DC_INVERT_VIDEO);
}
// function to power up the LCD and backlight - only works when using GPIO to power
void N5110::turnOn()
{
if (_pwr != NULL) {
_pwr->write(1); // apply power
}
}
// function to power down LCD
void N5110::turnOff()
{
clear(); // clear buffer
refresh();
setBrightness(0.0); // turn backlight off
clearRAM(); // clear RAM to ensure specified current consumption
// send command to ensure we are in basic mode
sendCommand(0x20 | CMD_FS_ACTIVE_MODE | CMD_FS_HORIZONTAL_MODE | CMD_FS_BASIC_MODE);
// clear the display
sendCommand(CMD_DC_CLEAR_DISPLAY);
// enter the extended mode and power down
sendCommand(0x20 | CMD_FS_POWER_DOWN_MODE | CMD_FS_HORIZONTAL_MODE | CMD_FS_EXTENDED_MODE);
// small delay and then turn off the power pin
wait_ms(10);
// if we are powering the LCD using the GPIO then make it low to turn off
if (_pwr != NULL) {
_pwr->write(0); // turn off power
}
}
// function to change LED backlight brightness
void N5110::setBrightness(float brightness)
{
// check whether brightness is within range
if (brightness < 0.0f)
brightness = 0.0f;
if (brightness > 1.0f)
brightness = 1.0f;
// set PWM duty cycle
_led->write(brightness);
}
// pulse the active low reset line
void N5110::reset()
{
_rst->write(0); // reset the LCD
_rst->write(1);
}
// function to initialise SPI peripheral
void N5110::initSPI()
{
_spi->format(8,1); // 8 bits, Mode 1 - polarity 0, phase 1 - base value of clock is 0, data captured on falling edge/propagated on rising edge
_spi->frequency(4000000); // maximum of screen is 4 MHz
}
// send a command to the display
void N5110::sendCommand(unsigned char command)
{
_dc->write(0); // set DC low for command
_sce->write(0); // set CE low to begin frame
_spi->write(command); // send command
_dc->write(1); // turn back to data by default
_sce->write(1); // set CE high to end frame (expected for transmission of single byte)
}
// send data to the display at the current XY address
// dc is set to 1 (i.e. data) after sending a command and so should
// be the default mode.
void N5110::sendData(unsigned char data)
{
_sce->write(0); // set CE low to begin frame
_spi->write(data);
_sce->write(1); // set CE high to end frame (expected for transmission of single byte)
}
// this function writes 0 to the 504 bytes to clear the RAM
void N5110::clearRAM()
{
_sce->write(0); //set CE low to begin frame
for(int i = 0; i < WIDTH * HEIGHT; i++) { // 48 x 84 bits = 504 bytes
_spi->write(0x00); // send 0's
}
_sce->write(1); // set CE high to end frame
}
// function to set the XY address in RAM for subsequenct data write
void N5110::setXYAddress(unsigned int const x,
unsigned int const y)
{
if (x<WIDTH && y<HEIGHT) { // check within range
sendCommand(0x80 | x); // send addresses to display with relevant mask
sendCommand(0x40 | y);
}
}
// These functions are used to set, clear and get the value of pixels in the display
// Pixels are addressed in the range of 0 to 47 (y) and 0 to 83 (x). The refresh()
// function must be called after set and clear in order to update the display
void N5110::setPixel(unsigned int const x,
unsigned int const y)
{
if (x<WIDTH && y<HEIGHT) { // check within range
// calculate bank and shift 1 to required position in the data byte
buffer[x][y/8] |= (1 << y%8);
}
}
void N5110::clearPixel(unsigned int const x,
unsigned int const y)
{
if (x<WIDTH && y<HEIGHT) { // check within range
// calculate bank and shift 1 to required position (using bit clear)
buffer[x][y/8] &= ~(1 << y%8);
}
}
int N5110::getPixel(unsigned int const x,
unsigned int const y) const
{
if (x<WIDTH && y<HEIGHT) { // check within range
// return relevant bank and mask required bit
int pixel = (int) buffer[x][y/8] & (1 << y%8);
if (pixel)
return 1;
else
return 0;
}
return 0;
}
// function to refresh the display
void N5110::refresh()
{
setXYAddress(0,0); // important to set address back to 0,0 before refreshing display
// address auto increments after printing string, so buffer[0][0] will not coincide
// with top-left pixel after priting string
_sce->write(0); //set CE low to begin frame
for(int j = 0; j < BANKS; j++) { // be careful to use correct order (j,i) for horizontal addressing
for(int i = 0; i < WIDTH; i++) {
_spi->write(buffer[i][j]); // send buffer
}
}
_sce->write(1); // set CE high to end frame
}
// fills the buffer with random bytes. Can be used to test the display.
// The rand() function isn't seeded so it probably creates the same pattern everytime
void N5110::randomiseBuffer()
{
int i,j;
for(j = 0; j < BANKS; j++) { // be careful to use correct order (j,i) for horizontal addressing
for(i = 0; i < WIDTH; i++) {
buffer[i][j] = rand()%256; // generate random byte
}
}
}
// function to print 5x7 font
void N5110::printChar(char const c,
unsigned int const x,
unsigned int const y)
{
if (y<BANKS) { // check if printing in range of y banks
for (int i = 0; i < 5 ; i++ ) {
int pixel_x = x+i;
if (pixel_x > WIDTH-1) // ensure pixel isn't outside the buffer size (0 - 83)
break;
buffer[pixel_x][y] = font5x7[(c - 32)*5 + i];
// array is offset by 32 relative to ASCII, each character is 5 pixels wide
}
}
}
// function to print string at specified position
void N5110::printString(const char *str,
unsigned int const x,
unsigned int const y)
{
if (y<BANKS) { // check if printing in range of y banks
int n = 0 ; // counter for number of characters in string
// loop through string and print character
while(*str) {
// writes the character bitmap data to the buffer, so that
// text and pixels can be displayed at the same time
for (int i = 0; i < 5 ; i++ ) {
int pixel_x = x+i+n*6;
if (pixel_x > WIDTH-1) // ensure pixel isn't outside the buffer size (0 - 83)
break;
buffer[pixel_x][y] = font5x7[(*str - 32)*5 + i];
}
str++; // go to next character in string
n++; // increment index
}
}
}
// function to clear the screen buffer
void N5110::clear()
{
memset(buffer,0,sizeof(buffer));
}
// function to plot array on display
void N5110::plotArray(float const array[])
{
for (int i=0; i<WIDTH; i++) { // loop through array
// elements are normalised from 0.0 to 1.0, so multiply
// by 47 to convert to pixel range, and subtract from 47
// since top-left is 0,0 in the display geometry
setPixel(i,47 - int(array[i]*47.0f));
}
}
// function to draw circle
void N5110:: drawCircle(unsigned int const x0,
unsigned int const y0,
unsigned int const radius,
FillType const fill)
{
// from http://en.wikipedia.org/wiki/Midpoint_circle_algorithm
int x = radius;
int y = 0;
int radiusError = 1-x;
while(x >= y) {
// if transparent, just draw outline
if (fill == FILL_TRANSPARENT) {
setPixel( x + x0, y + y0);
setPixel(-x + x0, y + y0);
setPixel( y + x0, x + y0);
setPixel(-y + x0, x + y0);
setPixel(-y + x0, -x + y0);
setPixel( y + x0, -x + y0);
setPixel( x + x0, -y + y0);
setPixel(-x + x0, -y + y0);
} else { // drawing filled circle, so draw lines between points at same y value
int type = (fill==FILL_BLACK) ? 1:0; // black or white fill
drawLine(x+x0,y+y0,-x+x0,y+y0,type);
drawLine(y+x0,x+y0,-y+x0,x+y0,type);
drawLine(y+x0,-x+y0,-y+x0,-x+y0,type);
drawLine(x+x0,-y+y0,-x+x0,-y+y0,type);
}
y++;
if (radiusError<0) {
radiusError += 2 * y + 1;
} else {
x--;
radiusError += 2 * (y - x) + 1;
}
}
}
void N5110::drawLine(unsigned int const x0,
unsigned int const y0,
unsigned int const x1,
unsigned int const y1,
unsigned int const type)
{
int y_range = y1-y0; // calc range of y and x
int x_range = x1-x0;
int start,stop,step;
// if dotted line, set step to 2, else step is 1
step = (type==2) ? 2:1;
// make sure we loop over the largest range to get the most pixels on the display
// for instance, if drawing a vertical line (x_range = 0), we need to loop down the y pixels
// or else we'll only end up with 1 pixel in the x column
if ( abs(x_range) > abs(y_range) ) {
// ensure we loop from smallest to largest or else for-loop won't run as expected
start = x1>x0 ? x0:x1;
stop = x1>x0 ? x1:x0;
// loop between x pixels
for (int x = start; x<= stop ; x+=step) {
// do linear interpolation
int y = y0 + (y1-y0)*(x-x0)/(x1-x0);
if (type == 0) // if 'white' line, turn off pixel
clearPixel(x,y);
else
setPixel(x,y); // else if 'black' or 'dotted' turn on pixel
}
} else {
// ensure we loop from smallest to largest or else for-loop won't run as expected
start = y1>y0 ? y0:y1;
stop = y1>y0 ? y1:y0;
for (int y = start; y<= stop ; y+=step) {
// do linear interpolation
int x = x0 + (x1-x0)*(y-y0)/(y1-y0);
if (type == 0) // if 'white' line, turn off pixel
clearPixel(x,y);
else
setPixel(x,y); // else if 'black' or 'dotted' turn on pixel
}
}
}
void N5110::drawRect(unsigned int const x0,
unsigned int const y0,
unsigned int const width,
unsigned int const height,
FillType const fill)
{
if (fill == FILL_TRANSPARENT) { // transparent, just outline
drawLine(x0,y0,x0+(width-1),y0,1); // top
drawLine(x0,y0+(height-1),x0+(width-1),y0+(height-1),1); // bottom
drawLine(x0,y0,x0,y0+(height-1),1); // left
drawLine(x0+(width-1),y0,x0+(width-1),y0+(height-1),1); // right
} else { // filled rectangle
int type = (fill==FILL_BLACK) ? 1:0; // black or white fill
for (int y = y0; y<y0+height; y++) { // loop through rows of rectangle
drawLine(x0,y,x0+(width-1),y,type); // draw line across screen
}
}
}
void N5110::drawSprite(int x0,
int y0,
int nrows,
int ncols,
int *sprite)
{
for (int i = 0; i < nrows; i++) {
for (int j = 0 ; j < ncols ; j++) {
int pixel = *((sprite+i*ncols)+j);
if (pixel) {
setPixel(x0+j,y0+i);
}
else {
clearPixel(x0+j,y0+i);
}
}
}
}
void N5110::drawPic(int x0,
int y0,
int nrows,
int ncols,
char *pic)
{
if((nrows - x0) < 84)
x0 = nrows - 84;
if((ncols - y0) < 48)
y0 = ncols - 48;
for(int m = 0; m < 84; m++)
{
for(int n = 0; n < 6; n++)
{
char pixels = 0;
int divisor = ((x0 + m) * ncols + (y0 + n * 8))/8;
int remainder = ((x0 + m) * ncols + (y0 + n * 8))%8;
pixels = ((pic[divisor] << remainder)) + ((pic[divisor+1] >> (8 - remainder)));
buffer[m][n] = pixels;
}
}
}
- main.cpp
#include "mbed.h"
#include "N5110.h"
// JP1 must be in 2/3 position
N5110 lcd(p8,p9,p10,p11,p13,p21);
const unsigned char gImage_xiaohei[510] = { /* 0X21,0X01,0X55,0X00,0X30,0X00, */
0X00,0X00,0X00,0X00,0X04,0X20,0X00,0X00,0X00,0X00,0X06,0X20,0X00,0X00,0X00,0X00,
0X02,0X28,0X00,0X00,0X00,0X00,0X02,0X20,0X00,0X00,0X00,0X00,0X02,0X28,0X00,0X00,
0X00,0X00,0X02,0X20,0X00,0X00,0X00,0X00,0X01,0X20,0X00,0X00,0X00,0X00,0X09,0X2C,
0X00,0X00,0X00,0X00,0X09,0X08,0X00,0X00,0X00,0X00,0X09,0X00,0X00,0X00,0X00,0X00,
0X09,0X40,0X00,0X00,0X00,0X00,0X01,0X40,0X00,0X00,0X00,0X00,0X00,0X40,0X00,0X00,
0X00,0X80,0X0C,0X50,0X00,0X00,0X00,0X80,0X1C,0X50,0X00,0X00,0X00,0X80,0X08,0X50,
0X00,0X00,0X00,0X80,0X04,0X50,0X00,0X00,0X00,0X00,0X02,0X50,0X00,0X00,0X00,0X00,
0X02,0X50,0X00,0X00,0X00,0X00,0X03,0X50,0X00,0X00,0X00,0X00,0X01,0X40,0X00,0X00,
0X00,0X00,0X00,0X08,0X00,0X00,0X00,0X00,0X00,0X20,0X00,0X00,0X00,0X86,0X01,0X34,
0X00,0X00,0X00,0X19,0X00,0X26,0X00,0X00,0X80,0X01,0X03,0X22,0X00,0X00,0X00,0X00,
0X02,0X1E,0X00,0X00,0X40,0X00,0X02,0X31,0X00,0X00,0X00,0X00,0X84,0X6D,0X00,0X00,
0X00,0X00,0X48,0X30,0X00,0X00,0XE0,0X00,0XB0,0X80,0X00,0X00,0X60,0X01,0X20,0XE0,
0X00,0X00,0X60,0X02,0X20,0XE0,0X00,0X00,0X70,0X24,0X30,0X20,0X00,0X00,0X70,0X44,
0X10,0X20,0X00,0X00,0XF8,0X8F,0X30,0X40,0X00,0X00,0XF8,0X1F,0X12,0X40,0X00,0X00,
0X1C,0X38,0X1C,0X01,0X00,0X00,0X1E,0X60,0XD0,0X81,0X00,0X00,0X8F,0X47,0X12,0XC0,
0X00,0X00,0XCF,0XCF,0X54,0X00,0X00,0X80,0XDF,0XCF,0X70,0X00,0X00,0X80,0X9F,0XCF,
0X70,0X00,0X00,0XC0,0X3F,0XC6,0X79,0X00,0X00,0XC0,0X7F,0XE0,0X7D,0X00,0X00,0XC0,
0XE3,0XFF,0X7F,0X03,0X00,0XF0,0X81,0XFF,0XFF,0X00,0X00,0XF8,0X3C,0XFF,0XFF,0X01,
0X00,0XFC,0X7C,0XFE,0XFF,0X01,0X00,0XFE,0X7C,0XFC,0XFF,0X00,0X00,0X82,0X7C,0XFC,
0XFF,0X01,0X00,0X04,0X79,0XFC,0X7F,0X80,0X00,0X70,0X03,0X9E,0X7F,0X80,0X00,0X00,
0X0F,0X0F,0XF8,0XC0,0X00,0X00,0XF8,0X03,0X68,0X00,0XFF,0XFF,0XFF,0XFF,0X4F,0X40,
0X00,0X00,0X00,0X00,0X48,0X00,0X00,0X00,0X00,0X00,0X48,0X00,0X00,0X00,0X00,0X00,
0X28,0X40,0X00,0X00,0X00,0X00,0X08,0X40,0X00,0X00,0X00,0X00,0X00,0X00,0X00,0X00,
0X00,0X00,0X00,0X40,0X00,0X00,0X00,0X00,0X10,0X40,0X00,0X00,0X00,0X00,0X10,0X40,
0X00,0X00,0X00,0X00,0X00,0XC0,0X00,0X00,0X00,0X00,0X20,0XA0,0X00,0X00,0X00,0X00,
0X00,0X40,0X00,0X00,0X00,0X00,0X40,0X20,0X00,0X00,0X00,0X00,0X80,0X18,0X00,0X00,
0X00,0X00,0X00,0X0D,0X00,0X00,0X00,0X00,0X00,0X06,0X00,0X00,0X00,0X00,0X00,0X04,
0X00,0X00,0X00,0X00,0X00,0X00,0XFF,0XFF,0XFF,0XFF,0XFF,0X0F,0X00,0X00,0X00,0X00,
0X00,0X00,0X04,0XF0,0XC3,0X00,0X7C,0X00,0X02,0X00,0X04,0X00,0X80,0X00,0X02,0X00,
0X00,0X00,0X80,0X04,0X02,0X00,0X00,0X00,0X80,0X04,0X02,0X00,0X00,0X00,0X80,0X04,
0X02,0X00,0X20,0X00,0X80,0X04,0X02,0X00,0X20,0X00,0X80,0X04,0X02,0X00,0X20,0X00,
0X80,0X04,0X02,0X00,0X20,0X00,0X80,0X04,0X02,0X00,0X20,0X00,0X00,0X04,};
int main()
{
// need to initialise the lcd first, do this once outside of the loop
lcd.init();
while(1) {
// clear the display at the start of the loop
lcd.clear();
lcd.drawPic(0,0,85,48,(char *)gImage_xiaohei);
lcd.refresh(); // refresh the LCD so the pixels appear
wait_ms(1000/10); // this gives a refresh rate of 10 frames per second
}
}