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 na systemie Linux

Z poziomu systemu Linux zainstalowanym na intel Galileo możemy programować np. w językach programowania C/C++, Python czy Bash, ale Galileo może bardziej przypaść do gustu programistom właśnie Pythona dając im możliwość programowania i sterowania pinami GPIO za pomocą ich ulubionego języka a wszystko dzięki dostępnej biblioteki pyGalileo.

Python

Dla języka Python społeczność przygotowała bibliotekę pyGalileo do sterowania pinami w intel Galileo.

Pobieramy bibliotekę ze strony projektu na GitHubie, a następnie rozpakowujemy i zmieniamy nazwę katalogu na pyGalileo. Następnie kopiujemy katalog (pyGalileo) na kartę microSD, którą przygotowaliśmy w poprzednim wpisie. Wkładamy kartę do złącza kart w Galileo i uruchamiamy płytkę.
Następnie logujemy się do naszego Galileo poprzez ssh. Możemy teraz skorzystać z gotowych przykładów znajdujących się w katalogu Examples lub samemu napisać program z wykorzystaniem biblioteki.

r   e   k   l   a   m   a

Uruchamiany prosty program blink.py za pomocą komendy


/media/mmcblk0p1/pyGalileo/Examples/blink.py

jest to przykładowy kod napisany za pomocą biblioteki, który ma za zadanie migać diodą na pinie 13


#!/usr/bin/env python
import sys

galileo_path = "/media/mmcblk0p1/";
if galileo_path not in sys.path:
    sys.path.append(galileo_path);

from pyGalileo import *

def setup():
    pinMode(led, OUTPUT);

def loop():
    digitalWrite(led, HIGH); #// turn the LED on (HIGH is the voltage level)
    delay(1000); #// wait for a second
    digitalWrite(led, LOW); #// turn the LED off by making the voltage LOW
    delay(1000); #// wait for a second

if __name__ == "__main__":
    led = 13;
    setup();
    while(1):
        loop();

Widać dość duże podobieństwa funkcji z Arduino IDE.

Dla zainteresowanych polecam przeglądnąć przykłady przygotowane przez autora biblioteki znajdujące na GitHub-ie

Bash

Możliwe jest sterowanie pinami z poziomu terminala a zarazem pisać skrypty w bashu. Jest to sterowane z wykorzystaniem wirtualnego systemu plików sysfs (podobnie jak w Raspberry Pi). Przedstawię trzy przykłady sterowania pinami.

Sterowanie stanami pinów IO

Przykładowo uruchomienie pinu 13 (GPIO39) na stan wysoki:


//eksportujemy pin aby można było go sterować z sysfs
echo -n "39" > /sys/class/gpio/export 

// Następnie ustawiamy pin jako wyjściowy dost opcje: out i in
echo -n "out" > /sys/class/gpio/gpio39/direction

// ustawia rodzaj pinu jako pullup, pulldown lub strong
//bez podawania tego domyślnie pin jest w stanie strong
echo -n "strong" > /sys/class/gpio/gpio39/drive

//polecenie pokazujące stan pinu
cat /sys/class/gpio/gpio39/value

//ustawienie pinu na stan wysoki
echo -n "1" > /sys/class/gpio/gpio39/value
// to samo tylko na stan niski
echo -n "0" > /sys/class/gpio/gpio39/value

Wykorzystanie funkcji PWM

intel Galileo posiada 8 pinów z funkcją PWM z czego tylko 6 pinów możemy użyć, aby zobaczyć ilość pinów wydajemy polecenie


// polecenie pokazuję ilość pinów pwm w naszym wypadku 8 ale tylko 6 jest do użycia
cat /sys/class/pwm/pwmchip0/npwm
8

Pokażę przykładowe uruchomienie pinu 3 (kanał PWM3)


// eksportujemy kanał 3 do sysfs
echo -n "3" > /sys/class/pwm/pwmchip0/export

// włączamy port wartość "1". Aby wyłączyć dajemy wartość "0"
echo -n "1" > /sys/class/pwm/pwmchip0/pwm3/enable

// ustawiamy częstotliwość odświerzania 1ms = 1000000
echo -n "1000000" > /sys/class/pwm/pwmchip0/pwm3/period

//ustawiamy pwm na 50% (500000/1000000*100%)
echo -n "500000" > /sys/class/pwm/pwmchip0/pwm3/duty_cycle

Za pomocą PWM możemy sterować np szybkością obrotów silników.

Piny Analogowe

Możliwe jest też sterowanie analogowymi pinami sterujac napięciem od 0 do 5V (0 do 4095)

Przykładowo aby ustawić wyjście pinu A0 (gpio37) analogowego na połowę mocy


// eksportujemy pin do sysfs
echo -n "37" > /sys/class/gpio/export

// ustawiamy pin jako wyjściowy
echo -n "out" > /sys/class/gpio/gpio37/direction

// ustawiamy wartość na połowę (zakres od 0 do 4095)
echo -n "2048" > /sys/class/gpio/gpio37/value

Dla bardziej rządnych wiedzy polecam blog malinov.com gdzie znajdziecie więcej przykładów, które autor owej strony opisuje na bieżąco.

Inne języki

Nie udało mi się znaleźć bibliotek chociażby do C czy C++ do sterowania pinami z poziomu Linuksa. Programowanie za pomocą tych języków z poziomu systemu Linux muszą być wykonywane na plikach tak jak ma to miejsce w przypadku poleceń w bash-u. Myślę że jest to kwestia czasu zanim społeczność lub sam Intel przygotuje taka bibliotekę.

Byłem pewien że system posiada biblioteki do sterowane przygotowane przez Intela ale niestety nigdzie nie znalazłem takiej informacji.

Więcej informacji oraz możliwość wymiany doświadczeń można znaleźć na stronie społeczności Intela.

Wcześniejsze części:

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