Strona używa cookies (ciasteczek). Dowiedz się więcej o celu ich używania i zmianach ustawień. Korzystając ze strony wyrażasz zgodę na używanie cookies, zgodnie z aktualnymi ustawieniami przeglądarki.    X

intel Galileo - programowanie i obsługa GPIO w Arduino IDE

intel Galileo posiada identyczny układ złącz GPIO jak w Arduino UNO R3, do którego pasują takie same moduły i skorupki (shield) jak w R3. Programowanie wygląda identycznie jak z każdym innym Arduino za pomocą specjalnej wersji Arduino IDE. intel Galileo posiada również możliwość sterowania pinami z poziomu systemu Linux, ale dziś skupimy się na programowaniu za pomocą Arduino IDE.

Poniżej przestawiam programy do sterowania urządzeniami. Ma to na celu pokazania tylko możliwości sterowania tymi urządzeniami przez intel Galileo, dlatego opisy i schematy podłączenia nie są szerzej opisane jak w typowych poradnikach.

Sterowanie diodami i przekaźnikami

Sterowanie diodami i przekaźnikami odbywa się na zasadzie ustawienia stanów wysokich (włączony) i niskich (wyłączony) na danym cyfrowym pinie.

r   e   k   l   a   m   a

Dioda RGB

Przykładowy program sterujący diodą RGB wykorzystuje 3 piny cyfrowe oraz jeden pin GND. Ustawienie jednego z pinów na wysoki daje na każdym inny kolor.

Dioda RGB posiada cztery nóżki z czego najdłuższa jest nóżka GND trzy pozostałe to kolory czerwony, zielony i niebieski.


// Ustawiamy nazwy trzech pinów z których będziemy korzystać
int red = 2; 
int green = 5;
int blue = 6;

void setup() {
// ustawiamy piny jako wyjściowe
  pinMode(red, OUTPUT);  
  pinMode(green, OUTPUT);
  pinMode(blue, OUTPUT);
}

void loop() {
//ustawiamy czerwony pin na stan wysoki, zaś pozostałe na stan niski
  digitalWrite(red, HIGH);
  digitalWrite(green, LOW);
  digitalWrite(blue, LOW);
  delay(2000); // czekamy 2 sekundy
  
// ustawiamy stan wysoki na pinie zielonym, na pozostałych niski
  digitalWrite(red, LOW);
  digitalWrite(green, HIGH);
  digitalWrite(blue, LOW);
  delay(2000); // czekamy 2 sekundy
  
// ustawiamy stan wysoki na pinie niebieskim, na pozostałych niski
  digitalWrite(red, LOW);
  digitalWrite(green, LOW);
  digitalWrite(blue, HIGH);
  delay(2000);
}

Po uruchomieniu dioda będzie co dwie sekundy zmieniać kolor świecenia.

Moduł przekaźnikowy

Za pomocą przekaźników możemy sterować zasilaniem różnych urządzeń np. lampami. Sterowanie nimi polega na ustawieniu pinu na stan wysoki gdzie przez układ popłynie prąd, który za pomocą cewki w przekaźniku przełącza włącznik. Więcej informacji o działaniu przekaźnika można przeczytać na wikipedii

Podłączenie wygląda tak że podłączamy piny z intel Galileo do modułu odpowiednio:


  • 5V <> VCC
  • Pin7 <> In1
  • Pin8 <> In2
  • GND <> GND


// ustawiamy numery pinów którymi będziemy sterować
int in1 = 7; 
int in2 = 8;

void setup() {
 //ustawiamy te piny na wyjście
  pinMode(in1, OUTPUT);  
  pinMode(in2, OUTPUT);
}
void loop() {
  //ustawiamy oba piny na stan niski
  digitalWrite(in1, LOW);
  digitalWrite(in2, LOW);
  delay(2000); // czekamy 2 sekundy
  
  // ustawiamy pin In1 na stan wysoki
  digitalWrite(in1, HIGH);
  digitalWrite(in2, LOW);
  delay(2000); // czekamy 2 sekundy
  
  // ustawiamy oba piny na stan wysoki
  digitalWrite(in1, HIGH);
  digitalWrite(in2, HIGH);
  delay(2000); // czekamy 2 sekundy
  
  // ustyawiamy pin In2 na stan wysoki a drugi na niski
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);
  delay(2000); // czekamy 2 sekundy
}

Po wgraniu programu nasze przekaźniki będą się włączać po kolei i wyłączać.

Sterowanie silnikiem krokowym i serwem

Silnik krokowy

Do prezentacji wykorzystałem silnik krokowy 28BYJ-48 mający przekładnię 68:1. Silnik sterowany jest za pomocą kontrolera ULN2003. Czym jest silnik krokowy oraz jak działa odsyłam na wikipedie.

Sterowanie polega na zmianie stanów wysokich na każdym z czterech pinów. Dlatego potrzebować będziemy aż czterech pinów z intel Galileo.


//ustawiamy numery pinów które będziemy używać do sterowania silnikiem
int Pin0 = 10; 
int Pin1 = 11; 
int Pin2 = 12; 
int Pin3 = 13; 
void setup() 
{ //ustawiamy piny jako wyjściowe
 pinMode(Pin0, OUTPUT);  
 pinMode(Pin1, OUTPUT);  
 pinMode(Pin2, OUTPUT);  
 pinMode(Pin3, OUTPUT);  
} 
 void loop() 
{ 
 //ustawiamy stan wysoki  tylko na pierwszym pinie
     digitalWrite(Pin0, HIGH); 
     digitalWrite(Pin1, LOW); 
     digitalWrite(Pin2, LOW); 
     digitalWrite(Pin3, LOW); 
delay(1);  // czekamy 1 milisekundę
 //ustawiamy stan wysoki  tylko na drugim pinie
     digitalWrite(Pin0, LOW);  
     digitalWrite(Pin1, HIGH); 
     digitalWrite(Pin2, LOW); 
     digitalWrite(Pin3, LOW); 
delay(1); 
 //ustawiamy stan wysoki  tylko na trzecim pinie
     digitalWrite(Pin0, LOW);  
     digitalWrite(Pin1, LOW); 
     digitalWrite(Pin2, HIGH); 
     digitalWrite(Pin3, LOW); 
delay(1); 
 //ustawiamy stan wysoki  tylko na czwartym pinie
     digitalWrite(Pin0, LOW);  
     digitalWrite(Pin1, LOW); 
     digitalWrite(Pin2, LOW); 
     digitalWrite(Pin3, HIGH); 
delay(1); 
}

Po wgraniu programu nasz silnik zacznie się obracać.

Serowo

Serwo działa podobnie jak silnik krokowy tyle tylko , że do samego sterowania używa się jednego złącza, na które ustawia się sygnał o danej częstotliwości. Zazwyczaj serwa maja obrót ustawiony tylko na 90 lub 180 stopni, choć są i obrotowe w 360 stopniach.
Czym jest serwomechanizm i jak działa odsyłam na wikipedie.

Do naszego przykładu użyłem serwa redox s90 mające obrót o 90 stopni.
Serwo ma trzy złącza: czarne (GND), czerwone (zasilanie 5V) oraz białe do sterowania, które podłączamy do pinu trzeciego w Galileo.


#include <Servo.h>
#include <Wire.h> 

Servo servoMain; // Definiujemy nasze serwo

void setup()
{
   servoMain.attach(3); // ustawiamy pin 3 do sterowania serwem
}

void loop()
{
   servoMain.write(0);   // ustawiamy serwo na położenie 0 stopni
   delay(1000);          // czekamy 1 sekundę
   servoMain.write(180); // ustawiamy serwo na wychylenie pełne
   delay(1000);          // czekamy 1 sekundę
  }

Po wgraniu programu nasze serwo zacznie się obracać wahadłowo.

Podsumowanie

Przykłady, które przedstawiłem są tylko kroplą w morzu możliwości i jesteśmy w stanie sterować dużą ilością przeróżnych czujników, sterowników, modułów i układów m.in silnikami i jego obrotami za pomocą złącza PWM. Zainteresowanych większą ilością funkcji i możliwości sterowania odsyłam do strony z opisami funkcji i przykładami.

Poniżej przedstawiam nagranie wyniku działania powyższych programów.

Wcześniejsze części:

W kolejnej części przybliżę możliwość programowania z poziomu systemu Linux zainstalowanego na intel Galileo.

Jeśli znalazłeś błąd, zgłoś go w komentarzu.

Wpis powstał w ramach akcji DP i Intela "Przetestuj sprzęt od Intela" dlatego przy okazji dziękuję za dostarczenie płytki do testów.  

linux sprzęt programowanie

Komentarze