Som Labs - IMx6 ULL - Debian - Obsługa portu GPIO na przykładzie diody oraz przycisku

W tym poście chciałbym opisać obsługę portów GPIO na przykładzie diody oraz przycisku zamontowanych na płycie

[Źródło: https://somlabs.com/product/visionsom-6ull/]

Obsługa portów GPIO możliwa jest dzięki sterownikom jądra systemu Linux. Do dyspozycji są piny zdefiniowane jako Led Class Driver jako wyjście, oraz piny wejściowe GPIO Buttons. 

Zamiast sterownika dedykowanego dla wejścia lub wyjścia można wykorzystać ogólny sterownik pinów GPIO.

Diody led zostały podłączone pod wyprowadzenia GPIO10 (Dioda niebieska), GPIO11 (Dioda zielona), GPIO12 (Dioda żółta), GPIO13 (Dioda czerwona). Przyciski natomiast to piny GPIO3, GPIO4, GPIO8, GPIO9.

Zmiany w Device Tree [1]:

W celu uzyskania dostępu do diod należy wprowadzić zmiany w Device Tree. W tym celu najlepiej
posłużyć się systemem obsługiwanym z Linuxa.

Na samym początku należy pobrać obrazVisionSom-6ULL:

1. sudo apt install qemu-user-static
2. wget http://ftp.somlabs.com/somlabs-visionsom-6ull-debian-rootfs-qemu.tar.xz
3. sudo tar -xvf somlabs-visionsom-6ull-debian-rootfs-qemu.tar.xz
4. sudo cp /etc/hostname ~/somlabs-debian/etc/hostname
5. sudo cp /etc/hosts ~/somlabs-debian/etc/hosts
6. sudo ./somlabs-debian/chtoolchain

Kolejnym elementem jest zbudowanie jądra systemu oraz wykonanie komendy make. W tym celu należy przejść do odpowiedniego folderu:

1. cd /home/developer/source/kernel/linux-rel_imx_4.1.15_2.1.0_ga

Po czym wykonać operację kopiowania domyślnej konfiguracji do folderu z jądrem systemu:

1. cp /home/developer/source/somlabs-dts-1.0/visionsom-6ull-linux_defconfig /home/developer/source/kernel/linux-rel_imx_4.1.15_2.1.0_ga/.config

Teraz można już uruchomić polecenie make z folderu do którego została skopiowana konfiguracja (/home/developer/source/kernel/linux-rel_imx_4.1.15_2.1.0_ga):

1. make deb-pkg -j8 CFLAGS_MODULE = -fno-pic

Po poprawnym wykonaniu powyższej czynności można przejść do modyfikacji Device Tree:

1. nano /home/developer/source/somlabs-dts-1.0/somlabs-visionsom-6ull.dts

Poniżej opiszę tylko udostępnienie dla użytkownika  pinów odpowiedzialnych za diody. Ponieważ domyślnie są one niedostępne. Inne sterowniki obsługą je do wyświetlania informacji np. o działającej transmisji danych.

Przyciski są automatycznie udostępnione wiec ich nie trzeba modyfikować.

W pliku należy znaleźć następujące informacje:

1. leds{
2.     compatible = "gpio-leds";
3.     usr0 {
4.         label = "usr0";
5.         gpios = <&gpio1 10 GPIO_ACTIVE_HIGH>;
6.         linux,default-trigger = "heartbeat";
7.     };
9.     usr1 {
10.         label = "usr1";
11.         gpios = <&gpio1 11 GPIO_ACTIVE_HIGH>;
12.         linux,default-trigger = "mmc0";
13.     };
15.     usr2 {
16.         label = "usr2";
17.         gpios = <&gpio1 13 GPIO_ACTIVE_HIGH>;
18.         linux,default-trigger = "mmc1";
19.     };
21.     usr3 {
22.         label = "usr3";
23.         gpios = <&gpio1 12 GPIO_ACTIVE_HIGH>;
24.     };
25. };

Aby udostępnić sterowanie pinami dla użytkownika to należy zakomentować odpowiednie części (usr0...usr3) znajdujące się wewnątrz nawiasów klamrowych dla definicji leds. Domyślnie są one przypisane do podsystemu, sterownika gpio-leds i sterowanie jest przeprowadzane przez domyślny trigger.

W celu sprawdzenia pozostałych definicji odpowiednich pinów oraz funkcji jakie są udostępnione poszczególnym pinom można sprawdzić w poniższym pliku:

1. /home/developer/source/kernel/linux-rel_imx_4.1.15_2.1.0_ga/arch/arm/boot/dts/imx6ul-pinfunc.h

Następnym elementem jest stworzenie pakietu Debiana:

1. cd /home/developer/source/somlabs-dts-1.0/
2. /home/developer/source/somlabs-dts-1.0# dpkg-buildpackage -us -uc

Teraz należy przesłać plik na urządzenie:

1. scp /home/developer/source/somlabs-dts_1.0.0_armhf.deb root@<IP_ADDR_SOMLABS>:/root/

W celu sprawdzeniu adresu IP urządzenia można skorzystać z jednej z dwóch komend:

1. hostname -I
2. //lub
3. ip a

Po przesłaniu pliku na płytkę należy zainstalować pakiet następującym poleceniem (tą komendę należy wywołać na płycie somlabs a nie na ubuntu jak wcześniejsze):

1. dpkg -i /root/somlabs-dts_1.0.0_armhf.deb

Gdy już operacja zostanie zakończona to w celu załadowania ustawień należy ponownie uruchomić system (np. polecenie reboot). Po ponownym uruchomieniu systemu można przejść do konfiguracji.

Sterowanie pinami polecenia konsoli:

Poniżej chciałbym opisać sposobu konfiguracji i obsługi pinów przez polecenia skryptowe. Na samym początku obsługa diod czyli gpio jako wyjście.

Dostęp do danych udostępnianych przez sterownik GPIO należy szukać w folderze:

1. cd /sys/class/gpio/

W opisanym folderze znajdują się dwa ważne pliki tzn. export oraz unexport. Dzięki nim można zająć lub zwolnić podane wyprowadzenie dla przestrzeni użytkownika. Oczywiście dane wyprowadzenie nie może być już wykorzystywane przez inny sterownik. Dlatego należało wykonać zmiany wyprowadzeń w Device Tree.

Aby wyeksportować dane wyprowadzenie należy wywołać polecenie:

1. echo 12 > /sys/class/gpio/export
2. //lub jesli wskaźnik jest juz w folderze gpio to
3. echo 12 > export

Po tej operacji zostaje stworzony folder z opisem danego wyprowadzenia (dla gpio 12 będzie to folder gpio12 itp. itd.).

Teraz można przejść do utworzonego folderu wykorzystując następującą komendę:

1. cd /sys/class/gpio/gpio12

Po tej operacji można wyświetlić informację z dostępnymi parametrami:

Najważniejsze z udostępnionych przez system plików to direction, value oraz edge. Poniżej krótki opis każdego z nich:

plik direction - odpowiada za kierunek działania danego wyprowadzenia (in/out)

plik value - odpowiada za ustawienie odpowiedniego stanu na pinie wyjściowym. W przypadku ustawienia jako wejścia ten plik będzie przechowywał aktualny stan na linii.

plik edge - pozwala na określenie jakie zbocze będzie wyzwalało zmianę stanu na linii. Dopuszczalne parametry do wpisania to none, rising, falling lub both.

Wobec tego w celu wybrania kierunku należy wprowadzić w konsoli następującą komendę:

1. //Jako wejście (np. przyciski)
2. echo in > /sys/class/gpio/gpio12/direction
3. //Jako wyjście (np. diody)
4. echo out > /sys/class/gpio/gpio12/direction

Po ustawieniu kierunku należy wprowadzić odpowiedni stan:

1. //Ustawienie stanu wysokiego
2. echo 1 > /sys/class/gpio/gpio12/direction
3. //Ustawienie stanu niskiego
4. echo 0 > /sys/class/gpio/gpio12/direction

Gdy ustawiony jest pin jako wyjściowy to stan linii można odczytać następującą komendą:

1. cat /sys/class/gpio/gpio12/value

W celu wywołania poniższych skryptów wystarczy wpisać:

1. /root/blink.sh

Prosty skrypt pozwalający na obsługę dostępnych diod może wyglądać następująco:

1. #!/bin/sh
3. SLEEP="/bin/sleep"
4. GpioData=/sys/class/gpio/gpio12
6. while true ; do
7.         echo 1 > $GpioData/value
8.         $SLEEP 1
9.         echo 0 > $GpioData/value
10.         $SLEEP 1
11. done

W celu obsługi większej liczby wyprowadzeń wystarczy rozbudować nieco skrypt dodając pozostałe wartości:

1. #!/bin/sh
3. LED1=10
4. LED2=11
5. LED3=12
6. LED4=13
7. SLEEP="/bin/sleep"
8. GPIOVALUE_1=/sys/class/gpio/gpio$LED1
9. GPIOVALUE_2=/sys/class/gpio/gpio$LED2
10. GPIOVALUE_3=/sys/class/gpio/gpio$LED3
11. GPIOVALUE_4=/sys/class/gpio/gpio$LED4
13. echo 0 > $GPIOVALUE_1/value
14. echo 0 > $GPIOVALUE_2/value
15. echo 0 > $GPIOVALUE_3/value
16. echo 0 > $GPIOVALUE_4/value
18. while true ; do
19.         echo 1 > $GPIOVALUE_1/value
20.         $SLEEP 1
21.         echo 1 > $GPIOVALUE_2/value
22.         $SLEEP 1
23.         echo 1 > $GPIOVALUE_3/value
24.         $SLEEP 1
25.         echo 1 > $GPIOVALUE_4/value
26.         $SLEEP 1
27.         echo 0 > $GPIOVALUE_4/value
28.         $SLEEP 1
29.         echo 0 > $GPIOVALUE_3/value
30.         $SLEEP 1
31.         echo 0 > $GPIOVALUE_2/value
32.         $SLEEP 1
33.         echo 0 > $GPIOVALUE_1/value
34.         $SLEEP 1
35. done

Przed użyciem powyższych dwóch skryptów należy uruchomić wyprowadzenia poleceniem export, oraz ustawić kierunek jako wyjściowy.

Tutaj należy pamiętać, że po ponownym uruchomieniu komputera zmiany zapisane w plikach /sys/class/gpio/ ulegną usunięciu. Wobec tego lepiej stosować skrypt ustawiający dane wyprowadzenia w odpowiednim stanie.

Nieco rozbudowana wersja uruchamiająca dane wyprowadzenie oraz ustawiająca kierunek działania:

1. #!/bin/sh
3. SLEEP="/bin/sleep"
5. GPIO_EXPORT=/sys/class/gpio/export
7. LED1=10
8. LED2=11
9. LED3=12
10. LED4=13
12. GPIOVALUE_1=/sys/class/gpio/gpio$LED1
13. GPIOVALUE_2=/sys/class/gpio/gpio$LED2
14. GPIOVALUE_3=/sys/class/gpio/gpio$LED3
15. GPIOVALUE_4=/sys/class/gpio/gpio$LED4
17. if [ ! -d "$GPIOVALUE_1" ]; then
18.         echo "Export GPIO$LED1"
19.         echo $LED1 > $GPIO_EXPORT
20. else
21.         echo "GPIO$LED1 exported"
22. fi
24. if [ ! -d "$GPIOVALUE_2" ]; then
25.         echo "Export GPIO$LED2"
26.         echo $LED2 > $GPIO_EXPORT
27. else
28.         echo "GPIO$LED2 exported"
29. fi
31. if [ ! -d "$GPIOVALUE_3" ]; then
32.         echo "Export GPIO$LED3"
33.         echo $LED3 > $GPIO_EXPORT
34. else
35.         echo "GPIO$LED3 exported"
36. fi
38. if [ ! -d "$GPIOVALUE_4" ]; then
39.         echo "Export GPIO$LED4"
40.         echo $LED4 > $GPIO_EXPORT
41. else
42.         echo "GPIO$LED4 exported"
43. fi
45. echo "Set pin as output"
46. echo out > $GPIOVALUE_1/direction
47. echo out > $GPIOVALUE_2/direction
48. echo out > $GPIOVALUE_3/direction
49. echo out > $GPIOVALUE_4/direction
51. echo "Set pin state to low"
52. echo 0 > $GPIOVALUE_1/value
53. echo 0 > $GPIOVALUE_2/value
54. echo 0 > $GPIOVALUE_3/value
55. echo 0 > $GPIOVALUE_4/value
57. echo "Enter into while loop"
58. while true ; do
59.         echo 1 > $GPIOVALUE_1/value
60.         $SLEEP 1
61.         echo 1 > $GPIOVALUE_2/value
62.         $SLEEP 1
63.         echo 1 > $GPIOVALUE_3/value
64.         $SLEEP 1
65.         echo 1 > $GPIOVALUE_4/value
66.         $SLEEP 1
67.         echo 0 > $GPIOVALUE_4/value
68.         $SLEEP 1
69.         echo 0 > $GPIOVALUE_3/value
70.         $SLEEP 1
71.         echo 0 > $GPIOVALUE_2/value
72.         $SLEEP 1
73.         echo 0 > $GPIOVALUE_1/value
74.         $SLEEP 1
75. done

Na samym początku skrypt sprawdza czy dane wyprowadzenie zostało już wyeksportowane, jeśli to to następuje wyeksportowanie danego wyprowadzenia. Po przejściu przez cztery piny dla diod ustawiany jest kierunek działania jako wyjście. Następnie piny ustawione zostają w stan niski i następuje wejście do pętli while wykonującej zapalanie oraz gaszenie diod.

Takie rozwiązanie pozwoli na uruchomienie skryptów zaraz po starcie systemu, dzięki temu nie będzie konieczności wprowadzania ręcznie informacji do sterownika gpio.

W celu obsługi przycisku należy wykonać następujące operacje:

1. echo 4 > /sys/class/gpio/export
2. echo in > /sys/class/gpio/gpio4/direction

Po takiej operacji ustawianą wartość przez przycisk można sprawdzić za pomocą polecenia cat. I tak przy nie wciśniętym przycisku wartość jest 1. Po jego kliknięciu wartość zmienia się na 0:

Teraz do skryptu dołożę obsługę przycisku tak aby po kliknięciu został przesłany tekst na wyświetlacz:

1. #!/bin/sh
3. SLEEP="/bin/sleep"
5. GPIO_EXPORT=/sys/class/gpio/export
7. BUTTONPIN=4
9. INPUTVALUE=/sys/class/gpio/gpio$BUTTONPIN
11. if [ ! -d "$INPUTVALUE" ]; then
12.         echo "Export Button on GPIO$BUTTONPIN"
13.         echo $BUTTONPIN > $GPIO_EXPORT
14. else
15.         echo "Button on GPIO$BUTTONPIN exported"
16. fi
18. echo "Button config"
19. echo in > $INPUTVALUE/direction
21. echo "Enter into while loop"
23. while true ; do
24.         var="$(cat $INPUTVALUE/value)"
25.         if [ $var -eq 0 ]; then
26.                 echo "Button Clicked"
27.         fi
28. done

Sterowanie pinami w c:

Poniżej przejdę do przedstawienia prostego programu pozwalającego na obsługę wyprowadzeń GPIO jako in/out.

Tutaj operacje wyglądają podobnie co przy plikach skryptowych. To znaczy dalej trzeba wyeksportować dane wyprowadzenie dla użytkownika, następnie trzeba ustawić kierunek i dopiero wtedy można przejść do zmiany wartości na pinie.

Poniżej przykład pozwalający na sterowanie diodami:

Funkcja odpowiedzialna za włączenie danego wyprowadzenia do przestrzeni użytkownika:

1. static int gpioExportPin(unsigned int gpioPinNumber)
2. {
3.         int fileDesc = -1;
4.         int writeBufferSize = -1;
5.         char buf[50] = {0x00};
7.         //Open file
8.         fileDesc = open(GPIO_MAIN_DIR "/export", O_WRONLY);
10.         //Check if operation error
11.         if(fileDesc < 0)
12.         {
13.                 perror("File gpio - export Error");
14.                 return fileDesc; //-1
15.         }
17.         //Prepare buffer
18.         writeBufferSize = snprintf(buf, sizeof(buf), "%d", gpioPinNumber);
19.         write(fileDesc, buf, writeBufferSize);
20.         close(fileDesc);
21.         return 0;
22. }

Operacje jak już wspomniałem wcześniej dotyczą operacji na plikach. Tym razem tylko nie są one wykonywane przez bash a przez instrukcję w języku C. Na samym początku zostaje otwarty plik export do którego zostaje wprowadzony numer pinu jaki ma być dostępny dla użytkownika.

Kolejna niezbędna funkcja pozwala na ustawienie kierunku działania danego wyprowadzenia:

1. static int gpioSelectDirection(unsigned int gpioPinNumber,  unsigned int gpioDi$
2. {
3.         int fileDesc = -1;
4.         char buf[100] = {0x00};
6.         snprintf(buf, sizeof(buf), GPIO_PIN_DIR "%d/direction", gpioPinNumber);
8.         fileDesc = open(buf, O_WRONLY);
10.         //Check FileDesc
11.         if (fileDesc < 0)
12.         {
13.                 perror("Write gpio - direction Error");
14.                 return fileDesc; //-1
15.         }
17.         //Write Direction to file
18.         if(gpioDirection == GPIO_OUT)
19.         {
20.                 write(fileDesc, "out", sizeof("out"));
21.         }
22.         else
23.         {
24.                 write(fileDesc, "in", sizeof("in"));
25.         }
27.         close(fileDesc);
28.         return 0;
29. }

Funkcja pozwalająca na ustawienie stanu wysokiego lub niskiego:

1. static int gpioSetValue(unsigned int gpioPinNumber, unsigned int gpioPinValue)
2. {
3.         int fileDesc = -1;
4.         char buf[100] = {0x00};
6.         snprintf(buf, sizeof(buf), GPIO_PIN_DIR "%d/value", gpioPinNumber);
8.         fileDesc = open(buf, O_WRONLY);
10.         if(fileDesc < 0)
11.         {
12.                 perror ("FileDescriptor gpio set value ERROR");
13.                 return fileDesc;
14.         }
16.         if (gpioPinValue == 1) //high
17.         {
18.                 write(fileDesc, "1", sizeof("1"));
19.         }
20.         else    //low
21.         {
22.                 write(fileDesc, "0", sizeof("0"));
23.         }
25.         close(fileDesc);
26.         return 0;
27. }

Poniżej sterowanie wszystkimi pinami z podłączonymi diodami (od IO10 do IO13):

1. int main (void)
2. {
3.         if((gpioExportPin(GPIO_PIN_10) < 0) ||
4.            (gpioExportPin(GPIO_PIN_11) < 0) ||
5.            (gpioExportPin(GPIO_PIN_12) < 0) ||
6.            (gpioExportPin(GPIO_PIN_13) < 0))
7.         {
8.                 exit (EXIT_FAILURE);
9.         }
11.         if((gpioSelectDirection(GPIO_PIN_10, GPIO_OUT) < 0) ||
12.            (gpioSelectDirection(GPIO_PIN_11, GPIO_OUT) < 0) ||
13.            (gpioSelectDirection(GPIO_PIN_12, GPIO_OUT) < 0) ||
14.            (gpioSelectDirection(GPIO_PIN_13, GPIO_OUT) < 0))
15.         {
16.                 exit (EXIT_FAILURE);
17.         }
19.         while (1)
20.         {
21.                 gpioSetValue(GPIO_PIN_10, 1);
22.                 gpioSetValue(GPIO_PIN_11, 1);
23.                 gpioSetValue(GPIO_PIN_12, 1);
24.                 gpioSetValue(GPIO_PIN_13, 1);
26.                 sleep (5);
28.                 gpioSetValue(GPIO_PIN_10, 0);
29.                 gpioSetValue(GPIO_PIN_11, 0);
30.                 gpioSetValue(GPIO_PIN_12, 0);
31.                 gpioSetValue(GPIO_PIN_13, 0);
33.                 sleep (5);
34.         }
35.         return EXIT_SUCCESS;
36. }

Teraz przejdę do opisu obsługi przycisku. Tutaj podobnie jak w przypadku wersji dla bash należy odczytać dane z pliku value gdzie sprawdzany będzie aktualny stan pinu. W przykładzie wykorzystam przycisk podłączony pod pin 4.

Sprawdzanie przycisku będzie polegało na sprawdzaniu stanu zbocza w oparciu o funkcję asynchronicznego wejścia/wyjścia zdefiniowane w bibliotece poll.h.

Na samym początku należy ustawić zbocze jakim będzie wyzwalane przerwanie:

1. static int gpioSelectEdge(unsigned int gpioPinNumber, char *gpioEdge)
2. {
3.         int fileDesc;
4.         char buf[70];
6.         snprintf(buf, sizeof(buf), GPIO_PIN_DIR "%d/edge", gpioPinNumber);
7.         fileDesc = open(buf, O_WRONLY);
9.         if(fileDesc < 0)
10.         {
11.                 perror ("Set gpio - edge ERROR");
12.                 return fileDesc;
13.         }
15.         if(gpioEdge == 1) //RISING
16.         {
17.                 write(fileDesc, "rising", sizeof("rising"));
18.         }
19.         else if(gpioEdge == 2) //FALLING
20.         {
21.                 write(fileDesc, "falling", sizeof("falling"));
22.         }
23.         else //BOTH
24.         {
25.                 write(fileDesc, "both", sizeof("both"));
26.         }
28.         close(fileDesc);
29.         return 0;
30. }

Tutaj następuje edycja pliku edge. Dla przypomnienia jako parametr można wprowadzić rising, falling lub both.

W celu uzyskania wartości z pliku value wykorzystam funkcję przekazującą deskryptor do otwartego pliku value.

1. static int gpioValueFileDesc(unsigned int gpioPinNumber)
2. {
3.         int fileDesc;
4.         char buf[60];
6.         snprintf(buf, sizeof(buf), GPIO_MAIN_DIR "%d/value", gpioPinNumber);
8.         fileDesc = open(buf, O_RDONLY | O_NONBLOCK);
10.         if(fileDesc < 0)
11.         {
12.                 perror("Open value file Error");
13.         }
14.         return fileDesc;
15. }

Plik należy odczytać tylko do odczytu, ponieważ będzie z niego pobierana wartość dla pinu. Dodatkowo należy umieścić flagę O_NONBLOCK otwierająca plik w trybie nieblokującym.

Funkcja main do pętli while wygląda następująco:

1. int main(void)
2. {
3.         struct pollfd pollFdStruct[1];
4.         int structNumbers = 1;
5.         int fileDesc = -1;
6.         int pollOperStat = 0;
7.         char buf[2] = {0x00};
9.         if (gpioExportPin(GPIO_PIN_BTN_4) < 0) {
10.                 exit(EXIT_FAILURE);
11.         }
13.         if (gpioSelectDirection(GPIO_PIN_BTN_4, GPIO_IN) < 0) {
14.                 exit(EXIT_FAILURE);
15.         }
17.         if (gpioSelectEdge(GPIO_PIN_BTN_4, 1) < 0) {
18.                 exit(EXIT_FAILURE);
19.         }
21.         fileDesc = gpioValueFileDesc(GPIO_PIN_BTN_4);
22.         if (fileDesc < 0){
23.                 exit(EXIT_FAILURE);
24.         }
26.         //Set offset
27.         lseek(fileDesc, 0, SEEK_SET);
28.        
29.         //ReadFile
30.         read(fileDesc, &buf, 2);
31.         printf(&buf);
33.         //Struct Descriptor
34.         //Write file descriptor to file
35.         pollFdStruct[0].fd = fileDesc;
36.         //Set event flag
37.         //High priority data may be read without blocking
38.         pollFdStruct[0].events = POLLPRI;
39.         pollFdStruct[0].revents = -1;
41.         //...
42.         //...
43. }

Po deklaracji pinu oraz odczycie deskryptora dla pliku value należy przygotować dane dla struktury pollfd.

Do niej wprowadzany jest deskryptor  do pliku value, rodzaj zdarzenia oraz jak długo nastąpi oczekiwanie na zdarzenie.

W pętli while następuje wywołanie funkcji poll po czym następuje sprawdzenie czy przycisk został wciśnięty po aktualizacji flagi w strukturze pollfd.

1. while (1)
2. {
3.     //Enable Poll, if success number > 0
4.     //if 0 then timeout
5.     pollOperStat = poll(pollFdStruct, structNumbers, 2000);
7.      //Check if Error occure
8.      if(pollOperStat < 0)
9.      {
10.         printf("poll function ERROR\n");
11.         break;
12.      }
13.      else if(pollOperStat == 0)
14.      {
15.          printf("poll function timeout\n");
16.      }
17.    
18.      if (pollFdStruct[0].revents & POLLPRI)
19.      {
20.         printf ("poll(): GPIO_%d interrupt occurred\n", GPIO_PI$
21.         lseek(pollFdStruct[0].fd, 0, SEEK_SET);
22.         read(pollFdStruct[0].fd, &buf, 2);
23.      }
24. }//close while
25. 
    
26. close(fileDesc);
27. return EXIT_FAILURE;
28. 
    
29. } //close main

Po wciśnięciu przycisku nastąpi aktualizacja danych w pliku value.

Programy opisane w tym poście dotyczące części języka C można pobrać z dysku Google pod tym linkiem.

[1] https://wiki.somlabs.com/index.php/How_to_customize_Debian_9.2_device_tree

[2] https://forbot.pl/blog/kurs-raspberry-pi-podstawy-gpio-skrypty-id23593