Pular para conteúdo

Prática 07

Prática GPIO

Identificando o Pino que o LED3 do Open-Smart Rich Shield está conectado no Módulo Colibri iMX8.

  1. Acessar o diretório Lab/Documentacao.
  2. Abrir o esquemático Rich Shield Schematic.pdf e identificar o pino do LED3.
  3. Abrir o datasheet da AsterBoard colibri_arm_aster_carrier_board_datasheet.pdf (Pag. 22) e identificar o Pino SODIMM que o LED3 está conectado
  4. 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


Aplicação em C desenvolvida com a biblioteca libgpiod

Exemplo de aplicação em C para manipular GPIO em Linux, use o exemplo abaixo BlinkLED:


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%


Ferramenta i2c-tools

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