Opiszę tutaj krok po kroku instalację, konfigurację oraz użycie darmowego kompilatora SDCC do tworzenia programów na mikroprocesory PIC.
Całość będzie w formie szczegółowego tutoriala.
Ze względu na długość całości tutorial podzielę na osobne tematy.
W dalszych częściach postaram się opisać użycie większości popularnych peryferiów, bibliotek, w SDCC na przykładzie PIC18F2550.
To ile ostatecznie wyjdzie części i co zostanie omówione zależy w dużej mierze też od tego jakie będą komentarze. Oczywiście przyjmuję sugestie, więc jak ktoś chce bym omówił np. komunikacje PICa po I2C z wybraną kostką/modułem, to proszę o informacje.
Spis części (osobnych tematów) tutoriala
Tutorial podzielony jest na osobne tematy i tutaj znajdują się do nich linki.
Część 1 - Konfiguracja środowiska pracy
https://www.elektroda.pl/rtvforum/topic3635522.html#18304424
Część 2 - Blink LED, piny IO, cyfrowe wejścia i wyjścia
https://www.elektroda.pl/rtvforum/topic3647884.html#18389188
Część 3 - Ustawienia oscylatora. Oscylator wewnętrzny, zewnętrzny, rezonator kwarcowy, PLL
https://www.elektroda.pl/rtvforum/topic3657704.html
Część 4 - Timery, przerwania
https://www.elektroda.pl/rtvforum/topic3676645.html#18580858
Część 5 - Obsługa wyświetlacza siedmiosegmentowego
https://www.elektroda.pl/rtvforum/topic3676650.html#18580877
Część 6 - Sterownik wyświetlacza LED MM5450
https://www.elektroda.pl/rtvforum/topic3845301.html
Spis treści będzie uzupełniany wraz z pisaniem przeze mnie kolejnych części.
Ten temat to jest część 1, czyli Konfiguracja środowiska pracy. Zaczynamy.
Co jest czym?
SDCC (Small Device C Compiler) to darmowy, open source kompilator dla wielu rodzin 8 bitowych mikroprocesorów, w tym m. in.:
- PIC16F/PIC18F (którymi zajmiemy się w tym temacie)
- 8031, 8032, 8051, 8052 Intela
- DS80C390 od Maxim/Dallas
- 68HC08 i 68HCS08 od Motorola/Freescale/NXP
- STM8 od STMicroelectronics
- PDK14 i PDK15 od Padauk Technology
- Zilog Z80, Z180, eZ80
SDCC jest dostępny na licencji GPL. Wspiera platformy Windows, Linux i macOS
GPUtils jest to zbiór narzędzi dla mikrokontrolerów PIC od Microchipa. Obejmuje programy takie jak gpasm, gplink, gplib. Dostępny jest na licencji GPL, na platformach Windows, Linux oraz macOS. GPUtils jest wymagane przez SDCC jeśli chcemy kompilować wsad dla PICów.
Co tutorial będzie obejmować?
W tym tutorialu (oraz w jego kolejnej części, która jest w drodze) postaram się zamieścić:
- krok po kroku instalacje SDCC wraz z ustawieniem ścieżek PATH na Windowsie
- krok po kroku instalacje GPUtils wraz z ustawieniem ścieżek PATH na Windowsie
- krok po kroku instalacje pakietu SDCC dla PIC wraz z ustawieniem ścieżek PATH na Ubuntu
- prezentacja metody jak sprawdzić czy SDCC/GPUtils jest poprawnie skonfigurowane
- krótki opis jak kompiluje się programy z pomocą SDCC
- szczegółowe przykłady programów zrobionych w SDCC dla PIC18F2550 z pomocą bibliotek dostępnych w samym kompilatorze oraz w sieci
Tutorial będzie praktyczny, czyli bardziej będę się skupiać na tym jak otrzymać rezultaty niż na tym jak co wewnętrznie działa. Umieszczane tutaj instrukcje będą w miarę możliwości szczegółowe (bez pomijania kroków itp), ale jednak oczekuję, że czytelnik też jest w stanie korzystać z wyszukiwarki i innych źródeł wiedzy. I przede wszystkim - tutorial nie zastępuje szkoły i książek!
Windows - Instalacja SDCC i GPUtils z pomocą instalatorów
Strona domowa SDCC umieszczona jest na SourceForge. Znajduje się na niej dokumentacja SDCC, manual w PDF, linki do pobrania oraz sam kod źródłowy kompilatora (jest on open source).
http://sdcc.sourceforge.net/index.php
Samo SDCC możemy pobrać stąd:
https://sourceforge.net/projects/sdcc/files/
Opiszę tutaj dokładnie proces instalacji. Na początek wchodzimy w powyższy link.
Wybieramy najnowszą wersję (na moment pisania jest to 3.9.0 z 2019-04-15):
Rozpoczynamy proces instalacji:
Standardowo, czytamy całą Licencję, SDCC jest na licencji GPL v2.
Wybieramy Menu Start Folder oraz pełną wersję instalacji:
Tutaj warto zmienić miejsce do którego zainstalujemy SDCC. Domyślnie instalator chce umieścić kompilator w "C:/Program Files/", ale ja na Windowsie doświadczyłem potem problemu z uruchamianiem SDCC przez spację w tej nazwie, więc najwygodniej jest zainstalować całość do np. "C:/SDCC/".
Czekamy aż proces instalacji SDCC się zakończy:
Na końcu instalator dodaje automatycznie ścieżkę SDCC do zmiennej środowiskowej PATH:
Teraz musimy zainstalować osobno GPUtils, w których znajduje się gpasm.exe niezbędne do skompilowania wsadu dla PICa.
GPUtils ma również swoją stronę na Sourceforge:
https://gputils.sourceforge.io/
Pobrać je można stąd:
https://sourceforge.net/projects/gputils/files/
Rozpoczynamy instalacje:
GPUtils też jest na licencji GPL. Czytamy licencję i ją akceptujemy:
Wybieramy pełną wersję instalacji:
Czekamy aż proces instalacji się zakończy:
Na koniec, tak jak z SDCC, instalator daje nam opcje automatycznego dodania folderu GPUtils do ścieżek systemowych:
Windows - Alternatywny sposób instalacji SDCC i GPUtils - Pinguino Compilers
Pinguino (darmowy, otwarty odpowiednik Arduino dla PIC) posiada w swoich zasobach gotową do użycia paczkę kompilatorów przeznaczonych dla 8 i 32 bitowych PICów. Znajduje się w niej też SDCC, wraz z całym potrzebnym osprzętem. Ta paczka zawiera już w sobie GPUtils (gpasm.exe, i inne), więc nie trzeba instalować ich potem osobno.
Można ją za darmo pobrać z githuba (są tam też pliki binarne):
https://github.com/PinguinoIDE/pinguino-compilers
Jest to pełen zestaw kompilatorów (SDCC i MIPS):
Są tam nawet pliki binarne dla systemu Linux:
Na wszelki wypadek umieszczam tutaj kopię zapasową powyższego repozytorium (stan na czas pisania tego postu):
Windows 32:
Windows 64:
Linux 32:
Linux 64:
Instalacja w ten sposób polega tylko na wypakowaniu paczki tam gdzie chcemy, tyle że trzeba zmienną środowiskową %PATH% ustawić ręcznie. W przeciwnym razie system nie będzie rozpoznawać polecenia sdcc, itp.
Windows - Ustawienie zmiennej środowiskowej PATH dla SDCC
Jeśli pobraliśmy SDCC z repozytorium Pinguino-compilers bądź w jakiś inny sposób bez użycia instalatora to może być potrzebne ręczne dodanie ścieżki do SDCC do zmiennej PATH. Jest to potrzebne by Windows rozpoznawał komendę sdcc będąc w dowolnym folderze.
Aby to zrobić, najpierw zapisujemy sobie w jakim folderze mamy zainstalowane kompilatory (a dokładniej: jaka jest pełna ścieżka do bin z folderu SDCC). Przykładowo:
A następnie dodajemy ją do %PATH%, przez interfejs Windows lub przez linię komend.
Sposób 1: Dodanie folderu do PATH poprzez interfejs okienkowy Windowsa
Na każdej wersji jest dość podobnie. Na Windows 10 najpierw otwieramy właściwości komputera:
Następnie otwieramy "Zaawansowane ustawienia systemu", zakładkę "Zaawansowane", klikamy tam przycisk "Zmienne środowiskowe":
Teraz widzimy edytor wszystkich zmiennych środowiskowych na systemie Windows. Wybieramy tam zmienną Path:
Klikamy ''''Edytuj'''' by przejść do edytora wszystkich ścieżek z tej zmiennej. Każda z nich jest tutaj osobno, nie musimy stosować średników. Nową dodajemy z pomocą przycisku ''''Nowy'''', po czym musimy zatwierdzić zmiany klikając ''''Ok''''.
Sposób 2: Dodanie zmiennej do PATH poprzez konsolę cmd
Mamy tam dostępną komendę set NAZWA=wartość, która ustawia zmienną o danej NAZWIE na daną wartość.
Można też tam wyświetlić bieżącą wartość zmiennej wpisując %NAZWA%.
Możemy zatem użyć tych dwóch mechanizmów na raz by dopisać kolejną ścieżkę do ścieżek systemowych.
Wpisujemy zatem w konsoli:
set PATH=%PATH%;ŚCIEŻKA_DO_SDCCgdzie ŚCIEŻKA_DO_SDCC to pełna ścieżka do SDCC, do folderu bin, pełna.
Tyle wystarczy by dodać ścieżkę do PATH i będzie ona pamiętana po ponownym uruchomieniu komputera.
Analogicznie postępujemy z GPUtils. Też dodajemy ścieżkę do PATH (o ile jej tam nie ma).
W przypadku Pinguino-Compilers nie musimy dwukrotnie dodawać ścieżek, gdyż tam i sdcc.exe i gpasm.exe jest w jednym folderze:
Windows - Sprawdzenie instalacji SDCC oraz GPUtils
Jeśli wszystko poszło dobrze (i ścieżka folderu SDCC została dodana do PATH) to w konsoli komend rozpoznawane powinno być polecenie sdcc. Można to sprawdzić po prostu wpisując w niej komendę sdcc, bądź np. sdcc -v by wyświetlić zainstalowaną wersję kompilatora.
W przypadku wersji z Pinguino wynik komendy sdcc -v może się troszkę różnić:
Analogicznie sprawdzamy czy poprawnie widoczne są narzędzia z GPUtils, a zwłaszcza gpasm.exe. Wpisujemy w konsoli komendę gpasm -v.
Ubuntu - Instalacja SDCC/GPUtils
Ktoś mógłby by pomyśleć, że SDCC/GPUtils można zainstalować na Ubuntu poprzez apt-get. Nic bardziej mylnego!
Rzeczywiście, apt-get pozwala ściągnąć SDCC na Ubuntu, ale tak ściągnięte SDCC nie wspiera niestety PICów.
W spoilerze zrzuty ekranu z instalacji ''''niepełnego'''' SDCC przez apt-get:
Spoiler:
Początek instalacji poprzez apt-get:
Końcówka instalacji:
Początek instalacji poprzez apt-get:
Końcówka instalacji:
Poniższy zrzut ekranu pokazuje jak kończy się taka instalacja SDCC na Ubuntu - po sprawdzeniu wersji z pomocą komendy "sdcc -v" widać, że PIC nie są wspierane, a sama komenda od kompilacji skutkuje błędem "cannot generate code for target ''''pic16''''".
Takie SDCC nam się nie przyda. Problem wynika stąd, że część plików powiązanych z PICami nie jest na licencji kompatybilnej z polityką repozytoriów apt-get, więc nasz kompilator musimy ściągnąć ręcznie.
Więc SDCC dla Ubuntu pod PICe musimy ściągnąć ręcznie, albo z samej strony SDCC, albo z wspomnianego już wcześniej Pinguino-compilers.
Ja tutaj opiszę jak ściągnąć SDCC z Pinguino-compilers (jest tam już skompilowane, i na 32-bitowego i na 64-bitowego Linuxa).
Otwieramy na Ubuntu odpowiednie repozytorium Github, skąd można pobrać Pinguino compilers, tutaj:
https://github.com/PinguinoIDE/pinguino-compilers
Pobieramy całe repozytorium, aczkolwiek przydadzą się nam tylko pliki binarne dla p8 (8 bitowe) dla Linuxa 64-bitowego.
Zapisujemy plik archiwum.
Wypakowujemy z niego tylko co jest dla nas potrzebne (tutaj: folder p8 z folderu linux64):
Wybieramy jakiś folder gdzie to wypakujemy. Ja wypakowałem do /home/test/sdcc/ (tam utworzony został katalog p8 a w nim bin). W zasadzie nie jest takie istotne gdzie to umieścimy, bo potem i tak skonfigujemy Linuxowe PATH by wskazywało do folderu bin z kompilatorem.
Po wypakowaniu widzimy, że mamy już pliki wykonywalne sdcc, gpasm i innych potrzebnych narzędzi.
Ubuntu - Ustawienie zmiennej środowiskowej PATH dla SDCC
Ustawienie tej ścieżki na systemach linuxowych wbrew pozorom nie jest aż tak analogiczne do systemu Windows jakby to się mogło zdawać.
W moim przypadku przypisanie nowej wartości do PATH z poziomu konsoli Ubuntu się nie sprawdziło, gdyż system zapominał jej wartość po ponownym uruchomieniu.
Czyli samo set PATH=%PATH%;/nowa/sciezka/ nie wystarczy.
Poprawnie zadziałała u mnie dopiero metoda edycji pliku /etc/environment.
1. Otwieramy ten plik jako administrator:
2. Dopisujemy tam ścieżkę do SDCC:
3. Ponownie uruchamiamy system
Od tego momentu po każdym włączeniu Ubuntu powinien znać ścieżkę do SDCC.
Ubuntu - Weryfikacja czy instalacja przebiegła pomyślnie
Tak jak w przypadku Windows.
Instalację SDCC/GPUtils możemy sprawdzić wpisując w konsoli komendy sdcc -v oraz gpasm -v.
Zrzut ekranu pokazuje poprawny, oczekiwany wynik.
Warto zwrócić uwagę, że komenda sdcc -v pokazuje wprost, że ta wersja SDCC wspiera pic16/pic14.
Pierwsza testowa kompilacja
Jak już wiemy, że SDCC oraz GPUtils dodane jest do ścieżek systemowych, to możemy sprawdzić czy sam proces kompilacji działa.
Bierzemy jakiś prosty kod, przykładowo blink dla PIC18F2550:
Kod: C / C++
Zaloguj się, aby zobaczyć kod
(W dalszej części tutoriala ten kod zostanie dokładniej umówiony).
Zapisujemy go w pliku z rozszerzeniem .c w wybranym przez nas folderze, np. na D:/PICProjects/SDCCTest/.
Otwieramy konsolę, przechodzimy do tego folderu z pomocą komendy cd:
I wykonujemy kompilacje z pomocą SDCC z pomocą polecenia:
sdcc.exe --use-non-free -mpic16 -p18f4550 p18f4550_blink.c
Rezultatem powinien być gotowy do wgrania na PICa plik .hex.
Jest to poprawny, gotowy do wgrania na PICa wsad:
Tak właśnie wygląda wsad na PIC po skompilowaniu w formacie .hex.
Jeśli kompilacja się nie powodzi i otrzymujemy błąd "Nazwa ''''gpasm.exe'''' nie jest rozpoznana" to znaczy, że albo nie mamy ustawionej ścieżki %PATH% do folderu bin z GPUtils, albo wcale GPUtils nie zainstalowaliśmy.
Przyglądamy się poleceniom SDCC
Mamy już kompilator zainstalowany. Teraz przeanalizujemy dokładnie komendę z pomocą której kompilujemy kod C na gotowy plik .hex dla PICa.
W najprostszej postaci wygląda ona tak:
sdcc.exe --use-non-free -mpic16 -p18f4550 p18f4550_blink.cTylko tyle wystarczy, by skompilować nasz program.
p18f4550_blink.c - jest to oczywiście nazwa naszego pliku z kodem. Może być w zasadzie dowolna, ale warto zachować w niej rozszerzenie .c.
Przełącznik --use-non-free pozwala kompilatorowi na użycie bibliotek od Microchipa przeznaczonych dla PIC i jest tutaj w większości przypadków potrzebny.
mpic16 oznacza tutaj, że kompilujemy pod rodzinę PIC18F. Tak, mpic16 oznacza 18F - te 16 bierze się tam stąd, że rdzeń rodziny PIC18F ma 16 bitowe słowo instrukcji.
(źródło: datasheet PIC18F4550)
Analogicznie, istnieje opcja mpic14 . Z jej pomocą kompilujemy dla rodziny PIC16F:
sdcc.exe --use-non-free -mpic14 -p16f628 p16f628_blink.c
mpic14 oznacza tutaj, że kompilujemy pod rodzinę PIC16F. Tak, mpic14 oznacza 16F - te 14 bierze się tam stąd, że rdzeń rodziny PIC16F ma 14 bitowe słowo instrukcji.
(źródło: datasheet PIC16F628A)
Użycie odpowiedniej opcji (mpic14 vs mpic16) jest niezbędne, m. in. od niej zależy to jakie pliki #include są dostępne (przykładowo pic18fregs.h jest tylko na rodzinie PIC18F).
Opcja mpic14 wspiera też rodzinę PIC12F*, np PIC12f675.
Kompilacja projektu złożonego z kilku plików w SDCC
Teraz jeszcze należy się zastanowić jak skompilować projekt złożony z kilku plików z kodem źródłowym.
Załóżmy, że mamy dwa pliki.
- test_blink_file.c
- p18f4550_blink_multipleFiles.c
Na pewno nie można zrobić tego tak:
sdcc.exe --use-non-free -mpic16 -p18f4550 p18f4550_blink_multipleFiles.c test_blink_file.cSkutkuje to dość niepokojącym błędem o treści "at 1: warning 120: cannot compile more than one source file. file ''''test_blink_file.c'''' ignored".
Ale to nic złego - SDCC jak najbardziej może kompilować projekt złożony z wielu plików, po prostu trzeba rozbić kompilację na osobne etapy.
sdcc.exe --use-non-free -mpic16 -p18f4550 -c test_blink_file.c
sdcc.exe --use-non-free -mpic16 -p18f4550 p18f4550_blink_multipleFiles.c test_blink_file.oW tym sposobie osobno kompilujemy każdy dodatkowy plik z kodem, a na końcu podajemy plik z funkcją main i rezultaty poprzednich kompilacji.
Bardzo ważne jest, by plik z funkcją main() podać tutaj jako pierwszy.
Można cały proces jeszcze bardziej rozdzielić - skompilować osobnym poleceniem każdy plik z kodem (też osobno plik z main()), a potem tylko je połączyć. Wymaga to jednak jeszcze ręcznego dopisania pliku .lib z funkcjami dla PIC18F.
sdcc.exe --use-non-free -mpic16 -p18f4550 -c test_blink_file.c
sdcc.exe --use-non-free -mpic16 -p18f4550 -c p18f4550_blink_multipleFiles.c
sdcc.exe --use-non-free -mpic16 -p18f4550 p18f4550_blink_multipleFiles.o test_blink_file.o libc18f.libOrganizacja pracy - skrypty do kompilacji
Oczywiście nie trzeba zawsze ręcznie wpisywać komend do konsoli. Można zrobić skrypt wsadowy .bat (na Windowsie; na Linuxie .sh) który wykona za to co chcemy.
Skrypt .bat to po prostu dokument tekstowy i tworzy się go tak jak plik txt:
Wpisujemy jego nazwę (wraz z rozszerzeniem .bat):
W razie takiego komunikatu potwierdzamy, że plik ma mieć rozszerzenie .bat:
Następnie edytujemy go jako plik tekstowy.
Do skryptu można wpisać te komendy które normalnie wykonuje się w konsoli, ale nie trzeba się martwić o ścieżki - wystarczy podać względne. Czyli jak plik z kodem jest w tym samym folderze co skrypt to podajemy tylko nazwę pliku z kodem, itp.
W skryptach można też użyć echo by wyświetlić komunikat oraz pause by zatrzymać okienko przed chowaniem.
Finalnie, jeden z najprostszych skryptów do kompilacji wygląda tak:
echo ''''Starting compilation script...''''
sdcc.exe --use-non-free -mpic16 -p18f2550 p18f2550_blink.c
pauseUruchomienie go włącza okienko konsoli i w nim proces kompilacji. Komenda ''''pause'''' sprawia że po kompilacji okienko zostaje i czeka zamknięcie, dzięki czemu możemy sprawdzić czy kompilacja się powiodła.
Alternatywa dla pisania kodu w Notepadzie - SDCC w Code Blocks
Użycie zintegrowanego środowiska do pisania kodu nie jest tu konieczne, lecz może być dość wygodne. Dlatego pokażę teraz jak można skonfigurować Code Blocks do współpracy z kompilatorem SDCC i pisania programów pod PICe.
SDCC i GPUtils należy mieć zainstalowane wcześniej wedle instrukcji z tego tematu!
Zaczynamy od ściągnięcia Code Blocks:
http://www.codeblocks.org/downloads
Na tym etapie możemy ściągnąć czystą wersję Code Blocks (bez żadnego kompilatora), jak również tą z MingW (tyle, że sam kompilator MingW się nam nie przyda - i tak będziemy korzystać z SDCC. To jedynie na wypadek gdybyśmy chcieli używać CB też do programowania na Windowsa).
Ale podkreślam, że Code Blocks pozwala mieć różne kompilatory jednocześnie (MingW nie będzie kolidować z SDCC).
Instalujemy Code Blocks poprzez instalator Windowsa.
Code Blocks też oczywiście jest na licencji GPL.
Wybieramy pełną instalację; to i tak tylko raptem 250MB.
Przy pierwszym uruchomieniu Code Blocks automatycznie wykrywa to jakie mamy kompilatory. Powinien wykryć obecność SDCC, ale nawet jeśli go nie wykryje to żaden problem - można ręcznie ustawić ścieżkę w ustawieniach.
Swoją drogą powyższy obrazek pokazuje jak dużo kompilatorów wspiera Code Blocks.
Po otwarciu IDE otwieramy Settings->Compiler:
Wybieramy tam SDCC (bądź pełną nazwą: Small Device C Compiler; zależy od tego jaką wersję Code Blocks mamy):
Tam są ustawienia globalne dla tego kompilatora.
W Toolchain executables upewniamy się, czy Compiler''''s installation directory poprawnie wskazuje na folder w którym jest SDCC (ale nie bezpośrednio na bin, tylko na folder który zawiera bin):
Potem przechodzi do Other settings, gdzie klikamy przycisk Advanced options.... Trzeba będzie tam coś ustawić.
Potwierdzamy, że wiemy co robimy:
Tutaj zaradzimy coś na popularny problem z rozszerzeniem plików wynikowych (.o versus .rel). Code Blocks oczekuje plików .rel, a w rzeczywistości mają one rozszerzenie .o. Aby to naprawić wpisujemy do pola "Object file extension (eg. o)" treść ''''o'''', zamiast ''''rel'''' które jest tam domyślnie.
Po tych zmianach koniecznie restartujemy Code Blocks! Wyłączamy go całkiem i włączamy ponownie!
Jeśli nie zmienimy oczekiwania rozszerzenia ''''rel'''' na ''''o'''' to w trakcie kompilacji otrzymamy błąd "at 1: warning 119: don''''t know what to do with file ''''objReleasecb_sdcc_test.rel''''. file extension unsupported":
Konfiguracja Code Blocks zakończona, teraz możemy utworzyć nowy projekt.
Klikamy File - > New Project. Tam wybieramy typ projektu ''''Empty Project'''':
Przechodzimy kolejne kroki ''''Empty Project Wizard'''':
Ustawiamy nazwę i lokację naszego projektu na dysku.
Wybieramy kompilator którego użyjemy, czyli oczywiście SDCC:
Wyłączamy konfigurację Debug:
Projekt jest gotowy. Jeśli są jakieś ostrzeżenia, to je ignorujemy.
Dodajemy nowy plik do folderu poprzez File -> New -> Empty File:
To utworzy nam pusty plik. Wklejamy do niego nasz kod.
Teraz musimy skonfigurować nasz projekt pod konkretnego PICa.
Otwieramy Project->Build Options.
Tam włączamy znany nam już z linii komend przełącznik --use-non-free:
Troszkę nad nim zaznaczamy pod którą rodzinę PICów kompilujemy (tez już wcześniej omawiane -mpic14 i -mpic16):
W sąsiedniej zakładce (Other compiler options) dopisujemy jeszcze przełącznik/wybór konkretnego PICa pod który piszemy. W przypadku tego przykładu to jest -p18f4550.
Jeszcze tylko w Linker Settings musimy ręcznie wskazać odpowiednie biblioteki, tutaj libc18f.lib. Jest ona potrzebna dla funkcji delay1ktcy. Jeśli chcemy zrobić własnego delaya, to może ona nie być potrzebna.
Jeszcze pozostało zrobić jedno - zmienić rozszerzenie wynikowego pliku kompilacji z .exe na .hex. Wykonujemy to w Project/target options -> Build targets.
Od tego momentu projekt powinien się poprawni kompilować w Code Blocks.
Wynik kompilacji (plik hex) powinien być w folderze /bin/Release w folderze naszego projektu.
Co będzie nam potrzebne by zacząć z PICami?
Przede wszystkim potrzebny jest programator.
Programator służy do wgrania wsadu (skompilowanego kodu, .hex) z komputera na PICa.
Oczywiście programator jest potrzebny tylko na czas programowania mikrokontrolera, potem można go odłączyć a nasz program, wsad będzie dalej działać.
Chyba najbardziej praktyczny teraz będzie zakup programatora PICKIT3, aczkolwiek ja preferuję PICKIT2 gdyż ten drugi jest zdolny do zasilania układu z mikrokontrolerem, a PICKIT3 niestety wymaga osobnego podania zasilania do PICa.
PICKIT2 nie jest już dawno wspierany, ale istnieją inicjatywy open source takie jak PICKIT2 Device Editor czy tam pic32prog które pozwalają z jego pomocą programować też nowsze PICe.
Jest jeszcze PICKIT4 ale z niego nie korzystałem, więc się nie wypowiem.
Oczywiście są też inne programatory dla PIC, ale by nie komplikować zbędnie w tym temacie użyjemy PICKIT3:
Tutaj chciałbym zwrócić uwagę na to, że PICKIT3 naprawdę wspiera dużo układów. Nawet AVRy:
(Powyższy zrzut ekranu pochodzi z MPLAB IPE, sam osobiście programowania Atmeg z pomocą PICKIT3 jeszcze nie testowałem).
Dla PICKIT3 potrzebny też będzie kabelek mini USB:
Całość mojego tutoriala będzie wykonana z PIC18F2550 na płytce stykowej, czyli nie będzie potrzebne nam żadne PCB. Wszystko złożymy na tzw. breadboard:
Kabelki do płytek stykowych (tzw. jumpery, zworki). Nimi zrobimy połączenia:
Do płytki trzeba będzie podprowadzić zasilanie 5V. Ja je wezmę z USB, poprzez te złącze mikro USB dla płytki stykowej:
I dodatkowo - kabelek mikro USB.
Oczywiście potrzebny też będzie PIC - ja wybrałem PIC18F2550. Więcej o nim w dalszej części tutoriala.
Teraz rzeczy potrzebne na początek dla PICa:
Rezytory 10k (jeden dla pinu RESET od PICa, też jako pull up/down przycisków), kondensator mniej więcej 220nF dla pinu VUSB, rezystory jakieś 1k dla diod LED, standardowo jakiś kondensator elektrolityczny i 100nF ceramiczne które podłączymy na zasilanie.
Kondensatory ceramiczne/elektrolityczne a PIC
Tutaj chciałbym tylko podkreślić, że użycie kondensatorów elektrolitycznych i ceramicznych w celu filtracji/odsprzęgania zasilania PICa (a w zasadzie dowolnego układu, nie tylko mikrokontrolerów) jest bardzo, niezwykle ważne!
Każdy pin zasilania mikrokontrolera (nawet, jeśli ma on kilka VDD czy AVDD) powinien mieć kondensator rzędu 100nF ceramiczny podłączony do masy, najbliżej samego mikrokontrolera jak tylko się da.
Dodatkowo w pobliżu układu warto zastosować większy kondensator elektrolityczny.
Wszystko to ma na celu eliminacje zakłóceń na liniach zasilania, które mogą pochodzić zarówno z zewnątrz jak i z wewnątrz naszego układu, czasem nawet powodując resetowanie się całości programu!
Nie jest powiedziane, że resetować się będzie zawsze - ale może się resetować w najmniej spodziewanym momencie.
Temat jest bardzo obszerny, ale tutaj na tym zakończę - po prostu nie powinniśmy uruchamiać żadnego układu bez dobrej filtracji zasilania.
Zaczynamy działanie z PIC18F2550
W tym momencie rozpoczynamy właściwą część tutoriala, czyli działania z PICem na płytce stykowej.
Dla tej części wybrałem PIC18F2550, ponieważ jest dość popularny, ma bogate peryferia oraz sprzętowe USB, które w przyszłości też być może wykorzystamy.
Oprócz PIC18F2550 można by tutaj użyć PIC18F4550, który
jest do niego bardzo podobny, oferuje jednak nieco więcej pinów (jest w obudowie DIP40).
Są też nieco nowsze wersje tych PICów, PIC18F25K50 oraz PIC18F45K50 które mają m. in. dokładniejszy wewnętrzny oscylator, dzięki czemu można na nich korzystać z USB bez użycia zewnętrznego oscylatora kwarcowego.
PIC18F2550 działa przy zasilaniu od 4.2V do 5.5V, ale dostępna jest też jego wersja (PIC18LF2550, gdzie ''''L'''' oznacza ''''Low voltage'''') na napięcia od 2V do 5.5V.
Pierwszym krokiem będzie skomunikowanie PICa z programatorem. Aby to zrobić należy podłączyć jego wszystkie piny zasilania (VCC, GND) oraz kondensator na VUSB. Dodatkowo przyda się rezystor 10k na pinie RESET.
Ale zacznijmy od początku, czyli od pustej płytki stykowej.
Na początek podpinamy zasilanie. Obowiązkowo kondensator elektrolityczny i ceramiczny na liniach VDD/GND:
Warto też dodać jakąś diodę LED do zasilania by wiedzieć czy 5V jest obecne w układzie:
Potem do akcji wkracza PIC - podłączamy jego wszystkie piny VDD/GND. Tutaj są dwa piny GND i jeden VDD. Dodatkowo 100nF najbliżej jak się da pinów PICa.
Mikrokontrolery z rodziny PIC18F też często wymagają dodatkowego kondensatora o pojemności rzędu 220nF. Podłącza się go na pinie VUSB, zgodnie z notą katalogową:
Co ciekawe, czasem może się zdarzyć że PIC będzie działać poprawnie bez tego kondensatora. Miałem kiedyś płytkę z PIC18F4550 i z zimnym lutem na miejscu tego kondensatora, na którą był wgrany wsad obsługi USB i działała ona na jednym komputerze, a na drugim Windows pokazywał komunikat "Nierozpoznane urządzenie.".
Ale my nie zamierzamy ryzykować więc kondensator 220nF na VUSB od razu podłączamy. Do tego rezystor 10k na pin RESET (tzw. pull up dla MCLR). Do samego programowania może on nie być konieczny, ale do uruchomienia zaprogramowanego wsadu już tak (no, chyba że wyłączymy RESET w konfiguracji PICa, ale aż tak nie komplikujemy).
UWAGA: Ta płytka stykową z której korzystam zrobiona jest tak, że jej boczne linie zasilania są przedzielone w połowie płytki. Dlatego potrzebna jest zworka. Na powyższym zdjęciu jest oznaczona na czerwono.
Na koniec podprowadzamy linie odpowiedzialne za programowanie ICSP (In Circuit Serial Programming), czyli piny PGC, PGD, MLCR aka RESET:
Podłączamy do nich programator.
Programator też wymaga podłączenia do masy (oczywiście) i do zasilania (VDD), nie możemy pominąć tych pinów.
Mikroprocesory PIC z reguły wspierają dwa rodzaje programowania:
- High Voltage Programming (HVP) (które w przypadku rodziny PIC18F podaje 12V na pin VPP)
- Low Voltage Programming (LVP) (które nie wymaga 12V na VPP)
LVP może być wyłączone w konfiguracji PICa, dlatego użyjemy HVP. Dobrymi programatorami HVP są PICKIT2/PICKIT3.
Programator do PICa podłączamy przez tzw. złącze ICSP. In Circuit Serial Programming, jak sama nazwa wskazuje, pozwala programować mikrokontroler nawet gdy jest już on podłączony w układzie. Czyli możemy mieć cały nasz układ na PCB i nie musimy wyciągać PICa z płytki/podstawki by go zaprogramować.
ICSP posiada następujące piny:
Pin numer 6 (PGM aka LVP) nie jest nam potrzebny i go nie podłączamy. Reszta jest niezbędna do podłączenia.
I tak wygląda ostatecznie gotowy setup pod następne etapy mojego tutorialu. Na nim uruchomimy kolejne przykłady z mruganiem LED, z przerwaniami, z UART, itp.
W takim układzie PICKIT powinien być już w stanie odczytać ID mikroprocesora, programować go, itp.
Pierwsze mruganie diodą
Teraz jeszcze zostało sprawdzić działanie naszego dzieła stworzonego na płytce stykowej z pomocą najprostszego programu - blink LED. Program po prostu będzie mrugać diodą LED.
Przede wszystkim musimy wybrać pin na którym umieścimy diodę LED i umiejscowić ją na płytce z rezystorem.
(Rezystor jest tam niezbędny by ograniczyć prąd płynący przez diodę i jej nie spalić).
Wybrałem pin C0 (najmłodszy bit z PORTC):
Podłączamy więc na niego rezystor i diodę LED:
I kompilujemy po czym wgrywamy następujący kod:
Kod: C / C++
Zaloguj się, aby zobaczyć kod
UWAGA: Ten kod zostanie dokładnie omówiony, ale to dopiero w następnej części tutoriala. Jak na razie tylko sprawdzamy czy działa.
Kompilacja oczywiście przechodzi pomyślnie i chwilę potem mamy gotowy .hex do wgrania:
Teraz trzeba jeszcze wgrać wsad do PICa.
Ja to zrobię z pomocą PICKIT3. W przypadku innych programatorów użyty software może się nieco różnić.
Odpalamy MPLAB IPE (Integrated Programming Environment):
Po uruchomieniu IPE od razu wykrywa, że mamy podłączonego PICKIT3. Widoczny jest on w polu rozwijanym Tool. Wybieramy interesującą nas rodzinę mikrokontrolerów i sam konkretny mikrokontroler jaki mamy. Następnie klikamy Connect by się połączyć.
IPE ostrzega nas, że nie powinniśmy próbować programować PICów na napięcie 3.3V z pomocą ustawień dla PICów na 5V. To dlatego ważne jest byśmy poprawnie wybrali tego PICa jakiego mamy.
Przy przełączaniu na PIC18F pierwszy raz należy troszkę poczekać, gdyż PICKIT3 będzie przestawiać się w tryb programowania tej rodziny. Następne programowania z kolei dokonywać się będą już dość szybko.
Potem wystarczy tylko wybrać plik hex (przycisk "Browse" z "Hex file") i można wgrywać wsad.
Po poprawnym wgraniu wsadu powinniśmy otrzymać długo oczekiwany efekt - miganie diodą LED:
Schemat połączeń ze zdjęcia powyżej:
Załączam tutaj pełną paczkę zip z tym przykładem (kod źródłowy .c, plik .bat kompilujący go na każdym komputerze z poprawnie zainstalowanymi SDCC/GPUtils, skompilowany plik .hex):
Ciąg dalszy tutoriala i przykładów dla PIC18F2550 będzie w następnym temacie.
Uzupełnienie tutoriala - materiały do zapoznania się
Oczywiście trudne byłoby w pełni merytoryczne opisanie tutaj wszystkiego związanego z SDCC i PICami, dlatego też zainteresowanych tematem odsyłam do materiałów źródłowych:
Manual SDCC:
Manual CodeBlocks:
Krótki opis konfiguracji SDCC i CodeBlocks dla 8051 (proces nieco podobny dla SDCC i PIC):
Podsumowanie
To była pierwsza część mojego praktycznego tutoriala o darmowym kompilatorze SDCC i PIC18F2550. Tutaj starałem się szczegółowo pokazać konfigurację kompilatora i środowiska na platformach Windows i Linux. Również pokazałem, że można go używać w połączeniu z Code Blocks.
W następnej części będziemy już programować samego PICa, zajmiemy się podstawami IO, czyli sterowaniem LEDami, obsługą przycisków, prostą komunikacją UART a może nawet też ADC lub PWM.
PS: Zapraszam do komentowania, jednakże jeśli ktoś ma jakieś mniej merytoryczne uwagi (literówki, złe słowa, drobne poprawki) to proszę z nimi do mnie na PW, temat będę poprawiać i aktualizować, nie róbmy śmietnika na forum.
Fajne? Ranking DIY Pomogłem? Kup mi kawę.
