Kursy • Poradniki • Inspirujące DIY • Forum

Premiera: Raspberry Pi
Debug Probe

Historia tranzystora w skrócie.
Wynalezienie czy odkrycie?

3 podstawowe rodzaje
akumulatorów, które warto znać

Co ciekawego w DIY?
10 projektów naszych czytelników #33

Piezoelektryki – czym
są materiały piezoelektryczne?

Czym jest moc?

Poznaj podstawy

Kurs elektroniki

Czujniki analogowe

Kursy Artykuły

DIY Forum

Pierwsze starcie z Genuino 101 – wizualizacja położenia

Archiwum Damian (Treker) Szymański

Genuino 101 zaprezentowano podczas hucznej premiery podczas Maker Faire 2015. Od tego czasu na premierę płytki czekali majsterkowicze z całego Świata.

W związku z tym, że w moje ręce trafiła właśnie ostateczna wersja 101 mogłem zabrać się za testy praktyczne. Jak płytka z Intel Curie sprawdza się w praktyce? Sprawdźmy!

Pierwszy projekt na Genuino 101

Opisywany tutaj projekt będzie "pierwszy" z dwóch powodów. Płytka trafiła do sprzedaży całkiem niedawno. Nie jest jeszcze dostępna u krajowych dystrybutorów Arduino. Przykładowo w Botlandzie Genuino 101 pojawi się dopiero za 2 tygodnie. Bazując na szybkich poszukiwaniach mogę śmiało stwierdzić, że jest to jedna z pierwszych płytek 101 w Polsce, możliwe nawet, że jest dokładnie pierwsza.

Pierwsze w Polsce (?) Genuino 101!

W związku z tym, opisywany tutaj projekt jest również moim pierwszym wykorzystaniem tego Genuino w praktyce. Nie miałem okazji podejrzeć innych majsterkowiczów. Aby szybko osiągnąć ciekawe efekty bazowałem wyłącznie na materiałach udostępnionych przez Arduino.

Genuino 101 - specyfikacja

Omawiana płytka od samego początku miała być konkurencją dla UNO, które jest bohaterem naszego kursu Arduino. Stąd należałoby ją porównać do tego kultowego już modelu z ATmegą.

	Arduino UNO	Genuino 101
Mikrokontroler	ATmega328P	Intel Curie
Napięcie zasilania (zalecane)	7-12V
Napięcie pracy	5V	3.3V (I/O tolerują 5V)
Częstotliwość pracy	16 MHz	32MHz
Wydajność prądowa I/O	20 mA
Liczba portów I/O	14
Liczba kanałów PWM	6	4
Liczba kanałów ADC	6
Bluetooth	Nie	Tak
Akcelerometr	Nie	Tak
Żyroskop	Nie	Tak
Pamięc Flash	32 kB	196 kB
Pamięć SRAM	2 kB	24 kB
Długość	68.6 mm
Szerokość	53.4 mm
Cena	$25	$30

Jak widać na korzyść 101 przemawia zdecydowanie obecność akcelerometru i żyroskopu. Co więcej mamy tam do dyspozycji moduł Bluetooth w wersji Low Energy. Oczywiście można dodać te peryferia do Arduino UNO, jednak zajmą one wtedy całkiem dużo miejsca. Tutaj wszystko jest na jednej płytce.

Co ważne, powyższe dodatki, jak Bluetooth, żyroskop i akcelerometr nie blokują nam dostępnych portów GPIO.

Kolejną widoczną przewagą jest wyższe taktowanie układu. W przypadku 101 mówimy o pracy z dwukrotnie większą częstotliwością, w porównaniu do Arduino UNO. Co więcej, płytka ta posiada znacznie więcej pamięci FLASH i RAM.

Czy warto dopłacić 5$ dla tych kilku wyróżników?
Moim zdaniem tak.

Arduino, Genuino, Arduino, Genuino...

Jeśli ktoś nie wie dlaczego nazwy Arduino i Genuino używam zamiennie, to przypominam: wszystko przez rozłam, który nastąpił wśród Twórców platformy, co doprowadziło również do walki o nazwę i znak firmowy.

W chwili obecnej płytki produkowane w USA są markowane na tamtym terenie jako Arduino, natomiast poza stanami występują pod nazwą Genuino, ponieważ prawa do znaku Arduino poza USA przypadają odłamowi firmy, który pozostał we Włoszech.

W związku z tym dostępne są płytki Arduino UNO i Genuino UNO, Arduino 101 i Genuino 101. Jednak z punktu widzenia użytkownika żadnych różnic nie znajdziemy.

: Źródło: https://www.arduino.cc

: Źródło: https://www.arduino.cc

Jak można programować Genuino 101?

Zapewne wielu z Was widząc na płytce logo Intela wraz ze słynnym już układem Intel Curie liczyła na ogromną ilość języków, którą można wykorzystać do pracy ze 101. Niestety, na ten moment możemy używać jedynie Arduino!

Moduły Intel Curie, źródło: http://iq.intel.com

Na płytce znajduje się RTOS (system czasu rzeczywistego), jednak użytkownik nie ma do niego na razie dostępu. Intel zapowiedział, że zarówno RTOS, jaki i cały framework stanie się otwarty najwcześniej w marcu tego roku. Do tego czasu z dobrodziejstw Curie można korzystać tylko z poziomu Arduino. Na ten moment nie interesowałem się jeszcze, jak jest to dokładnie realizowane.

Pierwszy projekt praktyczny na Genuino 101

W związku z tym, że nie miałem dużo czasu postanowiłem pobawić się jednym z przykładowych projektów opisanych na stronie Arduino. W związku z tym wykorzystałem żyroskop do wizualizacji położenia płytki z Genuino w przestrzeni 3D. Nie będę omawiał kodu - na ten moment ograniczymy się do podziwiania efektów.

Naszym celem jest takie wykorzystanie czujników znajdujących się na pokładzie Genuino 101, aby obracając (w dowolnej osi) podłączoną do komputera płytką odwzorowywać te same ruchy na monitorze (manipulując uproszczonym modelem).

W praktyce efekt końcowy, na ekranie komputera, będzie wyglądał następująco:

Efekt pracy z Genuino 101.

Jak osiągnąć taki efekt? O tym poniżej.

Niezbędne oprogramowanie

Oczywiście potrzebne jest Arduino IDE, które można pobrać ze strony projektu. Jeśli po instalacji w menu: Narzędzia → Płytka nie znajdziemy na liście pozycji "Arduino 101", to oznacza, że musimy pobrać odpowiedni pakiet. W tym celu wchodzimy do menu:

Narzędzia → Płytka → Menadżer płytek

Następnie w polu wyszukiwarki wpisujemy np.: "curie". Naszym oczom powinna ukazać się taka biblioteka jak: Intel Curie Boards by Intel. Klikamy na tę pozycję, a następnie po prawej stronie wybieramy Install. Gdy proces zakończy się sukcesem naszym oczom ukaże się taki efekt:

Efekt poprawnej instalacji płytki Genuino/Arduino 101.

Teraz możemy podłączyć 101 do komputera. Płytka zainstaluje sama odpowiednie sterowniki, a po chwili będzie widoczna jako nowy port COM:

Poprawnie zainstalowane Genuino 101.

Instalacja biblioteki Madgwick

Zadanie, które sobie postawiliśmy nie jest łatwe. Dlatego skorzystamy z filtru Madgwicka. Algorytm ten został opracowany w 2010 roku przez Sebastiana Madgwicka. Filtr ten wykorzystuje na wejściu dane bezpośrednio dostarczane z akcelerometru i żyroskopu. Na wyjściu otrzymujemy natomiast informacje o obrotach czujnika wokół osi X, Y oraz Z

Informacje te mogą być wykorzystane do obliczenia kątów Eulera (pitch, yaw, roll), czyli trzech katów, które pozwalają na jednoznaczną orientację układu w przestrzeni. Co ważne użyty tutaj filtr Madgwicka radzi sobie doskonale w sytuacjach, gdy ilość próbek jest stosunkowo mała.

Wizualizacja katów Eulera, źródło: Wikipedia.

Wizualizacja kątów Eulera, źródło: Wikipedia.

W celu instalacji biblioteki, która wykona za nas niezbędną matematykę należy wybrać menu:

Szkic → Dołącz bibliotekę → Zarządzaj bibliotekami

Następnie wpisujemy w okno wyszukiwarki Madgwick i instalujemy odpowiedni pakiet. Po instalacji zobaczymy odpowiednią adnotację obok nazwy biblioteki:

Zainstalowana biblioteka Madgwick.

Genuino 101 - rysujemy wykres

Zanim przejdziemy do trójwymiarowej wizualizacji położenia płytki możemy sprawdzić w terminalu, czy nasze Genuino działa poprawnie. W tym celu tworzymy nowy szkic i wklejamy tam następujący kod (tak jak mówiłem, na początku nie będziemy omawiać, co tam się dzieje). Program bazuje na demie udostępnionym przez Arduino.

#include "CurieImu.h"
#include "MadgwickAHRS.h"

Madgwick filter; // initialise Madgwick object
int ax, ay, az;
int gx, gy, gz;
float yaw;
float pitch;
float roll;
int factor = 800; // variable by which to divide gyroscope values, used to control sensitivity

int calibrateOffsets = 1; // int to determine whether calibration takes place or not

void setup() {
  // initialize Serial communication
  Serial.begin(9600);

  // initialize device
  CurieImu.initialize();

  // verify connection
  if (!CurieImu.testConnection()) {
    Serial.println("CurieImu connection failed");
  }


  if (calibrateOffsets == 1) {
    // use the code below to calibrate accel/gyro offset values
    Serial.println("Internal sensor offsets BEFORE calibration...");
    Serial.print(CurieImu.getXAccelOffset()); Serial.print("\t");
    Serial.print(CurieImu.getYAccelOffset()); Serial.print("\t");
    Serial.print(CurieImu.getZAccelOffset()); Serial.print("\t");
    Serial.print(CurieImu.getXGyroOffset()); Serial.print("\t");
    Serial.print(CurieImu.getYGyroOffset()); Serial.print("\t");
    Serial.print(CurieImu.getZGyroOffset()); Serial.print("\t");
    Serial.println("");
    
    //IMU device must be resting in a horizontal position for the following calibration procedure to work correctly!

    Serial.print("Starting Gyroscope calibration...");
    CurieImu.autoCalibrateGyroOffset();
    Serial.println(" Done");
    Serial.print("Starting Acceleration calibration...");
    CurieImu.autoCalibrateXAccelOffset(0);
    CurieImu.autoCalibrateYAccelOffset(0);
    CurieImu.autoCalibrateZAccelOffset(1);
    Serial.println(" Done");

    Serial.println("Internal sensor offsets AFTER calibration...");
    Serial.print(CurieImu.getXAccelOffset()); Serial.print("\t");
    Serial.print(CurieImu.getYAccelOffset()); Serial.print("\t");
    Serial.print(CurieImu.getZAccelOffset()); Serial.print("\t");
    Serial.print(CurieImu.getXGyroOffset()); Serial.print("\t");
    Serial.print(CurieImu.getYGyroOffset()); Serial.print("\t");
    Serial.print(CurieImu.getZGyroOffset()); Serial.print("\t");
    Serial.println("");
    Serial.println("Enabling Gyroscope/Acceleration offset compensation");
    CurieImu.setGyroOffsetEnabled(true);
    CurieImu.setAccelOffsetEnabled(true);
  }
}

void loop() {
  // read raw accel/gyro measurements from device
  ax = CurieImu.getAccelerationX();
  ay = CurieImu.getAccelerationY();
  az = CurieImu.getAccelerationZ();
  gx = CurieImu.getRotationX();
  gy = CurieImu.getRotationY();
  gz = CurieImu.getRotationZ();

  // use function from MagdwickAHRS.h to return quaternions
  filter.updateIMU(gx / factor, gy / factor, gz / factor, ax, ay, az);

  // functions to find yaw roll and pitch from quaternions
  yaw = filter.getYaw();
  roll = filter.getRoll();
  pitch = filter.getPitch();
  
  Serial.print(ax); Serial.print("\t");
  Serial.print(ay); Serial.print("\t");
  Serial.print(az); Serial.print("\t");
  Serial.print(gx); Serial.print("\t");
  Serial.print(gy); Serial.print("\t");
  Serial.print(gz); Serial.print("\t");
  Serial.println("");

  delay(50);
}

#include "CurieImu.h"

#include "MadgwickAHRS.h"

Madgwick filter; // initialise Madgwick object

int ax, ay, az;

int gx, gy, gz;

float yaw;

float pitch;

float roll;

int factor = 800; // variable by which to divide gyroscope values, used to control sensitivity

int calibrateOffsets = 1; // int to determine whether calibration takes place or not

void setup() {

// initialize Serial communication

Serial.begin(9600);

// initialize device

CurieImu.initialize();

// verify connection

if (!CurieImu.testConnection()) {

Serial.println("CurieImu connection failed");

}

if (calibrateOffsets == 1) {

// use the code below to calibrate accel/gyro offset values

Serial.println("Internal sensor offsets BEFORE calibration...");

Serial.print(CurieImu.getXAccelOffset()); Serial.print("\t");

Serial.print(CurieImu.getYAccelOffset()); Serial.print("\t");

Serial.print(CurieImu.getZAccelOffset()); Serial.print("\t");

Serial.print(CurieImu.getXGyroOffset()); Serial.print("\t");

Serial.print(CurieImu.getYGyroOffset()); Serial.print("\t");

Serial.print(CurieImu.getZGyroOffset()); Serial.print("\t");

Serial.println("");

//IMU device must be resting in a horizontal position for the following calibration procedure to work correctly!

Serial.print("Starting Gyroscope calibration...");

CurieImu.autoCalibrateGyroOffset();

Serial.println(" Done");

Serial.print("Starting Acceleration calibration...");

CurieImu.autoCalibrateXAccelOffset(0);

CurieImu.autoCalibrateYAccelOffset(0);

CurieImu.autoCalibrateZAccelOffset(1);

Serial.println(" Done");

Serial.println("Internal sensor offsets AFTER calibration...");

Serial.print(CurieImu.getXAccelOffset()); Serial.print("\t");

Serial.print(CurieImu.getYAccelOffset()); Serial.print("\t");

Serial.print(CurieImu.getZAccelOffset()); Serial.print("\t");

Serial.print(CurieImu.getXGyroOffset()); Serial.print("\t");

Serial.print(CurieImu.getYGyroOffset()); Serial.print("\t");

Serial.print(CurieImu.getZGyroOffset()); Serial.print("\t");

Serial.println("");

Serial.println("Enabling Gyroscope/Acceleration offset compensation");

CurieImu.setGyroOffsetEnabled(true);

CurieImu.setAccelOffsetEnabled(true);

}

void loop() {

// read raw accel/gyro measurements from device

ax = CurieImu.getAccelerationX();

ay = CurieImu.getAccelerationY();

az = CurieImu.getAccelerationZ();

gx = CurieImu.getRotationX();

gy = CurieImu.getRotationY();

gz = CurieImu.getRotationZ();

// use function from MagdwickAHRS.h to return quaternions

filter.updateIMU(gx / factor, gy / factor, gz / factor, ax, ay, az);

// functions to find yaw roll and pitch from quaternions

yaw = filter.getYaw();

roll = filter.getRoll();

pitch = filter.getPitch();

Serial.print(ax); Serial.print("\t");

Serial.print(ay); Serial.print("\t");

Serial.print(az); Serial.print("\t");

Serial.print(gx); Serial.print("\t");

Serial.print(gy); Serial.print("\t");

Serial.print(gz); Serial.print("\t");

Serial.println("");

delay(50);

}

Następnie kompilujemy szkic i wgrywamy go do Genuino 101. Tutaj bardzo ważna uwaga. Korzystamy z czujników położenia, które wymagają kalibracji (została ona zaimplementowana w powyższym programie.

W związku z tym płytka musi leżeć prosto podczas startu programu.
Inaczej zaburzymy proces kalibracji.

Gdy uruchomimy Szeregowy Monitor naszym oczom ukaże się wodospad liczb:

Informacje z czujników.

Są to informacje przetworzone przez zaimplementowany filtr. Wartości się zmieniają, ponieważ po kalibracji zacząłem ruszać płytkę. Zdecydowanie lepiej sytuacja wygląda po uruchomieniu innej opcji z menu, gdy wywołamy: Narzędzia → Monitor portu szeregowego, to naszym oczom ukaże się wykres rysowany z powyższych wartości (jest to stosunkowo nowa opcja w Arduino IDE):

Wizualizacja zmiany położenia układu.

Świetnie, potrafimy już rysować wykres, który jest kompletnie nieczytelny! Co dalej? Pora na prawdziwą wizualizację ruchów układu.

Processing - program do wizualizacji danych

W celu lepszego zobrazowania położenia płytki pobieramy darmowy program Processing. Jeśli nie spotkaliście się z nim wcześniej, to warto w wolnej chwili poznać jego możliwości. W dużym skrócie jest to IDE, które pozwala na łatwą pracę z obrazami.

Processing – język programowania oraz zintegrowane środowisko programistyczne (IDE) stworzone na potrzeby sztuki elektronicznej (wizualnej, interaktywnej, dźwiękowej) oraz projektowania graficznego. Autorami projektu są byli studenci i pracownicy Aesthetics and Computation Group (ACG) działającym w MediaLab w amerykańskim MIT.

Źródło: Wikipedia

Następnie korzystamy z dema programu dostarczonego również przez Arduino. Program ten odczytuje dane wysłane przez Genuino do komputera i na ich podstawie manipuluje wirtualną płytką w przestrzeni.

Jedyne, co należy zmienić, to nr portu COM, o czym więcej informacji umieściłem pod kodem.

import processing.serial.*;
Serial myPort;

int newLine = 13; // new line character in ASCII
float yaw;
float pitch;
float roll;
String message;
String [] ypr = new String [3];

void setup()
{
  size(600, 500, P3D);
  
  /*Set my serial port to same as Arduino, baud rate 9600*/
  myPort = new Serial(this, Serial.list()[0], 9600); 
  textSize(16); // set text size
  textMode(SHAPE); // set text mode to shape
}

void draw()
{
  serialEvent();  // read and parse incoming serial message
  background(255); // set background to white

  translate(width/2, height/2); // set position to centre
  
  pushMatrix(); // begin object
  
  rotateX(pitch); // RotateX pitch value
  rotateY(-yaw); // yaw
  rotateZ(-roll); // roll
  
  drawArduino(); // function to draw rough Arduino shape
  
  popMatrix(); // end of object

  // Print values to console
  print(pitch);
  print("\t");
  print(roll); 
  print("\t");
  print(-yaw);   
  println("\t");

  myPort.write("s"); // write an "s" to receive more data from Arduino
} 

void serialEvent()
{
  message = myPort.readStringUntil(newLine); // read from port until new line (ASCII code 13)
  if (message != null) {
    ypr = split(message, ","); // split message by commas and store in String array 
    yaw = float(ypr[0]); // convert to float yaw
    pitch = float(ypr[1]); // convert to float pitch
    roll = float(ypr[2]); // convert to float roll
  }
}
void drawArduino() {
  /* function contains shape(s) that are rotated with the IMU */
  stroke(0, 90, 90); // set outline colour to darker teal
  fill(0, 130, 130); // set fill colour to lighter teal
  box(300, 10, 200); // draw Arduino board base shape

  stroke(0); // set outline colour to black
  fill(80); // set fill colour to dark grey

  translate(60, -10, 90); // set position to edge of Arduino box
  box(170, 20, 10); // draw pin header as box

  translate(-20, 0, -180); // set position to other edge of Arduino box
  box(210, 20, 10); // draw other pin header as box
}

import processing.serial.*;

Serial myPort;

int newLine = 13; // new line character in ASCII

float yaw;

float pitch;

float roll;

String message;

String [] ypr = new String [3];

void setup()

{

size(600, 500, P3D);

/*Set my serial port to same as Arduino, baud rate 9600*/

myPort = new Serial(this, Serial.list()[0], 9600);

textSize(16); // set text size

textMode(SHAPE); // set text mode to shape

}

void draw()

{

serialEvent(); // read and parse incoming serial message

background(255); // set background to white

translate(width/2, height/2); // set position to centre

pushMatrix(); // begin object

rotateX(pitch); // RotateX pitch value

rotateY(-yaw); // yaw

rotateZ(-roll); // roll

drawArduino(); // function to draw rough Arduino shape

popMatrix(); // end of object

// Print values to console

print(pitch);

print("\t");

print(roll);

print("\t");

print(-yaw);

println("\t");

myPort.write("s"); // write an "s" to receive more data from Arduino

}

void serialEvent()

{

message = myPort.readStringUntil(newLine); // read from port until new line (ASCII code 13)

if (message != null) {

ypr = split(message, ","); // split message by commas and store in String array

yaw = float(ypr[0]); // convert to float yaw

pitch = float(ypr[1]); // convert to float pitch

roll = float(ypr[2]); // convert to float roll

}

void drawArduino() {

/* function contains shape(s) that are rotated with the IMU */

stroke(0, 90, 90); // set outline colour to darker teal

fill(0, 130, 130); // set fill colour to lighter teal

box(300, 10, 200); // draw Arduino board base shape

stroke(0); // set outline colour to black

fill(80); // set fill colour to dark grey

translate(60, -10, 90); // set position to edge of Arduino box

box(170, 20, 10); // draw pin header as box

translate(-20, 0, -180); // set position to other edge of Arduino box

box(210, 20, 10); // draw other pin header as box

}

Naszą uwagę należy poświęcić poniższej linii:

  myPort = new Serial(this, Serial.list()[0], 9600);

1	myPort = new Serial(this, Serial.list()[0], 9600);

W nawiasach kwadratowych należy podać odpowiedni nr portu COM. Jednak uwaga, nie jest to wartość widoczna w menedżerze urządzeń!

Numeracja ta bierze pod uwagę aktualnie aktywne porty licząc od zera. Czyli, jeśli w menedżerze urządzeń Genuino 101 było widoczne jako COM4, ale nie mieliśmy żadnych innych urządzeń aktywnych, to ustawiamy tutaj 0. Jeśli oprócz Genuino na porcie 3 działoby inne urządzenie, to wstawimy tutaj 1 (ponieważ Genuino działałoby wtedy na drugim w kolejności aktywnym porcie).

Po poprawnym odpowiedniej edycji programu i jego uruchomieniu otrzymamy efekt, taki jak na poniższym nagraniu. Wybaczcie słabe oświetlenie, jednak zależało mi na uchwyceniu jedną kamerą obu rzeczy, aby całość była wiarygodna:

Zastosowanie praktyczne?

Czy powyższa wizualizacja może mieć zastosowanie praktyczne? Oczywiście, że tak. W podobny sposób można zrealizować np.: rejestrowanie ruchów, czy rozpoznawanie gestów wykonywanych płytką. Ja postanowiłem wykorzystać gotowy program do przestrzennej prezentacji Forbota!

Dla ciekawskich program realizujący powyższe zadanie prezentował się następująco. Jak widać było to banalnie proste zadanie!

import processing.serial.*;
Serial myPort;

int newLine = 13; // new line character in ASCII
float yaw;
float pitch;
float roll;
String message;
String [] ypr = new String [3];

void setup()
{
  size(600, 500, P3D);
  
  /*Set my serial port to same as Arduino, baud rate 9600*/
  myPort = new Serial(this, Serial.list()[0], 9600); 
  textSize(16); // set text size
  textMode(SHAPE); // set text mode to shape
}

void draw()
{
  serialEvent();  // read and parse incoming serial message
  background(255); // set background to white

  translate(width/2, height/2); // set position to centre
  
  pushMatrix(); // begin object
  
  rotateX(pitch); // RotateX pitch value
  rotateY(-yaw); // yaw
  rotateZ(-roll); // roll
  
  drawArduino(); // function to draw rough Arduino shape
  
  popMatrix(); // end of object

  // Print values to console
  print(pitch);
  print("\t");
  print(roll); 
  print("\t");
  print(-yaw);   
  println("\t");

  myPort.write("s"); // write an "s" to receive more data from Arduino
} 

void serialEvent()
{
  message = myPort.readStringUntil(newLine); // read from port until new line (ASCII code 13)
  if (message != null) {
    ypr = split(message, ","); // split message by commas and store in String array 
    yaw = float(ypr[0]); // convert to float yaw
    pitch = float(ypr[1]); // convert to float pitch
    roll = float(ypr[2]); // convert to float roll
  }
}
void drawArduino() {
  /* function contains shape(s) that are rotated with the IMU */
  stroke(0); // set outline colour to black
  fill(80); // set fill colour to dark grey
  textSize(50); 
  text("FORBOT.pl",-90,0);
}

import processing.serial.*;

Serial myPort;

int newLine = 13; // new line character in ASCII

float yaw;

float pitch;

float roll;

String message;

String [] ypr = new String [3];

void setup()

{

size(600, 500, P3D);

/*Set my serial port to same as Arduino, baud rate 9600*/

myPort = new Serial(this, Serial.list()[0], 9600);

textSize(16); // set text size

textMode(SHAPE); // set text mode to shape

}

void draw()

{

serialEvent(); // read and parse incoming serial message

background(255); // set background to white

translate(width/2, height/2); // set position to centre

pushMatrix(); // begin object

rotateX(pitch); // RotateX pitch value

rotateY(-yaw); // yaw

rotateZ(-roll); // roll

drawArduino(); // function to draw rough Arduino shape

popMatrix(); // end of object

// Print values to console

print(pitch);

print("\t");

print(roll);

print("\t");

print(-yaw);

println("\t");

myPort.write("s"); // write an "s" to receive more data from Arduino

}

void serialEvent()

{

message = myPort.readStringUntil(newLine); // read from port until new line (ASCII code 13)

if (message != null) {

ypr = split(message, ","); // split message by commas and store in String array

yaw = float(ypr[0]); // convert to float yaw

pitch = float(ypr[1]); // convert to float pitch

roll = float(ypr[2]); // convert to float roll

}

void drawArduino() {

/* function contains shape(s) that are rotated with the IMU */

stroke(0); // set outline colour to black

fill(80); // set fill colour to dark grey

textSize(50);

text("FORBOT.pl",-90,0);

}

Podsumowanie pierwszego projektu na Genuino 101

Tak jak wspomniałem na początku, było to moje pierwsze zetknięcie z Genuino 101 w praktyce. Dlatego nie pisałem kodu samodzielnie. Starałem się szybko uzyskać ciekawy efekt i mam wrażenie, że cel został osiągnięty.

Genuino 101, fot. materiały prasowe.

Do tej pory nie nie napotkałem żadnej trudności podczas pracy z tą płytką. Możliwe, że kłopoty pojawią się później - podczas pisania własnych programów. Na ten moment mogę powiedzieć, że Intel stanął na wysokości zadania i Genuino wyposażone w Intel Curie działa bardzo przyjemnie.

Różnice względem UNO?

Po kilku godzinach zabawy z 101 mogę wskazać już kilka różnic względem Arduino UNO. Nie chodzi tutaj o parametry, które wypunktowałem na początku, jednak o sprawy, na które wcześniej nie zwróciłem uwagi.

Po pierwsze inaczej wygląda proces wgrywania programu na płytkę, a każdy szkic (nawet zwykłe miganie diodą) startuje dopiero po 5 sekundach od wgrania. Po drugie na płytce znajdziemy dwa przyciski reset:

Reset - odpowiednik resetu na Arduino UNO,
Master reset - przycisk resetujący cały moduł Curie.

Dwa przyciski reset na lewej krawędzi płytki.

Trzecią różnicą jest technologia wykonania płytki. Jak widać na zdjęciach elementy zastosowane w Genuino 101 są typu SMD oraz BGA. Ścieżki są niesamowicie cienkie i delikatne, więc można zapomnieć o własnych naprawach i modyfikacjach - chyba, że jesteśmy już doświadczonymi majsterkowiczami.

Na sam koniec pokusiłem się również o sprawdzenie prędkości GPIO. Może nie wszyscy zdają sobie z tego sprawę, jednak im potężniejszy układ, tym operacje na GPIO mogą być wolniejsze od zwykłej ATmegi. Nawet jeśli większy układ może pochwalić się znacznie wyższym taktowaniem. Jest to spowodowane innym sposobem dostępu do GPIO, emulacją, systemem operacyjnym itd.

Dlatego na obu płytkach uruchomiłem kod, który bez opóźnień miał zmieniać stan jednego z wyjść. Częstotliwość zmian zmierzyłem multimetrem uniwersalnym.

void setup() {
  pinMode(2, OUTPUT);
}

void loop() {
  digitalWrite(2, !digitalRead(2));
}

void setup() {

pinMode(2, OUTPUT);

}

void loop() {

digitalWrite(2, !digitalRead(2));

}

Wyniki prezentują się tak:

	Arduino UNO	Genuino 101
Częstotliwość zmian GPIO	~59kHz	~90kHz

Następnie pomiar powtórzyłem dla innej wersji kodu:

void setup() {
  pinMode(2, OUTPUT);
}

void loop() {
  digitalWrite(2, 0);
  digitalWrite(2, 1);
}

void setup() {

pinMode(2, OUTPUT);

}

void loop() {

digitalWrite(2, 0);

digitalWrite(2, 1);

}

Taka optymalizacja programu pozwoliła na osiągnięcie większej częstotliwości:

	Arduino UNO	Genuino 101
Częstotliwość zmian GPIO	~94kHz	~170kHz

W obu przypadkach zawieść mógł nienajlepszy sprzęt pomiarowy.
Jednak najważniejsze, że widać tendencję - Genuino 101 jest szybsze.

Wynik ten zaskoczył mnie pozytywnie, ponieważ obawiałem się, że RTOS zaimplementowany na Curie wraz z "emulatorem" Arduino może wprowadzać opóźnienia. Genuino 101 okazało się jednak znacznie szybsze.

Na sam koniec zmierzyłem jeszcze pobór prądu. W przypadku Arduino UNO było to 48mA, natomiast dla Genuino 101 miernik wskazał 92mA. Jednak są to pomiary dla tego samego kodu. Możliwe, że wprzypadku Genuino należałoby jeszcze (dla równych szans) wyłączyć czujniki i moduł Bluetooth. Tego jeszcze nie sprawdziłem.

Czekam na komentarze i pytania związane z Genuino. Myślę jednak, że więcej szczegółów będę mógł opowiedzieć, gdy posiedzę nad płytką trochę dłużej.

Artykuł był ciekawy?

Dołącz do 20 tysięcy osób, które otrzymują powiadomienia o nowych artykułach! Zapisz się, a otrzymasz PDF-y ze ściągami (m.in. na temat mocy, tranzystorów, diod i schematów) oraz listę inspirujących DIY na bazie Arduino i Raspberry Pi.