Wówczas możemy sięgnąć po mikrokontroler w rodzaju ATtiny2313. Nie uruchomimy na nim środowiska Arduino. Nie ma bootloadera, do programowania potrzebujemy jakiś programator. Ponadto nie ma biblioteki Arduino, tak więc nie ma wygodnych funkcji jak digitalWrite, analogRead itp. Trzeba się nieco ‘ubrudzić’ pisząc program, ale chyba już czas na to?

Sam doświadczenie poza Arduino posiadam niewielkie, ale właśnie mam okazję by zmierzyć się z małym projektem, w którym chcę użyć ATtiny2313. Ten wpis jest właśnie pokłosiem moich eksperymentów.

Pierwsza przeszkoda – programator. Ponieważ nie ma bootloadera, więc do wgrania naszego programu potrzebujemy programatora tzw ICSP (In Circuit  Serial Programming). W świecie układów ATMELa spotkać można programatory o dwóch rodzajach złącz 6-cio lub 10-cio pinowych. Są to gniazda 2 x 3 lub 2 x 5 w odstępach 2.54 mm, więc złącze programatora można zrobić np z goldpina. Ja już od dłuższego czasu korzystam z programatora USBtinyISP, którego trzeba przed pierwszym użyciem zlutować (jest też dostępny gotowy do pracy programator ICSP typu USBAP), który ma złącza zarówno 6 jak i 10 pinowe.

Złącze ICSP

Opis wyprowadzeń programatorów. Uwaga! Jest to opis wyprowadzeń widzianych od góry – od strony kabla. Trzymając wtyczkę programatora i zaglądając w głąb wtyczki należy rysunki odbić w pionie.

USBtinyISP ma zworkę, która gdy założona podaje napięcie zasilające na Vcc (jest to 5V z USB). Można je wykorzystać do zasilania programowanego ATtiny2313, tak więc pozostaje podłączyć sygnały do wyprowadzeń ATtiny2313 korzystając z tej ściągi:

Jak podłączyć ICSP do ATtiny/ATmega

Cały nasz układ, gotowy do programowania wygląda tak:

ATtiny2313 gotowy do programowania

Jak widać, korzystam z małej płytki stykowej (BB-170), w którą wsadzamy ATtiny2313 (wycięcie na obudowie jest słabo widoczne ale jest w górnej części zdjęcia). Wyjście z 6-cio pinowego złącza USBtinyISP jest rozprowadzone przewodami montażowymi (JW-75). I tak:

• czarny – masa
• czerwony – +5V
• biały – SCK
• zielony – MISO
• żółty – MOSI
• niebieski – RESET

Czemu nie potrzeba żadnych dodatkowych elementów? Większość mikrokontrolerów AVR ma wbudowany prosty oscylator, który zapewnia zegar niezbędny do pracy. Jest on słabej jakości – nieprecyzyjny, częstotliwość pływa z czasem i temperaturą otoczenia, ale jeżli nasz projekt nie wymaga specjalnie mierzenia czasu i dokładności w tej mierze – wewnętrzny oscylator jest good enough.

Częstotliwość tego wewnętrznego zegara to 8 MHz, jednak możliwe jest włączenie dzielnika przez 2, 8 lub 64 uzyskując odpowiednio 4 MHz, 1 MHz lub 128 kHz. Po co zmniejszać prędkość działania? Głównie dla oszczędności prądu – im niższe taktowanie tym mniej prądu pobiera układ. Jak zmieniać częstotliwość – o tym następnym razem (dla chcących szukać samemu – szukajcie informacji o fuse bits).

OK, teraz pozostaje – co tam wgrać? Zacznijmy od klasycznego blink czyli migania diodą. Ponieważ moim celem było przetestowanie procesu wgrywania – znalazłem gotowca. Zwłaszcza mam na myśli Makefile. Dzięki temu plikowi wystarczy napisać make w linii poleceń i projekt się skompiluje i wgra na ATtiny2313 (przynajmniej u mnie na Ubuntu – Makefile wydaje się być użytecznym pod Windowsem, ale nie mogę powiedzieć co dokładnie trzeba zainstalować aby działało).

Nasz cały program wygląda tak:

#include <avr/interrupt.h>	// Definicje nazw pinow układu

#define F_CPU 1000000UL		// Zapisanie predkosci procesora w Hz dla biblioteki delay.h
#include <util/delay.h>

// Deklaracja funkcji mrugajacej dioda
void blinkEm(uint8_t count);

// Glowna funkcja programu
int main()
{
  DDRD = _BV(PD4); // Ustawienie PORT D 4 (noga 8)jako wyjscie

  while (1) // Petla, ktora nigdy sie nie konczy
  {
    blinkEm(1); // Wywolanie funkcji mrugajacej dioda
  }
}

// Funkcja mrugajaca dioda LED ustalona ilosc razy
void blinkEm(uint8_t count)
{
  // petla ilosci mrugniec
  // dziala az zmienna count osiagnie wartosc 0
  while (count > 0)
  {
    // Wlaczenie diody led
    PORTD = _BV(PD4);
    // oczekiwanie 1 s
    _delay_ms(1000);

    // wylaczenie diody led
    PORTD = ~_BV(PD4);
    _delay_ms(1000);

    // odliczanie ilosci mrugniec
    count--;
  }
}

Wystarczy podłączyć diodę z rezystorem do pinu 8, +5V oraz masę i działa:

To zdjęcie pokazuje, czemu naprawdę warto zainteresować się tego typu rozwiązaniami – nic poza ATtiny nie jest nam potrzebne, żadnych dodatkowych elementów niezbędnych do działania (tak długo jak wewnętrzny zegar jest dla nas wystarczająco dobry).

W stosunku do równoważnego szkicu w Arduino IDE widać następujące różnice:

• nie ma setup i loop. Jest tylko main, które w C jest domyślnie uruchamianą pierwszą funkcją programu. loop jest zastąpione przez pętlę zrobioną za pomocą while (1)
• definicja funkcji main wygląda tak jak by wyglądała w Arduino IDE. Natomiast blinkEm jest zdefiniowane tak jakby dwa razy. W linii 5 oraz 19. W linii 5 jest tak zwany nagłówek – określamy nazwę funkcji, jakie argumenty przyjmuje oraz jaką wartość zwraca. Sama funkcja wraz z kodem ją realizującym jest określona w linii 19 i następnych. Po co to? Bo bez nagłówka funkcji kompilator w linii 13 nie mógłby określić czy wywołanie funkcji jest poprawne. Dlatego w C jeżeli chcemy korzystać z funkcji  w programie w miejscu, do którego kompilator dociera zanim znalazł tą funkcję, musimy określić parametry niezbędne dla kompilatora w tym momencie – czyli właśnie jakie argumenty przyjmuje funkcja i jaką wartość zwraca. W Arduino IDE przed kompilacją naszego szkicu IDE dodaje nagłówki funkcji automatycznie.
• Nie mamy do dyspozycji funkcji znanych z biblioteki Arduino – czyli właśnie analogWrite, digitalRead itp. Dlatego operacje na portach dokonuję się za pomocą magicznych akronimów jak _BV, PD4. O tym co dokładnie znaczą i jak z nich korzystać postaram się napisać następnym razem.

Kod jest udostępniony na githubie:

https://github.com/netmaniac/AVRtest

Ponieważ planuję na potrzeby następnych przykładów ten kod przerobić i rozbudować, to link do wersji dokładnie z tej której korzystałem w tym przykładzie jest taki:

https://github.com/netmaniac/AVRtest/tree/fb828f9edcccfc5945897b9e546b858af37022fd

LinkLove – na podstawie tych materiałów udało mi się ruszyć z programowaniem ATtiny, tam możecie szukać dalszych informacji, jeżeli nie macie cierpliwości aż powstaną następne przykłady :

http://www.evilmadscientist.com/article.php/avrtargetboards
http://www.instructables.com/id/Reading-Switches-with-ATtiny2313/step2/Blinkenlights-for-a-Signal/
http://www.engbedded.com/fusecalc/
http://www.ladyada.net/learn/avr/programming.html

Udział wzięli:

• ATtiny2313. Ewentualnie 2313V, jego brat bliźniak, który może pracować już od napięcia zasilającego 1.8V (vs 2.7 w wersji podstawowej), kosztem maksymalnej częstotliwości pracy 10 MHz
• USBtinyISP – sugeruję użycie gotowego programatora USBASP, który już jest w ofercie Nettigo
• BB-170 mała płytka stykowa, niezastąpiona do takich niewielkich, prostych prototypów
• JW-75 – uniwersalne kable do łączenia nie tylko płytek stykowych
• Coś do migania, jeżeli jeszcze jakimś cudem nie masz w szufladzie baterii diod LED i rezystorów

Ten wpis jest początkiem nieco dłuższej serii (mam nadzieję), w której postaram się przybliżyć nieco to co można zrobić bez Arduino…

Akcelerometr

Akcelerometr to czujnik badający przyspieszenie. Przyspieszenie występuje wtedy, kiedy jakaś rzecz zmienia prędkość. Opisuje to druga zasada dynamiki Newtona.

Jeśli jadąc samochodem naciśniesz na “gaz”, to samochód zacznie przyśpieszać, bo silnik zadziałał na niego większą siła przezwyciężając inną siłę – siłę tarcia, która stara się samochód zatrzymać.

Jeśli puścisz pedał “gazu”, to znowu siła tarcia będzie większa i będzie dążyła do zatrzymania samochodu. Czyli przyspieszenie będzie ujemne.

Jest jeszcze jedna siła. Siła grawitacji, która nie pozwala by samochód odfrunął, bo dociska go do ziemi. Siła grawitacji powoduje, że wszystko spada na ziemie z takim samym przyspieszeniem 9,81 m/s2. Ta siła  oznaczona jest jednostką 1 g (nie mylić z gramem).

Ta jednostka symbolizuje, że coś działa na jakąś rzecz z siłą grawitacji. W samolotach przy wykonywaniu manewrów siły działające na pilota dochodzą do 9 g. Popularnie się wtedy mówi, że jego ciało waży wtedy 9 razy więcej niż na ziemi. Za to na orbicie Ziemi panuje siła 0 g. Dlatego przedmioty mogą tam swobodnie latać.

Akcelerometr mierzy te siły w jednostkach g. Najpopularniejsze dziś akcelerometry 3-osiowe to tak naprawdę 3 akcelerometry w jednym układzie ułożone tak, by mierzyć przyspieszenie w 3 różnych kierunkach. W dół, w bok i do przodu. Kierunki te nazywane są osiami X, Y i Z i tak określają je twórcy urządzeń.

Jeśli zadziałasz na czujnik przyspieszeniem o przeciwnym kierunku niż został skierowany czujnik, to on zwróci nam wartość przyspieszenia jako ujemną.

Czujnik przyspieszenia i matematyka

Jeśli czujnik leży nieruchomo na ziemi, to wskazuje tylko siłę grawitacji skierowaną w dół do środka Ziemi.

W czujnikach 3-osiowych ta właściwość pozwala na określenie kąta pod jakim jest urządzenie względem ziemi. Wystarczy sprawdzić z jaką siłą grawitacja działa na poszczególne czujniki.

Zakładając, że czujnik skierowany w lewo to X, w przód to Y, a w dół to Z, to akcelerometr leżąc płasko na ziemi, powinien zwrócić wartości:

X = 0g
Y = 0g
Z = 1g

Oznacza to, że dół urządzenia skierowany jest do ziemi.

Natomiast jeśli przechylisz urządzenie na lewy bok, to czujniki pokażą:

X = 1g
Y = 0g
Z = 0g

Jak widzisz siła grawitacji przestała działać na czujnik Z i zaczęła działać z pełną siłą na czujnik X.

A co będzie, jeśli przechylisz urządzenie  między ziemią i lewym bokiem (o kąt 45°)?

X = 0.7g
Y = 0g
Z = 0.7g

Okazało się, że grawitacja podzieliła po równo siły na czujnik X i na czujnik Z. Im urządzenie jest skierowane bardziej dołem do ziemi, tym większa jest wartość Z, a mniejsza wartość X. Im urządzenie jest skierowane bardziej lewym bokiem tym większa wartość X, a mniejsza Z.

Jeśli zaczniesz przechylać urządzenie na prawy bok, to czujnik X zacznie zwracać wartości ujemne, bo siła grawitacji będzie działać w jego drugim kierunku. Jeśli położysz urządzenie górą do ziemi to czujnik Z zwróci wartość -1.

Specjalną funkcją trygonometryczną występującą w wielu językach programowania jest “atan2(y, x)”, przetwarzająca te wartości na dokładny kąt przechylenia urządzenia.

Funkcja ta bierze współrzędne punktu x, y i podaje pod jakim kątem jest ten punkt względem środka układu współrzędnych czyli punktu o współrzędnych 0, 0.

Jak zapewne wiesz w fizyce wartość siły określa się długością strzałki zwanej “wektorem”. Jej kierunek czyli “zwrot” to kierunek w jakim działa siła.

Jeśli na coś działa kilka sił w różnych kierunkach, to od tego odchodzi kilka wektorów w różnych kierunkach o określonej długości.

Jednak wynikiem działania tych sił jest wypadkowa siła działająca w jednym kierunku. Siłę tą można wyznaczyć poprzez “złożenie” innych sił, za pomocą linii pomocniczych. Ich przecięcie wyznaczy wypadkową siłę działającą na coś.

Możesz to sobie wyobrazić tak, że kwadrat jest samolotem, który leci w kierunku dłuższego wektora i wieje na niego boczny wiatr z kierunku krótszego wektora i go spycha. Czyli tak na serio samolot będzie leciał zgodnie z kierunkiem wektora siły wypadkowej.

Tak samo jest i w akcelerometrze. Jego czujniki zwracają wartości, które można przedstawić jako długości wektorów. Te wektory mają kierunek zgodny z kierunkiem czujników. Siłę wypadkową w przypadku akcelerometru wyznaczać będzie kierunek działania siły grawitacji, czyli kąt urządzenia względem ziemi.

To pozwala na proste użycie funkcji “atan2” do ustalenia kierunku siły wypadkowej złożonej z wartości sił poszczególnych czujników.

Wykorzystanie funkcji atan2

W jezyku programowania Python funkcja “atan2” znajduje się w module funkcji matematycznych “math”. Można ją testować podstawiając pod jej argumenty różne wartości z powyższych przykładów (argument “x” to wartość czujnika “Z”, a argument “y” to wartość czujnika “X”).

import math

print "Dol urzadzenia jest skierowany do ziemi"
print math.atan2(0, 1)

print "Lewy bok urzadzenia jest skierowany do ziemi"
print math.atan2(1, 0)

print "Urzadzenie skierowane w polowie miedzy ziemia i lewym bokiem"
print math.atan2(0.5, 0.5)

print "Urzadzenie skierowane jak w ostatnim przykladzie dzialania sil"
print math.atan2(0.66, 0.33)

Wynik działania programu może niektórym wydawać się dziwny:

 Dol urzadzenia jest skierowany do ziemi
0.0
Lewy bok urzadzenia jest skierowany do ziemi
1.57079632679
Urzadzenie skierowane w polowie miedzy ziemia i lewym bokiem
0.785398163397
Urzadzenie skierowane jak w ostatnim przykladzie dzialania sil
1.10714871779

Nie są to wartości przedstawione w stopniach. Są przedstawione w radianach.

Radian to jednostka kąta (używana w nauce i programowaniu), w której kąt zamiast w stopniach przedstawiany jest w wielokrotności liczby PI. Liczba PI czyli około 3,1415 odpowiada kątowi 180°. Połowa liczby PI czyli 1.57 to połowa kąta 180° czyli 90°. Tak samo jak 2*PI to kąt 2*180° czyli 360°.

Radiany przelicza się bardzo łatwo na stopnie. Służy do tego wzór:

stopnie = radiany * 180 / PI

Można też użyć specjalnej funkcji języka Python, która przerabia radiany na stopnie. Nosi ona nazwę “degrees” i jest z modułu “math”.

import math

print "Dol urzadzenia jest skierowany do ziemi"
print math.degrees(math.atan2(0, 1))

print "Lewy bok urzadzenia jest skierowany do ziemi"
print math.degrees(math.atan2(1, 0))

print "Urzadzenie skierowane w polowie miedzy ziemia i lewym bokiem"
print math.degrees(math.atan2(0.5, 0.5))

print "Urzadzenie skierowane jak w ostatnim przykladzie dzialania sil"
print math.degrees(math.atan2(0.66, 0.33))

Teraz wynik działania programu jest już bardziej zrozumiały i zgadza się z wcześniejszym teoretyzowaniem.

Dol urzadzenia jest skierowany do ziemi
0.0
Lewy bok urzadzenia jest skierowany do ziemi
90.0
Urzadzenie skierowane w polowie miedzy ziemia i lewym bokiem
45.0
Urzadzenie skierowane jak w ostatnim przykladzie dzialania sil
63.4349488229

Wspomne jeszcze o dwóch rodzajach kątów. Na co dzień przyzwyczajeni jesteśmy przez szkołę, że istnieją kąty od 0 do 360°. Jenak nie jest tak zawsze.  Często też liczy się tak, że kąty na prawo od 0° to 1°, 2°, 3° … 180°, a na lewo to -1°, -2°, -3° … -179°. Zatem zamiast 181° jest -179°, a zamiast 359° jest -1°.

W Arduino używanie funkcji “atan2” jest podobne, z tą różnicą, że nie ma funkcji konwertującej na stopnie, dlatego zastosowałem wzór.

void setup()
{
  Serial.begin(9600);

  Serial.println(F("Dol urzadzenia jest skierowany do ziemi"));
  Serial.println(atan2(0, 1) * 180 / PI);

  Serial.println(F("Lewy bok urzadzenia jest skierowany do ziemi"));
  Serial.println(atan2(1, 0) * 180 / PI);

  Serial.println(F("Lewy bok urzadzenia jest skierowany do ziemi"));
  Serial.println(atan2(0.5, 0.5) * 180 / PI);

  Serial.println(F("Urzadzenie skierowane jak w ostatnim przykladzie dzialania sil"));
  Serial.println(atan2(0.66, 0.33) * 180 / PI);
}

void loop()
{
}

Czujnik przyspieszenia ADXL345

Wiele płytek z czujnikami w ofercie Nettigo ma w sobie czujnik przyspieszenia ADXL345. Jest to cyfrowy czujnik przyspieszenia. Pracuje on w standardzie 3,3V. Komunikuje się za pomocą interfejsów TWI (i2c) lub SPI. Czujnik może mierzyć przyspieszenia do +/- 16 g. Przy pełnym zakresie pomiarów rozdzielczość wynosi 13 bitów, a dokładność 0,004 g. Jednak można też zawęzić zakres pomiarowy do +/- 2/4/8/16 g i rozdzielczość do 10 bitów w ten sposób zmniejszając dokładność. Czujnik może mierzyć przyspieszenie z częstotliwością od 6,25 do 3200 razy na sekundę. Urządzenie ma bufor FIFO. Pozwala on na to, żeby procesor nie musiał odczytywać wyników w określonym czasie wyznaczonym przez częstotliwość, tylko odczytał je potem w większej ilości na raz.

Podłączenie czujnika ADXL345

Czujnik występujący na płytkach ma zazwyczaj wyprowadzone piny magistrali i2c i zasilania. Zasilanie wynosi 3,3V i w takim też standardzie działa płytka. Jeśli chcesz podłączyć ja do Arduino musisz zastosować dwukierunkowy konwerter poziomów logicznych opisany w poprzednim wpisie.

Wyjście magistrali TWI w nowym Arduino UNO R3 znajduje się tak jak na rysunku nad pinem AREF.

W starszych płytkach magistrala miała wyprowadzenia w grupie pinów ANALOG IN. Sygnał SDA jest w pinie Analog In 4, a sygnał SCL jest w Analog In 5.

W Arduino MEGA sygnały TWI są w grupie pinów COMMUNICATION. Sygnał SDA to pin 20, a SCL to pin 21.

Wyjście magistrali TWI (i2c) w standardzie 5V podłączone są do dwukierunkowych wejść konwertera poziomów logicznych za pomocą przewodów pomarańczowego (SDA) i zielonego (SCL).

Do konwertera podłączone jest też zasilanie 5V (czerwony przewód) i 3,3V (niebieski przewód). Masa czyli GND podłączona jest czarnym przewodem.

Dwukierunkowe wyjście magistrali TWI z konwertera w standardzie 3,3V oznaczone jest przewodem fioletowym (SCL) i żółtym (SDA), które wraz z zasilaniem 3,3V (niebieski przewód) i GND (czarny przewód) trafia do czujnika.

Ponieważ jest wiele wersji płytek czujników, musisz sam sprawdzić w jego dokumentacji do jakich pinów trafiają jakie sygnały. W przykładzie wybrałem płytkę najbardziej rozbudowanego czujnika 9dof.

Programowanie czujnika ADXL345

Do sterowania czujnikiem najlepiej użyć wbudowanej w Arduino IDE biblioteki “Wire.h”. Zapewnia ona komunikację z urządzeniami magistrali i2c (TWI).

Biblioteka udostępnia obiekt o nazwie “Wire” przez który wywołujemy różne metody obsługujące magistralę. W funkcji “setup” należy najpierw wywołać metodę “Wire.begin()” przygotowującą bibliotekę do działania.

#include <Wire.h>

void setup()
{
  Wire.begin();
}

Aby wysłać coś do urządzenia potrzebne są kolejne 3 metody.

• “Wire.beginTransmission(adres)”, która przygotowuje przesyłanie danych do urządzenia, którego adres (numer identyfikacyjny określający do którego urządzenia wysyła się dane) jest argumentem metody.

• “Wire.write(dane)”, która wysyła dane do urządzenia.

• “Wire.endTransmission()”, która kończy wysyłanie danych do wybranego urządzenia.

Czujnik ADXL348 ma adres w magistrali TWI o numerze szesnastkowym 0×53. Czujnik ten ma kilkanaście rejestrów. Rejestry to takie sprzętowe zmienne wewnątrz urządzenia, które ustawiają parametry działania urządzenia i przechowują wyniki jego pracy. Aby zapisać coś do rejestru, trzeba wysłać do urządzenia 2 bajty. Pierwszym jest numer rejestru, a kolejnym wartość jaką trzeba zapisać do rejestru.

Ponieważ czujnik wymaga ustawienia kilku rejestrów napisałem specjalną funkcję ustawiającą rejestr.

void twiSetRegister(int address, byte reg, byte data)
{
  // przygotowanie transmisji
  Wire.beginTransmission(address);
  // wysylanie numeru rejestru
  Wire.write(reg);
  // wysylanie wartosci do zapisania w rejestrze
  Wire.write(data);
  // koniec transmisji
  Wire.endTransmission();
  delay(5);
}

Argumenty tej funkcji to adres urządzenia, numer rejestru i wartość do zapisania w tym rejestrze.

Aby uruchomić czujnik trzeba ustawić 3 rejestry.

Rejestr o numerze 0x2d to jakby włącznik czujnika. Ustala on czy urządzenie ma działać czy być w trybie uśpienia regulując tym samym jego pobór prądu. Bity tego rejestru oznaczają:

Bit Link ustawia urządzenie w tryb nieaktywności, i pomiary są robione dopiero kiedy procesor potwierdzi, że chce je otrzymać.

Bit AUTO_SLEEP ustawia czujnik w tryb oszczędzania energii, z którego wychodzi po wykryciu przyspieszenia o jakiejś minimalnej wartości.

Bit Measure włącza tryb normalnej pracy czujnika. Czujnik robi ciągle pomiary i zapisuje ich wyniki w odpowiednich rejestrach.

Bit Sleep przełącza urządzenie w tryb oszczędzania energii

Bity Wakeup regulują czas, co jaki urządzenie w trybie oszczędzania energii ma się budzić i sprawdzać przeciążenie. Od 1 do 8 razy na sekundę.

W programie ustawiam ten rejestr na wartość 0×08 czyli binarnie 00001000. Oznacza to, że włączę tylko bit Measure rejestru. Przestawi to czujnik w tryb ciągłego pomiaru bez żadnego oszczędzania energii.

Rejestr o numerze 0×31 ustala w jakim formacie mają być wyniki pomiarów czujnika.

Bit SELF_TEST służy do testowania czujnika. Po jego włączeniu zamiast normalnych wartości pomiarów zwraca specjalne liczby, których zakres jeśli się zgadza z dokumentacją, to czujnik jest dobry.

Bit SPI służy do ustawiania trybu pracy magistrali SPI. Jeśli jest włączony to magistrala jest 3 przewodowa (sygnał danych jest 2 kierunkowy), jeśli wyłączony to magistrala jest standardowa 4 przewodowa z 2 przewodami przesyłania danych.

Bit INT_INVERT określa czy wyjście przerwania jest aktywne w stanie wysokim (bit włączony) lub aktywne w stanie niskim (bit wyłączony).

Bit FULL_RES włącza tryb pełnej rozdzielczości czujnika (13 bitów), gdzie wynik ma dokładnośc 0,004 g na jednostkę. Wyłączenie bitu skaluje wynik na wartość 10 bitową, której zakres ustala się kolejnymi bitami.

Bit Justify. Wynik pomiaru w zależności bitu FULL_RES jest 10 albo 13 bitowy. Rejestry z wynikiem są 2*8 bitów czyli 16 bitowe. Włączenie tego bitu powoduje, że wynik będzie zapisany od ostatniego bitu rejestru wyniku (binarnie nnnnnnnnnn000000 n-to bity wyniku), a wyłączenie, że od pierwszego (binarnie 000000nnnnnnnnnn).

Bity Range0 i Range1 ustalają zakres pomiarów czujnika od +/-2 do +/-16 g. Zakres ten pozwala określić dokładność w jakiej pracuje czujnik w trybie 10 bitowym. Np. dla zakresu +/-2g dokładność wyjścia 10 bitów (1024 poziomy) będzie wynosiła(od -2 do 2 są 4 jednostki)  4 / 1024 = 0,004 g czyli taka sama jak w trybie “FULL_RES”. Dla kolejnych zakresów dokładność będzie spadała z każdym krokiem o połowę.

W programie ustawiłem ten rejestr na wartość szesnastkową 0×08 czyli binarnie 00001000. Oznacza to włączony tylko bit FULL_RES ustawiający wyjścia na dokładność 0.004g na jednostkę.

Rejestr o numerze 0x2c ustawia częstotliwość z jaką czujnik ma mierzyć przyspieszenie.

Bit LOW_POWER włącza tryb oszczędzania energii (o 30%). W tym trybie pomiar może być wykonywany normalnie, lecz jest bardziej zaszumiony.

Bity Rate3..Rate0 określają cześtotliwość pomiarów (w Hz) z jaką wyniki będą zapisywane do rejestrów.

Rejestr ten ustawiłem na wartość 0×09 czyli binarnie 00001001, co daje częstotliwość pomiarów 50 razy na sekundę.

Rozwinięty program z ustawianiem rejestrów wygląda tak:

#include <Wire.h>

// Adres czujnika 
#define ADXL_ADDR 0x53

// Funkcja ustawiania rejestru

void twiSetRegister(int address, byte reg, byte data)
{
  Wire.beginTransmission(address);
  Wire.write(reg);
  Wire.write(data);
  Wire.endTransmission();
  delay(5);
}

void setup()
{
  Wire.begin();

  // Ustawianie rejestrow
  twiSetRegister(ADXL_ADDR, 0x2d, 0x08);
  twiSetRegister(ADXL_ADDR, 0x31, 0x08);
  twiSetRegister(ADXL_ADDR, 0x2c, 0x09);
}

void loop()
{
}

Po uruchomieniu programu czujnik powinien działać już prawidłowo jednak do pełni szczęścia zostało…

Odczytywanie danych z czujnika ADXL345

Wyniki pomiarów czujnika to liczby typu “int” (16 bitowa wartość ze znakiem [+/-]). Ponieważ rejestry czujnika są 8 bitowe, to wynik przechowywany jest w 2 rejestrach dla każdego kierunku. W pierwszym są bity od 0 do 7 (zwane też LSB), a w drugim od 8 do 15 (zwane też MSB).

Za zamianę 2 zmiennych 8 bitowych na jedną 16 bitową odpowiada funkcja “word(h, l)”. Jej pierwszym argumentem jest zmienna 8 bitowa przechowująca bity od 8 do 15, a drugim zmienna trzymająca bity od 0 do 7. Można ją wykorzystać tak:

int wynik = word(rejestr1, rejestr0);

Jeśli jest ustawiony bit FULL_RES rejestru 0×31 to jednostka wyniku daje dokładność 0,004 g. Co można łatwo przeliczyć na siłę w jednostkach g.

float sila_g = wynik * 0.004;

Do odebrania danych z rejestrów musisz poznać kolejne 3 metody obiektu “Wire”.

• “Wire.requestFrom(adres, ilosc)” – przygotowuje magistrale TWI do odbioru danych z urządzenia o adresie podanym w pierwszym argumencie, a ilość danych do odbioru określa się w drugim argumencie.

• “Wire.available()” – zwraca ilość bajtów oczekujących na odebranie.

• “Wire.read()” – zwraca jeden bajt danych odebranych z magistrali TWI.

Przygotowałem funkcję ułatwiającą odczyt kilku rejestrów napisaną na podstawie tych metod.

byte twiGetRegisters(int address, byte reg, byte *buffer, byte length)
{
  // liczinik odebranych danych
  byte count = 0;

  // wyslanie numeru pierwszego rejestru
  Wire.beginTransmission(address);
  Wire.write(reg);
  Wire.endTransmission();

  // odbieranie wartosci z rejestrow
  Wire.beginTransmission(address);
  Wire.requestFrom(address, (int) length);
  while (Wire.available())
  {
    buffer[count] = Wire.read();
    count++;
  }
  Wire.endTransmission();

  // zwracanie ilosci odebranych danych
  return count;
}

Argumenty tej funkcji to adres urządzenia z którego chcesz pobrać dane, numer rejestru od którego chcesz zacząć pobieranie, nazwa tablicy do której mają być zapisane dane i ilość danych do odczytania.

Funkcja zwraca liczbę odczytanych rejestrów.

Rejestry z wynikami zaczynają się od numeru 0×32. Ułożone są parami x0, x1, y0, y1, z0, z1.

#include <Wire.h>

// Adres czujnika 
#define ADXL_ADDR 0x53

// Funkcja ustawiania rejestru
void twiSetRegister(int address, byte reg, byte data)
{
  Wire.beginTransmission(address);
  Wire.write(reg);
  Wire.write(data);
  Wire.endTransmission();
  delay(5);
}

// Funkcja odczytywania rejestrow
byte twiGetRegisters(int address, byte reg, byte *buffer, byte length)
{
  byte count = 0;

  Wire.beginTransmission(address);
  Wire.write(reg);
  Wire.endTransmission();

  Wire.beginTransmission(address);
  Wire.requestFrom(address, (int) length);
  while (Wire.available())
  {
    buffer[count] = Wire.read();
    count++;
  }
  Wire.endTransmission();

  return count;
}

void setup()
{
  Wire.begin();

  // Ustawianie rejestrow
  twiSetRegister(ADXL_ADDR, 0x2d, 0x08);
  twiSetRegister(ADXL_ADDR, 0x31, 0x08);
  twiSetRegister(ADXL_ADDR, 0x2c, 0x09);

  // Ustawienie komunikacji z komputerem
  Serial.begin(57600);
}

void loop()
{
  // tablica do zapisywania danych z rejestrow
  byte buffer[6];
  // odczytywanie 6 rejestrow do tablicy buffer
  byte readed = twiGetRegisters(ADXL_ADDR, 0x32, buffer, 6);
  // sprawdzenie czy odebrano 6 rejestrow
  if (readed != 6)
  {
    // jesli nie to wyswietl error
    Serial.println(F("ERROR"));
  }
  else
  {
    // jesli tak to wyswietl wartosc pomiaru akcelerometru Z
    //odczytywanie wartosci cyfrowej z akcelerometru
    int result = word(buffer[5], buffer[4]);
    // zamiana cyfrwej wartosci na jednostke g
    float g_force = result * 0.004;
    Serial.println(g_force);
  }
  // oczekiwianie na kolejny wynik 20 ms czyli 1/50 s
  // dla czujnika ustawionego na 50 pomiarow/s
  delay(20);
}

Program odczytuje wartość pomiaru z czujnika przyśpieszenia “Z” i wyświetla w jednostkach g. Jeśli czujnik leżał płasko na ziemi to powinien zwracać wartość około 1.00 g. Wraz z przechylaniem czujnika wartość ta powinna maleć.

Odczytywanie przechylenia i pochylenia czujnika

Na początku wpisu opisałem funkcję “atan2(y, x)”. Teraz przyszedł czas na jej wykorzystanie.
Kąt przechylenia (na boki) obliczasz składając wektory czujników “X” i “Z”.

float roll = atan2(gX, gZ) * 180 / PI;

Kąt pochylenia (do przodu i do tyłu) obliczasz składając wektory czujników “Y” i “Z”.

float pitch = atan2(gY, gZ) * 180 / PI;

W ten sposób możesz przerobić funkcję “loop” programu do odczytywania kąta położenia urządzenia względem Ziemi.

void loop()
{
  byte buffer[6];
  byte readed = twiGetRegisters(ADXL_ADDR, 0x32, buffer, 6);
  if (readed != 6)
  {
    Serial.println(F("ERROR"));
  }
  else
  {
    // odczytanie wartości pomiarów
    int resultX = word(buffer[1], buffer[0]);
    int resultY = word(buffer[3], buffer[2]);
    int resultZ = word(buffer[5], buffer[4]);

    // zamiana na jednostki g
    float gX = resultX * 0.004;
    float gY = resultY * 0.004;
    float gZ = resultZ * 0.004;

    // obliczenie przechylenia
    float roll = atan2(gX, gZ) * 180 / PI;
    // obliczenie pochylenia
    float pitch = atan2(gY, gZ) * 180 / PI;

    // wyslanie danych do komputera
    Serial.print(roll); // przechylenie
    Serial.print(",");
    Serial.println(pitch); // pochylenie
  }
  delay(20);
}

Program powinien zwracać w “Serial Monitor” (pamiętaj o ustawieniu 57600 bodów) 2 liczby rozdzielone przecinkiem. Pierwsza to kąt przechylenia, a druga to kąt pochylenia.

Praktyczne wykorzystanie

Byś mógł lepiej prześledzić działanie czujnika, napisałem za pomocą języka Python i modułów “pyserial” i “PyGtk2” program wizualizujący jego działanie. Program składa się z 3 widgetów. Pierwszym jest wyświetlanie przyspieszeń w 3 osiach. Widget jest podobny do tego wykorzystywanego kiedyś w transmisjach F1 pokazujący przeciążenia działające na kierowce.

Drugim widgetem jest znany z samolotów sztuczny horyzont pokazujący przechylenie i pochylenie samolotu względem ziemi.

Trzecim widgetem jest symulacja znanej u majsterkowiczów poziomnicy, którą się przykłada do różnych konstrukcji, by sprawdzić czy trzymają poziom.

Żółty wskaźnik to wektor siły z akcelerometru “X”, czerwony/zielony akcelerometru “Y”, a niebieski “Z”.

Program wymaga, aby Arduino dostarczyło do komputera odpowiednie dane o siłach przyspieszenia, pochyleniu i przechyleniu w formacie:

#ACC=fx,fy,fz,roll,pitch\r\n

Dlatego przerobiłem funkcję “loop” z ostatniego przykładu na taką:

void loop()
{
  byte buffer[6];
  byte readed = twiGetRegisters(ADXL_ADDR, 0x32, buffer, 6);
  if (readed != 6)
  {
    Serial.println(F("ERROR"));
  }
  else
  {
    int resultX = word(buffer[1], buffer[0]);
    int resultY = word(buffer[3], buffer[2]);
    int resultZ = word(buffer[5], buffer[4]);

    float gX = resultX * 0.004;
    float gY = resultY * 0.004;
    float gZ = resultZ * 0.004;

    float roll = atan2(gX, gZ) * 180 / PI;
    float pitch = atan2(gY, gZ) * 180 / PI;

    Serial.print(F("#ACC="));
    Serial.print(gX);
    Serial.print(",");
    Serial.print(gY);
    Serial.print(",");
    Serial.print(gZ);
    Serial.print(",");
    Serial.print(roll);
    Serial.print(",");
    Serial.println(pitch);
  }
  delay(20);
}

Program w Pythonie do uruchomienia wymaga tylko jednej drobnej zmiany. Ustalenia w zmiennej “ACC_PORT” na początku pliku, nazwy portu szeregowego do którego podłączyłeś Arduino.

ACC_PORT = 'com4:'

Kalibracja akcelerometru

Świat nie jest idealny. Montując czujnik w urządzeniu nie masz gwarancji, że umieścisz go tam idealnie prosto, lub wymaga to zbyt wiele wysiłku. Kładąc potem urządzenie na wypoziomowanym podłożu może się okazać, że czujnik wskazuje jakiś kąt przechylenia/pochylenia. Taka sytuacja wymaga kalibracji czujnika.

Korekcja polega na dodaniu lub odjęciu jakiejś wartości od wyników czujnika tak, żeby podawał wartości jakich oczekujesz.

Do korekcji osi czujników służą specjalne rejestry o numerach 0x1e, 0x1f, 0×20 odpowiadające osiom “X”, “Y”, “Z”. Pozwalają one dodać lub odjąć jakąś wartość do rejestrów wynikowych czujnika. Maksymalną korekcję jaką można dokonać to +/- 2g. Rejestry przyjmują wartości 8 bitowe ze znakiem, czyli typ “char” (przechowujący liczby od -128 do 127). Minimalna jednostka z jaką można przesunąć wartość wyniku to:

2.0 / 128 = 0.015625 g

Jeśli moje urządzenie leżąc płasko na ziemi ma wyniki X:0,05g, Y:-0,11g, Z:1,0g, to oprócz “Z”, które jest prawidłowo, trzeba przesunąć inne o odwrotną wartość, czyli:

 X: -0,05 / 0,015625 = -3 Y: 0,11 / 0,015625 = 7 

Zatem do rejestru 0x1e trzeba wpisać liczbę -3, do 0x1f trzeba wpisać 7, a do 0×20 trzeba wpisać 0.

void setup()
{
  Serial.begin(57600);
  Wire.begin();
  twiSetRegister(ADXL_ADDR, 0x2d, 0x08);
  twiSetRegister(ADXL_ADDR, 0x31, 0x08);
  twiSetRegister(ADXL_ADDR, 0x2c, 0x09);

  // kalibracja
  twiSetRegister(ADXL_ADDR, 0x1e, (char) -3);
  twiSetRegister(ADXL_ADDR, 0x1f, (char) 7);
  twiSetRegister(ADXL_ADDR, 0x20, (char) 0);
}

Typ “(char)” w nawiasie określa jakiego typu mają być liczby przekazywane w argumencie.

Innym rodzajem kalibracji jest określenie, czy każdy czujnik po skierowaniu w kierunki grawitacji i w przeciwnym ma takie same wielkości wartości (czyli 1.0g i -1.0g). Jeśli się różnią to trzeba je odpowiednio przeskalować.

Zakładając, że przy dokładności 0.004 g, wartość cyfrowa czujnika czyli zmiennej “resultX” dla 1g wynosi 1 / 0.004 = 250

Jeśli czujnik “X” skierowany w kierunku grawitacji zwracałby wartość cyfrową 256, a w przeciwnym -270, to należałoby go skalibrować za pomocą takiego algorytmu:

if (resultX >= 0)
{
  resultX = map(resultX, 0, 256, 0, 250);
}

else
{
  resultX = map(resultX, -270, 0, -250, 0);
}

Wykorzystałem tu funkcje skalującą “map” z biblioteki Arduino. Funkcja ta przetwarza zakres wartości jakimi dysponujesz (argumenty 0, 256), na wartości jakich oczekujesz (argumenty 0, 250). Dzięki temu jeśli czujnik skierowany w kierunku grawitacji zwróci 256, to funkcja “map” przerobi tą wartość na 250 czyli 1g.

Niedoskonałości czujnika przyspieszenia

Czujnik przyspieszenia nie jest idealnym rozwiązaniem do badania położenia. O tym samym przekonani się producenci telefonów i konsol. Wystarczy, że nim potrząśniesz (czyli dodasz kilka wektorów przyspieszenia), a już gubi kierunek grawitacji. Można próbować to eliminować różnymi filtrami i algorytmami, ale one tylko spowalniają pomiar, a tym samym szybkość reakcji urządzenia na zmianę położenia.

Inną niedogodnością jest to, że sam czujnik przyspieszenia wykrywa tylko przechylenie i pochylenie (pitch i roll), ale nie wykrywa odchylenia (yaw) czyli kierunku wg stron świata.

Te niedogodności rozwiązują inne czujniki (znajdujące się zwykle na płytkach z akcelerometrem), które opiszę w kolejnych odcinkach.

Linki

• Przykładowy program w Pythonie
• Wszystkie czujniki w sklepie Nettigo, w tym wszystkie akcelerometry oraz dokładnie ADXL 345
• Dokumentacja czujnika ADXL345

Aby móc obsłużyć inne urządzenia USB niezbędny jest właśnie USB Host Shield. Shield ten jest produkowany przez SparkFun na podstawie projektu wykonanego przez CircuitsAtHome. Autor shielda utrzymuje też bibliotekę go obsługującego. Sęk w tym, że ta wersja bibliotki jest przeznaczona dla nieco zmodyfikowanej płytki sprzedawanej przez CircuitsAtHome. Wersja SparkFun (i sprzedawana przez Nettigo) wymaga drobnej modyfikacji aby działało oprogramowanie:

USB Host shield działający z wersją biblioteki 2.0

Wystarczy połączyć cyfrowe wyjście D7 z RST (obok zasilania 3.3V) i od tego momentu test płytki (board_qc w Examples) działa poprawnie:

Circuits At Home 2011
USB Host Shield Quality Control Routine
Reading REVISION register... Die revision 03
SPI long test. Transfers 1MB of data. Each dot is 64K................
SPI long test passed
GPIO test. Connect GPIN0 to GPOUT7, GPIN1 to GPOUT6, and so on
Test failed. Value written: 00 Value read: FF
Press any key to continue...
GPIO test passed.
PLL test. 100 chip resets will be performed
Resetting oscillator Reset number 0 Time to stabilize - 445 cycles Reset
number 1 Time to stabilize - 446 cycles Reset number 2 Time to stabilize
- 446 cycles Reset number 3 Time to stabilize - 446 cycles Reset number
4 Time to stabilize - 446 cycles Reset number 5 Time to stabilize - 456
cycles Reset number 6 Time to stabilize - 476 cycles Reset number 7 Time
to stabilize - 476 cycles Reset number 8 Time to stabilize - 477 cycles
Reset number 9 Time to stabilize - 476 cycles Reset number 10 Time to
stabilize - 476 cycles Reset number 11 Time to stabilize - 476 cycles
Reset number 12 Time to stabilize - 476 cycles Reset number 13 Time to
stabilize - 477 cycles Reset number 14 Time to stabilize - 476 cycles
Reset number 15 Time to stabilize - 477 cycles Reset number 16 Time to
stabilize - 476 cycles Reset number 17 Time to stabilize - 477 cycles
Reset number 18 Time to stabilize - 476 cycles Reset number 19 Time to
stabilize - 477 cycles Reset number 20 Time to stabilize - 476 cycles
Reset number 21 Time to stabilize - 476 cycles Reset number 22 Time to
stabilize - 476 cycles Reset number 23 Time to stabilize - 476 cycles
Reset number 24 Time to stabilize - 477 cycles Reset number 25 Time to
stabilize - 476 cycles Reset number 26 Time to stabilize - 477 cycles
Reset number 27 Time to stabilize - 476 cycles Reset number 28 Time to
stabilize - 477 cycles Reset number 29 Time to stabilize - 476 cycles
Reset number 30 Time to stabilize - 478 cycles Reset number 31 Time to
stabilize - 476 cycles Reset number 32 Time to stabilize - 476 cycles
Reset number 33 Time to stabilize - 476 cycles Reset number 34 Time to
stabilize - 476 cycles Reset number 35 Time to stabilize - 478 cycles
Reset number 36 Time to stabilize - 476 cycles Reset number 37 Time to
stabilize - 477 cycles Reset number 38 Time to stabilize - 476 cycles
Reset number 39 Time to stabilize - 477 cycles Reset number 40 Time to
stabilize - 476 cycles Reset number 41 Time to stabilize - 478 cycles
Reset number 42 Time to stabilize - 476 cycles Reset number 43 Time to
stabilize - 476 cycles Reset number 44 Time to stabilize - 476 cycles
Reset number 45 Time to stabilize - 476 cycles Reset number 46 Time to
stabilize - 477 cycles Reset number 47 Time to stabilize - 476 cycles
Reset number 48 Time to stabilize - 478 cycles Reset number 49 Time to
stabilize - 476 cycles Reset number 50 Time to stabilize - 477 cycles
Reset number 51 Time to stabilize - 476 cycles Reset number 52 Time to
stabilize - 478 cycles Reset number 53 Time to stabilize - 476 cycles
Reset number 54 Time to stabilize - 476 cycles Reset number 55 Time to
stabilize - 476 cycles Reset number 56 Time to stabilize - 476 cycles
Reset number 57 Time to stabilize - 478 cycles Reset number 58 Time to
stabilize - 476 cycles Reset number 59 Time to stabilize - 477 cycles
Reset number 60 Time to stabilize - 476 cycles Reset number 61 Time to
stabilize - 477 cycles Reset number 62 Time to stabilize - 476 cycles
Reset number 63 Time to stabilize - 477 cycles Reset number 64 Time to
stabilize - 476 cycles Reset number 65 Time to stabilize - 477 cycles
Reset number 66 Time to stabilize - 477 cycles Reset number 67 Time to
stabilize - 476 cycles Reset number 68 Time to stabilize - 478 cycles
Reset number 69 Time to stabilize - 476 cycles Reset number 70 Time to
stabilize - 477 cycles Reset number 71 Time to stabilize - 476 cycles
Reset number 72 Time to stabilize - 477 cycles Reset number 73 Time to
stabilize - 476 cycles Reset number 74 Time to stabilize - 477 cycles
Reset number 75 Time to stabilize - 476 cycles Reset number 76 Time to
stabilize - 476 cycles Reset number 77 Time to stabilize - 476 cycles
Reset number 78 Time to stabilize - 476 cycles Reset number 79 Time to
stabilize - 477 cycles Reset number 80 Time to stabilize - 476 cycles
Reset number 81 Time to stabilize - 477 cycles Reset number 82 Time to
stabilize - 476 cycles Reset number 83 Time to stabilize - 477 cycles
Reset number 84 Time to stabilize - 476 cycles Reset number 85 Time to
stabilize - 477 cycles Reset number 86 Time to stabilize - 476 cycles
Reset number 87 Time to stabilize - 476 cycles Reset number 88 Time to
stabilize - 476 cycles Reset number 89 Time to stabilize - 476 cycles
Reset number 90 Time to stabilize - 477 cycles Reset number 91 Time to
stabilize - 476 cycles Reset number 92 Time to stabilize - 477 cycles
Reset number 93 Time to stabilize - 476 cycles Reset number 94 Time to
stabilize - 477 cycles Reset number 95 Time to stabilize - 476 cycles
Reset number 96 Time to stabilize - 476 cycles Reset number 97 Time to
stabilize - 476 cycles Reset number 98 Time to stabilize - 476 cycles
Reset number 99 Time to stabilize - 476 cycles Reset number 100 Time to
stabilize - 476 cycles
Checking USB device communication.

Device connected. Resetting Reset complete. Waiting for the first SOF...
Getting device descriptor
Descriptor Length:	12
Descriptor type:	01
USB version:		0110
Device class:		00
Device Subclass:	00
Device Protocol:	00
Max.packet size:	40
Vendor  ID:		055F
Product ID:		021D
Revision ID:		0100
Mfg.string index:	00
Prod.string index:	01
Serial number index:	00
Number of conf.:	01

All tests passed. Press RESET to restart test

GPIO na shieldzie są nie podłączone więc test ma prawo się nie udać. Do portu USB na shieldzie podłączyłem skaner Musteka (vendorID 055F).

Wstęp

Podczas rozwoju podzespołów elektronicznych, wraz z ich przyśpieszaniem i zmniejszaniem poboru energii, zmieniały się też standardy w jakich te układy pracowały. Obecnie w elektronice amatorskiej (także w Arduino) panuje standard 5V. Oznacza to, że zasilanie układów scalonych i ich stany logiczne odnoszą się właśnie do tego napięcia. Wiadomo, że stan niski “LOW” to GND, a stan wyoki “HIGH” to napięcie w okolicach 5V.

Coraz częściej spotyka się układy scalone pracujące w standardzie 3,3V. Oznacza to, że ich zasilanie i stany logiczne nie pasują do obecnych rozwiązań. W tym wpisie dowiesz się jak sprawić, by urządzenia obydwu standardów mogły się ze sobą łączyć i komunikować.

W Arduino w grupie pinów “POWER” jest wyjście napięcia 3,3V. W nowszych wersjach Arduino grupy R3 pojawił się tam dodatkowy pin o nazwie “IOREF”. Jest na nim napięcie w jakim pracuje dana płytka Arduino. To taki wybieg jego projektantów dla przyszłych wersji płytek, które mogą pracować już w standardzie 3,3V. Ten pin pozwoli dopasowywać komunikację układów podczas okresu przejściowego.

Opisywane wcześniej układy PCF8574 i TLC5940 potrafią pracować w obydwu standardach. Jeśli zasilisz je napięciem 5V, to pracują w standardzie 5V. Jeśli zasilisz napięciem 3,3V, to będą pracować w standardzie 3,3V.

Są też jeszcze inne układy przejściowe, które mają opcję “5V Compilant”. Są zasilane napięciem 3,3V, jednak jeśli podłączysz do nich sygnały logiczne standardu 5V, to będą działały bez przeszkód. Przykładem takiego układu jest opisany niżej bufor 74AHC125.

Coraz częsciej spotykane są układy używające tylko standardu 3,3V. Podłączenie do nich innych stanów logicznych lub zasilania może spowodować ich uszkodzenie. Aby komunikowały się ze starszym standardem potrzebne są układy dopasowujące, które tu opiszę.

Zasilanie układów 3,3V

Pin 3V3 w Arduino ma ograniczoną wydajność do 40 mA. Często zdarza się, że zasilane tym napięciem układy pobierają znacznie więcej prądu.

Jeśli tak jest i w twoim przypadku, należy zbudować sobie odpowiedni układ zasilający.

Układ jest dość prosty. Składa się ze stabilizatora liniowego (o oznaczeniu MCP1700-3302E/TO) i dwóch kondensatorów ceramicznych 1µF. Stabilizator to rodzaj układu scalonego, który mimo różnych napięc na wejściu, zawsze ma cały czas takie samo napięcie na wyjściu. Ten typ stabilizatora wytrzymuje prąd do 250 mA. Jest on w obudowie typu TO-92 znanej z różnego rodzaju tranzystorów. Układ ma trzy wyprowadzenia. Patrząc od jego ściętej strony od lewej  - pierwsze to GND, kolejne to wejście napięcia (do 6V), a ostatnie to wyjście stabilizowanego napięcia 3,3V. Do wejścia i wyjścia należy podłączyć kondensatory jak na rysunku.

Układ można zasilić napięciem z pinu 5V Arduino.

Układ pochodzi z modułu Adafruit XBee Adapter v1.1 i został w nim sprawdzony.

Są też inne stabilizatory wytrzymujące prąd o natężeniu do 3A. Podłączenie ich jest podobne do tego na rysunku, jednak zawsze należy się tego upewnić zaglądając do ich noty katalogowej.

Podłączenie wyjścia układu 5V do wejścia układu 3,3V

Schemat przedstawia połączenie Arduino pracującego w standardzie 5V z modułem typu XBee, pracującym w standardzie 3,3V. Sygnał wyjścia szeregowego Arduino ma trafić do wejścia szeregowego XBee i być przystosowany do jego napięcia pracy.

Wyjście pinu arduino podłączone jest do 2 rezystorów połączonych szeregowo. Wyjście drugiego rezystora podłączone jest do GND. Połączenie między rezystorami trafia do wejścia XBee.

Tak połączone rezystory tworzą tzw. dzielnik napięcia, pozwalający zmniejszyć napięcie. Napięcie wyjściowe ustala się ze wzoru:

Uwy = Uwe * R2 / (R1 + R2)

W tym układzie są 2 rezystory o takim samym oporze 10 kΩ. Daje to dzielnik napięcia przez 2.

Uwy = 5V * 10 kΩ / (10 kΩ + 10 kΩ) = 5V * 10 / 20 = 5V * 1 / 2 = 2,5 V

Co sprawia, że stan wysoki wychodzący z pinu 1 Arduino zostanie zmniejszony do 2,5V i trafi do XBee.

Ponieważ napięcie 2,5V jest mniejsze niż 3,3V to nie zepsuje XBee. Takie napięcie mieści się też na granicy zakresu tolerancji stanu wysokiego układów na 3,3V. Układ pochodzi z modułu Arduino XBee Shield v1.1 i działa w nim poprawnie.`

Innym sposobem dopasowania wyjścia 5V do wejścia 3,3V jest zastosowanie różnego rodzaju dopasowujących układów scalonych (buforów). Jednym z nich jest układ 74AHC125, posiadający 4 takie bufory.

Układ zasilany jest napięciem od 2 do 5V. Od napięcia zasilania zależy to w jakim standardzie będą działały wyjścia. W tym przypadku zasiliłem układ napięciem 3,3V (czerwony przewód).

Układ posiada 4 bufory. Wejścia buforów (oznaczone kolorem niebieskim) tolerują napięcie do 5V. Wyjścia (oznaczone kolorem żółtym) mają w stanie wysokim w tym przypadku napięcie do 3,3V. Każde wejście bufora jest powiązane z wyjściem i oznaczone na rysunku cyfrą.

Układ pochodzi z modułu Adafruit XBee Adapter v1.1 i działał w nim poprawnie.

Podłączenie wyjścia układu 3,3V do wejścia układu 5V

Tutaj sprawa jest ułatwiona. Wyjścia standardu 3,3V można łączyć bezpośrednio do wejść standardu 5V. Tolerancja wejść tego standardu pokrywa się z zakresem napięć wyjścia 3,3V.

Połączenie dwukierunkowe standarów 5V i 3,3V

Sygnały magistrali I2C (TWI) mogą być przesyłane w obydwu kierunkach. To utrudnia sprawę z dopasowaniem sygnału dla obydwu standardów i wymaga trudniejszego schematu.

Układ składa się z tranzystora MOSFET typu N z wbudowaną diodą o oznaczeniu BSS138 i 2 rezystorów 10 kΩ.

LV to wejście zasilania 3,3V, a HV to wejście zasilania 5V. TX_LV to miejsce podpięcia sygnału w standardzie 3,3V, natomiast TX_HV to miejsce podłączenia sygnału w standardzie 5V.

Wysyłając sygnały, urządzenia magistrali TWI ustawiają się albo w stan niski, albo nieustalony. Zapobiega to przeciążeniu układu w przypadku gdyby 2 urządzenia na raz zaczęły nadawać różne sygnały (jeden HIGH drugi LOW). Dlatego magistrala we własnym zakresie musi zapewnić rezystory podciągające PullUp zapewniające na niej bezpieczny stan wysoki jako domyślny. Układ na schemacie zapewnia takie rezystory dla każdej ze stron standardu oznaczone jako R3 i R4.

Tranzystor MOSFET (Q1) składa się z trzech wyprowadzeń. Bramka (Gate) to wyprowadzenie podłączone do zasilania LV (3,3V). Źródło (Source) to wyprowadzenie podłączone do wyjścia TX_LV. Ostatnie wyprowadzenie o nazwie dren podłączono do wyjścia TX_HV. Tranzystor jest rodzajem przełącznika, który przewodzi prąd między drenem i źródłem w zależności od napięcia jakie znajduje się między bramką i źródłem. Jeśli to napięcie nie różni się to tranzystor nie przewodzi. Jeśli się różni o jakąś minimalną wartość, to zaczyna przewodzić.

W przypadku, gdy żaden z układów magistrali nie ustawił jej w stan niski, napięcie na źródle i drenie nie różni się i dla obydwu wynosi 3,3V.

Gdy układ po stronie standardu 3,3V ustawi magistralę w stan niski, wtedy na źródle pojawi się stan LOW czyli GND czyli 0V, a na bramce pozostanie dalej napięcie 3,3V. W ten sposób powstanie różnica napięć i tranzystor zacznie przewodzić prąd. Czyli ustawi stan niski LOW po stronie standardu 5V.

Po stronie standardu 5V, gdy panuje stan wysoki HIGH, dioda nie przewodzi prądu i po stronie standardu 3,3V napięcie stanu wysokiego ustala rezystor PullUp R3. Gdy po stronie 5V urządzenie ustawi magistralę w stan niski, wtedy dioda zacznie przewodzić stan niski, który jest taki sam dla obydwu standardów.

Moduł konwersji stanów logicznych z Nettigo

Sklep Nettigo oferuje gotową płytkę, która zawiera 2 kanały dwukierunkowej konwersji standardów 3,3V i 5V, oraz dwa kanały konwersji standardów opartych na dzielnikach napięcia.

• HV – zasilanie 5V

• LV – zasilanie 3,3V

• GND – masa GND

• TXO – strona standardu 5V dla dwukierunkowego połączenia

• TXI – strona standardu 3,3V dla dwukierunkowego połączenia

• RXI – wejście standardu 5V do dzielnika napięcia

• RXO – wyjście standardu 3,3V z dzielnika

Przykład pokazuje jak wykorzystać moduł do konwersji standardu TWI w Arduino UNO R3. Wykorzystuje on 2 konwertery dwukierunkowe modułu.

Ten przykład jest kopią układu z początku artykułu. Pokazuje sposób podłączenie wyjścia szeregowego Arduino w standardzie 5V do wejścia szeregowego modułu typu XBee w standardzie 3,3V. Przykład wykorzystuje dzielnik napięcia kanału 1.

Oczywiście można wykorzystywać na raz dzielniki i 2 kanałowe połączenia.

Zakończenie

Na koniec wypada mi jeszcze wspomnieć o tym, że są też inne rodzaje Arduino, które pracują z różnymi standardami stanów logicznych. Arduino LilyPad można zasilać napięciami od 2,7 do 5 V. Zatem jego standard pracy zależy od tego jakim napięciem go zasilisz. Arduino Fio i Pro Mini (model 3,3V)  pracują już tylko w standardzie 3,3V.
Wpis ten jest wstępem do kolejnych, w których opiszę serię urządzeń pracujących tylko w standardzie 3,3V. Jakie to urządzenia? Przekonasz się o tym już za jakiś czas.

Linki

• Moduł konwersji stanów logicznych z Nettigo
• Nota katalogowa stabilizatorów MCP1700
• Nota katalogowa układu 74AHC125
• Dzielnik napięcia na Wikipedii

TLC5940 to układ scalony zawierający 16 wyjść PWM. Generator PWM układu ma rozdzielczość 12 bitów czyli 4096 stopni wypełnienia. Jedną z głównych zalet tego chipu jest możliwość podłączenia do jego wyjść bezpośrednio diod LED (bez rezystorów). Jego wyjścia mogą wytrzymać do 120 mA obciążenia.

Wyprowadzenia układu TLC5940

OUT0..OUT15 – 16 wyjść PWM generatorów układu. Wyjścia są typu “otwarty kolektor” czyli przewodzą albo stan niski, albo stan nieustalony. Wyjścia można obciążać maksymalnie od 5 do 120 mA. Prąd wyjść reguluje się za pomocą wyprowadzenia IREF i/lub specjalnych rejestrów “DC” układu.

VPRG – Wejście trybu programowania układu – podłączasz do GND w Arduino.
Stan niski to programowanie rejestrów wypełnienia PWM (GS), stan wysoki to programowanie rejestrów korekcji prądu wyjść (DC).

SIN – Wejście szeregowe  - podłączasz do pinu cyfrowego 11 w Arduino UNO

SCLK – Wejście szeregowe zegara zatwierdzającego bity danych – podłączasz do pinu cyfrowego 13 w Arduino UNO

XLAT – Wejście zatwierdzające wysłane dane – podłączasz do pinu cyfrowego 9 w Arduino UNO

BLANK – Wejście wyłączania wyjść i resetowania liczników generatora PWM – podłączasz do pinu cyfrowego 10 w Arduino UNO

GND – Wejście zasilania masa – podłączasz do GND w Arduino

VCC – Wejście zasilania +5 V – podłączasz do pinu zasilania 5V w Arduino

IREF – Wejście ustalania prądu na wyjściach OUT. Do wejścia podłączasz rezystor o oporze dostosowanym do prądu wyjścia, gdzie druga noga rezystora jest podłączona do GND.

Prąd wyjścia oblicza się ze wzoru:

Imax = (Vref / Rref) * 31,5 = (1.24 / Rref) * 31,5

Rref = Wartość oporu rezystora podłączonego między IREF i GND.

Przyjmując, że diody LED wymagają prądu 20 mA, to rezystor powinien mieć wartość 2 KOhm.

DCPRG – Wejście wybierania danych dokładnej regulacji prądu wyjścia – podłączasz do +5V

GSCLK – Wejście zegara, którego impulsy powodują zliczanie przez liczniki generatorów PWM układu – podłączasz do pinu cyfrowego 3 w Arduino UNO

SOUT – Szeregowe wyjście danych z układu. W konfiguracji wielu układów złączonych szeregowo to wyjście jest podłączone do SIN następnego układu.

XERR  - Wyjście błędów układu. Jeśli układ się przegrzeje, lub jakaś dioda LED podłączona do wyjść generatora PWM się przepali, na wyjściu pojawią się impulsy stanu niskiego. Wyjście jest typu “otwarty dren”, co powoduje, że ma albo stan niski, albo nieustalony.

Podłączenie układu TLC5940 do Arduino

Schemat przedstawia sposób podłączenia układu do Arduino. Połączenie zabiera 5 cyfrowych pinów Arduino. Do wyjść od OUT0 do OUT15 można podłączyć bezpośrednio diody LED, katodą do OUT, anodą do 5V (pod warunkiem zastosowania odpowiedniego rezystora IREF). W przykładzie podłączyłem diodę LED do wyjścia OUT1.

Podłączenie do Arduino MEGA

Ponieważ Arduino MEGA ma wyjście SPI w nieco innym miejscu, podłączenie do niego TLC5940 wymaga innego schematu elektrycznego.

Programowanie układu TLC5940

#include <Tlc5940.h>

void setup()
{
  Tlc.init();

  Tlc.set(1, 2048);

  while (Tlc.update());
}

void loop()
{
}

Społeczność Arduino napisała również dla układu TLC5940 odpowiednią bibliotekę. Przykład zapala diodę LED podłączoną do wyjścia OUT1 na połowę jasności.

Programowanie układu rozpoczyna się od załadowania odpowiedniej biblioteki poprzez “#include <Tlc5940.h>”. Następnie w funkcji “setup” biblioteka musi zostać zainicjowana za pomocą metody “Tlc.init();”. Metodę “Tlc.update()” umieściłem w pętli “while”. Metoda ta odpowiada za wysłanie danych do do układu i zaktualizowanie jego rejestrów. Trzeba wywoływać ja tak długo aż zwróci wartość 0. Jeśli nie jest to krytyczne, możesz umieścić też tą metodę w funkcji “loop”.

Za ustawianie poszczególnych wyjść PWM układu TLC5940 odpowiada metoda “Tlc.set”. Jej pierwszym parametrem jest numer wyjścia od 0 do 15, a drugim wartość wypełnienia generatora PWM od 0 do 4095.

Bibioteka wykorzystuje do swojej pracy układy Timer1 i Timer2 oraz SPI kontrolera Arduino, dlatego warto uważać, czy nie koliduje to z inną biblioteką w twoim projekcie.

Metody obiektu Tlc:

• Tlc.init() Uaktywnia działanie biblioteki i inicjuje komunikacje z układem TLC5940. Ma opcjonalny argument, który jest liczbą od 0 do 4095. Argument ustawia początkową wartość wypełnienia na wszystkich wyjściach układu. Wywołanie metody bez argumentu sprawia, że wyjścia ustawiają się na 0.
• Tlc.clear() Ustawia wszystkie wyjścia na wartość 0.

• Tlc.setAll(value) Ustawia wszystkie wyjścia na wartość wypełnienia podaną w argumencie (od 0 do 4095).

   

• Tlc.set(out, value) Ustawia wyjście określone w argumencie “out” (od 0 do 15) na wartość określoną w argumencie “value” (od 0 do 4095).
• Tlc.get(out) Zwraca wartość wypełnienia dla wyjścia podanego w argumencie “out” (od 0 do 15).
• Tlc.update() Wysyła dane do układu. Zwraca 0 jeśli dane zostaną zatwierdzone lub 1 jeśli jeszcze nie.

Wskaźnik diodowy

#include <Tlc5940.h>

void tlc_progress(word value, word prefix)
{
  byte out_num = value / 4096;
  word out_brg = value % 4096;

  for (byte out=0; out<16; out++)
  {
    if (out < out_num)
    {
      Tlc.set(out, prefix);
    }

    else if (out == out_num)
    {
      Tlc.set(out, out_brg);
    }

    else
    {
      Tlc.set(out, 0);
    }
  }
}

void setup()
{
  Tlc.init();
}

void loop()
{
  int value = analogRead(0);
  value = map(value, 0, 1023, 0, 65535);
  tlc_progress(value, 4095);
  Tlc.update();
}

Jako temat przykładu użycia biblioteki wykorzystałem pomysł na wskaźnik typu “linijka diodowa”. Zakłada on podłączenie do wszystkich pinów OUT układu TLC5940 diod LED. Działanie wskaźnika można opisać w ten sposób, że im program dostanie większe napięcie na pin Arduino Analog 0 tym więcej diod na kolejnych wyjściach się będzie świeciło. Przy napięciu 5V świecą się wszystkie diody. Dodatkową zaletą wykorzystania PWM jest to, że ostatnia zapalona dioda wskaźnika zapala się stopniowo wraz ze wzrostem napięcia na wejściu.

Najważniejszą funkcją programu jest “tlc_progress”. Steruje ona zapalaniem diod podłączonych do układu. Jej pierwszy arguement to wartość od 0 do 65535. Im większa liczba tym kolejne diody wskaźnika się płynnie zapalają. Kolejnym argumentem funkcji jest argument jasności świecenia lampek poprzedzających ostatnią zapaloną. Jeśli ustawisz mu wartość 0, to będzie paliła się na raz tylko jedna dioda – imitując wskazówkę.

Jeśli wstawisz tam wartość maksymalną, czyli 4095, to będą zapalały się kolejne diody aż do maksymalnej jasności.

W funkcji “loop” program odczytuje wartość z pinu Analog 0. Ponieważ funkcja “analogRead” odczytuje wartości z zakresu od 0 do 1023, to trzeba je przeskalować za pomocą funkcji “map” na wartości zakresu funkcji “tlc_progress”, czyli od 0 do 65535.

Wskaźnik diodowy ma zastosowanie tam, gdzie nie liczy się zbytnia dokładność, ale ważne jest szybkie zorientowanie się co do poziomu jakiegoś sygnału. Program możesz łatwo przerobić na fajny “analogowy” termometr, obrotomierz lub wskaźnik poziomu głośności w zestawie audio.

W nagraniu do wejścia analogowego 0 podłączyłem potencjometr.

Inne przykłady z biblioteki układu

Oprócz podstawowego nagłówka “Tlc5940.h”, biblioteka posiada jeszcze kilka ciekawych nagłówków z dodatkowymi funkcjami pomagającymi szybko rozwiązać pewne pomysły.

Fades

Pierwszym z nich jest “tlc_fades.h”, ułatwiający tworzenie płynnie zapalających się i gasnących efektów świetlnych.

#include <Tlc5940.h>
#include <tlc_fades.h>

void setup()
{
  Tlc.init();

  tlc_addFade(1, 0, 4095, 5000, 10000);
}

void loop()
{
  tlc_updateFades();
}

Użycie biblioteki rozpoczynasz od dodania nagłówka “#include <tlc_fades.h>”. Potem należy normalnie zainicjować układ w funkcji “setup”. W funkcji “loop” powinna być funkcja “tlc_updateFades();” odpowiedzialna za synchronizowanie działania całej biblioteki.

Za przygotowanie zapalania/gaśnięcia odpowiada funkcja “tlc_addFade”. Jej pierwszym argumentem jest numer wyjścia układu TLC5940 na którym ma się odbyć animacja. Kolejnym jest wartość początkowa jasności animacji (od 0 do 4095). Trzecim argumentem jest wartość końcowa jasności animacji o parametrach jak poprzednia.

Dwa ostatnie argumenty to czas w milisekundach liczony od chwili włączenia Arduino. Przedostatni mówi o tym w jakiej milisekundzie ma się rozpocząć animacja, a kolejny w jakiej ma się skończyć.

Funkcja w przykładzie tworzy animacje zapalenia się diody na wyjściu “OUT1” od wartości 0 do wartości 4095. Rozświetlenie ma się odbyć w czasie od 5 do 10 sekundy od chwili włączenia Arduino.

Można wykonać do 24 animacji na raz (wywołań funkcji “tlc_addFade”). Potem trzeba poczekać, aż któraś animacja się skończy. Pomocną przy tym funkcją jest “tlc_isFading”. Jej argumentem jest numer wyjścia, a zwraca 1 jeśli na danym wyjściu jest przewidziana jakaś animacja lub 0 jeśli nie jest.

Jest jeszcze funkcja “tlc_removeFades”. Jej argumentem jest numer wyjścia. Usuwa ona wszystkie animacje dla danego wyjścia.

#include <Tlc5940.h>
#include <tlc_fades.h>

void setup()
{
  Tlc.init();
}

void loop()
{
  if (!tlc_isFading(1))
  {
    unsigned long time = millis();
    tlc_addFade(1, 0, 4095, time+1000, time+1250);
    tlc_addFade(1, 4095, 0, time+1500, time+2000);
  }
  tlc_updateFades();
}

W tym przykładzie zrealizowałem animację mrugania diody LED na wyjściu OUT1. Warunek “if” sprawdza czy jest tam aktualnie animacja i jeśli nie ma to tworzy kolejną.

Animacja powstaje tak, że pobierany jest aktualny czas do zmiennej “time”. Sekundę po tym czasie rozpoczyna się rozświetlanie trwające 250 ms. Po 1.5 s zaczyna się gaśnięcie trwające 500 ms. Daje to ładny efekt płynnego mrugania.

Funkcja “tlc_updateFades” ma opcjonalny argument, którym są aktualne milisekundy. Jeśli nie odpowiada ci w animacji czas od chwili włączenia Arduino, możesz w argumencie dostarczyć swoją aktualną wartość czasu wyrażoną w milisekundach.

Shifts

Biblioteka “tlc_shifts.h” odpowiada za efekt przesuwania wartości wypełnienia z jednego wyjścia na kolejne.

#include <Tlc5940.h>
#include <tlc_shifts.h>

void setup()
{
  Tlc.init();
}

void loop()
{
  static byte counter = 0;
  if (counter % 4)
    tlc_shiftUp(0);

  else
    tlc_shiftUp(4095);

  counter++;
  Tlc.update();
  delay(100);
}

Przykład tworzy efekt “wąż świetlny”, który polega na złudzeniu, że światło w diodach ustawionych w linię pełza.

Funkcja “tlc_shiftUp” powoduje zapisanie do wyjścia OUT0 nowej wartości wypełnienia, podanej w argumencie, podczas gdy reszta wartości jest przesuwana do kolejnych wyjść (z OUT0 do OUT1, z OUT1 do OUT2 itp.). Ostatnia wartość, która była w rejestrze wypełnienia OUT15 jest zwracana przez tą funkcję (ułatwia to zapętlanie).

Jest też odwrotnie działająca funkcja o nazwie “tlc_shiftDown”, której argument zapisuje wartość wypełnienia do OUT15 i przesuwa wartości rejestrów w dół (z OUT15 do OUT14, z OUT14 do OUT13 itp.). Zwraca ona wartość rejestru OUT0 przed przesunięciem.

Dane z pamięci programu

Czasem zachodzi potrzeba przeniesienia na wyjścia PWM jakiś danych z pamięci. Kontroler AVR w Arduino ma kilka pamięci z których najbardziej pojemna jest pamięć Flash, gdzie przechowywany jest program. Pamięć RAM jest kilka razy mniej pojemna, dlatego najlepiej przechowuje się w niej aktualne zmienne, a nie tablice ze stałymi danymi. Dlatego autorzy biblioteki układu TLC5940 zadbali o możliwość współpracy z pamięcią programu.

#include <Tlc5940.h>
#include <tlc_progmem_utils.h>

byte pwm_data[24] PROGMEM = {
  GS_DUO(4095, 3839), GS_DUO(3583, 3327), GS_DUO(3071, 2815), GS_DUO(2559, 2303), 
  GS_DUO(2047, 1791), GS_DUO(1535, 1279), GS_DUO(1023, 767), GS_DUO(511, 255)
};

void setup()
{
  Tlc.init();

  tlc_setGSfromProgmem(pwm_data);

  while (Tlc.update());
}

void loop()
{
}

Biblioteka “tlc_progmem_utils.h” zawiera narzędzia do obsługi danych z pamięci programu.

Aby przygotować tablice wartości wypełnienia dla rejestrów PWM układu, trzeba ją zadeklarować w odpowiedni sposób. oprócz standardowego określenia typu “byte”, nazwy tablicy “pwm_data” i jej rozmiaru, trzeba jeszcze dodać odpowiednią dyrektywę informującą, że tablica ma być przechowywana w pamięci programu a nie w normalnej pamięci RAM. Ta dyrektywa to “PROGMEM”. Rozmiar tablicy określony jest przez ilość danych potrzebnych do zaprogramowania układu. Wynika on z tego, że układ potrzebuje szesnastu 12 bitowych wartości. W języku C nie ma typu, który by przechowywał dokładnie 12 bitowe wartości. Jest albo 16 bitowy “word”, albo 8 bitowy “byte”. Aby nie było niepotrzebnych strat danych biblioteka używa 8 bitowego “byte”. 24 elementy tablicy typu “byte” wynikają z tego, że 16×12 bitów /  8 (typ byte) = 24. Tablica jest poukładana od ostatniego rejestru GS OUT15 do pierwszego GS OUT0.

Aby było łatwiej układać dane, w bibliotece jest makro o nazwie GS_DUO, które ma dwa argumenty reprezentujące kolejne 2 wyjścia PWM (OUT15, OUT14 aż do OUT1, OUT0).

Wysłaniem danych z tablicy zajmuje się funkcja “tlc_setGSfromProgmem”. Jej argumentem jest nazwa tablicy z danymi do wyświetlenia.

Animacje z pamięci programu

Jeśli chciałbyś wysyłać do układu TLC5940 sekwencje danych np. w postaci animacji lub danych do wyświetlacza widmowego, możesz skorzystać z biblioteki “tlc_animations.h”, która działa podobnie do poprzedniej.

#include <Tlc5940.h>
#include <tlc_animations.h>

byte pwm_data[24*2] PROGMEM = {
  GS_DUO(4095, 0), GS_DUO(4095, 0), GS_DUO(4095, 0), GS_DUO(4095, 0), 
  GS_DUO(4095, 0), GS_DUO(4095, 0), GS_DUO(4095, 0), GS_DUO(4095, 0), 

  GS_DUO(0, 4095), GS_DUO(0, 4095), GS_DUO(0, 4095), GS_DUO(0, 4095), 
  GS_DUO(0, 4095), GS_DUO(0, 4095), GS_DUO(0, 4095), GS_DUO(0, 4095)
};

void setup()
{
  Tlc.init();
}

void loop()
{
  if (!tlc_onUpdateFinished)
  {
    tlc_playAnimation(pwm_data, 2, 500);
  }
}

Tym razem wielkość tablicy “pwm_data” musi być pomnożona o liczbę klatek animacji. W tym przykładzie stworzyłem 2 klatki animacji. Pierwsza klatka to maksymalne świecenie diod wyjść nieparzystych, a druga to maksymalne świecenie diod parzystych. Klatki rozdzieliłem pustą linia.

Za uruchomienie animacji odpowiada funkcja “tlc_playAnimation”. Jej pierwszy argument to tablica z danymi animacji, drugi to liczba klatek animacji, a ostatni to czas po jakim mają się wyświetlać kolejne klatki animacji. Czas jest wyrażony w cyklach licznika PWM, a jeden cykl trwa 1,024 ms. Zatem 500 oznacza, że klatki będą pojawiać się co około pół sekundy.

Ponieważ funkcja “tlc_playAnimation” nie zapętla animacji, dlatego po wyświetleniu ostatniej klatki animacji trzeba ją uruchamiać ponownie. Zmienna “tlc_onUpdateFinished” zwraca 0 jeśli animacja się skończyła i 1 jeśli wciąż trwa. Dlatego zastosowałem ją w “if” do zapętlania animacji.

Korekcja prądu wyjść układu TLC5940

Jeśli podłączasz do wyjść układu TLC5940 różnokolorowe diody LED, często ich światło nie jest jednakowo jasne. Można to ustawić tworząc skomplikowane wzory przeliczające wartość rejestru wypełnienia i ograniczając rozdzielczość kanałów PWM. Ten układ ma jednak dodatkowy sprzęt, który pomoże dokonać korekty jasność.

Rejestry DC (Dot Correct) odpowiadają za dokładniejszą regulację prądu na wyjściach PWM. Ich rozdzielczość jest 6 bitowa, czyli przyjmują wartości od 0 do 63. Dzielą one wartość maksymalnego prądu na wyjściu ustalanego przez rezystor na wejściu IREF.

Aby dobrać się do rejestrów DC należy dokonać drobnej zmiany w układzie elektrycznym i bibliotece programu.

Na schemacie dodałem kolejny przewód do cyfrowego pinu Arduino. Przewód prowadzi od wejścia VPRG (noga 27 układu TLC5940) do pinu cyfrowego 8 w Arduino. W Arduino MEGA należy podłączyć ten sygnał do cyfrowego pinu 50.

Potem w katalogu biblioteki układu znajdź plik “tlc_config.h”, który odpowiada za ustawianie parametrów biblioteki i znajdz w nim definicję “#define VPRG_ENABLED 0” i zmień na “#define VPRG_ENABLED 1”. Uaktywni to dodatkowe elementy biblioteki odpowiedzialne za rejestry DC.

#include <Tlc5940.h>
#include <tlc_progmem_utils.h>

byte DC_data[12] PROGMEM = {
  DC_QUARTET(3, 3, 3, 3), DC_QUARTET(3, 3, 3, 3), 
  DC_QUARTET(14, 14, 14, 14), DC_QUARTET(14, 14, 14, 14)
};

void setup()
{
  Tlc.init(4095);

  tlc_setDCfromProgmem(DC_data);

  while (Tlc.update());
}

void loop()
{
}

Rejestry najłatwiej obsługiwać za pomocą biblioteki “tlc_progmem_utils.h”.

Ustawianie rejestrów DC wygląda podobnie do opisywanej wcześniej funkcji ustawiania rejestrów wypełnienia z pamięci programu Flash. W tym przypadku potrzebna jest tablica w pamięci programu zawierająca 12 elementów typu “byte”. Do łatwego ustawiania poszczególnych rejestrów potrzebne są makra “DC_QUARTET”, które mają po 4 argumenty, reprezentujące poszczególne wyjścia w odwrotnej kolejności. Do ustawienia wszystkich rejestrów potrzeba czterech makr.

Za zapisanie danych z tablicy do układu TLC5940 odpowiada funkcja “tlc_setDCfromProgmem”, której jedynym argumentem jest nazwa tablicy z danymi rejestrów DC.

W przykładzie miałem do wyjść OUT0 – OUT7 podłączone diody zielone i do wyjść OUT8 – OUT15 diody czerwone. Diody czerwone były bardzo jaskrawe i dużo jaśniejsze od zielonych, dlatego dostały wartość 3, a diody zielone, mniej jaskrawe wartość 14.

Wszystko dlatego ma tak niskie wartości, aby nie raziło, a jednocześnie świeciło na tyle jasno by widzieć dokładnie które diody świecą.

Sterowanie serwomechanizmem

Jak dowidziałeś się z poprzedniego wpisu, kąt obrotu serwomechanizmu zależy od szerokości impulsu PWM. Do układu TLC5940 możesz też podłączyć 16 serwomechanizmów.

Wyjścia układu TLC 5940 są typu “otwarty kolektor” i przekazują tylko albo stan niski, albo nieustalony. Dlatego aby wysterować wejście sterujące sewomechanizmu, trzeba podłączyć rezystor PullUp. Rezystor ten wg. dokumentacji biblioteki powinien mieć od 2k do 5k Ohm.

#include <Tlc5940.h>

#define SERVO_MIN_WIDTH 177
#define SERVO_MAX_WIDTH 571

#include <tlc_servos.h>

void setup()
{
  tlc_initServos();
}

void loop()
{
  int value = analogRead(0);
  value = map(value, 0, 1023, 0, 180);

  tlc_setServo(1, value);
  Tlc.update();
}

Do używania serwomechanizmów przez układ służy specjalna biblioteka “tlc_servos.h”. Ponieważ biblioteka ma ustawione dość bezpieczne czasy minimalnego i maksymalnego impulsu serwomechanizmu, dlatego przed załadowaniem biblioteki trzeba zdefiniować własne ich czasy w makrach “SERVO_MIN_WIDTH” i “SERVO_MAX_WIDTH”. Wartości te są wyrażone w liczbie czasu wypełnienia w rejestrze PWM czyli od 0 do 4095. Pierwsza wartość wypełnienia jest przy serwie ustawionym na 0 stopni, a druga na 180 stopni. Czas wypełnienia dla 1000 mikrosekund to 204. Moje serwomechanizmy (HTX900) mają zakres od 870 do 2800 mikrosekund, dlatego dałem im wartości wypełnienia od 177 do 571. Wartości te można obliczyć ze wzoru:

GSvalue = czas_impulsu_us * 204 / 1000

W funkcji “setup” biblioteka wymaga wywołania funkcji “tlc_initServos();”, której opcjonalny argument to kąt obrotu serw podłączonych do wyjść.

Serwomechanizmy ustawia się za pomocą funkcji “tlc_setServo”, której pierwszym argumentem jest numer wyjścia, do którego podłączone jest serwo, a drugim kąt obrotu jego osi.

Na końcu należy oczywiście zatwierdzić wysłanie danych do układu za pomocą metody “Tlc.update();”

Dane do serwomechanizmu można też przekazywać za pomocą metody “Tlc.set”, pamiętając by nie przekraczać minimalnego i maksymalnego impulsu. Zanim poda się parametr wypełnienia dla tej metody, trzeba go odjąć od liczby 4095 (“Tlc.set(4095-imp_width);”).

Korzystając z biblioteki serwomechanizmów, do można do wyjść podłączyć też inne elementy, pamiętając o tym, że teraz generują impulsy z częstotliwością 50 Hz.

Program w przykładzie odczytuje wartość z wejścia analogowego i po przeskalowaniu ustawia oś serwomechanizmu proporcjonalnie do napięcia na wejściu.

UWAGA:

Biblioteka wymaga drobnej poprawki, gdyż wynik zakresu impulsu moich serwomechanizmów wywołał w niej błąd. W katalogu biblioteki w pliku “tlc_servos.h” funkcja “tlc_angleToVal” powinna wyglądać tak:

/** Converts and angle (0 - SERVO_MAX_ANGLE) to the inverted tlc channel value
    (4095 - 0). */
uint16_t tlc_angleToVal(uint8_t angle)
{
    return 4095 - SERVO_MIN_WIDTH - (
            ((uint32_t) (angle) * (uint16_t)(SERVO_MAX_WIDTH - SERVO_MIN_WIDTH))
            / SERVO_MAX_ANGLE);
}

Sterowanie silnikiem

Silnikiem elektrycznym steruje się jak w poprzednim wpisie za pomocą tranzystora MOSFET. Pamiętając oczywiście o zapewnieniu rezystora PullUp na wyjściu układu TLC5940.

#include <Tlc5940.h>

void setup()
{
  Tlc.init();
}

void loop()
{
  int value = analogRead(0);
  value = map(value, 0, 1023, 0, 4095);

  Tlc.set(1, value);
  Tlc.update();
}

Przykład nie różni się od poprzednich, nie wymaga specjalnej biblioteki. Steruje prędkością silnika w zależności od napięcia na analogowym wejściu 0 w Arduino, skalując wartość do poziomu zakresu wartości rejestru wypełnienia GS.

Łączenie wielu układów TLC5940

Aby zyskać kolejne wyjścia PWM należy podłączyć kolejny układ TLC5940. Nie trzeba do tego wykorzystywać żadnych dodatkowych pinów Arduino. Kolejne układy podłączamy tak samo jak ten pierwszy, przekazując kolejnym te same sygnały z jednym wyjątkiem. Sygnał SIN (noga 26) następnego układu łączysz z sygnałem SOUT (noga 17) poprzedniego. W ten sposób zyskujesz kolejne 16 wyjść PWM. Układów możesz tak łączyć dowolną ilość pamiętając, że przesadne ilości wymagają więcej modyfikacji w bibliotece sterującej.

Aby program mógł skorzystać z dodatkowych układów należy otworzyć plik z katalogu biblioteki o nazwie “tlc_config.h”. Jest w nim zdefiniowane makro “#define NUM_TLCS 1”. Liczba za nazwą odpowiada liczbie podłączonych układów TLC5940. W moim przypadku będzie to “#define NUM_TLCS 2”.

#include <Tlc5940.h>

void setup()
{
  Tlc.init();

  Tlc.set(1, 2048);
  Tlc.set(17, 2048);

  while (Tlc.update());
}

void loop()
{
}

W programie sterującym układami prawie nic się nie zmienia. Różnica polega tylko na tym, że kolejne wyjścia mają kolejne numery. Zatem czerwona dioda LED podłączona do OUT1 pierwszego układu ma numer 1, a zielona dioda LED podłączona do wyjścia OUT1 drugiego układu ma numer 17. Jest to bardzo proste rozwiązanie.

Podobnie jest z innymi elementami biblioteki układu. W każdej ilość wyjść zwiększa się o wielokrotność układów. Biblioteki korzystające z pamięci Flash muszą mieć powiększone tablice do ilości wyjść układów.

Zakończenie

TLC5940 to bardzo ciekawy układ scalony. Jego możliwości w połączeniu z Arduino są bardzo duże. Dzięki niemu możesz robić kroczące roboty, na których mięśnie składa się kilkanaście serwomechanizmów, lub zaskakujące efekty świetlne na przyszłoroczną choinkę. Zdecydowanie najciekawszym efektem jaki można zrobić przy pomocy tych układów jest wyświetlacz widmowy. Nie chciałem odbierać ci tej przygody i dlatego postaraj się zrealizować go sam :-). Tylko pamiętaj o solidnym przymocowaniu LED-ów najlepiej na płytce uniwersalnej.

Linki

• TLC5940NT do kupienia na Nettigo
• Biblioteka Tlc5940.h
• Opis biblioteki Tlc5940.h [en]

Wstęp

Wielu użytkowników Arduino zapewne zauważyło, że wśród pinów z grupy DIGITAL jest kilka oznaczonych jako “PWM” lub “~”. W tym artykule postaram się wyjaśnić co to znaczy i jak dokładnie działa. Napiszę też jak można to praktycznie wykorzystać.

PWM w teorii

PWM to skrót od angielskich słów “Pulse Width Modulation”, co oznacza po polsku “Modulacja Szerokości Impulsu”.

W życiu codziennym posługujesz się przełącznikami. One powodują, że włączasz jakieś urządzenie lub wyłączasz. Włączenie oznacza dostarczenie do urządzenia 100% energii elektrycznej, a wyłączenie zmniejsza tą ilość do 0%.

Jeśli masz w domu jakieś urządzenie z silnikiem to możesz zauważyć, że włączając i wyłączając je wiele razy w ciągu sekundy silnik nie zdąży się rozpędzić do maksymalnych obrotów. Wynika to z tego, że wolno się rozpędza. Zatem jeśli odetniesz mu prąd zanim osiągnie maksymalne obroty to będzie kręcił się wolniej i zwalniał do czasu, aż znowu go włączysz. W ten sposób można regulować jego prędkość.

Działanie PWM polega właśnie na tym, że im dłużej silnik jest włączony w ciągu sekundy, tym szybciej się kręci. A jeśli dłużej trwa czas wyłączenia tym wolniej. Czas włączenia to właśnie ten “Impuls” (“Pulse”) w nazwie, którego “Szerokość” (“Width”) regulujesz.

Fizycznie rzecz ujmując działanie PWM polega na dostarczeniu mniejszej ilości energii elektrycznej do urządzenia w przeciągu jakiegoś czasu. Czego skutkiem ubocznym są takie właśnie miłe efekty jak regulacja szybkości lub jasności.

Parametry PWM

W rzeczywistości urządzenia PWM są dużo szybsze. Te w Arduino działają z prędkością około 400 razy na sekundę, co pozwala regulować urządzenia mające dużo szybszy czas reakcji np. jasność żarówek lub diod LED.

Parametrów pracy PWM jest kilka. Najważniejsze z nich są 3.

• Szybkość działania: To częstotliwość w jakiej mieszczą się czasy włączenia i wyłączenia. 400 Hz oznacza, że PWM włącza i wyłącza coś 400 razy na sekundę. Od tego zależy płynność pracy urządzenia.

• Wypełnienie: Oznacza ile czasu na jeden okres włączenia/wyłączenia PWM jest w stanie wysokim. 50% oznacza, że pół czasu urządzenie jest włączone, a drugie pół wyłączone. 75% oznacza, że ¾ czasu urządzenie jest włączone.

• Czas impulsu: Jest parametrem pochodzącym od powyższych. Oznacza to ile czasu trwa impuls włączenia. Jeśli PWM pracuje z prędkością 400 Hz, to czas całej fali PWM (włączony/wyłączony) trwa 1/400 = 0,0025s. Jeśli wypełnienie zajmuje 25% to czas impulsu wynosi 0,0025 * 25% = 0,0025 * 0,25 = 0,000625 s czyli 625 mikrosekund.

PWM w praktyce

Działanie generatora PWM w urządzeniach cyfrowych polega na tym, że w rejestrze przechowującym jakąś liczbę trzymana jest wartość wypełnienia. Od wielkości tego rejestru zależy ile jest stopni wypełnienia. 8 bitowy rejestr może mieć 256 stopni wypełnienia, a 16 bitowy 65 tysięcy. Oznacza to z jaką dokładnością będzie można regulować długość impulsu.

1 / 256 * 100 = 0,39

Wynik ten podaje, że 8 bitowy rejestr PWM jest w stanie regulować wypełnienie z dokładnością 0,39%.

Oprócz rejestru w generatorze PWM jest też licznik. Licznik to urządzenie, które przechowuje liczbę i co jakiś czas dodaje do niej +1. Od szybkości dodawania tej wartości zależy szybkość z jaką pracuje PWM.

Ostatnim elementem generatora PWM jest układ, który porównuje wartość licznika z wartością rejestru wypełnienia. Jeśli te wartości są sobie równe to wyjście PWM zmienia się w stan niski czyli wyłącza urządzenie.

Po dojściu licznika do ostatniej wartości jaką może policzyć, stan wyjścia PWM zmieniany jest na wysoki – włączający urządzenie i licznik zaczyna liczyć od nowa.

Wykres działania generatora PWM dla wartości 10 w 8 bitowym rejestrze wypełnienia.

Wykres działania generatora PWM dla wartości 15 w 8 bitowym rejestrze wypełnienia.

Programowy PWM

Z pewnością mogłeś mi nie uwierzyć, że to jest takie proste ;-). Dlatego, aby ci to udowodnić napiszę program do Arduino, który będzie udawał działanie generatora PWM i regulował jasność wbudowanej w Arduino diody LED.

// numer pinu z wbudowaną diodą
#define LED_PIN 13

// Zmienna z wartością licznika
byte pwmCounter = 0;
// Zmienna z wartością rejestru wypełnienia
byte pwmValue = 10;

void setup()
{
  // Ustawienie pinu diody na wyjście
  pinMode(LED_PIN, OUTPUT);
  // Ustawienie pinu diody na stan niski
  digitalWrite(LED_PIN, LOW);
}

void loop()
{
  // Jeśli stan licznika się przekręci to ustaw pin w stan wysoki
  if (pwmCounter == 0)
  {
    digitalWrite(LED_PIN, HIGH);
  }

  // Jeśli stan licznika jest równy stanu rejestru to ustaw pin w stan niski
  if (pwmCounter == pwmValue)
  {
    digitalWrite(LED_PIN, LOW);
  }

  // Zwiększanie wartości licznika o 1
  pwmCounter++;
}

Działanie programu odpowiada temu co opisałem w zasadzie działania generatora PWM. Zmienna “pwmValue” reprezentuje rejestr regulujący szerokość impulsu czyli poziom wypełnienia. Wartość 10 odpowiada wypełnieniu 3,90%.

10 / 256 * 100 = 3,90

Zmienna “pwmCounter” to zmienna reprezentująca licznik generatora. Zarówno ta zmienna, jak i “pwmValue” są typu “byte”, zatem reprezentują wartości 8 bitowe, czyli mogą przechowywać liczby od 0 do 255. Jeśli licznik podczas dodawania przekroczy tą liczbę, to zaczyna liczyć od nowa od 0.

Cały mechanizm działania generatora PWM znajduje się w funkcji “loop”. W pierwszym warunku “if” sprawdzane jest czy licznik nie zaczął liczyć od nowa. Jeśli tak to wyjście PWM ustawiane jest w stan wysoki.

W drugim warunku “if” program sprawdza, czy wartość licznika jest równa wartości rejestru wypełnienia. Jeśli tak to zmienia stan wyjścia PWM na niski, który będzie utrzymany aż licznik zacznie liczyć od nowa czyli od 0.

Jeśli uruchomiłeś ten program to powinieneś zauważyć w Arduino, że wbudowana dioda świeci bardzo słabo. Zmieniając wartość zmiennej “pwmValue” możesz zmieniać jasność świecenia tej diody. Wartość 255 to maksymalne świecenie, a 0 to minimalne.

Takie rozwiązanie programowe jest proste, ale ma kilka wad. Pierwszą jest to, że dodając nowe elementy do programu powodujesz, że szybkość działania generatora spada, bo musi się on dzielić czasem procesora z innymi elementami programu. Inną wadą jest to, że wyjście takiego generatora może być niestabilne, przez to, że na działanie głównego programu mogą wpływać przerwania. Jednym z nich jest np. komunikacja Serial.

Sprzętowy PWM

Arduino UNO posiada w grupie pinów “DIGITAL” 6 wyjść PWM. Oznaczone są one na płytce przez napisy “PWM” lub znaczek “~”. Generowane przez te wyjścia sygnały PWM są tworzone sprzętowo przez wbudowane w procesor Arduino liczniki/timery. Oznacza to, że program procesora ani ich nie zwalania, ani nie wpływa na zakłócenia ich pracy. Domyślnie pracują one z prędkością 490 Hz i przyjmują wartości 8 bitowe.

Funkcja odpowiadająca za działanie tych pinów nosi nazwę “analogWrite”. Jej pierwszym argumentem jest numer pinu PWM, a drugim wartość wypełnienia od 0 do 255.

Aby ta funkcja zadziałała pin musi być najpierw ustawiony jako wyjście.

#define PWM_PIN 3

void setup()
{
  pinMode(PWM_PIN, OUTPUT);

  analogWrite(PWM_PIN, 10);
}

void loop()
{
}

Jak widzisz w funkcji “loop” nie trzeba już niczego zamieszczać. Sygnał generuje się automatycznie po wywołaniu “analogWrite”.

Co można podłączyć do PWM?

Niestety nie ma sprzętowego wyjścia PWM do pinu 13 wbudowanej diody LED. Zatem aby sprawdzić działanie wyjścia możesz podłączyć do niego inną diodę połączoną szeregowo z rezystorem 220 Ohm. Jej anodę podłączasz do wyjścia PWM, a katodę do GND.

Można też w ten sposób podłączyć 3-kolorową diodę LED ze wspólną katodą, tak by każde wyjście PWM sterowało osobnym kolorem, co da płynną możliwość dobierania kolorów.

Taka dioda LED składa się z 3 niezależnych diod w jednej obudowie. Barwy emitowane przez diody są podstawowymi barwami składowymi RGB – Czerwony, Zielony, Niebieski. Każda z tych barw podłączona jest do innego wyjścia PWM (pin 3 – zielony, pin 5 – niebieski, pin 6 – czerwony) przez rezystor 220 Ohm. Wspólna katoda diod podłączona jest do GND. Takie połączenie powinno dać teoretycznie 16 mln barw (256 poziomów na składową czyli 256^3 = 16777216).

Do wyjścia PWM możesz podłączyć też silnik elektryczny i regulować prędkość jego wału. Ponieważ silnik pobiera znacznie więcej prądu niż może wygenerować cyfrowe wyjście Arduino, zalecam zastosowanie tranzystora MOSFET typu N. Tranzystory te wytrzymują znaczne prądy obciążenia i duże napięcia (w moim przypadku do 12A i 60V – tranzystor o oznaczeniu D12N06 (typu N) ze starej drukarki).

Bramkę (Gate) tranzystora podłączyłem przez rezystor 1 KOhm do wyjścia PWM pin 3. Źródło (Source) tranzystora podłączyłem do GND. Natomiast Dren (Drain) połączyłem z silnikiem. Drugie wyprowadzenie silnika podłączyłem z jego zasilaniem. Do tego może służyć osobny zasilacz silnika lub pin Vin Arduino, jeśli silnik nie pobiera zbyt dużej mocy.

W przypadku silnika, nie każda wartość wypełnienia impulsu PWM może wpływać na jego działanie. W moim przypadku silnik zaczął się kręcić dopiero od wartości 60 (wypełnienie 23,5%).

Serwomechanizmy są elementami zależnymi od czasu trwania impulsu PWM. Szerokość impulsu decyduje o tym jak będzie ustawiony kąt osi serwomechanizmu. Moje serwomechanizmy (HTX900) przyjmują szerokości impulsów od 580 (0 stopni) do 2800 (180 stopni) mikrosekund. Do ich obsługi stosuje się raczej bibliotekę “Servo.h”, która dobrze spełnia swoje zadanie.

Wyjście PWM może sterować też głośnikiem lecz wymaga generatora PWM o częstotliwości pracy w zakresie ultradzwięków (powyżej 20000 Hz). Częstotliwości niższe są słyszalne dla ucha człowieka i powodują, że zamiast sygnału jaki chciałeś wygenerować, słyszysz pisk sygnału PWM. W tym artykule nie napiszę o sposobach generowania takiego sygnału, ale pojawiło się już wiele takich projektów w społeczności Arduino i można je wyszukać.

Sterowanie głośnikiem przez PWM pozwala na wytwarzanie przez głośnik fal o dowolnych kształtach i głośności, a nawet odtwarzanie sampli. Eksperymentatorzy będą mieli zapewne wiele zabawy.

Zakończenie

Mam nadzieję, że tym wpisem rozwiałem twoje wątpliwości dotyczące tego jak działają i do czego służą wyjścia PWM. Jeśli masz jeszcze jakieś pytania dotyczące PWM, możesz zamieścić je w komentarzach pod artykułem.

W nastepnym wpisie przedstawię jak można uzyskać 16 kanałów PWM o rozdzielczości 12 bitów (4096 poziomów wypełnienia).

Linki

• Opis funkcji “analogWrite” [EN]
• Opis działania PWM na Wikipedii [Paskudne akademickie teoretyzowanie ;-)]
• Opis biblioteki “Servo.h” [EN]

Jeśli spojrzycie na kod tamtego sygnalizatora, możecie dostrzec następującą pętlę loop:

void loop()
{
  val = digitalRead(buttonPin);
  if (val == HIGH && prev == LOW) {
    next_status();
  }
  prev = val;
  display_status();
  delay(50);

}

Wykrywanie naciśnięcia odbywa się przez porównanie bieżącej wartości wejścia cyfrowego z poprzednią. Jeżeli aktualna wartość to HIGH a poprzednia to LOW, to wykonujemy akcję next_status(), która zmienia stan sygnalizatora. I wszystko działa. Ale nie ma problemów, tylko dzięki ostatniej linii kodu w loop: delay(50);.

Przycisk jest urządzeniem mechanicznym i włączenie lub wyłączenie nie jest jednoznaczne, jeżeli będziemy stan przycisku badać dostatecznie często. W momencie dociskania/zwalniania przycisku jest taki moment, w którym styk już łapie/puszcza przez co włączenie wyłączenie nie jest czystym przełączeniem między LOW a HIGH tylko migotaniem. Angielska Wikipedia przy haśle contact bounce (bo tak się zjawisko to nazywa) ma ten piękny obrazek ilustrujący ten problem:

Ilustracja migotania przełącznika (CC Wikipedia)

Opóźnienie w loop załatwia nam ten problem, bowiem jeżeli zauważymy zmianę stanu klawisza odczekanie 50 ms przed następnym odczytem zapewnia margines wykluczający błędny odczyt. Gdyby nie ono, wówczas w następnym przebiegach moglibyśmy odczytać migotanie jako kolejne przyciśnięcia. Rezultat? Z punktu widzenia użytkownika – on nacisnął przycisk jeden raz, a sygnalizator przeskoczył o 1 lub więcej stanów za jednym razem.

Rozwiązanie z użyciem delay nie zawsze jest dopuszczalne, bo może nasze Arduino musi robić coś więcej niż tylko czekać na naciśnięcie klawisza.

Jak się zabezpieczyć przed złymi odczytami?

Najlepszą metodą jest zapamiętanie czasu w którym odczytaliśmy zmianę stanu klawisza i przez następne kilkanaście, kilkadziesiąt milisekund nie reagować na zmiany stanu wejścia. Ale wówczas kod znacznie się komplikuje, a taki jest znacznie bardziej podatny na błędy. Na szczęście jest gotowe rozwiązanie w postaci biblioteki Bounce.

Instalujemy bibliotekę w sketchbook/libraries i teraz możemy korzystać z dobrodziejstw klasy Bounce. Zamiast odczytywać wartość przez digitalRead i samemu starać się rozszyfrować co znaczy odczyt w zależności od poprzedniej wartości i czasu który upłynął od ostatniej zmiany, definiujemy obiekt w naszym szkicu:

int buttonPin = 4;
Bounce button(buttonPin,20);

Od teraz cyfrowe wejście nr 4 będzie obsługiwane przez Bounce, z 20-sto milisekundowym marginesem. W czasie 20 milisekund od wykrycia zmiany stanu wejścia jego następne zmiany będą ignorowane. Dopiero po upływie tego czasu obiekt może zmienić swój stan.

Pierwszym krokiem jest uaktualnienie stanu przycisku przez funkcję update(). To właśnie w tym momencie jest odczytywana wartość na wejściu:

  button.update();

update zwraca wartość true lub false – w zależności czy stan przycisku uległ zmianie czy jest taki jak poprzednio.

Po tej operacji możemy sprawdzić czy przycisk jest wciśnięty lub nie (read()) albo jeżeli interesuje nas tylko czy został właśnie wciśnięty lub zwolniony informacji dostarczy nam risingEdge() lub fallingEdge(). W wypadku sygnalizatora nas interesuje kiedy został wciśnięty klawisz:

  if (button.risingEdge()) {
    next_status();
  };

next_status zostanie wywołany tylko kiedy zostanie wykryta zmiana ze stanu LOW na HIGH. W następnym przebiegu, jeżeli przycisk jest nadal wciśnięty, risingEdge() już zwróci false.

Biblioteka ma sobie jeszcze kilka przydatnych funkcji, pozwalających określić jak długo już przycisk jest w aktualnym stanie, albo przydatnych do generowania wirtualnych ‘przyciśnięć’ (to drugie świetnie się sprawdza do powtarzania akcji gdy przycisk jest ciągle wciśnięty).

To jeszcze nie koniec o sygnalizatorze, bo on nadal istnieje. Oczywiście kartonowy v1 został zastąpiony przez v2 ze spienionego PCW, które jest świetnym materiałem do budowy prostych konstrukcji. Sygnalizator dorobił się dodatku w postaci zapory napędzanej przez serwomechanizm, co widać też w kodzie.

O tym jak korzystać z serwomechanizmów na przykładzie zapory i tego szkicu postaram się napisać już niedługo.

Cały kod sygnalizatora v2.

Teoria związana z przepływem prądów w układach RLC (R – rezystory, L – cewki, C – kondensatory) jest cała najeżona wzorami, których nie chcecie widzieć :) (a jeżeli ktoś musi się przekonać to np zobaczcie to i wrócicie zaraz tutaj :) ).

Teraz podam kilka uproszczeń, które wystarczą do zmierzenia się z użyciem rezystorów w kontekście Arduino.

Ważną cechą układów elektronicznych jest to, że jeżeli mamy jakieś napięcie w układzie (coś je wytwarza), to jeżeli obwód jest zamknięty (nie ma żadnej przerwy), napięcie to się odłoży na wszystkich elementach w taki sposób, że sumując napięcia na każdym elemencie z osobna otrzymamy napięcie z naszego źródła. Jest to zgodne z intuicyjnym rozumieniem – napięcie nie bierze się znikąd i nie może nigdzie znikać.

Druga ważna informacja, to prawo Ohma – mówiące że napięcie (U) na danym elemencie jest proporcjonalne do prądu (I) przez niego płynącego, a jaka jest to konkretnie wartość mówi nam właśnie rezystancja (R):

Prawo Ohma

Oczywiście dotyczy to elementów o charakterze rezystancyjnym – właśnie rezystorów, sprawa np z diodą jest inna.

Może podłączmy sobie dwa rezystory do baterii:

Prosty układ z dwoma rezystorami

Zgodnie z tym co właśnie napisaliśmy napięcia U₁ i U₂ zsumowane dadzą napięcie równe napięciu baterii. Jeżeli bateria daje 5V to napięcia U₁ i U₂ po dodaniu wyniosą 5V.

Ważne – jest to połączenie szeregowe, czyli mówiąc po ludzku – rezystory są łączone po kolei. W takim wypadku rezystancja całego układu dwóch rezystorów jest sumą ich rezystancji.

W teorii układów RLC jest kilka twierdzeń, które w wielkim uproszczeniu można zastąpić zdaniem, że z punktu widzenia baterii jest obojętne czy podłączymy jeden rezystor 10k czy 2 rezystory 5k połączone szeregowo – prąd płynący w takim układzie będzie taki sam.

Inaczej – dowolny układ rezystorów możemy zastąpić jednym o rezystancji będącej wypadkową rezystancji składowych przeliczonych w zależności od tego jak połączone są te rezystory (jak dotąd była mowa o połączeniu szeregowym, może być jeszcze równoległe i wszelkie kombinacje tych dwóch)

Kolejną intuicyjnie rozumianą rzeczą jest, że prąd płynący przez elementy w połączeniu szeregowym jest taki sam w każdym elemencie.

Przypomnijmy sobie prawo Ohma – jeżeli przyłożymy napięcie z baterii wówczas przez oba rezystory popłynie jednakowy prąd równy napięcie baterii/sumaryczna rezystancja. Skoro prąd jest taki sam w obu rezystorach to napięcie na każdym z nich będzie wynosić rezystancja tego jednego rezystora * prąd.

Na przykład weźmy układ dwóch rezystorów połączonych szeregowo o sumarycznej rezystancji 10 Ohm. Podłączmy je do baterii 20V – prąd płynący przez rezystory (wyliczony z prawa Ohma) to 2A – bo 20V/10Ohm = 2A. Teraz jeżeli są to dwa rezystory po 5 Ohm (suma rezystancji wynosi 10 Ohm), prąd nadal jest 2A. Napięcie na każdym z rezystorów to 5 Ohm * 2 A = 10V. W sumie – 20V, czyli wszystko się zgadza.

Jeżeli jednak weźmiemy rezystor o różnych wartościach – na przykład 1 Ohm i 9 Ohm (suma nadal 10 Ohm) to mamy na pierwszym 1 Ohm * 2A = 2V a na drugim – 9 Ohm * 2A = 18V. Suma napięć – nadal 20V, czyli tyle ile daje nasza bateria. Ale w tym wypadku rozkład napięć U₁ U₂ jest zupełnie inny. Powiedzmy że na naszym schemacie górny rezystor to 1 Ohm a dolny to 9 Ohm. Napięcie na górnym rezystorze to 2V, na dolnym 18V.

Mierząc napięcie między minusem baterii (tutaj jest to tak zwana masa) a punktem pomiędzy rezystorami otrzymamy 18V – 90% wartości napięcia baterii. 9 Ohm stanowi 90% sumarycznej rezystancji układu. Zmieniając proporcje rezystancji, w tym punkcie otrzymamy odpowiednio zmienione napięcie. Gdy dolny rezystor będzie stanowił 30% sumarycznej rezystancji obu rezystorów, napięcie w punkcie pomiędzy rezystorami będzie wynosiło 30% napięcia baterii. Widzicie zależność? Właśnie poznaliście zasadę działania dzielnika napięcia, bo tak taki układ rezystorów się nazywa.

W rzeczywistym zastosowaniu trzeba pamiętać o jednym – nie możemy pobierać (dużo) prądu z punktu pomiaru pomiędzy rezystorami. Bo powyższe rozumowanie zakładało, że przez oba rezystory płynie równy prąd, prawda? Czyli nadaje się to uzyskania jakiegoś napięcia odniesienia, ale nie bardzo aby uzyskać napięcie zasilające.

Do czego jeszcze może się nam przydać rezystor?

Kolejnym podstawowym zastosowaniem oporników (jak też są nazywane rezystory) jest ograniczanie (czy raczej wymuszanie) wartości prądu w gałęzi układu. Jeżeli wiemy jakie napięcie zostanie odłożone na oporniku to dobierając odpowiednią wartość rezystancji możemy określić jaki prąd będzie płynął w gałęzi. Jeżeli wiemy, że na rezystorze będzie napięcie 1.7V to jeżeli użyjemy rezystora 220 Ohm, prąd płynący w gałęzi będzie wynosił 1.7/220 = 7.73 mA. Wartość tę wyliczyliśmy dzięki przekształceniu prawa Ohma – zależność prądu od napięcia i rezystancji:

Inny zapis prawa Ohma

Ma to zastosowanie np przy podłączaniu diod LED, ale bardziej szczegółowo o tym wkrótce.

Gdy pojawiło się Arduino UNO, przez chwilę pojawiła się chęć przetestowania klawiaturowego firmware dla ATmega8u2 w ramach tego właśnie hacku, ale projekt nie wystartował. Co UNO zmieniało? Otóż z nowym firmware, podłączone do komputera widziane jest jako klawiatura więc odpada cała komplikacja z odczytem seriala i wysyłania komunikatów do gry. Po prostu Arduino może ‘wciskać klawisze’ przez port USB i całość wydaje się znacznie prostsza.

Ale gdy tylko zobaczyłem Gameduino wiedziałem że to jest to czego potrzebowałem. Ostatnie dni deszczowe były, tak więc – do dzieła!

Najpierw – jedno z dem dołączonych do biblioteki to Asteroids – lecisz statkiem przez pole asteroidów i strzelasz do nich. Proste. Rozpakować bibliotekę do sketchbook/libraries, uruchomić Arduino IDE, menu File/Examples/Gameduino/Demos/asteroids. Kompilacja, upload i mamy. Tyle, że nie mamy żadnego kontrolera do sterowania statkiem. Ja do pierwszych testów użyłem Nettigo Keypada, bo go pod ręką miałem.

Wystarczy zmienić kod w controller_sense i zamiast domyślnego kodu przeznaczonego dla game controllera od SparkFun użyć swojego. Ale to mało pasjonujące naciskać na klawisze, byle konsola to ma :)

Czas na Level 2

Podłączyć czujnik przyspieszenia i zrobić jakąś platformę, na której stojąc będzie się sterować statkiem. Przechył w lewo – obrót w lewo. Przechył w prawo – obrót w prawo. Przechył do przodu – lecimy. W tył – strzelamy. Taki Segway. No może bez tego strzelania :)

Pierwsza rzecz jak zrobić samą platformę? Miałem pod ręką kawałek panela podłogowego. Do niego przyklejona płytka stykowa 170 (dzięki swojej taśmie samoprzylepnej). Na niej czujnik przyspieszenia, kabelki zgodnie z opisem w dokumentacji czujnika i możemy ustalić położenie panela. Interesują nas dwie osie – X i Y, Z na razie nam niepotrzebne :)

Czujnik przyspieszenia na płytce stykowej

Pozostaje teraz rozwiązać konstrukcję modułu wychylnego. Musi to być coś co pozwoli naszemu panelowi kiwać się na wszystkie strony, jednocześnie nie za bardzo, tak aby gracz nie spadał z niego. Po wielu testach różnych materiałów i różnych rozwiązań mocowań konsultowanych z NASA nasze finalne rozwiązanie wygląda tak:

Źródło: NASA (just joking)

Jak widać wybór padł na starą poduszkę :) Panel położony na niej ma dość swobody aby poruszać się w dwóch osiach na tyle aby czujnik mógł odczytać położenie.

Hard za nami, teraz soft

Teraz trochę kodu, czyli w zasadzie jedyna zmiana w kodzie dema, to nowa funkcja controller_sense:

#define LR_NEUTRAL 330
#define UD_NEUTRAL 345

#define LR_DELTA 8
#define UD_DELTA 7
static byte controller_sense(uint16_t clock)
{
int rd,a1,a2;

rd = 0;
a1 = analogRead(3);
a2 = analogRead(4);

  if (a1 < LR_NEUTRAL - LR_DELTA){
//    Serial.println("Lewo");
    rd = rd | CONTROL_LEFT;
  }  
  else if (a1 > LR_NEUTRAL + LR_DELTA)
  {
    rd = rd | CONTROL_RIGHT;
//    Serial.println("Prawo");
  }
  if (a2 < UD_NEUTRAL - UD_DELTA){
    rd = rd | CONTROL_DOWN;
//    Serial.println("Jazda");
  }  
  else if (a2 > UD_NEUTRAL + UD_DELTA)
  {
    rd = rd | CONTROL_UP;
//    Serial.println("Ognia");
  }
  return rd;

Teraz kilka słów wyjaśnienia. LR_NEUTRAL to wartość jaka jest odczytywana w osi X w pozycji neutralnej. LR jest od Left Right, bo przechył w osi X w naszym ułożeniu czujnika oznacza przechył w lewo/prawo. LR_DELTA to jest margines o jaki może się w każdą stronę zmienić odczyt od pozycji neutralnej zanim zostanie uznany za wciśnięcie lewo lub prawo.

Podobnie jest z UD (od up i down). Oznaczenia te pochodzą od oznaczeń używanych w kodzie dema, nie od kierunku ruchu panela :)

rd jest na początku ustawiane na zero i jeżeli wychył od pozycji neutralnej jest dostatecznie duży odpowiednia wartość CONTROL_ jest ORowana. O co chodzi? Jeśli spojrzeć na definicję wartości CONTROL_ :

#define CONTROL_LEFT  1
#define CONTROL_RIGHT 2
#define CONTROL_UP    4
#define CONTROL_DOWN  8

są to kolejne potęgi 2. W zapisie binarnym odpowiada to kolejnym bitom. 1 to 0001, 2 to 0010, 4 to 0100, itd. Logiczne OR dwóch liczb (w C to symbol tzw pałki | ) zwraca wartość gdzie bity są ustawione na 1 wszędzie tam gdzie choć w jednej z liczb była jedynka. Na przykład:

• 0000 OR 0001 = 0001
• 0000 OR 0010 = 0010
• 0100 OR 0010 = 0110
• 0100 OR 0100 = 0100

W ten sposób wiedząc że 1 na ostatnim bicie to CONTROL_LEFT a 1 na pierwszym to CONTROL_DOWN, można w jednej liczbie całkowitej przekazać informację, że wciśnięte zostały dwa klawisze jednocześnie: 1001 czyli 9 dziesiętnie. Bardzo często stosowana metoda przekazywania stanu różnych rzeczy przez jedną liczbę całkowitą.

A jak potem łatwo można odczytać czy bit jest ustawiony? Ano z wykorzystaniem AND (znak &):

• 1001 AND 1000 = 1000
• 1001 AND 0100 = 0000
• 1001 AND 0010 = 0000
• 1001 AND 0001 = 0001

Teraz już chyba jest jasne w jaki sposób przez rd jest zwracana informacja o równocześnie naciśniętych przyciskach.

Co do naszego czujnika – wartości _NEUTRAL oraz _DELTA zostały dobrane eksperymentalnie – obserwując odczyty z czujnika, które na ten czas wysyłane były na Serial. Po ich ustaleniu komendy Serial.print zostały usunięte, bo zajmują cenne takty procesora ;)

Jak to wychodzi w praktyce można zobaczyć na tym krótkim filmiku (nie wiem jak go odwrócić, aparat było mi wygodniej trzymać w pionie):

Ze względu na dynamikę całości :) niezbędne jest osłonięcie czujnika aby zabezpieczyć przed przypadkowym zgnieceniem:

W obudowie

Raport Millera – czyli co można poprawić

Położenie neutralne zmienia się nieco (tzn odczyt z czujnika), w zależności od zasilania Arduino (np mój notebook zamiast 5V na USB ma 4.9, co przy niewielkich zmianach napięcia na wyjściu czujnika może mieć znaczenie – punkt odniesienia się zmienia to i odczyt zwracany przez analogRead się zmienia). Również z czasem czujnik może minimalnie zmienić odczyt. Wówczas zostaje ręczna zmiana wartości w kodzie, kompilacja i wgranie do Arduino.

Lepszym rozwiązaniem byłaby kalibracja – otóż specjalny tryb, zamiast grania wyświetli polecenie: Wychyl się w lewo. Potem odczytuje wartość z czujnika. Następnie Wychyl się w prawo i znowu. W ten sposób szkic jest sam w stanie wyznaczyć sobie wartości _NEUTRAL i _DELTA.

Druga uwaga – dynamika gry jest duża i chyba taki kontroler byłby lepszy dla jakiejś sportowej niż strzelanki. Ale to już lepiej byłoby jednak użyć klawiaturowego firmware i komputera, może innym razem…