Warsztat

Eclipse nie zostało zaprojektowane specjalnie dla mikrokontrolerów AVR. Jest to środowisko, w którym możesz programować w wielu różnych językach programowania. Aby rozpoznawało mikrokontrolery AVR, należy zainstalować odpowiednią wtyczkę programową, co opisuję dokładnie poniżej.

Platforma Eclipse dostępna jest zarówno dla Windows jak i dla Linuksa. W obu tych systemach Eclipse działa identycznie. Dodatkowo środowisko to jest naprawdę wygodne i sam chętnie je stosuję. Programowanie w Eclipse wymaga znajomości języka C, zatem proponuję przerobienie naszego kursu programowania w C.

Jeśli pracujesz w środowisku Windows, to dobrą alternatywą dla Eclipse jest kompletne środowisko programowania mikrokontrolerów AVR, które udostępnia zupełnie darmowo firma ATMEL. Środowisko nazywa się Atmel Studio i pozwala programować wszystkie aktualnie dostępne mikrokontrolery AVR.

W Eclipse tworzy się projekt dla odpowiedniego typu mikrokontrolera, np. ATtiny2313. Następnie w edytorze piszemy program sterujący dla tego mikrokontrolera w języku C. Po napisaniu programu, kompilujemy go, czyli przekształcamy na plik binarny, który zawiera instrukcje specyficzne dla danego modelu mikrokontrolera. Plik programu przesyłamy za pomocą programu komunikacyjnego AVRDude do mikrokontrolera. Na tym etapie potrzebujemy specjalne urządzenie, które nazywa się programatorem. Programator podłącza się do portu USB komputera PC. Programator posiada drugie wyjście z sygnałami sterującymi mikrokontrolerem. Sygnały te muszą być doprowadzone do mikrokontrolera (obecne modele mikrokontrolerów firmy ATMEL można programować bezpośrednio w układzie elektronicznym bez potrzeby ich wyjmowania, nazywa się to ISP - ang. In System Programming). Program komunikacyjny AVRDude przesyła wybrany plik programu do programatora, a ten z kolei przesyła go do mikrokontrolera. Problem leży w tym, że istnieje wiele programatorów dla mikrokontrolerów AVR i należy je odpowiednio zainstalować w swoim komputerze, aby program AVRDude uzyskał do nich dostęp.

Sam korzystam z kilku typów programatorów:

USBasp

Zaletą tego programatora jest niewątpliwie jego cena. Na Allegro kupisz go już za 8...12 zł. W środowisku Eclipse nie będziesz miał problemu z używaniem takiego programatora, ponieważ AVRDude współpracuje z nim bardzo dobrze. Wadą USBAsp jest mała szybkość transmisji danych do mikrokontrolera. Dla małych projektów nie ma to praktycznie znaczenia (program ładuje się 2...3 sekundy). Jeśli jednak planujesz programowanie większych mikrokontrolerów z rodziny ATMEGA, to czas przesłania programu może być znaczny. Z drugiej strony takie mikrokontrolery programują użytkownicy zaawansowani, a im moje rady nie są już potrzebne. Do nauki programator jest świetny i szczerze go polecam.

MKII

Do bardziej profesjonalnych zastosowań proponuję zaopatrzyć się w programator AVR-ISP-MK2. Kosztuje on około 70...120 zł. Możesz go stosować z AVRDude (zwykle programatory te pozwalają również na współpracę z AVR Studio - oryginalnym systemem programowania mikrokontrolerów AVR opracowanym i udostępnionym przez ich wytwórcę, firmę ATMEL) po przełączeniu zworką lub po naciśnięciu odpowiedniego przycisku (szczegóły znajdziesz w instrukcji). Programatory mk2 umożliwiają programowanie większości dostępnych mikrokontrolerów AVR, są zatem bardziej wszechstronne od programatorów USBasp i ich szybkość transmisji do mikrokontrolera jest kilkakrotnie większa. Również polecam ten programator.

W sprzedaży dostępne są profesjonalne programatory dla mikrokontrolerów AVR, jednakże ich cena może stanowić problem dla kieszeni amatora. Korzyści z używania takich programatorów mają doświadczeni elektronicy. Jeśli jesteś początkującym (a zaawansowani raczej tego nie czytają), to kup sobie najtańszy programator USBasp – w przypadku zmiany zainteresowań przynajmniej nie stracisz zbyt dużo pieniędzy :)

Zakupiłeś programator. Co dalej? Jeśli jest to inny model od opisanych powyżej, to przeczytaj dokładnie instrukcję jego instalacji na twoim komputerze. Ja opiszę instalację tylko tych dwóch powyższych programatorów, ponieważ takowe posiadam. Instalację innych programatorów znajdziesz bez problemu w Internecie.

USBasp – Windows

Aby program komunikacyjny AVRDude (zainstalujemy go za chwilę) mógł się porozumieć z programatorem, musisz na swoim komputerze zainstalować odpowiedni sterownik USB, który pozwoli systemowi Windows rozpoznać programator. Inaczej komunikacja nie będzie możliwa. Procedura jest następująca (Windows 7/8/10):

USBasp – Linuks Ubuntu

W systemie Linuks nie są potrzebne żadne sterowniki do komunikacji z programatorem USBasp. Musimy jednakże posiadać dostęp do portu USB ze swojego konta użytkownika.

Naciśnij Ctrl+Alt+T, aby uruchomić terminal.

Sprawdź, czy należysz do grupy plugdev (urządzenia podłączane). Wpisz polecenie:

groups
geo adm cdrom sudo dip plugdev lpadmin sambashare

Jeśli na liście grup nie pojawi się plugdev, to wpisz polecenia (musisz posiadać uprawnienia administratora):

sudo adduser twoje_konto plugdev
groups

Utwórz plik reguł dostępu do portów USB. Uruchom edytor nano z odpowiednią nazwą pliku:

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

 Zostanie otwarty pusty plik. Wklej 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 programator USBasp. Plik zapisz, naciskając kombinację klawiszy Ctrl+O, po czym wyjdź z edytora nano kombinacją klawiszy Ctrl+X.

Zresetuj podsystem USB oraz reguły dostępu, aby utworzony plik reguł został uwzględniony (można również ponownie uruchomić komputer). Wpisz polecenia:

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

Na koniec sprawdź, czy system widzi podłączony do portu USB programator. Podłącz programator USBasp do dowolnego portu USB i wpisz w terminalu polecenie:

lsusb
...
Bus 002 Device 005: ID 16c0:05dc Van Ooijen Technische Informatica shared ID for use with libusb
...

Na liście powinno pojawić się wyróżnione wyżej urządzenie. Instalacja jest zakończona.

MK2 – Windows

Do współpracy z AVRDude instalujemy sterownik programatora MK2 identycznie jak dla USBasp – za pomocą programu zadig. Jeśli zainstalowałeś sterownik USBasp, to nie musisz już instalować sterownika dla MK2, ponieważ oba korzystają z tego samego filtra libusb-win32. Jeśli nie instalowałeś sterownika dla programatora USBasp, to pobierz z witryny http://zadig.akeo.ie/ program zadig dla Windows i uruchom go (potrzebne są uprawnienia administratora). Podłącz programator MK2 do portu USB. Zadig powinien go rozpoznać i wyświetlić jego nazwę u góry okienka . W polu wskazanym zieloną strzałką wybierz:

i kliknij myszką przycisk Install Driver. Zamknij zadig. Kliknij prawym przyciskiem myszki w przycisk Start na pasku zadań Windows i wybierz z menu kontekstowego Menedżer urządzeń. Na liście urządzeń powinno się pojawić:

MK2 – Linuks Ubuntu

Uruchom terminal przez naciśnięcie klawiszy Ctrl+Alt+T. Najpierw zainstaluj brakujący w Ubuntu pakiet uisp:

sudo apt-get install uisp

Następnie sprawdź, czy twoje konto należy do grupy plugdev:

groups
geo adm cdrom sudo dip plugdev lpadmin sambashare

Jeśli nie, to wpisz:

sudo adduser twoje_konto plugdev
groups

Utwórz plik reguł dostępu do portów USB. Uruchom edytor nano z odpowiednią nazwą pliku:

sudo nano /etc/udev/rules.d/61-avrisp-programator.rules

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

ATTR{idVendor}=="03eb", ATTR{idProduct}=="2103", MODE="0666", GROUP="plugdev"
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2104", MODE="0666", GROUP="plugdev"
ATTR{idVendor}=="03eb", ATTR{idProduct}=="2107", MODE="0660", GROUP="plugdev"

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

Zresetuj podsystem USB oraz reguły dostępu, aby utworzony plik reguł został uwzględniony (można również ponownie uruchomić komputer). Wpisz polecenia:

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

Na koniec sprawdź, czy system widzi podłączony do portu USB programator. Podłącz programator MK2 do dowolnego portu USB i wpisz w terminalu polecenie:

lsusb
...
Bus 002 Device 006: ID 03eb:2104 Atmel Corp. AVR ISP mkII
...

Na liście powinno pojawić się wyróżnione wyżej urządzenie (może być nieco inne, jeśli masz programator innego typu, np. Dragon). Instalacja jest zakończona.

Najlepszym rozwiązaniem jest zainstalowanie oprogramowania dostarczanego przez firmę ATMEL, ponieważ obejmuje ono wszystkie nowe mikrokontrolery. Istnieją również alternatywne rozwiązania, lecz są one już dosyć stare (w sumie do nauki wciąż jeszcze bardzo dobrze się nadają), dlatego nie będę ich polecał.

ATMEL toolchain – Windows

W googlach wpisz hasło:

atmel toolchain windows

Powinien zostać znaleziony link do strony domowej firmy Atmel. Podaję go poniżej, lecz lepiej sam sobie wyszukaj, ponieważ z czasem ten link może stracić ważność:

http://www.atmel.com/tools/ATMELAVRTOOLCHAINFORWINDOWS.aspx

Link powinien zaprowadzić cię na stronę, z której będziesz mógł pobrać instalator toolchain'a. Zwykle są tam do pobrania trzy elementy. Wybierz Atmel AVR 8-bit Toolchain X.X.X - Windows (XXX oznacza numer wersji, na chwilę obecną jest to 3.5.3). Pobranie czegokolwiek z firmy ATMEL wymaga założenia darmowego konta. Odpowiedni formularz rejestracyjny znajdziesz po wybraniu toolchain'a do pobrania. Wypełnij go i zapisz sobie gdzieś dane swojego konta – przydadzą się w przyszłości, gdybyś chciał pobrać inne rzeczy.

Po zalogowaniu przejdziesz na stronę pobierania wybranego narzędzia. Pobieranie powinno rozpocząć się automatycznie (a jego przebieg zależy od używanej przez ciebie przeglądarki):

Po załadowaniu uruchom instalator. Instalacja wymaga praw administratora. Instalacja polega na wypakowaniu zawartości archiwum 7-ZIP do wskazanego katalogu. W pierwszym okienku dialogowym określasz to miejsce

Po kliknięciu przycisku Extract, pliki zostaną wypakowane do wskazanego miejsca:

W wybranym przez ciebie katalogu pojawi się katalog avr8-gnu-toolchain. Sprawdź na koniec poprawność instalacji:

Uruchom terminal (wciśnij przycisk Window+R i wpisz cmd). W terminalu wpisz:

cd \XXX\avr8-gnu-toolchain\bin
avr-gcc --version

XXX oznacza ścieżkę dostępu do katalogu, w którym zostało rozpakowane archiwum. W odpowiedzi powinieneś otrzymać:

avr-gcc (AVR_8_bit_GNU_Toolchain_3.5.3_1700) 4.9.2
Copyright (C) 2014 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Pozostało ci jeszcze doinstalować program GNU make, którego brakuje w toolchain'ie Atmela. W zależności od wersji twojego Windows, pobierz do katalogu bin toolchain'a odpowiedni plik:

ATMEL toolchain – Linuks Ubuntu

W googlach wpisujesz hasło:

atmel toolchain linux

Następnie przechodzisz pod znaleziony adres. Podaję go poniżej, lecz w przyszłości może się on zmienić:

http://www.atmel.com/tools/atmelavrtoolchainforlinux.aspx

Znajdziesz tu pliki do pobrania. Wybierz Atmel AVR 8-bit Toolchain X.X.X - Linux 32-bit lub Atmel AVR 8-bit Toolchain X.X.X - Linux 64-bit w zależności od posiadanej wersji Linuksa (XXX oznacza numer wersji, w chwili obecnej jest to 3.5.3). Pobranie plików z firmy ATMEL wymaga utworzenia darmowego konta. Po zalogowaniu się na to konto, wybrany plik będzie pobrany. Uruchom go za pomocą menedżera archiwów:

Gdy archiwum zostanie pobrane na twój dysk twardy, wybierz je i kliknij przycisk Rozpakuj. Pojawi się okno dialogowe wyboru katalogu, w którym zostanie rozpakowane archiwum. Wybierz katalog domowy (lub inny, ale zapamiętaj, gdzie toolchain został rozpakowany):

Po wybraniu katalogu, kliknij przycisk Rozpakuj. Jeśli wszystko poszło dobrze, to w katalogu domowym pojawi się katalog z toolchain'em:

Wejdź do tego katalogu, a następnie do katalogu bin i uruchom w nim terminal (kliknij w katalogu prawym przyciskiem myszki i z menu kontekstowego wybierz opcję Otwórz w terminalu). Następnie wpisz:

./avr-gcc --version

Otrzymasz:

avr-gcc (AVR_8_bit_GNU_Toolchain_3.5.3_1700) 4.9.2
Copyright (C) 2014 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Instalacja jest zakończona.

AVRDude – Windows

Przejdź do strony: http://download.savannah.gnu.org/releases/avrdude/. Znajdziesz na niej najnowsze wersje programu AVRDude. Wyszukaj plik o największym numerze wersji z końcówką nazwy mingw32.zip. Pobierz go i rozpakuj, najlepiej do katalogu bin w twojej instalacji toolchain ATMELA. To w zasadzie kończy instalację. Pozostaje jednak sprawdzenie, czy AVRDude komunikuje się z twoim programatorem, a w konsekwencji z mikrokontrolerem podłączonym do programatora. Aby tego dokonać, musisz zbudować prosty układ z mikrokontrolerem.

Programator komunikuje się z mikrokontrolerem za pomocą sygnałów:

Ważne jest 6 sygnałów (Vcc, GND, MOSI, RST, SCK i MISO). Sygnały te muszą zostać doprowadzone do odpowiednich wyprowadzeń (pinów, nóżek) mikrokontrolera. Niestety, dla różnych mikrokontrolerów będą to różne wyprowadzenia. Na poniższym rysunku zebrałem konfigurację wyprowadzeń popularnych mikrokontrolerów AVR (inne musisz sobie znaleźć w sieci Internet):

Do płytki stykowej włóż mikrokontroler w sposób pokazany poniżej:

Obok nóżki nr 1 znajduje się na obudowie małe, koliste wgłębienie. Mikrokontroler powinien być tak włożony w płytkę stykową, aby nóżka nr 1 znajdowała się w lewym dolnym rogu. Zaopatrz się w różnokolorowe przewody z wtykami żeńskimi i męskimi. Można je zakupić w każdym sklepie elektronicznym lub na Allegro i warto to zrobić, ponieważ przydają się do różnych połączeń:

Przewodami łączymy wyjścia z programatora (Vcc, GND, RST, MISO, MOSI i SCK) z odpowiednimi wyprowadzeniami mikrokontrolera (sprawdź dokładnie wszystkie połączenia). Pamiętaj, aby połączeń dokonywać przy programatorze niepodłączonym do portu USB:

Podłącz swój programator do portu USB. Uruchom okienko konsoli (naciśnij Windows+R i wpisz cmd) i wpisz do niego polecenie:

cd \XXX

XXX jest ścieżką dostępu do katalogu, w którym zapisałeś program AVRDude. Na przykład, u siebie wpisuję:

cd \apps\avr8-gnu-toolchain\bin\

Program AVRDude można uruchamiać z wiersza poleceń, chociaż nie jest to specjalnie wygodne. Gdy zainstalujesz Eclipse, będzie to robione automatycznie. Składnia wywołania AVRDude jest następująca:

avrdude opcje

W opcjach określamy sposób zachowania się AVRDude. Opcji jest dosyć dużo (kolejny powód używania Eclipse), podam jedynie te, które będą nam tutaj teraz potrzebne:

Przykładowo, dla programatora USBasp i mikrokontrolera ATtiny13 wpisujesz polecenie:

avrdude -c usbasp -p t13

A dla programatora MK2 i mikrokontrolera ATmega 8 wpisz:

avrdude -c avrisp2 -p m8

Jeśli wszystko jest w porządku, to w odpowiedzi otrzymasz (dla mikrokontrolera ATtiny13):

avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.05s

avrdude: Device signature = 0x1e9007 (probably t13)

avrdude: safemode: Fuses OK (E:FF, H:FF, L:6A)

avrdude done. Thank you.

Jeśli AVRDude nie może się skomunikować z programatorem lub z mikrokontrolerem, to otrzymasz coś innego, np:

avrdude: error: program enable: target doesn't answer. 1 avrdude: initialization failed, rc=-1 Double check connections and try again, or use -F to override this check. avrdude done. Thank you.

W takim przypadku sprawdź, czy wpisałeś dobre polecenie (programator i mikrokontroler), czy przewody są poprawnie połączone, itd. (spróbuj wymienić mikrokontroler na inny egzemplarz). W przypadku programatora MK2 sprawdź, czy został przełączony na współpracę z AVRDude (jak to zrobić znajdziesz w instrukcji swojego programatora).

Nie demontuj tego układu, przyda nam się do testowania instalacji Eclipse.

AVRDude – Linuks Ubuntu

Uruchom terminal (naciśnij Ctrl-Alt-T) i wpisz (musisz posiadać uprawnienia administratora):

sudo add-apt-repository ppa:pmjdebruijn/avrdude-release sudo apt-get update sudo apt-get install avrdude

Aby sprawdzić komunikację AVRDude z programatorem i mikrokontrolerem, cofnij się do poprzedniego podrozdziału i zbuduj układ testowy z programatora i mikrokontrolera. Wpisz podane tam polecenia (w Linuksie nie musisz wchodzić w katalog bin). Wynik w Linuksie jest identyczny jak w Windows:

Instalacja Javy

Aplikacja Eclipse działa w środowisku maszyny wirtualnej Javy. Dlatego przed instalacją musisz się upewnić, że na twoim komputerze jest zainstalowana Java w odpowiedniej wersji. Przy instalacji należy zwrócić uwagę, aby instalowany pakiet Javy zgadzał się z systemem operacyjnym. Jeśli masz Windows 64-bitowe, to również zainstaluj Jawę 64-bitową.

Dla Eclipse potrzebny jest pakiet JRE (ang. Java Runtime-Environment) o jak najwyższym numerze wersji (na dzień dzisiejszy jest to JRE 1.8). Wejdź na podaną poniżej stronę WWW:

http://www.oracle.com/technetwork/java/javase/downloads/index.html

Na stronie wyszukaj przycisk:

Spowoduje to przejście na stronę, z której pobierzesz odpowiedni pakiet instalacyjny JRE. Zanim będziesz mógł cokolwiek pobrać, musisz zaznaczyć opcję: Accept Licence Agreement (zgoda na umowę licencyjną). Następnie wybierz odpowiedni pakiet instalacyjny (dla Windows 64-bit należy wybrać pakiet Windows x64 Offline):

Gdy pakiet zostanie pobrany na twój komputer, uruchom go. Instalacja jest bardzo prosta (musisz posiadać uprawnienia administratora): kliknij przycisk Install.

Instalacja Eclipse

Gdy na twoim komputerze jest już zainstalowana Java, możesz przystąpić do instalacji Eclipse. Przejdź do strony:

https://eclipse.org/

Każde kolejne wydania Eclipse otrzymują nazwy rozpoczynające się kolejnymi literami alfabetu. W tej chwili najnowsze wydanie nosi nazwę Neon. Na podanej stronie znajdziesz przycisk Download, który przeniesie cię do strony, z której będziesz mógł pobrać pakiet instalacyjny. Po pobraniu tego pakietu, uruchom go. Pojawi się okienko z wyborem różnych środowisk Eclipse.

Dla naszych potrzeb wybierz Eclipse IDE for C/C++ Developers. Reszta instalacji polega po prostu na zatwierdzaniu następnych okienek, dlatego nie będę tego opisywał. Gdy instalacja się zakończy, otrzymamy możliwość uruchomienia Eclipse za pomocą przycisku LAUNCH:

Konfiguracja Eclipse

Uruchamiamy Eclipse i od razu przypinamy jej ikonę do paska zadań, aby program był zawsze pod ręką. Gdy Eclipse uruchomi się po raz pierwszy, prosi o określenie tzw. przestrzeni roboczej, w której będą tworzone i zapisywane projekty:

Jeśli tej przestrzeni nie chcesz zmieniać, to zaznacz opcję Use this as the default and do not ask again (użyj tego jako wartości standardowej i nie pytaj ponownie). Zatwierdź okienko, klikając w przycisk OK. Gdy Eclipse się uruchomi, z menu wybierz opcję:

Help → Instal New Software...

Opcja ta umożliwi nam zainstalowanie w środowisku Eclipse wtyczki obsługującej projekty dla mikrokontrolerów AVR. Pojawi się okienko instalacji oprogramowania. W polu Work with (pracuj z) wpisz adres:

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

i wciśnij klawisz Enter. Jeśli na tym etapie nie popełniłeś błędu, to poniżej pojawi się wtyczka AVR (AVR Eclipse Plugin). Zaznacz ją i kliknij przycisk Next: W następnym okienku (ang. Install Details – szczegóły instalacji) również kliknij przycisk Next. Pojawi się okienko z licencją. Na spodzie zaznacz opcję: I accept the terms of the licence agreement (zgadzam się na warunki umowy licencyjnej) i kliknij przycisk Finish. Rozpocznie się pobieranie oraz instalacja wtyczki AVR:

W międzyczasie zostanie wyświetlone okienko ostrzegawcze, które uprzedza cię, że instalowane oprogramowanie nie posiada podpisu cyfrowego i nie można stwierdzić jego autentyczności. Nie przejmuj się tym i kliknij OK.

Ostatnie okienko informuje cię, że będziesz musiał ponownie uruchomić Eclipse, aby wprowadzone zmiany zaczęły działać. Zrób to. Gdy Eclipse uruchomi się ponownie, wybierz z menu opcję:

Window → Preferences

Otworzy się okienko Własności. Z lewej strony masz drzewko własności. Otwórz gałąź AVR i kliknij w Paths. Musimy tutaj podać ścieżki dostępu do poszczególnych składników toolchain'a oraz do programu AVRDude. Wprowadź ścieżki za pomocą przycisku Edit, opcję Path source (żródło ścieżki) ustawiaj na Custom (własne).

W zależności od miejsca umieszczenia toolchain'a ATMELA na twoim dysku twardym, ścieżki powinny wyglądać następująco:

Ostatnią ścieżkę do Atmel Part Description Files (opis mikrokontrolerów Atmela) nie ustawiaj i nie przejmuj się znakiem wykrzyknika.

W gałęzi AVR kliknij AVRDude. Tutaj definiujesz programatory, z którymi ma współpracować AVRDude.

Kliknij w przycisk Add... Otworzy się okienko z dosyć dużą listą programatorów.

Jeśli masz programator USBasp, to u góry w polu Configuration name (nazwa konfiguracji) wpisz USBasp (lub cokolwiek innego kojarzącego ci się z tym programatorem). W polu Description (opis) możesz wpisać kilka słów o tym programatorze, jednak nie jest to obowiązkowe. Teraz z listy wybierz: USBasp, http://www.fischl.de/usbasp/ i zatwierdź wybór przyciskiem OK. Po powrocie do okienka Preferences kliknij przycisk Apply (zastosuj) – ważne, inaczej programator nie zostanie zapamiętany.

Jeśli masz programator MK2, to u góry w polu Configuration name wpisz MK2. Z listy wybierz: Atmel AVR ISP mkII i zatwierdź wybór przyciskiem OK. Po powrocie do okienka Preferences kliknij przycisk Apply.

Można zdefiniować więcej niż jeden programator:

Zamknij okienko przyciskiem OK. Eclipse zostało skonfigurowane i jest gotowe do tworzenia programów dla mikrokontrolerów AVR.

Test Eclipse z AVR

Musisz sprawdzić, czy konfiguracja Eclipse jest poprawna i można będzie pisać programy dla mikrokontrolerów AVR przy pomocy tego środowiska. Wykorzystamy układ, który zbudowaliśmy do testowania AVRDude.

Podłącz swój programator do portu USB. Do programatora powinien być podłączony mikrokontroler na płytce stykowej (sygnały Vcc, GND, RST, SCLK, MISO i MOSI).

Uruchom Eclipse i zamknij stronę startową (na jej spodzie jest opcja, aby ta strona nie była pokazywana przy każdym uruchomieniu Eclipse). Gdy to zrobisz, ukaże się okno robocze:

Przeznaczenie poszczególnych elementów tego okna poznasz później. W panelu dolnym ustaw zakładkę Console, aby widzieć to, co będą produkowały uruchamiane przez Eclipse programy z toolchain'a.

Utworzysz teraz projekt dla swojego mikrokontrolera. Z menu wybierz opcję:

File → New → C Project

Pojawi się okno tworzenia projektu dla języka C.

W polu tekstowym Project name u góry okienka wpisz nazwę dla swojego projektu, np. test. Następnie wybierz w polu Project type w gałęzi AVR Cross Target Application opcję Empty Project (jak na powyższej ilustracji) i kliknij przycisk Next.

W następnym okienku wybierasz rodzaj konfiguracji. Debug (uruchomieniowa) i Release (ostateczna). Pozostaw te opcje włączone i kliknij przycisk Next.

W tym okienku wybierasz rodzaj mikrokontrolera (MCU Type) oraz częstotliwość jego zegara w Hz (MCU Frequency). Ja podłączyłem do programatora mikrokontroler ATtiny13. Ty musisz wybrać swój mikrokontroler, inaczej nie dojdzie do przesłania danych. Gdy to zrobisz, kliknij w przycisk Finish.

Projekt został utworzony i jego nazwę widzisz w panelu Project Explorer. Kliknij myszką w tę nazwę, a następnie wybierz z menu opcję:

Project → Properties

Musisz wybrać rodzaj programatora, który w projekcie będziesz używał do komunikacji z mikrokontrolerem. Po wybraniu z menu powyższej opcji pojawi się okienko dialogowe własności projektu.

W lewym panelu otwórz gałąź AVR i kliknij w AVRDude. Na zakładce Programmer ustaw swój programator (u mnie jest to akurat MK2) i kliknij przycisk Apply (ważne, inaczej nie zostanie to zapamiętane), po czym kliknij w OK, aby zamknąć okienko dialogowe.

Teraz musimy dodać do projektu plik z tekstem programu. Z menu wybierz opcję:

File → New → Source File

Pojawi się okienko tworzenia nowego pliku z tekstem źródłowym programu:

W polu Source file wpisz main.c i kliknij przycisk Finish. W edytorze pojawi się plik main.c. Eclipse pozwala zawijać wiersze programu (bardzo pożyteczna funkcja, szczególnie w długich programach). Wtedy po numerze wiersza pojawia się w kółeczku znak +. Aby rozwinąć wiersze, kliknij w ten znak myszką. Wiersze się rozwiną, a znak + zmieni się na znak -, który posiada funkcję przeciwną, tzn. zwija wiersze.

Tekst widoczny w oknie edytora jest tzw. komentarzem. Przejdź pod ten komentarz i wpisz następujący program:

#include <avr/io.h> int main(void) { while(1); }

Program ten nic sensownego nie robi, lecz pozwoli nam przetestować działanie IDE. Gdy wpiszesz w edytorze program, zapisz go na dysku (wciśnij Ctrl+S – ważne, gdyż inaczej program nie zostanie skompilowany). Następnie zapisany program musisz skompilować, czyli zamienić na plik binarny, który będzie następnie przesłany do mikrokontrolera w celu wykonywania zawartych w nim poleceń. Na pasku narzędziowym u góry okienka roboczego Eclipse masz ikonę młotka. Obok niej po prawej stronie znajduje się czarna strzałka w dół. Kliknij tę strzałkę i z menu wybierz konfigurację Release (przy następnej kompilacji wystarczy kliknąć w sam młotek, chyba że ponownie chcesz zmienić konfigurację):

Zostanie wywołany kompilator AVR-GCC z toolchain'a Atmela, który skompiluje program. W panelu na dole (zakładka Console) zobaczysz raport tej kompilacji, który powinien pod koniec wyglądać mniej więcej tak:

AVR Memory Usage ---------------- Device: attiny13 Program: 40 bytes (3.9% Full) (.text + .data + .bootloader) Data: 0 bytes (0.0% Full) (.data + .bss + .noinit) 'Finished building: sizedummy' ' ' 09:50:29 Build Finished (took 2s.136ms)

Zwróć uwagę na sekcję Program. Podany tam jest rozmiar utworzonego programu oraz zajętość pamięci przez ten program w mikrokontrolerze. U mnie jest to 40 bajtów i program zajmie 3,9% pamięci mikrokontrolera. Czyli wszystko w porządku.

Na koniec musisz przesłać ten program do mikrokontrolera. Upewnij, że podłączyłeś swój programator do portu USB. U góry okna Eclipse jest ikona AVR z zieloną strzałką w dół. Kliknij ją. Zostanie wywołany program AVRDude, a ten z kolei prześle skompilowany program do mikrokontrolera. W okienku konsoli powinieneś zobaczyć coś takiego:

avrdude: AVR device initialized and ready to accept instructions Reading | ################################################## | 100% -0.00s avrdude: Device signature = 0x1e9007 (probably t13) 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 (40 bytes): Writing | ################################################## | 100% 0.04s avrdude: 40 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 40 bytes avrdude: reading on-chip flash data: Reading | ################################################## | 100% 0.02s avrdude: verifying ... avrdude: 40 bytes of flash verified avrdude done. Thank you. avrdude finished

Instalacja jest zakończona, możesz rozpocząć programowanie mikrokontrolerów AVR.

nstalacja Eclipse z Centrum Oprogramowania

Pakiet Eclipse możesz zainstalować z Centrum Oprogramowania Ubuntu. Znajdziesz go w sekcji:

Narzędzia programistyczne > Zintegrowane środowiska programistyczne

Nie będzie to najnowsza wersja Eclipse, lecz do nauki i programowania jest więcej niż wystarczająca (po instalacji przejdź dalej do konfiguracji Eclipse).

Gdybyś jednak bardzo pragnął posiadać najnowszą wersję Eclipse, to postępuj wg poniżej przedstawionych instrukcji.

Instalacja Javy

Eclipse jest aplikacją działającą w środowisku maszyny wirtualnej Javy. Instalator wymaga dostępności tej maszyny, ponieważ sam jest napisany w języku Java, zatem najpierw musisz zainstalować w Ubuntu obsługę Jawy. Uruchom terminal (Ctrl+Alt+T) i wpisz (musisz posiadać uprawnienia administratora):

sudo add-apt-repository ppa:webupd8team/java sudo apt-get update sudo apt-get install oracle-java8-installer

W trakcie instalacji zostaniesz poproszony o wyrażenie zgody na warunki licencji. Dopiero po jej uzyskaniu instalator rozpocznie instalowanie Javy w twoim systemie. Gdy zakończy, sprawdź instalację przez wpisanie polecenia:

java -version

Powinieneś otrzymać coś podobnego do tego poniżej:

java version "1.8.0_101" Java(TM) SE Runtime Environment (build 1.8.0_101-b13) Java HotSpot(TM) 64-Bit Server VM (build 25.101-b13, mixed mode)

Instalacja Eclipse

Po zainstalowaniu Javy instalujesz Eclipse w sposób następujący:

Przejdź do strony: http://www.eclipse.org/downloads/. Znajdziesz na niej przycisk DOWNLOAD do pobrania instalatora Eclipse Neon (twój system powinien zostać automatycznie rozpoznany z danych przesłanych przez przeglądarkę). Kliknij w niego myszką:

Przejdziesz do strony wyboru serwera lustrzanego (serwery lustrzane przechowują te same pliki dla różnych części świata, aby zapewnić odpowiednią szybkość transmisji), na której powinien znajdować się przycisk do pobrania tego instalatora:

Kliknij myszką w przycisk DOWNLOAD, zapisz plik na dysku, a następnie otwórz go w Menedżerze archiwów (wystarczy kliknąć w plik myszką). Wewnątrz pobranego archiwum znajduje się katalog eclipse-installer:

Wypakuj go do swojego katalogu domowego (lub w inne wygodne dla ciebie miejsce) i na koniec kliknij myszką w przycisk Wyświetl pliki:

Pojawi się Menedżer plików. Otwórz katalog eclipse-installer i wyszukaj w nim plik eclipse-inst. Kliknij go dwukrotnie myszką. Instalacja Eclipse w Linuksie Ubuntu jest praktycznie identyczna jak w Windows. Gdy instalator się uruchomi, wyświetli w okienku środowiska Eclipse dla różnych języków programowania. Nas interesuje wersja Eclipse IDE for C/C++ Developers.

Wybierz ją, w następnym okienku kliknij w przycisk Install, a proces instalacji się rozpocznie – w trakcie będziesz poproszony o zgodę na warunki licencji oraz o zatwierdzenie źródła instalacji.

Konfiguracja Eclipse

Gdy instalacja się zakończy, Eclipse znajdziesz w:

Katalog domowy/eclipse/cpp-neon/eclipse

Wejdź do tego katalogu i uruchom zawarty w nim plik Eclipse. Program od razu przypnij do panelu uruchamiania, aby był zawsze pod ręką. Przy pierwszym uruchomieniu Eclipse prosi o podanie katalogu roboczego, w którym będą zapisywane projekty. Standardowo jest to katalog workspace w twoim katalogu domowym, ale oczywiście możesz wybrać inny (jest to istotne wtedy, gdy używasz kilku egzemplarzy środowiska Eclipse do różnych celów, a wtedy lepiej mieć różne przestrzenie robocze).

Aby nie być każdorazowo pytanym o ten katalog przy uruchamianiu Eclipse, zaznacz opcję Use this as the default and do not ask again (Użyj tego jako opcji standardowej i nie pytaj więcej). Zatwierdź okienko klawiszem OK.

Gdy pojawi się okno robocze Eclipse, musisz zainstalować wtyczkę, która umożliwi współpracę z toolchain'em Atmela. Z menu wybierz opcję:

Help → Instal New Software...

Pojawi się okienko dialogowe instalacji nowego oprogramowania. W polu Work with (pracuj z) wpisz poniższy adres:

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

i naciśnij klawisz Enter. Eclipse skontaktuje się z podaną witryną WWW i pobierze z niej informacje o dostępnych wtyczkach. Na liście poniżej powinna pojawić się wtyczka AVR Eclipse Plugin:

Zaznacz ją i kliknij w przycisk Next. W następnym oknie dialogowym zostaniesz poinformowany o szczegółach wybranej wtyczki. Kliknij w nim w przycisk Next. Kolejne okienko dialogowe wyświetli umowę licencyjną i poprosi cię o zgodę na jej warunki. Zaznacz opcję I accept the terms of the licence agreement (akceptuję warunki tej umowy licencyjnej) i kliknij przycisk Finish. Rozpocznie się instalacja wtyczki AVR:

W pewnym momencie pojawi się okienko z ostrzeżeniem, że instalujesz niepodpisane oprogramowanie. Podpis elektroniczny wymaga rejestracji i uiszczenia różnych opłat, aby był utrzymywany na serwerach w sieci Internet. Sam rozumiesz, że wolne oprogramowanie takich funduszy zwykle nie posiada. Wtyczka jest bezpieczna, korzystają z niej miliony użytkowników na całym świecie.

Zatem zatwierdź okienko przyciskiem OK i instalacja będzie kontynuowana. Po zakończeniu instalacji wtyczki AVR pojawi się okienko informujące cię, że Eclipse musi być uruchomione jeszcze raz, aby wtyczka zaczęła działać:

Kliknij w przycisk Yes i uruchom ponownie Eclipse. Teraz musisz skonfigurować wtyczkę AVR oraz program AVRDude. W menu wybierz opcję

Window → Preferences

Pojawi się okienko dialogowe własności (ang. Preferences). Na drzewku własności w lewym panelu otwórz gałąź AVR i kliknij w Paths (ścieżki). Na liście ścieżek dwie są niezdefiniowane:

Wybierz AVR-GCC i kliknij w przycisk Edit. W okienku dialogowym, które się pojawi zmień Path source (źródło ścieżki) na Custom (własne), następnie kliknij przycisk Browse... (przeglądaj) i wybierz katalog bin w toolchain'ie Atmela:

Zatwierdź ścieżkę przyciskiem OK. Podobnie postąp ze ścieżką AVR Header Files. Tym razem wybierz katalog avr/include w toolchain'ie Atmela.

Jeśli wszystko wykonałeś poprawnie, to lista ścieżek powinna wyglądać następująco:

Po ustawieniu ścieżek do toolchain'u musisz skonfigurować AVRDude do obsługi twoich programatorów. W lewym panelu drzewka własności kliknij w AVRDude. Zawartość okienka dialogowego zmieni się. Kliknij w przycisk Add, który znajduje się po prawej stronie. Pojawi się duże okno z listą programatorów.

Dla programatora USBasp:

W polu Configuration name (nazwa konfiguracji) wpisz USBasp.

W polu Description (opis) możesz umieścić krótki opis tego programatora, np. Dla ATtiny.

Na liście programatorów wyszukaj i zaznacz: USBasp, http://www.fischl.de/usbasp/

Kliknij przycisk OK.

Dla programatora MK2:

W polu Configuration name (nazwa konfiguracji) wpisz MK2.

W polu Description (opis) możesz umieścić krótki opis tego programatora, np. Dla ATmega.

Na liście programatorów wyszukaj i zaznacz: Atmel AVR ISP mkII

Kliknij przycisk OK.

Ważne: po zdefiniowaniu konfiguracji programatora koniecznie kliknij w przycisk Apply (zastosuj), inaczej nic nie zostanie zapamiętane.

Gdy zdefiniujesz konfigurację AVRDude do współpracy z twoim programatorem, zamknij okienko własności klikając w przycisk OK.

Na koniec wybierz w menu opcję:

Window → Perspective → Open Perspective → Other...

I w okienku Open Perspective zaznacz C/C++ i kliknij OK. Spowoduje to przełączenie środowiska Eclipse do trybu tworzenia programów w języku C (lub C++, ale z tej opcji tutaj nie będziemy korzystać).

Instalacja jest zakończona. Pozostało nam sprawdzenie poprawności działania Eclipse. Wykonujemy to identycznie jak w systemie Windows, zatem przejdź do tego podrozdziału.