Mirley - Elektronika i Programowanie

Artykuł ten ma rozjaśnić programowanie mikrokontrolerów AVR w programie AVRDude, ten darmowy i znakomity program obsługuje wiele programatorów (np. USBAsp, STK200/300, STK500, Bascom SAMPLE Cable itp) a ponadto jest darmowy i pracuje bezproblemowo pod Linuxem i Windowsem, co jest jego ogromną zaletą. AVRDude jest programem konsolowym (tekstowym) jednak posiada wiele nakładek graficznych ułatwiających pracę.

1. Instalacja AVRdude i praca w trybie tekstowym

AVRDude pod Windowsem nie wymaga instalacji a jedynie ściągnięcia i rozpakowania archiwum do określonego folderu (najlepiej C:\Program Files\avrdude). Wersja której ja używam (5.5) znajduje się tutaj, natomiast najnowszych wersji można poszukać na stronie http://mirror.lihnidos.org/GNU/savannah/avrdude/ . Pod Linuxem instalacja sprowadza się do zainstalowania specjalnej paczki dla mikrokontrolerów AVR (przynajmniej tak jest pod ArchLinux i Ubuntu). Dalsza część opisu dotyczyć będzie pracy pod Windowsem, gdyż pod systemem Linux ten tryb pracy jest wszystkim dobrze znany a komendy w konsoli dla AVRDude są identyczne.

Uruchamiamy konsolę wpisując cmd w linii poleceń (Start->Uruchom) i przechodzimy do folderu w którym mamy AVRDude (domyślnie jest to C:\Program Files\avrdude). Powinno to wyglądać tak:

Jesteśmy teraz przygotowani do pracy. Po wpisaniu w konsoli avrdude bez żadnych parametrów program wyrzuca listę dostępnych poleceń:

C:\Program Files\avrdude>avrdude
Usage: avrdude [options]
Options:
  -p <partno>                Required. Specify AVR device.
  -b <baudrate>              Override RS-232 baud rate.
  -B <bitclock>              Specify JTAG/STK500v2 bit clock period (us).
  -C <config-file>           Specify location of configuration file.
  -c <programmer>            Specify programmer type.
  -D                         Disable auto erase for flash memory
  -i <delay>                 ISP Clock Delay [in microseconds]
  -P <port>                  Specify connection port.
  -F                         Override invalid signature check.
  -e                         Perform a chip erase.
  -O                         Perform RC oscillator calibration (see AVR053).
  -U <memtype>:r|w|v:<filename>[:format]
                             Memory operation specification.
                             Multiple -U options are allowed, each request
                             is performed in the order specified.
  -n                         Do not write anything to the device.
  -V                         Do not verify.
  -u                         Disable safemode, default when running from a script.
  -s                         Silent safemode operation, will not ask you if
                             fuses should be changed back.
  -t                         Enter terminal mode.
  -E <exitspec>[,<exitspec>] List programmer exit specifications.
  -y                         Count # erase cycles in EEPROM.
  -Y <number>                Initialize erase cycle # in EEPROM.
  -v                         Verbose output. -v -v for more.
  -q                         Quell progress output. -q -q for less.
  -?                         Display this usage.
 
avrdude project: <URL:http://savannah.nongnu.org/projects/avrdude>

Wykonujemy teraz proste polecenie pozwalające na sprawdzenie komunikacji między procesorem a komputerem:

avrdude -c usbasp -p t2313

Oczywiście uprzednio programator musi być podłączony do komputera a procesor do programatora. Zasilanie całości musi być włączone (procesora i ewentualnie programatora jeśli tego wymaga). Polecenie to nie wgrywa nic do procesora ale odczytuje jego sygnaturę, co pozwala sprawdzić czy komunikacja przebiega prawidłowo. Składnia tego polecenia wygląda następująco:

avrdude -c {programator} -p {typ procesora}

Nazwy kodowe procesorów i programatorów jakie obsługuje AVRDude przedstawione są na końcu tego rozdziału. Gdy programator jest podłączony do komputera i procesor ma podłączone zasilanie to powinniśmy otrzymać następujący wynik:

avrdude: AVR device initialized and ready to accept instructions
 
Reading | ################################################## | 100% 0.00s
 
avrdude: Device signature = 0x1e910a
 
avrdude: safemode: Fuses OK
 
avrdude done.  Thank you.

gdy natomiast występuje problem z komunikacją to dostaniemy następujący komunikat:

avrdude: error: programm enable: target doesn't answer. 1
avrdude: AVR device initialized and ready to accept instructions
 
Reading | ################################################## | 100% 0.02s
 
avrdude: Device signature = 0x000000
avrdude: Yikes!  Invalid device signature.
         Double check connections and try again, or use -F to override
         this check.

Jeśli otrzymujesz dowolny komunikat o błędzie to nie wykonuj dalszych poleceń bo jest to bez sensu. Jeśli natomiast wszystko przebiega zgodnie z opisem to można przystąpić do wgrywania programu to mikrokontrolera. Odczyt programu z pamięci mikrokontrolera do pliku *.hex następuje po wykonaniu polecenia:

avrdude -c usbasp -p t2313 -U flash:r:program.hex

Natomiast zapis programu z pliku *.hex do pamięci mikrokontrolera dokonujemy za pomocą:

avrdude -c usbasp -p t2313 -U flash:w:program.hex

Możliwe jest jeszcze ustawienie fusebitów z poziomu konsoli tekstowej ale nie zalecam tej metody(o wiele łatwiej dokonać tego w programie graficznym) gdyż nie jest to zadanie dla początkujących. Jednak gdyby ktoś bardzo chciał to można dokonać ustawień za pomocą komendy:

avrdude -c usbasp -p t2313 -U hfuse:w:0x{wartość}:m -U lfuse:w:0x{wartość}:m 

Gdzie pola wartość to liczby heksadecymalne przedstawiające stan rejestrów hfuse i lfuse mikrokontrolera. Wartości te można obliczyć na podstawie karty katalogowej mikrokontrolera(ale to tylko dla ambitnych)

Poniżej przedstawione są programatory obsługiwane przez AVRDude:

dasa3 = serial port banging, reset=!dtr sck=rts mosi=txd miso=cts
dasa = serial port banging, reset=rts sck=dtr mosi=txd miso=cts
siprog = Lancos SI-Prog
ponyser = design ponyprog serial, reset=!txd sck=rts mosi=dtr miso=cts
frank-stk200 = Frank STK200
blaster = Altera ByteBlaster
ere-isp-avr = ERE ISP-AVR
atisp = AT-ISP V1.1 programming cable for AVR-SDK1 from
dapa = Direct AVR Parallel Access cable
xil = Xilinx JTAG cable
futurlec = Futurlec.com programming cable.
abcmini = ABCmini Board, aka Dick Smith HOTCHIP
picoweb = Picoweb Programming Cable, http://www.picoweb.net/
sp12 = Steve Bolt's Programmer
alf = Nightshade ALF-PgmAVR, http://nightshade.homeip.net/
bascom = Bascom SAMPLE programming cable
dt006 = Dontronics DT006
pony-stk200 = Pony Prog STK200
stk200 = STK200
bsd = Brian Dean's Programmer, http://www.bsdhome.com/avrdude/
pavr = Jason Kyle's pAVR Serial Programmer
dragon_dw = Atmel AVR Dragon in debugWire mode
dragon_hvsp = Atmel AVR Dragon in HVSP mode
dragon_pp = Atmel AVR Dragon in PP mode
dragon_isp = Atmel AVR Dragon in ISP mode
dragon_jtag = Atmel AVR Dragon in JTAG mode
jtag2dw = Atmel JTAG ICE mkII in debugWire mode
jtag2isp = Atmel JTAG ICE mkII in ISP mode
jtag2 = Atmel JTAG ICE mkII
jtag2fast = Atmel JTAG ICE mkII
jtag2slow = Atmel JTAG ICE mkII
jtagmkII = Atmel JTAG ICE mkII
jtag1slow = Atmel JTAG ICE (mkI)
jtag1 = Atmel JTAG ICE (mkI)
jtagmkI = Atmel JTAG ICE (mkI)
avr911 = Atmel AppNote AVR911 AVROSP
avr109 = Atmel AppNote AVR109 Boot Loader
butterfly = Atmel Butterfly Development Board
usbasp = USBasp, http://www.fischl.de/usbasp/
avr910 = Atmel Low Cost Serial Programmer
stk500hvsp = Atmel STK500 V2 in high-voltage serial programming mode
stk500pp = Atmel STK500 V2 in parallel programming mode
stk500v2 = Atmel STK500 Version 2.x firmware (DualAVR)
stk500v1 = Atmel STK500 Version 1.x firmware
stk500 = Atmel STK500
avrisp2 = Atmel AVR ISP mkII
avrispmkII = Atmel AVR ISP mkII
avrispv2 = Atmel AVR ISP V2
avrisp = Atmel AVR ISP

oraz nazwy procesorów używane przez AVRDude:

m6450 = ATMEGA6450
m3250 = ATMEGA3250
m645 = ATMEGA645
usb1287 = AT90USB1287
usb1286 = AT90USB1286
usb647 = AT90USB647
usb646 = AT90USB646
t84 = ATtiny84
t44 = ATtiny44
t24 = ATtiny24
m2561 = ATMEGA2561
m2560 = ATMEGA2560
m1281 = ATMEGA1281
m1280 = ATMEGA1280
m640 = ATMEGA640
t85 = ATtiny85
t45 = ATtiny45
t25 = ATtiny25
pwm3 = AT90PWM3
pwm2 = AT90PWM2
t2313 = ATtiny2313
m168 = ATMEGA168
m88 = ATMEGA88
m48 = ATMEGA48
t861 = ATTINY861
t461 = ATTINY461
t261 = ATTINY261
t26 = ATTINY26
m8535 = ATMEGA8535
m8515 = ATMEGA8515
m8 = ATMEGA8
m161 = ATMEGA161
m32 = ATMEGA32
m6490 = ATMEGA6490
m649 = ATMEGA649
m3290 = ATMEGA3290
m329 = ATMEGA329
m169 = ATMEGA169
m163 = ATMEGA163
m162 = ATMEGA162
m644 = ATMEGA644
m324 = ATMEGA324
m164 = ATMEGA164
m16 = ATMEGA16
c128 = AT90CAN128
m128 = ATMEGA128
m64 = ATMEGA64
m103 = ATMEGA103
8535 = AT90S8535
8515 = AT90S8515
4434 = AT90S4434
4433 = AT90S4433
2343 = AT90S2343
2333 = AT90S2333
2313 = AT90S2313
4414 = AT90S4414
1200 = AT90S1200
t15 = ATtiny15
t13 = ATtiny13
t12 = ATtiny12
t11 = ATtiny11

2. Instalacja i Konfiguracja Burn-O-Mat'a

AVRDude jest bardzo dobrym programem jednak jego obsługa z poziomu konsoli tekstowej może wydawać się skomplikowana. Dlatego wykorzystuje się nakładki graficzne na AVRDude (programy generujące polecenia dla AVRDude) ułatwiające pracę z tym programem. Jedną z nich jest Burn-O-Mat, polecam go ponieważ obsługa jest bardzo intuicyjna a ustawienia Fusebitów banalne. Program można pobrać tutaj. Znajduje się tam wersja w postaci instalatora Windows albo spakowany program w formacie *.zip (Ta wersja działa również pod Linuxem a uruchamianie następuje poprzez znajdujący się tam skrypt powłoki, lub bezpośrednio z konsoli za pomocą Java). Program Burn-O-Mat napisany jest w Javie, więc wymaga zainstalowania pakietu JRE (http://java.sun.com/javase/downloads/index.jsp).

Po zainstalowaniu lub wypakowaniu programu, uruchamiamy go, powinno to wyglądać jak na rysunku poniżej:

Zanim zaczniemy programować mikrokontroler musimy dokonać kilku ustawień w menu Settings->AVRDUDE (bez tego nic nie zaprogramujemy), ale o tym za chwilę. W głównym oknie znajduje się jeszcze pole do wyboru typu mikrokontrolera AVR Type i przycisk wywołujący okno ustawień jego fusebitów (Fuses), jednak o tym powiemy na samym końcu. Tutaj znajdują się jeszcze funkcje umożliwaijące zaprogramowanie pamięci programu (Flash) i pamięci EEPROM mikrokontrolera. Aby zaprogramować procesor wystarczy wybrać plik *.hex z dysku za pomocą przycisku File i kliknąć przycisk Write, weryfikacja poprawności zapisanych danych odbywa się po wciśnięciu Verify, a odczyt danych z mikrokontrolera po klinięciu Read. Analogicznie sprawa wygląda podczas programowania pamięci EEPROM, tylko że służą do tego odpowiednie przyciski w sekcji EEPROM, a dodatkowo można też wgrywać plik *.eep wygenerowany przez Bascom'a. Główne okno programu zawiera jeszcze pole tekstowe, w którym można podglądać parametry z jakimi program Burn-O-Mat wywołuje AVRDude i jego odpowiedzi.

Ustawień programu, jak już wcześniej mówiłem dokonujemy wybierając z menu Settings->AVRDUDE, musimy tego dokonać zanim przystapimy do programowania. Okno ustawień wygląda następująco:

Na samym początku wybieramy ścieżkę dostępu do programu AVRDude (avrdude.exe) i do jego pliku konfiguracyjnego (avrdude.conf), po czym klikamy Apply i uruchamiamy ponownie program Burn-O-Mat aby mogły się wczytać ustawienia i typy programatorów z pliku konfiguracyjnego AVRDude. Po ponownym uruchomieniu programu wchodzimy do ustawień i tym razem konfigurujemy typ programatora (Programmer) i port do którego jest podłączony (nie wszystkie programatory wymagają ustawienia portu, np USBASP, którego sam używam tego nie wymaga). Poniższe opcje, możliwe do zaznaczenia, pozostawiamy odznaczone (tak jak na rysunku wyżej). Na samym dole mamy jeszcze możliwość dopisać ręcznie do AVRDude dodatkowe parametry wywołania (additional options), jednak pozostawmy to pole puste, gdyż nie jest to wymagane. Po tych czynnościach klikamy Apply okceptując ustawienia.

W oknie głównym programu za pomocą przycisku Fuses przechodzimy do ustawień fusebitów (bitów konfiguracyjnych) mikrokontrolera. Widzimy następujące okno:

U góry okna począwszy od lewej mamy przyciski umożliwiające: Odczyt fusebitów (read fuses), Zapis fusebitów (write fuses), weryfikacje ustawień (verify fuses) oraz Reset do wartości domyślnych (reset to default). Poniżej znajdują się zakładki umożliwiające ustawienie Fusebitów różnymi sposobami, nas bedzie interesowała pierwsza zakładka (Fuse Editor) pozwalająca konfigurować pojedyńcze bity i ewentualnie druga (Fuse Hex Editor) pozwalająca wpisywać wartości szesnastkowo. Zakładki te są ze sobą powiązane i zmiana wartości w jednej zmienia wartości w drugiej. Na zakładce pierwszej widzimy tabelkę z pojedyńczymi bitami, tych zaznaczonych na czerwono nie można przestawiać, gdyż nieumiejętne wpisanie złej wartości może zablokować dalszą możliwość programowania procesora (zmiana trybu Mode:normal na Mode:expert u góry okna pozwala ustawiać wszystko). Tabela z bitami konfoguracyjnymi jest dla każdego mikrokontrolera inna a dokładny opis wszystkich bitów znajduje się w karcie katalogowej danego mikrokontrolera. Podstawowe ustawienia dla najczęściej używanych mikrokontrolerów przedstawiłem w opisie tutaj. Należy pamiętać że zaprogramowany bit to bit o wartości 0, czyli zaznaczenie "ptaszkiem" bitu nadaje mu wartość 0 (jest to napisane w programie pod tabelką). Dla przykładu gdy mamy ustawić np. CKSEL=0100, SUT=10 i CKDIV8=0 to znaczy że zaznaczmy bity CKSEL0, CKSEL1, CKSEL3, SUT0, CKDIV8 a odznaczmy CKSEL2 i SUT1 (widok powyżej na zdjęciu)

Konfigurację Fusebitów dobrze jest wykonać w następującej kolejności: Najpierw odczytujemy wcześniejsze ustawienia za pomocą przycisku read fuses, potem jeśli operacja nie wygeneruje błędów to ustawiamy żądane wartości, na samym końcu klikamy write fuses. Należy pamiętać, że jeśli ustawimy sobie taktowanie (za pomocą bitów CKSEL) z zewnętrznego rezonatora kwarcowego to po kliknięciu write fuses procesor nie ruszy dopuki nie podłączymy takiego kwarca.

3. Konfiguracja Bascom AVR do współpracy z AVRDude

Pod Windowsem istnieje możliwość współpracy programu Bascom AVR z AVRDude. Aby to zrobić wykonujemy następujące czynności. Aby to zrobić wchodzimy do ustawień programatora w Bascomie (Options->Programmer). Okno ustawień powinno wyględać jak na rysunku poniżej:

W polu Programmer wybieramy Extrenal programmer. W części Other w polu Program wybieramy scieżkę do AVRDude, w polu Parameter wpisujemy:

"avrdude" -p m8 -c usbasp -U flash:w:"{FILE}":a -U flash:v:"{FILE}":a

oczywiście m8 jest typem aktualnie programowanego mikrokontrolera, a zamiast usbasp musimy podać nazwę naszego programatora (analogicznie jak jest to opisane w rozdziale pierwszym). Drobną niedogodnością jest konieczność przestawiania w opcjach Bascom'a typu mikrokontrolera na ten który aktualnie programujemy za każdym razem kiedy piszemy program pod inny mikrokontroler niż ostatnio, oraz tym sposobem nie są programowane Fusebity ani pamięć EEPROM mikrokontrolera. Mimo wszystko taka konfiguracja jest bardzo przydatna podczas testów nad nowym projektem, lub gdy programujemy płytke testową (wielokrotne programowanie tylko pamięci programu), bo pozwala w kilka sekund wrzucić program do procesora nie wychodząc z okna Bascoma (tylko na początku trzeba ustawić Fusebity w Burn-O-Mat).