ATNEL tech-forum 2019-08-10T13:06:42+01:00 https://forum.atnel.pl/feed.php?f=30&t=22474&mode 2019-08-10T13:06:42+01:00 2019-08-10T13:06:42+01:00 https://forum.atnel.pl/viewtopic.php?t=22474&p=221156#p221156 <![CDATA[Re: oled i2c]]>

Statystyki: Napisane przez Adam12 — 10 sie 2019, o 13:06

]]> 2019-08-10T12:06:14+01:00 2019-08-10T12:06:14+01:00 https://forum.atnel.pl/viewtopic.php?t=22474&p=221153#p221153 <![CDATA[Re: oled i2c]]> Nie wiem o co chodzi bo nadal nie uruchamia się ten wyświetlacz, może kupiłem jakiś wybrakowany szmelc. Pokombinuje jeszcze.

Schemat połączeń:
OLED - ATB
------------------
VCC <-> VCC
GND <-> GND
DIN <-> SDA
CLK <-> SCL
RST <-> PINx

EDIT:
Ogarnąłem. Musi być podłączony jeszcze reset i wysterowany tak jak miałem początkowo w inicjalizacji. Teraz ruszył. Dla potomnych - OLED 0.96 dwukolorowy 128x64px spi / i2c

Statystyki: Napisane przez Lex_ — 10 sie 2019, o 12:06

]]> 2019-08-09T22:13:12+01:00 2019-08-09T22:13:12+01:00 https://forum.atnel.pl/viewtopic.php?t=22474&p=221148#p221148 <![CDATA[Re: oled i2c]]>
i2c.h, i2c.c
[syntax=c]//deklaracje i2c.h
#define SSD1306_DEFAULT_ADDRESS 0x78 //zmiana adresu na 0x78

void init(void);
void start(void);
void write(uint8_t data);
void stop(void);


//definicje i2c.c

void init(void) {
TWSR &= ~( (1<<TWPS1)|(1<<TWPS0) );//prescaler = 1
uint8_t bitrate = ((F_CPU/1000ul)/400); //400kHz
if(bitrate >= 16) bitrate = (bitrate-16+1)/2;
TWBR = bitrate;
}

//funkcje start, stop, write w najprostszej wersji - bez kontroli błędów
void start(void) {
TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWSTA);
while (!(TWCR&(1<<TWINT)));
}

void stop(void) {
TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWSTO);
while ( (TWCR&(1<<TWSTO)));
}

void write(uint8_t data) {
TWDR = data;
TWCR = (1<<TWINT)|(1<<TWEN);
while ( !(TWCR&(1<<TWINT)));
}[/syntax]

ssd1306.c
[syntax=c]uint8_t SSD1306() {
//start();
//send_Start_Command(SSD1306_SWITCHCAPVCC, SSD1306_DEFAULT_ADDRESS);
sendCommand(SSD1306_SWITCHCAPVCC);
sendCommand(SSD1306_DISPLAYOFF);
sendCommand(SSD1306_SETDISPLAYCLOCKDIV);
sendCommand(0x80);

sendCommand(SSD1306_SETMULTIPLEX);
sendCommand(0x3F);

sendCommand(SSD1306_SETDISPLAYOFFSET);
sendCommand(0x00);
sendCommand(SSD1306_SETSTARTLINE | 0x00);

// We use internal charge pump
sendCommand(SSD1306_CHARGEPUMP);
sendCommand(0x14);

// Horizontal memory mode
sendCommand(SSD1306_MEMORYMODE);
sendCommand(0x00);

sendCommand(SSD1306_SEGREMAP | 0x1);
sendCommand(SSD1306_COMSCANDEC);
sendCommand(SSD1306_SETCOMPINS);
sendCommand(0x12);

// Max contrast
sendCommand(SSD1306_SETCONTRAST);
sendCommand(0xCF);

sendCommand(SSD1306_SETPRECHARGE);
sendCommand(0xF1);

sendCommand(SSD1306_SETVCOMDETECT);
sendCommand(0x40);

sendCommand(SSD1306_DISPLAYALLON_RESUME);

// Non-inverted display
sendCommand(SSD1306_NORMALDISPLAY);

return 0;
}

void sendCommand(uint8_t command) {
start();//bit startu
write(SSD1306_DEFAULT_ADDRESS);//adres OLED'a - 0x78
// write(0x40);//wysyłka danych
write(0x00);//wysyłka komendy
write(command);
stop();//bit stopu
}


void sendData(uint8_t data) {
start();//bit startu
write(SSD1306_DEFAULT_ADDRESS);//adres OLED'a - 0x78
write(0x40);//wysyłka danych
// write(0x00);//wysyłka komendy
write(data);
stop();//bit stopu
}

void sendFramebuffer(uint8_t *buffer) {

//start();//tutaj niepotrzebny
sendCommand(SSD1306_COLUMNADDR);
sendCommand(0x00);
sendCommand(0x7F);

sendCommand(SSD1306_PAGEADDR);
sendCommand(0x00);
sendCommand(0x07);


start(); //bit startu - sekwencja wysyłki danych

// send the buffer as 16 bytes packets
// buffer is 1024 bytes long, 1024/16 = 64
// We have to send 64 packets

write(SSD1306_DEFAULT_ADDRESS);//adres OLED'a
write(0x40);//wysyłka danych

for (uint8_t packet = 0; packet < 64; packet++) {//dane z bufora
for (uint8_t packet_byte = 0; packet_byte < 16; ++packet_byte) {
write(buffer[packet*16+packet_byte]);
}

}
stop(); //bit stopu - koniec wysyłki danych
}[/syntax]

framebuffer.c
[syntax=c]void drawPixel2(uint8_t pos_x, uint8_t pos_y) {
if (pos_x >= SSD1306_WIDTH || pos_y >= SSD1306_HEIGHT) {
return;
}

buffer[pos_x+(pos_y/8)*SSD1306_WIDTH] |= (1 << (pos_y&7));
// sendFramebuffer(buffer);//wysyłanie z bufora dopiero po zapisie do bufora wszystkich pixeli
}[/syntax]

main.c
[syntax=c]int main(void) {

init(); //set bitrate
SSD1306();
sendCommand(SSD1306_DISPLAYON);//to może być w inicjalizacji SSD1306()
clear();

//przykładowa sekwencja wysyłki danych - z pominięciem buforowania
start();
write(SSD1306_DEFAULT_ADDRESS);
write(0x40);
for (int i = 0; i < 1024; ++i) {
write(0xFF);
_delay_ms(3);
}
stop();

drawPixel(35, 35, 1);

//rysowanie linii z zapisem całej linii do bufora, a następnie wysyłka danych z bufora - inaczej przy
//każdym pixelu jest wysyłany cały bufor co trwa wieki
drawLine(0,0,80,40);//sendFramebuffer usunięty z drawPixel2 - rysowanie do bufora
sendFramebuffer(buffer); //przesłanie danych z bufora do OLED'a - w tym wypadku linii utworzonej za pomocą drawLine

while(1);
}
}[/syntax]

Statystyki: Napisane przez Adam12 — 9 sie 2019, o 22:13

]]> 2019-08-08T21:46:10+01:00 2019-08-08T21:46:10+01:00 https://forum.atnel.pl/viewtopic.php?t=22474&p=221131#p221131 <![CDATA[Re: oled i2c]]> Statystyki: Napisane przez Adam12 — 8 sie 2019, o 21:46

]]> 2019-08-08T20:42:13+01:00 2019-08-08T20:42:13+01:00 https://forum.atnel.pl/viewtopic.php?t=22474&p=221130#p221130 <![CDATA[Re: oled i2c]]> Lex_ napisał(a):

na forach oprócz dokumentacji i też była mowa o adresie 0x78 ale na arduino działało właśnie na adresie 0x3C

Widzisz, kluczem do zrozumienia tych rozbieżności jest zrozumienia zasady działania magistrali TWI/I2C.
Na początku transmisji należny zaadresować urządzenie dla którego przeznaczona jest paczka danych, i adres ten jest wysyłany w pierwszym bajcie, ale tylko 7 najstarszych bitów jest za niego odpowiedzialna, bo najmłodszy bit oznacza w zależności czy jest jedynką czy zerem, zapis bądź odczyt z urządzenia.
I teraz jak się przyjrzysz adresom 0x3C i 0x78 w postaci binarnej, okaże się że różnią się one tylko przesunięciem o jeden bajt:
0x3C => 0b00111100
0x78 => 0b01111000
Różnica jest tylko w tym że arduinowcy przyjęli sobie adres w takiej formie, że bit zapisu/odczytu na żywca wycinają i adresem nazywają to co zostało. Nie wiem może dla niektórych taki zapis jest bardziej logiczny, ale nawet chińczyki na oledach które mają możliwość wyboru adresu zapisuję je jako 0x78 lub 0x7A więc nie wiem skąd w arduino wziął się ten inny zapis, a jest to zapis nieoptymalny z punktu widzenia programu ponieważ aby wysłać taką postać adresu na magistralę trzeba zrobić dwie operacje: przesunąć bitowo o 1 w lewo i dokleić bit zapisu/odczytu:
[syntax=c]data = (OLED_ADRES<<1)|bit_zapisu; //gdzie bit zapisu przyjmuje wartości 0b00000001 lub 0b00000000, a OLED_ADRES = 0x3C czyli 0b00111100[/syntax]
Natomiast ta druga wersja adresu w najmłodszym bicie ma już miejsce na bit zapisu/odczytu (w adresie zapisuje się tam, czyli na najmłodszym bicie, zawsze poprostu 0) więc nie trzeba robić przesunięcia tylko wrzucenie bitu zapisu/odczytu:
[syntax=c]data = OLED_ADRES|bit_zapisu; //gdzie bit zapisu przyjmuje wartości 0b00000001 lub 0b00000000, a OLED_ADRES = 0x78 czyli 0b01111000[/syntax]
Jak widzisz, adres można sobie zapisać na różne sposoby, trzeba tylko później odpowiednio program napisać by we właściwej formie go wysłał na magistralę TWI/I2C.

Statystyki: Napisane przez xentis — 8 sie 2019, o 20:42

]]> 2019-08-07T21:56:11+01:00 2019-08-07T21:56:11+01:00 https://forum.atnel.pl/viewtopic.php?t=22474&p=221087#p221087 <![CDATA[Re: oled i2c]]>
Podejrzewam że namieszałem, ale też już czuję że się w tym pogubiłem. Przeczytałem sporo różnych wątków na forach oprócz dokumentacji i też była mowa o adresie 0x78 ale na arduino działało właśnie na adresie 0x3C :/ w dokumentacji była mowa o wyłączeniu zasilania na czas inicjalizacji - że należy wystawić stan niski zamiast wysokiego. Efekt - TWI w ogóle nie mogło się zinicjalizować. I nie dziwi mnie to tylko po co w dokumentacji piszą takie rzeczy? Podsyłam potrzebne pliki. Mega dzięki za pomoc - na dole załącznik.
Hasło do archiwum tylko dla zainteresowanych.

Statystyki: Napisane przez Lex_ — 7 sie 2019, o 21:56

]]> 2019-08-07T19:12:41+01:00 2019-08-07T19:12:41+01:00 https://forum.atnel.pl/viewtopic.php?t=22474&p=221085#p221085 <![CDATA[Re: oled i2c]]>

Statystyki: Napisane przez Adam12 — 7 sie 2019, o 19:12

]]> 2019-08-07T18:28:33+01:00 2019-08-07T18:28:33+01:00 https://forum.atnel.pl/viewtopic.php?t=22474&p=221084#p221084 <![CDATA[Re: oled i2c]]>
Nic dziwnego że zapala się tylko dioda bo nic innego w pętli while pliku main nie masz
zatrzymujesz program na 10 ms zapalasz diodę i zwiększasz wartość zmiennej y2
o jeden aż do 255

nie masz ani wywołania jakiejś funkcji
ani nie dajesz w tej pętli nic innego do zrobienia oprócz zapalenia diody

Statystyki: Napisane przez miki53 — 7 sie 2019, o 18:28

]]> 2019-08-07T15:03:06+01:00 2019-08-07T15:03:06+01:00 https://forum.atnel.pl/viewtopic.php?t=22474&p=221078#p221078 <![CDATA[oled i2c]]>
Piszę bo już męczę to od ponad dwóch tygodni. Chcę napisać swoją bibliotekę do oled'a wykorzystując i2c. Przeczytałem dokumentację sterownika i przekonałem się, że informacje tam zawarte niestety nie sprawdzają się w praktyce.

Zacząłem od podłączenia do arduino aby szybko przetestować wyświetlacz czy jest żywy i ruszył na bibliotekach Adafruit. Zacząłem więc pisać ją w języku C i mam już wszystko napisane tylko że wyświetlacz nadal nie wstaje. Wykorzystuje sprzętowe TWI. Może ktoś z Was zauważy co robię nie tak albo poda jakiś prosty przykład który działa ? Będę wdzięczny za każdą pomoc. Napisałem już tego sporo, kosztowało dużo czasu i chciałbym to dokończyć.

MAIN:
[syntax=c]#include <avr/io.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <string.h>
#include <stdlib.h>
#include "framebuffer.h"
#include "ssd1306.h"
#include "LCD/lcd44780.h"

uint8_t y2=0;

#define LED_PIN1 (1<<PD6)
#define LED_OFF1 PORTD &= ~LED_PIN1// makrodefinicja – załączenie diody
#define LED_ON1 PORTD |= LED_PIN1// makrodefinicja – wyłączenie diody
#define LED_TOG1 PORTD ^= LED_PIN1// makrodefinicja – zmiana stanu diody

#define VCC_PIN (1<<PD4)
#define VCC_OFF PORTD &= ~VCC_PIN
#define VCC_ON PORTD |= VCC_PIN
#define VCC_TOG PORTD ^= VCC_PIN

int main(void) {

DDRD |= (1<<PD7);
DDRD |= (1<<PD4) | (1<<PD3);

DDRD |= LED_PIN1;
LED_ON1;
VCC_ON;
sei();
lcd_init();

lcd_cls();
lcd_locate(0,0);

init(); //set bitrate i2c

SSD1306();

lcd_cls();
lcd_locate(0,0); lcd_str(" INIT OK!");

_delay_ms(100);

sendCommand(SSD1306_DISPLAYON);

clear();
lcd_locate(1,0); lcd_str("OK");
drawPixel(35, 35, 1);

show();

while(1) {
_delay_ms(10);

LED_OFF1; // zapal led

y2++;

}
return 0;
}[/syntax]

SSD1306.c
[syntax=c]#include <stdint.h>
#include <avr/io.h>
#include <util/delay.h>
#include "LCD/lcd44780.h"
#include "ssd1306.h"

#define adress_oled 0x3C
#define RST_PIN1 (1<<PD7) // dla inicjalizacji
#define RST_low PORTD &= ~RST_PIN1
#define RST_hi PORTD |= RST_PIN1
#define RST_tog PORTD ^= RST_PIN1

uint8_t SSD1306() {
// reset dla inicjalizacji
RST_hi;
_delay_ms(1);
RST_low;
_delay_ms(10);
RST_hi; // Reset Pin High for normal operation

start();

send_Start_Command(SSD1306_SWITCHCAPVCC, SSD1306_DEFAULT_ADDRESS);

sendCommand(SSD1306_DISPLAYOFF);

sendCommand(SSD1306_SETDISPLAYCLOCKDIV);
sendCommand(0x80);

sendCommand(SSD1306_SETMULTIPLEX);
sendCommand(0x3F);

sendCommand(SSD1306_SETDISPLAYOFFSET);
sendCommand(0x00);

sendCommand(SSD1306_SETSTARTLINE | 0x00);

// We use internal charge pump
sendCommand(SSD1306_CHARGEPUMP);
sendCommand(0x14);

// Horizontal memory mode
sendCommand(SSD1306_MEMORYMODE);
sendCommand(0x00);

sendCommand(SSD1306_SEGREMAP | 0x1);

sendCommand(SSD1306_COMSCANDEC);

sendCommand(SSD1306_SETCOMPINS);
sendCommand(0x12);


// Max contrast
sendCommand(SSD1306_SETCONTRAST);
sendCommand(0xCF);

sendCommand(SSD1306_SETPRECHARGE);
sendCommand(0xF1);

sendCommand(SSD1306_SETVCOMDETECT);
sendCommand(0x40);

sendCommand(SSD1306_DISPLAYALLON_RESUME);

// Non-inverted display
sendCommand(SSD1306_NORMALDISPLAY);

return 0;
}

void sendCommand(uint8_t command) {
// start();
write(SSD1306_DEFAULT_ADDRESS);
// write(0x40);
write(command);
// stop();
}

void send_Start_Command(uint8_t command, uint8_t adr) {

write(SSD1306_DEFAULT_ADDRESS);
write(command);

}

void inverts(uint8_t inverted) {

if (inverted) {
sendCommand(SSD1306_INVERTDISPLAY);
} else {
sendCommand(SSD1306_NORMALDISPLAY);
}

}

void sendFramebuffer(uint8_t *buffer) {

start();
sendCommand(SSD1306_COLUMNADDR);
sendCommand(0x00);
sendCommand(0x7F);

sendCommand(SSD1306_PAGEADDR);
sendCommand(0x00);
sendCommand(0x07);

//lcd_locate(1,0); lcd_str("OK?");

//write(0x40);
start();
// We have to send the buffer as 16 bytes packets
// Our buffer is 1024 bytes long, 1024/16 = 64
// We have to send 64 packets
for (uint8_t packet = 0; packet < 64; packet++) {
for (uint8_t packet_byte = 0; packet_byte < 16; ++packet_byte) {
write(buffer[packet*16+packet_byte]);
}

}
stop();
}[/syntax]
i2c.c
[syntax=c]#include "i2c.h"
#include <util/delay.h>
#include <avr/io.h>
#include "LCD/lcd44780.h"
#include "ssd1306.h"

#define LED_PIN2 (1<<PD3)
#define LED_OFF2 PORTD &= ~LED_PIN2// makrodefinicja – załączenie diody
#define LED_ON2 PORTD |= LED_PIN2// makrodefinicja – wyłączenie diody
#define LED_TOG2 PORTD ^= LED_PIN2// makrodefinicja – zmiana stanu diody

uint8_t binary;

int init() {

LED_ON2;
TWSR = 2;
uint8_t bitrate;

bitrate = ((F_CPU/1000l)/100);
if(bitrate >= 16)
bitrate = (bitrate-16)/2;
//lcd_locate(0,6); lcd_int(TWPS);
TWBR = bitrate;
_delay_ms(1);

return 0;
}

uint8_t start() {
binary = (1<<TWSTA) | (1<<TWEN) | (1<<TWINT);
TWCR = binary;
TWDR = SSD1306_DEFAULT_ADDRESS;
// lcd_locate(0,1); lcd_int(binary);

_delay_ms(1);

while(!(TWCR&(1<<TWINT)));

twi_status_register = (TW_STATUS & 0xF8);

//binary = (twi_status_register != TW_START) && (twi_status_register != TW_REP_START);
// lcd_locate(1,10); lcd_int(binary);
if ((twi_status_register != TW_START) && (twi_status_register != TW_REP_START)) {
return 1;
}

TWDR = SSD1306_DEFAULT_ADDRESS;
TWCR = (1<<TWINT) | (1<<TWEN);

while(!(TWCR & (1<<TWINT)));

twi_status_register = TW_STATUS & 0xF8;
if ((twi_status_register != TW_MT_SLA_ACK) && (twi_status_register != TW_MR_SLA_ACK)) {
return 1; lcd_locate(1,0); lcd_str("ERROR");
}

return 0;
}

uint8_t write(uint8_t data) {
TWDR = data;
TWCR = (1<<TWINT) | (1<<TWEN);

while(!(TWCR & (1<<TWINT)));

twi_status_register = TW_STATUS & 0xF8;
if (twi_status_register != TW_MT_DATA_ACK) {
return 1; LED_ON2;
} else {
return 0;
}
}

void stop(void) {
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
while(!(TWCR & (1<<TWSTO)));
}[/syntax]

Dodam tylko że program przechodzi do pętli WHILE i zapala diode led, ale nic poza tym się nie dzieje.

Statystyki: Napisane przez Lex_ — 7 sie 2019, o 15:03

]]>