ATSAML21 - przepis na delay i podstawowe operacje na GitHub-ie

Wszyscy krzywimy się na pomysł używania delay-i .Niestety bez nich się nie obędzie, szczególnie w przypadku sprzętu , który wymaga opóźnień w procesie inicjacji czy wymiany danych. Sztandarowym przykładem niech będzie wiecznie żywy kontroler LCD HD44870, z którym bez delay-i nie porozmawiamy. W nawyk mi weszło, że po pierwszej rozmowie z nowym MCU rozglądam się za implementacją opóźnień. Staram się w tym przypadku nie odkrywać na nowo koła ale podejrzeć jak to robią inni ,bardziej zaawansowani użytkownicy danego MCU. W artykule pokażę zatem kod , który mi najbardziej przypadł do gustu. Przy okazji zmierzymy się z zagadnieniem współpracy z GitHub-em w przypadku kiedy środowisko nie oferuje narzędzi do kontroli wersji.

Naszym celem będzie z grubsza :

• stworzenie nowego projektu o nazwie atsam21l_delay w środowisku SEGGERA
• przesłanie lokalnego projektu na zdalny serwer w  GitHub ,używając komend konsolowych Linuxa
• dodanie do projektu pliku delay.h i wypełnienie go kodem
• przesłanie zmian lokalnych na zdalny serwer w GitHub
• ściągnięcie projektu ze zdalnego serwera na lokalny komputer
  

Tworzymy na dysku lokalnym katalog Segger_Projects a w nim katalog z nazwą naszego projektu ATSAML21_DELAY (dużymi literami). Uruchamiamy środowisko SEGGER-a i wybieramy opcję File --> New_Project.

Jeśli wyskoczy nam okienko z dwoma opcjami tworzenia projektu, w nowym Solution lub dodanie do istniejącego Solution to wybieramy pierwszą opcje na górze czyli dodajemy projekt do nowego Solution. W kolejnym okienku wybieramy rodzaj projektu a na dole okienka podajemy nazwę naszego projektu i lokalizację gdzie projekt zostanie zapisany czyli do wcześniej utworzonego katalogu ATSAML21_DELAY .

W kolejnym okienku dokonujemy tylko wyboru naszego MCU czyli ATSAML21G18B

W kolejnych trzech okienkach klikamy tylko Next i na koniec klikamy Finish.

Pierwszą czynnością po stworzeniu każdego nowego projektu jest uruchomienie opcji Build (klawisz F7). W procesie tym dołączone zostaną pliki nagłówkowe naszego MCU. Znajdziemy je w ścieżce CMSIS_Files --> system_saml21.c --> Dependencies.

Modyfikujemy  plik main.c czyli wywalamy treść jaką tam zastajemy i wstawiamy swoją propozycję. Pewnie jest gdzieś opcja do tworzenia szablonów ale ja jej jeszcze nie szukałem. W pliku main.c jak widzimy skonfigurowałem pin PB11 jako wyjście. Na tym pinie mam na swojej płytce developerskiej diodę LED. Przy pomocy funkcji opóźniającej będziemy migać tą diodą.

Mamy zatem stworzony nasz projekt i przygotowany do dalszego działania. Spróbujmy zatem przygotować go do wysłania na zdalny serwer na github.com . Mój system to Linux Mint 18.3 Git-a już miałem zainstalowanego lokalnie a dowiedziałem się o tym wpisując w konsoli komendę git  :

Pomijam aspekt założenia konta na zdalnym GitHub bo zakładam , że je mamy.

Wchodzimy na nasze konto na GitHubie i tworzymy nowe zdalne repozytorium. Jego nazwa nie musi być taka jak nasz projekt lokalny ale dowolna. Na obrazku poniżej moja propozycja utworzenia nowego repozytorium :

Po utworzeniu zdalnego repozytorium o nazwie ATSAML21_DELAY otrzymamy obrazek jak poniżej czyli jego zawartość. Na razie tam nic nie mamy oprócz jednego pliku README.md. Docelowo chcemy aby znalazł się tutaj nasz projekt zapisany lokalnie.

Pierwszą czynnością jaką musimy zrobić lokalnie jest konfiguracja Gita.

Wracamy zatem na nasz dysk lokalny i w konsoli Linuxa podajemy ścieżkę dostępu do naszego projektu. U mnie to wygląda jak poniżej :

Teraz konfigurujemy lokalnego Gita , czyli podajemy nasz adres email i nazwę użytkownika na lokalnym komputerze w/g konwencji:

git config --global user.name "Twoje imię i nazwisko"
git config --global user.email twój@email

Ja podaję dane , jak poniżej. Robimy to tylko raz. Jak będziemy później podpinać do Gita kolejne projekty to już tego nie powtarzamy.

Następnie będąc cały czas w ścieżce naszego katalogu z projektem ATSAML21_DELAY wykonujemy polecenie git init W efekcie utworzone zostaną w naszym katalogu z projektem, pliki niezbędne do działania z Git-em. W sumie utworzony zostanie tylko katalog .git. Komendy git init używamy do każdego nowego projektu utworzonego lokalnie

Zawartość katalogu z naszym projektem po wykonaniu komendy git init wygląda jak poniżej :

Teraz musimy dodać nasz zdalny serwer. Robimy to w/g konwencji  :

git remote add twoja-nazwa-zdalnego-repozytorium https://github.com/adres-twojego-serwera/nazwa-repozytorium.git

A skąd mamy wziąć adres zdalnego repozytorium (czyli naszego projektu) pokazuje obrazek poniżej :

wykonujemy komendę :
git remote add ATSAML21_DELAY https://github.com/PICmajster/ATSAML21_DELAY.git

Od teraz w komendach takich jak push, pull posługujemy się nazwą podaną w komendzie git remote czyli w naszym przypadku ATSAML21_DELAY
Listę wszystkich dodanych serwerów(lokalizacji) można sprawdzić za pomocą komendy git remote -v

Teraz dodajemy pliki naszego lokalnego projektu do Gitowej poczekalni , robimy to za pomocą komendy git add * (na końcu po spacji gwiazdka) . Dodane zostaną wszystkie pliki . Pliki w poczekalni są już śledzone przez Gita.

 

Po dodaniu wszystkich plików do poczekalni musimy jeszcze zatwierdzić zmiany w projekcie, służy do tego polecenie commit. Zapis commit -h pokaże nam  wszystkie warianty dla tego polecenia My użyjemy natomiast tego:
git commit -m 'nazwa commita' . Jako "nazwa commita" możemy wpisać wszystko co odnosi się do wprowadzonej przez nas zmiany. Np. start projektu, poprawka błędów, dodanie czegoś itd.

Zatwierdzamy zmiany w plikach projektu lokalnego za pomocą komendy commit, . Użyte przez nas po raz pierwszy, zatwierdzi  nam wszystkie pliki projektu lokalnego . Wykonujemy zatem komendę git commit -m 'start projektu' Efekt poniżej :

Teraz kiedy mamy już dodane pliki i zatwierdzone zmiany lokalnie, możemy je w końcu wysłać na nasz zdalny serwer do naszego repozytorium na github.com. Robimy to przy pomocy tego polecenia:

git push -u twoja-nazwa-zdalnego-repozytrium master (dodawaliśmy nazwę zdalnego serwer wyżej w komendzie remote, jakby ktoś zapomniał :))

Wpisujemy zatem w konsole : git push ATSAML21_DELAY master

Jeśli wszystko jest oki to zostaniemy zapytani o nazwę użytkownika i hasło dostępu do zdalnego Githuba (to są dane za pomocą , których zakładaliśmy konto na github.com)

W efekcie otrzymamy informację o nie wykonaniu operacji push z powodu braku integracji lokalnego projektu ze zdalnym. 

W informacji mamy podane rozwiązanie problemu . Musimy użyć komendy pull, która pobiera nam pliki ze zdalnego serwera. Wykonujemy zatem tę komendę :
git pull ATSAML21_DELAY master

Jeśli pojawi się komunikat o błedzie typu :  fatal : refusing to merge unrelated histories to należy zdezaktywować go poprzez wpisanie git pull <remote> <branch> --allow-unrelated-histories (remote - ATSAML21_DELAY a branch - master) i ponownie wprowadzić git pull ATSAML21_DELAY master
Wyskoczy nam okienko edycyjne, które zamykamy skrótem ctrl i X. Wrócimy do konsoli gdzie zobaczymy mniej więcej poniższą treść :

Wygląda na to, że jest wszystko teraz w porządku . Ponawiamy zatem naszą komendę push , która wyśle nam nasz lokalny projekt z zatwierdzonymi zmianami do zdalnego repozytorium. Wpisujemy zatem : git push -u ATSAML21_DELAY master

Brawo udało się. Teraz pozostaje nam tylko sprawdzić czy mamy pliki naszego lokalnego projektu na zdalnym serwerze. Odświerzamy stronę na naszym zdalnym serwerze i cieszymy się widokiem :

No dobrze teraz zrobimy zmiany w projekcie lokalnym czyli stworzymy pusty plik delay.h i wypełnimy go kodem impelementującym opóźnienia dla naszego MCU. Te zmiany później dodamy do poczekalni gitowej i po zatwierdzeniu wyślemy do zdalnego repozytorium.

Wypełniam treścią plik delay.h czyli wstawiam kod implementujący opóźnienia :

Teraz robimy procedurę , która spowoduje dodanie zmian wykonanych lokalnie (utworzenie pliku delay.h) do zdalnego repozytorium na gihub.com.
Musimy wykonać sekwencję komend :

git add (doda nam wszystkie pliki do poczekalni)
git commit (zatwierdza zmiany)
git push (wysyła fizycznie pliki na zdalny serwer)

Tylko pamiętajmy aby wszytkie komendy wykonywać z aktywnej ścieżki naszego katalogu z projektem (aby tam się dostać stosujemy komendę konsolową cd ..) . Na wszelki wypadek pokazuje jeszcze raz :

dodajemy pliki do poczekalni gitowej :
git add *

zatwierdzamy zmiany (tylko zatwierdzone zmiany zostaną wysłane na zdalny serwer) :

git commit -m 'dodanie pliku delay.h'

wysyłamy zmiany na zdalny serwer :

git push ATSAML21_DELAY master

W sumie zostało wysłanych 5 obiektów, nasz plik delay.h i jakieś tam zapisy środowiska. Sprawdźmy czy nasz plik delay.h został dodany do zdalnego repozytorium, po odświerzeniu strony zobaczymy :

Jak widać github pięknie nam uzupełnił zdalne repozytorium o nasz dodany plik delay.h.

No dobrze, wiemy jak wysyłać lokalny projekt na zdalny serwer i jak aktualizować zmiany. Teraz pora na zagadnienie w którym rozważymy przypadek pobrania projektu zdalnego na lokalny komputer i dodanie go do środowiska SEGGER-a. Generalnie służy do tego komenda gitowa clone ale ja pokażę również alternatywną drogę za pomocą komendy pull.

Najpierw jednak najprostsza i najszybsza droga czyli za pomocą komendy clone. Wchodzimy za pomocą komendy linuxowej cd do ścieżki z katalogiem Segger_Projects (wcześniej utworzonym). Następnie w otwartej ścieżce do naszego katalogu, posługujemy się komendą : git clone adres zdalnego repozytorium a fizycznie wpisujemy komendę :

git clone https://github.com/PICmajster/ATSAML21_DELAY.git

Po chwili zobaczymy nowo dodany katalog do katalogu Segger_Projects o nazwie zdalnego repozytorium czyli ATSAML21_DELAY, w katalogu znajdziemy wszystkie pliki ściągnięte ze zdalnego repozytorium. I to już wszystko jeśli chodzi o ściąganie z serwera za pomocą komendy clone. Proste łatwe i przyjemne.

Teraz inna opcja tym razem za pomocą komendy pull a tu się trochę napracujemy ale idea tego jest trochę inna niż w przypadku komendy clone. W przypadku komendy pull zdalne repozytorium scala się z lokalnym, czyli jakby ta komenda scala dwa światy zdalny i lokalny , komenda clone tylko kopiuje i nic więcej. 

Po stronie lokalnej nie mamy ani projektu ani katalogu projektu. Pierwszą czynnością będzie zatem stworzenie katalogu do którego ściągniemy zdalny projekt. Tworzę zatem w katalogu Segger_Projects katalog ATSAML21_DELAY, tu nazwa może być dowolna nie musi być taka jak nazwa zdalnego repozytorium. W konsoli Linuxa wchodzę w ścieżkę katalogu za pomocą komendy cd ścieżka i wewnątrz katalogu z pustym projektem uruchamiam komendę git init.

Zakładam , że na lokalnym komputerze Git jest skonfigurowany czyli podana nazwa użytkownika i adres email za pomoca komend :

git config --global user.name "Twoje imię i nazwisko"
git config --global user.email twój@email

Robimy to tylko raz na początku współpracy Gita z naszym komputerem.

Teraz musimy dodać nasz zdalny serwer jeśli wcześniej tego nie zrobiliśmy. Robimy to w/g konwencji  :
git remote add twoja-nazwa-zdalnego-repozytorium https://github.com/adres-twojego-serwera/nazwa-repozytorium.git

A skąd wziąć adres repozytorium to już było opisane wcześniej.
Wpisujemy git remote add ATSAML21_DELAY https://github.com/PICmajster/ATSAML21_DELAY.git

Po wydaniu komendy remote sprawdzamy za pomocą komendy git remote -v
czy istnieje jakiś zdefiniowany zdalny adres repozytorium. Jeśli tak to zobaczymy ten adres.

Przechodzimy teraz do kluczowej operacji czyli wydania komendy do ściągnięcia plików  ze zdalnego repozytorium (naszego projektu) robimy to tak :

git pull ATSAML21_DELAY master (gdzie ATSAML21_DELAY jest nazwą podaną wcześniej w git remote ..., zamiast zdefiniowanej nazwy można tutaj podać pełną ścieżkę do zdalnego repozytorium co nie jest wygodne).

Nasz zdalny projekt powinien się pojawić na naszym lokalnym komputerze w katalogu ATSAML21_DELAY. Sprawdźmy czy tak jest :

Wszystko się zgadza , wierna kopia projektu ze zdalnego repozytorium została pobrana na nasz lokalny komputer. Teraz tylko wystarczy dodać katalog z projektem do środowiska SEGGER-a. A robimy to tak File --> Open Solution i wybieramy plik projektu :

Na koniec pokażę jak korzystać z funkcji delay w programie :

Kompletny projekt do środowiska SEGGER-a jest dostępny na GitHub.

W sumie tylko liznąłem zagadnienia związane z GitHubem, bo temat jest o wiele szerszy. Ale na początek mamy jakiś punkt zaczepienia do dalszego rozpoznania tego narzędzia.Warto nabyć książkę Git. Rozproszony system kontroli wersji Włodzimierz Gajda. i rozszerzyć swoją wiedzę na ten temat bo warto.

Pozdrawiam
picmajster.blog@gmail.com

Linki :
GIT - poradnik dla leniwych
GIT - tutorial
GIT - wprowadzenie 
GIT - jak korzystać
GIT - program do pobrania
Artykuł o ATSAML21
Projekt na GitHub do pobrania