ATNEL tech-forum 2019-10-27T22:05:48+01:00 https://forum.atnel.pl/feed.php?f=42&t=12638&mode 2019-10-27T22:05:48+01:00 2019-10-27T22:05:48+01:00 https://forum.atnel.pl/viewtopic.php?t=12638&p=222726#p222726 <![CDATA[Re: Problem z OLED 1,3"]]> Nie będę wklejał biblioteki MK_GLCD, ale może ktoś podpowie który element inicjacji w SDD1306 powinienem podmienić ?

Wyświetlacz działa - sprawdzałem na bibliotece U8glib - pod Adruino, ale biblioteka MK_GLCD jest lepsza i wolałbym a niej pracować.

[syntax=c]/*
u8g_dev_sh1106_128x64.c
Universal 8bit Graphics Library
Copyright (c) 2011, olikraus@gmail.com
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/* 初衷: 惠特128x64使用的SH1106芯片,这使得SSD1306总有些奇怪的情况.
* 这里包含修改: 提供一个写入sh1106函数,使用[U8GLIB_SH1106_128X64 u8g(U8G_I2C_OPT_NONE)]调用
*/

#include "u8g.h"

#define WIDTH 128 //SH1106 -- 132x64, different from sh1106, But in here only use 128(col2-col129)
#define HEIGHT 64
#define PAGE_HEIGHT 8

/* init with HuiTec 1.3' SH1106 I2C OLED Module
* It use the display module: QG-2864KLBLG01 By Allvision technology
*/
static const uint8_t u8g_dev_sh1106_128x64_huitec_init_seq[] PROGMEM = {
U8G_ESC_CS(0), /* disable chip */
U8G_ESC_ADR(0), /* instruction mode */
U8G_ESC_RST(1), /* do reset low pulse with (1*16)+2 milliseconds */
U8G_ESC_CS(1), /* enable chip */

/* Start Enter Set,First off display */
0x0ae, // display off,when all this have done,we light on the display again:)

/* Set Lower Column Address: (00H - 0FH) */

0x002, //Set lower column address(from col2 for 128x64,that's specal)

/* Set Higher Column Address: (10H - 1FH) */
0x010, //Set hight column address,there just begin with start,this is the [0 0 0 1 X X X X], so the small will be [0001 0000]=10H.

/* Set Display Start Line: (40H - 7FH)
Specifies line address (refer to Figure. 8) to determine the initial display line or COM0. The RAM display data becomes the
top line of OLED screen. It is followed by the higher number of lines in ascending order, corresponding to the duty cycle. When this command changes the line address, the smooth scrolling or page change takes place.
*/
0x040, //Set display start line just from 40H:)

/* Set Page Address: (B0H - B7H)
Specifies page address to load display RAM data to page address register. Any RAM data bit can be accessed when its page address and column address are specified. The display remains unchanged even when the page address is changed.
*/
0x0b0, //We Start just from B0H:)

/* Set Contrast Control Register: (Double Bytes Command)
This command is to set contrast setting of the display. The chip has 256 contrast steps from 00 to FF. The segment output current increases as the contrast step value increases.
Segment output current setting: ISEG = a/256 X IREF X scale factor
Where: a is contrast step; IREF is reference current equals 12.5μA; Scale factor = 16.*/
0x081, //Enter The Contrast Control Mode Set: (81H)
0x080, //Contrast Data Register Set: (00H - FFH),default value is 80H(means nothing change)

/* Set Segment Re-map: (A0H - A1H)
Change the relationship between RAM column address and segment driver. The order of segment driver output pads can be
reversed by software. This allows flexible IC layout during OLED module assembly. For details, refer to the column address section of Figure. 8. When display data is written or read, the column address is incremented by 1 as shown in Figure.
*/
0x0a1, //Value can be A0H(normal direction-the right rotates) or A1H(reverse direction-the left rotates),The Chip Default is A1H,But The HuiTec Module use A1H as deafult,And if you A0H for HuiTec Module,EveryThing will filp:)

/* Set Normal/Reverse Display: (A6H -A7H)
Reverses the display ON/OFF status without rewriting the contents of the display data RAM.
*/
0x0a6, //Value can be A6H(normal display, the RAM data is high, being OLED ON potential) or A7H(reverse display, the RAM data is low, being OLED ON potential), Chip Default is A6H

/* Set Multiplex Ration: (Double Bytes Command)
This command switches default 64 multiplex modes to any multiplex ratio from 1 to 64. The output pads COM0-COM63 will be switched to corresponding common signal.
*/
0x0a8, //Enter Multiplex Ration Mode,not sure what's this for:)
0x03f, //Set the Multiplex Ration Data, 0x00F(1) - 0x03F(64), default value is 0x03f(64)

/* Set DC-DC OFF/ON: (Double Bytes Command)
This command is to control the DC-DC voltage converter. The converter will be turned on by issuing this command then display ON command. The panel display must be off while issuing this command.
*/
0x0ad, //Enter DC-DC Control Mode Set,The other name is called [set charge pump enable mode:)]
0x08b, //DC-DC ON/OFF Mode Set: 8AH(off),8BH(on), default value is 8BH(on),maens dont use extern VCC.

/* Set Pump voltage value
Specifies output voltage (VPP) of the internal charger pump.
*/
0x031, //Specifies output voltage (VPP) of the internal charger pump(30H-33H).The value include: {30H: 6.4V,31H: 7.4V,32H: 8.0V,33H: 9.0V},default in chip is 32H,for the HuiTec Module them use 30H.as i test seems them all be okay.

/* Set Common Output Scan Direction
This command sets the scan direction of the common output allowing layout flexibility in OLED module design. In addition, the display will have immediate effect once this command is issued. That is, if this command is sent during normal display, the graphic display will be vertically flipped.
*/
0x0c8, //Value Can be C0H or C8H,C0H Means Scan from COM0 to COM [N -1].C8H Means Scan from COM [N -1] to COM0.CHIP default is C0H,but HuiTec Module use C8H

/* Set Display Offset: (Double Bytes Command)
This is a double byte command. The next command specifies the mapping of display start line to one of COM0-63 (it is assumed that COM0 is the display start line, that equals to 0). For example, to move the COM16 towards the COM0 direction for 16 lines, the 6-bit data in the second byte should be given by 010000. To move in the opposite direction by 16 lines, the 6-bit data should be given by (64-16), so the second byte should be 100000.
*/
0x0d3, //Enter Display Offset Mode Set: (D3H)
0x000, //Display Offset Data Set: (00H~3FH),Default is 00H

/* Set Display Clock Divide Ratio/Oscillator Frequency: (Double Bytes Command)
This command is used to set the frequency of the internal display clocks (DCLKs). It is defined as the divide ratio (Value
from 1 to 16) used to divide the oscillator frequency. POR is 1. Frame frequency is determined by divide ratio, number of display clocks per row, MUX ratio and oscillator frequency.
*/
0x0d5, //Enter Divide Ratio/Oscillator Frequency Mode Set: (D5H)
0x080, //Divide Ratio/Oscillator Frequency Data Set: (00H - FFH), The Chip Default is 50H, The HuiTec Module default is 80H,Means Divide Ration is 1,oscillator frequency is +15%(1000B).

/* Set Dis-charge/Pre-charge Period: (Double Bytes Command)
This command is used to set the duration of the pre-charge period. The interval is counted in number of DCLK. POR is 2 DCLKs.
*/
0x0d9, //Enter Pre-charge Period Mode Set: (D9H)
0x01f, //Dis-charge/Pre-charge Period Data Set: (00H - FFH),Default is 22H(2 DCLKs,2 DCLKs),USE 1FH for long lifetime (maybe)

/* Set Common pads hardware configuration: (Double Bytes Command) */
0x0da, //Enter Common Pads Hardware Configuration Mode Set: (DAH)
0x012, //Sequential/Alternative Mode Set: (02H,12H),Default is 12H(COM62, 60 - 2, 0,SEG0, 1 - 130, 131,COM1, 3 - 61, 63)

/* Set VCOM Deselect Level: (Double Bytes Command)
This command is to set the common pad output voltage level at deselect stage.
*/
0x0db, //Enter VCOM Deselect Level Mode Set: (DBH)
0x040, //VCOM Deselect Level Data Set: (00H - FFH),HuiTec Module use 40H(B=0.1), VCOM = B x VREF = (0.1 + 64 X 0.006415) X VREF

/* Display ON */
0x0af, //Display ON OLED(AFH)

U8G_ESC_CS(0), /* disable chip */
U8G_ESC_END /* end of sequence */
};


/* select one init sequence here */
#define u8g_dev_sh1106_128x64_init_seq u8g_dev_sh1106_128x64_huitec_init_seq

static const uint8_t u8g_dev_sh1106_128x64_data_start[] PROGMEM = {
U8G_ESC_ADR(0), /* instruction mode */
U8G_ESC_CS(1), /* enable chip */
0x010, /* set upper 4 bit of the col adr to 0 */

/* In the 128x64 display,We start with col2,and end with 122 */
0x002, /* set lower 4 bit of the col adr to 2 */
U8G_ESC_END /* end of sequence */
};

static const uint8_t u8g_dev_sh1106_sleep_on[] PROGMEM = {
U8G_ESC_ADR(0), /* instruction mode */
U8G_ESC_CS(1), /* enable chip */
0x0ae, /* display off */
U8G_ESC_CS(1), /* disable chip */
U8G_ESC_END /* end of sequence */
};

static const uint8_t u8g_dev_sh1106_sleep_off[] PROGMEM = {
U8G_ESC_ADR(0), /* instruction mode */
U8G_ESC_CS(1), /* enable chip */
0x0af, /* display on */

/* Power Stabilized (100ms Delay Recommended) */
U8G_ESC_DLY(100), /* delay 100 ms */
U8G_ESC_CS(1), /* disable chip */
U8G_ESC_END /* end of sequence */
};

//@slboat 入口看起来是...初始化的入口功能
uint8_t u8g_dev_sh1106_128x64_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg){
//@slboat msg是个枚举的小玩意
switch (msg) {
case U8G_DEV_MSG_INIT:
u8g_InitCom(u8g, dev, U8G_SPI_CLK_CYCLE_300NS);
u8g_WriteEscSeqP(u8g, dev, u8g_dev_sh1106_128x64_init_seq);
break;
case U8G_DEV_MSG_STOP:
break;
case U8G_DEV_MSG_PAGE_NEXT:
{
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);
u8g_WriteEscSeqP(u8g, dev, u8g_dev_sh1106_128x64_data_start);
u8g_WriteByte(u8g, dev, 0x0b0 | pb->p.page); /* select current page (sh1106) */
u8g_SetAddress(u8g, dev, 1); /* data mode */
if (u8g_pb_WriteBuffer(pb, u8g, dev) == 0)
return 0;
u8g_SetChipSelect(u8g, dev, 0);
}
break;
case U8G_DEV_MSG_SLEEP_ON:
u8g_WriteEscSeqP(u8g, dev, u8g_dev_sh1106_sleep_on);
return 1;
case U8G_DEV_MSG_SLEEP_OFF:
u8g_WriteEscSeqP(u8g, dev, u8g_dev_sh1106_sleep_off);
return 1;
}
return u8g_dev_pb8v1_base_fn(u8g, dev, msg, arg);
}

uint8_t u8g_dev_sh1106_128x64_2x_fn(u8g_t *u8g, u8g_dev_t *dev, uint8_t msg, void *arg){
switch (msg) {
case U8G_DEV_MSG_INIT:
//why use U8G_SPI_CLK_CYCLE_300NS?
u8g_InitCom(u8g, dev, U8G_SPI_CLK_CYCLE_300NS);
u8g_WriteEscSeqP(u8g, dev, u8g_dev_sh1106_128x64_init_seq);
break;
case U8G_DEV_MSG_STOP:
break;
case U8G_DEV_MSG_PAGE_NEXT:
{
u8g_pb_t *pb = (u8g_pb_t *)(dev->dev_mem);

u8g_WriteEscSeqP(u8g, dev, u8g_dev_sh1106_128x64_data_start);
u8g_WriteByte(u8g, dev, 0x0b0 | (pb->p.page * 2)); /* select current page (sh1106) */
u8g_SetAddress(u8g, dev, 1); /* data mode */
u8g_WriteSequence(u8g, dev, pb->width, pb->buf);
u8g_SetChipSelect(u8g, dev, 0);

u8g_WriteEscSeqP(u8g, dev, u8g_dev_sh1106_128x64_data_start);
u8g_WriteByte(u8g, dev, 0x0b0 | (pb->p.page * 2 + 1)); /* select current page (sh1106) */
u8g_SetAddress(u8g, dev, 1); /* data mode */
u8g_WriteSequence(u8g, dev, pb->width, (uint8_t *)(pb->buf) + pb->width);
u8g_SetChipSelect(u8g, dev, 0);
}
break;
case U8G_DEV_MSG_SLEEP_ON:
u8g_WriteEscSeqP(u8g, dev, u8g_dev_sh1106_sleep_on);
return 1;
case U8G_DEV_MSG_SLEEP_OFF:
u8g_WriteEscSeqP(u8g, dev, u8g_dev_sh1106_sleep_off);
return 1;
}
return u8g_dev_pb16v1_base_fn(u8g, dev, msg, arg);
}

U8G_PB_DEV(u8g_dev_sh1106_128x64_sw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_sh1106_128x64_fn, U8G_COM_SW_SPI);
U8G_PB_DEV(u8g_dev_sh1106_128x64_hw_spi, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_sh1106_128x64_fn, U8G_COM_HW_SPI);
U8G_PB_DEV(u8g_dev_sh1106_128x64_i2c, WIDTH, HEIGHT, PAGE_HEIGHT, u8g_dev_sh1106_128x64_fn, U8G_COM_SSD_I2C);

uint8_t u8g_dev_sh1106_128x64_2x_buf[WIDTH * 2] U8G_NOCOMMON;
u8g_pb_t u8g_dev_sh1106_128x64_2x_pb = { {16, HEIGHT, 0, 0, 0}, WIDTH, u8g_dev_sh1106_128x64_2x_buf};
u8g_dev_t u8g_dev_sh1106_128x64_2x_sw_spi = { u8g_dev_sh1106_128x64_2x_fn, &u8g_dev_sh1106_128x64_2x_pb, U8G_COM_SW_SPI };
u8g_dev_t u8g_dev_sh1106_128x64_2x_hw_spi = { u8g_dev_sh1106_128x64_2x_fn, &u8g_dev_sh1106_128x64_2x_pb, U8G_COM_HW_SPI };
u8g_dev_t u8g_dev_sh1106_128x64_2x_i2c = { u8g_dev_sh1106_128x64_2x_fn, &u8g_dev_sh1106_128x64_2x_pb, U8G_COM_SSD_I2C };[/syntax]


Program (cały) .c
[syntax=c]* lcd.h
*
* Created by Michael Köhler on 22.12.16.
* Copyright 2016 Skie-Systems. All rights reserved.
*
* lib for OLED-Display with ssd1306/ssd1309/sh1106-Controller
* first dev-version only for I2C-Connection
* at ATMega328P like Arduino Uno
*
* at GRAPHICMODE lib needs static SRAM for display:
* DISPLAY-WIDTH * DISPLAY-HEIGHT + 2 bytes
*
* at TEXTMODE lib need static SRAM for display:
* 2 bytes (cursorPosition)
*/

#include "lcd.h"
#include "font.h"
#include <string.h>

#if defined SPI
#include <util/delay.h>
#endif

static struct {
uint8_t x;
uint8_t y;
} cursorPosition;

static uint8_t charMode = NORMALSIZE;
#if defined GRAPHICMODE
#include <stdlib.h>
static uint8_t displayBuffer[DISPLAY_HEIGHT/8][DISPLAY_WIDTH];
#elif defined TEXTMODE
#else
#error "No valid displaymode! Refer lcd.h"
#endif


const uint8_t init_sequence [] PROGMEM = { // Initialization Sequence
LCD_DISP_OFF, // Display OFF (sleep mode)
0x20, 0b00, // Set Memory Addressing Mode
// 00=Horizontal Addressing Mode; 01=Vertical Addressing Mode;
// 10=Page Addressing Mode (RESET); 11=Invalid
0xB0, // Set Page Start Address for Page Addressing Mode, 0-7
0xC8, // Set COM Output Scan Direction
0x02,// 0x00, // --set low column address
0x10, // --set high column address
0x40, // --set start line address
0x81, 0x3F, // Set contrast control register
0xA0, // Set Segment Re-map. A0=address mapped; A1=address 127 mapped.
0xA6, // Set display mode. A6=Normal; A7=Inverse
0xA8, DISPLAY_HEIGHT-1, // Set multiplex ratio(1 to 64)
0xA4, // Output RAM to Display
// 0xA4=Output follows RAM content; 0xA5,Output ignores RAM content
0xD3, 0x00, // Set display offset. 00 = no offset
0xD5, // --set display clock divide ratio/oscillator frequency
0xF0, // --set divide ratio
0xD9, 0x22, // Set pre-charge period
0xDA, 0x12, // Set com pins hardware configuration
0xDB, // --set vcomh
0x20, // 0x20,0.77xVcc
0x8D, 0x14, // Set DC-DC enable

};
#pragma mark LCD COMMUNICATION

void lcd_command(uint8_t cmd[], uint8_t size) {
#if defined I2C
i2c_start((LCD_I2C_ADR << 1) | 0);
i2c_byte(0x00); // 0x00 for command, 0x40 for data
for (uint8_t i=0; i<size; i++) {
i2c_byte(cmd[i]);
}
i2c_stop();
#elif defined SPI
LCD_PORT &= ~(1 << CS_PIN);
LCD_PORT &= ~(1 << DC_PIN);
for (uint8_t i=0; i<size; i++) {
SPDR = cmd[i];
while(!(SPSR & (1<<SPIF)));
}
LCD_PORT |= (1 << CS_PIN);
#endif
}
void lcd_data(uint8_t data[], uint16_t size) {
#if defined I2C
i2c_start((LCD_I2C_ADR << 1) | 0);
i2c_byte(0x40); // 0x00 for command, 0x40 for data
for (uint16_t i = 0; i<size; i++) {
i2c_byte(data[i]);
}
i2c_stop();
#elif defined SPI
LCD_PORT &= ~(1 << CS_PIN);
LCD_PORT |= (1 << DC_PIN);
for (uint16_t i = 0; i<size; i++) {
SPDR = data[i];
while(!(SPSR & (1<<SPIF)));
}
LCD_PORT |= (1 << CS_PIN);
#endif
}
#pragma mark -
#pragma mark GENERAL FUNCTIONS
void lcd_init(uint8_t dispAttr){
#if defined I2C
i2c_init();
#elif defined SPI
DDRB |= (1 << PB2)|(1 << PB3)|(1 << PB5);
SPCR = (1 << SPE)|(1<<MSTR)|(1<<SPR0);
LCD_DDR |= (1 << CS_PIN)|(1 << DC_PIN)|(1 << RES_PIN);
LCD_PORT |= (1 << CS_PIN)|(1 << DC_PIN)|(1 << RES_PIN);
LCD_PORT &= ~(1 << RES_PIN);
_delay_ms(10);
LCD_PORT |= (1 << RES_PIN);
#endif

uint8_t commandSequence[sizeof(init_sequence)+1];
for (uint8_t i = 0; i < sizeof (init_sequence); i++) {
commandSequence[i] = (pgm_read_byte(&init_sequence[i]));
}
commandSequence[sizeof(init_sequence)]=(dispAttr);
lcd_command(commandSequence, sizeof(commandSequence));
lcd_clrscr();
}
void lcd_gotoxy(uint8_t x, uint8_t y){
if( x > (DISPLAY_WIDTH/sizeof(FONT[0])) || y > (DISPLAY_HEIGHT/8-1)) return;// out of display
x = x * sizeof(FONT[0]);
cursorPosition.x=x;
cursorPosition.y=y;
#if defined (SSD1306) || defined (SSD1309)
uint8_t commandSequence[] = {0xb0+y, 0x21, x, 0x7f};
#elif defined SH1106
uint8_t commandSequence[] = {0xb0+y, 0x21, 0x00+((2+x) & (0x0f)), 0x10+( ((2+x) & (0xf0)) >> 4 ), 0x7f};
#endif
lcd_command(commandSequence, sizeof(commandSequence));
}

void lcd_clrscr(void){
#ifdef GRAPHICMODE
for (uint8_t i = 0; i < DISPLAY_HEIGHT/8; i++){
memset(displayBuffer[i], 0x00, sizeof(displayBuffer[i]));
lcd_gotoxy(0,i);
lcd_data(displayBuffer[i], sizeof(displayBuffer[i]));
}
#elif defined TEXTMODE
uint8_t displayBuffer[DISPLAY_WIDTH];
memset(displayBuffer, 0x00, sizeof(displayBuffer));
for (uint8_t i = 0; i < DISPLAY_HEIGHT/8; i++){
lcd_gotoxy(0,i);
lcd_data(displayBuffer, sizeof(displayBuffer));
}
#endif
lcd_home();
}
void lcd_home(void){
lcd_gotoxy(0, 0);
}
void lcd_invert(uint8_t invert){
uint8_t commandSequence[1];
if (invert != YES) {
commandSequence[0] = 0xA6;
} else {
commandSequence[0] = 0xA7;
}
lcd_command(commandSequence, 1);
}
void lcd_sleep(uint8_t sleep){
uint8_t commandSequence[1];
if (sleep != YES) {
commandSequence[0] = 0xAF;
} else {
commandSequence[0] = 0xAE;
}
lcd_command(commandSequence, 1);
}
void lcd_set_contrast(uint8_t contrast){
uint8_t commandSequence[2] = {0x81, contrast};
lcd_command(commandSequence, sizeof(commandSequence));
}
void lcd_putc(char c){
switch (c) {
case '\b':
// backspace
lcd_gotoxy(cursorPosition.x-charMode, cursorPosition.y);
lcd_putc(' ');
lcd_gotoxy(cursorPosition.x-charMode, cursorPosition.y);
break;
case '\t':
// tab
if( (cursorPosition.x+charMode*4) < (DISPLAY_WIDTH/ sizeof(FONT[0])-charMode*4) ){
lcd_gotoxy(cursorPosition.x+charMode*4, cursorPosition.y);
}else{
lcd_gotoxy(DISPLAY_WIDTH/ sizeof(FONT[0]), cursorPosition.y);
}
break;
case '\n':
// linefeed
if(cursorPosition.y < (DISPLAY_HEIGHT/8-1)){
lcd_gotoxy(cursorPosition.x, cursorPosition.y+charMode);
}
break;
case '\r':
// carrige return
lcd_gotoxy(0, cursorPosition.y);
break;
default:
// char doesn't fit in line
if( (cursorPosition.x >= DISPLAY_WIDTH-sizeof(FONT[0])) || (c < ' ') ) break;
// mapping char
c -= ' ';
if (c >= pgm_read_byte(&special_char[0][1]) ) {
char temp = c;
c = 0xff;
for (uint8_t i=0; pgm_read_byte(&special_char[i][1]) != 0xff; i++) {
if ( pgm_read_byte(&special_char[i][0])-' ' == temp ) {
c = pgm_read_byte(&special_char[i][1]);
break;
}
}
if ( c == 0xff ) break;
}
// print char at display
#ifdef GRAPHICMODE
if (charMode == DOUBLESIZE) {
uint16_t doubleChar[sizeof(FONT[0])];
uint8_t dChar;
if ((cursorPosition.x+2*sizeof(FONT[0]))>DISPLAY_WIDTH) break;

for (uint8_t i=0; i < sizeof(FONT[0]); i++) {
doubleChar[i] = 0;
dChar = pgm_read_byte(&(FONT[(uint8_t)c][i]));
for (uint8_t j=0; j<8; j++) {
if ((dChar & (1 << j))) {
doubleChar[i] |= (1 << (j*2));
doubleChar[i] |= (1 << ((j*2)+1));
}
}
}
for (uint8_t i = 0; i < sizeof(FONT[0]); i++)
{
// load bit-pattern from flash
displayBuffer[cursorPosition.y+1][cursorPosition.x+(2*i)] = doubleChar[i] >> 8;
displayBuffer[cursorPosition.y+1][cursorPosition.x+(2*i)+1] = doubleChar[i] >> 8;
displayBuffer[cursorPosition.y][cursorPosition.x+(2*i)] = doubleChar[i] & 0xff;
displayBuffer[cursorPosition.y][cursorPosition.x+(2*i)+1] = doubleChar[i] & 0xff;
}
cursorPosition.x += sizeof(FONT[0])*2;
} else {
if ((cursorPosition.x+sizeof(FONT[0]))>DISPLAY_WIDTH) break;

for (uint8_t i = 0; i < sizeof(FONT[0]); i++)
{
// load bit-pattern from flash
displayBuffer[cursorPosition.y][cursorPosition.x+i] =pgm_read_byte(&(FONT[(uint8_t)c][i]));
}
cursorPosition.x += sizeof(FONT[0]);
}
#elif defined TEXTMODE
if (charMode == DOUBLESIZE) {
uint16_t doubleChar[sizeof(FONT[0])];
uint8_t dChar;
if ((cursorPosition.x+2*sizeof(FONT[0]))>DISPLAY_WIDTH) break;

for (uint8_t i=0; i < sizeof(FONT[0]); i++) {
doubleChar[i] = 0;
dChar = pgm_read_byte(&(FONT[(uint8_t)c][i]));
for (uint8_t j=0; j<8; j++) {
if ((dChar & (1 << j))) {
doubleChar[i] |= (1 << (j*2));
doubleChar[i] |= (1 << ((j*2)+1));
}
}
}
uint8_t data[sizeof(FONT[0])*2];
for (uint8_t i = 0; i < sizeof(FONT[0]); i++)
{
// print font to ram, print 6 columns
data[i<<1]=(doubleChar[i] & 0xff);
data[(i<<1)+1]=(doubleChar[i] & 0xff);
}
lcd_data(data, sizeof(FONT[0])*2);

#if defined (SSD1306) || defined (SSD1309)
uint8_t commandSequence[] = {0xb0+cursorPosition.y+1,
0x21,
cursorPosition.x,
0x7f};
#elif defined SH1106
uint8_t commandSequence[] = {0xb0+cursorPosition.y+1,
0x21,
0x00+((2+cursorPosition.x) & (0x0f)),
0x10+( ((2+cursorPosition.x) & (0xf0)) >> 4 ),
0x7f};
#endif
lcd_command(commandSequence, sizeof(commandSequence));

for (uint8_t i = 0; i < sizeof(FONT[0]); i++)
{
// print font to ram, print 6 columns
data[i<<1]=(doubleChar[i] >> 8);
data[(i<<1)+1]=(doubleChar[i] >> 8);
}
lcd_data(data, sizeof(FONT[0])*2);

commandSequence[0] = 0xb0+cursorPosition.y;
#if defined (SSD1306) || defined (SSD1309)
commandSequence[2] = cursorPosition.x+(2*sizeof(FONT[0]));
#elif defined SH1106
commandSequence[2] = 0x00+((2+cursorPosition.x+(2*sizeof(FONT[0]))) & (0x0f));
commandSequence[3] = 0x10+( ((2+cursorPosition.x+(2*sizeof(FONT[0]))) & (0xf0)) >> 4 );
#endif
lcd_command(commandSequence, sizeof(commandSequence));
cursorPosition.x += sizeof(FONT[0])*2;
} else {
uint8_t data[sizeof(FONT[0])];
if ((cursorPosition.x+sizeof(FONT[0]))>DISPLAY_WIDTH) break;

for (uint8_t i = 0; i < sizeof(FONT[0]); i++)
{
// print font to ram, print 6 columns
data[i]=(pgm_read_byte(&(FONT[(uint8_t)c][i])));
}
lcd_data(data, sizeof(FONT[0]));
cursorPosition.x += sizeof(FONT[0]);
}
#endif
break;
}

}
void lcd_charMode(uint8_t mode){
charMode = mode;
}
void lcd_puts(const char* s){
while (*s) {
lcd_putc(*s++);
}
}
void lcd_puts_p(const char* progmem_s){
register uint8_t c;
while ((c = pgm_read_byte(progmem_s++))) {
lcd_putc(c);
}
}
#ifdef GRAPHICMODE
#pragma mark -
#pragma mark GRAPHIC FUNCTIONS
void lcd_drawPixel(uint8_t x, uint8_t y, uint8_t color){
if( x > DISPLAY_WIDTH-1 || y > (DISPLAY_HEIGHT-1)) return; // out of Display
if( color == WHITE){
displayBuffer[(y / 8)][x] |= (1 << (y % 8));
} else {
displayBuffer[(y / 8)][x] &= ~(1 << (y % 8));
}
}
void lcd_drawLine(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint8_t color){
if( x1 > DISPLAY_WIDTH-1 ||
x2 > DISPLAY_WIDTH-1 ||
y1 > DISPLAY_HEIGHT-1 ||
y2 > DISPLAY_HEIGHT-1) return;
int dx = abs(x2-x1), sx = x1<x2 ? 1 : -1;
int dy = -abs(y2-y1), sy = y1<y2 ? 1 : -1;
int err = dx+dy, e2; /* error value e_xy */

while(1){
lcd_drawPixel(x1, y1, color);
if (x1==x2 && y1==y2) break;
e2 = 2*err;
if (e2 > dy) { err += dy; x1 += sx; } /* e_xy+e_x > 0 */
if (e2 < dx) { err += dx; y1 += sy; } /* e_xy+e_y < 0 */
}
}
void lcd_drawRect(uint8_t px1, uint8_t py1, uint8_t px2, uint8_t py2, uint8_t color){
if( px1 > DISPLAY_WIDTH-1 ||
px2 > DISPLAY_WIDTH-1 ||
py1 > DISPLAY_HEIGHT-1 ||
py2 > DISPLAY_HEIGHT-1) return;
lcd_drawLine(px1, py1, px2, py1, color);
lcd_drawLine(px2, py1, px2, py2, color);
lcd_drawLine(px2, py2, px1, py2, color);
lcd_drawLine(px1, py2, px1, py1, color);
}
void lcd_fillRect(uint8_t px1, uint8_t py1, uint8_t px2, uint8_t py2, uint8_t color){
if( px1 > px2){
uint8_t temp = px1;
px1 = px2;
px2 = temp;
temp = py1;
py1 = py2;
py2 = temp;
}
for (uint8_t i=0; i<=(py2-py1); i++){
lcd_drawLine(px1, py1+i, px2, py1+i, color);
}
}
void lcd_drawCircle(uint8_t center_x, uint8_t center_y, uint8_t radius, uint8_t color){
if( ((center_x + radius) > DISPLAY_WIDTH-1) ||
((center_y + radius) > DISPLAY_HEIGHT-1) ||
center_x < radius ||
center_y < radius) return;
int16_t f = 1 - radius;
int16_t ddF_x = 1;
int16_t ddF_y = -2 * radius;
int16_t x = 0;
int16_t y = radius;

lcd_drawPixel(center_x , center_y+radius, color);
lcd_drawPixel(center_x , center_y-radius, color);
lcd_drawPixel(center_x+radius, center_y , color);
lcd_drawPixel(center_x-radius, center_y , color);

while (x<y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x;

lcd_drawPixel(center_x + x, center_y + y, color);
lcd_drawPixel(center_x - x, center_y + y, color);
lcd_drawPixel(center_x + x, center_y - y, color);
lcd_drawPixel(center_x - x, center_y - y, color);
lcd_drawPixel(center_x + y, center_y + x, color);
lcd_drawPixel(center_x - y, center_y + x, color);
lcd_drawPixel(center_x + y, center_y - x, color);
lcd_drawPixel(center_x - y, center_y - x, color);
}
}
void lcd_fillCircle(uint8_t center_x, uint8_t center_y, uint8_t radius, uint8_t color) {
for(uint8_t i=0; i<= radius;i++){
lcd_drawCircle(center_x, center_y, i, color);
}
}
void lcd_drawBitmap(uint8_t x, uint8_t y, const uint8_t *picture, uint8_t width, uint8_t height, uint8_t color){
uint8_t i,j, byteWidth = (width+7)/8;
for (j = 0; j < height; j++) {
for(i=0; i < width;i++){
if(pgm_read_byte(picture + j * byteWidth + i / 8) & (128 >> (i & 7))){
lcd_drawPixel(x+i, y+j, color);
} else {
lcd_drawPixel(x+i, y+j, !color);
}
}
}
}
void lcd_display() {
#if defined (SSD1306) || defined (SSD1309)
lcd_gotoxy(0,0);
lcd_data(&displayBuffer[0][0], DISPLAY_WIDTH*DISPLAY_HEIGHT/8);
#elif defined SH1106
for (uint8_t i = 0; i < DISPLAY_HEIGHT/8; i++){
lcd_gotoxy(0,i);
lcd_data(displayBuffer[i], sizeof(displayBuffer[i]));
}
#endif
}
#endif[/syntax]

ta sama biblioteka .h
[syntax=c]/*
* This file is part of lcd library for ssd1306/ssd1309/sh1106 oled-display.
*
* lcd library for ssd1306/ssd1309/sh1106 oled-display is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or any later version.
*
* lcd library for ssd1306/ssd1309/sh1106 oled-display is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Foobar. If not, see <http://www.gnu.org/licenses/>.
*
* Diese Datei ist Teil von lcd library for ssd1306/ssd1309/sh1106 oled-display.
*
* lcd library for ssd1306/ssd1309/sh1106 oled-display ist Freie Software: Sie können es unter den Bedingungen
* der GNU General Public License, wie von der Free Software Foundation,
* Version 3 der Lizenz oder jeder späteren
* veröffentlichten Version, weiterverbreiten und/oder modifizieren.
*
* lcd library for ssd1306/ssd1309/sh1106 oled-display wird in der Hoffnung, dass es nützlich sein wird, aber
* OHNE JEDE GEWÄHRLEISTUNG, bereitgestellt; sogar ohne die implizite
* Gewährleistung der MARKTFÄHIGKEIT oder EIGNUNG FÜR EINEN BESTIMMTEN ZWECK.
* Siehe die GNU General Public License für weitere Details.
*
* Sie sollten eine Kopie der GNU General Public License zusammen mit diesem
* Programm erhalten haben. Wenn nicht, siehe <http://www.gnu.org/licenses/>.
*
* lcd.h
*
* Created by Michael Köhler on 22.12.16.
* Copyright 2016 Skie-Systems. All rights reserved.
*
* lib for OLED-Display with ssd1306/ssd1309/sh1106-Controller
* first dev-version only for I2C-Connection
* at ATMega328P like Arduino Uno
*
* at GRAPHICMODE lib needs SRAM for display
* DISPLAY-WIDTH * DISPLAY-HEIGHT + 2 bytes
*/

#ifndef LCD_H
#define LCD_H

#ifdef __cplusplus
extern "C" {
#endif

#if (__GNUC__ * 100 + __GNUC_MINOR__) < 303
#error "This library requires AVR-GCC 3.3 or later, update to newer AVR-GCC compiler !"
#endif

#include <inttypes.h>
#include <avr/pgmspace.h>

/* TODO: define bus */
#define I2C// I2C or SPI
/* TODO: define displaycontroller */
#define SH1106 // or SSD1306, check datasheet of your display
/* TODO: define displaymode */
#define TEXTMODE // TEXTMODE for only text to display,
// GRAPHICMODE for text and graphic
/* TODO: define font */
#define FONT ssd1306oled_font// set font here, refer font-name at font.h/font.c

/* TODO: define I2C-adress for display */

// using 7-bit-adress for lcd-library
// if you use your own library for twi check I2C-adress-handle
#define LCD_I2C_ADR (0x78 >> 1) // 7 bit slave-adress without r/w-bit
// r/w-bit are set/unset by library
// e.g. 8 bit slave-adress:
// 0x78 = adress 0x3C with cleared r/w-bit (write-mode)


#ifdef I2C
#include "i2c.h"// library for I2C-communication
// if you want to use other lib for I2C
// edit i2c_xxx commands in this library
// i2c_start(), i2c_byte(), i2c_stop()

#elif defined SPI
// if you want to use your other lib/function for SPI replace SPI-commands
#define LCD_PORTPORTB
#define LCD_DDRDDRB
#define RES_PINPB0
#define DC_PINPB1
#define CS_PINPB2

#endif

#ifndef YES
#define YES 1
#endif

#define NORMALSIZE 1
#define DOUBLESIZE 2

#define LCD_DISP_OFF 0xAE
#define LCD_DISP_ON 0xAF

#define WHITE 0x01
#define BLACK 0x00

#define DISPLAY_WIDTH 128
#define DISPLAY_HEIGHT 64



void lcd_command(uint8_t cmd[], uint8_t size); // transmit command to display
void lcd_data(uint8_t data[], uint16_t size); // transmit data to display
void lcd_init(uint8_t dispAttr);
void lcd_home(void); // set cursor to 0,0
void lcd_invert(uint8_t invert); // invert display
void lcd_sleep(uint8_t sleep); // display goto sleep (power off)
void lcd_set_contrast(uint8_t contrast); // set contrast for display
void lcd_puts(const char* s); // print string, \n-terminated, from ram on screen (TEXTMODE)
// or buffer (GRAPHICMODE)
void lcd_puts_p(const char* progmem_s); // print string from flash on screen (TEXTMODE)
// or buffer (GRAPHICMODE)

void lcd_clrscr(void); // clear screen (and buffer at GRFAICMODE)
void lcd_gotoxy(uint8_t x, uint8_t y); // set curser at pos x, y. x means character,
// y means line (page, refer lcd manual)
void lcd_putc(char c); // print character on screen at TEXTMODE
// at GRAPHICMODE print character to buffer
void lcd_charMode(uint8_t mode); // set size of chars
#if defined GRAPHICMODE
void lcd_drawPixel(uint8_t x, uint8_t y, uint8_t color);
void lcd_drawLine(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2, uint8_t color);
void lcd_drawRect(uint8_t px1, uint8_t py1, uint8_t px2, uint8_t py2, uint8_t color);
void lcd_fillRect(uint8_t px1, uint8_t py1, uint8_t px2, uint8_t py2, uint8_t color);
void lcd_drawCircle(uint8_t center_x, uint8_t center_y, uint8_t radius, uint8_t color);
void lcd_fillCircle(uint8_t center_x, uint8_t center_y, uint8_t radius, uint8_t color);
void lcd_drawBitmap(uint8_t x, uint8_t y, const uint8_t picture[], uint8_t width, uint8_t height, uint8_t color);
void lcd_display(void); // copy buffer to display RAM
#endif

#ifdef __cplusplus
}
#endif
#endif /* LCD_H */[/syntax]

inna biblioteka. .c
[syntax=c]// Functions for SSD1306/SSD1106 OLED Driver
// Version 4.0 by Nigel Mercier, based on code by dariuskrail

#include "SH1106.h"
#include "font5.h"
#include "font6R.h"
#include "functions.h"

// SSD1307:
// StartCol = 0;
// DisplayRAMColSize = 128;
// SH1106:
// StartCol = 2;
// DisplayRAMColSize = 132;

// ** Functions **
// Display Internal functions

void initDisplay(void)
{
DisplayRST = 0 ; // reset display (RST is active LOW)
delayX25ms(1) ; // minimum 10uS
DisplayRST = 1 ; // release reset

sendCmd(0xAE) ; // turn off OLED panel [#11]

sendCmd(0xC8) ; // set COM scan direction 0-n [POR = C0, C8] [#13]
sendCmd(0xA1) ; // set SEG/Column left/right re-map [POR = A0, A1] [#6]
// sendCmd(0xA4) ; // Entire Display Force On [POR = A4, A5 force on] [#7]

clsDisplay() ; // clear RAM data and zero cursor
setContrast(128) ; // POR value = 0x80
sendCmd(0xAF) ; // turn on OLED panel [#11]
delayX25ms(4) ; // at least 100mS after 0xAF command
}

void sendCmd(byte cmdOut)
{ // Write a command to Display
DisplayD_C = 0 ; // set A0 low, select Command mode DisplayD_C = 0 for this byte
writeSD(cmdOut) ; // Clock out command bits
DisplayD_C = 1 ; // set A0 high, select Data mode DisplayD_C = 1 for next ...
}

void sendData(byte dataOut)
{ // Write data to Display, DisplayD_C = 1 set after sendCmd()
// DisplayD_C = 1 ; // set A0 high, select Data mode DisplayD_C = 1
writeSD(dataOut) ; // Clock out data bits
}

void writeSD(byte byteOut)
{ // Clocks out data to the SSD1306/SSD1106 controller
signed short int bitcnt ;
for (bitcnt = 8 ; bitcnt > 0 ; bitcnt--)
{
DisplayCLK = 0 ; // Set clock low
DisplaySDI = byteOut.B7 ; // transfer current bit 7 of byteOut to DisplaySDI pin
DisplayCLK = 1 ; // clock data bit on the rising edge of DisplayCLK
byteOut = byteOut << 1 ; // logical shift left: get next bit to b7
}
}

void sendGlyphs(const byte *pRow, byte size)
{ //Send any font row to print character
byte count ;
for (count = 0 ; count < size ; count++) // Send row to print the character
{
sendData((pRow[count])) ;
}
sendData(0x00); // 1 pixel horizontal space after character
}

// Display Screen Controls

void setContrast(unsigned char contr)
{
sendCmd(0x81) ; // set contrast control register [#5]
sendCmd(contr) ; //
}

void cursorY(unsigned char add)
{ //Set page address for Page Addressing Mode
sendCmd(0xB0 | add) ;
}

void cursorX(unsigned char add)
{ //Set column adress for Page Addressing Mode
add = add+sXOffset ;
sendCmd(0x10 | (add>>4)) ; // shift high 4
sendCmd(0x0F & add) ; // low 4
}

void cursorXY(byte x, byte y)
{ // Position cursor to column, line
cursorY(y) ; // Y axis = line 0-7
cursorX(x) ; // X axis = column 0 - (sWidth - 1)
}

void onDisplay(void)
{
sendCmd(0xAF) ; // turn on OLED panel
}

void offDisplay(void)
{
sendCmd(0xAE) ; // turn off OLED panel
}

void clsDisplay(void)
{ // Erase the entire display DDRAM and set cursor home (0,0)
byte line;
offDisplay() ; // turn off OLED panel
for (line = 8 ; line > 0 ; line--) // 8 lines of Display DDRAM
{ clLnDisplay(8 - line) ; } // erase each in turn, home cursor to line
onDisplay() ; // turn on OLED panel
}

void clLnDisplay(byte yline)
{ // Clear single line 0-7 on display, cursor to line start
byte ram ;
cursorXY(0, yline) ; // Cursor Home
for (ram=sWidth ; ram>0 ; ram--) // sWidth DDRAM addresses in each line
{ sendData(0); } // clear RAM
cursorXY(0, yline) ; // Cursor Home
}

void rptPix(byte pix, byte blank, byte percent)
{ // repeat pixel across Display for percent - show bar graph
byte count ;
int width ;
width = (sWidth*percent)/100 ; // screen width x fill level
for (count=0; count<sWidth; count++) // loop for width
{
if ((count <= width)||(count > (sWidth - 2)))
{ sendData(pix) ; } // send 'pix' glyph to display
else
{ sendData(blank) ;} // send 'blank' glyph to display
}
}

void barDisplay(byte barG)
{// water bargraph on line 7
cursorXY(0, 7) ;
rptPix(0b11111111, 0b10000001, barG); // Draw line, then blanks
}

// Display FONTS:
// 5x8 (1-line, full 7-bit ASCII from space)
// 34x48 (6 lines, numerals only, ASCII 48 - 57) Calibri Bold 54

// Font5 functions (5x8)

void charFont5(byte character) // MODIFY IF FONT RANGE CHANGED
{ // Prepare to write byte to Font5, via sendGlyphs
if (character == ' ') // munge ' ' to empty ';' character
{ character = ';' ; }
if ((character<'.')||(character>'Z')) // reduced font5 table, CAPS only
{ return ; } // Exit function if character out of ASCII range
//Index to row of the character in font5 table, then send glyphs
sendGlyphs(font5[character - '.'], sizeof font5[0]);
}

void strFont5(byte s[])
{ // Write Variable or Contatant string to Font5
while(*s) {charFont5(*s++);} // Points to character, or terminator
}

void strFont5XY(byte s[], byte x, byte y)
{ // Write (V or C) string to Font5 @ XY
cursorXY(x,y);
strFont5(s);
}

void byteFont5XY(byte num, byte x, byte y)
{ // display byte value at XY
char txt4[4];
ByteToStr(num, txt4);
strFont5XY(txt4, x, y);
}

void intFont5XY(int num, byte x, byte y)
{ // display int value at XY
char txt7[7];
IntToStr(num, txt7);
strFont5XY(txt7, x, y);
}

void byteFont5(byte num)
{ // display byte value at cursor
char txt4[4];
ByteToStr(num, txt4);
strFont5(txt4);
}

void digitFont5(byte digit) // send single digit to Display
{
charFont5(digit + '0');
}

void digitFont5XY(byte digit, byte x, byte y) // send single digit to Display @ x, y
{
cursorXY(x,y);
digitFont5(digit) ;
}

// End of Font5 functions

// Font6R functions (34x48) numerals only

void charfont6Ra(byte character)
{ // Prepare top 22 bytes for Display, via sendGlyphs (numerals, space and '.' only)
//if (character==' ') {character='/';} // Munge ' ' into '/' for blank glyph
if ((character<'0')||(character>'9'))
{ return ; } // Exit function if character out of numeric range
//Index to row of the character in font6R table, then send glyphs
sendGlyphs(font6Ra[character - '0'], sizeof font6Ra[0]);
}

void charfont6Rb(byte character)
{ // Prepare middle1 22 bytes for Display, via sendGlyphs
// if (character==' ') {character='/';} // Munge ' ' into '/' for blank glyph
if ((character<'0')||(character>'9'))
{ return ; } // Exit function if character out of numeric range
//Index to row of the character in font6R table, then send glyphs
sendGlyphs(font6Rb[character - '0'], sizeof font6Rb[0]);
}

void charfont6Rc(byte character)
{ // Prepare middle2 22 bytes for Display, via sendGlyphs
// if (character==' ') {character='/';} // Munge ' ' into '/' for blank glyph
if ((character<'0')||(character>'9'))
{ return ; } // Exit function if character out of numeric range
//Index to row of the character in font6R table, then send glyphs
sendGlyphs(font6Rc[character - '0'], sizeof font6Rc[0]);
}

void charfont6Rd(byte character)
{ // Prepare lower 22 bytes for Display, via sendGlyphs
// if (character==' ') {character='/';} // Munge ' ' into '/' for blank glyph
if ((character<'0')||(character>'9'))
{ return ; } // Exit function if character out of numeric range
//Index to row of the character in font6R table, then send glyphs
sendGlyphs(font6Rd[character - '0'], sizeof font6Rd[0]);
}

void charfont6Re(byte character)
{ // Prepare lower 22 bytes for Display, via sendGlyphs
// if (character==' ') {character='/';} // Munge ' ' into '/' for blank glyph
if ((character<'0')||(character>'9'))
{ return ; } // Exit function if character out of numeric range
//Index to row of the character in font6R table, then send glyphs
sendGlyphs(font6Re[character - '0'], sizeof font6Re[0]);
}

void charfont6Rf(byte character)
{ // Prepare lower 22 bytes for Display, via sendGlyphs
// if (character==' ') {character='/';} // Munge ' ' into '/' for blank glyph
if ((character<'0')||(character>'9'))
{ return ; } // Exit function if character out of numeric range
//Index to row of the character in font6R table, then send glyphs
sendGlyphs(font6Rf[character - '0'], sizeof font6Rf[0]);
}

void strfont6Ra(byte s[])
{ // Write (V or C) string to font6Ra
while(*s) {charfont6Ra(*s++);} // Points to character, or terminator
}

void strfont6Rb(byte s[])
{ // Write (V or C) string to font6Rb
while(*s) {charfont6Rb(*s++);} // Points to character, or terminator
}

void strfont6Rc(byte s[])
{ // Write (V or C) string to font6Rc
while(*s) {charfont6Rc(*s++);} // Points to character, or terminator
}

void strfont6Rd(byte s[])
{ // Write (V or C) string to font6Rd
while(*s) {charfont6Rd(*s++);} // Points to character, or terminator
}

void strfont6Re(byte s[])
{ // Write (V or C) string to font6Rd
while(*s) {charfont6Re(*s++);} // Points to character, or terminator
}

void strfont6Rf(byte s[])
{ // Write (V or C) string to font6Rd
while(*s) {charfont6Rf(*s++);} // Points to character, or terminator
}

void strfont6RXY(byte s[], byte x, byte y)
{ // Write (V or C) string to font6R @ XY
cursorXY(x, y) ;
strfont6Ra(s) ;
cursorXY(x, y+1) ;
strfont6Rb(s) ;
cursorXY(x, y+2) ;
strfont6Rc(s) ;
cursorXY(x, y+3) ;
strfont6Rd(s) ;
cursorXY(x, y+4) ;
strfont6Re(s) ;
cursorXY(x, y+5) ;
strfont6Rf(s) ;
}
// End of font6R functions

// Misc init command repository

// sendCmd(0x0F & sXOffset) ; // set low column address to any offset [#1]
// sendCmd(0x10) ; // set high column address to 0 [#2]
// sendCmd(0xD9) ; // set pre-charge period [#16]
// sendCmd(0x25) ; // default is 22
// sendCmd(0xDB) ; // set Vcom Deselect Level [#18]
// sendCmd(0x20) ; // set Vcom Deselect Level [POR = 35]
// sendCmd(0xF1) ; // Set Pre-Charge as 15 Clocks & Discharge as 1 Clock
// clsDisplay ;


// sendCmd(0x32) ; // set Charge Pump voltage 0x32 = 8V [#3]
// sendCmd(0xAD) ; // DC-DC Control Mode [#10]
// sendCmd(0x8B) ; // DC-DC Set ON

// sendCmd(0x8D) ; // set SSD1306 Charge Pump enable/disable [see supplement]
// sendCmd(0x14) ; // enable charge pump on SSD1306


/*
sendCmd(0xA8) ; // set multiplex ratio (1 to 64) [#9]
sendCmd(0x3F) ; // [POR = 3F] 1/64 duty
sendCmd(0xD3) ; // set display offset Shift Mapping RAM Counter (0x00~0x3F) [#14]
sendCmd(0x00) ; // [POR = 0] not offset
sendCmd(0x40) ; // set start line to 0 [#4]
sendCmd(0xA0) ; // set SEG/Column left re-map [POR = A0] [#6]
sendCmd(0xC0) ; // set COM scan direction 0-n [POR = C0] [#13]
sendCmd(0xDA) ; // set com pins hardware configuration [#17]
sendCmd(0x12) ; // [POR = 12]
sendCmd(0x81) ; // set contrast control register [#5]
sendCmd(0xF0) ; // 80 [POR]

sendCmd(0xA6) ; // set normal display A6 [POR] (reverse = A7) [#8]
sendCmd(0xD5) ; // set display clock divide ratio/oscillator frequency [#15]
sendCmd(0x50) ; // set divide ratio 0, Set Clock*/[/syntax]

.h
[syntax=c]// Header for SSD1306/SSD1106 OLED Driver
// Version 4.0 by Nigel Mercier

#include "typedefs.h" // typedef unsigned short int byte ;
#include "defs MK4 PCB.h" // port assignments for PCB MK4

#define sWidth 128 // screen width
#define sXOffset 2 // x offset


// ** Function Prototypes **

// Display Internal functions
void initDisplay(void) ; // initialise the display
void sendCmd(byte) ; // write a command to display
void sendData(byte) ; // write data to display
void writeSD(byte); // clock out serial data to the display controller

// Display Control

void onDisplay(void) ; // turn on OLED panel
void offDisplay(void) ; // turn off OLED panel
void clsDisplay(void) ; // erase the display DDRAM and set cursor home (0,0)
void clLnDisplay(byte) ; // clear line on display, cursor to line start
void cursorXY(byte, byte) ; // position cursor to column, line
void setContrast(byte) ; // set contrast

// Display
void rptPix(byte, byte, byte) ; // repeat pixel across Display - show bar graph
void barDisplay(byte) ; // display bar graph
void charFont5(byte); // Write byte in font 5, via sendGlyphs
void strFont5(byte []); // Write Variable or Contstant string in font 5
void strFont5XY(byte [], byte, byte); // Write (V or C) string in font 5 @XY
void strFont6RXY(byte [], byte, byte); // Write (V or C) string in font 22 @XY
void byteFont5(byte) ; // Write 3 characters of byte in font 5
void intFont5XY(int, byte, byte) ; // Write 5 characters of int in font 5
void byteFont5XY(byte, byte, byte); // Write 3 characters of byte in font 5 @XY
void digitFont5(byte) ; // Send single digit to Display
void digitFont5XY(byte, byte, byte) ; // Send single digit to Display @XY

// private functions for reference
// void sendGlyphs(const byte *, byte); //Send any font row to print character[/syntax]

Statystyki: Napisane przez Hass-pol — 27 paź 2019, o 22:05

]]> 2015-08-14T20:46:03+01:00 2015-08-14T20:46:03+01:00 https://forum.atnel.pl/viewtopic.php?t=12638&p=137317#p137317 <![CDATA[Re: Problem z OLED 1,3"]]> Statystyki: Napisane przez luki — 14 sie 2015, o 20:46

]]> 2015-08-14T20:44:49+01:00 2015-08-14T20:44:49+01:00 https://forum.atnel.pl/viewtopic.php?t=12638&p=137316#p137316 <![CDATA[Re: Problem z OLED 1,3"]]> [syntax=c]void ssd1306_display( void )
{
ssd1306_cmd( SSD1306_SETLOWCOLUMN | 0x0 );
ssd1306_cmd( SSD1306_SETHIGHCOLUMN | 0x0 );
ssd1306_cmd( SSD1306_SETSTARTLINE | 0x0 );

// ***************************** SSD1306 *****************************************************************
#if USE_SH1106 == 0 // 0 - SSD1306 1 - SH1106
#if USE_CS == 1
CS_HI;
#endif

DC_HI;

#if USE_CS == 1
CS_LO;
#endif

for ( uint16_t i = 0 ; i < ( SSD1306_WIDTH * SSD1306_HEIGHT / 8) ; i++ )
{
SPIwrite( ssd1306_buf[i] );
}

#if USE_CS == 1
CS_HI;
#endif
#endif

// ********************************* SH1106 *****************************************************************
#if USE_SH1106 == 1 // 0 - SSD1306 1 - SH1106
uint8_t height=64;
uint8_t width=132;
uint8_t m_row = 0;
uint8_t m_col = 2;

height >>= 3;
width >>= 3;

int p = 0;

uint8_t i, j, k =0;

for ( i = 0; i < height; i++)
{

// *************** send a bunch of data in one xmission ********************************************
ssd1306_cmd(0xB0 + i + m_row); //set page address
ssd1306_cmd(m_col & 0xF); //set lower column address
ssd1306_cmd(0x10 | (m_col >> 4)); //set higher column address

for( j = 0; j < 8; j++)
{

#if USE_CS == 1
CS_HI;
#endif

DC_HI;

#if USE_CS == 1
CS_LO;
#endif

for ( k = 0; k < width; k++, p++)
{
SPIwrite( ssd1306_buf[p] );
}

#if USE_CS == 1
CS_HI;
#endif
}
}
#endif
}[/syntax]

Statystyki: Napisane przez gufim — 14 sie 2015, o 20:44

]]> 2015-08-14T18:59:07+01:00 2015-08-14T18:59:07+01:00 https://forum.atnel.pl/viewtopic.php?t=12638&p=137292#p137292 <![CDATA[Problem z OLED 1,3"]]>
Mam problem z uruchomienie OLED 1,3" (SSD1306) wyświetlacz nowy, korzystam z bibliotek z poradników.
Wyświetlacz sterowany po SPI.
Biblioteka jak i program prawidłowa ponieważ gdy podepnę wyświetlacz 0,96" wszystko działa tak jak trzeba po przełączeniu na 1,3" bez zmiany wsadu mam taki oto efekt:
iframe

Cały bufor wyświetlany jest i nadpisywany tylko na 1/8 wyświetlacza gdy w inicjalizacji zmienię ofset to cały pasek przesuwa się odpowiednio więc uszkodzenie sterowania pikseli można wykluczyć.
OLED 0,96"
Obrazek

Dodam że problem występuje zrówno na oryginalnej płytce jak i na tej od Gufima.
Gdy na jego płytce był przylutowany 0,9" też wszystko działo co potwierdza poprawność wszystkich połączeń.
Moim zdaniem trzeba coś zmienić/dodać w inicjalizacji.
Filmik dokładnie pokazuję jaki mam efekt.

Kodów nie wklejam ponieważ są one przepisane zgodnie z poradnikami gdyby były by tam jakieś błędy to na obydwu wyświetlaczach powinien być taki sam efekt (moim zdaniem).
Procek to ATMEGA328P
Oscylator wew 8MHz

Proszę o pomoc
Pozdrawiam Luki

Statystyki: Napisane przez luki — 14 sie 2015, o 18:59

]]>