microgeek.eu

Post ten (pseudo-artykuł) będzie traktował o uruchomieniu magistrali I2C na mikrokontrolerze STM32F103 na malutkiej, taniutkiej, chińskiej płyteczce ewaluacyjnej w połączeniu z malutkim, chińskim ekranikiem OLED o wymiarach 128x32. Z racji tego, że ekran nie lubi komunikować się z uC, a jedynie przyjmuje dane ( no może oprócz odpowiedzi w formie ACK ), zajmiemy się tylko konfiguracja i wysyłaniem danych.

Do pisania używać będziemy środowiska Atollic 7.0.1 Lite. Kwestie ściągnięcia, instalacji i uruchomienia nie będą tu poruszane.

Obsługa wyświetlacza zostanie uruchomiona z wykorzystaniem bibliotek SPL. Dlaczego nie HAL? SPL wciąż cieszy się sporą popularnością, poza tym kod jest, wbrew pozorom, łatwiejszy do zrozumienia.


Poniżej linki do ebay.com do użytych w tym materiale narzędzi: (proszę zgłaszać nie działające linki)

http://www.ebay.ca/itm/STM32F103C8T6-ARM-STM32-Minimum-System-Development-Board-Module-For-Arduino-D-/112035273840?hash=item1a15d29c70:g:CioAAOSwMNxXaqSp

http://www.ebay.com/itm/IIC-I2C-0-91-128x32-white-OLED-LCD-Display-Module-3-3v-5v-For-Arduino-PIC-/152106706368?hash=item236a4425c0:g:BHQAAOSw6btXSWm3


Podstawowa konfiguracja i rozpoczęcie projektu.


Na poczatku wybieramy opcję FILE->NEW->C PROJECT

01_nowy_projekt.jpg

klikamy NEXT

Następnie nadajemy nazwę dla naszego projektu i wybieramy EMBEDDED C PROJECT z ramki po lewej i ATOLLIC ARM TOOLS z prawej strony

02_nazwa_projektu.jpg

klikamy NEXT

Teraz wybieramy procek z jakim mamy do czynienia. Żeby było szybciej, górze mamy okno filtra i wpiszemy tam nazwę naszego kontrolera, czyli STM32F103c8, w tym czasie w oknie DEVICE powinien pojawić się właściwy i na niego klikamy. Automatycznie wypełnią się podstawowe dane łącznie z informacją o dostępnej ilości pamięci FLASH i RAM.

03_wybor_procka.jpg

klikamy NEXT

Następna opcja to wybór biblioteki i opcje optymalizacji, niczego tu nie zmieniamy

04_opcje_toolchaina.jpg

klikamy NEXT

Wybieramy programator. Z racji, że używam J-LINK'a (w sumie jego klona) na obrazku własnie ten jest wybrany, ale są tam inne opcje i należy wybrać własciwą i odpowiednią dla nas i naszego sprzętu.

05_programator.jpg

klikamy NEXT

I na koniec możemy wybrać konfiguracje z jakimi będziemy pracować, ja zawszę zostawiam jak jest, czyli opcje Debug oraz Release. Z reguły używam tylko opcji Debug, dlatego że tylko pracuję nad projektem, a nie wcielam go w życie w jakimś urządzeniu.

06_wynik_kompilacji.jpg

klikamy FINISH

Na naszym ekranie powinno pojawić się coś w ten desń

07_restore.jpg

klikamy RESTORE, tam gdzie wskazuje strzałka i powinno pojawić się nam to:

08_organizacja_srodowiska.jpg

Strzałkami zaznaczone jest:
1 - Outline, to możemy zminimalizować, raczej nam to nie będzie potrzebne
2 - Information Center, to polecam zamknąć, bo raczej przeglądarka ze stroną informacyjną Atollica nam się nie przyda
3 - Tu przełączamy na CONSOLE, jest to najważniejsze miejsce zawierające wszystko o wynikach naszej kompilacji, czyli błędy, ostrzeżenia
4 - Build Analyzer, .. to niestety nie będzie nam potrzebne, dlatego, że jest to opcja działająca w wersji PRO Atollica.

W edytorze pliku main.c ja z reguły pozbywam się całej wygenerowanej automatycznie zawrtości, dlatego że w większości zawiera dane debbugera i opcje dla zestawów, których nie posiadamy.

09_main_clean.jpg

CTRL-A i DEL


plik main.c

I tu się wszystko zaczyna. Na początek zaczynamy od “inkludowania” najpotrzebniejszych plików systemowych.



Teraz kolej na definicje funkcji które będziemy konstruować




Teraz zajmiemy się utworzeniem tabeli zawierającej zestaw komend odpowiedzialnych za inicjalizację wyświetlacza. ( i tu należą się wielkie podziękowania koledze Antystatycznemu za znalezienie i optymalizację sekwencji inicjalizującej ten wyświetlacz ). Tablica jest static, by była widoczna tylko w tej jednostce kompilacji:




Zadeklarujmy jeszcze bufor, który odzwierciedla całą pamięć graficzną naszego wyświetlaczyka. SSD1306_Width, SSD_Height to makra zdefiniowane w pliku SSD1306.h i definiują szerokość i wysokość ekranu.



Ekran składa się z czterech stron ułożonych poziomo. Każda strona składa się ze 128-miu bajtów. Każdy bajt strony to osiem pikseli (bitów) na ekranie ułożonych w pionie.

ekran.jpg

Jak widzimy na obrazku wpisanie do pierwszego bajtu bufora liczby 1 zaświeci nam punkt w lewym górnym rogu

ekran_0x01.jpg

a jeżeli wpiszemy 0xFF (255, czyli wypełnimy bajt jedynkami) zaświeci się nam pionowa linia po lewej stronie ekranu. Linia ta symbolizuje też wysokość pierwszej strony pamięci wyświetlacza.

ekran_0xFF.jpg

----------------------------------------------------------------------------------------------

Zaczynamy z właściwym programem.

Na początek trzeba zainicjalizować piny odpowiedzialne za I2C. Dla F103 są to PB6 i PB7 - SCL,SDA. Zaczynamy więc od przypisana Definicji Typu Inicjalizacyjnego dla portów wejścia-wyjścia ogólnego przeznaczenia:



Aby móc korzystać z portów GPIO [ i nie tylko ] na mikrokontrolerach z rdzeniem Cortex-M3 [ i nie tylko ] koniecznie trzeba (należy?) zacząć konfigurację portu od uruchomienia sygnału zegarowego dla danego peryferium. W tym przypadku będzie to:



Kolejną rzeczą jaką musimy zrobić to “odblokować” alternatywne funkcje pinów. Jest to nam niezbędne do uruchomienia wbudowanego, sprzętowego I2C:



Następnym krokiem jest uruchomienie magistrali I2C:



I teraz, kiedy mamy już włączone podstawowe elementy uC, możemy skonfigurować właściwe piny. Najpierw struktura inicjalizacji GPIO (ta, którą powołaliśmy do życia chwilę wcześniej):



Ustalmy, z którymi pinami chcemy pracować:




Następnie podajemy informację o tym, że w/w piny będą pracować ze swoją alternatywną funkcją:



(*OD oznacza Open Drain, I2C wymaga aby jego piny pracowały w ten sposób)...to chyba kazdy wie, co? A jeśli nie wie, to RTFM


Kolejnym krokiem konfiguracji pinów jest określenie maksymalnej prędkości, z jaką mogą pracować:



(umawiamy się na 50 MHz, czyli maksimum dla tego procesora. Nie zasilamy układu bateryjnie, więc nie musimy się zbytnio przejmować oszczędzaniem energii).
I na koniec wstępu do początku wcielimy w życie strukturę, którą właśnie skonfigurowaliśmy:



Kolejny etap to konfiguracja I2C.

Jak przy konfiguracji pinów powołujemy do życia strukturę inicjalizacyjną magistralę.



Tak samo jak w przypadku GPIO będziemy ustawiać teraz parametry pracy I2C.

Ustalimy tutaj coś, co możemy nazwać wypełnieniem zegara. Mamy do wyboru dwie opcje 2 i 16/9. Chodzi o stosunek długości stanu niskiego do stanu wysokiego na wyjściu zegarowym szyny. Nas interesuje opcja 2, czyli stosunek stanów zegara wynosi 1:1..


Przypisanie adresu układu MASTER (W naszym przypadku nieistotne):


Włączenie żądania (oczekiwania) na odpowiedź od urządzenia


Teraz decydujemy o długości adresów układów , z którymi będziemy się komunikować. Możliwe opcje to adres 7 bitowy lub 10 bitowy. Większość układów SLAVE posiada 7 bitowy adres. Aby uniknąć pomyłki, zawsze należy zajrzeć do dokumentacji wykorzystywanego układu SLAVE.


W tym miejscu decydujemy w jakim trybie będzie pracowała nasza magistrala ( do wyboru jest jeszcze SMBus_Host i SMBus_Device, ale to nas nie interesuje)


… oraz, co bardzo ważne, ustalamy prędkość z jaką nasze urządzenia będą się komunikować (tu też bardzo ważne jest dokładne przeczytanie Datasheeta naszego wyświetlacza, czy czegokolwiek innego, bo właśnie tam producent podaje wartości z jakimi układ może pracowac. W naszym przypadku jest również ważna errata do DS, gdzie dowiadujemy się, iż nasz oledzik pracuje poprawnie tylko z prędkością 400KHz)


Inicjalizujemy strukturę


i włączamy “peryferium” (cudne słowo)



KONIEC CZĘŚCI PIERWSZEJ, NIE OSTATNIEJ.

Druga część “kursu” (fakt, to wielkie słowo) opisywać będzie inicjalizację ekranu.

Na początek drobne uzupełnienie części pierwszej. Aby ułatwić sobie życie i za każdym razem nie pisać serii bajtów chcąc wyświetlić literę, stwórzmy sobie tablicę znaków (konkretnie liter) do późniejszego wykorzystania. Znaki zawierają się w matrycy 5x8 i są stałej szerokości.

matryca5x8.jpg

Jak widać na załączonym obrazku wzór litery składa się z pięciu bajtów. Każdy z nich odpowiada za pionową linię o wysokości 8 punktów (bitów). I tak 5 bajtów = 5 pionowych linii składających się na literę.


A teraz przejdźmy do bardziej twórczych rzeczy i napiszmy funkcję oled_init.



Na początku musimy wysłać sygnał START



Zgodnie z protokołem następny musi być adres urządzenia odbierającego nasze dane



Teraz musimy wysłać informację czy wysyłane dane będą komendą, czy danymi



Teraz możemy wysyłać dane(komendy) do sterownika



i na koniec, zgodnie z protokołem, generujemy sygnał STOP



Po takim zestawie instrukcji nasz ekran jest gotowy do przyjmowania danych i wyświetlania tego, co się nam zamarzy.

Najpierw jednak musimy nauczyć się czyścić (usuwać) zawartość ekranu. Musimy, dlatego że tuż po inicjalizacji na ekranie (z reguły) pojawią się bliżej nieokreślone hieroglify. Spowodowane jest to tym, że po włączeniu zasilania w pamięci naszego sterownika znajdują się losowe dane.



i tyle …
Nasza funkcja czyszcząca ekran, za pomocą instrukcji memset wpisuje do naszego bufora zera (0x00) i skutkuje to tym, że wszystkie nasze piksele nie są podświetlone, a więc ekran jest czarny i “wyczyszczony”,

Zostaje to wszystko jednak tylko w naszym programie(w zmiennej buffer w pamięci naszego procka), a na ekranie wciąż są śmieci. Należy teraz uzbroić się w funkcję update_screen(). Będzie ona wysyłać zawartość zmiennej buffer do pamięci sterownika naszego wyświetlacza.




Z grubsza mamy już większość rzeczy jakie są nam potrzebne i możemy przejść do właściwego programu i zacząć coś wyświetlać. Po konfiguracji GPIO i I2C powinniśmy wywołać funkcję inicjującą



następnie wstępnie wyczyśćmy bufor ekranu



A więc czas na jakieś bardziej “widowiskowe” działanie.


( to co teraz nastąpi może być szkodliwe dla zdrowia psychicznego programistów, może skutkować zaplutym monitorem i mieć inne negatywne skutki — ale zostało to popełnione z pełną świadomością, że tak się nie robi, że tak się nie pisze i nie powinno tak być )

Wyświetlimy teraz “jakiś” napis na pierwszej stronie wyświetlacza.






KONIEC CZĘŚCI DRUGIEJ … NIE OSTATNIEJ

Super artykuł! A będziesz opisywał skalowanie czcionek?

Antystatyczny pisze:A będziesz opisywał skalowanie czcionek?

Nie przewidywałem tego (na obecną chwilę), dlatego że mam inne plany. A nie chcę tu podawać gotowców, a jedynie pokazać kierunek działań w celu uruchomienia i dalszej pracy już we własnym zakresie. Przy czym niczego nie można wykluczyć ... ( no i Ty musiałbyś mieć czas i cierpliwość na pomoc dla mnie w tym temacie )

No dobra, to może coś wspólnie wykombinujemy. Wszystko rozbija się o ilość wolnego czasu i uruchomionych projektów.

W części trzeciej trochę się wytłumaczę ….

To co nastąpiło powyżej, cały ten chaos i brak organizacji jest celowym zabiegiem. Tak samo pewne niedopowiedzenia lub brak w elementach kodu pewnych strategicznych wpisów. Chciałem zmusić pokolenie Copy&Paste (bez urazy) do samodzielnego myślenia lub do drążenia tematu na forum za pomocą postów... Wyszłoby to wszystkim na dobre, tak dla mnie(też się dopiero uczę), dla pytającego jak i dla wszystkich, którzy w przyszłości trafią na ten temat, próbując bezskutecznie uruchomić taki wyświetlacz na takim lub podobnym “procesorku” (wiem, że to jest mikrokontroler, ale lubię to określenie). Dzięki różnym pytaniom różnych ludzi wyjaśniło by się pewnie wiele drobnych ludzkich pomyłek, “niezrozumień” bądź zwykłych niedopatrzeń i błędów typu rc=-1...

Moim celem jest pokazanie jak zacząć, a nie dostarczyć gotową bibliotekę. Jeśli ktoś ma ochotę pracować z gotowcami to gorąco polecam Arduino lub mbed. Są to bardzo fajne środowiska, których sam czasem używam i dzięki którym można zbudować bardzo ciekawe urządzenia w relatywnie krótkim czasie (prościej mówiąc – bardzo szybko ).

Tutaj chciałbym, razem z Wami, czegoś się nauczyć.

Jeśli będzie taka potrzeba i pomoc na forum nie przyniesie efektu, udostępnię cały projekt z Atollic’a jako paczkę do pobrania. Będzie to dokładnie to samo co powstało podczas pisania tego artykułu, więc z założenia powinno działać bez najmniejszych problemów.

Poniżej zawartość pliku SSD1306.h, potrzebna do uruchomienia.