Przerwa wakacyjna

Ponownie spotykamy się w październiku 2017 r.

Podsumowując rok akademicki 2016/17: przeprowadziliśmy 31 spotkań w ramach Fi-BOTa, w tym jedno festiwalowe (XV Podlaski Festiwal nauki i Sztuki). Dziękuję za wytrwałość i zapraszam w roku akademickim 2017/18 (termin będzie ustalony w październiku). Zachęcam do samodzielnej pracy z Arduino i… pochwaleniem się własnymi projektami w nowym semestrze!

K.G.

Zajęcia nr 5 – serwo silniki, map(), bluetooth

 Serwo silnik (a właściwie mikro-serwo)

serwo1Czyli silnik, który obraca się od 0 do 180 stopni (ma blokadę na inne wychylenia). Potem utrzymuje swoją pozycję. Służy do tworzenia obrotowych ramion itd…

Trzy przewody – zasilanie (czerowny +5V, czarny/brązowy GND) oraz jeden sterujący – musi być PWM. Za dużo nie wnikałem o co chodzi w sterowaniu tym silnikiem, tylko wspomniałem o potencjometrze wewnątrz i o wypełnieniu sygnału sterującego… więcej może później? Zobaczymy.

 

Do sterowania tym silnikiem użyliśmy 2 nowych funkcji z nowej biblioteki:

  • #include <Servo.h> – na początku programu informujemy, że chcemy funkcje z tej nowej biblioteki
  • Servo silniczek; tworzymy zmienną typu silnik-serwo, czyli właśnie o to nam chodzi!
  • silniczek.attach(3); powoduje przekazanie informacji do Arduino, że sterujemy silnikiem przez pin numer 3 (przypominam: musi być to pin PWM, czyli jak nie 3, to 5,9…)
  • silniczek.write(133); ustawia nasz silnik w pozycji 133 stopni. Albo na dowolny inny z zakresu 0..180 stopni. Dziecinie proste 😉

Serwo sterowane z klawiatury

Przypomnieliśmy sobie jak odczytywać liczby z klawiatury (funkcja parseInt() dla obiektu Serial) i stworzyliśmy program ustawiający silnik w pozycji wczytanej z klawiatury. Proste a przyjemne. No i zawsze warto powtarzać wiedzę 😉

Serwo sterowane potencjometrem

Połączenie poprzednich zajęć – potencjometr liniowy (dzielnik napięć!) wykorzystany do ustawiania pozycji serwa – ruszam „gałką” w lewo, orczyk w serwie obraca się w lewo. Tak samo w prawo. Fajne!

Serwo sterowane potencjometrem – program PRO

Dbamy o szczegóły – i nie chcemy ustawiać położenia serwa wówczas, gdy potencjometr nie zminił swojej pozycji. Bez złośliwości – my staramy się programować na serio

Prąd „zjadany” przez serwo – mierzymy!

W skrajnych ustawieniach serwa (tj. w okolicy 0 stopni, oraz w okolicach 180 stopni) słyszymy buczenie/piszczenie serwo-silnika. Coś się dzieje. Amperomierz w garść i mierzymy prąd.

serwo1

Przyjrzyj się uważnie obrazkowi i zwróć uwagę, jak podłączony jest amperomierz.

Oczywiście w wirtualnym Arduino (ciągle polecam circuits.io) silniczek serwo jest idealny i nie widzimy tego, co było u nas na zajęciach….

Dodatkowo: w przypadku mierników uniwersalnych ustaw największą wartość prądu, jaką się spodziewasz dostać – nie odwrotnie! W przeciwnym przypadku zwiększając zakres przepalisz bezpiecznik w multimetrze…

Funkcja map()

Czyli skalowanie wartości z jednego zakresu na drugi zakres. Przykład, z którym my się bawiliśmy: serwo silniczek sterowany potencjometrem. Odczytujemy nastawy potencjometru z portu analogowego Arduino jako liczbę (nazwijmy ją x) z zakresu 0..1023, a następnie ustawiamy serwo w położeniu z zakresu 0..180 stopni (nazwijmy te stopnie y). Czyli musimy dokonać zamiany wczytaj liczby x na y. Na zajęciach pokazałem skalowanie funkcją liniową, rozwiązaliśmy ten układ równań, ale Arduino jest także dla tych co tego nie umieją zrobić i przygotowało funkcję map(). W naszym przypadku będzie to:

y=map(x, 0, 1023, 0, 180);

Należy pamiętać, że funkcja map() działa tylko na liczbach całkowitych (int).

Serwo sterowane przez Androida – bluetooth XM-15B

Dlaczego ten? Bo działa w zakresie 3-6V, czyli można go bezpiecznie podłączyć do Arduino. Inne modele – popularne HC-05, HC-06 komunikują się przez 3.3V i wymagają „zbijania” napięcia (np. dzielnikiem napięć). To proste, ale… po co się w to bawić, jak można kupić właśnie moduł pozbawiony tej uciążliwości? Praujemy więc z XM-15B.

 

Pamiętajmy o łączeniu „na krzyż” portów RxD,TxD modułu XM-15B z portami RxD,TxD płytki Arduino (także tymi wirtualnymi).

Komunikacja z 8LAMP

Ze sklepu Play bierzemy prostą apkę i sprawdzamy, co ona wysyła do naszego bluetootha. Kod:

#include <SoftwareSerial.h>

#define RxD 8
#define TxD 9
SoftwareSerial btSerial(RxD,TxD);

void setup() {
  Serial.begin(9600);
  btSerial.begin(9600);
  Serial.println("start!");
}

void loop() {
  if (btSerial.available()){
    Serial.print("Odebrałem znak= ");
    Serial.println(btSerial.read());
  }  
}

Następnie tak modyfikujemy ten program, by wczytany znak sterował naszym serwem – guzik '1′ ustawiał serwo na 90 stopni, guzik '2′ na 10 stopni i guzik '3′ na 170 stopni. Inne modyfikacje mile widziane 😉

Ważne

Na następne zajęcia proszę o zainstalowanie ze sklepu Play aplikacji Arduino Bluetooth Controler bo będziemy sterować pojazdem.

RaspberryPi ZeroW – test Mathematicy

Wraz z czerwcowym numerem The MagPi Magazine prenumeratorzy wersji papierowej otrzymali komputer RaspberryPi Zero W, plus obudowa (z trzema pokrywkami) oraz niezbędne przejściówki (USB, HDMI). Jest to najmniejszy komputer z rodziny Malinek – cechuje go bardzo kompaktowy rozmiar. Wydział Fizyki jako prenumerator tego magazynu otrzymał swój egzemplarz, a ja przyjrzałem się wydajności tej maszynki w znanym programie Wolfram Mathematica – bezpłatnego (pod sporymi restrykcjami) na Malinki.

Parametry

Wymaga wymienić podstawową konfigurację świadczącą o szybkości, więc:

  • 1GHz, jednordzeniowy CPU,
  • 512MB RAM.

Jeśli chodzi o dodatkowe rzeczy, to:

  • Mini HDMI and USB On-The-Go ports
  • Micro USB power
  • HAT-compatible 40-pin header
  • Composite video and reset headers
  • CSI camera connector
  • 802.11 b/g/n wireless LAN
  • Bluetooth 4.1
  • Bluetooth Low Energy (BLE).

Z rozmiaru pamięci widać, że szału nie będzie. Ale skoro jest to maszynka edukacyjna, z oprogramowaniem Mathematicy (w wersji na Rasbiana) to dlaczego by nie sprawdzić? Dla podkreślenia, wersja druga Maliny wyposażona jest w czterordzeniowy procek taktowany 900MHz, no i RAMu ma dwa razy więcej – 1GB. Sprawdzałem wielokrotnie, że da się pracować na Mathematicy  w zadawalający sposób. A tutaj jak będzie?

Powyżej zdjęcie porównujące „gabaryty” nowej Malinki (po prawej stronie) do wersji Pi2B (lewa strina). Widać wyraźnie, że trzeba być przygotowany na jakiś hub z portami USB, bo inaczej nie podłączymy klawiatury+myszki – jest tylko jeden port USB (drugi, widoczny na zdjęciu – to port zasilania). Więc trzeba mieć klawiaturę zintegrowaną z myszką, albo hub-a. Przy okazji – piny GPIO nie są przylutowane, należy samodzielnie to zrobić.

Upgrade systemu na Pi 2 Model B i przełożenie karty z systemem i… ZeroW wystartował bez problemów (mówie o Rasbianie). Później w domu sprawdziłem, że taki upgrade i sieć wi-fi uruchomił bezproblemowo.

Uruchomienie – ciężki start

A nawet gorzej – nie da się pracować na Mathematicy. Samo uruchomienie to czekanie ponad 2 minuty – a system stracił responsywność.  Zaglądam na zużycie pamięci i widzę, że środowisko X-ów z uruchomoioną Mathematicą pożarło 450 MB RAMu. Jesteśmy na granicy… Co się dzieje dalej?

Praca z Mathematicą – szału nie ma

Nie ma się co oszukiwać – 512MB to zdecydowanie za mało na działanie Mathematicy. Poniżej przedstawiam wyniki kilku testów szybkościowych – generowanie fraktala Mandelbrota (prosta metoda, różne siatki jak też i dwa kryteria zbieżności, różniące się dwukrotnie progiem liczby iteracji – na końcu znajdują się dokładne procedury testujące). Porównuję czasy do Pi2 Model B – uruchomionego z tej samej karty (i do biurkowego Intela i7-4790K CPU @ 4.00GHz, 32GB RAM pod kontrolą Ubuntu 16.04).

  mandel-1 export mandel-2 mandel-3 kolor
Intel i7 0.84 s 1.2 s 0.9 s 1.4 s 0.2 s
RPi2 28.5 s 24.5 s 12 s 49 s 7.5 s
*RPi3 15.6 s 13.0 s ? 27 s 4.6 s
ZeroW 96 s 86 s 40 s 164 s 600 s

Wyniki w tabelce to wynik poleceń Timing[] Mathematicy i nie oddają dokładnie tego, co się dzieje z systemem. A dzieje się dużo – jak już wspomniałem, na RPi Zero występuje utrata responsywności, czyli możliwości pracy (system zachowuje się jakby się „zawiesił” – okna się nie odświeżają, polecenia się nie wykonują, menu się nie rozwijają). To oznacza całkowitą klęskę w obsłudze programu Mathematicy – co było do przewidzenia ze względu na wielkość pamięci RAM tego modelu. Zresztą – w domu mam RPi w pierwszej wersji, także z 512MB ramu i tam jedyne co można – to uruchomić Mathematicę, nic konkretnego nie da się zrobić (OK – poza wykresem prostej funkcji).

Z kolei wersja druga Maliny działa już jak najbardziej przyzwoicie – nawet, gdy program zajęty jest obliczeniami, ciągle możemy działać (wiadomo – więcej pamięci i cztery rdzenie CPU, podczas gdy moje testy angażują tylko jeden rdzeń).

Podsumowując

RPi Zero W – bardzo fajne urządzenie, ale nie do Mathematicy. Zdecydowanie odradzam wydatek około 50 zł na tą maszynkę w celu wykorzystania jej do rozwiązywania zadań domowych z pomocą programu Wolframa. Inne zastosowania (elektronika, IoT) – jak najbardziej TAK, zarówno mocy obliczeniowej jak i RAMu jest wystarczająco. Tym bardziej, że płytka ma już zintegrowaną kartę Wi-Fi (oraz Bluetooth, choć tego jeszcze nie sprawdziłem). 

Wyjaśnienie

Artykuł powstał z powodu rozmowy ze studentami, których uczę Mathematicy a którzy mnie dopytywali o nowy, tani model RPi Zero.

Testy

Funkcja dla Mandelbrota

mandelbrot[p_, max_] := 
 Module[{zn = p, i = 0}, 
  While[(i < max) && (Abs[zn] < 2), zn = zn^2 + p; i++]; Abs[zn] < 2]

mandelbrot[0, 100]

True

mandelbrot[I, 100]

True

mandelbrot[I + 0.1, 100]

False

Timing[mandelbrot[I + 0.1, 10000]]

{0., False}

Test 1

Timing[
 minx = -2;
 maxx = 2;
 dx = (maxx - minx)/200.;
 miny = -2;
 maxy = 2;
 dy = (maxy - miny)/200.;
 r = Show[
   Graphics[{
     Black,
     Table[
      If[mandelbrot[x + I*y, 100], 
       Rectangle[{x - dx/2, y - dy/2}, {x + dx/2, y + dy/2}]], {x, 
       minx, maxx, dx}, {y, miny, maxy, dy}]
     }
    ],
   Frame -> True,
   PlotRange -> {{minx, maxx}, {miny, maxy}}]
 ]

Test 2

Timing[
 Export["mandel.jpg", r, ImageResolution -> 300]
 ]

Test 3

Timing[
 minx = -1.45;
 maxx = -1.2;
 dx = (maxx - minx)/100.;
 miny = -0.1;
 maxy = 0.1;
 dy = (maxy - miny)/100.;
 Show[
 Graphics[{
 Black,
 Table[
 If[mandelbrot[x + I*y, 200], 
 Rectangle[{x - dx/2, y - dy/2}, {x + dx/2, y + dy/2}]], {x, 
 minx, maxx, dx}, {y, miny, maxy, dy}]
 }
 ],
 Frame -> True,
 PlotRange -> {{minx, maxx}, {miny, maxy}}]
 ]

Test 4- kolorowy

kolormandelbrot2 = Compile[{{p, _Complex}, {max, _Integer}},
  Module[{zn = p, i = 0}, 
   While[(i < max) && (Abs[zn] < 2), zn = zn^2 + p; i++]; i]
  ]


minx = -1.42;
maxx = -1.415;
dx = (maxx - minx)/200.;
miny = -0.01;
maxy = 0.01;
dy = (maxy - miny)/200.;
Timing[
 Show[
  Graphics[{
    Table[{
      Hue[-0.7*kolormandelbrot2[x + I*y, 200]/200. + 0.7],
      Rectangle[{x - dx/2, y - dy/2}, {x + dx/2, y + dy/2}]}
     , {x, minx, maxx, dx}, {y, miny, maxy, dy}]
    }
   ],
  Frame -> True,
  PlotRange -> {{minx, maxx}, {miny, maxy}}]
 ]

 

Followliner (FL) – starcie 1

  1. Prosty FL – zbudowany na 2 czujnikach TCRT5000 ustawionych blisko siebie tak, by oba leżały nad czarną linią. Położenie czujek – z przodu, przy napędzie (wiem wiem…).
  2. Instalacja modułu w pojeździe.
  3. Pierwszy program – jedź prosto, gdy oba czujniki „widzą” linię.
  4. Modyfikacja – skręcaj (zatrzymując jedno koło) gdy jedna czujka „gubi” linię.
  5. Modyfikacja – silniki STOP, gdy obie czujki zgubiły linię.

Do zrobienia:

  1. (chwilowo) zostaniemy przy 2 czujkach, za to dodamy regulację szybkości kół w zależności od sygnału na czujce (aby nie było szarpania, a ruch był płynny).
  2. gdy pojazd wyjechał poza linię, to ma się cofnąć (może nawet kilka razy, a jeśli po tych kilku razach dalej nie widać linii – to dopiero wówczas STOP).
  3. zmodyfikujemy tor testowy – łagodniejsze łuki (łatwiejsze, ale z czasem zmienimy).

Liczymy obroty (TCRT5000) – sukces!

Liczymy obroty silniczka D65:

Znalezione obrazy dla zapytania d65 zestaw napedowytutaj nasz program:

 

bool stan, poprz;
unsigned long int t1;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  stan=false;
}

int odczyt;
int licz=0;
void loop() {
  poprz=stan;
  odczyt=analogRead(A0);
  if (odczyt<50)
    stan=true;
  else
    stan=false;
//  Serial.print(odczyt);
//  Serial.print("   ");
//  Serial.print(stan?"jasne":"ciemne");
//  Serial.print("   ");
  if (stan!=poprz){
    licz++;
    Serial.print(" KLIK ");
    Serial.print(licz);
    Serial.print(" ");
    if (licz%2==0){
      Serial.print(1000./(millis() - t1)*60);
      Serial.println(" rpm");
      t1= millis();
    }
  }
//  else
//    Serial.println();
}

I działa bardzo fajnie, nawet z tylko jednym znacznikiem! Wyniki są bardzo powtarzalne (przy zasilaniu około 7V – jeden obrót w 230-240ms, czyli 4 obroty w 1 sekundę, a to daje 4*60=240 obrotów na minutę – rpm).

Rozbudowa?

  1. więcej znaczników (już 2 polepszają sprawę, 4 to zdecydowanie OK).
  2. inny algorytm – zliczanie liczny obrotów i aktualizowanie wartości rpm co określony czas, np. 2 sek

Arduino Cinque

Kolejna płytka ze stajnu Arduino – kompatybilna z UNO, za to wyposażona w dużo mocniejszy procesor (już nie jest zbudowana na bazie ATmegi, a Freedom E310).

Nie tylko nowa szybkość procesora (Freedom E310 to 32bitowy mikrokontroler, mogący działać z szybkością 320MHz, a więc 20x szybciej niż aktualnie UNO), ale także:

  • 16kB RAMu na dane
  • Wi-Fi
  • Bluetooth

Pełna specyfikacja płytki : https://www.allaboutcircuits.com/news/arduino-cinque-brings-together-risc-v-and-the-popular-arduino-platform/

Cena? Jeszcze nie jest znana, ale… tanio nie będzie (porównując do klonów UNO) – pierwsza wersja tej płytki o naziwe HiFive1 kosztowała niecałe $60 (a to juest już druga wersja, ulepszona). Mimo wszystko ciekawa alternatywa.