Prática 07
Prática GPIO
Identificando o Pino que o LED3 do Open-Smart Rich Shield está conectado no Módulo Colibri iMX8.
Acessar o diretório Lab/Documentacao.
Abrir o esquemático Rich Shield Schematic.pdf e identificar o pino do LED3.
Abrir o datasheet da AsterBoard colibri_arm_aster_carrier_board_datasheet.pdf (Pag. 22) e identificar o Pino SODIMM que o LED3 está conectado
Abrir o datasheet do Módulo Colibri iMX8 colibri_arm_som_imx8x_datasheet.pdf (Pag. 25 e 26) procurar a tabela de Pinout/PinMux e localizar o número SODIMM, em seguida, procurar pela coluna ALT4 o nome do GPIO deste pino.
Note
LED3 -> SODIMM_30 -> LSIO.GPIO0.IO22
Descobrindo o GPIO utilizando os comandos do libgpiod:
Executar no TARGET gpiodetect
gpioinfo 0
gpioinfo 1
Question
Procure na saída dos comandos acima onde ao executar um dos gpioinfo irá mostrar a referência para SODIMM_30.
Acionando o LED3 via terminal utilizando as ferramentas de GPIO da libgpiod - Kernel 5.x:
Executar no TARGET - Kernel 5.15 gpioset 1 22 = 0
gpioget 1 22
gpioset 1 22 = 1
gpioget 1 22
gpioset 1 22 = 0
Pode explorar os GPIO's disponiveis e em uso com:
Executar no TARGET gpioinfo
Exemplo de aplicação em C para manipular GPIO em Linux, use o exemplo abaixo BlinkLED:
BlinkLED BlinkLED tratando signal
Crie o arquivo /home/root/blinkLED.c no TARGET :
Executar no TARGET cd /home/root
touch blinkLED.c
Copie o conteúdo abaixo para blinkLED.c:
/*
* Aplicacao Blink LED
* Autor: Cleiton Bueno
* Data: 06/2023
*
* $ aarch64-tdx-linux-gcc blinkLED.c -o blinkLED -lgpiod
*
* Treinamento B2Open Systems
*/
#include <gpiod.h>
#include <stdio.h>
#include <unistd.h>
int main ( int argc , char ** argv )
{
printf ( "Iniciando aplicacao BlinkLED... \n " );
//
// Kernel 5.15
//
const char * chipname0 = "gpiochip1" ;
const char * chipname1 = "gpiochip2" ;
const char * chipname4 = "gpiochip5" ;
//
// Kernel 6.6
//
// const char *chipname0 = "gpiochip0";
// const char *chipname1 = "gpiochip1";
// const char *chipname4 = "gpiochip4";
struct gpiod_chip * chip0 ;
struct gpiod_chip * chip1 ;
struct gpiod_chip * chip4 ;
struct gpiod_line * lineRed ; // Red LED
struct gpiod_line * lineGreen ; // Green LED
struct gpiod_line * lineBlue ; // Blue LED
// struct gpiod_line *lineYellow; // Yellow LED
int i , val ;
// Open GPIO chip
chip0 = gpiod_chip_open_by_name ( chipname0 );
chip1 = gpiod_chip_open_by_name ( chipname1 );
chip4 = gpiod_chip_open_by_name ( chipname4 );
// Open GPIO lines
lineRed = gpiod_chip_get_line ( chip4 , 4 );
lineGreen = gpiod_chip_get_line ( chip0 , 21 );
lineBlue = gpiod_chip_get_line ( chip0 , 22 );
// lineYellow = gpiod_chip_get_line(chip1, 18);
// Open LED lines for output
gpiod_line_request_output ( lineRed , "exampleLED" , 0 );
gpiod_line_request_output ( lineGreen , "exampleLED" , 0 );
gpiod_line_request_output ( lineBlue , "exampleLED" , 0 );
// gpiod_line_request_output(lineYellow, "exampleLED", 0);
// Blink LEDs in a binary pattern
i = 0 ;
while ( true ) {
gpiod_line_set_value ( lineRed , ( i & 1 ) != 0 );
gpiod_line_set_value ( lineGreen , ( i & 2 ) != 0 );
gpiod_line_set_value ( lineBlue , ( i & 3 ) != 0 );
// gpiod_line_set_value(lineYellow, (i & 4) != 0);
usleep ( 100000 );
i ++ ;
}
// Set initial state
gpiod_line_set_value ( lineRed , 0 );
gpiod_line_set_value ( lineGreen , 0 );
gpiod_line_set_value ( lineBlue , 0 );
// gpiod_line_set_value(lineYellow, 0);
// Release lines and chip
gpiod_line_release ( lineRed );
gpiod_line_release ( lineGreen );
gpiod_line_release ( lineBlue );
// gpiod_line_release(lineYellow);
gpiod_chip_close ( chip0 );
gpiod_chip_close ( chip1 );
gpiod_chip_close ( chip4 );
printf ( "Encerrando aplicacao BlinkLED... \n " );
return 0 ;
}
Compilando no TARGET :
Executar no TARGET cd /home/root
aarch64-tdx-linux-gcc blinkLED.c -o blinkLED -lgpiod
Testando:
Executar no TARGET ./blinkLED
Crie o arquivo /home/root/blinkLED_v2.c no TARGET :
Executar no TARGET cd /home/root
touch blinkLED_v2.c
Copie o conteúdo abaixo para blinkLED_v2.c:
/*
* Aplicacao Blink LED V2
* Autor: Cleiton Bueno
* Data: 06/2026
*
* $ aarch64-tdx-linux-gcc blinkLED_v2.c -o blinkLED_v2 -lgpiod
*
* Treinamento B2Open Systems
*/
#include <gpiod.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
volatile sig_atomic_t keep_running = 1 ;
// Funcao de callback para tratar SIGINT
void handle_sigint ( int sig ) {
const char msg [] = " \n [Ctrl+C] Iniciando encerramento com seguranca... \n " ;
write ( STDOUT_FILENO , msg , sizeof ( msg ) - 1 );
keep_running = 0 ;
}
int main ( int argc , char ** argv )
{
printf ( "Iniciando aplicacao BlinkLEDv2... \n " );
// Iniciando estrutura e limpando valores iniciais
struct sigaction act ;
act . sa_handler = handle_sigint ;
sigemptyset ( & act . sa_mask );
act . sa_flags = 0 ;
// Registrando o sinal SIGINT e funcao de callback
if ( sigaction ( SIGINT , & act , NULL ) < 0 ) {
perror ( "sigaction registration failed" );
return EXIT_FAILURE ;
}
//
// Kernel 5.15
//
const char * chipname0 = "gpiochip1" ;
const char * chipname1 = "gpiochip2" ;
const char * chipname4 = "gpiochip5" ;
//
// Kernel 6.6
//
// const char *chipname0 = "gpiochip0";
// const char *chipname1 = "gpiochip1";
// const char *chipname4 = "gpiochip4";
struct gpiod_chip * chip0 ;
struct gpiod_chip * chip1 ;
struct gpiod_chip * chip4 ;
struct gpiod_line * lineRed ; // Red LED
struct gpiod_line * lineGreen ; // Green LED
struct gpiod_line * lineBlue ; // Blue LED
// struct gpiod_line *lineYellow; // Yellow LED
int i , val ;
// Open GPIO chip
chip0 = gpiod_chip_open_by_name ( chipname0 );
chip1 = gpiod_chip_open_by_name ( chipname1 );
chip4 = gpiod_chip_open_by_name ( chipname4 );
// Open GPIO lines
lineRed = gpiod_chip_get_line ( chip4 , 4 );
lineGreen = gpiod_chip_get_line ( chip0 , 21 );
lineBlue = gpiod_chip_get_line ( chip0 , 22 );
// lineYellow = gpiod_chip_get_line(chip1, 18);
// Open LED lines for output
gpiod_line_request_output ( lineRed , "exampleLED" , 0 );
gpiod_line_request_output ( lineGreen , "exampleLED" , 0 );
gpiod_line_request_output ( lineBlue , "exampleLED" , 0 );
// gpiod_line_request_output(lineYellow, "exampleLED", 0);
// Blink LEDs in a binary pattern
i = 0 ;
while ( keep_running ) {
gpiod_line_set_value ( lineRed , ( i & 1 ) != 0 );
gpiod_line_set_value ( lineGreen , ( i & 2 ) != 0 );
gpiod_line_set_value ( lineBlue , ( i & 3 ) != 0 );
// gpiod_line_set_value(lineYellow, (i & 4) != 0);
usleep ( 100000 );
i ++ ;
}
// Set initial state
gpiod_line_set_value ( lineRed , 0 );
gpiod_line_set_value ( lineGreen , 0 );
gpiod_line_set_value ( lineBlue , 0 );
// gpiod_line_set_value(lineYellow, 0);
// Release lines and chip
gpiod_line_release ( lineRed );
gpiod_line_release ( lineGreen );
gpiod_line_release ( lineBlue );
// gpiod_line_release(lineYellow);
gpiod_chip_close ( chip0 );
gpiod_chip_close ( chip1 );
gpiod_chip_close ( chip4 );
printf ( "Encerrando aplicacao BlinkLEDv2... \n " );
return 0 ;
}
Compilando no TARGET :
Executar no TARGET cd /home/root
aarch64-tdx-linux-gcc blinkLED_v2.c -o blinkLED_v2 -lgpiod
Testando:
Executar no TARGET ./blinkLED_v2
Shell Script - LEDS
Utilizando Shell Script e os comandos do libgpiod para manipular os leds, antes de executar de permissão de execução para o .sh:
Crie o arquivo /home/root/b2-leds.sh no TARGET :
Executar no TARGET touch b2-leds.sh
chmod +x b2-leds.sh
Copie o conteúdo abaixo para b2-leds.sh:
#!/bin/bash
set +x
# Kernel 5.15
CHIPLED =( 5 1 1 )
# Kernel 6.6
# CHIPLED=(4 0 0)
OFFSETLED =( 4 21 22 )
for nLED in 1 2 3
do
echo "CHIP[ ${ CHIPLED [ $(( ${ nLED } - 1 )) ] } ]: ${ OFFSETLED [ $(( ${ nLED } - 1 )) ] } "
echo " Ligando LED ${ nLED } "
gpioset ${ CHIPLED [ $(( ${ nLED } - 1 )) ] } ${ OFFSETLED [ $(( ${ nLED } - 1 )) ] } = 1
sleep 0 .5
done
sleep 1
for nLED in 1 2 3
do
echo "CHIP[ ${ CHIPLED [ $(( ${ nLED } - 1 )) ] } ]: ${ OFFSETLED [ $(( ${ nLED } - 1 )) ] } "
echo " Desligando LED ${ nLED } "
gpioset ${ CHIPLED [ $(( ${ nLED } - 1 )) ] } ${ OFFSETLED [ $(( ${ nLED } - 1 )) ] } = 0
sleep 0 .5
done
exit 0
Executando:
Executar no TARGET ./b2-leds.sh
Saída esperada:
CHIP[ 5 ] : 4
Ligando LED1
CHIP[ 1 ] : 21
Ligando LED2
CHIP[ 1 ] : 22
Ligando LED3
CHIP[ 5 ] : 4
Desligando LED1
CHIP[ 1 ] : 21
Desligando LED2
CHIP[ 1 ] : 22
Desligando LED3
Shell Script - BUZZER
O PWM pode ser configurado e manipulado via SysFS em /sys/class/pwm, exemplo com o Buzzer do Shield:
Executar no TARGET - Kernel 5.15 echo 0 > /sys/class/pwm/pwmchip1/export
echo 1000000 > /sys/class/pwm/pwmchip1/pwm0/period
echo 500000 > /sys/class/pwm/pwmchip1/pwm0/duty_cycle
echo 1 > /sys/class/pwm/pwmchip1/pwm0/enable
echo 0 > /sys/class/pwm/pwmchip1/pwm0/enable
echo 0 > /sys/class/pwm/pwmchip1/unexport
Utilizando Shell Script realizamos a configuração do periodo e duty-cycle via sysfs /sys , antes de executar de permissão de execução para o .sh:
Crie o arquivo /home/root/b2-buzzer.sh no TARGET :
Executar no TARGET cd /home/root
touch b2-buzzer.sh
chmod +x b2-buzzer.sh
Copie o conteúdo abaixo para b2-buzzer.sh:
#!/bin/bash
# Com todos PWM's habilitados:
# PWM_D LSIO_PWM2 /sys/class/pwm/pwmchip3/
# Desabilitando PWM1(LED2) e PWM2(LED3)
# PWM_D LSIO_PWM2 /sys/class/pwm/pwmchip1/
# Kernel 5.15
NPWM = 1
# Kernel 6.6
# NPWM=0
PERIOD_ms = 1
PERIOD_ns = " $(( ${ PERIOD_ms } * 1000 * 1000 )) "
IS_LIVE = true
# trap ctrl-c and call ctrl_c()
trap ctrl_c INT
function ctrl_c() {
echo "Signal Catch..."
IS_LIVE = false
}
if [ ! -e "/sys/class/pwm/pwmchip ${ NPWM } /pwm0" ] ; then
echo 0 > /sys/class/pwm/pwmchip${ NPWM } /export
fi
echo "Period(ns): ${ PERIOD_ns } "
echo ${ PERIOD_ns } > /sys/class/pwm/pwmchip${ NPWM } /pwm0/period
echo "DutyCycle: $(( ${ PERIOD_ns } / 2 )) "
echo 1 > /sys/class/pwm/pwmchip${ NPWM } /pwm0/enable
while true; do
echo " $(( ${ PERIOD_ns } / 2 )) " > /sys/class/pwm/pwmchip${ NPWM } /pwm0/duty_cycle
sleep 0 .2 # Critical
# sleep 0.250 # Medium
echo " $(( ${ PERIOD_ns } )) " > /sys/class/pwm/pwmchip${ NPWM } /pwm0/duty_cycle
# sleep 0.075 # Critical
# sleep 0.125 # Medium
sleep 1 .2
if [ ${ IS_LIVE } == false ] ; then
echo 0 > /sys/class/pwm/pwmchip${ NPWM } /pwm0/enable
echo 0 > /sys/class/pwm/pwmchip${ NPWM } /unexport
echo "Exitting..."
exit 0
fi
done
Executando:
Executar no TARGET ./b2-buzzer.sh
Saída esperada:
Period( ns) : 1000000
DutyCycle: 500000
Shell Script - POTENCIÔMETRO(KNOB)
Utilizando Shell Script realizamos leiturado knob conectado em um ADC da AsterBoard, antes de executar de permissão de execução para o .sh.
Crie o arquivo /home/root/b2-knob.sh no TARGET :
Executar no TARGET cd /home/root
touch b2-knob.sh
chmod +x b2-knob.sh
Copie o conteúdo abaixo para b2-knob.sh:
#!/bin/bash
PERIOD_ms = 1
PERIOD_ns = " $(( ${ PERIOD_ms } * 1000 * 1000 )) "
IS_LIVE = true
KNOB = "/dev/colibri-ain0"
# Kernel 5.15
NPWM = 1
# Kernel 6.6
# NPWM=0
# Trap Ctrl_C
trap ctrl_c INT
function ctrl_c() {
echo "Signal Catch..."
IS_LIVE = false
}
function checkHardware() {
if [ ! -e " ${ KNOB } " ] ; then
echo "Analog Knob not found!"
exit 7
fi
if [ ! -e "/sys/class/pwm/pwmchip ${ NPWM } /pwm0" ] ; then
echo 0 > /sys/class/pwm/pwmchip${ NPWM } /export
fi
}
function main() {
checkHardware
echo "Period(ns): ${ PERIOD_ns } "
echo ${ PERIOD_ns } > /sys/class/pwm/pwmchip${ NPWM } /pwm0/period
echo "DutyCycle: $(( ${ PERIOD_ns } / 2 )) "
echo 1 > /sys/class/pwm/pwmchip${ NPWM } /pwm0/enable
while true; do
local knob_value = $( cat ${ KNOB } )
local knob_value_to_pwm_period = 1
echo "Knob Value: ${ knob_value } "
knob_value_to_pwm_period = $(( ${ knob_value } / 1000 ))
if [ ${ knob_value_to_pwm_period } == 0 ] ; then
knob_value_to_pwm_period = 1
fi
local value_period = $(( ${ PERIOD_ns } / ${ knob_value_to_pwm_period } ))
echo " ${ value_period } " > /sys/class/pwm/pwmchip${ NPWM } /pwm0/duty_cycle
sleep 0 .2 # Critical
# sleep 0.250 # Medium
echo " $(( ${ PERIOD_ns } )) " > /sys/class/pwm/pwmchip${ NPWM } /pwm0/duty_cycle
# sleep 0.075 # Critical
# sleep 0.125 # Medium
sleep 1 .2
if [ ${ IS_LIVE } == false ] ; then
echo 0 > /sys/class/pwm/pwmchip${ NPWM } /pwm0/enable
echo 0 > /sys/class/pwm/pwmchip${ NPWM } /unexport
echo "Exitting..."
exit 0
fi
done
}
#
# MAIN
#
main
Executando:
Executar no TARGET ./b2-knob.sh
Saída esperada:
Period( ns) : 1000000
DutyCycle: 500000
Knob Value: 4095
Knob Value: 4095
Knob Value: 2611
Knob Value: 2609
Knob Value: 2067
Knob Value: 1643
Shell Script - LDR
Utilizando Shell Script realizamos leiturado do LDR conectado em um canal ADC da AsterBoard, antes de executar de permissão de execução para o .sh.
Crie o arquivo /home/root/b2-ldr.sh no TARGET :
Executar no TARGET cd /home/root
touch b2-ldr.sh
chmod +x b2-ldr.sh
Copie o conteúdo abaixo para b2-ldr.sh:
#!/bin/bash
# /dev/colibri-ain0 -> /sys/devices/platform/bus@5a000000/5a880000.adc/iio:device0/in_voltage0_raw
# /dev/colibri-ain1 -> /sys/devices/platform/bus@5a000000/5a880000.adc/iio:device0/in_voltage1_raw
# /dev/colibri-ain2 -> /sys/devices/platform/bus@5a000000/5a880000.adc/iio:device0/in_voltage4_raw
# /dev/colibri-ain3 -> /sys/devices/platform/bus@5a000000/5a880000.adc/iio:device0/in_voltage5_raw
# Caminho para o dispositivo ADC
ADC_PATH = "/sys/bus/iio/devices/iio:device0"
# Canal (4 para LDR)
LDR_CHAN = "in_voltage4_raw"
echo "Iniciando leitura (Pressione Ctrl+C para sair)..."
echo "------------------------------------------------"
while true; do
# Le os valores brutos (raw)
VAL_LDR = $( cat " $ADC_PATH / $LDR_CHAN " )
# LUZ_PCT=$(echo "scale=1; ($VAL_LDR / 4095) * 100" | bc -l)
LUZ_PCT = $( awk -v r = " $VAL_LDR " 'BEGIN { printf "%.1f", (r / 4095) * 100 }' )
# Pega hora atual
DATA = $( date "+%H:%M:%S" )
# Imprime na tela
echo "[ $DATA ] LDR: $VAL_LDR - $LUZ_PCT %"
# Aguarda 1s
sleep 1
done
Executando:
Executar no TARGET ./b2-ldr.sh
Saída esperada:
Iniciando leitura ( Pressione Ctrl+C para sair) ...
------------------------------------------------
[ 12 :18:40] LDR: 4095 - 100 .0%
[ 12 :18:41] LDR: 4095 - 100 .0%
[ 12 :18:42] LDR: 4095 - 100 .0%
[ 12 :18:43] LDR: 4095 - 100 .0%
[ 12 :18:45] LDR: 4095 - 100 .0%
[ 12 :18:46] LDR: 4095 - 100 .0%
[ 12 :18:47] LDR: 111 - 2 .7%
[ 12 :18:48] LDR: 77 - 1 .9%
[ 12 :18:49] LDR: 73 - 1 .8%
[ 12 :18:50] LDR: 4095 - 100 .0%
[ 12 :18:51] LDR: 4095 - 100 .0%
[ 12 :18:52] LDR: 1592 - 38 .9%
[ 12 :18:53] LDR: 2871 - 70 .1%
[ 12 :18:54] LDR: 2883 - 70 .4%
A ferramenta i2c-tools é a principal ferramenta de linha de comando para varrer o barramento i2c e listar dispositivos, assim como ler e escrever informações para o mesmo,
Executar no TARGET i2cdetect -l
Resultado esperado:
i2c-0 i2c 5a800000.i2c I2C adapter
i2c-1 i2c 5a810000.i2c I2C adapter
Executar no TARGET i2cdetect -y -r 0
Resultado esperado:
0 1 2 3 4 5 6 7 8 9 a b c d e f
00 : UU -- UU -- -- -- -- --
10 : -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20 : -- -- -- -- -- -- -- -- -- -- -- -- 2c -- -- --
30 : -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40 : -- -- -- UU -- -- -- -- -- -- -- -- -- -- -- --
50 : -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60 : -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70 : -- -- -- -- -- -- -- --
Executar no TARGET i2cdetect -y -r 1
Resultado esperado:
0 1 2 3 4 5 6 7 8 9 a b c d e f
00 : -- -- -- -- -- -- -- --
10 : -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20 : -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30 : -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40 : -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50 : -- -- -- -- -- -- -- UU -- -- -- -- -- -- -- --
60 : -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70 : -- -- -- -- -- -- -- --
EEPROM
No Shield há uma memoria EEPROM conectada na I2C com endereço 0x57, o mesmo aparece como UU no exemplo acima, abaixo como localizar e manipular um eeprom via SysFS:
Executar no TARGET find /sys/ -iname 'eeprom*'
Resultado esperado:
/sys/devices/platform/bus@5a000000/5a810000.i2c/i2c-1/1-0057/eeprom
/sys/firmware/devicetree/base/bus@5a000000/i2c@5a810000/eeprom@57
Listando diretório:
Executar no TARGET ls -l /sys/devices/platform/bus@5a000000/5a810000.i2c/i2c-1/1-0057/
total 0
drwxr-xr-x 3 root root 0 Apr 28 17 :42 1 -00571
lrwxrwxrwx 1 root root 0 Apr 28 18 :24 driver -> ../../../../../../bus/i2c/drivers/at24
-rw------- 1 root root 256 Apr 28 18 :24 eeprom
-r--r--r-- 1 root root 4096 Apr 28 18 :24 modalias
-r--r--r-- 1 root root 4096 Apr 28 17 :44 name
lrwxrwxrwx 1 root root 0 Apr 28 18 :24 of_node -> ../../../../../../firmware/devicetree/base/bus@5a000000/i2c@5a810000/eeprom@57
drwxr-xr-x 2 root root 0 Apr 28 18 :24 power
lrwxrwxrwx 1 root root 0 Apr 28 17 :42 subsystem -> ../../../../../../bus/i2c
lrwxrwxrwx 1 root root 0 Apr 28 18 :24 supplier:regulator:regulator.0 -> ../../../../../virtual/devlink/regulator:regulator.0--i2c:1-0057
-rw-r--r-- 1 root root 4096 Apr 28 17 :42 uevent
Lendo o valor da EEPROM:
Executar no TARGET cat /sys/devices/platform/bus@5a000000/5a810000.i2c/i2c-1/1-0057/eeprom
cat /sys/devices/platform/bus@5a000000/5a810000.i2c/i2c-1/1-0057/eeprom | hexdump
hexdump -C /sys/devices/platform/bus@5a000000/5a810000.i2c/i2c-1/1-0057/eeprom
echo '123456' > /sys/devices/platform/bus@5a000000/5a810000.i2c/i2c-1/1-0057/eeprom