Mikrokontrolery AVR


Tematy pokrewne   Podrozdziały
(w budowie)
  Mikrokontrolery
Środowisko programowania
Pierwsza aplikacja AVR
Parametry mikrokontrolerów AVR

 

 

Mikrokontrolery

 
   
Przy pomocy bramek i przerzutników można budować dowolnie skomplikowane sieci logiczne. Jednakże od strony ekonomicznej jest to nieefektywne. Gdy liczba elementów rośnie, konstrukcja staje się coraz bardziej złożona i trudniejsza do wykonania oraz do uruchomienia. W takim skomplikowanym układzie mogą pojawić się różne problemy, np. zimne luty, znaczne zużycie energii. Rozwiązaniem okazało się zastosowanie układów uniwersalnych, które są sterowane przez program i mogą pełnić różne funkcje. Układy takie nazywamy mikrokontrolerami.

Mikrokontroler jest kompletnym komputerem, który został umieszczony wewnątrz pojedynczego układu scalonego. Na rynku elektronicznym spotkamy ogromną ilość różnych mikrokontrolerów, głównie rodziny PIC i AVR. My jednak ograniczymy się do produktów firmy Atmel z serii AVR (układy są tanie, łatwe w programowaniu i posiadają mnóstwo zastosowań – to samo można powiedzieć o mikrokontrolerach PIC, ale nie chciałbym tutaj rozpoczynać wojny pomiędzy zwolennikami obu rodzin). Zewnętrznie mikrokontroler wygląda jak zwykły układ scalony:

Istnieją wersje przewlekane i SMD o tych samych parametrach (niektóre zaawansowane mikrokontrolery produkowane są tylko w wersji SMD, ponieważ posiadają bardzo dużo wyprowadzeń).

Wewnątrz układu scalonego kontrolera znajduje się mikroprocesor, pamięć oraz różne urządzenia wejścia/wyjścia. Mikroprocesor jest programowany przez użytkownika za pośrednictwem komputera IBM (lub dowolnego innego, na którym da się uruchomić środowisko programowania oraz do którego da się podłączyć programator), odpowiedniego oprogramowania oraz urządzenia zwanego programatorem. Zanim przejdziemy do tych zagadnień, dowiedzmy się coś na temat mikroprocesorów stosowanych w mikrokontrolerach.

Sieć logiczna budowana jest z bramek oraz przerzutników. Sposób jej działania jest ściśle określony przez wzajemne połączenia tych elementów. Mówimy, że sieć jest zaprogramowana sprzętowo i może realizować określone funkcje logiczne (historyczny komputer ENIAC również był programowany sprzętowo za pomocą łączenia ze sobą różnych modułów obliczeniowych). Mikroprocesor również jest siecią logiczną zbudowaną z bramek i przerzutników. Różnica leży w stopniu złożoności. W mikroprocesorze znajduje się zwykle wiele tysięcy elementów logicznych (nawet wiele milionów, jak w przypadku procesorów używanych przez duże komputery). Dzięki temu działanie tej sieci jest bardzo złożone i może być programowane przez użytkownika. Mikroprocesor ściśle współpracuje z dwoma dodatkowymi elementami systemu: z pamięcią oraz z urządzeniami wejścia/wyjścia.

Pamięć przechowuje program oraz przetwarzane dane. Urządzenia wejścia/wyjścia umożliwiają wymianę informacji z otoczeniem. Sam mikroprocesor jest centralnym elementem wykonawczym.

Pamięć zbudowana jest z ciągu komórek (rejestrów), które przechowują informację w postaci porcji bitów (najczęściej 8 bitów). Każda komórka pamięci posiada swój numer zwany adresem komórki. Liczba komórek określa pojemność pamięci. Im ich więcej, tym więcej informacji można przechowywać w pamięci.

Program dla mikroprocesora określa operacje, które ma on wykonywać. Program składa się z ciągu kodów instrukcji, które są umieszczone w komórkach pamięci. Oczywiście, wszystko ma postać binarną, ponieważ tylko w takiej postaci jest zrozumiałe dla mikroprocesora. Wykonując program, mikroprocesor pobiera sobie kody instrukcji z pamięci, następnie analizuje je, rozpoznaje operację i wykonuje ją. Po wykonaniu jednej instrukcji mikroprocesor pobiera z pamięci następną i cykl się powtarza (w rzeczywistości nowa instrukcja jest pobierana w trakcie wykonywania poprzedniej, dzięki czemu program wykonywany jest o wiele szybciej). W programie występują instrukcje arytmetyczne, logiczne oraz takie, które zmieniają adres następnej instrukcji do wykonania (mikroprocesor wykonuje instrukcje z kolejnych komórek pamięci, dopóki nie napotka instrukcji nakazującej mu wykonywanie programu z innego miejsca w pamięci).

Firma Atmel produkuje wiele różnych modeli mikrokontrolerów AVR. Wszystkie jednak cechuje podobna budowa wewnętrzna (mówimy, że posiadają wspólną architekturę). Dla nas jest to bardzo dobra wiadomość, ponieważ nie będziemy musieli opanowywać od początku każdego mikrokontrolera Atmel. Oczywiście są między nimi różnice (inaczej po co by produkowano tyle modeli), lecz sama idea programowania jest u wszystkich bardzo podobna, a wiele komponentów jest nawet wspólnych.

CPU

Mikrokontroler posiada odpowiednio zaprojektowany mikroprocesor 8-bitowy, który jest zbudowany wg tzw. architektury harwardzkiej (AVR – oznacza kontroler jednoukładowy RISC ze zmodyfikowaną architekturą harwardzką). W architekturze tej pamięć programu jest oddzielona od pamięci danych. Mikroprocesor jest układem RISC  (ang. Reduced Instruction Set Computer – komputer o zredukowanym zestawie rozkazów), czyli posiada zubożony zestaw rozkazów w porównaniu do mikroprocesorów CISC (ang. Complex Instruction Set Computer – komputer o złożonym zestawie rozkazów), lecz za to są one wykonywane bardzo szybko. Okazuje się, że komputery RISC są wydajniejsze od komputerów CISC. Zubożenie listy rozkazów upraszcza budowę mikroprocesora, dzięki czemu może on wykonywać szybciej podstawowe operacje. Rozkazy skomplikowane zawsze da się wykonać za pomocą ciągu prostszych rozkazów. Nie jest to zatem jakieś zubożenie funkcjonalności procesora. Raczej potraktuj to jako odchudzenie grubasa, dzięki czemu staje się on szybszym biegaczem, bo nie musi taszczyć ze sobą swojego brzuszyska.

Pamięć FLASH

Do przechowywania programu dla mikroprocesora służy pamięć FLASH (taka sama jak w popularnych pendrive'ach). Pamięć FLASH można wielokrotnie zapisywać nową informacją (tutaj gwarantowane jest zwykle 10.000 cykli zapisu). Jej cechą charakterystyczną jest to, że zapisane dane nie są tracone po zaniku napięcia zasilającego. Dlatego program raz zapisany w tej pamięci jest od razu dostępny dla mikroprocesora po włączeniu zasilania (w komputerze PC program musi być wczytany z zewnętrznego nośnika, co zajmuje czas przy starcie systemu). Ilość pamięci FLASH wpływa na wielkość programu, który możemy umieścić w kontrolerze, a to z kolei określa złożoność funkcji, które ten kontroler może pełnić. Jeden z najmniejszych mikrokontrolerów ATTINY13 ma tej pamięci 1KB (1024 komórki 8-bitowe), co wystarcza w zupełności do prostych zastosowań. Starsi bracia posiadają odpowiednio więcej pamięci FLASH, zatem mogą wykonywać większe programy (czyli mogą pełnić bardziej skomplikowane funkcje).

Pamięć RAM

Dane przechowywane są w pamięci RAM. Pamięć ta po zaniku zasilania traci informację. Ilość pamięci RAM również określa funkcjonalność mikrokontrolera. Im jest jej więcej, tym więcej danych jest on w stanie przetwarzać. W pchełce ATTINY13 jest zaledwie 64 bajty pamięci RAM. Nie martw się, tyle zwykle wystarczy dla tego mikrokontrolera.

Pamięć EEPROM

Do przechowywania danych, które mają przetrwać wyłączenie zasilania (np. jakieś parametry konfiguracyjne lub dane startowe), służy pamięć EEPROM. Pamięć ta pozwala mikroprocesorowi wymazywać oraz zapisywać dane. Trwa to dłużej niż w przypadku RAM i dostęp jest bardziej skomplikowany. Dodatkowo liczba zapisów jest ograniczona do około 100 tysięcy (tyle gwarantuje firma ATMEL, lecz jeden z użytkowników męczył swój mikrokontroler zapisami do pamięci EEPROM i osiągnął liczbę ponad 4 milionów zapisów, zanim pamięć odmówiła dalszej współpracy). Z pamięci EEPROM na początku nie będziemy korzystać.

Porty we/wy

Ze światem zewnętrznym mikrokontroler komunikuje się za pomocą portów. Porty są wyprowadzone na nóżki układu scalonego. Do portów tych podłączamy różne urządzenia zewnętrzne. Porty mogą pracować dwukierunkowo, tzn. mogą wyprowadzać informację wpisaną do nich przez mikroprocesor, albo mogą odczytywać dane, które pojawiają się na linii portu z zewnątrz (np. naciśnięcie przycisku może zwierać linię portu wejściowego do masy i wymuszać na niej stan logiczny 0). Opanowanie programowania portów zapewni ci sukces w efektywnym stosowaniu mikrokontrolera. Im więcej linii portów, tym łatwiej podłączać do mikrokontrolera różne urządzenia bez dodatkowych układów scalonych. Pchełka ATTINY13 ma 8 nóżek, z których dwie są przeznaczone dla zasilania układu +5V oraz GND. Pozostałe 6 nóżek to właśnie linie portów. Linie portów mogą pełnić różne funkcje dodatkowe, o czym pomówimy w dalszej części kursu.

ISP

Układ programowania ISP (ang. In System Programming) pozwala programować mikrokontroler bez wyjmowania go z układu aplikacyjnego, czyli bezpośrednio na płytce PCB. Jest to bardzo wygodne rozwiązanie. Starsze mikrokontrolery wymagały wyjęcia mikrokontrolera z urządzenia i programowania go w specjalnych programatorach zewnętrznych (również drogich). Dzisiaj, dzięki ISP, jest to banalnie proste. Bezpośrednio w układzie podłączasz do odpowiednich nóżek mikrokontrolera sygnały z programatora i programujesz mikrokontroler. Gdy proces się zakończy, mikrokontroler zostaje zresetowany i rozpoczyna wykonywanie programu, który został zapisany w jego pamięci FLASH. Programator umożliwia również zapis do pamięci EEPROM oraz ustawienie różnych funkcji dodatkowych mikrokontrolera.

Układy dodatkowe

Tutaj różne rodziny są wyposażane w przeróżne dodatki: liczniki, komparatory, moduły transmisyjne. Zajmiemy się nimi w miarę potrzeb.

 

 

Środowisko programowania

 
   

Programowanie mikroprocesora bezpośrednio za pomocą rozpoznawanych przez niego instrukcji (czyli w asemblerze) jest niestety trudne i tym tutaj nie będziemy się zajmować. Na szczęście opracowano tzw. języki wysokiego poziomu, które posiadają składnię zbliżoną do języka ludzkiego. Dla mikrokontrolerów AVR standardowo będzie to język C, bardzo szybki i bardzo efektywny.

Aby efektywnie zaprogramować mikrokontroler AVR potrzebujesz następujących elementów:

Programator AVR

Jest to urządzenie elektroniczne, które pozwoli ci przesłać do mikrokontrolera program (zostanie on przez programator zapisany w pamięci FLASH mikrokontrolera, czyli w pamięci programu). Na rynku spotkasz całe mnóstwo różnych programatorów. Na początek nie musi to być urządzenie profesjonalne za kilkaset złotych. W zupełności wystarczy ci prosty programator USBasp za około 12...16zł (do kupienia w serwisie Allegro lub w firmach wysyłkowych). W przyszłości programator zrobisz sobie sam.

Programator jest podłączany do portu USB komputera PC (dawniej używano portów drukarki lub RS-232, lecz coraz częściej producenci pomijają je w nowym sprzęcie komputerowym). Na drugim końcu posiada złącze typu Kanda, które służy do sprzęgania programatora z mikrokontrolerem. Złącze zawiera dziesięć wtyków (istnieją wersje z 6 wtykami) o następujących oznaczeniach:

Sygnały MOSI, RST, SCK i MISO należy dołączyć do odpowiednich końcówek mikrokontrolera AVR. VCC oznacza napięcie zasilające, GND to masa. Programator może zasilać niewielkie układy prądem do 500mA (ponieważ tyle da się wycisnąć ze zwykłego portu USB komputera).

Jeśli twój komputer pracuje pod kontrolą systemu Windows 7/8/10, to poprawną pracę programatora USBasp uzyskasz po zainstalowaniu odpowiednich sterowników. Dokładny proces instalacji jest opisany szczegółowo pod poniższym adresem (uwaga: na czas instalacji sterownika będziesz musiał wyłączyć ochronę antywirusową, inaczej proces instalacji się nie powiedzie):

 

http://mirekk36.blogspot.com/2013/03/usbasp-win8-instalacja.html

 

W systemie Linux (wszystkie opisy dotyczą dystrybucji Ubuntu i pochodnych) dostęp do portu USB wymaga odpowiednich uprawnień. W tym celu należy wpisać następujące polecenia:

 

su root
sudo adduser konto_użytkownika plugdev

 

Zamiast konto_użytkownika wpisujemy w powyższym poleceniu nazwę konta, na którym będziemy pracować.

Tworzymy plik reguł dostępu do portów USB. Najpierw uruchamiamy edytor nano z odpowiednią nazwą pliku:

 

sudo nano /etc/udev/rules.d/81-avr-programator.rules

 

Zostanie otwarty pusty plik. Wklejamy do niego poniższy tekst (uwaga: dotyczy tylko programatorów USBasp!!!):

 

ATTRS{idVendor}=="16c0", ATTRS{idProduct}=="05dc", MODE="0666", GROUP="plugdev"

 

Wpis ten określa regułę dostępu do urządzenia USB, którym jest nasz programator. Plik zapisujemy, naciskając kombinację klawiszy Ctrl+O, po czym wychodzimy z edytora nano kombinacją Ctrl+X.

Teraz musimy zrestartować podsystem USB oraz reguły dostępu, aby nasz plik został uwzględniony (można również zrestartować komputer). Wydajemy polecenia:

 

sudo service udev restart
sudo udevadm control --reload-rules
exit

 

Po wykonaniu tych poleceń programator stanie się widoczny dla oprogramowania.

 

AVRDUDE

Do sterowania programatorem potrzebujesz specjalnego programu komunikacyjnego o nazwie AVRDude. Program ten musisz pobrać z Internetu i zainstalować na swoim komputerze.

Jeśli pracujesz w systemie Windows, to pobierz i zainstaluj pakiet WinAVR (nie jest on już nowy, ale do nauki w zupełności wystarcza. Alternatywą jest pakiet udostępniony przez firmę Atmel). Pakiet zawiera w sobie narzędzia do kompilacji programów dla mikrokontrolerów AVR oraz program AVRDude.

W środowisku Linux wpisz polecenia:

 

su root
sudo apt-get install avrdude
exit

 

Narzędzia do kompilacji

W środowisku Windows instalujesz pakiet WinAVR.

W systemie Linux  wpisz polecenia:

 

su root
sudo apt-get install gcc-avr binutils-avr gdb-avr avr-libc
exit
 

Zainstalują one kompilator języka C o nazwie gcc-avr oraz różne programy użytkowe i program uruchomieniowy. Zainstalowane zostaną również pliki nagłówkowe (pomówimy o nich później) dla mikrokontrolerów rodziny AVR.

 

Środowisko Eclipse

Właściwie po zainstalowaniu narzędzi i programu komunikacyjnego AVRDude mógłbyś już programować kontrolery. Jednakże wymagałoby to od ciebie wpisywania wielu rozkazów w wierszu poleceń. Aby cię odciążyć od tej nieprzyjemnej powinności, będziemy używać profesjonalnego środowiska programowania o nazwie Eclipse. Zaletą Eclipse jest to, że istnieje w identycznej postaci w wielu różnych systemach operacyjnych, np. w Windows i Linux. Alternatywą dla Eclipse jest Atmel Studio, jednakże jest ono dostępne tylko w systemie Windows i wspiera głównie firmowe programatory (USBasp nie jest normalnie obsługiwany), które działają kilkakrotnie szybciej od tanich USBasp. Z drugiej strony producentem jest firma Atmel. Zdecyduj sam.

Czym jest Eclipse? Tego typu oprogramowanie nazywamy zintegrowanym środowiskiem programowania, w skrócie IDE (ang. Integrated Development Environment). Łączy ono w sobie zadania wielu oddzielnych programów. Zawiera wygodną konfigurację, edytor oraz łączność z dodatkowymi narzędziami, które zainstalowałeś w poprzednich punktach.

Najpierw zainstaluj pakiet Eclipse. W systemie Windows ściągnij z Internetu odpowiednie archiwum, które następnie rozpakuj na dysku. Eclipse nie musi być specjalnie instalowane, wystarczy uruchomić plik programu eclipse.exe, który znajdziesz wewnątrz katalogu eclipse po rozpakowaniu ściągniętego z Internetu archiwum (Uwaga: do uruchomienia Eclipse niezbędne jest zainstalowanie najnowszego pakietu Java JRE). Jeśli korzystasz z systemu Windows 8/10, to dodatkowo umieść w katalogu WinAVR-xxx\utils\bin plik msys-1.0.dll. Bez tego pliku nie będzie poprawnie działał kompilator gcc-avr.

W systemie Linux zainstaluj Eclipse z centrum oprogramowania. Następnie wpisz polecenia:

 

su root
sudo apt-get install eclipse-cdt
exit
 

W obu przypadkach Windows i Linux uruchom Eclipse. Wybierz z menu opcję:

 

Help → Install New Software

 

Pojawi się okno dialogowe Install. Kliknij w przycisk Add. Pojawi się nowe okienko dialogowe Add Repository, w którym będą dwa pola tekstowe Name i Location. W polu Location wprowadź adres:

 

http://avr-eclipse.sourceforge.net/updatesite/

 

Kliknij w przycisk OK. Spowoduje to pobranie informacji z podanej lokacji o dostępnych wtyczkach dla eclipse. W oknie Install powinien się pojawić element AVR Eclipse Plugin. Wybierz go i kliknij przycisk Next. Okno Install zmieni nieco swój wygląd i zobaczysz w nim wybraną do instalacji wtyczkę AVR Eclipse Plugin. Ponownie kliknij przycisk Next. Teraz będziesz musiał zatwierdzić warunki licencji. Na spodzie wybierz pierwszą opcję:

Kliknij przycisk Finish, co rozpocznie instalację wtyczki. W trakcie tego procesu pojawia się okno z ostrzeżeniem, że oprogramowanie zawiera niepodpisaną zawartość:

Zatwierdź je przyciskiem OK. Po instalacji wtyczki system Eclipse musi być ponownie uruchomiony, o czym poinformuje cię ostatnie okienko dialogowe.

Gdy Eclipse uruchomi się ponownie, musimy skonfigurować w nim programator AVR. W tym celu z menu wybierz opcję:

 

Window → Preferences

 

Pojawi się okno dialogowe z preferencjami:

Jeśli instalacja wtyczki AVR Eclipse Plugin powiodła się, to w panelu bocznym zobaczysz element AVR. Otwórz go, klikając myszką w strzałkę po lewej stronie. Wybierz AVRDude:

W prawym panelu kliknij przycisk Add... Otworzy się duże okienko dialogowe z listą programatorów obsługiwanych przez AVRDude. U góry w polu Configuration Name wpisz USBasp. Na liście Programmer Hardware wyszukaj i zaznacz:

Kliknij przycisk OK. Okno z listą programatorów zostanie zamknięte. Wybrany programator powinien pojawić się w okienku preferencji:

Aby konfiguracja zaczęła obowiązywać, kliknij przycisk Apply, po czym zamknij okno przyciskiem OK. Po tej operacji twoje środowisko jest gotowe do rozpoczęcia programowania mikrokontrolerów AVR.

 

 

 

Pierwsza aplikacja AVR

 
   
Po zainstalowaniu środowiska programowania powinieneś je przetestować. Uruchomimy zatem prostą aplikację dla mikrokontrolera ATTiny13. Specjalnie wybrałem na początek ten mikrokontroler, ponieważ jest mały i tani (od 2 zł za sztukę w serwisie Allegro), a mimo to zawiera wszystkie podstawowe elementy pozostałych, większych mikrokontrolerów AVR. Naukę programowania lepiej rozpoczynać na czymś prostym. ATTiny13 jest tutaj idealny.

Mikrokontroler ATTiny13 jest produkowany w różnych obudowach. Spotkasz wersję przewlekaną i SMD. Na początek zajmiemy się wersją przewlekaną, ponieważ łatwo ją wstawić w płytkę stykową i w podstawkę. Mikrokontroler ATTiny13 wyposażony jest w 8 końcówek o następujących oznaczeniach (oznaczenia odzwierciedlają funkcje spełniane przez końcówki, a tych jest kilka w zależności od trybu pracy mikrokontrolera; funkcje dodatkowe są oznaczone na czerwono):

Wyprowadzenia nr 4 i 8 służą do podpięcia odpowiednio masy (GND) i plusa zasilania (VCC). Pozostałe wyprowadzenia są bitami portu B. Port jest specjalnym rejestrem wewnątrz mikrokontrolera, poprzez który mikrokontroler komunikuje się ze światem zewnętrznym. Poszczególne bity tego rejestru są wyprowadzone na nóżki mikrokontrolera o numerach 1...3 i 5...7. Każdy bit portu B posiada oznaczenie PBn, gdzie n jest numerem tego bitu od 0 do 5 (port B w ATTiny jest 6-cio bitowy). Bity PBn wyprowadzone na nóżki zewnętrzne mikrokontrolera będziemy nazywać liniami portu B. Specjalną funkcję pełni linia PB5, ponieważ posiada ona funkcję zerowania stanu mikrokontrolera, gdy zostanie wprowadzona w stan niski. Również wykorzystywana jest przez interfejs ISP. Z tego powodu jej użycie jest dosyć ograniczone. Pozostałe linie PB0...PB4 są do twojej dyspozycji i możesz z nimi robić co ci się podoba. Musimy tutaj wyjaśnić jedną rzecz. Każda linia portu B może pracować jako wejście lub wyjście. W przypadku pracy jako wyjście mikrokontroler może ustawić na niej stan logiczny 0 lub 1 wpisując 0 lub 1 do odpowiedniego bitu portu B, co z kolei można wykorzystać do sterowania jakimś urządzeniem, np. diodą LED, silniczkiem, itp. Jeśli linia portu pracuje jako wejście, to urządzenie zewnętrzne może na niej ustawiać stan logiczny 0 lub 1, a mikrokontroler posiada możliwość odczytu tego stanu przez odczyt odpowiedniego bitu w rejestrze portu B. O trybie pracy linii portu decyduje program, co dokładnie opiszemy w dalszych rozdziałach kursu.

Na płytce stykowej zmontuj następujący układ (widoczne na schemacie montażowym gniazdko Kanda należy do programatora AVR – łączysz jego bolce z płytką stykową za pomocą przewodów wyposażonych w złącza męskie i żeńskie. Poniżej schematu montażowego umieszczone zostały rysunki wyprowadzeń w złączu Kanda zarówno dla gniazdka w programatorze jak i dla wtyczki na końcu taśmy, w którą powinien być wyposażony programator AVR):

Spis elementów
Element Ilość Opis
Programator AVR 1  
płytka stykowa + kable 1  
ATTiny13 1 Mikrokontroler AVR
opornik 4,7kΩ/0,125W 1 –(                )–
opornik 270Ω/0,125W 1 –(                )–
czerwona dioda LED 1 do sygnalizacji stanu 1
  żółty
zielony
biały
pomarańczowy
niebieski
czerwony
– MOSI
– RESET
– SCK
– MISO
– GND
– +5V

Mikrokontroler będzie sterował świeceniem diody LED podłączonej do linii PB0. Opornik 4,7kΩ wymusza na wejściu RESET stan wysoki. Zwykle nie jest potrzebny, lecz jego zastosowanie polepsza odporność układu na zakłócenia.

Poniżej opisujemy krok po kroku procedurę tworzenia programu dla mikrokontrolera. Postaraj się dokładnie wykonać podane tu polecenia, gdyż od tego zależy sukces całej operacji.

 

Uruchom środowisko Eclipse. Obok pierwszej ikony (New) na pasku narzędziowym u góry okienka znajduje się strzałka w dół. Kliknij ją. Otworzy sie lista nowych elementów, które możesz utworzyć tym narzędziem:

Na liście kliknij w C Project. Otworzy się nowe okno dialogowe projektu C.

W polu Project name wpisz wybraną nazwę dla projektu. Następnie kliknij strzałkę obok AVR Cross Target Application i zaznacz Empty Project. Kliknij przycisk Next. Pojawi się kolejne okno dialogowe.

W oknie tym odznacz opcję Debug. Pozostaw zaznaczoną opcję Release. Kompilacja w trybie Debug umieszcza w kodzie dodatkowe elementy, co nie wychodzi na zdrowie małemu ATTiny13. Dlatego należy tę opcję wyłączyć. Kliknij przycisk Next. Następne okno dialogowe pozwoli ci wybrać rodzaj mikrokontrolera, dla którego będzie tworzony program oraz częstotliwość jego pracy (istotne przy odmierzaniu czasu).

W polu MCU Type wybierz mikrokontroler ATtiny13. Pole MCU Frequency pozostaw nienaruszone. Kliknij przycisk Finish. Projekt został utworzony i jego nazwa powinna pojawić się w panelu po lewej stronie (tutaj będą pojawiać się tworzone przez ciebie projekty). Kliknij w nazwę projektu, aby został wybrany przez Eclipse.

Jeśli z jakiś powodów nie widzisz panelu C/C++ Projects, to z menu wybierz opcję:

 

Window → Show View → C/C++ Projects

 

W kolejnym kroku należy zdefiniować programator AVR, który chcesz używać ze swoim projektem. W tym celu wybierz z menu opcję:

 

Project → Properties

 

Pojawi się okno z opcjami projektu.

Otwórz w bocznym panelu sekcję AVR i kliknij w AVRDude. Wtedy z prawej strony pojawią się opcje konfiguracyjne dla AVRDude. Pod Programmer configuration znajduje się lista dostępnych programatorów (możesz przecież posiadać kilka różnych typów). Kliknij strzałkę w dół i wybierz USBasp (skonfigurowaliśmy go wcześniej). Kliknij przycisk Apply (ważne, inaczej Eclipse nie zapamięta twojego wyboru), a następnie kliknij OK.

 

Teraz musisz dodać do projektu plik źródłowy, w którym umieścisz tekst programu dla mikrokontrolera. Ponownie kliknij w strzałkę przy ikonie New.

Z listy wybierz Source File (plik źródłowy). Pojawi się okienko dialogowe:

W polu Source file wpisz nazwę pliku i kliknij w przycisk Finish.  Eclipse utworzy w projekcie nowy plik źródłowy i otworzy go w oknie edytora.

 

Przekopiuj do tego okna poniższy tekst programu. Nie przejmuj się, jeśli go nie rozumiesz. Wszystko wyjaśnimy w dalszej części kursu.

 

#include <avr/io.h>
#include <util/delay.h>

int main(void)
{
    DDRB = 1;
    while(1)
    {
        PORTB = 0;
        _delay_ms(100);
        PORTB = 1;
        _delay_ms(1000);
    }
}
 

Gdy program znajdzie się w edytorze, zapisz go na dysku, naciskając Ctrl+S (pamiętaj zawsze o zapisywaniu swoich programów przed kompilacją, ponieważ kompilator czyta plik z dysku, nie z edytora Eclipse). Teraz musimy przekształcić ten tekst w program dla mikrokontrolera AVR. W tym celu kliknij na pasku narzędziowym ikonę kompilatora:

Eclipse uruchomi kompilator gcc-avr, który dokona kompilacji, czyli przekształci tekst twojego programu źródłowego w ciąg kodów instrukcji dla mikrokontrolera AVR. Jeśli nie popełniłeś błędu, to w panelu konsoli powinien pojawić się taki tekst:

 

19:26:23 **** Build of configuration Release for project test ****
make all
Building file: ../main.c
Invoking: AVR Compiler
avr-gcc -Wall -Os -fpack-struct -fshort-enums -ffunction-sections -fdata-sections -std=gnu99 -funsigned-char -funsigned-bitfields -mmcu=attiny13 -DF_CPU=1000000UL -MMD -MP -MF"main.d" -MT"main.d" -c -o "main.o" "../main.c"
Finished building: ../main.c
Building target: test.elf
Invoking: AVR C Linker
avr-gcc -Wl,-Map,test.map -mmcu=attiny13 -o "test.elf" ./main.o
Finished building target: test.elf
Invoking: AVR Create Extended Listing
avr-objdump -h -S test.elf >"test.lss"
Finished building: test.lss
Create Flash image (ihex format)
avr-objcopy -R .eeprom -R .fuse -R .lock -R .signature -O ihex test.elf "test.hex"
Finished building: test.hex
Create eeprom image (ihex format)
avr-objcopy -j .eeprom --no-change-warnings --change-section-lma .eeprom=0 -O ihex test.elf "test.eep"
Finished building: test.eep
Invoking: Print Size
avr-size --format=avr --mcu=attiny13 test.elf

AVR Memory Usage
----------------
Device: attiny13
Program: 78 bytes (7.6% Full)
(.text + .data + .bootloader)
Data: 0 bytes (0.0% Full)
(.data + .bss + .noinit)

Finished building: sizedummy
19:26:23 Build Finished (took 373ms)

 

Nie przejmuj się, jeśli tego nie rozumiesz. Tak naprawdę ważna jest końcówka, która podsumowuje zużycie pamięci programu (78 bajtów) oraz pamięci RAM (0 bajtów). Informacje te pozwalają się nam zorientować, czy program zmieści się wewnątrz mikrokontrolera. ATTiny13 dysponuje 1024 bajtami pamięci Flash dla programu (program zużywa jej tylko 7,6% tej pamięci) oraz 64 bajtami pamięci RAM. Wiem, że to niewiele, ale ATTiny13 przeznaczony jest dla bardzo prostych zadań, dlatego go właśnie wybrałem!

Wynikiem działania kompilatora gcc-avr jest kilka plików, które powstają w katalogu projektowym. Na razie nie musisz znać ich dokładnego przeznaczenia.

Po utworzeniu programu należy go przesłać do mikrokontrolera. Podłącz swój programator AVR do portu USB komputera. Kliknij na pasku narzędziowym ikonę AVRDude:

Jeśli wszystko skonfigurowałeś poprawnie, to w panelu konsoli pojawi się tekst z aplikacji AVRDude:

 

Launching C:\WinAVR-20100110\bin\avrdude -pt13 -cusbasp -Pusb -Uflash:w:test.hex:a

Output:

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.02s

avrdude: Device signature = 0x1e9007
avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed
To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file "test.hex"
avrdude: input file test.hex auto detected as Intel Hex
avrdude: writing flash (78 bytes):

Writing | ################################################## | 100% 0.62s

avrdude: 78 bytes of flash written
avrdude: verifying flash memory against test.hex:
avrdude: load data flash data from input file test.hex:
avrdude: input file test.hex auto detected as Intel Hex
avrdude: input file test.hex contains 78 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 0.44s

avrdude: verifying ...
avrdude: 78 bytes of flash verified
avrdude done. Thank you.

avrdude finished

 

Po przesłaniu programu do mikrokontrolera ATTiny13 dołączona do niego dioda LED powinna zacząć mrugać (świecenie 1 sekunda, zgaszenie 1/10 sekundy i powtórka). Jeśli tak się dzieje, gratulacje, masz skonfigurowany system do tworzenia oprogramowania na mikrokontrolery AVR. Jeśli nie, sprawdź połączenia programatora z mikrokontrolerem. Jeśli są poprawne, to popełniłeś gdzieś błąd w konfiguracji oprogramowania. Wróć na początek rozdziału i spróbuj ponownie wykonać wszystko krok po kroku. Jeśli ci się dalej nie powiedzie, to poproś kolegę o zainstalowanie wszystkiego wg podanych tutaj procedur. Może jemu się uda.

 

Podsumowanie

Kolejne kroki tworzenia aplikacji dla mikrokontrolera AVR są następujące:
  1. Tworzymy odpowiedni układ elektroniczny.
  2. Mikrokontroler łączymy z programatorem za pomocą linii RESET, SCK, MISO i MOSI. Są to linie transmisji danych, przez które programator komunikuje sie z mikrokontrolerem wg specjalnego protokołu.
  3. Uruchamiamy system Eclipse i tworzymy w nim nowy projekt C dla AVR. Wybieramy nazwę i rodzaj mikrokontrolera. Dla mikrokontrolerów ATTiny wyłączamy opcję Debug (jest ona przydatna, gdy uruchamiamy złożone programy lub chcemy śledzić wykonanie programu w debugerze).
  4. Dla projektu wybieramy odpowiedni programator AVR.
  5. Tworzymy plik źródłowy C i wpisujemy do niego program. Plik ten należy zapisać na dysku.
  6. Uruchamiamy kompilator gcc-avr i kompilujemy plik źródłowy. W efekcie powstaje plik programu dla mikrokontrolera AVR.
  7. Uruchamiamy program AVRDude, który prześle plik programu do mikrokontrolera AVR.
  8. Testujemy naszą aplikację.

 

 

Parametry mikrokontrolerów AVR

 
   
Firma Atmel produkuje całą gamę różnych mikrokontrolerów. Programuje się je bardzo podobnie za pomocą tego samego programatora oraz środowiska IDE. Różnią się one parametrami oraz możliwościami. Poniżej przedstawiamy kilka wybranych mikrokontrolerów rodziny AVR.

ATTINY13

Jest to jeden z najmniejszych mikrokontrolerów, który nadaje się do prostych zastosowań. Układ posiada 8 wyprowadzeń, z których 6 pełni funkcję portów wejścia/wyjścia. Zawiera wydajny, 8-bitowy procesor RISC, który może wykonywać do 20 milionów operacji na sekundę przy taktowaniu 20MHz. Oprócz wersji podstawowej produkowane są układy o powiększonych możliwościach.

Model ATTINY13 ATTINY25 ATTINY45 ATTINY85    
Pamięć Flash programu 1 2 4 8 kB 10.000 cykli zapisu
Pamięć RAM danych 64 128 256 512 B  
Pamięć EEPROM 64 128 256 512 B 100.000 cykli zapisu
Zasilanie 2,7...5,5 V  
Częstotliwość zegara 0...20 MHz  

 

ATTINY24

Mikrokontroler ATTINY24 posiada większe możliwości od opisanego wyżej ATTINY13. Dostępnych jest więcej linii portów (12 zamiast 6), co pozwala w prosty sposób sterować większą liczbą urządzeń lub urządzeniami, które wymagają kilku linii sterujących. Posiada również więcej pamięci programu i danych.

Model ATTINY24 ATTINY44 ATTINY84    
Pamięć Flash programu 2 4 8 kB 10.000 cykli zapisu
Pamięć RAM danych 128 256 512 B  
Pamięć EEPROM 128 256 512 B 100.000 cykli zapisu
Zasilanie 2,7...5,5 V  
Częstotliwość zegara 0...20 MHz  
 

ATTINY2313

Mikrokontroler ATTINY2313 jest najchętniej stosowanym mikrokontrolerem przez hobbystów. Powodem jest niska cena (około 4...6zł za sztukę) oraz względnie duża liczba wyprowadzeń, co umożliwia mu sterowanie nawet skomplikowanymi urządzeniami. Również powiększona pamięć Flash dla programu pozwala pomieścić bardziej złożone programy.

Model ATTINY2313 ATTINY4313    
Pamięć Flash programu 2 4 kB 10.000 cykli zapisu
Pamięć RAM danych 128 256 B  
Pamięć EEPROM 128 256 B 100.000 cykli zapisu
Zasilanie 2,7...5,5 V  
Częstotliwość zegara 0...20 MHz  

 

ATMEGA8

Mikrokontroler ATMEGA8 posiada bardzo duże możliwości i jest stosowany tam, gdzie trzeba sterować skomplikowanymi urządzeniami lub program musi być bardzo złożony. Występuje również w kilku wersjach o różnych możliwościach. Do programowania ATMEGA8 potrzebny jest profesjonalny programator, ponieważ programowanie zwykłym programatorem USBasp zajmuje mnóstwo czasu (chyba że masz dużo cierpliwości).

Model ATMEGA8 ATMEGA16 ATMEGA32 ATMEGA64 ATMEGA128    
Pamięć Flash programu 8 16 32 64 128 kB 10.000 cykli zapisu
Pamięć RAM danych 1 1 2 4 4 kB  
Pamięć EEPROM 512 512 1024 2048 4096 B 100.000 cykli zapisu
Zasilanie 2,7...5,5 V  
Częstotliwość zegara 0...16 MHz  

 

 



List do administratora Serwisu Edukacyjnego Nauczycieli I LO

Twój email: (jeśli chcesz otrzymać odpowiedź)
Temat:
Uwaga: ← tutaj wpisz wyraz  ilo , inaczej list zostanie zignorowany

Poniżej wpisz swoje uwagi lub pytania dotyczące tego rozdziału (max. 2048 znaków).

Liczba znaków do wykorzystania: 2048

 

W związku z dużą liczbą listów do naszego serwisu edukacyjnego nie będziemy udzielać odpowiedzi na prośby rozwiązywania zadań, pisania programów zaliczeniowych, przesyłania materiałów czy też tłumaczenia zagadnień szeroko opisywanych w podręcznikach.



   I Liceum Ogólnokształcące   
im. Kazimierza Brodzińskiego
w Tarnowie

©2017 mgr Jerzy Wałaszek

Dokument ten rozpowszechniany jest zgodnie z zasadami licencji
GNU Free Documentation License.