Uniwersalna płytka dla mikrokontrolerów PIC 8 bit firmy Microchip - instalacja środowiska, pierwsze uruchomienie.

Mój projekt uniwersalnej płytki dla mikrokontrolerów PIC 8 bit firmy Microchip został zakończony i urzeczywistniony . Mam już pierwszą ukompletowaną płytkę. Płytka wyszła w realu fajnie i cieszy moje oko . Mogę zatem przystąpić do jej pierwszego uruchomienia. W artykule pokażę działania od punktu zero czyli od instalacji środowiska i narzędzi niezbędnych do działania z MCU 8 bit firmy Microchip aż do Hello World wykonanej z pomocą mojej płytki. W ramach Hello World pomrugamy sobie diodą LED znajdującą się na płytce .

Do podstawki precyzyjnej na płytce wpiąłem mikrokontroler PIC18F47Q43, czemu ten ?. Do mojej płytki zaaplikujemy prawie dowolny PIC 8 bit w obudowie DIP 28 lub 40 pin, ja wybrałem sobie model z nowej rodziny Q43 , który akurat wpadł mi w oko z racji ciekawych i bogatych peryferiów jak na konstrukcję 8-bitową . Jeśli będziemy mieć problem z nabyciem tego modelu MCU w obudowie DIP 40 pin a możemy mieć bo jest to w sumie nowy model to można nabyć np. PIC18F25Q10 w obudowie 28 pin trochę starszy model ale równie ciekawy . Widziałem go np w TME.

Moja baza sprzętowa :

- Płytka PIC 8 bit z PIC18F47Q43 w obudowie DIP 40 pin

- Programator MPLAB SNAP

- zewnętrzny zasilacz 12 V

Baza programowa, która będzie nam potrzebna do uruchomienia płytki i zabaw z PIC 8-bit :

- MPLABX IDE czyli jedyne słuszne środowisko Microchipa dla PIC 8/16/32 bit

- MPLAB XC8 kompilator Microchipa dla MCU 8 bit

System operacyjny na PC jaki posiadam to LINUX Mint ver 20 64 bit. I do niego odnoszę poczynania w części programowej.

Najpierw zainstalujemy sobie środowisko Microchipa. Jeśli jesteśmy dumnymi posiadaczami systemu LINUX 64-bit musimy doinstalować m.in paczki 32-bit runtime libraries. Ale to jest proste i wszystko opisane jest pod tym linkiem.

W moim przypadku w konsoli systemu Linux wpisuję poniższą sekwencję :

sudo apt-get install libc6:i386 libx11-6:i386 libxext6:i386 libstdc++6:i386 libexpat1:i386

Po doinstalowaniu paczek ściągamy plik instalacyjny środowiska ,który znajdziemy po tym linkiem MPLABX IDE .Ja ściągam plik dla systemu Linux 64 bit ,obecna wersja środowiska to 5.40.

Ściągnięty plik jest w formacie spakowanym. Musimy go rozpakować . Robimy to w prosty sposób klikając na nazwę ściągniętego pliku .

Efekt po rozpakowaniu ściągniętego pliku :

Rozpakowany plik będzie miał rozszerzenie .sh . Teraz z poziomu konsoli Linuxa ustawiamy dostęp do naszego rozpakowanego pliku za pomocą komendy cd .., następnie zmieniamy prawa dostępu do pliku za pomocą komendy chmod u+x, po czym odpalamy instalację . Wszystkie powyższe kroki obrazuje poniższy zrzut z mojej konsoli :

Jeśli wszystko jest w porządku , wyskoczy nam okienko startowe z instalacją środowiska jak powyżej.

Dalej postępujemy zgodnie z komunikatami czyli zatwierdzamy licencję programu. Dochodzimy do okienka jak poniżej (okienko z lewej) gdzie pokazuję moją propozycję instalacji.

Zwieńczeniem instalacji będzie ostatni obrazek , jak poniżej :

Teraz można ponownie uruchomić PC.

Kolejnym krokiem będzie instalacja kompilatora dla MCU 8 bit. Dla wersji 16 i 32 bit to są oddzielne paczki do zainstalowania. My skupiamy się tylko na 8-bitach. Paczkę z kompilatorem XC8 szukamy pod tym linkiem. Ja ściągam wersję dla Linux.

Ściągnięty plik z wersją kompilatora XC8 2.20 wygląda jak poniżej, plik jest w postaci nieskompresowanej  :

Aby zainstalować kompilator XC8 w systemie Linux , odpalamy konsolę linuxową,

podajemy ścieżkę dostępu do ściągniętego pliku za pomocą komendy cd.., zmieniamy prawa dostępu do pliku za pomocą komendy chmod u+x i odpalamy instalację. Poniższe czynności w mojej konsoli wyglądają jak poniżej , po ich wykonaniu pojawi się okienko startujące z instalacją (okienko po lewej) :

Dochodzimy z instalacją do okienka jak poniżej i tam możemy zaptaszkować obie opcje  :

Kolejne okienko gdzie wybieramy tylko Next i nic więcej na nim nie kombinujemy :

Okienkiem jak poniżej finiszujemy instalację :

Wszystkie poniższe czynności i cały proces instalacji jest relatywnie prosty i szybki.

Mamy w naszym systemie zainstalowane środowisko Microchipa i kompilator dla PIC 8 bit ,czas na pierwsze uruchomienie środowiska. Skrót do uruchomienia MPLABX IDE  w systemie Linux Mint znajdziemy w zakładce Programowanie.

Obrazek po pierwszym uruchomieniu będzie wyglądał jak poniżej :

Zamykamy dwie zakładki na belce górnej tak aby zbędne rzeczy nam w oczy nie wchodziły i doprowadzamy do ascetycznego widoku jak poniżej :

Teraz czas na doinstalowanie pluginu MCC (MPLAB Code Configurator) czyli ustawiacza i konfiguratora PIC-owego dla leniwych lub nie mających czasu :). To jest ten smaczek lub inaczej wisienka na torcie , której nie znajdziemy w ekosystemie popularnych AVR-ów. Klikamy sobie obrazki i generuje nam się kod konfiguracyjny dla peryferiów i wszelakich zasobów naszego PIC-a. Jest to narzędzie szczególnie pomocne dla początkujących PIC-użytkowników.

Wybieramy z górnego menu Tools -> Plugins. Odszukujemy plugin MCC i instalujemy go.

Po instalacji pluginu MCC resetujemy środowisko MPLABX IDE ale to wymusi instalator pluginu. Zainstalowany plugin MCC będzie reprezentowany na górnej belce z ikonkami narzędziowymi w postaci ikonki o kształcie odznaki policyjnej z napisem MCC. Od strony programowej mamy wszystko przygotowane aby zadziałać z naszą płytką i wpiętym MCU , w moim przypadku dla przypomnienia jest to PIC18F47Q43

Stwórzmy sobie zatem projekt w MPLABX IDE dla naszego MCU. Tu mała dygresja , z PIC 8-bit nie miałem do czynienia . Przygodę z PIC-ami zaczynałem od 16 bit :). W sumie to jednak bez większego znaczenia ponieważ jak się człowiek nauczy poruszać po dowolnym PIC-u to z dowolnym innym PIC-em da sobie radę. Raz spróbować a potem zostanie wiedza na całe życie :).

Odpalamy MPLABX IDE i wybieramy z belki z ikonkami (druga od lewej) tę o nazwie New Project. W pierwszym okienku jakie zobaczymy zostawiamy domyślne opcje :

W kolejnym okienku wybieramy rodzinę i model naszego MCU . W ostatnim wyborze opisanym Tool zostawiamy domyślny wybór czyli Simulator. Zakładam, że programator mamy jeszcze nie podpięty i nie wiemy jak się on będzie nazywał na liście narzędzi :). Jesteśmy początkujący ,więc wszystko dla nas jest nie do końca jasne (no tak zakładam).

Przechodzimy do kolejnego okienka wybierając Next. W okienku tym wskazujemy jakim kompilatorem chcemy nasz projekt kompilować. Wybór jedynie słuszny XC8.

Przechodzimy do kolejnego okienka w którym podajemy tylko nazwę naszego projektu. W moim przypadku będzie to MyFirstPIC18. Przy instalacji środowiska MPLABX IDE stworzony zostanie domyślny katalog do którego będą pakowane nasze projekty.

Zamykam okienko wybierając Finish. Po lewej stronie w okienku Projects pojawi się nasz projekt , rozwijając jego nazwę zobaczymy strukturę projektu. Na razie w projekcie nie mamy żadnych plików np. main.c etc. To jest pusty szablon projektu. Dla nas ważne są foldery Header Files i Sources Files bo w nich będziemy składować pliki napisane w języku C. Na razie nie mamy w nich kompletnie nic.

Do konfiguracji naszego MCU służy wtyczka MCC, którą wyżej instalowaliśmy. Odpalamy tę wtyczkę "klikając" jeden raz na ikonkę z napisem MCC (ostatnia z prawej ikonka). Po chwili wyskoczy nam okienko w którym wybieramy opcję Zapisz. Po zapisaniu pliku z nazwą pliku konfiguracyjnego MCC z ustawieniami naszego MCU pojawi się główne okno wtyczki MCC a wygląda ono jak poniżej :

Jest pięknie , intuicyjnie, jest komfortowo. Witaj w świecie PIC . Pierwszą czynnością powinno być ustawienie zegara. Wykorzystamy do naszych działań , wewnętrzny zegar ustawiony na maksymalną dostępną częstotliwość czyli 64 MHz. Ustawienia robimy w okienku środkowym System Module czyli na wprost gałek ocznych, prościej już nie można. Ustawiamy tak jak na obrazku poniżej :

Teraz musimy określić co ma robić nasz MCU od tego zależy dalsza konfiguracja.

Chcemy aby dioda LED na płytce mrugała np z okresem 1 s . Do odliczania czasu wykorzystamy Timer, na tym etapie nie wiem jeszcze z jakim numerkiem. Aby uzyskać okres 1 s , zmiana stanu diody LED na przeciwny musi nastąpić co 0.5 s. Do sterowania diodą LED musimy skonfigurować pin nr RA4 jako cyfrowe wyjście. Do tego pinu mamy na mojej płytce podpiętą na sztywno diodę LED.

Zacznijmy od konfiguracji pinu RA4. Okienko z ustawieniami pinów mamy na dole

tam gdzie widzimy las kłódeczek. Odzyskujemy nazwę RA4 i "zapinamy" kłódeczkę w wierszu Output. Efekt wykonania operacji poniżej :

Teraz ważna rzecz, chcąc aby nasz pin był podłączony do sekcji cyfrowej musimy się upewnić czy tak jest. W tym celu przełączamy widok środkowego okienka na Pin Module. W okienku tym znajdują się wszystkie skonfigurowane piny, w naszym przypadku tylko RA4. Powinny jeszcze być tutaj piny do obsługi programatora ale ich nie widzę, ale ten temat zostawiamy na razie. W kolumnie Analog musimy "odptaszkować" kwadracik tak jak poniżęj.

Teraz zajmiemy się ustawieniem Timera przy pomocy którego będziemy odmierzać odcinek czasu i reagować w przerwaniu na jego upłynięcie. Z lewej strony mamy okienko Data Resources. Odszukujemy tam sekcję Timer i rozwijamy ją. Efekt jak poniżej.

Widzimy, że mamy do dyspozycji aż 6 Timerów. Do naszych rozważań wybieramy ten z numerkiem 0 i "klikamy" plusik przy napisie TMR 0. Spowoduje to dodanie TMR0 do okienka Project Recources i jednocześnie pojawi się na środku panel konfiguracyjny wybranego timera. Pierwszą czynnością w okienku konfiguracyjnym naszego timera będzie zaptaszkowanie opcji Enable Timer Interrupt. Chcemy aby informacja o osiągnięciu założonego pułapu odliczania była sygnalizowana w przerwaniu. Drugą czynnością będzie wybranie źródła zegara dla naszego Timera. Źródło ustawiamy na HFINTOSC. Czyli wewnętrzny szybki oscylator. Ostatnią czynnością w konfiguracji timera jest takie ustawienie opcji Clock prescaler i Postscaler abyśmy w okienku Timer Period mogli wpisać wartość 500 ms. Dlaczego 500 ms ? dlatego, że założyliśmy sobie aby nasza dioda LED migała z okresem 1 s. Czyli dioda 500 ms świeci i 500 ms nie świeci i tak w koło Macieju. Jeszcze jedno bo bym zapomniał , w opcji Callback Function Rate wpisujemy wartość 0x1. W wygenerowanym kodzie będzie wygodna funkcja Callback wywoływana co 500 ms i do niej wpakujemy obsługę diody LED. Wszystkie ustawienia timera o których była powyżej mowa na obrazku poniżej :

Kończymy pracę w MCC, mamy wszytko ustawione co nam było potrzebne. "Klikamy" w okienku Project Resources, zakładkę Generate. Coś tam przez chwilę się pomieli i po zakończeniu mieleniu wychodzimy z MCC "klikając" jeden raz w ikonkę MCC. Następnie przełączamy się na widok Projects w lewym górnym okienku zakładka Projects. Rozwijamy sobie w projekcie katalog Sources Files i widzimy, że przybył nam plik main.c i katalog MCC Generated Files a w nim pliki z konfiguracją modułów m.in plik tmr0.c.

Aby zasterować naszą diodą led na pinie RA4, musimy dokonać odpowiedniego zapisu i umieścić go w funkcji callback wygenerowanej przez MCC. Funkcję tę znajdziemy w pliku tmr0.c. Tzn spodziewam się ją tam zastać bo na razie nie wiem na 100 % :) dla przypomnienia pisząc ten artykuł odkrywam po raz pierwszy MCU 8 bit Microchipa.

Otwieram zatem plik tmr0.c i szukam funkcji callback. Znalazłem ją , jej ciało na obrazku poniżej zaznaczone na niebiesko :

Do tej funkcji callback, która jest wywoływana w przerwaniu co 500 ms musimy wstawić zapis realizujący nam zmianę stanu na przeciwny na pinie RA4, czyli tam gdzie podłączona jest nasza dioda LED. Skorzystamy tutaj z zapisu do "toglowania" pinem jaki proponuje nam wygenerowany przez MCC kod. Kod ten  znajdziemy  w katalogu Header Files , katalog MCC Generated Files i plik pin_manager.h. Zapis do "toglowania" pinem na obrazku poniżej :

Jak widzimy MCC daje nam zbiór prostych definicji do obsługi pinów , które możemy ale nie musimy wykorzystać w projekcie. Wpisujemy zatem do funkcji callback zapis "toglujący" pinem RA4. Ciało funkcji będzie docelowo wyglądać jak poniżej :

Skompilujmy nasz program (ikonka młoteczka szewskiego) i zobaczmy czy wszystko jest w porządku. Okazuje się, że nie jest, nasza definicja "toglująca" pinem wstawiona do funkcji callback generuje błąd. Plik tmr0.c nie widzi naszej definicji. Rozwiązanie jest proste, musimy dołączyć plik nagłówkowy pin_manager.h lub mcc.h. Po dołączeniu pliku kompilacja będzie prawidłowa. "Warningi" sygnalizacyjne widoczne poniżej są nieistotne do poprawnego działania programu ale sugerują , że np musimy uruchomić działanie timera wywołując funkcję TMR0_StartTimer().

Zaglądamy do pliku main.c i tam dodajemy funkcję TMR0_StartTimer(), która odpali nam nasz timer. Dodatkowo musimy odkomentować zapis dotyczący odblokowania przerwań w MCU. Docelowa zawartość pliku main.c wygląda jak poniżej :

To już w zasadzie koniec, teraz trzeba wgrać nasz program do MCU i zobaczyć czy coś zadziała. Ciekawy jestem czy coś nie wybuchnie nam. Na wszelki wypadek zakładam okulary ochronne. Podłączam programator MPLAB SNAP do PC i do płytki po czym podłączam zasilacz do płytki. Nic nie wybuchło jest git. Na programatorze pali się zielona dioda na mojej płytce czerwona sygnalizująca podanie zasilania. Ponieważ przy tworzeniu projektu zamiast wybrać programator wybraliśmy symulator dlatego nie widzimy aktywnej ikonki do zaprogramowania MCU (zielona strzałeczka w dół). Aby wskazać nasz programator, na nazwie projektu otwieramy prawym klawiszem myszki menu i na końcu wchodzimy w wybór Properties. W okienku które nam wyskoczy zaznaczamy Conf.(default), zobaczymy obrazek jak poniżej :

Ptaszkujemy opcję Show All i wyszukujemy nasz podłączony programator (tam gdzie jest napis Simulator, rozwijamy okno wyboru) . znajdujemy naszego SNAP-a z jego numerem ID. U mnie to wygląda jak poniżej :

Zatwierdzamy ustawienia "klikając" Apply i potem OK. Ikonki do programowania zostaną aktywowane co widać poniżej.

Wgrywamy nasz program do MCU za pomocą ikonki z obrazkiem strzałka w dół.

Sam jestem ciekawy czy coś nie poknociłem o czymś nie zapomniałem i czy dioda zamiga :). Wszytko OK, dioda poprawnie miga na mojej płytce, rozjaśnia miło półmrok, soczystym słonecznym kolorem. Diody LED zaaplikowałem na płytkę w kolorze żółtym. Na filmiku poniżej zobaczymy efekt końcowy (filmik zrobiony na szybko telefonem):

W sumie jestem zadowolony z projektu. Płytka wyszła fajnie, działa. No przynajmniej ta jedna dioda LED :). Zaletą mojej płytki jest prosta konstrukcja łatwa do polutowania. Najmniejszy element SMD w obudowie 1206 czyli nawet ślepa kura to polutuje. Niski koszt wykonania. Uniwersalność co do typu PIC 8 bit , zainstalujemy tutaj PIC-e w obudowie DIP 28 lub DIP40. Moje pierwsze wrażenie z obcowania z konstrukcją PIC 8-bit było bardzo pozytywne. Wszytko wydaje się być bajecznie proste i przyjazne użytkownikowi. Kod generowany przez MCC jest wysokiej jakości i przejrzysty. Można się z niego uczyć i czerpać garściami wiedzę. Już na dzień dobry poznajemy jak wyglądają zapisy sterujące pinami, konfiguracja Timera podana w kodzie jak na tacy etc. Zwróćmy też uwagę , że nie napisaliśmy tak naprawdę ani jednej linijki kodu a cel osiągnięty z powodzeniem. Można i tak jak ktoś leniwy :). Spotkałem się kiedyś z opinią , że jak ktoś pozna MCU 32 bit to potem nie będzie się chciał cofnąć do 8-bit. Moim zdaniem to nie prawda. Cofnięcie się do 8-bit jest fajnym transcendentalnym przeżyciem i może dać dużo zabawy i frajdy :). Po za tym konstrukcje 8-bit mają tę podstawową zaletę, że posiadają proste peryferia , które nie są tak mocno rozbudowane i skomplikowane jak w 32-bitach. Powoduje to, że w 8-bitach nie ma potrzeby posługiwać się bibliotekami typu HAL ,które skutecznie stępiają mózg ale możemy czerpać satysfakcję z programowania przy użyciu rejestrów. Moim zdaniem więcej jesteśmy się w stanie nauczyć zaczynając przygodę z MCU na 8-bitach (AVR czy PIC) niż na 32-bitach. Howgh !.

Pozdrawiam

PICmajster
picmajster.blog@gmail.com