Serwis Edukacyjny
Nauczycieli
w I-LO w Tarnowie

Do strony głównej I LO w Tarnowie

Materiały dla uczniów liceum

  Wyjście       Spis treści       Poprzedni       Następny  

©2019 mgr Jerzy Wałaszek
I LO w Tarnowie

Autor artykułu: mgr Jerzy Wałaszek
Konsultacje: Wojciech Grodowski, mgr inż. Janusz Wałaszek

 

 

Warsztat elektronika

Instalacja Eclipse z AVRDude

 

Do czego służy program Eclipse

Eclipse jest zintegrowanym środowiskiem programowania (ang. IDE = Integrated Development Environment). Jest to oprogramowanie, które w wygodny sposób umożliwia ci tworzenie programów dla mikrokontrolerów AVR. Dzięki Eclipse łatwo utworzysz projekt dla określonego mikrokontrolera, utworzysz dla niego program w edytorze z podświetlaniem składni, skompilujesz i prześlesz z PC-ta na mikrokontroler. Wszystko w jednym miejscu. Dawniej zadanie to wymagało ręcznego uruchamiania wielu różnych programów, a dzisiaj to samo masz po kliknięciu w jeden przycisk.

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

 

Instalacja programatora AVR

Procedura tworzenia programu dla mikrokontrolera jest następująca:

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):

Przejdź do witryny http://zadig.akeo.ie/ i załaduj z niej na swój komputer program zadig w wersji dla Windows Vista lub późniejszej. Program zadig instaluje sterowniki urządzeń USB.

Podłącz do portu USB swój programatow USBasp.

Uruchom pobrany program zadig. Instalacja sterowników wymaga uprawnień administratora, zatem może pojawić się okno dialogowe, które wymaga od ciebie potwierdzenia instalacji. Program zadiag powinien rozpoznać programator jako USBasp. Jeśli tak się nie dzieje, to wyjmij programator z portu USB i spróbuj podłączyć go jeszcze raz. Jeśli wciąż się nic nie pokazuje, to masz coś pomieszane w konfiguracji urządzeń (powinien to oglądnąć jakiś zaprzyjaźniony informatyk, ponieważ trudno podać jedną ogólną przyczynę).

Gdy zadig rozpozna programator, to w okienku u góry pojawi się napis USBasp. Pozostaje ci wybrać odpowiedni sterownik: libusb-win32 (v1.2.6.0):

i kliknąć przycisk Instal Driver. Gdy sterownik zostanie zainstalowany, pojawi się okienko:

Kliknij w przycisk Close i zamknij program zadig. Instalacja programatora USBasp jest skończona.

Kliknij prawym przyciskiem myszki w przycisk Start (Windows 10) i z menu kontekstowego wybierz opcję Menedżer urządzeń. Na liście urządzeń powinno pojawić się:

USBasp – Linux Ubuntu

W systemie Linux 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 – Linux 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.

 

Instalacja toolchain'a firmy ATMEL

Toolchain (czytaj tulczejn) jest słowem angielskim, które na język polski można przetłumaczyć jako "łańcuch narzędzi", czyli jest to grupa programów narzędziowych służących jakiemuś celowi. W naszym przypadku chodzi o programy do tworzenia oprogramowania dla mikrokontrolerów AVR produkowanych przez firmę ATMEL. W skład tych programów wchodzą takie narzędzia jak kompilator, linker oraz pliki z definicjami dla poszczególnych mikrokontrolerów (obejmującymi typy danych, nazwy rejestrów oraz ich bitów itp.).

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 – Linux 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 Linuxa (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.

 

Instalacja AVRDude

Do komunikacji z programatorem mikrokontrolerów AVR potrzebny jest program AVRDude.

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:

http://www.forbot.pl/forum/upload_img/obrazki/IMG_4ff4d80933ca49873.png

 

Vcc napięcie zasilające mikrokontroler, zwykle +5V
GND masa
MOSI (ang. Master Out Slave In), sygnał przesyłu danych od programatora do mikrokontrolera, np. zapis programu
LED sterowanie diodą LED, można pominąć
RST (ang. ReSeT), sygnał podłączany do wejścia RESET mikrokontrolera, stan niski inicjuje komunikację przez programator
SCK (ang. Serial Clock), impulsy synchronizujące przesyłanie bitów danych
MISO (ang. Master In Slave Out), sygnał przesyłu danych od mikrokontrolera do programatora, np. odczyt pamięci.

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:

-c programator określa programator, z którym ma współpracować AVRDude:

usbasp
avrisp2 lub avrispmkii dla MK2

-p mikrokontroler określa rodzaj mikrokontrolera, z którym ma współpracować programator:
t13  –  ATtiny13
t24  –  ATtiny 24
t2313  –  ATtiny 2313
m8  –  ATmega 8

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 – Linux 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 Linuxie nie musisz wchodzić w katalog bin). Wynik w Linuxie jest identyczny jak w Windows:

 

Instalacja Eclipse dla Windows

Dopiero teraz, po zainstalowaniu poprzednich składników, jesteś gotowy na zainstalowanie Eclipse.

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:

AVR-GCC  –  kompilator, znajduje się w katalogu bin
GNU make  –  narzędzie do tworzenia programu wynikowego, katalog bin
AVR Header Files  –  pliki nagłówkowe, katalog avr\include
AVRDude  –  program komunikacyjny, katalog bin

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.

 

Instalacja Eclipse dla Linuxa Ubuntu

Instalacja 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 Linuxie 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:

AVR-GCC    ścieżka do kompilatora AVR
AVR Header Files    ścieżka do plików nagłówkowych

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.

Zespół Przedmiotowy
Chemii-Fizyki-Informatyki

w I Liceum Ogólnokształcącym
im. Kazimierza Brodzińskiego
w Tarnowie
ul. Piłsudskiego 4
©2019 mgr Jerzy Wałaszek

Materiały tylko do użytku dydaktycznego. Ich kopiowanie i powielanie jest dozwolone
pod warunkiem podania źródła oraz niepobierania za to pieniędzy.

Pytania proszę przesyłać na adres email: i-lo@eduinf.waw.pl

Serwis wykorzystuje pliki cookies. Jeśli nie chcesz ich otrzymywać, zablokuj je w swojej przeglądarce.
Informacje dodatkowe.