Embedded Files
使用する表示デバイスについて
使用する表示デバイスについて
下記のI2Cインターフェースを持った小型128x64フルドットマトリックス OLEDをPSoCに接続してみます。
このボードはOLEDのコントロールとして、SSD1603というデバイスを使用しています。
データシートはこちら、
https://cdn-shop.adafruit.com/datasheets/SSD1306.pdf
PSoC 5LPにI2C_1を定義して、実際にコードを作成してみます。
ピン接続
ピン接続
ドライバコード：
ドライバコード：
OLED 128x64
/*---------------------------------------------------------------------------------------
* OLED Interface (128x64,i2c)
*---------------------------------------------------------------------------------------
*/
#define OLED_ADDR 0x3c
#define OLED_RS_CMD 0x00
#define OLED_RS_DATA 0x40
#define OLED_PORT_DC 0
#define OLED_PORT_RESET 1
#define OLED_PORT_VBATC 2
#define OLED_PORT_VDDC 3
uint8_t value_oled_port = 0;
void OLED_port_init(void)
{
// IOWR(OLED_PIO_BASE, 0, value_oled_port);
}
// 0: data/command 0=command, 1=data
// 1: reset 0=Assert, 1=DeAssert
// 2: vbatc 1=active
// 3: vddc 1=active
void OLED_port_set(uint8_t num)
{
// value_oled_port |= (1 << num);
//printf("value_oled_port = 0x%0X\n", value_oled_port);
}
void OLED_port_clear(uint8_t num)
{
// value_oled_port &= ~(1 << num) & 0xF;
//printf("value_oled_port = 0x%0X\n", value_oled_port);
}
uint8_t OLED_reg_write(uint8_t addr, uint8_t data)
{
uint8_t retval;
uint8 status;
status = I2C_1_MasterSendStart(OLED_ADDR, I2C_1_WRITE_XFER_MODE);
Delay(1);
status = I2C_1_MasterWriteByte(reg);
Delay(1);
status = I2C_1_MasterWriteByte(value);
Delay(1);
status = I2C_1_MasterSendStop();
return retval;
}
uint8_t ssd1306_command(uint8_t cmd)
{
uint8_t retval;
retval = OLED_reg_write(OLED_RS_CMD, cmd);
return retval;
}
uint8_t ssd1306_data(uint8_t cmd)
{
uint8_t retval;
retval = OLED_reg_write(OLED_RS_DATA, cmd);
return retval;
}
#define SSD1306_SETCONTRAST 0x81
#define SSD1306_DISPLAYALLON_RESUME 0xA4
#define SSD1306_DISPLAYALLON 0xA5
#define SSD1306_NORMALDISPLAY 0xA6
#define SSD1306_INVERTDISPLAY 0xA7
#define SSD1306_DISPLAYOFF 0xAE
#define SSD1306_DISPLAYON 0xAF
#define SSD1306_SETDISPLAYOFFSET 0xD3
#define SSD1306_SETCOMPINS 0xDA
#define SSD1306_SETVCOMDETECT 0xDB
#define SSD1306_SETDISPLAYCLOCKDIV 0xD5
#define SSD1306_SETPRECHARGE 0xD9
#define SSD1306_SETMULTIPLEX 0xA8
#define SSD1306_SETLOWCOLUMN 0x00
#define SSD1306_SETHIGHCOLUMN 0x10
#define SSD1306_SETSTARTLINE 0x40
#define SSD1306_MEMORYMODE 0x20
#define SSD1306_COLUMNADDR 0x21
#define SSD1306_PAGEADDR 0x22
#define SSD1306_COMSCANINC 0xC0
#define SSD1306_COMSCANDEC 0xC8
//#define SSD1306_SEGREMAP 0xA0
#define SSD1306_CHARGEPUMP 0x8D
#define SSD1306_EXTERNALVCC 0x01
#define SSD1306_SWITCHCAPVCC 0x02
#define SSD1306_SEGREMAP 0xA1
/* Coordinates of current pixel location on the display. The origin
** is at the upper left of the display. X increases to the right
** and y increases going down.
*/
const uint8_t rgbFillPat[] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 0x00
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 0x01
0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, // 0x02
0x11, 0x44, 0x00, 0x11, 0x44, 0x00, 0x11, 0x44, // 0x03
0x92, 0x45, 0x24, 0x92, 0x45, 0x24, 0x92, 0x45, // 0x04
0x49, 0x92, 0x24, 0x49, 0x92, 0x24, 0x49, 0x92, // 0x05
0x22, 0x11, 0x22, 0x00, 0x22, 0x11, 0x22, 0x00, // 0x06
0x11, 0x22, 0x11, 0x00, 0x11, 0x22, 0x11, 0x00 // 0x07
};
const uint8_t rgbOledFont0[] = {
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 0x20, space
0x00,0x00,0x00,0x5f,0x00,0x00,0x00,0x00, // 0x21, !
0x00,0x00,0x03,0x00,0x03,0x00,0x00,0x00, // 0x22, "
0x64,0x3c,0x26,0x64,0x3c,0x26,0x24,0x00, // 0x23, #
0x26,0x49,0x49,0x7f,0x49,0x49,0x32,0x00, // 0x23, $
0x42,0x25,0x12,0x08,0x24,0x52,0x21,0x00, // 0x25, %
0x20,0x50,0x4e,0x55,0x22,0x58,0x28,0x00, // 0x26, &
0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00, // 0x27, '
0x00,0x00,0x1c,0x22,0x41,0x00,0x00,0x00, // 0x28, (
0x00,0x00,0x00,0x41,0x22,0x1c,0x00,0x00, // 0x29, )
0x00,0x15,0x15,0x0e,0x0e,0x15,0x15,0x00, // 0x2A, *
0x00,0x08,0x08,0x3e,0x08,0x08,0x00,0x00, // 0x2B, +
0x00,0x00,0x00,0x50,0x30,0x00,0x00,0x00, // 0x2C, ,
0x00,0x08,0x08,0x08,0x08,0x08,0x00,0x00, // 0x2D, -
0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00, // 0x2E, .
0x40,0x20,0x10,0x08,0x04,0x02,0x01,0x00, // 0x2F, /
0x00,0x3e,0x41,0x41,0x41,0x3e,0x00,0x00, // 0x30, 0
0x00,0x00,0x41,0x7f,0x40,0x00,0x00,0x00, // 0x31, 1
0x00,0x42,0x61,0x51,0x49,0x6e,0x00,0x00, // 0x32, 2
0x00,0x22,0x41,0x49,0x49,0x36,0x00,0x00, // 0x33, 3
0x00,0x18,0x14,0x12,0x7f,0x10,0x00,0x00, // 0x33, 4
0x00,0x27,0x49,0x49,0x49,0x71,0x00,0x00, // 0x35, 5
0x00,0x3c,0x4a,0x49,0x48,0x70,0x00,0x00, // 0x36, 6
0x00,0x43,0x21,0x11,0x0d,0x03,0x00,0x00, // 0x37, 7
0x00,0x36,0x49,0x49,0x49,0x36,0x00,0x00, // 0x38, 8
0x00,0x06,0x09,0x49,0x29,0x1e,0x00,0x00, // 0x39, 9
0x00,0x00,0x00,0x12,0x00,0x00,0x00,0x00, // 0x3A, :
0x00,0x00,0x00,0x52,0x30,0x00,0x00,0x00, // 0x3B, //
0x00,0x00,0x08,0x14,0x14,0x22,0x00,0x00, // 0x3C, <
0x00,0x14,0x14,0x14,0x14,0x14,0x14,0x00, // 0x3D, =
0x00,0x00,0x22,0x14,0x14,0x08,0x00,0x00, // 0x3E, >
0x00,0x02,0x01,0x59,0x05,0x02,0x00,0x00, // 0x3F, ?
0x3e,0x41,0x5d,0x55,0x4d,0x51,0x2e,0x00, // 0x40, @
0x40,0x7c,0x4a,0x09,0x4a,0x7c,0x40,0x00, // 0x41, A
0x41,0x7f,0x49,0x49,0x49,0x49,0x36,0x00, // 0x42, B
0x1c,0x22,0x41,0x41,0x41,0x41,0x22,0x00, // 0x43, C
0x41,0x7f,0x41,0x41,0x41,0x22,0x1c,0x00, // 0x44, D
0x41,0x7f,0x49,0x49,0x5d,0x41,0x63,0x00, // 0x45, E
0x41,0x7f,0x49,0x09,0x1d,0x01,0x03,0x00, // 0x46, F
0x1c,0x22,0x41,0x49,0x49,0x3a,0x08,0x00, // 0x47, G
0x41,0x7f,0x08,0x08,0x08,0x7f,0x41,0x00, // 0x48, H
0x00,0x41,0x41,0x7F,0x41,0x41,0x00,0x00, // 0x49, I
0x30,0x40,0x41,0x41,0x3F,0x01,0x01,0x00, // 0x4A, J
0x41,0x7f,0x08,0x0c,0x12,0x61,0x41,0x00, // 0x4B, K
0x41,0x7f,0x41,0x40,0x40,0x40,0x60,0x00, // 0x4C, L
0x41,0x7f,0x42,0x0c,0x42,0x7f,0x41,0x00, // 0x4D, M
0x41,0x7f,0x42,0x0c,0x11,0x7f,0x01,0x00, // 0x4E, N
0x1c,0x22,0x41,0x41,0x41,0x22,0x1c,0x00, // 0x4F, O
0x41,0x7f,0x49,0x09,0x09,0x09,0x06,0x00, // 0x50, P
0x0c,0x12,0x21,0x21,0x61,0x52,0x4c,0x00, // 0x51, Q
0x41,0x7f,0x09,0x09,0x19,0x69,0x46,0x00, // 0x52, R
0x66,0x49,0x49,0x49,0x49,0x49,0x33,0x00, // 0x53, S
0x03,0x01,0x41,0x7f,0x41,0x01,0x03,0x00, // 0x54, T
0x01,0x3f,0x41,0x40,0x41,0x3f,0x01,0x00, // 0x55, U
0x01,0x0f,0x31,0x40,0x31,0x0f,0x01,0x00, // 0x56, V
0x01,0x1f,0x61,0x14,0x61,0x1f,0x01,0x00, // 0x57, W
0x41,0x41,0x36,0x08,0x36,0x41,0x41,0x00, // 0x58, X
0x01,0x03,0x44,0x78,0x44,0x03,0x01,0x00, // 0x59, Y
0x43,0x61,0x51,0x49,0x45,0x43,0x61,0x00, // 0x5A, Z
0x00,0x00,0x7f,0x41,0x41,0x00,0x00,0x00, // 0x5B, [
0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x00, // 0x5C,
0x00,0x00,0x41,0x41,0x7f,0x00,0x00,0x00, // 0x5D, ]
0x00,0x04,0x02,0x01,0x01,0x02,0x04,0x00, // 0x5E, ^
0x00,0x40,0x40,0x40,0x40,0x40,0x40,0x00, // 0x5F, _
0x00,0x01,0x02,0x00,0x00,0x00,0x00,0x00, // 0x60, `
0x00,0x34,0x4a,0x4a,0x4a,0x3c,0x40,0x00, // 0x61, a
0x00,0x41,0x3f,0x48,0x48,0x48,0x30,0x00, // 0x62. b
0x00,0x3c,0x42,0x42,0x42,0x24,0x00,0x00, // 0x63, c
0x00,0x30,0x48,0x48,0x49,0x3f,0x40,0x00, // 0x63, d
0x00,0x3c,0x4a,0x4a,0x4a,0x2c,0x00,0x00, // 0x65, e
0x00,0x00,0x48,0x7e,0x49,0x09,0x00,0x00, // 0x66, f
0x00,0x26,0x49,0x49,0x49,0x3f,0x01,0x00, // 0x67, g
0x41,0x7f,0x48,0x04,0x44,0x78,0x40,0x00, // 0x68, h
0x00,0x00,0x44,0x7d,0x40,0x00,0x00,0x00, // 0x69, i
0x00,0x00,0x40,0x44,0x3d,0x00,0x00,0x00, // 0x6A, j
0x41,0x7f,0x10,0x18,0x24,0x42,0x42,0x00, // 0x6B, k
0x00,0x40,0x41,0x7f,0x40,0x40,0x00,0x00, // 0x6C, l
0x42,0x7e,0x02,0x7c,0x02,0x7e,0x40,0x00, // 0x6D, m
0x42,0x7e,0x44,0x02,0x42,0x7c,0x40,0x00, // 0x6E, n
0x00,0x3c,0x42,0x42,0x42,0x3c,0x00,0x00, // 0x6F, o
0x00,0x41,0x7f,0x49,0x09,0x09,0x06,0x00, // 0x70, p
0x00,0x06,0x09,0x09,0x49,0x7f,0x41,0x00, // 0x71, q
0x00,0x42,0x7e,0x44,0x02,0x02,0x04,0x00, // 0x72, r
0x00,0x64,0x4a,0x4a,0x4a,0x36,0x00,0x00, // 0x73, s
0x00,0x04,0x3f,0x44,0x44,0x20,0x00,0x00, // 0x73, t
0x00,0x02,0x3e,0x40,0x40,0x22,0x7e,0x40, // 0x75, u
0x02,0x0e,0x32,0x40,0x32,0x0e,0x02,0x00, // 0x76, v
0x02,0x1e,0x62,0x18,0x62,0x1e,0x02,0x00, // 0x77, w
0x42,0x62,0x14,0x08,0x14,0x62,0x42,0x00, // 0x78, x
0x01,0x43,0x45,0x38,0x05,0x03,0x01,0x00, // 0x79, y
0x00,0x46,0x62,0x52,0x4a,0x46,0x62,0x00, // 0x7A, z
0x00,0x00,0x08,0x36,0x41,0x00,0x00,0x00, // 0x7B, {
0x00,0x00,0x00,0x7f,0x00,0x00,0x00,0x00, // 0x7C, |
0x00,0x00,0x00,0x41,0x36,0x08,0x00,0x00, // 0x7D, }
0x00,0x18,0x08,0x08,0x10,0x10,0x18,0x00, // 0x7E, ~
0xAA,0x55,0xAA,0x55,0xAA,0x55,0xAA,0x55 // 0x7F, DEL
};
#define ccolOledMax 128 //number of display columns
#define crowOledMax 64 //number of display rows
#define cbOledDispMax (ccolOledMax*crowOledMax/8) //max number of bytes in display buffer
#define cpagOledMax (crowOledMax/8) //number of display memory pages
#define cbOledChar 8 //font glyph definitions is 8 bytes long
#define chOledUserMax 0x20 //number of character defs in user font table
#define cbOledFontUser (chOledUserMax*cbOledChar)
/* Graphics drawing modes.
*/
#define modOledSet 0
#define modOledOr 1
#define modOledAnd 2
#define modOledXor 3
uint8_t rgbOledBmp[cbOledDispMax];
int xcoOledCur;
int ycoOledCur;
uint8_t * pbOledCur; //address of byte corresponding to current location
int bnOledCur; //bit number of bit corresponding to current location
uint8_t clrOledCur; //drawing color to use
uint8_t * pbOledPatCur; //current fill pattern
int fOledCharUpdate;
int dxcoOledFontCur;
int dycoOledFontCur;
uint8_t * pbOledFontCur;
uint8_t * pbOledFontUser;
void OledDisplayOn(void);
void OledDisplayOff(void);
void OledClear(void);
void OledClearBuffer(void);
void OledUpdate(void);
void OledPutBuffer(int cb, uint8_t * rgbTx);
// for Character Interface
int xchOledCur;
int ychOledCur;
int xchOledMax;
int ychOledMax;
uint8_t * pbOledFontExt;
uint8_t rgbOledFontUser[cbOledFontUser];
void OledDrawGlyph(char ch);
void OledAdvanceCursor();
// for Graphic Interface
uint8_t (*pfnDoRop)(uint8_t bPix, uint8_t bDsp, uint8_t mskPix);
int modOledCur;
void OledMoveDown();
void OledMoveUp();
void OledMoveRight();
void OledMoveLeft();
uint8_t OledRopSet(uint8_t bPix, uint8_t bDsp, uint8_t mskPix);
uint8_t OledRopOr(uint8_t bPix, uint8_t bDsp, uint8_t mskPix);
uint8_t OledRopAnd(uint8_t bPix, uint8_t bDsp, uint8_t mskPix);
uint8_t OledRopXor(uint8_t bPix, uint8_t bDsp, uint8_t mskPix);
int OledClampXco(int xco);
int OledClampYco(int yco);
// graphic interface functions
void OledMoveTo(int xco, int yco)
{
/* Clamp the specified coordinates to the display surface
*/
xco = OledClampXco(xco);
yco = OledClampYco(yco);
/* Save the current position.
*/
xcoOledCur = xco;
ycoOledCur = yco;
/* Compute the display access parameters corresponding to
** the specified position.
*/
pbOledCur = &rgbOledBmp[((yco/8) * ccolOledMax) + xco];
bnOledCur = yco & 7;
}
void OledGetPos(int * pxco, int * pyco)
{
*pxco = xcoOledCur;
*pyco = ycoOledCur;
}
void OledSetDrawColor(uint8_t clr)
{
clrOledCur = clr & 0x01;
}
uint8_t *OledGetStdPattern(int ipat)
{
return rgbFillPat + 8*ipat;
}
void OledSetFillPattern(uint8_t * pbPat)
{
pbOledPatCur = pbPat;
}
void OledSetDrawMode(int mod)
{
modOledCur = mod;
switch(mod) {
case modOledSet:
pfnDoRop = OledRopSet;
break;
case modOledOr:
pfnDoRop = OledRopOr;
break;
case modOledAnd:
pfnDoRop = OledRopAnd;
break;
case modOledXor:
pfnDoRop = OledRopXor;
break;
default:
modOledCur = modOledSet;
pfnDoRop = OledRopSet;
}
}
int OledGetDrawMode(void)
{
return modOledCur;
}
void OledDrawPixel(void)
{
*pbOledCur = (*pfnDoRop)((clrOledCur << bnOledCur), *pbOledCur, (1<<bnOledCur));
}
uint8_t OledGetPixel(void)
{
return (*pbOledCur & (1<<bnOledCur)) != 0 ? 1 : 0;
}
void OledLineTo(int xco, int yco)
{
int err;
int del;
int lim;
int cpx;
int dxco;
int dyco;
void (*pfnMajor)();
void (*pfnMinor)();
/* Clamp the point to be on the display.
*/
xco = OledClampXco(xco);
yco = OledClampYco(yco);
/* Determine which octant the line occupies
*/
dxco = xco - xcoOledCur;
dyco = yco - ycoOledCur;
if (abs(dxco) >= abs(dyco)) {
/* Line is x-major
*/
lim = abs(dxco);
del = abs(dyco);
if (dxco >= 0) {
pfnMajor = OledMoveRight;
}
else {
pfnMajor = OledMoveLeft;
}
if (dyco >= 0) {
pfnMinor = OledMoveDown;
}
else {
pfnMinor = OledMoveUp;
}
}
else {
/* Line is y-major
*/
lim = abs(dyco);
del = abs(dxco);
if (dyco >= 0) {
pfnMajor = OledMoveDown;
}
else {
pfnMajor = OledMoveUp;
}
if (dxco >= 0) {
pfnMinor = OledMoveRight;
}
else {
pfnMinor = OledMoveLeft;
}
}
/* Render the line. The algorithm is:
** Write the current pixel
** Move one pixel on the major axis
** Add the minor axis delta to the error accumulator
** if the error accumulator is greater than the major axis delta
** Move one pixel in the minor axis
** Subtract major axis delta from error accumulator
*/
err = lim/2;
cpx = lim;
while (cpx > 0) {
OledDrawPixel();
(*pfnMajor)();
err += del;
if (err > lim) {
err -= lim;
(*pfnMinor)();
}
cpx -= 1;
}
/* Update the current location variables.
*/
xcoOledCur = xco;
ycoOledCur = yco;
}
void OledDrawRect(int xco, int yco)
{
int xco1;
int yco1;
/* Clamp the point to be on the display.
*/
xco = OledClampXco(xco);
yco = OledClampYco(yco);
xco1 = xcoOledCur;
yco1 = ycoOledCur;
OledLineTo(xco, yco1);
OledLineTo(xco, yco);
OledLineTo(xco1, yco);
OledLineTo(xco1, yco1);
}
void OledFillRect(int xco, int yco)
{
int xcoLeft;
int xcoRight;
int ycoTop;
int ycoBottom;
int ibPat;
uint8_t * pbCur;
uint8_t * pbLeft;
int xcoCur;
uint8_t bTmp;
uint8_t mskPat;
/* Clamp the point to be on the display.
*/
xco = OledClampXco(xco);
yco = OledClampYco(yco);
/* Set up the four sides of the rectangle.
*/
if (xcoOledCur < xco) {
xcoLeft = xcoOledCur;
xcoRight = xco;
}
else {
xcoLeft = xco;
xcoRight = xcoOledCur;
}
if (ycoOledCur < yco) {
ycoTop = ycoOledCur;
ycoBottom = yco;
}
else {
ycoTop = yco;
ycoBottom = ycoOledCur;
}
while (ycoTop <= ycoBottom) {
/* Compute the address of the left edge of the rectangle for this
** stripe across the rectangle.
*/
pbLeft = &rgbOledBmp[((ycoTop/8) * ccolOledMax) + xcoLeft];
/* Generate a mask to preserve any low bits in the byte that aren't
** part of the rectangle being filled.
*/
mskPat = (1 << (ycoTop & 0x07)) - 1;
/* Combine with a mask to preserve any upper bits in the byte that aren't
** part of the rectangle being filled.
** This mask will end up not preserving any bits for bytes that are in
** the middle of the rectangle vertically.
*/
if ((ycoTop / 8) == (ycoBottom / 8)) {
mskPat |= ~((1 << ((ycoBottom&0x07)+1)) - 1);
}
ibPat = xcoLeft & 0x07; //index to first pattern byte
xcoCur = xcoLeft;
pbCur = pbLeft;
/* Loop through all of the bytes horizontally making up this stripe
** of the rectangle.
*/
while (xcoCur <= xcoRight) {
*pbCur = (*pfnDoRop)(*(pbOledPatCur+ibPat), *pbCur, ~mskPat);
xcoCur += 1;
pbCur += 1;
ibPat += 1;
if (ibPat > 7) {
ibPat = 0;
}
}
/* Advance to the next horizontal stripe.
*/
ycoTop = 8*((ycoTop/8)+1);
}
}
void OledGetBmp(int dxco, int dyco, uint8_t * pbBits)
{
int xcoLeft;
int xcoRight;
int ycoTop;
int ycoBottom;
uint8_t * pbDspCur;
uint8_t * pbDspLeft;
uint8_t * pbBmpCur;
uint8_t * pbBmpLeft;
int xcoCur;
int bnAlign;
uint8_t mskEnd;
uint8_t bTmp;
/* Set up the four sides of the source rectangle.
*/
xcoLeft = xcoOledCur;
xcoRight = xcoLeft + dxco;
if (xcoRight >= ccolOledMax) {
xcoRight = ccolOledMax - 1;
}
ycoTop = ycoOledCur;
ycoBottom = ycoTop + dyco;
if (ycoBottom >= crowOledMax) {
ycoBottom = crowOledMax - 1;
}
bnAlign = ycoTop & 0x07;
pbDspLeft = &rgbOledBmp[((ycoTop/8) * ccolOledMax) + xcoLeft];
pbBmpLeft = pbBits;
while (ycoTop < ycoBottom) {
if ((ycoTop / 8) == ((ycoBottom-1) / 8)) {
mskEnd = ((1 << (((ycoBottom-1)&0x07)+1)) - 1);
}
else {
mskEnd = 0xFF;
}
xcoCur = xcoLeft;
pbDspCur = pbDspLeft;
pbBmpCur = pbBmpLeft;
/* Loop through all of the bytes horizontally making up this stripe
** of the rectangle.
*/
if (bnAlign == 0) {
while (xcoCur < xcoRight) {
*pbBmpCur = (*pbDspCur) & mskEnd;
xcoCur += 1;
pbBmpCur += 1;
pbDspCur += 1;
}
}
else {
while (xcoCur < xcoRight) {
bTmp = *pbDspCur;
bTmp = *(pbDspCur+ccolOledMax);
*pbBmpCur = ((*pbDspCur >> bnAlign) |
((*(pbDspCur+ccolOledMax)) << (8-bnAlign))) & mskEnd;
xcoCur += 1;
pbBmpCur += 1;
pbDspCur += 1;
}
}
/* Advance to the next horizontal stripe.
*/
ycoTop += 8;
pbDspLeft += ccolOledMax;
pbBmpLeft += dxco;
}
}
void OledPutBmp(int dxco, int dyco, uint8_t * pbBits)
{
int xcoLeft;
int xcoRight;
int ycoTop;
int ycoBottom;
uint8_t * pbDspCur;
uint8_t * pbDspLeft;
uint8_t * pbBmpCur;
uint8_t * pbBmpLeft;
int xcoCur;
uint8_t bDsp;
uint8_t bBmp;
uint8_t mskEnd;
uint8_t mskUpper;
uint8_t mskLower;
int bnAlign;
int fTop;
uint8_t bTmp;
/* Set up the four sides of the destination rectangle.
*/
xcoLeft = xcoOledCur;
xcoRight = xcoLeft + dxco;
if (xcoRight >= ccolOledMax) {
xcoRight = ccolOledMax - 1;
}
ycoTop = ycoOledCur;
ycoBottom = ycoTop + dyco;
if (ycoBottom >= crowOledMax) {
ycoBottom = crowOledMax - 1;
}
bnAlign = ycoTop & 0x07;
mskUpper = (1 << bnAlign) - 1;
mskLower = ~mskUpper;
pbDspLeft = &rgbOledBmp[((ycoTop/8) * ccolOledMax) + xcoLeft];
pbBmpLeft = pbBits;
fTop = 1;
while (ycoTop < ycoBottom) {
/* Combine with a mask to preserve any upper bits in the byte that aren't
** part of the rectangle being filled.
** This mask will end up not preserving any bits for bytes that are in
** the middle of the rectangle vertically.
*/
if ((ycoTop / 8) == ((ycoBottom-1) / 8)) {
mskEnd = ((1 << (((ycoBottom-1)&0x07)+1)) - 1);
}
else {
mskEnd = 0xFF;
}
if (fTop) {
mskEnd &= ~mskUpper;
}
xcoCur = xcoLeft;
pbDspCur = pbDspLeft;
pbBmpCur = pbBmpLeft;
/* Loop through all of the bytes horizontally making up this stripe
** of the rectangle.
*/
if (bnAlign == 0) {
while (xcoCur < xcoRight) {
*pbDspCur = (*pfnDoRop)(*pbBmpCur, *pbDspCur, mskEnd);
xcoCur += 1;
pbDspCur += 1;
pbBmpCur += 1;
}
}
else {
while (xcoCur < xcoRight) {
bBmp = ((*pbBmpCur) << bnAlign);
if (!fTop) {
bBmp |= ((*(pbBmpCur - dxco) >> (8-bnAlign)) & ~mskLower);
}
bBmp &= mskEnd;
*pbDspCur = (*pfnDoRop)(bBmp, *pbDspCur, mskEnd);
xcoCur += 1;
pbDspCur += 1;
pbBmpCur += 1;
}
}
/* Advance to the next horizontal stripe.
*/
ycoTop = 8*((ycoTop/8)+1);
pbDspLeft += ccolOledMax;
pbBmpLeft += dxco;
fTop = 0;
}
}
void OledDrawChar(char ch)
{
uint8_t * pbFont;
uint8_t * pbBmp;
int ib;
if ((ch & 0x80) != 0) {
return;
}
if (ch < chOledUserMax) {
pbFont = pbOledFontUser + ch*cbOledChar;
}
else if ((ch & 0x80) == 0) {
pbFont = pbOledFontCur + (ch-chOledUserMax) * cbOledChar;
}
pbBmp = pbOledCur;
OledPutBmp(dxcoOledFontCur, dycoOledFontCur, pbFont);
xcoOledCur += dxcoOledFontCur;
}
void OledDrawString(char * sz)
{
while (*sz != '\0') {
OledDrawChar(*sz);
sz += 1;
}
}
uint8_t OledRopSet(uint8_t bPix, uint8_t bDsp, uint8_t mskPix)
{
return (bDsp & ~mskPix) | (bPix & mskPix);
}
uint8_t OledRopOr(uint8_t bPix, uint8_t bDsp, uint8_t mskPix)
{
return bDsp | (bPix & mskPix);
}
uint8_t OledRopAnd(uint8_t bPix, uint8_t bDsp, uint8_t mskPix)
{
return bDsp & (bPix & mskPix);
}
uint8_t OledRopXor(uint8_t bPix, uint8_t bDsp, uint8_t mskPix)
{
return bDsp ^ (bPix & mskPix);
}
void OledMoveUp(void)
{
/* Go up one bit position in the current byte.
*/
bnOledCur -= 1;
/* If we have gone off the end of the current byte
** go up 1 page.
*/
if (bnOledCur < 0) {
bnOledCur = 7;
pbOledCur -= ccolOledMax;
/* If we have gone off of the top of the display,
** go back down.
*/
if (pbOledCur < rgbOledBmp) {
pbOledCur += ccolOledMax;
}
}
}
void OledMoveDown(void)
{
/* Go down one bit position in the current byte.
*/
bnOledCur += 1;
/* If we have gone off the end of the current byte,
** go down one page in the display memory.
*/
if (bnOledCur > 7) {
bnOledCur = 0;
pbOledCur += ccolOledMax;
/* If we have gone off the end of the display memory
** go back up a page.
*/
if (pbOledCur >= rgbOledBmp+cbOledDispMax) {
pbOledCur -= ccolOledMax;
}
}
}
void OledMoveLeft(void)
{
/* Are we at the left edge of the display already
*/
if (((pbOledCur - rgbOledBmp) & (ccolOledMax-1)) == 0) {
return;
}
/* Not at the left edge, so go back one byte.
*/
pbOledCur -= 1;
}
void OledMoveRight(void)
{
/* Are we at the right edge of the display already
*/
if (((pbOledCur-rgbOledBmp) & (ccolOledMax-1)) == (ccolOledMax-1)) {
return;
}
/* Not at the right edge, so go forward one byte
*/
pbOledCur += 1;
}
int OledClampXco(int xco)
{
if (xco < 0) {
xco = 0;
}
if (xco >= ccolOledMax) {
xco = ccolOledMax-1;
}
return xco;
}
int OledClampYco(int yco)
{
if (yco < 0) {
yco = 0;
}
if (yco >= crowOledMax) {
yco = crowOledMax-1;
}
return yco;
}
// character interface functions
void OledSetCursor(int xch, int ych)
{
/* Clamp the specified location to the display surface
*/
if (xch >= xchOledMax) {
xch = xchOledMax-1;
}
if (ych >= ychOledMax) {
ych = ychOledMax-1;
}
/* Save the given character location.
*/
xchOledCur = xch;
ychOledCur = ych;
/* Convert the character location to a frame buffer address.
*/
OledMoveTo(xch*dxcoOledFontCur, ych*dycoOledFontCur);
}
void OledGetCursor( int * pxch, int * pych)
{
*pxch = xchOledCur;
*pych = ychOledCur;
}
int OledDefUserChar(char ch, uint8_t * pbDef)
{
uint8_t * pb;
int ib;
if (ch < chOledUserMax) {
pb = pbOledFontUser + ch * cbOledChar;
for (ib = 0; ib < cbOledChar; ib++) {
*pb++ = *pbDef++;
}
return 1;
}
else {
return 0;
}
}
void OledSetCharUpdate(int f)
{
fOledCharUpdate = (f != 0) ? 1 : 0;
}
int OledGetCharUpdate(void)
{
return fOledCharUpdate;
}
void OledPutChar(char ch)
{
OledDrawGlyph(ch);
OledAdvanceCursor();
// if (fOledCharUpdate) {
// OledUpdate();
// }
}
void OledPutString(char * sz)
{
while (*sz != '\0') {
OledDrawGlyph(*sz);
OledAdvanceCursor();
sz += 1;
}
// if (fOledCharUpdate) {
// OledUpdate();
// }
}
void OledDrawGlyph(char ch)
{
uint8_t * pbFont;
uint8_t * pbBmp;
int ib;
if ((ch & 0x80) != 0) {
return;
}
if (ch < chOledUserMax) {
pbFont = pbOledFontUser + ch*cbOledChar;
}
else if ((ch & 0x80) == 0) {
pbFont = pbOledFontCur + (ch-chOledUserMax) * cbOledChar;
}
pbBmp = pbOledCur;
for (ib = 0; ib < dxcoOledFontCur; ib++) {
*pbBmp++ = *pbFont++;
}
}
void OledAdvanceCursor(void)
{
xchOledCur += 1;
if (xchOledCur >= xchOledMax) {
xchOledCur = 0;
ychOledCur += 1;
}
if (ychOledCur >= ychOledMax) {
ychOledCur = 0;
}
OledSetCursor(xchOledCur, ychOledCur);
}
void OledClearBuffer(void)
{
int ib;
uint8_t * pb;
pb = rgbOledBmp;
/* Fill the memory buffer with 0.
*/
for (ib = 0; ib < cbOledDispMax; ib++) {
*pb++ = 0x00;
}
}
void OLED_DSP_Init(void)
{
int ib;
/* Init the parameters for the default font
*/
dxcoOledFontCur = cbOledChar;
dycoOledFontCur = 8;
pbOledFontCur = (uint8_t*)rgbOledFont0;
pbOledFontUser = rgbOledFontUser;
for (ib = 0; ib < cbOledFontUser; ib++) {
rgbOledFontUser[ib] = 0;
}
xchOledMax = ccolOledMax / dxcoOledFontCur;
ychOledMax = crowOledMax / dycoOledFontCur;
/* Set the default character cursor position.
*/
OledSetCursor(0, 0);
/* Set the default foreground draw color and fill pattern
*/
clrOledCur = 0x01;
pbOledPatCur = (uint8_t*)rgbFillPat;
OledSetDrawMode(modOledSet);
/* Default the character routines to automaticall
** update the display.
*/
fOledCharUpdate = 1;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - -
// oled driver
// - - - - - - - - - - - - - - - - - - - - - - - - - - -
void OledDisplayOn(void)
{
ssd1306_command(SSD1306_DISPLAYON);
}
void OledDisplayOff(void)
{
ssd1306_command(SSD1306_DISPLAYOFF); // 0xAE
}
void OledClear(void)
{
OledClearBuffer();
OledUpdate();
}
void OledUpdate(void)
{
int ipag;
int icol;
uint8_t * pb;
pb = rgbOledBmp;
for (ipag = 0; ipag < cpagOledMax; ipag++) {
/* Set the page address
*/
ssd1306_command(0x22); //Set page command
ssd1306_command(ipag); //page number
/* Start at the left column
*/
ssd1306_command(0x00); //set low nybble of column
ssd1306_command(0x10); //set high nybble of column
/* Copy this memory page of display data.
*/
OledPutBuffer(ccolOledMax, pb);
pb += ccolOledMax;
}
}
void OledUpdate_page(uint8_t pageno)
{
int ipag;
uint8_t * pb;
pb = rgbOledBmp + (pageno * ccolOledMax);
ipag = pageno;
/* Set the page address
*/
ssd1306_command(0x22); //Set page command
ssd1306_command(ipag); //page number
/* Start at the left column
*/
ssd1306_command(0x00); //set low nibble of column
ssd1306_command(0x10); //set high nibble of column
/* Copy this memory page of display data.
*/
OledPutBuffer(ccolOledMax, pb);
}
void OledPutBuffer(int cb, uint8_t * rgbTx)
{
int ib;
/* Write/Read the data
*/
for (ib = 0; ib < cb; ib++) {
ssd1306_data(*rgbTx++);
}
}
void OLED_Init(void)
{
OLED_port_init();
OLED_port_set(OLED_PORT_VBATC);
OLED_port_set(OLED_PORT_VDDC);
OLED_port_set(OLED_PORT_RESET);
delay(1);
OLED_port_clear(OLED_PORT_DC);
OLED_port_clear(OLED_PORT_VDDC);
delay(1);
ssd1306_command(SSD1306_DISPLAYOFF); // 0xAE
// bring reset low and then high
OLED_port_clear(OLED_PORT_RESET);
delay(5);
OLED_port_set(OLED_PORT_RESET);
delay(5);
// send the set charge pump and set pre-charge period commands
ssd1306_command(0x8D); // from univision datasheet, not in SSD1306 datasheet
ssd1306_command(0x14);
ssd1306_command(0xD9); // from univision datasheet, not in SSD1306 datasheet
ssd1306_command(0xF1);
// turn on vcc and wait 100ms
OLED_port_clear(OLED_PORT_VBATC);
delay(100);
// send the commands to invert the display
ssd1306_command(SSD1306_SEGREMAP);
ssd1306_command(SSD1306_COMSCANDEC);
// send the commands to select sequential COM configuration
ssd1306_command(SSD1306_SETCOMPINS);
ssd1306_command(0x20);
ssd1306_command(SSD1306_DISPLAYON);
}
void OLED_invertDisplay(uint8_t i)
{
if (i) {
ssd1306_command(SSD1306_INVERTDISPLAY);
} else {
ssd1306_command(SSD1306_NORMALDISPLAY);
}
}
void OLED_dim(uint8_t dim)
{
uint8_t contrast;
if (dim) {
contrast = 0; // Dimmed display
} else {
contrast = 0xCF;
}
// the range of contrast to too small to be really useful
// it is useful to dim the display
ssd1306_command(SSD1306_SETCONTRAST);
ssd1306_command(contrast);
}
//printf("[%08d] IORD(BUTTON_PIO_BASE)=0x%X\n", sys_number, IORD(BUTTON_PIO_BASE,0));
// OLED : character = 16*4
/*
* DISPLAY
* 0 1
* 1234567890123456
* BB4-MAX VER.001
* Up:0000000000000 <-(13digit)
*
*
*/
int main(void)
{
alt_u32 current_time;
alt_u64 sys_number;
uint8_t blink;
alt_u16 ad_min, ad_max, ad_value;
char dspbuf[16];
sys_number = 0;
blink = 0;
ad_min = 0xFFFF;
ad_max = 0;
INIT_timer();
LED_port_init();
OLED_Init();
OLED_invertDisplay(0);
OLED_dim(0);
OLED_DSP_Init();
OledClear();
IOWR(DAC_PD_BASE,0, 0);
printf("start program..\n");
while (1) {
if (alrm_rang_main) { // 10msec cyclic
alrm_rang_main = 0;
sys_number++;
// nios-ii heartbeat
if (!(sys_number % 1)) {
/*
if (blink) {
LED_port_set(3);
blink = 0;
} else {
LED_port_clear(3);
blink = 1;
}
*/
sprintf(dspbuf, "%012d", sys_number);
OledSetCursor(0,0);
OledPutString(dspbuf);
ad_value = IORD(ADC_IN16_BASE,0);
if ( ad_value < ad_min)
ad_min = ad_value;
if (ad_value > ad_max)
ad_max = ad_value;
sprintf(dspbuf, "%04x", ad_max);
OledSetCursor(7,1);
OledPutString(dspbuf);
sprintf(dspbuf, "%04x", ad_min);
OledSetCursor(12,1);
OledPutString(dspbuf);
sprintf(dspbuf, "%04x", ad_value);
OledSetCursor(2,1);
OledPutString(dspbuf);
OledMoveTo(0,30);
OledLineTo(100,30);
}
}//
}
return 0;
}
Google Sites
Report abuse