Atmel Studio - Programatory

Autor: tmf

Redakcja: Dondu

Artykuł jest częścią cyklu: Atmel Studio - Spis treści

W drugiej części mini-kursu poświęconego Atmel Studio pokazane zostanie jak wybierać narzędzia do programowania/debugowania mikrokontrolerów. Jest to o tyle ważne, że dzięki prostej konfiguracji będziemy mieli możliwość programowania/debugowania mikrokontrolerów wprost z IDE (środowisko programistyczne, w naszym przypadku Atmel Studio), bez konieczności uruchamiania programów zewnętrznych.


Zacznijmy więc od samych programatorów.

Na rynku mamy dziesiątki różnych wersji. Ja na początek proponowałbym użyć narzędzi dostarczonych przez firmę Atmel. Są one nieco droższe, ale moim zdaniem warte swojej ceny.


AVRISP
Dla osób mających ograniczony budżet proponuję AVRISP, który można kupić za około 60-80 zł (są to różne klony, jednak w pełni kompatybilne z oryginałem). Pamiętać jednak należy, że AVRISP programuje tylko mikrokontrolery ATtiny oraz ATmega posiadające interfejs ISP i nie jest bezpośrednio wspierany przez Atmel Studio 6. Jednak można „pośrednio” go z tym programem spiąć.

AVRISPMkII
To nieco droższa opcja (w granicach 170 zł). Jest to unowocześniona wersja AVRISP, która oprócz programowania starszych mikrokontrolerów, umożliwia także programowanie nowszych, wyposażonych w interfejs PDI.

AVRISPMkII na stronie Atmel'a.

Dragon
Jeśli jednak jest ktoś gotów wydać 170 zł na taki programator, to proponuję jeszcze trochę zacisnąć pasa i kupić AVR Dragon. Jak sama nazwa wskazuje, jest to prawdziwy smok – umożliwia programowanie wszystkich mikrokontrolerów AVR, przy cenie około 220 zł. Obsługuje on wszystkie interfejsy (ISP, PDI, dW, JTAG, HV, parallel), jednak jak to ze smokami bywa - trzeba się z nim obchodzić ostrożnie. 


Dragon na stronie Atmela.


Dragon sprzedawany jest jako goła płytka drukowana z przylutowanymi elementami. Sami musimy sobie kupić kabel USB, oraz wykonać kable łączące interfejsy Dragona z naszymi układami. Jednak pamiętajmy, że za tą w sumie niewielką cenę dostajemy układ o możliwościach przewyższających półprofesjonalny JTAGICEMkII, który kosztuje ponad 1200 zł! 


Jak widzimy na liście interfejsów pojawia się JTAG – dzięki temu zyskamy nie tylko możliwość programowania układów, ale także ich sprzętowego debugowania. Jakie daje to możliwości – może opiszemy w kolejnych artykułach.


Praca na różnych napięciach
Olbrzymią przewagą programatorów oryginalnych (oprócz wsparcia w Atmel Studio), jest ich dostosowanie do pracy z układami programowanymi w zakresie napięć 1,8-5V. W najbliższych latach, standard 5V będzie nieuchronnie odchodził do lamusa, a już obecnie zaczynają dominować układy zasilane napięciem 3,3V. Niższe napięcie zasilające to także niższy pobór prądu, co ma szczególne znaczenie dla urządzeń zasilanych z baterii.

Większość programatorów „homemade” nie ma możliwości pracy z napięciami innymi niż 5V, co czyni je w niektórych zastosowaniach małoprzydatnymi.

Konfiguracja programatora w Atmel Studio

Właściwie wszystkie obecnie sprzedawane programatory wyposażone są w interfejs USB. Wystarczy więc tylko włożyć kabel USB do komputera i programatora, po czym system powinien rozpoznać nowe urządzenie i rozpocząć instalację sterowników. Jeśli wszystko przebiegło pomyślnie powinniśmy dostać komunikat jak poniżej (do komputera został podłączony AVRISPMkII):

Warto upewnić się, że wszystko jest ok, przeglądając menagera urządzeń:

Urządzenia firmy Atmel korzystają ze sterownika Jungo (który jest instalowany razem z Atmel Studio), stąd też na liście urządzeń powinny znajdować się w zakładce o nazwie Jungo. Po instalacji urządzenie jest gotowe do użycia.

Pamiętaj, aby najpierw zainstalować Atmel Studio, a dopiero potem podpinać programatory. Postępowanie odwrotne sprawi, że system operacyjny nie będzie mógł odnaleźć potrzebnych sterowników i urządzenie nie będzie działało.

Oczywiście sterowniki można pobrać „ręcznie” i cały proces instalacji przeprowadzić manualnie, ale przecież miało być łatwo – a nie o to chodzi, aby posiadając śrubokręt wkręcać śrubki nożem.
Po poprawnym zainstalowaniu urządzeń, uruchamiamy Atmel Studio i przechodzimy do właściwości wcześniej utworzonego projektu (Project->Properties...). Wybieramy zakładkę Tool i w Selected debugger/programmer wybieramy posiadany programator:

Jak widzimy w okienku Selected debugger/programmer można wybrać tylko te urządzenia, które są dostępne w komputerze.

Jeśli posiadany programator nie będzie poprawnie zainstalowany w systemie, to nie będzie możliwości jego wyboru w Atmel Studio.

Oprócz nazwy programatora pojawia się dodatkowo jego numer seryjny – jest on przydatny jeśli w wystemie mamy zainstalowanych kilka programatorów tego samego typu (co jednak jest mało prawdopodobne). W ten sposób poszczególne programatory można od siebie odróżnić.

Drugą opcją po wybraniu programatora jest wybór interfejsu do programowania. Zarówno AVRISPMkII, jak i Dragon, czy JTAGICEMkII dysponują kilkoma interfejsami do wyboru.

Na liście interfejsów pojawią się wyłącznie te interfejsy, które wspiera wybrany programator i mikrokontroler.

Stąd też, co prawda pokazany AVRISPMkII wspiera interfejsy ISP oraz PDI, jednak wybrany w poprzedniej części kursu mikrokontroler ATMega128 wspiera tylko ISP i JTAG. W efekcie dla naszego programatora jedyną możliwością jest wybór interfejsu ISP.

Dla interfejsu ISP ważna jest także częstotliwość przesyłu danych.

Pamiętaj, że zastosowany zegar taktujący ISP musi być co najmniej 4-krotnie niższy niż zegar taktujący mikrokontroler. W przeciwnym przypadku programowanie nie będzie możliwe.

I tak, jeśli wybrany mikrokontroler jest taktowany zegarem 2 MHz, to maksymalna częstotliwość zegara ISP nie może być wyższa niż 500 kHz. W większości przypadków domyślne ustawienie jakim jest 250 kHz jest poprawne. Możemy je zwiększyć, co przyśpieszy programowanie mikrokontrolera, w rzadkich przypadkach, kiedy mikrokontroler jest taktowany zegarem o ultraniskiej częstotliwości (np. z kwarcu zegarkowego) należy je zmniejszyć. Pozostałe opcje dla interfejsu ISP na tej zakładce możemy zostawić bez zmian.


Jeśli korzystamy z Dragon'a, to do wyboru będziemy mieli (w przypadku ATMega128), aż 3 interfejsy: ISP, HV i JTAG:

Musimy wybrać taki interfejs jaki jest wykorzystywany w układzie. Stąd też wybór jednego z powyższych interfejsów jest determinowany poprzez wykonane połączenia pomiędzy mikrokontrolerem, a gniazdem programatora.

Dla interfejsu JTAG pojawiają się dodatkowe opcje związane z konfiguracją Daisy Chain (umożliwiającą łączenie w szereg wielu mikrokontrolerów/urządzeń wspierających JTAG – szczegóły znajdziesz w książce „Język C dla mikrokontrolerów AVR – od podstaw do zaawansowanych aplikacji"). W większości przypadków poniższe opcje zostawiamy bez zmian.


Symulator

Niezależnie od podłączonych programatorów zawsze na liście wyboru programatora dostępna jest jedna opcja dodatkowa – AVR Simulator.

Co to takiego? Jest to coś czego nie mają użytkownicy innych IDE (a przynajmniej nie mają tego w formie tak rozbudowanej i dobrze działającej). 

Jest to jedno z bezcennych narzędzi, które mogą nam zaoszczędzić mnóstwo czasu i pieniędzy – o ile będziemy umieli się nim posługiwać.

W skrócie jest to symulator mikrokontrolerów AVR. Po jego wybraniu możemy uruchomić debugowanie programu (Debug->Start Debugging and Break, Alt+F5). Sesja debuggera programowego zostanie pokazana w dalszej części kursu.

Jeśli twój program nie działa jak należy, to warto skorzystać z symulatora i prześledzić krok po kroku jego działanie, a także stan procesora – w symulatorze dostępne są wszystkie rejestry IO mikrokontrolera, a także jego pamięć. Możemy je podglądać oraz modyfikować.

Możliwości te wprost trudno przecenić. Jedyną lepszą rzeczą od symulatora jest... symulator sprzętowy oparty o np. interfejs JTAG – ale wymaga to zakupu co najmniej AVR Dragon.


Uaktualnienie oprogramowania

Wszystkie narzędzia firmy Atmel zawierają w sobie mikrokontroler, który realizuje określony program (firmware), odpowiedzialny z komunikację pomiędzy komputerem PC, a programowanym układem. Okazjonalnie zachodzi potrzeba jego uaktualnienia.

Atmel Studio samo wykrywa sytuację, w której firmware posiadanego narzędzia jest nieaktualny – sygnalizuje wtedy konieczność jego aktualizacji. Proces ten odbywa się całkowicie automatycznie i nie wymaga żadnej ingerencji użytkownika – poza potwierdzeniem chęci uaktualnienia. Proces uaktualnienia można także zainicjować „ręcznie” wybierając opcję Tools->AVR Tools Firmware Upgrade. Atmel Studio przeszuka podłączone urządzenia i sprawdzi, czy nie wymagają one aktualizacji, na końcu wyświetlając mini raport:

Pamiętaj, aby przed procesem aktualizacji sprawdzić wszystkie połączenia pomiędzy komputerem na aktualizowanym narzędziem. Dobrze jest też odłączyć narzędzie od innych układów. Zapewni to bezproblemowy proces aktualizacji. Nie wyłączaj też komputera dopóki aktualizacja się nie zakończy.

W rzadkich sytuacjach może pojawić się problem i po aktualizacji urządzenie nie będzie działać. Zwykle jest to związane z utratą połączenia, błędem systemu lub działaniem tzw. siły wyższej   Nie należy się wtedy załamywać – każde urządzenie firmy Atmel ma „protokół awaryjny”, umożliwiający ratunkowe przeprogramowanie firmware. Opisy jak to zrobić znajdują się na stronie firmy Atmel, a jeśli zajdzie taka potrzeba umieścimy je i tutaj.

To tyle. Po dokonaniu wyboru programatora możemy programować swoje układy wprost z poziomu Atmel Studio. W tym celu klikamy na ikonkę na pasku narzędziowym:

Obok przycisku programowania wyświetlone będą też informacje o wybranym mikrokontrolerze oraz programatorze i interfejsie programowania – w naszym przykładzie będzie to ATMega128, a programatorem będzie AVR Dragon pracujący w trybie JTAG.


Zobacz także: Atmel Studio - Spis treści

Atmel Studio - czyli środowisko programistyczne (IDE)

Autor: tmf

Redakcja: Dondu

Artykuł jest częścią cyklu: Atmel Studio - Spis treści

Które środowisko wybrać?
To dylemat większości początkujących.

Naturalnym wyborem jest środowisko programistyczne (tzw. IDE) przygotowane przez producenta mikrokontrolera. W przypadku Atmela, środowiskiem tym jest Atmel Studio (w poprzednich odsłonach nazywane AVR Studio) i dotyczy zarówno mikrokontrolerów AVR jak i ARM

Nieważne które IDE wybierzesz, ważne, aby być konsekwentnym.

Jak zawsze na początku różne rzeczy będą cię denerwować, ale pamiętaj – po jakimś czasie przywykniesz, nauczysz się obsługiwać wybrane IDE i problemy znikną.

Najgorszą rzeczą jaką może zrobić początkujący jest szybkie porzucenie wybranego IDE (bo jest be, albo co gorsze, bo inni mówią, że jest be) i instalacja kolejnego (niby lepszego, ale niekoniecznie).

Jak wspomniałem naturalnym wyborem jest Atmel Studio. Dlaczego?
Ano z kilku powodów:

• Wybraliśmy AVR'y, a Atmel Studio ma najlepsze dla nich wsparcie i obsługuje wszystkie typy mikrokontrolerów Atmela.
• To samo środowisko posłuży nam także po przesiadce na AVR32 czy ARM.
• Jest kompletne i zawiera IDE + cały toolchain, a także symulator AVR (ważne!) .
• Zawiera ponad 1.100  gotowych do użycia przykładów.
• Jest proste w instalacji – ściągasz, instalujesz i masz wszystko.
• Zawiera dokumentację (datasheet'y) wszystkich mikrokontrolerów Atmela, które aktualizują się automatycznie poprzez wbudowany updater, nigdy więc nie przeoczysz żadnej erraty.

Ponadto: 

• Jeśli producent wypuści jakieś nowe, to zazwyczaj uaktualnienie IDE pojawia się jeszcze zanim procesory zostaną oficjalnie zapowiedziane. 
• Jest wygodne (nieco mulaste, ale inne zaawansowane IDE,  też są mulaste łącznie z Eclipse -  może z wyjątkiem CodeBlocks).
• Pakiet WinAVR, który jest wymagany przez inne IDE już od lat nie jest rozwijany i raczej nic nie wskazuje, że ta sytuacja się zmieni.
• Wspiera ASF (Atmel Software Framework) - nowa platforma programowa umożliwiająca łatwe przenoszenie kodu pomiędzy procesorami ATMega, XMega, AVR32 i ARM. Na większych procesorach to może być istotna zaleta.

... i pewnie wielu innych powodów, o których nie warto wspominać.

Jednak ciągle można się spotkać z opiniami, że Atmel Studio jest złe i należy je zmienić na Eclipse.
Skąd się one biorą? 


Nieco historii.
Bardzo dobrą wersją środowiska IDE Atmela, było AVR Studio 4. Ale ograniczało się do mikrokontrolerów AVR. Wraz z rozpowszechnieniem się ARM'ów Atmel podjął decyzję o rozbudowie i stworzenia uniwersalnego środowiska opartego o Visual Studio.


Przebudowa ta została rozpocząta od AVR'ów i powstała wersja AVR Studio 5. Pierwsze wersje tego IDE (oznaczone jako beta) były takie sobie, ale co gorsze – miały nową wersję toolchain'a (a więc kompilatora, bibliotek i narzędzi) również w wersji beta. I jak to w takich sytuacjach bywa – w cały pakiet wkradły się liczne błędy. Błędy na tyle poważne, że osoby początkujące miały problemy. Ale w informatyce i elektronice czas upływa raczej szybko, obecnie mamy wersję Atmel Studio 6, wraz z nowym toolchain'em i nową wersją kompilatora avr-gcc, które już tych błędów nie posiadają.

20rafalo

Dwa dni zmarnowane na ustawienia w Eclipse i nic - przez ten czas już napisał bym program w AVRStudio i był bym do przodu ...

Także nie polecam przesiadki na Eclipse tym, którzy zawsze pisali w AVRStudio, chyba, że dostaną skonfigurowaną wersję Eclipse od jakiegoś użytkownika ...

Atmel Studio ma równie dobry edytor i wiele fajnych opcji, których Eclipse nie ma - np. symulator.

Instalacja

Cały pakiet Atmel Studio po rejestracji można pobrać ze strony firmy Atmel: http://www.atmel.com/atmelstudio

Pakiet jest sporawy, co może niektórych zniechęcać. Związane jest to z tym, że oprócz IDE zawiera toolchain oraz komplet dokumentów (not aplikacyjnych i katalogowych) wszystkich mikrokontrolerów produkowanych przez firmę Atmel. Dzięki temu po instalacji nie będzie potrzeby ich dodatkowego ściągania z Internetu.

Co ważne, zawiera także liczne przykłady. W wielu sytuacjach są to gotowe rozwiązania często spotykanych problemów, warto więc je przeanalizować.

Po pobraniu i zainstalowaniu pliku jesteteśmy gotowi do pracy. Proste, prawda? W przeciwieństwie do innych IDE nic nie trzeba konfigurować, wybierać, czy poprawiać. Instalujesz i działa, czyli tak jakbyśmy się tego spodziewali.

Jarosław J

Jeszcze raz dzięki wszystkim. Próbowałem z ECLIPSE za usilną namową ...., ale jak to mówią jak coś jest do wszystkiego to jest do niczego. Zniechęca konfiguracja. Ja zostaję przy ATMEL STUDIO. Pewnie jeszcze nie raz się wyrżnę na jakichś pułapkach ale nie boję się konfrontacji z nimi.

---

Pierwszy projekt

Mamy już zainstalowane środowisko i zaczynamy zabawę :-)

Startujemy

Po uruchomieniu programu powinnyśmy zobaczyć okienko jak poniżej:

Warto przejrzeć przykładowe projekty dostarczone przez firmę Atmel (New Example Project from ASF) lub możemy stworzyć własny projekt. Klikamy więc na New Project:

W otworzonym okienku możemy wybrać nazwę projektu (Name), katalog roboczy (Location), a także język projektu. Do wyboru mamy:

• assembler, 
• C, 
• C++.

Do C++ na AVR8 może kiedyś jeszcze wrócę (a może dowiesz się o nim z mojej nowej książki - wkrótce).

Wybieramy C jako język projektu, spowoduje to automatyczne skonfigurowanie wszystkiego co potrzeba, aby skompilować program w C – zostaną wygenerowane odpowiednie katalogi i podkatalogi, plik Makefile itd. Ale to nie koniec konfiguracji. Trzeba jeszcze wybrać używany mikrokontroler, np. ATMega128:

W okienku powyżej oprócz parametrów wybranego mikrokontrolera, po prawej wymienione są także narzędzia (oczywiście wyłącznie narzędzia produkowane przez firmę Atmel), przy pomocy których możemy dany mikrokontroler programować. Po kliknięciu Ok możemy rozpocząć pisanie programu. Ale czy aby na pewno? Rozpocząć pisanie możemy, ale uzyskane efekty będą zapewne odbiegać od spodziewanych.


Konfiguracja projektu

Projekt trzeba jeszcze skonfigurować. Do tej pory wybraliśmy jedynie typ mikrokontrolera (MCU), a jak pamiętamy, należałoby jeszcze przynajmniej zrobić kilka innych rzeczy:

1. określić częstotliwość taktowania mikrokontrolera,
2. określić różne optymalizacje,
3. określić narzędzia, które posłużą do programowania.

Wszystkie powyższe opcje definiuje się wybierając Project->Properties... lub naciskając po prostu Alt+F7.


1. Ustawienie F_CPU

To jest chyba najczęściej spotykany problem początkujących. W AVR Studio 4 w tym celu była osobna zakładka, w począwszy od AVR Studio 5 także i w Atmel Studio 6 jej nie ma!

I co począć? Ano sięgnąć do podstaw i zastanowić się czym owo F_CPU jest? A jest zwykłym symbolem. Jak pamiętamy, symbol można zdefiniować na dwa sposoby:


a) w kodzie programu dyrektywą preprocesora:

#define F_CPU 2000000UL

Definiowanie F_CPU w w kodzie w większości sytuacji nie jest zalecane, o czym pisałem w tym artykule: F_CPU – gdzie definiować?

b) lub przekazując kompilatorowi podczas wywołania definicję symbolu, czyli tak:

Po wyborze okienka właściwości projektu i rozwinięciu zakładki Toolchain z pewnością zauważymy w gałęzi AVR/GNU C Compiler znajomo wyglądającą zakładkę Symbols. Bingo! Zdefiniujmy więc nowy symbol:

Jak widać, wpisujemy po prostu nazwę symbolu (bez –D) i towarzyszącą mu wartość. Od tej chwili we wszystkich kompilowanych plikach symbol F_CPU jest zdefiniowany:

Chyba to nie aż tak skomplikowana operacja, by z tego powodu przesiadać się na inne IDE na np. Eclipse, w którym i tak będziesz musiał zdefiniować F_CPU w podobny sposób?


2. Optymalizacja

Atmel Studio oferuje nam wygodne i szerokie możliwości optymalizacji tworzonego programu. Dzięki temu nie trzeba zagłębiać się w wiedzę tajemną jaką są opcje wywołania avr-gcc lub linkera. Ze wszystkich opcji najważniejsza jest jedna, znajdująca się w zakładce Toolchain/AVR/GNU C Compiler/Optimization.

Domyślnym poziomem optymalizacji jest poziom O1 – nie jest to opcja optymalna. Bez wdawania się w szczegóły warto wybrać poziom Os – generuje on najbardziej zwarty kod.

Zakładka ta powinna więc wyglądać jak poniżej:

Jednym z najczęstszych błędów jest pozostawienie optymalizacji na poziomie O1 – skutkuje to generowaniem bardzo długiego kodu wynikowego.

3. Wybór narzędzi do programowania

Ostatnim obowiązkowym polem, które należy skonfigurować jest wybór narzędzi programowania. Właściwie konfiguracja tego pola jest nie tyle obowiązkowa, co wygodna. Jeśli jesteśmy szczęśliwymi posiadaczami narzędzi firmy Atmel (lub ich klonów), to możemy programować mikrokontroler bezpośrednio z poziomu Atmel Studio. Jeśli posiadamy inne narzędzia to też możemy, ale wymaga to odpowiedniej konfiguracji Atmel Studio. Wyboru dokonujemy w zakładce Tool.

Oprócz wyboru narzędzi do programowania możemy wybrać symulator – dzięki temu będziemy mieli możliwość symulowania działania naszego programu, tak jakby działał on na prawdziwym mikrokontrolerze:

I to tyle – prawda, że proste? Po tych trzech małych krokach masz w pełni skonfigurowane IDE oraz projekt. Nic tylko siąść i pisać swoje dzieła. Powodzenia :-)

Zobacz także: Atmel Studio - Spis treści

Atmel Studio - Spis treści.

Autor: tmf

Redakcja: Dondu

Atmel Studio to oryginalne, wielofunkcyjne środowisko programistyczne firmy Atmel. To jedyne środowisko jakie potrzebujesz, by:

• pisać programy w Assemblerze, C oraz C++,
• dwie rodziny mikrokontrolerów Atmela: AVR i ARM, 
• symulować działanie mikrokontrolera,
• debugować,
• studiować ponad 1.100 przykładów,
• mieć aktualną wersję datasheet każdego mikrokontrolera Atmel,
• i wiele innych funkcji przyspieszających pracę.

Postanowiłem przybliżyć Wam Atmel Studio, by rozwiać wszelkie mity z nim związane :-)

Spis treści

• Atmel Studio - czyli środowisko programistyczne (IDE)
• Atmel Studio - Programatory
• Atmel Studio i niefirmowe programatory (np. USBasp)
• Atmel ICE - Programator i debugger (nowość 2014r.)
• Dlaczego programatory współpracujące z Atmel Studio są fajne?
• Jak przyspieszyć Atmel Studio?
• Masowe dodawanie plików - szablony
• Symulator pomaga szybko znaleźć błędy  !!! 
• Słownik języka polskiego i kolory komentarzy
• Numerowanie linii programu
• Naggy - sprawdzanie poprawności programu w trakcie pisania
• Code Size - określa wykorzystanie pamięci mikrokontrolera
• Data Size Viewer - jak szukać oszczędności pamięci?
• cdn. ...

Dokumentacja Atmela:

• Atmel Studio - Manual

Dla znających angielski:




Życzę wielu udanych projektów!

Atmel Studio: Dodatek Code Size - określa wykorzystanie pamięci

Autor: Dondu


Artykuł jest częścią cyklu: Atmel Studio - Spis treści

Elektronik wykorzystujący mikrokontrolery w szczególności te z małymi zasobami pamięci programu oraz SRAM i EEPROM, musi kontrolować ich wykorzystanie, by utrzymać w ryzach swoje zapędy programistyczne :-)

Dlatego w większości środowisk programistycznych dostępne są opcje pokazujące stan wykorzystania pamięci określany na etapie kompilacji programu. Także i Atmel Studio posiada taką funkcjonalność w postaci dodatku, który warto włączyć.

Funkcjonalność Code Size wygląda następująco:

Instalacja

Aby zainstalować dodatek należy przejść do menu Tools > Extension Manager:

Znajdujemy Code Size na spisie dodatków:

i instalujemy klikając Download.

Następnie należy oczywiście zamknąć i uruchomić ponownie Atmel Studio.


Włączenie okna Code Size

Aby włączyć dodatek należy sięgnąć do menu View > Other Windows > Code Size:

Pojawi się okienko, które może być puste jeżeli nie kompilowałeś jeszcze programu:

Okienko można w różny sposób dokować w zależności od upodobań. Sugeruję jednak wykorzystywać funkcję Auto Hide. Aby to zrobić należy wcześniej użyć jakiegokolwiek dokowania:

Jeżeli więc wybierzesz na przykład Dock, to okienko ustawi się następująco:

Teraz już wystarczy włączyć opcję Auto Hide klikając małą ikonkę (czerwona strzałka) lub wybierając z menu okna (zielone strzałki):

Okienko zniknie i od tego momentu widoczne jest w lewym dolnym rogu ekranu w postaci przycisku, na który wystarczy najechać kursorem lub kliknąć:

Atmel Studio: Jak przyśpieszyć?

Autor: tmf

Redakcja: Dondu

Artykuł jest częścią cyklu: Atmel Studio - Spis treści

Można się spotkać z opinią, że Atmel Studio jest duże i ociężałe. Z pewnością nie jest bardziej ociężałe niż np. Eclipse, ale faktycznie start mógłby być szybszy. Prostym rozwiązaniem problemu jest zmiana komputera, ale zapewne nie takie rozwiązanie nas interesuje. Przyjrzyjmy się więc co możemy zrobić, aby nieco Atmel Studio przyśpieszyć.


Długie otwieranie projektu

Chyba jedną z najbardziej uciążliwych dolegliwości związanych z Atmel Studio jest długie wczytywanie projektu. Szczególnie jeśli projekt składa się z wielu plików i jest raczej spory, Atmel Studio podczas startu może na dłużej się „zamulić”.

Winę za to ponosi aplikacja Visual Assist, która podczas startu parsuje wszystkie pliki, co zajmuje sporo czasu. Na szczęście opcję parsowania plików możemy wyłączyć. W tym celu z menu VassistX wybieramy Visual Assist X Options i w zakładce Performance odznaczamy opcję Parse all files when opening a project:

Visual Assist możemy też w każdej chwili całkowicie wyłączyć (przydaje się to na naprawdę wolnych komputerach) wybierając z menu VassistX opcję Enable/Disable Visual Assist X. Oczywiście wyłączając tą aplikację rezygnujemy z wielu udogodnień oferowanych przez IDE, stąd też z opcji tej powinniśmy skorzystać w ostateczności.


Antywirus

Programem, który potrafi pochłonąć sporą moc obliczeniową jest antywirus. Z pewnością nie warto wyłączać tego programu, aby przyśpieszyć działanie komputera, lecz nie wszystkie lokalizacje muszą być chronione. Z ochrony możemy wyłączyć lokalizacje powiązane z Atmel Studio, co przyśpieszy działanie naszego IDE.

W tym celu:

W używanym programie antywirusowym należy wyłączyć skanowanie następujących lokalizacji:

C:\Program Files (x86)\Atmel\Atmel Studio 6.1
C:\Users\użytkownik\AppData\Roaming\Atmel
C:\Users\użytkownik\AppData\Local\Atmel

Ponieważ pierwsza ścieżka zawiera nr wersji Atmel Studio, stąd w przyszłych wersjach, należy wyłączyć odpowiednio inną ścieżkę. Podobnie, gdy zainstalujesz Atmel Studio na innym dysku, czy w innym folderze.


W efekcie dostęp do plików Atmel Studio będzie szybszy (różnica może wynieść od kilku do kilkudziesięciu procent). 

Na przykład w programie Microsoft Security Essentials odpowiednie katalogi wpisujemy w zakładce Ustawienia, pozycja Wykluczone pliki i lokalizacje:

Ze skanowania możemy wyłączyć także niektóre typy plików. Z pewnością wirus nie ukryje się nam w plikach tekstowych zawierających kod języka C:

Możemy także wyłączyć z ochrony proces związany z Atmel Studio. MSE umożliwia wyłączenie z ochrony dowolnego pliku wykonywalnego. Z opcji tej możemy skorzystać wybierając zakładkę Wykluczone procesy:

Przyśpieszenie kompilacji

W przypadku dużych projektów czas kompilacji zaczyna mieć znaczenie, szczególnie jeśli wielokrotnie rekompilujemy projekt.

Cały toolchain jest zbudowany tak, że bezproblemowo osobne pliki źródłowe języka C można kompilować równolegle. Na maszynach wieloprocesorowych / wielordzeniowych daje to ogromne (nawet kilkunastokrotne) przyśpieszenie kompilacji.

Domyślnie w systemie Windows, kompilacja przebiega jednak sekwencyjnie, plik po pliku. To zachowanie możemy łatwo zmienić. W tym celu z menu Tools wybieramy Options, a następnie w oknie, które się pojawi Builder/GNU Make. Klikamy na wartość która pojawi się pod opcją Build Files Parallely i zmieniamy domyślną wartość False na True:

Od tego momentu możemy cieszyć się naprawdę szybką kompilacją projektu :-)

Jeśli znasz inne tricki jak przyśpieszyć Atmel Studio, to podziel się nimi!

A może nie tylko tricki dot. przyspieszenia - inne także :-)

Artykuł jest częścią cyklu: Atmel Studio - Spis treści

Atmel Studio: Programatory współpracujące są fajne!

Autor: tmf

Redakcja: Dondu

Artykuł jest częścią cyklu: Atmel Studio - Spis treści

Do tej pory wielokrotnie podkreślałem różne przewagi programatorów Atmela i ich klonów, nad tanimi usbasp i innymi programatorami „homemade”. Bez obaw, nie będę się powtarzał  Celem tego artykułu jest pokazanie możliwości i wygody jaka się wiąże z używaniem Atmel Studio i częściowo programatorów typu AVRISP-MkII.

Skoro wydaliśmy kilkadziesiąt złotych na programator, to zapewne chcielibyśmy móc skorzystać z możliwości jakie on oferuje. Poniżej przedstawię zrzuty zrobione z użyciem programatora AVR Dragon, lecz w zakresie programowania (nie debugowania) układów AVRISP-MkII i jego klony mają możliwości identyczne.


Dlaczego programatory współpracujące z Atmel Studio są fajne?

Zacznijmy więc od okna programowania. Podłączony programator korzysta z USB jest więc automatycznie rozpoznawany przez system, a jeśli wcześniej zainstalowaliśmy Atmel Studio to nie musimy także martwić się o sterowniki – system wszystko zainstaluje automatycznie.

Dialog programatora możemy uruchomić wybierając z menu Tools > Device Programming, lub klikając na odpowiednią ikonę na listwie narzędziowej (ikonka z układem scalonym i błyskawicą):

Zapewne najszybciej będzie po prostu nacisnąć Ctrl+Shift+P, co spowoduje uruchomienie dialogu programowania:

Do wyboru będziemy mieli listę dostępnych narzędzi (Tool) z której wybieramy programator, którego chcemy użyć. Następnie wybieramy programowane urządzenie (Device), interfejs, który chcemy wykorzystać do programowania (np. pokazany JTAG) i klikamy Apply. Jeśli wszystkie połączenia są poprawne, to programator nawiąże połączenie z programowanym układem, a my będziemy mogli wybierać opcje programowania.

W dalszych przykładach jako procesor wybiorę ATMega128 – tylko dlatego, żeby pokazać wybór i konfigurację fusebitów. Procesory, które używam na co dzień (XMEGA) zasadniczo nie wymagają konfiguracji fusebitów, więc dla zilustrowania tematu o którym piszę byłyby po prostu nudne.

Nie tylko początkującym osobom spore problemy sprawiają bity konfiguracyjne (tzw. fusebity). Często zdarza się, że wybieramy nieprawidłową konfigurację, w efekcie procesor próbuje uruchomić się z nieistniejącego źródła zegara, co oczywiście nie jest możliwe.

Warto podkreślić, że problem ten nie występuje w przypadku mikrokontrolerów XMEGA – one zawsze startują z wewnętrznego generatora RC o częstotliwości 2 MHz, a wybór i konfigurację zegara przeprowadza się programowo.

Problemy te powodują, że szukamy różnych rozwiązań, mniej lub bardziej dziwacznych. Począwszy od studiowania noty procesora (co jest godne pochwały), a skończywszy na różnych nakładkach graficznych na AVR Dude. Niektóre z nich są płatne i mają nas rzekomo uchronić przed zablokowaniem MCU. Z pewnością pomagają one w uniknięciu nieprawidłowej konfiguracji procesora, lecz nie są w stanie jej zapobiec (chyba, że uniemożliwią nam po prostu wybór pewnych konfiguracji, co jest raczej rozwiązaniem bezsensownym).

Ale to samo możemy osiągnąć bez programów zewnętrznych, wykorzystując IDE jakim jest Atmel Studio. W celu konfiguracji fusebitów klikamy po prostu zakładkę Fuses i wybieramy pożądaną konfigurację:

Wybierając źródło i konfigurację zegara, typ oscylatora i czasy startu mikrokontrolera wybieramy pożądaną konfigurację z rozwijanej listy. W powyższym przykładzie zaznaczona jest opcja taktowania MCU z zewnętrznego źródła zegara o częstotliwości 8-12 MHz, z czasem startu równym 64 ms.

Proste, prawda? Podobnie możemy wybierać konfigurację innych opcji określanych przez fusebity. Co więcej, na dole okienka mamy wyświetloną bieżącą wartość fusebitów w postaci heksadecymalnej (extended, high i low), możemy w dowolnej chwili odczytać ich aktualny stan lub zapisać nowy.

Dodatkowo przy każdej opcji dostępna jest pomoc kontekstowa, a także dymek opisujący skrótowo za co dana opcja odpowiada.

Wydaje się więc, że korzystając z tej zakładki konfiguracyjnej powinniśmy uniknąć problemów z zablokowanym mikrokontrolerem. A przynajmniej tego typu problemy znacznie ograniczyć.

Warto też pamiętać, że problem w ogóle znika jeśli korzystamy z interfejsu JTAG. Interfejs ten służy także do taktowania mikrokontrolera, w efekcie nawet jeśli wybierzemy niewłaściwe źródło zegara, to przy pomocy JTAG zawsze będziemy mogli zmienić konfigurację fusebitów (oczywiście nie wszystkie MCU dysponują interfejsem JTAG).

W podobny sposób w zakładce lockbits możemy skonfigurować bity odpowiedzialne za dostęp do poszczególnych typów pamięci:

Ale to nie wszystko. Oczywiście możemy także wybrać pliki, które posłużą do zaprogramowania MCU. W zakładce Memories możemy określić pliki zawierające dane, które należy zapisać w pamięci FLASH i EEPROM mikrokontrolera. Co ważne do zaprogramowania możemy użyć plików w formacie IntelHeX lub w formacie .elf:

Jeśli zdecydujemy się na pliki w formacie .elf (jest to opcja zdecydowanie zalecana) to prawdopodobnie lepiej będzie jeśli zaglądniemy do zakładki Production file. W zakładce tej możemy wybrać do programowania tzw. plik produkcyjny.

Co to takiego? To nic innego jak plik w formacie .elf. Jak pamiętamy pliki te zawierają komplet informacji potrzebynych do zaprogramowania mikrokontrolera (dane dla pamięci FLASH, EEPROM oraz konfigurację fuse- i lockbitów). Pliki .elf są szczególnie wygodne, jeśli chcemy komuś przesłać nasz program w postaci skompilowanej.

Zamiast dostarczać dwóch plików (z danymi dla FLASH i EEPROM) oraz opis konfiguracji fuse- i lockbitów (co zawsze wiąże się z niebezpieczeństwem popełnienia błędu) możemy po prostu przesłać zawierający wszystko plik w formacie .elf. Taki plik to właśnie plik produkcyjny – umożliwia on „rozpoczęcie produkcji” gotowych do użycia, zaprogramowanych i skonfigurowanych mikrokontrolerów.

Po wybraniu zakładki Production file i wybraniu pliku elf możemy skonfigurować co chcemy aby programator wykonał:

Jeśli wybrany plik .elf nie zawiera np. informacji o pamięci EEPROM to opcja programowania tej pamięci będzie niedostępna. W efekcie mamy do dyspozycji wyłącznie te opcje, które są istotne dla wybranego pliku elf. Aby uniknąć każdorazowego programowania np. fuse- czy lockbitów opcje te możemy odznaczyć. Po naciśnięciu przycisku Program, IDE wykona wszystkie zaprogramowane akcje.

---

A co mają zrobić posiadacze USBAsp?

Mogą zazdrościć :-)

Co prawda Atmel Studio można skonfigurować do współpracy z USBasp, lecz współpraca ta nie będzie pełna, a z wielu opcji oferowanych przez narzędzia bezpośrednio wspierane przez Atmel Studio nie będziemy mogli skorzystać.

Ale nie jest tak źle. Z pewnością wybierając typ programatora w tej zakładce zauważyłeś(aś), że na liście jest dostępne urządzenie o nazwie Simulator. Urządzenie to nie jest fizycznym programatorem, ale go udaje – oczywiście w ten sposób nie zaprogramujemy żadnego realnego układu.

Ale obecność symulatora ma ogromną zaletę dla posiadaczy USBasp i innych niewspieranych bezpośrednio programatorów – możemy sobie za jego pomocą skonfigurować fuse- i lockbity wybranego mikrokontrolera, a następnie uzyskane wartości hex tych bitów konfiguracyjnych wykorzystać do programowania mikrokontrolera.

Co nam to daje? Użytkownicy avrdude wiedzą, że program ten wymaga podania fuse- i lockbitów w postaci wartości liczbowych. W efekcie musimy mozolnie ślęczeć nad notą użytego procesora i je wyliczyć, lub skorzystać z jakiejś nakładki graficznej na avrdude, która te wyliczenia zrobi za nas. Jednak w poprzednim odcinku tego mini-kursu Atmel Studio zintegrowaliśmy programator USBasp z naszym ulubionym IDE. W związku z tym sens stosowania zewnętrznych nakładek dla wyliczenia fusów były nikły.

Dzięki symulatorowi mamy fusebity ładnie policzone, wystarczy tylko ich wartości podać jako argumenty wywołania programu avrdude. W ten sposób mamy nie tylko wygodne narzędzie do konfiguracji bitów konfiguracyjnych procesora, ale także unikamy możliwej pomyłki związanej z niewłaściwym wyliczeniem wartości liczbowej odpowiadającej wybranej konfiguracji:

Nic tylko korzystać, bez obaw, że przypadkowo zablokujemy mikrokontroler.

Jeśli jednak ciągle czujesz się niepewnie programując fusebity, to jest jeszcze jedno rozwiązanie – przejść na XMEGA. Dlaczego? Bo masz ten sam rdzeń AVR, lecz nie ma problemu z fusebitami!


Artykuł jest częścią cyklu: Atmel Studio - Spis treści

Atmel Studio i niefirmowe programatory (np. USBasp)

Autor: tmf

Redakcja: Dondu

Artykuł jest częścią cyklu: Atmel Studio - Spis treści

Jakiś czas temu obiecałem pokazać w jaki sposób połączyć Atmel Studio z programatorami, których ono bezpośrednio nie wspiera, czyli np. popularnym USBasp czy USBTiny. Połączenie takie w pewnym stopniu jest możliwe, jednak zdecydowanie je odradzam. Dlaczego?

W wielkim skrócie:

• zwykle tanie programatory (te w cenie 20-40 zł) nie posiadają translatora poziomów logicznych, w efekcie nie współpracują poprawnie z układami zasilanymi napięciami poniżej 3,3V, 
• są wolne. Programatory Atmela i ich klony potrafią programować układ kilka-kilkanaście razy szybciej niż np. USBasp  Jeśli piszemy programy o długości do paru kB prawdopodobnie nie ma to znaczenia, ale czas ładowania wsadu za pomocą USBasp o długości 50 i więcej kB może być naprawdę długi. 
• o ile integracja z IDE Atmela niefirmowych programatorów jest możliwa, to z pewnych funkcji nie będziemy mogli skorzystać. Głównie chodzi tu o możliwość wygodnej zmiany fusebitów przy pomocy graficznego kreatora dostępnego w IDE, dzięki czemu szansa na ich błędne ustawienie jest minimalna. 
• możliwość używania plików produkcyjnych w formacie elf. Jest to o tyle faje, że nie musimy generować plików hex (co dodatkowo zajmuje czas podczas kompilacji), a przede wszystkim w jednym pliku mamy dane dla FLASH, EEPROM, a także konfigurację fuse- i lockbitów plus cokolwiek jeszcze zechcemy. Niestety popularny avrdude nie współpracuje z plikami w formacie elf (może się to zmieni). 
• programatory bezpośrednio wspierane przez Atmel Studio lepiej się z tym IDE integrują, w efekcie praca z nimi jest zdecydowanie przyjemniejsza i łatwiejsza. 
• popularny USBasp nie wspiera wszystkich rodzin AVR, można nim programować tylko układy wyposażone w interfejs ISP, układy używające interfejsu PDI (np. XMEGA) lub dW/TPI są dla nas niedostępne (niektóre ATTiny). 

Oczywiście to nie oznacza, że zaraz musimy kupować drogie, oryginalne narzędzia firmy Atmel. Oryginalny programator AVRISP-MkII kosztuje prawie 200zł, przy tej cenie lepiej dodać niecałe 50zł i za 249 zł kupić AVR Dragon, który umożliwia także sprzętowe debugowanie układów Atmela. Na szczęście do dyspozycji mamy różne klony AVRISP-MkII, dostępne w cenie 60-70zł, czyli w miarę przystępnej.

Dlaczego warto kupić klon AVRISPMkII, a nie tańszy (cena około 20zł) USBasp? 

Przede wszystkim nawet najtańszy klon zawiera dodatkowy bufor i translator poziomów, dzięki czemu możemy programować układy zasilane od 1,8V. Wbrew pozorom ta możliwość staje się co raz ważniejsza, gdyż wiele ciekawych układów i modułów zasilana jest maksymalnie z 3,3V. Klony posiadają też sprzętowy interfejs USB, dzięki czemu działają pewniej, a proces programowania jest zdecydowanie szybszy.

Warto jednak zwrócić uwagę na dostawcę układu. Klony zwykle nie współdziałają z oryginalnym firmware Atmela (posiadają swój własny), który jest kompatybilny na poziomie interfejsu z firmware Atmela.

Ponieważ okresowo (np. przy kolejnych wydaniach Atmel Studio) mogą być wymagane uaktualnienia firmware warto więc wybrać firmę, która takie uaktualnienia nam zapewni.

Klon AVRISP-MkII można sobie także złożyć samemu – np. wg schematów umieszczonych na blogu kolegi Manekinen: Programator USBTiny-MkII SLIM

Cena 60-70zł złotych pozornie jest 3-krotnie wyższa niż USBasp, jednak jeśli chcemy kupić naprawdę porządnie wykonane USBasp, z translatorem poziomów to też musimy liczyć się z wydatkiem 40-50zł. No i USBasp nie programuje wszystkich mikrokontrolerów firmy Atmel (np. nie programuje XMEGA), natomiast klon AVRISP-MkII programuje wszystkie układy.

---

Jak „ożenić” USBasp i Atmel Studio?

Ok, skoro czytasz dalej, to rozumiem, że moja argumentacja cię nie przekonała. Co więc zrobić? Jak się nie ma co się lubi, to się lubi co się ma, spróbujmy więc jakoś „ożenić” USBasp i Atmel Studio.

Aby współpraca była możliwa, Atmel Studio będzie wywoływał zewnętrzny program kontrolujący sprzętowy programator. Takim programem do którego większość użytkowników USBasp przywykła jest zapewne avrdude. Zakładam więc dalej, że masz poprawnie skonfigurowany programator (jest widoczny w systemie operacyjnym), masz zainstalowane avrdude i avrdude jest w stanie komunikować się z programatorem. Jeśli tak, to pozostaje ostatni element układanki, czyli konfiguracja Atmel Studio.


Konfiguracja Atmel Studio

Nadszedł więc czas na uruchomienie Atmel Studio. Niezależnie, czy mamy wersję 5.x (niezalecana), czy 6.x (zalecane 6.1 lub wyższe) konfiguracja przebiega podobnie.

Z menu Tools wybieramy opcję External tools tak jak to pokazano na poniższym rysunku:

Pojawi nam się okienko takie jak pokazane poniżej:

Okno to umożliwia konfigurację dowolnego zewnętrznego narzędzia, które będziemy mogli wywołać następnie z menu lub z listwy przycisków. W ten sposób możemy dodać nie tylko obsługę zewnętrznego programatora, lecz także możliwość wywołania dowolnego zewnętrznego programu.

Mając otwarte powyższe okienko przystępujemy do konfiguracji opcji wywołania zewnętrznego programu. W tym celu uzupełniamy pola Title, Command, Arguments oraz Initial directory.

• W polu Title wpisujemy po prostu nazwę, która będzie identyfikowała dodawane narzędzie. Może to być np. USBasp.

• W polu Command wpisujemy ścieżkę do wywoływanego programu (w naszym przypadku jest to avrdude.exe). Ścieżka ta może być ścieżką bezwzględną – zawierającą całą ścieżkę dostępu, moożemy ograniczyć się do wpisania samej nazwy programu, jeśli dostęp do niego określony jest w zmiennej środowiskowej PATH (znajduje się on w domyślnej ścieżce wyszukiwania).

• W polu Arguments podajemy argumenty wywołania programu avrdude – analogicznie jakbyśmy go wywoływali z linii poleceń. W przypadku, kiedy ścieżki do plików hex zawierają spacje całą ścieżkę należy ująć w znak cudzysłowia, w przeciwnym przypadku spacje separujące elementy ścieżki zostałyby przez program avrdude potraktowane jako oddzielne argumenty i wywołanie zakończyłoby się błędem. W polu Arguments możemy wpisać nazwy plików wynikowych w formacie IntelHEX, musimy określić typ mikrokontrolera oraz sposób komunikacji z programatorem. 

Po kolei więc, najpierw sposób połączenia i typ mikrokontrolera:

-e -P usb -c USBasp -p Atmega16

W naszym przypadku użyliśmy mikrokontrolera ATMega16, taki więc typ przekazujemy jako wywołanie avrdude.

Niestety Atmel Studio używa innych nazw mikrokontrolerów, niż nazwy rozpoznawane przez avrdude, w efekcie jeśli zmienimy typ mikrokontrolera użytego w projekcie, musimy zmienić ręcznie opcje wywołania programu avrdude.

Jest to pewną uciążliwością, ale niewielką – rekonfiguracji musimy dokonać tylko wtedy, gdy zmieniamy typ użytego mikrokontrolera. Warto wspomnieć, że jeśli korzystamy z narzędzi w pełni współpracujących z Atmel Studio to typ procesora pobierany jest automatycznie z opcji projektu.

Teraz pozostaje jeszcze tylko określenie czym zaprogramujemy mikrokontroler, dodajemy więc „magiczne zaklęcie”:

-e -U flash:w:$(ProjectDir)Release\$(ItemFileName).hex:a

Dlaczego magiczne? Ścieżkę i nazwy plików możemy ustawić na stałe, jednak zmieniając nazwę projektu lub jego lokalizację musielibyśmy je za każdym razem zmieniać. Środowiska oparte o Visual Studio posługują się kilkoma zmiennymi, które zawierają opcje projektu, a także jego nazwę i ścieżki w których zapisane są pliki projektu. Stąd też makro ProjectDir zawiera ścieżkę do projektu, a makro ItemFileName zawiera jego nazwę. Wystarczy do niej dodać rozszerzenie hex lub eep, aby mieć nazwę pliku, którym możemy zaprogramować mikrokontroler. 

Ponieważ ścieżka dostępu do pliku wynikowego zależy od celu z jakim budujemy projekt (domyślne cele to Debug lub Release), musimy odpowiedni podkatalog dodać ręcznie. Jeśli budujemy określając cel Release będzie to podkatalog Release, jeśli celem będzie Debug, to podkatalogiem będzie Debug, np.:

-e -U flash:w:$(ProjectDir)Debug\$(ItemFileName).hex:a

W okienku konfiguracji wywołania programu zewnętrznego znajdziemy jeszcze ciekawe opcje: Use Output Window, Prompt for arguments i Close on exit. Opcje te czasami warto zaznaczyć.

Use Output window powoduje otwarcie okna konsoli podczas wywołania avrdude, w efekcie mamy podgląd na to co się dzieje, ma to szczególne znaczenie, jeśli po skonfigurowaniu narzędzia coś nie działa jak należy.

Z kolei Prompt for arguments powoduje wyświetlenie zapytania o argumenty wywołania za każdym razem, kiedy wywołujemy avrdude. Jest to opcja na dłuższą metę uciążliwa, lecz przydaje się na początku konfiguracji. W ten sposób przed wywołaniem avrdude widzimy jak został skonstruowany wiersz wywołania i czy jest on poprawny. Opcja ta przydaje się też w sytuacji, kiedy często zmieniamy typ mikrokontrolera.

Warto także odznaczyć opcję Close on exit – dzięki temu po wywołaniu avrdude i zaprogramowaniu MCU okienko avrdude pozostanie otwarte, a my będziemy widzieć rezultat programowania.

Warto zwrócić uwagę na przyciski z trójkącikami przy linii Arguments i Initial Directory. Jeśli je klikniemy ukaże nam się lista wyboru:

Lista ta zawiera dostępne dla nas makra, takie jak np. wspomniane wcześniej makro ProjectDir (opcja Project Directory). W efekcie możemy łatwo wstawiać dowolne makra do linii poleceń.

Konfiguracja menu

Musimy jeszcze udostępnić nowe narzędzie. W tym celu klikamy ponownie na Tool, a następnie wybieramy Customize. W pojawiającym się okienku dodajemy nowy obszar na listwę narzędzi (toolbar) wybierając New, a następnie określając nazwę nowego obszaru. Nazwa może być dowolna, my użyjemy nazawy "USBasp":

Dodaliśmy nowe pole do listwy narzędziowej, musimy jeszcze dodać samo narzędzie. W tym celu wybieramy zakładkę Commands, klikamy na opcję Toolbar i wybieramy pozycję o nazwie, pod którą chcielibyśmy identyfikować nasz programator (możemy znowu wybrać "USBasp"):

Teraz możemy polecenie powiązać ze zdefiniowanym wcześniej wywołaniem programu klikając na Add Command, a następnie wybierając w pojawiającym się oknie opcję Tools i External Command 1 – pod tą enigmatyczną nazwą kryje się nasze zdefiniowane wcześniej polecenie:

I to tyle, na listwie pojawi się nowa sekcja zawierająca skrót do naszego programu. W ten sposób możemy programować nie opuszczając IDE, lecz niestety w ten sposób nie zmusimy do działania z naszym programatorem kreatora konfiguracji Atmel Studio.

Testowanie konfiguracji

W menu Tools pojawiła nam się nowa pozycja:

Klikając na nią możemy wywołać zdefiniowane wcześniej polecenie, możemy to samo uczynić klikając na listwę narzędziową:

W efekcie zostanie wywołane avrdude. Jeśli podczas konfiguracji narzędzi zaznaczyliśmy opcję podawania argumentów przed wywołaniem programu, to pojawi nam się okienko:

Widzimy w nim argumenty, które sami określiliśmy (Arguments), a poniżej Command Line, czyli to co dokładnie zostanie przekazane w linii poleceń. Widzimy, że makra typu ProjectDir zostały zastąpione odpowiednimi ścieżkami dostępu. Dzięki temu możemy łatwo określić, gdzie leży ewentualny błąd wywołania programu avrdude.

I to właściwie tyle, mamy zintegrowane USBasp z naszym projektem i możliwość jego łatwego wywoływania. W kolejnej części poznamy niektóre zalety programowania programatorami bezpośrednio wspieranymi przez IDE.


Artykuł jest częścią cyklu: Atmel Studio - Spis treści