Koło elektroniczno-informatyczne

Mikrokontrolery

 
 

Co to jest mikrokontroler?

 
   
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. 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 układu scalonego. Na rynku elektronicznym spotkamy ogromną ilość różnych mikrokontrolerów. My jednak ograniczymy się do produktów firmy Atmel z serii AVR. Zewnętrznie mikrokontroler wygląda jak zwykły układ scalony:

http://shop.myavr.com/pic/articles/attiny13_g.png http://upload.wikimedia.org/wikipedia/commons/8/86/ATtiny2313.png http://wolfpaulus.com/wp-content/uploads/2012/11/atmega8.jpeg http://shop.partoelec.com/image/cache/data/product/atmega8/ATmega%208%20smd-500x500.jpg

Wewnątrz układu scalonego kontrolera znajduje się mikroprocesor, pamięć oraz urządzenia wejścia wyjścia. Mikroprocesor może być programowany przez użytkownika za pośrednictwem komputera IBM, odpowiedniego oprogramowania oraz urządzenia zwanego programatorem. Zanim przejdziemy do tych zagadnień, dowiedzmy się coś na temat mikroprocesorów.

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. 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.

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. Jest to bardzo wygodne rozwiązanie. Starsze mikrokontrolery wymagały wyjęcia z układu aplikacyjnego i programowania w specjalnych programatorach. 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 pamięci FLASH. Programator umożliwia również zapis do pamięci EEPROM oraz ustawienie różnych funkcji procesora.

Układy

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.

 

 

 

Instalacja środowiska programowania AVR 

 
   
Programowanie mikroprocesora bezpośrednio za pomocą rozpoznawanych przez niego instrukcji 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, musisz posiadać kilka składników:

Programator AVR

Jest to urządzenie elektroniczne, które pozwoli ci przesłać do mikrokontrolera program do wykonywania (program ten zostanie przez programator zapisany w pamięci FLASH mikrokontrolera). 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).
http://store.extremeelectronics.co.in/images/D/USBAVRProg21Main.jpg http://nicegear.co.nz/obj/images/09825-01b.jpg http://letsmakerobots.com/files/field_primary_image/usbaspver2.jpg?

Programator jest podłączany do portu USB komputera PC. Na drugim końcu posiada złącze typu Kanada, które służy do sprzęgania programatora z mikrokontrolerem. Złącze zawiera dziesięć wtyków 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.

Jeśli twój komputer pracuje pod kontrolą systemu Windows 7, 8 lub 10, to poprawną pracę programatora USBasp uzyskasz po zainstalowaniu odpowiednich sterowników. Dokładny proces instalacji jest opisany szczegółowo pod 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) dostęp do portu USB wymaga odpowiednich uprawnień. W tym celu należy z konta administracyjnego wydać następujące polecenia:

 

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

 

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. Pakiet ten zawiera w sobie narzędzia do kompilacji programów dla mikrokontrolerów AVR oraz program AVRDude.

W środowisku Linux z konta administracyjnego wydaj polecenie:

 

sudo apt-get install avrdude

 

Narzędzia do kompilacji

W środowisku Windows instalujesz pakiet WinAVR.

W systemie Linux  z konta administracyjnego wydajesz polecenia:

 

sudo apt-get install gcc-avr binutils-avr gdb-avr avr-libc

 

Zainstaluje ono 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 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ć 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.x, 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 z konta administracyjnego wydaj polecenie:

 
sudo apt-get install eclipse-cdt

 

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 na pewno zechcesz 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,50zł za sztukę). Mimo to zawiera wszystkie podstawowe elementy pozostałych, większych mikrokontrolerów AVR i znakomicie nadaje się do nauki programowania.

http://shop.myavr.com/pic/articles/attiny13_g.png

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 wybranego trybu pracy):

Wyprowadzenia 4 i 8 służą do podpięcia odpowiednio masy (GND) i plusa zasilania (VCC). Pozostałe wyprowadzenia tworzą linie we/wy portu B. Specjalną funkcję pełni linia PB5, ponieważ posiada ona funkcję restartowania mikrokontrolera, gdy jest w stanie niskim. Z tego powodu jej użycie jest ograniczone. Pozostałe linie PB0...PB4 są do dyspozycji użytkownika. Musimy tutaj wyjaśnić jedną rzecz. Linia 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, który z kolei można wykorzystać do sterowania jakimś urządzeniem, np. diodą LED, silniczkiem, itp. Jeśli linia 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. O trybie pracy linii portu decyduje program, co dokładnie opiszemy w dalszych rozdziałach artykułu.

Na płytce stykowej zmontuj następujący układ (widoczne na schemacie montażowym gniazdko Kanada 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 Kanada 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.

Procedura tworzenia oprogramowania dla mikrokontrolerów AVR w środowisku Eclipse jest następująca:

 

Uruchom 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ą). Teraz musimy przekształcić ten tekst w program dla mikrokontrolera AVR. W tym celu kliknij na pasku narzędziowym ikonę kompilatora:

Eclipse wywoła 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%) 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 musisz 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 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 poszukaj w Internecie innych poradników instalacji Eclipse z AVR. Jest tego mnóstwo.

 

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ę.

 



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.