SunDuino jest klonem ARDUINO

Ponadto łatwo go wykonać we własnym zakresie. i dlatego chciałbym na jego przykładzie opisać i przedstawić platformę i API dla ARDUINO, W sumie to ta niewielka płyteczka , ma sporo zalet. Za sprawą nakładek schield czy też ideologi Open Source i Open Hardware, Ale główną zaletą jest API i olbrzymia społeczność, która wprowadza własne rozwiązania i biblioteki programowe.

Tak czy siak warto poznać je od każdej strony .....


A więc programować go można w tym środowisku.
Aby zacząć zabawę potrzebujemy:
1. SunDuino - dowolne dostępne np:
- SunDuino 1.0 - uproszczona wersja Arduino dostępna w wersjach:
a. z procesorem ATMega8 / 16Mhz
b. z procesorem ATMega168 / 16Mhz
- SunDuino 1.5 - 100% zgodna z rozszerzeniami ARDUINO (tzw. Shields)
info tutaj http://arduino.cc/en/Main/ArduinoShields
- tylko z procesorem ATMega168 / 16Mhz
- SunDuino 2.0 - rozbudowana wersja Arduino z procesorem ATMega644p
przystosowana do zastosowania w płytkach stykowych tzw. BreadBoard
2. Kabel / moduł komunikacyjny USB - RS-232 TTL np:
- FTDI USB-UART Konwenter - ZALECANY !!

Opisałem go tutaj raz ze schematem kabla z AUTORESETEM do arduino co znacznie upraszcza
prace ze środowiskiem :
http://www.sunduino.pl/wordpress/konwer ... el-usb-01/
w przypadku pracy z bootloaderem arduino.

- Kabel FTDI
- Sun USART

3. Programator USBasp
Programator przyda się w przypadku wgrywania bootloadera wprost ze środowiska Arduino
lub programowania Arduino poprzez opcję wgrywania wsadu przez programator

oczywiście podłączamy do złącza ISP (2x6pin)




4. Oprogramowanie ARDUINO dostępne tu : http://arduino.cc/en/Main/Software



Opis w oparciu o Sunduino v1.0 / 1.5
Pliki integracyjne dostępne w pobieralni:

Po zainstalowaniu oprogramowania i sterowników komunikacyjnych odpalamy
Środowisko Arduino i ustawiamy odpowiednio :
W menu TOOLS zakładka Serial PORT > właściwy port COM dla naszego urządzenia np. u mnie port COM9
A następnie w Menu TOOLS zakładka BOARD > właściwą płytkę :
Dla Sunduino 1.0 i 1.5 wybieramy SunDuino 1.0 w/ ATMega168 lub ATMega8
w zależności od procesora jaki jest na płytce.



Jeśli nie masz na liscie płytek Sunduino jak to widac na fotce , to pobierz plik board.txt, który znajdziesz w Pobieralni katalog Sunduino - w opisie znajdziesz instrukcję jak go wgrać do pakietu Arduino 017

I już możemy rozpocząć zabawę
Na początek coś prostego sprawdzimy czy nasze SunDuino działa prawidłowo.
Z menu FILE wybieramy zakładkę Examples i w niej podmenu Digital i Blink
w ten sposób wczytamy przykładowy programik, który powoduje miganie Diody L,
która jest podłączona do portu D13:

TAK WYGLĄDA LISTING TEGO PROGRAMU:



Teraz naciskamy klawisz RESET na płytce Sunduino - (zielona dioda zamiga parę razy) oznacza to ze weszliśmy w tryb pracy ARDUINO i BootLoader oczekuje na transmisje programu do procesora .
Po czym klikamy na ikonkę UPLOAD (6 od lewej strony okna) w programie Arduino jeśli wszystko mamy dobrze ustawione po chwili na dole pokaże się napis UPLOAD COMPLETE i po jakiś 2 sekundach dioda L (D13) zacznie zapalać się i gasnąć co 1000ms
Teraz możesz pobawić się częstotliwością migania diody zmieniając w programie w pętli głównej

void loop() wartość w linijkach:

delay(1000); na np delay(100); - delay oznacza opóźnienie a w nawiasie podajemy wartość w milisekundach

i wgrywamy program tak jak opisałem wyżej : - prawda, że teraz miga szybciej ??

Oczywiście na Nowszych SunDuino i Nowszym bootloaderem oraz płytkach ARDUINO
reset dokonuje się samoczynnie : (edit-20013)

Jeśli masz DIODĘ LED możesz ja tez włożyć w gniazdo DIGITAL w piny 13 i GND
dłuższą nóżką do pinu 13 a krótszą do GND - teraz migają 2 diody

Pobawcie się chwilkę zmieniając wartość polecenia delay() możesz też na początku programu w linii:

int ledPin = 13; // LED connected to digital pin 13

zmienić numer portu na dowolny z zakresu 0 do 13 ale pamiętaj o podłączeniu do właściwego portu Diody inaczej nie zadziała. Język programowania opiszę szeżej wraz z operatorami w następnej części Poradnika na razie udało się nam podłączyć SunDuino do komputera i uruchomić oraz skonfigurować
środowisko programistyczne ARDUINO oraz wgrać pierwszy prosty program do naszej płytki
oraz zmieniać częstotliwość jej migania , a nawet port na którym się znajduje (pod warunkiem posiadania dodatkowej diody LED w dowolnym kolorze)

W następnych krokach poznamy lepiej język programowania i nauczymy się wykonywać proste efekty świetlne na diodach LED , Sterować Silnikiem DC, Serwomechanizmem i wysyłać dane do komputera z czujnika temperatury poprzez program terminalowy.

Jak zmienić procka w SunDuino

Jak wiadomo SunDuino jest z procesorem ATMEL ATMega168,
który ma 16Kb pamięci flash - po odjęciu bootloadera ARDUINO zostaje nam 14Kb
czasem trochę mało więc wypadało by zmienić procesor na większy
czyli dostępny w Nettigo.pl ATMega328P

Można go kupić z bootloaderem na pokładzie i w tej wersji nic nie trzeba robić wystarczy
wyjąc z podstawki stary Mega168 i włożyć Mega328 i gotowe

ale można też kupić taniej bez bootloadera i wtedy trzeba pamiętać ze procesor nie będzie zbyt dobrze działał z SunDuino i Arduino bo nie jest skonfigurowany:

Fabrycznie każdy AVR jest ustawiony na wewnętrzny zegar 1Mhz , a nam potrzeba 16Mhz zewnętrzny dodatkowo fabrycznie nie ma miejsca na bootloader więc tą sekcję też musimy włączyć i wgrać bootloader aby ładnie nam wszystko działało z Oprogramowaniem ARDUINO.

No to do pracy:

Potrzebne będą:

- płytka SunDuino v1.0/1.5 lub Arduino
- programator USBasp
- oprogramowanie AVRDUDE dostępne tutaj
http://tinkerlog.com/2007/07/15/avrdude-54-for-windows/
avrdude po zainstalowaniu nie obsługuje ATmegi328 więc musimy w katalogu
AVRDUDE zmienić plik konfiguracyjny avrdude.conf na ten w dziale download od tej pory mamy juz
obsługę ATMegi328
- mały śrubokręcik
- duże piwo
- trochę samozaparcia

Jedziemy:

- instalujemy procesor w podstawce płytki SunDuino , uprzednio wyjmując stary lekko podważając go z obu stron śrubokręcikiem:




i w to miejsce wkładamy nowy procesor - UWAGA !!! wkładamy go tak samo jak poprzedni więc zwróćcie proszę uwagę jak jest włożony stary procesor - patrząc tak jak na fotce pin1 procesora jest po prawej u góry o czym świadczy wcięcie na obudowie procesora , oraz takie samo podstawce (dla niedowidzących - napisy na procesorze mają być do góry nogami - patrząc tak jak na fotce czyli gniazda zasilania po lewej stronie )

JAK Włożysz ODWROTNIE TO ZNISZCZYSZ PROCESOR !!!

- podłączamy zasilanie do płytki
- podłączamy programator do komputera i instalujemy sterowniki
- instalujemy pobrane AVRDUDE
najlepiej bezpośrednio na dysku C w katalogu AVRDUDE

- teraz uruchamiamy command shell (CLI) i przechodzimy komendą cd.. [enter] aż do głównego
katalogu dysku C
- teraz otwieramy folder AVRDUDE komendą cd AVRDUDE [Enter]
- teraz zaczynamy sie bać

- jesteśmy w folderze AVRDUDE
- w programatorze musimy przestawić zworkę na SLOW i podłączamy przewód programujący do gniazda ICSP na płytce SunDuino uważnie by nie pomylić wyprowadzeń (pin 1 został oznaczony na płytce , a na kablu też jest zaznaczony strzałeczką)

i zaczynamy zmianę FUSE BITS robimy to uważnie i uważamy na wielkość znaków, inaczej zamordujemy sobie procesor.

1. Teraz musimy ustawic zegar na 16Mhz i odblokowac segment pamięci przeznaczony na bootloader
robimy to wpisując w CMD rozkaz :

avrdude -p m328p -c usbasp -V -e -U lock:w:0x3F:m -U hfuse:w:0xD8:m -U lfuse:w:0xFF:m -U efuse:w:0x03:m

Wpisujcie UWAŻNIE ROZMIAR LITER JEST WAŻNY !!!

jeśli wszystko przebiegło dobrze zobaczymy takie coś



teraz przestawiamy zworkę SLOW w programatorze i sprawdzamy czy wszystko działa jak należy :

wpisujemy : avrdude -c usbasp -p m328p -t [ENTER]
po chwili uzyskamy połaczenie z procesorem obie diody programatora świecą :

wpisujemy : erase [enter] - pochwili dowiemy sie ze procesor został wykasowany
wpisujemy : q [ENTER] wyjscie z terminala (jedna dioda gaśnie)

Nio to wszystko sie udało mamy ustawiony zegar 16Mhz

Czas na wgranie bootloadera ARDUINO
pobieramy w dziale Download plik - sunduino_v1_boot_M328.hex

i wgrywamy plik sunduino_v1_boot_M328.hex do folderu AVRDUDE na C ,a teraz do procesora, wpisujemy uważnie:


avrdude -p m328p -c usbasp -V -D -U flash:w:sunduino_v1_boot_M328.hex:i

po chwili zobaczymy postęp wgrywania i na koniec napis OK



NO i super mamy bootloader
Teraz zabezpieczymy go przed przypadkowym skasowaniem i nadpisaniem (co utrudni nam życie):
więc by się tak nie stało wpisujemy w CMD rozkaz:

avrdude -p m328p -c usbasp -V -U lock:w:0x0F:m


po chwili zobaczymy takie coś



oznacza to, że od tej pory nasz bootloader jest bezpieczny i mamy do dyspozycji
30Kb pamięci na nasze programy

Odłączamy programator od płytki zamykamy wszystkie okienka i wciskamy reset na SunDuino
zielona dioda L (D13) zamigotała radośnie mówiąc kodem migowym
czekam na wgranie programu

GOTOWE !!
Możemy schować piwo z powrotem do lodówki

Teraz pozostaje nam tylko uruchomić Oprogramowanie ARDUINO i skonfigurować nową płytkę
poprzez wybranie w menu TOOLS , zakładka Board - Sunduino w/ATmega328 i możemy zacząć pracę na nowej płytce z większa pamięcią na poważniejsze Programy

Jeśli nie masz na liście płytki Sunduino v1.5 w/ ATmega328 napisz do mnie.

/ UWAGA /
ZA NIE WŁAŚCIWE UŻYWANIE ROZKAZÓW TU OPUBLIKOWANYCH ORAZ EWENTUALNE UŚMIERCENIE PROCESORA
NIE ODPOWIADAM --- WYKONUJESZ NA WŁASNE RYZYKO !!!
DZIAŁA TYLKO Z PROCESOREM ATMEGA328P NIE PRÓBOWAĆ Z INNYMI PROCESORAMI GDYŻ ICH KODY FUSE BITS SĄ INNE !!!!

Wprowadzenie do języka ARDUINO część 1
Opis struktury programu.


Struktura programu w Środowisku ARDUINO jest bardzo prosta i w większości przypadków będzie sie ograniczać do dwóch podstawowych Funkcji, które muszą być użyte w programie i stanowią jego szkielet:

Przykład:


void setup()
{
wyrażenia;
}

void loop()
{
wyrażenia i instrukcje;
}

[/syntax]


Funkcja setup() służy do konfigurowania programu , a loop() wykonuje program. Obie funkcje są wymagane do działania programu.

1. Funkcja setup() - konfiguracja

funkcja ta jest wywoływana tylko raz podczas startu programu. Zazwyczaj zawiera ustawienia portów , inicjalizacje komunikacji szeregowej. Musi być włączona w program nawet jeśli nie zawiera żadnych instrukcji.

Przykład użycia:





2. Funkcja loop() - Pętla główna

funkcja ta ustala kolejność i przebieg wykonywania programu w pętli dzięki czemu program działa i wykonuje zawarte w KLAMRACH instrukcje i polecenia, które są wykonywane "w koło" przez cały czas działania urządzenia z pominięciem Funkcji setup().



3. Funkcje własne

Funkcja jest blokiem instrukcji, który ma unikalną nazwę oraz zawiera szereg instrukcji, które są wykonywane za każdym razem gdy funkcja jest wywoływana. Funkcje wbudowane setup() i loop() mamy już omówione , a inne opiszemy później.
Funkcje własne zazwyczaj używa sie do wykonywania powtarzalnych zadań i w celu zwiększenia czytelności kodu programu. Funkcja musi zostać zdefiniowana przez podanie jej typu i nadanie jej nazwy, która powinna sie kojarzyć z wykonywanym zadaniem.

Typ funkcji to typ wartości zwracany przez funkcję do programu np. taki jak "int" dla funkcji typu integer. W nawiasie możemy umieścić wszystkie dane przekazywane do funkcji.

nazwaFunkcji typ (parametry)
{
instrukcje;
}

Napiszemy teraz funkcję typu integer o nazwie delayVal(), która będzie służyć do ustawiania opóźnienia przez odczyt wartości ustawianej za pomocą potencjometru. Najpierw zadeklarujemy zmienną lokalna "v", w której dokonamy konwersji wartości analogowych potencjometru na wartości cyfrowe. Wartość analogowa mieści się w przedziale 0 - 1023, która po odczytaniu podzielimy przez 4 uzyskując wartości cyfrowe z przedziału 0-255 i z tego przedziału wartości zwracamy do programu głównego:

int delayVal()
{
int v; // tworzymy zmienna lokalna "v"
v = analogRead(POT); // odczytujemy wartość potencjometru 0-1023 i zapisujemy w zmiennej v
v / = 4; // dokonujemy konwersji wartości z analogowej na postać cyfrową 0-255
return v; // zwracamy do zmiennej v wartość po konwersji
}


4. {} KLAMRY

Klamrami (określanymi również jako "szelki" lub "nawiasy klamrowe") określa się początek i koniec bloków funkcyjnych programu i blokuje instrukcje pętli takich jak loop(), for oraz if.

typ funkcji()
{ // początek bloku
instrukcje; // instrukcje
} // koniec bloku


Każdy otwarty nawias klamrowy musi być zawsze zamknięty nawiasem klamrowym. Często stosuje się tu nazwę "nawiasy zrównoważone". Niezrównoważone nawiasy często prowadzą do błędów kompilatora , takie błędy są trudne do zlokalizowania w dużym programie z wieloma pętlami i funkcjami. Na szczęście środowisko ARDUINO posiada wbudowany system śledzenia KLAMER - wystarczy kliknąć na jedną z nich by podświetliły się obie lub by uzyskać komunikat o braku drugiej.

5. ; Średnik

średnik jest używany do zaznaczenia końca instrukcji i poszczególnych elementów programu oraz do oddzielania elementów w pętli FOR.

int x=13; // średnik kończy wyrażenie w tym wierszu

UWAGA:

Zapominanie o umieszczeniu średnika na końcu instrukcji powoduje błąd składni kompilatora , jest to błąd oczywisty i odnosi się do braku średnika , ale nie musi. Jeśli pojawia się błąd składni kompilatora tzw. syntax error - jednym z pierwszych powodów jest właśnie brak średnika w pobliżu linii wskazanej w błędzie przez kompilator.


6. /* ... */ Blok komentarzy

komentarze grupowe lub wielo-komentarze, są to obszary tekstu ignorowane przez kompilator i są stosowane do opisywania działania programu , lub funkcji, które pomagają innym na zrozumienie naszego kodu oraz zasad działania programu. Warto pisać wiele komentarzy co nam samym też ułatwi czytanie kodu i wprowadzanie zmian zwłaszcza po dłuższym czasie. Komentarze grupowe zawsze zaczynają się od znacznika /* i kończą */ , mogą zawierać wiele linii opisujących program lub funkcję.

/*
To jest blok komentarzy, można wpisać wiele wierszy
nie należy zapominać o tym by zamknąć blok komentarzy -
każdy otwarty blok komentarzy musi zostać zamknięty.
*/

Ponieważ komentarze są ignorowane przez program i kompilator oraz nie zajmują pamięci mikrokontrolera powinno się je stosować hojnie , można je stosować do komentowania bloków programu , celów debugowania czy też przekazania sposobu podłączenia urządzeń do portów mikrokontrolera, a nawet konfiguracji urządzeń zewnętrznych.

7. // Linia komentarza

pojedyncza linia komentarza zaczyna się znacznikiem // i nie musi być zamykana, również i ona jest ignorowana przez kompilator i nie zajmuje miejsca w pamięci mikrokontrolera.

// To jest komentarz jednego wiersza

komentarza w takiej formie używa się do opisania danego wiersza programu w celu późniejszego przypomnienia lub przekazania realizowanego przez niego zadania np:

int x = 13; // deklaruje zmienna x typu integer i przypisuje jej wartość 13


Wprowadzenie do języka ARDUINO część 2

ZMIENNE

Zmienne służą do przechowywania wartości liczbowych odczytanych z czujników lub wyliczonych w funkcjach programu, przekazywanych później do innych części programu lub funkcji. Zmienne mogą być stałe , ale ich wartość może ulegać zmianie, gdzie dla stałych wartość ta nie zmienia się w czasie działania programu.
Każda zmienna musi być zadeklarowana i mogą być do niej przypisane wartości początkowe , które ma przechowywać. Poniższy przykład deklaruje zmienną inputVariable, a następnie przypisuje jej wartość uzyskaną z odczytu wejścia analogowego pin2 .

int inputVariable = 0; //deklarujemy zmienna inputVariable i przypisujemy
//jej wartość 0
inputVariable = analogRead(2); // ustawiamy wartość zmiennej na odczytaną z pin2


Jak widać takie rozwiązanie udostępni nam wartości odczytane z wejścia analogowego w innych miejscach programu.

Po przypisaniu wartości do zmiennej możemy ponownie przypisać jej inna wartość, przetestować i odczytać, a spełniając pewne warunki użyć jej wartości bezpośrednio.

Jako przykład ilustrujący ważność i użyteczność zmiennych w programie przedstawię trzy proste działania na nich:

Najpierw sprawdzimy czy zmienna inputVariable jest mniejsza niż 100, jeśli tak to przypiszemy jej wartość równą 100, a następnie ustawimy opóźnienie w oparciu o naszą zmienną, która obecnie wynosi co najmniej 100:

if (inputVariable < 100) // sprawdzamy czy zmienna jest mniejsza niż 100
{
inputVariable = 100; //jeśli wartość zmiennej jest mniejsza przypisujemy
//do niej wartość równą 100
}
delay(inputVariable); //używamy zmiennej jako opóźnienia


UWAGA !!

Zmiennym należy nadawać nazwy kojarzące się z typem danych jakie reprezentują. Nazwy takie jak tempSensor czy przyciskA pozwalają na łatwiejsze czytanie kodu i zrozumienie zasad działania całego programu niż zmienne o nazwach x czy y, które powodują brak czytelności i utrudniają pisanie większych programów gdzie zmiennych będzie wiele więcej. Nazwą zmiennej może być dowolne słowo pod warunkiem że nie jest jednym ze słów kluczowych języka ARDUINO.



1. Deklaracja zmiennej.

Wszystkie zmienne musza być zadeklarowane przed funkcją w której mogą być stosowane. Deklarowanie zmiennej polega na określeniu jej typu wartości, takich jak byte, int, long, float , ustawienie nazwy oraz opcjonalne przypisanie wartości początkowych. Wartość ta może zostać dowolnie i w dowolnym czasie modyfikowana poprzez działania arytmetyczne i poprzez różne zadania wynikające z działania programu.

Poniższy przykład deklaruje że zmienna inputVariable jest typu integer, a jej wartość początkowa jest równa zeru:

int inputVariable = 0;

Zmienna może być zadeklarowana w wielu miejscach w całym programie i gdy deklaracja ta sie odbywa określa, jakie części programu mogą korzystać ze zmiennej.


2. Rodzaje i zasięg zmiennych w programie.

Zmienna może być zadeklarowana na początku programu przed funkcją setup(), lokalnie wewnątrz funkcji, a czasami w bloku instrukcji takich jak pętle. Miejsce zadeklarowania zmiennej określa jej zasięg lub zdolność niektórych części programu do korzystania z tej zmiennej. Rozróżniamy zmienne:

Zmienna Globalna - to zmienna, z której mogą korzystać wszystkie funkcje
programu, musi być zadeklarowana przed funkcją setup().

Zmienna Lokalna - to zmienna, która jest definiowana wewnątrz funkcji, lub jako
część pętli FOR. Jest widoczna i może być używana tylko
wewnątrz funkcji, w której została zadeklarowana.

Zmienna Tymczasowa - to zmienna lokalna, która jest wywoływana tymczasowo
jako zmienna pomocnicza

Dlatego też jest możliwe użycie dwóch zmiennych o takich samych nazwach w różnych częściach programu, które zawierają różne wartości. Zapewnienie, że tylko jedna funkcja ma dostęp do danych zawartych w zmiennej zmniejsza ryzyko popełnienia błędów programistycznych.

Poniższy przykład ilustruje jak zadeklarować kilka różnych typów zmiennych i pokazuje "widoczność" każdej z nich:


int value; // zmienna , która będzie dostępna w całym programie
//- zmienna globalna
void setup()
{
// pusty blok ustawień
}
void loop()
{
for (int i =0; i<20;) // zmienna tymczasowa i widoczna tylko w pętli for
{
i++;
}
float f // zmienna "f" jest widoczna tylko wewnątrz pętli głównej loop() - zmienna lokalna
}




WPROWADZENIE DO JĘZYKA ARDUINO CZĘŚĆ 3
TYPY DANYCH I TABLICE


Liczby naturalne są podstawowym typem danych do przechowywania / przekazywania wartości liczbowych bez miejsc po przecinku.

BYTE - bajt

To 8 bitowa wartość liczbowa, bez miejsca po przecinku. Przyjmuje wartości całkowite z zakresu 0 - 255

byte someVariable = 180 // zmienna someVariable jest typu byte
// i może przyjąć wartości
// z zakresu 0-255 czyli w tym wypadku 180


INT - integer - liczba całkowita

To 16 bitowa wartość liczbowa z zakresu -32768 do 32767

int someVariable = 1500 // teraz nasza zmienna przyjmuje
// wartości typu integer
// może przyjmować wartości całkowite
// w zakresie 16 bitów


UWAGA !!

Zmienne zadeklarowane jako typ integer mogą przechodzić z wartości maksymalnej do minimalnej poprzez przeniesienie lub porównanie.
Np. jeśli x = 32767, a następne wyrażenie dodaje 1 do x, to x = x + 1 lub x + x nastąpi przeniesienie wartości do minimalnej czyli -32768

LONG - długi

To rozszerzony typ danych dla długich liczb/wartości całkowitych umożliwia przechowywanie 32 bitowych wartości liczbowych w zakresie od 2147483647 do -2147483648.

long someVariable = 90000 // w ten sposób możemy przechować lub udostępnić większe wartości liczbowe w programie

FLOAT - zmiennoprzecinkowe (ułamek)

Typ danych dla liczb zmiennoprzecinkowych (ułamków). Liczby te mają większą rozdzielczość niż liczby całkowite i są zawsze przechowywane
jako wartość 32 bitowa z zakresu -3.4028235E+38 do 3.4028235E +38.

float someVariable = 3,14 // tak umieszczamy wartości zmiennoprzecinkowe w zmiennej

UWAGA !!

Liczby zmiennoprzecinkowe nie są dokładne, porównywanie ich w programie może przynieść nieopisane skutki i złe nieprzewidywalne działanie programu, przetwarzanie ich trwa dłużej niż liczb całkowitych. Należy unikać stosowania tego typu danych, chyba że jest to absolutnie konieczne.



TABLICE

Tablica jest zbiorem wartości. Każda wartość w tablicy może zostać wywołana przez wywołanie nazwy tablicy i numeru indeksu wartości. Tablice są indeksowane od 0. Musi być zadeklarowana i musi mieć przypisane wartości przed ich wykorzystaniem.

int myArray[] = {wartość0, wartość1, ........}

Można też zadeklarować tablicę podając jej typ i rozmiar, a później przypisać wartości odpowiednim pozycjom indeksu.

int myArray[5] //deklarujemy tablicę, której wartości będą liczbami całkowitymi
//tablica ta będzie posiadać 6 miejsc
myArray[3] = 10; // przypisujemy wartość 10 do 4 pozycji indexu

Aby pobrać wartość z tablicy należy zmiennej przypisać nazwę tablicy oraz numer indeksu:

x = myArray[3] // x jest teraz równe 10

Tablice często są wykorzystywane w pętli FOR, gdzie przyrost licznika jest również stosowany jako numer pozycji indeksu w tablicy.
W przykładzie poniżej użyjemy wartości z tablicy do spowodowania migania diody LED. Użyjemy pętli FOR w której licznik zacznie sie od pozycji 0 tablicy i przypisze wartości zawarte w indeksie do pinu PWM(10) w tym wypadku wartość 180, odczeka 200ms i przejdzie do następnej pozycji
indeksu w tablicy:



WPROWADZENIE DO JĘZYKA ARDUINO CZĘŚĆ 4
Działania i operatory arytmetyczne


Operatory arytmetyczne to dodawanie, odejmowanie, mnożenie i dzielenie. Zwracają one sumę, różnicę, iloczyn lub iloraz oraz wyniki wielu operatorów.

y = y + 3; y = y + 3;
x = x - 7; x = x - 7;
i = j * 6; i = j * 6;
r = r / 5; r = r / 5;

Operacje są przeprowadzane za pomocą zmiennych z odpowiednimi typami danych, które mogą reprezentować ,a więc np.: 9/4 da wynik 2 zamiast 2,25 ponieważ typ danych to int zatem nie jest możliwe wykorzystanie miejsc po przecinku.
Oznacza to też ze wynikiem operacji może być przepełnienie, jeśli wynik jest większy niż możliwy do przechowania w zmiennej danego typu.
Przykładowo jeśli jedna ze zmiennych należy do typu „float”, a druga do „integer” to zostanie użyty typ danych floating do obliczenia wartości.
Wybieramy zmienne o wielkości, która jest wystarczająca do przechowania dużych wyników obliczeń. Wiemy też w jakim punkcie nastąpi zmiana kierunku (wywrócenie) np. (0-1) lub (0--32768) to typowe wykorzystanie frakcji w matematyce dla zmiennych typu „float”,
ale należy pamiętać o ich wadach – duży rozmiar i wolne obliczanie wartości.

Uwaga: Należy używać operatora cast np. (int) myFloat do przekształcenia typu
jednej zmiennej do innego w locie.

Np. i = (int) 3,6 // ustawi nam i na wartość równą 3

1. Specjalne Operatory arytmetyczne

To operacje arytmetyczne z przypisaniem, które są powszechnie stosowane w pętlach for, którą opiszę w dalszej części. Do najczęstszych złożonych działań należą:

x ++ // to samo co x = x + 1, x zostaje zwiększony o +1
x -- x -- // to samo co x = x – 1 , x zostaje zmniejszony o -1
x + // to samo co x = x + y, lub przyrost x o + y
x -= y // to samo co x = x - y, lub zmniejsza x przez -y
x *= y // to samo co x = x * y, lub mnożenia x przez y
x /= y // to samo co x = x / y, lub dzieli x przez y

Uwaga: Na przykład, x *= 3 potraja wartość zmiennej x i ponownie przypisuje
wynikającą z tej operacji wartość do zmiennej.

2. Operatory porównania

Porównywanie jednej zmiennej lub stałej z inna, jest często stosowane w przypadku wyrażeń. W celu sprawdzenia czy określony warunek został spełniony.
W przykładach, które znajdziemy w dalszych częściach przewodnika zobaczymy jak użyć porównania do wskazania spełnienia różnych warunków:

x == y // x jest równe y
x != y // x nie jest równe y
x < y // x jest mniejsze od y
x > y // x jest większe od y
x <= y // x jest mniejsze lub równe y
x >= y // x jest większe lub równe y

3. Operatory logiczne AND, OR, NOT

Są najczęściej używanym sposobem porównania dwóch wyrażeń i powrotu do programu
Przez warunki TRUE (prawda) lub FALSE (fałsz) w zależności od zwracanej wartości. Dostępne są trzy operatory logiczne AND, OR i NOT i są często używane w przypadku wyrażeń:

- Logiczne I (AND) :
if (x> 0 & & x <5) // TRUE tylko wtedy, gdy
// wyrażenia są prawdziwe
- Logiczne LUB (OR):
if (x> 0 | | y> 0) // TRUE jeśli
// wyrażenie jest prawdziwe

- Logiczne NIE (NOT):
if (! x> 0) // TRUE tylko wtedy, gdy
// wyrażenie jest fałszywe


WPROWADZENIE DO JĘZYKA ARDUINO CZĘŚĆ 5
Stałe

Język ARDUINO ma kilka predefiniowanych wartości, które nazywane są stałymi.
Służą one do zwiększenia czytelności kodu programu. Stałe są sklasyfikowane w grupach:

1. TRUE / FALSE - prawda / fałsz

Są to stałe logiczne, do określania stanów logicznych. FALSE zwykle definiuje się jako 0 (zero) natomiast TRUE jest często definiowana jako 1, ale może być również zapisana inna wartość oprócz zera. Tak więc w sensie logicznym, -1, 2 i – 200 są również określane jako TRUE:

if (b == TRUE);
{
doSomething;
}

2. HIGH / LOW - wysokie / niskie

Te stałe określają stany wyprowadzeń pin takie jak HIGH lub LOW i są używane podczas
odczytu lub zapisu do cyfrowych wyprowadzeń mikroprocesora. HIGH jest definiowane jako poziom logiczny 1 co oznacza włączenie 5V na wyprowadzeniu. Natomiast LOW oznacza poziom logiczny 0 czyli Wyłączone lub 0V:

digitalWrite (13, HIGH); // ustawia 5V na pinie 13 czyli zapala diodę L

3. INPUT / OUTPUT - wejścia / wyjścia

Te stałe są stosowane do ustawienia cyfrowych pinów mikrokontrolera na określony tryb pracy czyli jako wejście lub wyjście rozkazem pinMode()

pinMode(13, OUTPUT); // pin D13 ustawiony jako wyjście
pinMode (12, INPUT); // pin D12 ustawiony jako wejście

Prawda że proste

WPROWADZENIE DO JĘZYKA ARDUINO CZĘŚĆ 6
Pętle czyli sterowanie przepływem.



1. Pętla warunkowa IF - jeśli

Pętla ta służy do sprawdzania czy pewien warunek został osiągnięty, jak na przykład sprawdzenie czy wartości na wejściach analogowych osiągnęły właściwą wartość liczbową oraz wykonuje wyrażenia wewnątrz Klamer jeśli wynik jest prawdziwy , a jeśli fałszywy pomija rozkazy i powraca do wykonywania programu.

if (someVariable ?? value)
{
wykonajTo; // jeśli FALSE to ta część nie zostanie wykonana
}

Powyższy przykład porównuje zmieną someVariable z inną wartością, która może pochodzić ze zmiennej lub stałej. Jeśli wynik porównania, czy warunek w nawiasach jest prawdziwy, wyjdzie pozytywnie instrukcje wewnątrz Klamer zostaną wykonane, Jeśli nie program ominie te rozkazy i przejdzie do dalszej części programu.

Uwaga: Należy uważać na przypadkowe użycie "=", na przykład w przypadku if (x = 10), technicznie przypisuje zmiennej x wartość 10 co jest zawsze wynikiem prawdziwym. Zamiast używania ‘ ==’ np. if (x==10) która testuje czy wartość x jest równy 10 czy nie, Pamiętaj , że ‘=’ oznacza ‘równa się’, a ‘==’ oznacza ‘jest równa’.

2. IF …. ELSE - Jeśli …. w przeciwnym razie

If .. Else pozwala podjąć decyzję typu „albo – albo” Na przykład jeśli chcesz przetestować czy wejście cyfrowe spełnia jakiś warunek np. jeśli wejście osiągnęło stan HIGH wykonaj zadanie , a jeśli nie to wykonaj co innego. Sprawdzenie takiego warunku zapisujemy w taki sposób:

if (inputPin == HIGH)
{
wykonajA;
}
ELSE
{
wykonajB;
}

ELSE można poprzedzić innym warunkiem tak by uzyskać wiele sprawdzeń zależności , które będą się wzajemnie wykluczać i mogą być uruchamiane w tym samym czasie. Można mieć nieskończona liczbę różnych warunków należy jednak pamiętać o tym, że każdy warunek jest uruchamiany w zależności od wyniku badania stanu danego wejścia:

if (inputPin <500)
{
wykonajA;
}
else if (inputPin >= 1000)
{
wykonajB;
}
else
{
wykonajC;
}


UWAGA: Pętla IF bada prawdziwość stwierdzenia w nawiasach czy jest prawdziwe czy też fałszywe (True/False). Wyrażenie to może mieć dowolnie ustawiony warunek dla prawdy. Np. w pierwszym przykładzie. (inputPin == HIGH) tu jak widać IF sprawdza tylko czy określony pin faktycznie jest w stanie wysokiego poziomu logicznego czyli czy występuje na nim +5V


3. Pętla FOR - (dla)

Pętla For powtarza blok instrukcji umieszczony w nawiasach klamrowych określoną liczbę razy i można też określić kierunek zliczania oraz krok przyrostu licznika , który jest często używany do określenia przyrostu i zakończenia pętli. Dla pętli FOR istnieją trzy części oddzielone średnikami (;) i są umieszczane w nagłówku pętli. Typowa składnia dla pętli
FOR wygląda następująco:


for (inicjalizacja, warunek, ekspresja)
{
wykonajTo;
}

Inicjalizacja jest ładowana tylko jeden raz na wykonanie pętli i zdarza się tez tylko jeden raz.
Warunek jest testowany przy każdym, przejściu przez pętlę i jeśli jest prawdziwy wykonywane są instrukcje pętli, a pętla powraca do testowania warunku ponownie. Jeśli jednak warunek jest fałszywy pętla zostanie zakończona.

Poniższy przykład przypisze zmiennej I liczbę całkowitą 0 i i będzie sprawdzać czy wartość zmiennej wynosi mniej niż 20. Jeśli to prawda , nastąpi zwiększenie i o 1 oraz wykona polecenia zawarte wewnątrz pętli. Jeśli i osiągnie wartość 20 nastąpi zakończenie pętli i wykonanie rozkazów poza nią.



Uwaga: W języku C pętle są dużo bardziej elastyczne niż w innych językach programowania w tym tych z BASCOMA. Każdy lub nawet wszystkie trzy elementy nagłówka mogą być pominięte chociaż średniki są wymagane. Można wykonać pętle bez rozkazów. Tego typu niezwykłe stosowanie pętli FOR może być sposobem na rozwiązanie niektórych rzadkich problemów programistycznych, np. można zastąpić pętlą rozkaz delay().

4. Pętla WHILE - podczas gdy…

Pętla While będzie nie skończona przez cały czas dopóki warunki w nawiasach nie będą fałszywe. Warunki muszą być zmieniane inaczej pętla nie zostanie ukończona. Może zostać użyta do badania zmiennych lub zewnętrznych warunków takich jak sprawdzanie stanu czujników.

while (naszaZmienna ?? wartość)
{
wykonajTo;
}

W przykładzie poniżej będziemy sprawdzać czy zmienna „naszaZmienna” jest mniejsza niż 200 i jeśli to prawda wykonamy instrukcje w nawiasach klamrowych pętli, tak długo , aż zmienna nie będzie już mniejsza od 200:

while (someVariable <200) // sprawdzamy, jeśli mniej niż 200
{
doSomething; // wykonujemy rozkaz
someVariable // zwiększamy zmienną o 1
}

5. DO … WHILE - nie ... ale

DO … WHILE to pętla która działa w taki sam sposób jak pętla while,
z zastrzeżeniem, że warunek jest testowany na końcu pętli, więc do pętla będzie wykonana
zawsze co najmniej raz.

do
{
doSomething;
} while (someVariable ?? value);

Poniższy przykład przypisuje readSensors () do zmiennej "x", zatrzymuje się na 50 milliseconds,
a następnie wykonuje pętle w nieskończoność dopóki "x" nie jest już równe mniej niż 100:

do
{
x = readSensors(); // przypisanie wartości
// ReadSensors (), do x
delay (50); // zatrzymuje 50 milisekund
} while (x < 100); // wykonaj ponownie jeśli x jest mniejsze niż 100

Na dziś wystarczy zapraszam do kolejnej części gdzie opiszę rozkazy operacji na Portach Mikrokontrolera takie jak pinMode , digitalWrite , analogRead i inne


WPROWADZENIE DO JEZYKA ARDUINO cz 7:
OBSŁUGA Cyfrowych i Analogowych portów I/O

1. pinMode(pin, mode)

Używamy w sekcji void setup() aby skonfigurować określony pin mikrokontrolera który ma się zachowywać jako wejście lub wyjście.

pinMode (pin, output); // pin lub zestaw pinów - jako wyjście

W środowisku ARDUINO domyślnie wszystkie porty cyfrowe są przypisane do WEJŚCIA, a więc powinny być jednoznacznie kojarzone jako Wejście rozkazem pinMode(). O Pinach skonfigurowanych jako wejście - Mówi się, że są w stanie wysokiej impedancji. Istnieją tutaj także 20KΩ rezystory pull-up wbudowane w mikrokontroler ATMega, które mogą być ustawiane/włączane z poziomu oprogramowania i powodują podciągniecie wyjścia/wejścia do plusa (stanu wysokiego). Te wbudowane rezystory pull-up są dostępne wnastępujący sposób:

pinMode (pin, INPUT) // ustawiamy "PIN" jako WEJŚCIE
digitalWrite (pin, HIGH) // włączamy rezystory pull-up

Rezystory pullup w normalnych warunkach są stosowane do podłączania takich urządzeń wejściowych jak przyciski. Powyższy przykład nie konwertuje pinów do wyjścia, jest to jedynie metoda Aktywacji wewnętrznych rezystorów pull-up. O Pinach skonfigurowanych jako wyjście - Mówi się, że w niskiej impedancji mogą dostarczyć do 40 mA (miliamperów) obowiązujące dla innych podłączonych urządzeń / układów. To wystarczy do jasnego świecenia diody LED (nie wolno zapomnieć o rezystorze ograniczającym), ale już jest za mało by sterować przekaźnikiem , zaworem elektromagnetycznym lub silnikami. Zwarcie na pinach i nadmierne obciążenie może spowodować uszkodzenie lub nawet zniszczenie wejść a nawet całego mikrokontrolera ATMEGA. Dlatego dobrym pomysłem i często stosowanym jest podłączenie Pinu Mikrokontrolera do zewnętrznych urządzeń poprzez umieszczony szeregowo rezystor 470om lub 1Kom, który zabezpieczy delikatne wejścia ATmegi przed przeciążeniem i zniszczeniem.

2. digitalRead (pin)

Rozkaz ten odczytuje wartość z określonego pinu cyfrowy z wynikiem zarówno HIGH lub LOW. Pin może być określony przez zmienna lub stałą w zakresie 0-13 dla płytek z mikrokontrolerami ATMega8 / 168 / 328


3. digitalWrite(pin, value)

Ten rozkaz przypisuje do wyjścia określonego przez pin (0-13) stan Niski lub Wysoki czyli Włącza lub wyłącza zdefiniowane wyjście określone na płytce jako Digital Output (0-13)

digitalWrite(pin, HIGH); // ustawia pin jako włączony

Poniższy przykład ustawia przycisk podłączony do wejścia cyfrowego, który włącza diodę LED podłączona do Pinu D13 gdy przycisk zostanie wciśnięty:



4. analogRead(pin);

Rozkaz ten odczytuje wartości z pinów Analogowych w 10 – bitowej rozdzielczości. Funkcja ta działa tylko na porty oznaczone Analog In (0-5). Umożliwia przechwytywanie danych w formie liczb całkowitych w zakresie 0 – 1023:

value = analogRead(pin); // value określa 'wartość wejścia ' pin '

Uwaga: Piny analogowe w przeciwieństwie do cyfrowych , nie muszą być definiowane jako pierwsze oraz jako Input lub Output

5. analogWrite(pin, value);

Zapisuje pseudo-wartości analogowe przy użyciu sprzętowej modulacji szerokości impulsu (PWM) z pinów wyjścia oznaczonych PWM. Na nowszych płytkach z układem ATmega168, Funkcja ta działa na piny 3, 5, 6, 9, 10 i 11. Starsze płytki z ATmega8 obsługują tylko piny 9, 10 i 11. Wartość może zostać określona jako zmienna lub stała o wartości w zakresie 0-255.

analogWrite(pin, wartość); //konwertuje "wartość" na postać analogową, "PIN"

Wartość 0 generuje stały 0V, a wartość 255 generuje stałe 5V na określony w kodzie PIN. Dla wartości w przedziale od 0 do 255 liczby te reprezentują napięcie pojawiające się na PIN od 0 do 5V – im wyższa wartość tym częściej PIN jest w stanie wysokim. Np.:

Dla wartości 64 oznacza to ze stan niski (0V) będzie występował na PINie przez ¾ czasu, a stan wysoki (5V) tylko ¼ czasu. Dla 128 poziom 0 będzie występował przez połowę czasu, podobnie jak dla 255 , a dla 192 stan 0 będzie trwał ¼ czasu a stan 1 będzie trwał ¾ czasu. Ponieważ jest to funkcja sprzętowa, PIN będzie generować stały przebieg, po wywołaniu analogWrite w tle aż do następnego wywołania analogWrite (lub połączenia z digitalRead lub digitalWrite dla tego samego wyjścia PIN).



Przykład ten pokazuje jak można sterować dioda LED poprzez odczyt wejścia analogowego sterującego sygnałem PWM


Wprowadzenie do języka ARDUINO część 8
Funkcje Opuźniające , liczniki i generatory losowe


1. delay(ms)

Wstrzymuje program na czas określony w milisekundach, gdzie 1000
wynosi 1 sekunda. MS może być wyrażona zmienną.

delay(1000); // czeka jedną sekundę

2. Millis()

Zwraca liczbę milisekund odkąd program rozpoczął działanie
jako wartości unsigned long.

wartość = Millis(); // wartość określa stan Millis()

Uwaga: Gdy wartość millis się przepełni nastąpi reset z powrotem do zera, następuje to po po około 50 dniach (jeśli nie zresetujemy) pracy procesora.

3. min(x, y)

Oblicza najmniej dwie liczby wszelkiego rodzaju danych i zwraca mniejszą z nich.

wartość = min(wartość 100); // ustawia wartość do mniejszej
// "Wartości" lub równej 100, zapewniając
// że nigdy nie przekroczy 100.


4. max(x, y)

Oblicza maksymalnie dwie liczby wszelkiego rodzaju danych i zwraca większą number. z nich.

wartość = max(wartość, 100); // ustawia wartość do większej niż 100
// zapewniając że wartość będzie równa co najmniej 100


5. randomSeed(seed)

Funkcja stawia wartość , jako punkt wyjścia/zakres dla funkcji random().
randomSeed(value); // wartość ustawia zakres generowania liczb


Ponieważ Arduino jest w stanie stworzyć prawdziwie losowe liczby, randomSeed pozwala na użycie zmiennych, stałych, lub wykonywanie innych czynności na funkcji losowej, która pomaga generować więcej losowych liczb. Istnieje wiele różnych sposobów , funkcji które mogą być używane w tej funkcji, w tym Millis() lub nawet analogRead() , czego można użyć do odczytu szumu elektrycznego poprzez wejścia analogowe (piny 0-5)

6. random(max) i random(min, max)

To funkcje pseudo-losowe pozwalające na generowanie liczb losowych określonych przez wartości min i max.

wartość = random(100, 200); // ustawia wartość do losowania
// Liczby pomiędzy 100 a 200

Uwaga: Używaj tego zapisu po funkcji randomSeed ().
Poniższy przykład tworzy wartość losową między 0-255 dla wyjść PWM i przypisuje losową wartośc do pinu PWM:






WPROWADZENIE DO JĘZYKA ARDUINO cześć 9
Komunikacja Szeregowa


1. Serial.begin(wskaźnik)

Otwiera port szeregowy i ustawia szybkość transmisji szeregowej danych. Typowy szybkość transmisji do komunikacji z komputerem to 9600 bodów chociaż inne prędkości są też obsługiwane.

void setup()
{
Serial.begin(9600); // otwarcie portu szeregowego
} // szybkość transmisji na 9600 bodów

Uwaga: Korzystając z komunikacji szeregowej, cyfrowe piny 0 (RX) i 1 (TX) nie moga być
wykorzystywane w tym samym czasie. Należy też pamiętać by terminal w komputerze
był ustawiony na taką samą prędkość transmisji.

2. Serial.println(dane)

Drukuje dane do portu szeregowego, a następnie przesuwa karetkę do nowego wiersza.
To polecenie ma taką samą formę jak Serial.print(), ale jest łatwiejszy do odczytu danych
Serial Monitor czy też dowolny program terminalowy.

Serial.println(analogValue); // wysyła wartości
// zmiennej "AnalogValue"

Uwaga: Więcej informacji na temat różnych permutacji funkcji Serial.println() i Serial.print()
można znaleźć na stronie internetowej ARDUINO.

Prosty przykład obsługi komunikacji. Program ma za zadanie odczytać z wejścia AnalogIn pin0
wartość i wysyłać pojawiające się tam dane do komputera co 1sekundę:



I na tym zakończyliśmy teorię i poznawanie języka teraz czas na ćwiczenia praktyczne , ale tym się już zajmiemy w następnych częściach jeśli oczywiście będziecie chcieli bum je pisał .... ponadto wiele przykładów znajdziecie na mojej stronie internetowej....
Jeśli się trafią jakieś błędy to przepraszam , ale napisałem to i wiele więcej materiału już dawno temu, niemniej nie mam czasu na zabawy z wydawnictwami w tej chwili więc podzielę się być może całym materiałem tutaj , na razie tylko ten fragment przedstawiam.

_________________
Zbuduj swój system [url=https://helion.pl/ksiazki/w-labiryncie-iot-budowanie-urzadzen-z-wykorzystaniem-ukladow-esp8266-i-esp32-andrzej-gromczynski,wlablo.htm#format/d]IOT[/url]

Brawo! Brawo Mistrzu! Jak zawsze, konkretnie i na temat. Dobre jest dostrzegane natychmiast
Jeśli materiał ma mieć jeszcze większą wartość dla początkujących, rozszerzyłbym go o wyczerpujące opisanie pojęcia funkcji i zagadnień z tym związanych czyli typów danych. Do bólu dokładnie. Jest to pojęcie podstawowe, które gdy zostanie porządnie zrozumiane pozwala na dobry start. Niestety Dużym nie przychodzi najczęściej do głowy, że malutcy mogą tego nie wiedzieć i bezmyślnie piszą "int void..." nie wiedząc dlaczego. Zanim zadziała inteligencja i wszystko powiąże, podstawowa wiedza musi zostać nakładziona łopatą Pozdrawiam i dziękuję.

-- 52 minutyach --

Wątek liczy sobie tylko kilka godzin, a linka do Allegro zdążyła się już zestarzeć. Leute, leute jak ten zeit leci, to nie do wiary gerade aus.

nie nie ten link wygasł w chwili jak zakończyłem pisanie tej części czyli jakoś 2 lata temu to było , a zapomniałem o tym linku
ale zaktualizuję choć chyba zmienie odnośnik do mojej strony tylko bo tam to opisałem

_________________
Zbuduj swój system [url=https://helion.pl/ksiazki/w-labiryncie-iot-budowanie-urzadzen-z-wykorzystaniem-ukladow-esp8266-i-esp32-andrzej-gromczynski,wlablo.htm#format/d]IOT[/url]

mistrzu popraw mały błąd w funkcji Millis()
Napisałeś: "Uwaga: Gdy wartość millis się przepełni nastąpi reset z powrotem do zera, następuje to po ok. 9 godzinach pracy procesora."

A na moje oko i kalkulator jakbym nie liczył to wychodzi 49,71 dnia czyli "trochę" dłużej niż 9 godzin .

pozdrawiam

_________________
sig off ;(

każdemu się może zdażyć
Dzięki ...

_________________
Zbuduj swój system [url=https://helion.pl/ksiazki/w-labiryncie-iot-budowanie-urzadzen-z-wykorzystaniem-ukladow-esp8266-i-esp32-andrzej-gromczynski,wlablo.htm#format/d]IOT[/url]

SunRiver wydał książkę
Zabrakło jeszcze jak dla mnie funkcji
wybierz najczęściej się powtarzające z przedziału liczb