Przedstawiamy drugą część kursu obsługi wyświetlacza OLED za pomocą STM32. Pierwsza część artykułu jest dostępna pod adresem.
Wyświetlacz graficzny doskonale się nadaje do wyświetlania tekstu. W klasycznych wyświetlaczach alfanumerycznych czcionki mają jednakową wielkość zależną od wielkości wyświetlacza i mogą być wyświetlane w ustalonych wierszach. W wyświetlaczu graficznym można definiować czcionki o różnych rozmiarach zależnie od potrzeb i umieszczać je w dowolnym miejscu wyświetlacza – o ile się tam zmieszczą.
Przy adresowaniu Page Addressing Mode jest bardzo łatwo zdefiniować znaki o wysokości 8 pikseli, lub wielokrotności tej wartości: 16, 24, 32 itd. Najprościej definiować znaki np. 8×6 pikseli umieszczając w pamięci generatora znaków 6 kolejnych bajtów – łatwo to sobie wyobrazić patrząc na rysunek 7. W programowych bibliotekach obsługujących wyświetlacze graficzne stosowałem z powodzeniem tę metodę. Mam zdefiniowaną tablice generatora znaków i proste procedury wyświetlania znaku na podstawie jego kodu ASCII. Niestety przy tym wyświetlaczu znaki o wysokości 8 pikseli są praktycznie nieczytelne. Wynika to po prostu z małych wymiarów (przekątnej) matrycy. W naszym przypadku wartością graniczną jest wysokość 12 pikseli, a najlepiej gdyby znaki miały 16 i więcej pikseli.
Do rysowania znaków o dowolnej wielkości najlepiej się nadaje funkcja, która potrafi zapalić lub zgasić jeden piksel o dowolnych współrzędnych x, y niezależnych od trybu adresowania. Taka funkcja została pokazana na listingu 7.
List. 7. Rysowanie punktu o ustalonych współrzędnych
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
//********************************************************** //"rysowanie” punktu w buforze RAM mikrokontrolera Hosta //********************************************************** void DrawPoint(unsigned char x,unsigned char y, unsigned char p) { uint8_t chPos, chBx, chTemp = 0; if (x > 127 || y > 63) { return; } chPos = 7 - y / 8; chBx = y % 8; chTemp = 1 << (7 - chBx); if (p) { DispBuff[x][chPos] |= chTemp; } else { DispBuff[x][chPos] &= ~chTemp; } } |
Jak łatwo zauważyć funkcja void DrawPoint() z listingu 7 tylko modyfikuje zawartość dwuwymiarowego bufora DispBuff umieszczonego w pamięci RAM mikrokontrolera Hosta i nie zapisuje modyfikacji do sterownika SSD1306. Jak zobaczymy dalej wszystkie procedury wyświetlania modyfikują tylko ten bufor i aby zobaczyć efekt tych modyfikacji trzeba przepisać całą zawartość DispBuff do pamięci sterownika wywołując funkcję void RefreshRAM(void) pokazaną na listingu 5.
Mając do dyspozycji procedurę potrafiącą zapalać/gasić piksel o konkretnej współrzędnej możemy rysować proste, figury, okręgi, ale też rysować znaki alfanumeryczne o dowolnych wielkościach. Żeby to robić potrzebne są wzorce znaków umieszczone w tablicy zwanej tez generatorem znaków. Ręczne tworzenie wzorców znaków jest możliwe, ale to żmudne zajęcie. Istnieje szereg programów tworzących wzorce o zadanej wielkości znaku. W Internecie można też znaleźć gotowe tablice z wzorcami. Ja skorzystałem z gotowych tablic ze zdefiniowanymi znakami o wielkości 12x6pikseli i 16x8pikseli. Tablice są tak zbudowane, ze kod ASCII znaku adresuje grupę bajtów definiujących ten znak. To znacznie upraszcza procedury wyświetlające łańcuchy znaków (napisy). Na przykład tablica dla znaków o wysokości 12 i szerokości 6 pikseli jest dwuwymiarową tablicą const char c_chFont1206[95][12] i zawiera 95 wzorców znaków. Każdy element wzorca znaków ma 12bajtów i definiuje znak o szerokości 6 pikseli, ale wykorzystuje przestrzeń 12×8 pikseli – listing 8.
List. 8. Fragment tablicy generatora znaków 12×6 pikseli
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
const char c_chFont1206[95][12] = { {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*" ",0*/ {0x00,0x00,0x00,0x00,0x3F,0x40,0x00,0x00,0x00,0x00,0x00,0x00},/*"!",1*/ {0x00,0x00,0x30,0x00,0x40,0x00,0x30,0x00,0x40,0x00,0x00,0x00},/*""",2*/ {0x09,0x00,0x0B,0xC0,0x3D,0x00,0x0B,0xC0,0x3D,0x00,0x09,0x00},/*"#",3*/ {0x18,0xC0,0x24,0x40,0x7F,0xE0,0x22,0x40,0x31,0x80,0x00,0x00},/*"$",4*/ {0x18,0x00,0x24,0xC0,0x1B,0x00,0x0D,0x80,0x32,0x40,0x01,0x80},/*"%",5*/ {0x03,0x80,0x1C,0x40,0x27,0x40,0x1C,0x80,0x07,0x40,0x00,0x40},/*"&",6*/ {0x10,0x00,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},/*"'",7*/ {0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0x80,0x20,0x40,0x40,0x20},/*"(",8*/ {0x00,0x00,0x40,0x20,0x20,0x40,0x1F,0x80,0x00,0x00,0x00,0x00},/*")",9*/ {0x09,0x00,0x06,0x00,0x1F,0x80,0x06,0x00,0x09,0x00,0x00,0x00},/*"*",10*/ ……… } |
Dla znaków 16×8 pikseli jest zdefiniowana druga tablica const uint8_t c_chFont1608[95][16].
Mając tablice generatora znaków i procedurę DrawPoint() potrafiącą „zapalać i gasić” bit w buforze pamięci mikrokontrolera odpowiadający zawartości pamięci RAM sterownika, a tym samym odpowiadający pikselowi na matrycy OLED można napisać procedurę „rysującą” znak w pamięci RAM mikrokontrolera. Pamiętamy, że aby ten znak się wyświetlił trzeba przepisać zawartość DispBuff do pamięci RAM wywołując funkcję void RefreshRAM().
Na listingu 9 pokazano procedurę void DisplayChar() z argumentami:
- x i y – współrzędne początku znaku na ekranie,
- Chr – kod ASCII wyświetlanego znaku,
- size – wielkość znaku 12, lub 16 pikseli,
- mode= 1 wyświetlanie normalne, mode=0 wyświetlanie w negatywie.
Zależnie od wartości argumentu size bajty wzorca są pobierane z tablicy c_chFont1206[95][12] lub z tablicy c_chFont1608[95][16]. Kiedy argument mode jest wyzerowany to dodatkowo wartość pobranego bajtu jest negowana. Potem jest analizowany każdy bit bajtu wzorca i zależnie od jego wartości DrawPoint() zapisuje do bufora DispBuff odpowiednią wartość.
List. 9. Wyświetlenie jednego znaku
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
//****************************************************************************** //wyświetlenie jednego znaku //argumenty: //x,y - współrzędne na ekranie //Chr - kod ASCII znaku //size - rozmiar 12, lub 16 //mode=1 znak wyświetlany normalnie, mode=0 znak wyświetlany w negatywie //******************************************************************************* void DisplayChar(uint8_t x, uint8_t y, uint8_t Chr, uint8_t size, uint8_t mode) { uint8_t i, j; uint8_t chTemp, chYpos0 = y; Chr =Chr - ' '; for (i = 0; i < size; i ++) { if (size == 12) { if (mode) { chTemp = c_chFont1206[Chr][i]; } else { chTemp = ~c_chFont1206[Chr][i]; } } else { if (mode) { chTemp = c_chFont1608[Chr][i]; } else { chTemp = ~c_chFont1608[Chr][i]; } } for (j = 0; j < 8; j ++) { if (chTemp & 0x80) { DrawPoint(x, y, 1); } else { DrawPoint(x, y, 0); } chTemp <<= 1; y ++; if ((y - chYpos0) == size) { y = chYpos0; x ++; break; } } } } |
Mając procedurę wyświetlania jednego znaku o dowolnych współrzędnych można napisać procedurę wyświetlającą łańcuch znaków od określonej pozycji.
Na listingu 10 pokazano procedurę void DispTxt() z argumentami:
- x i y – współrzędne początku znaku na ekranie,
- *txt – wskaźnik na początek bufora z łańcuchem znaków,
- size – wielkość znaku 12 lub 16 pikseli,
- mode= 1 wyświetlanie normalne, mode=0 wyświetlanie w negatywie.
List. 10. Procedura wyświetlania ciągów znaków
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
//********************************************************************************* //wyświetlenie łańcucha znaków - napisu //argumenty //x,y - współrzędne na ekranie //*txt - wskaźnik na początek bufora zwierającego łańcuch znaków ASCII do wyświetlenia //size - wysokość znaków 12, lub 16 pikseli //mode=1 znaki wyświetlane normalnie, mode=0 znaki wyświetlane w negatywie //********************************************************************************* void DispTxt(uint8_t x, uint8_t y, const uint8_t *txt, uint8_t size, uint8_t mode) { while (*txt != '\0') { if (x > (SSD1306_WIDTH - size / 2)) { x = 0; y += size; if (y > (SSD1306_HEIGHT - size)) { y = x = 0; DisplayCls(0x00); } } DisplayChar(x, y, *txt, size, mode); x += size / 2; txt ++; } } |
