Snap4Arduino – następca S4A

Opisując wczoraj Scratch dla Arduino – S4A czułem, że projekt mimo, że funkcjonalny to jest nieco opuszczony. Dziwiło mnie, że nikt nie zrobił poprawek do starego firmware dla Arduino do komunikacji z programem. To nie jest trudne.

Przeglądałem blog projektu i okazało się, że autorzy pracują nad czymś nowszym. Nowy projekt nosi nazwę Snap4Arduino. Środowisko jest bardzo podobne do Scratch, tak więc nikt nie będzie czuł się zagubiony.

Snap4Aruino na razie jest w wersji Alpha i u mnie był dość niestabilny. U ciebie może będzie lepiej, bo ja mam również system operacyjny w wersji testowej co pewnie pogłębiło niestabilność #życieNaKrawędzi ;-).

Program można pobrać ze strony projektu:

Działa z systemami operacyjnymi Windows, Linux i OS X.

By móc połączyć się z płytką kontrolera wymagane jest wczytanie do niej protokołu Firmata. To standardowy protokół obsługujący chyba wszystkie płytki Arduino i zgodne z nimi czyli np. Teensy.

Żeby go wczytać, wybierz w Arduino IDE menu: Plik > Przykłady > Firmata > StandardFirmata i wgraj do swojej płytki.

Snap4Arduino dzięki Firmata pozwala na dowolne wykorzystanie pinów kontrolera i  ich obsługa jest 7x szybsza niż w poprzednim projekcie.
Dodatkową zaletą jest to, że projekt został napisany w NodeJS, co pozwala na łatwe dodawanie klocków i rozwijanie programu.

sprae

Fritzing 0.9.0

Fritzing to program do robienia schematów dla twórców DIY “Zrób to sam”. Potrafi tworzyć estetyczne schematy koncepcyjne w sam raz do wklejenia na bloga, schematy ideowe oraz projekty płytek drukowanych.

Niedawno pojawiła się nowa wersja oznaczona numerem 0.9.0. Nowością pod maską jest użycie bibliotek graficznych Qt 5, dzięki czemu operacje graficzne programu powinny znacznie przyspieszyć.

Miłą niespodzianką są dodatkowe części w katalogu podzespołów. Wśród nich są popularne ostatnio płytki kontrolerów:

  • Arduino YUN
  • Raspberry PI A, B, B 2.0 (nie ma jeszcze B+ [czyżby zaskoczenie?])
  • Intel Galileo
  • Teensy 3.0 i 3.1

Program można pobrać ze strony fritzing.org. Działa on na platformach Linux 32/64 bit, Apple OS X i Windows.

sprae

Teensy 3.1 jak trzymać dane w pamięci Flash.

Teensy mimo swoich rozmiarów ma dużo pamięci jak na kontroler.
Pamięci RAM jest 64 KB. Trafiają do niej wszystkie zmienne programu i bibliotek.

Zmienna typu byte:

byte zmienna = 1;

Zajmuje 1 bajt. Takich zmiennych zmieści się w Teensy ponad 64 tysiące.

Zmienna typu int:

int zmienna = 1000;

Zajmuje 4 bajty, więc takich zmieścisz 16 tysięcy.

Wielokrotnością zmiennej są tablice, które pozwalają trzymać wiele danych pod jedną nazwą.

int tablica[4] = {2, 4, 6, 8};

Pod nazwą “tablica” znajdują się 4 liczby. Ponieważ tablica jest typu int, liczby zajmują w niej 4 (rozmiar int) * 4 (elementy tablicy) = 16 bajtów.

Pamięci Flash jest 256 KB. Czyli 4 razy więcej niż RAM. Znajduje się w niej głównie kod programu. Ta pamięć z punktu widzenia programu jest tylko do odczytu. Zapisuje się ja podczas wrzucania programu z komputera na Teensy.

W każdym programie są pewne zmienne, których dane nie będą zmieniane przez program. Są to np zmienne z numerami pinów, z napisami, obrazki lub wygląd czcionek dla wyświetlacza graficznego.

int ledPin = 13;char napis[] = “Ala ma kota”;
byte font[8] = {0x00, 0x01, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff};

Można łatwo sprawić, by te zmienne nie zajmowały pamięci RAM i znajdowały się tylko we Flash. Trzeba zrobić z nich stałe (tylko do odczytu). Robi się to bardzo prosto za pomocą etykiety “const”.

const int ledPin = 13;
const char napis[] = “Ala ma kota”;
const byte font[8] = {0x00, 0x01, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff};

Tym prostym ruchem stałe, które program będzie odczytywał, będą trzymane w pamięci programu Flash i można ich używać jak dawnej.

Czemu się tym tak ekscytuje? Ponieważ w Arduino było mało pamięci RAM (2 kB). Żeby deklarować w jego programie stałe z pamięci Flash, trzeba było używać specjalnej etykiety PROGMEM. Aby odczytać stałe z takiej pamięci trzeba było używać specjalnych funkcji pgm_read_byte, pgm_read_world. W Teensy i na kontrolerach ARM jest prościej :-).

Dla kompatybilności Teensy 3.1 też potrafi obsługiwać bibliotekę “avr/pgmspace.h”. Więc nie trzeba przerabiać bibliotek dla Arduino korzystających z tego.

sprae

Teensy 3.1 – dzień III – wydajność

Dziś wielkie starcie. W prawym narożniku Arduino Leonardo. Zawodnik o wadze 16 MHz. W lewym Teensy 3.1. Jego zegar to 96 MHz.

Sprawdźmy ile razy bardziej wydajne jest Teensy 3.1 w porównaniu do jednej z najbardziej popularnych płytek Arduino Leonardo.

Dzielenie liczb liczb jest jedną z najbardziej czasochłonnych operacji dla procesora. Procesor ARM Cortex M4 w Teensy 3.1 ma specjalny rozkaz, dzięki któremu dzieli liczby sprzętowo.
Procesor AVR w Arduino Leonardo nie ma dzielenia sprzętowego i musi zastępować je kilkoma innymi operacjami.

To program który porówna wydajności w dzieleniu:

unsigned long sum;

void setup()
{
  while (!Serial);
  Serial.begin(9600);
}

void loop()
{
  Serial.println(F("Start"));
  unsigned long timeBegin = millis();
  for (int a=0; a<10000; a++)
  {
    for (int b=1; b<100; b++)
    {
      sum += a / b;
    }
  }
  
  unsigned long processTime = millis() - timeBegin;
  Serial.println(F("End"));
  Serial.print(F("Czas obliczen: "));
  Serial.println(processTime);
}

Program dzieli przez siebie milion liczb i mierzy czas tej operacji.

  • Arduino Leonardo zajęło to 14,978 s
  • Teensy 3.1 zajęło to 0,127 s

Czyli w dzieleniu Teensy okazało się 118 razy szybsze.

Kolejny test jest dość zabawny. Polega na uruchomieniu na obydwu płytkach tego samego emulatora procesora 6502. Na emulatorze uruchomiłem język EhBASIC. Cały kod pochodzi z wątku na forum Arduino, o którym niedawno pisałem.

Uznałem, że emulator to dobre środowisko by przetestować różnorodne operacje. W końcu to taki duży skomplikowany program, który robi dużo obliczeń, dużo komunikuje się z pamięcią Flash i RAM. Będzie dobrze odzwierciedlał ogólną wydajność procesora.

W języku BASIC napisałem prosty program zliczający od 0 do 10000.

Czas jego działania dla każdej płytki to:

  • Arduino Leonardo: 57,22 s
  • Teensy 3.1: 9,8 s

W tym teście Teensy nie ma już takiej ogromnej przewagi. Ale nadal jest prawie 6 razy szybsze.

Na koniec zostawiłem najmocniejszy test. Wziąłem algorytmy do obliczeń GPS ze starego projektu licznika rowerowego. Jest w nich dużo liczb zmiennoprzecinkowych (float) i masa różnych funkcji trygonometrycznych typu sin, cos, tan, atan2.

W oparciu o to, napisałem program, który oblicza trasę 36km z Płocka na zachód. Co 0.0001 stopień szerokości geograficznej.

float lat = 52.512204;
float lon = 19.675606;
float lonTo = 19.143456;

float oldLat = lat;
float oldLon = lon;

float angle;
float distance;

float getDistance(float latf, float lonf, float latt, float lont)
{
  float distance = acos(cos(latf)*cos(lonf)*cos(latt)*cos(lont)+cos(latf)*sin(lonf)*cos(latt)*sin(lont)+sin(latf)*sin(latt)) * 6378.137;
  return distance;
}

float lonTox(float lon)
{
  float x = (lon + PI) / (2 * PI) * 2.0;
  return x;
}

float latToy(float lat)
{
  float y = (1.0 - log(tan(lat) + (1 / cos(lat))) / PI);
  return y;
}

float getAngle(float latf, float lonf, float latt, float lont)
{
  float xf = lonTox(lonf);
  float yf = latToy(latf);
  float xt = lonTox(lont);
  float yt = latToy(latt);
  
  float x = xt - xf;
  float y = yt - yf;
  float angle = atan2(y, x);
  return angle;
}

void setup()
{
  while (!Serial);
  Serial.begin(9600);
}

void loop()
{
  Serial.println(F("Start"));
  unsigned long timeBegin = millis();
  for (float a=lon; a>lonTo; a-=0.0001)
  {
    distance += getDistance(oldLat, oldLon, lat, a);
    angle = getAngle(oldLat, oldLon, lat, a);
    oldLat = lat;
    oldLon = a;
  }
  
  unsigned long processTime = millis() - timeBegin;
  Serial.println(F("End"));
  Serial.print(F("Czas obliczen: "));
  Serial.println(processTime);
  
  Serial.print(F("Odleglosc: "));
  Serial.println(distance);
  Serial.print(F("Kat: "));
  Serial.println(angle);
  distance = 0.0;
  angle = 0.0;
}

Program pokazuje jak dobrze sprawdza się Teensy w autopilotach i innych podobnych systemach związanych z nawigacją, położeniem i obliczeniami z przecinkiem.

  • Arduino Leonardo policzyło trasę w 10,242 s
  • Teensy 3.1 policzyło trasę w 4,215 s

W takich obliczeniach Teensy okazało się 2,6 raza wydajniejsze od Arduino Leonardo.

BTW. Jeśli interesujecie się nawigacją to w tym teście macie gotowe funkcje do obsługi GPS.

Funkcja “getDistance” oblicza odległość między dwoma punktami geograficznymi. Argumenty to długość i szerokość geograficzna punktu początkowego i długość i szerokość geograficzna punktu końcowego. Argumenty podajemy w radianach, a nie stopniach – co mi się zapomniało ;-).

Funkcja “getAngle” oblicza kąt pod jakim jest punkt geograficzny od nas względem zachodu. Jej argumenty są takie same jak “getDistance”.

Funkcje “latToy” i “lonTox” zamieniają długość i szerokość geograficzną na współrzędne punktu  x, y na płaskiej mapie.

Teensy 3.1 siłą rzeczy jest wydajniejsze od Arduino Leonardo. Dzięki testom dowiedziałeś się jak bardzo i w jakich operacjach radzi sobie najlepiej.

Pozytywnie zaskoczyło mnie dziś to, że programy pod Teensy obsługują pamięć Flash tak jak w Arduino. Można używać F() do tekstów. Autor Teensy przeniósł nawet bibliotekę “/avr/pgmspace.h”, żeby biblioteki Arduino obsługujące Flash działały na Teensy bez modyfikacji.

sprae

Teensy 3.1 – dzień II – uruchomienie i programowanie

Dziś o tym jaka jest filozofia programowania Teensy.

Do programowania Teensy potrzebujesz przewodu Micro USB

image

Po podłączeniu Teensy pierwszy raz do komputera, uaktywnia się domyślny program. Mruga wbudowaną diodą świecącą. Dzięki temu wiesz, że twoje Teensy działa.

image

By programować Teensy potrzebujesz Arduino IDE 1.0.5 i Teensyduino.
Teensyduino to program modyfikujący Arduino IDE, żeby współpracowało z Teensy.

Ściągasz je ze stron:

Najpierw instalujesz Arduino IDE w komputerze, a potem Teensyduino.

Do instalacji Teensyduino potrzebne są prawa Administratora. Dlatego na pliku instalatora musisz kliknąć prawym klawiszem myszy i wybrać w menu opcję “Uruchom jako Administrator”.

Na początku program instalatora wygląda tak:

image

Klikasz przycisk Next i instalator informuje, że nie ma zainstalowanych sterowników do obsługi komunikacji Serial. Dzięki nim możesz podglądać w Monitorze portu szeregowego to co program wysyła przez “Serial.print();”.

image

Kliknięcie w przycisk Next zainstaluje sterownik.
Kliknięcie na “Skip Driver Install” pominie instalację sterowników. Ponieważ są one potrzebne, naciśnij Next.

W następnym oknie wybierasz miejsce na dysku, gdzie zainstalowałeś Arduino IDE.

image

U mnie jest to D:programyArduino-1.0.5-r2

image

Naciskasz Next. W następnym oknie wybierasz biblioteki. Każda z nich odpowiada za obsługę jakiegoś urządzenia przez Teensy.

image

Ja wybrałem wszystkie, klikając w All.

Po kliknięciu w Next, instalator pyta się czy rozpocząć instalację plików.

image

Jeśli się na to zdecydowałeś, naciśnij Install

image

Po zainstalowaniu Teenstyduino pojawia się prosty samouczek.

image

Informuje on, by po pierwszym uruchomieniu przerobionego Arduino IDE z jakimś szkicem, nacisnąć przycisk Weryfikacji programu, a potem przycisk na płytce Teensy.

Jeśli instalacja przebiegła prawidłowo, to po uruchomieniu Arduino IDE w menu Narzędzia -> Board będziesz miał do wyboru płytki z rodziny Teensy.

image

Tu trzeba wybrać posiadany model, czyli Teensy 3.1.

W menu Narzędzia -> USB Type wybierasz jaką rolę będzie pełniło Teensy w twoim programie.

image

Serial – Teensy w takim przypadku emuluje port szeregowy COM: przez USB. Pozwala to na używanie obiektu Serial w programie i zwracanie różnych komunikatów przez Monitor portu szeregowego.

Keyboard + Mouse + Joystick – sprawia, że Teensy będzie udawało klawiaturę, mysz i joystick. Po użyciu odpowiedniej biblioteki możesz programem z płytki Teensy wysyłać skróty klawiaturowe, ruchy myszy i kliknięcia oraz emulować joystick. Czyli zrobić własny kontroler do gry lub programów.

Serial + Keyboard + Mouse + Joystick – to tryb w którym Teensy oprócz klawiatury, myszy i joysticka dodatkowo emuluje port szeregowy COM:. Można dzięki temu oprócz sterowania grą przez standardowe peryferia, komunikować się z płytką wysyłając do Teensy jakieś informacje.
Jest to przydatne, gdy robisz panel do gry i oprócz przycisków sterujących, chcesz mieć wyświetlacze prezentujące informacje z gry.
Jak w opisanych niedawno projektach paneli do KSP.
Taka konfiguracja może się też przydać cziterom farmiącym golda w Diablo 😉

MIDI – to tryb w którym Teensy udaje urządzenie muzyczne MIDI. Pozwala to sterować programami do tworzenia muzyki i udawać instrument.

Raw HID – to tryb w którym mamy dostęp do struktur interfejsu HID. Tryb ten pozwala na komunikację z aplikacjami Metro w Windows 8 i Windows Phone 8. Ponieważ w ich API zrezygnowano z interfejsu Serial.

Flight Sim Controls – ten tryb pozwala na komunikację z symulatorem lotu X-Plane. Dzięki niemu możesz z Teensy zrobić element kokpitu samolotu, którego przyciski będą reagowały na instrumenty pokładowe w symulatorze lotu.

W menu Narzędzia -> CPU Speed masz do wyboru częstotliwość z jaką będzie działał procesor.

image

Zakres zegara procesora można ustawić od 2 do 96 MHz w zależności od potrzeb. Im mniejsza częstotliwość, tym kontroler mniej zużywa prądu.
Częstotliwości poniżej 24 MHz nie obsługują komunikacji USB.
Częstotliwość 96 MHz to przetaktowanie procesora. Można jej użyć, gdy program zbyt wolno coś oblicza.

W menu Narzędzia->Keyboard Layout ustawiasz język klawiatury, którą emuluje Teensy. Ma to związek z przypisaniem liter do kodów klawiszy.

image

Dla naszego regionu najlepszym będzie standardowy US English albo US International.

Programy na Teensy pisze się tak samo jak na Arduino. Tu też zaczyna się od 2 funkcji “setup” i “loop”. Funkcja setup uruchamia się tylko raz na początku działania programu. Funkcja loop uruchamia się ciągle od nowa.

Na początek wpisałem pusty program. Chciałem zobaczyć ile taki zajmuje.
W ostatnim oknie instalatora Teensyduino, samouczek napisał by przy pierwszym programie wcisnąć przycisk “Weryfikuj”.

Po jego wciśnięciu pojawia się okno programowania Teesny. Pisze nam, żeby wcisnąć przycisk na płytce by zacząć programowanie.

Po jego wciśnięciu program załadował się w ułamku sekundy, a LED na płytce przestał mrugać. Stało się tak dlatego, bo nowy program niczego nie robi.

Pusty program zajmuje około 13 kB. Wielkość dlatego jest tak duża, bo doliczony jest do niej rozmiar programu rozruchowego. Zajmuje się on programowaniem płytki, ustawieniem USB i wszystkich interfejsów kontrolera.

Ten tajemniczy przycisk do programowania to nie jest Reset. Teensy działa tak, że po podłączeniu zasilania od razu włącza się program użytkownika. Przycisk wyłącza program użytkownika i przełącza płytkę w tryb programowania.

Ma to pewną praktyczną zaletę. Jeśli twój program źle działa i zablokuje port USB albo kontroler, to wciskasz przycisk i wszystko się odblokowuje, a ty możesz wgrać działający program.

W Arduino nie ma takiego trybu i zdarza się, że Arduino Leonardo może się zablokować w wyniku złego programu na tyle, że programator go nie pozna ;-).
W Teensy 3.1 nie ma tego problemu.

Dla porównania napisałem standardowy program mrugający wbudowaną diodą co 100 ms.

Ilość zajmowanej pamięci Flash zwiększyła się o 40 bajtów. Można przyjąć, że ten kawałek kodu właśnie tyle zajmuje.

Rzeczy które pozytywnie mnie zaskoczyły to szybkość programowania przez USB. Dzieje się to tak szybko, że nie zdążyłem odwrócić wzroku. Druga to przycisk do programowania, który chroni przed skutkami działania złego programu.

sprae

Teensy 3.1 – dzień I – Opis płytki

Witam w nowym serialu. W tym sezonie omówię ci płytkę Teensy 3.1.
Ogólnie rzecz ujmując jest to płytka o możliwościach Arduino DUE, za cenę mniejszą niż Arduino UNO.

Płytka jest bardzo małych rozmiarów (3.56 cm x 1.78 cm). Jest 2 razy krótsza niż mój palec wskazujący. Mimo małych rozmiarów rozstaw pinów jest standardowy i wynosi 2,54 mm. To taki sam rozstaw jak w płytce stykowej, popularnych układach scalonych typu DIP, albo jak piny w Arduino.

Sercem płytki jest kontroler MK20DX256VLH7 firmy Freescale. Jest to 32 bitowy kontroler oparty o rdzeń ARM Cortex M4. Ta wersja rdzenia ma takie funkcje jak szybkie dzielenie i mnożenie liczb oraz operacje obróbki sygnałów DSP (szybkie liczenie y=a*x+b). 

Kontroler pracuje z zegarem 72 MHz. Co daje mu 90 milionów operacji na sekundę. Jest ponad 5 razy szybszy niż ten w standardowym Arduino. Jeśli chcesz możesz podkręcić w nim zegar do 96 MHz uzyskując jeszcze większą wydajność.

Na program masz do dyspozycji 256 kB pamięci Flash. Dla zmiennych jest 64 kB pamięci RAM. Pamięci EEPROM jest 2 kB.
Mimo, że jest 8x więcej pamięci Flash niż w Arduino UNO, nie znaczy że zmieścisz tam 8x większy program. Programy na platformę ARM kompilują się do większych rozmiarów niż takie same dla AVR.

W zestawie z płytką otrzymasz ulotkę na której rozpisane jest znaczenie poszczególnych pinów Teensy.

Tu można przeżyć szok. Mimo rozmiarów płytki, jej twórcy dali nam do dyspozycji 34 piny cyfrowe. Działają one w standardzie 3,3 V. Jednak jako wejścia tolerują napięcie 5 V. Tak więc płytka może być kompatybilna ze starymi układami z logiką 5 V.

Wadą jest to, że część pinów od spodu płytki jest tylko w postaci pól lutowniczych, a nie otworów. 

Większość pinów cyfrowych pełni więcej niż jedną funkcję. Część z nich to wejścia analogowe, wyjścia PWM, szeregowe itp.

Na płytce jest 21 wejść analogowych. Mają one rozdzielczość 16 bitów, jednak autorzy wspominają, że użytecznych bitów jest 13. Daje to dokładność odczytu 8192 poziomów napięcia.

Do sterowania szybkością silników i jasnością LEDów jest 12 wyjśc PWM.

Dodatkowo jest jedno wyjście przetwornika cyfrowo-analogowego DAC. Dzięki niemu możesz mieć wyjście z płynną regulacją napięcia. Do takiego wyjścia możesz podłączyć wzmacniacz z głośnikiem i nadawać różne dźwięki, albo komunikaty głosowe.
Wyjście ma rozdzielczość 12 bitów. Co daje 4096 poziomów napięcia wyjściowego.

Ciekawostką są wejścia przycisków dotykowych. Jest ich 12. W kolejnych odcinkach omówię jak z nich korzystać.

Wśród interfejsów do przesyłania danych na płytce są:

  • 3 interfejsy typu Serial (asynchroniczne RS232 TTL)
  • 2 magistrale I2C/TWI
  • 1 interfejs SPI
  • 1 magistrala CAN (używana w samochodach i przemyśle)

Wyjście zasilania 3,3 V można obciążyć do 100 mA.

Kontroler posiada w sobie zegar czasu rzeczywistego RTC. Służy on do sprzętowego przechowywania i obliczania daty oraz czasu. Jego funkcję uaktywnia się poprzez wlutowanie standardowego kwarcu zegarkowego o częstotliwości 32,768 kHz. By godzina i data były liczone po odłączeniu zasilania, do pinu VBat trzeba podłączyć bateryjkę 3V. Taką jak na płycie głównej PC.

Oczywiście jest też interfejs USB zakończony wtyczką Micro USB. Standardowo służy do programowania płytki. Po użyciu odpowiednich bibliotek, może udawać dowolne urządzenie USB. Po wlutowaniu w odpowiednie miejsce kondensatora 150 uF, interfejs USB może pełnić rolę Host USB i sterować innymi urządzeniami USB takimi jak pendrive, aparat cyfrowy albo smartphone.


Rozpiska pinów Teensy 3.1 (zdjęcie pochodzi ze strony Pjrc)

Twórcy płytki oferują specjalne biblioteki do każdego z interfejsów. Ale o tym jak zacząć przygodę z programowaniem Teensy 3.1 dowiesz się w kolejnych odcinkach.

Jeśli masz jakieś pytania i chciałbyś, żebym sprawdził coś dokładniej. Napisz w komentarzu pod wpisem. Chętnie rozwieje twoje wątpliwości.

Udanych eksperymentów życzy
sprae

W kolejnym odcinku…

W przyszłym tygodniu naszego serialu, spędzimy kilka dni z czymś co jest:

  • mniejsze niż palec;
  • ma kilkadziesiąt programowalnych pinów;
  • ma wydajność Arduino DUE;
  • jest ponad 2x tańsze niż Arduino DUE;
  • jest tańsze nawet niż Arduino UNO;
  • toleruje stany logiczne 5V.

Zobaczę, czy jest tak wygodne w programowaniu jak Arduino. Czy pasują do niego różne biblioteki. Czy to w ogóle ma sens?!

Jeśli masz pytania dotyczące tej płytki, zostaw je w komentarzu. Postaram się je rozwiązać w przyszłych wpisach.

sprae

Biblioteka aREST do Internet Of Things

Biblioteka aREST do Internet Of Things