DEV Community: Henrique Otogami

[Boost]

Henrique Otogami — Wed, 12 Nov 2025 23:24:58 +0000

Java — Tradução de Máscara de Bits (BitMask)

Henrique Otogami ・ Oct 18

#java #bitmask #bitshifting #henriqueotogami

Banana Pi — Como Habilitar o SSH no Raspbian

Henrique Otogami — Wed, 12 Nov 2025 23:20:19 +0000

Henrique Otogami

Oct 22 '25

Banana Pi — Como Habilitar o SSH no Raspbian

#bananapi #raspberrypi #ssh #henriqueotogami

Comments

4 min read

Projeto Sirios - Apache + Python para Acionar LEDs via Web na Banana Pi

Henrique Otogami — Wed, 12 Nov 2025 00:42:51 +0000

Projeto Sirios - Apache + Python para Acionar LEDs via Web na Banana Pi

Henrique Otogami ・ Nov 11

#bananapi #apacheserver #python #henriqueotogami

Projeto Sirios - Apache + Python para Acionar LEDs via Web na Banana Pi

Henrique Otogami — Tue, 11 Nov 2025 18:48:40 +0000

Introdução

Este artigo implementa um sistema web para acionamento remoto de periféricos.

O sistema web é composto do servidor Apache para hospedar a página em HTML e CSS, além de habilitar o módulo CGI para controle de GPIO. Esse sistema completo será implementado na Banana Pi.

O acesso a página web será restrito apenas à rede local em que a Banana Pi está conectada. Por isso, o acionamento remoto é realizado por qualquer dispositivo da rede local. O periférico de controle utilizado é um led.

Esse projeto foi concebido dessa forma simples e reduzida apenas para validar o funcionamento do sistema como uma ideia inicial que pode expandir para outras aplicações.

Índice

Requisitos
Arquitetura
Dependências
Desenvolvimento
Conclusão
Referências

01. Requisitos

01.01 - Hardware

Banana Pi M2 Zero com GPIO disponível
Cartão SD com Raspbian Stretch
Conexão de rede Wi-Fi
01 Resistor 330 Ohms
01 LED difuso 5mm Verde
02 Fios Jumper Macho-Fêmea

01.02 - Software

Raspbian Stretch
SSH habilitado na Banana Pi
Acesso remoto via SSH configurado
Editor de texto (nano, vim ou outro)

02. Arquitetura

Esse projeto utiliza uma arquitetura modularizada em uma Interface Web hospedada em um servidor web Apache com módulo CGI habilitado via LAN para acionamento de um LED conectado fisicamente na Banana Pi.

Imagem 01 - Esquema de Arquitetura do Projeto Sirios

02.01 - Interface Web

Utilizando a LAN (rede local) em que a Banana Pi está conectada via Wi-fi, o usuário consegue acessar a Interface Web (página em HTML) via IP e Porta, por exemplo http://192.168.100.42/.
Na página web, existem dois botões para ligar e desligar o LED.

Cada botão é responsável pela execução de um script Python para acionamento da GPIO do LED. Esses arquivos são gerenciados pelo módulo CGI do Apache.

02.02 - Web Server Apache

Quando o módulo CGI recebe a requisição de um script Python para manipular a GPIO, ele executa o script com as permissões configuradas no sistema, permitindo alterar o valor lógico do pino de GPIO em conjunto com o Linux Kernel.

Imagem 02 - Esquema de Arquitetura do Projeto Sirios

02.03 - Hardware Layer

A camada de hardware é responsável pela conexão física do circuito de alimentação do LED, que será acionado pelos scripts em Python.

O circuito físico de alimentação do LED é bem simples e é o mesmo utilizado no artigo:

Como piscar um LED utilizando Banana Pi e Python via SSH

Henrique Otogami

Mar 15 '25

Como piscar um LED utilizando BananaPi e Python via SSH

#python #ssh #bananapi #henriqueotogami

Comments

4 min read

03. Dependências

03.01 - Atualização da URL do Repositório APT

O Raspbian Stretch utiliza o repositório legacy para a Banana Pi, pois a versão não é mais suportada oficialmente.

É necessário atualizar a configuração do repositório APT para atualizar o sistema e baixar novas bibliotecas.

Para saber como realizar essa configuração, leia o artigo:

Raspbian: Atualização de URL de repositório de pacotes APT do Linux

Henrique Otogami

May 31 '25

Raspbian: Atualização de URL de repositório de pacotes APT do Linux

#raspbian #linux #raspberrypi #henriqueotogami

Comments

5 min read

03.02 - Habilitação do SSH

O SSH, ou Secure Shell, é um protocolo de rede que permite a comunicação e administração remota de computadores de forma segura, utilizando criptografia para proteger os dados.

Durante o desenvolvimento do projeto, utilizando um computador auxiliar em conjunto com a Banana Pi, será necessário transferir arquivos e realizar configurações. Assim, é necessário habilitar o SSH para permitir o acesso na Banana Pi a partir do computador auxiliar.

Para saber como realizar essa configuração, leia o artigo:

Banana Pi - Como Habilitar o SSH no Raspbian

Henrique Otogami

Oct 22 '25

Banana Pi — Como Habilitar o SSH no Raspbian

#bananapi #raspberrypi #ssh #henriqueotogami

Comments

4 min read

03.03 - Instalação do Apache

O Apache HTTP Server é o servidor web mais popular do mundo desde 1996. Ele foi criado em 1995 e é mantido pela Apache Software Foundation como software open source e gratuito.

Conforme comentado anteriormente, o Apache é importante para sustentar a interface entre humano e máquina, hospedando a página web e permitir o módulo CGI gerenciar a GPIO.

Para saber como realizar essa instalação, leia o artigo:

Banana Pi - Como instalar o Apache

03.04 - Permissões de Execução de Scripts

Os scripts Python que controlam GPIO precisam executar comandos com privilégios de administrador. Para evitar restrições de permissões, é necessário configurar o sudo para o usuário www-data.

Abra o arquivo de configuração do sudo enviando o comando abaixo:

$ sudo visudo

Adicione a seguinte linha ao final do arquivo:

www-data ALL=(ALL) NOPASSWD: /usr/bin/tee, /bin/echo, /usr/bin/gpio, /usr/bin/top, /bin/cat, /bin/df

Essa configuração permite que o Apache (usuário www-data) execute os comandos especificados sem solicitar senha.
Isso é necessário porque:

/usr/bin/tee: Usado para escrever valores em arquivos GPI
/bin/echo: Usado para enviar comandos para GPIO
/usr/bin/gpio: Ferramenta de manipulação GPIO
/usr/bin/top, /bin/cat, /bin/df: Comandos de monitoramento adicionais

03.05 - Habilitação do Módulo CGI

O Common Gateway Interface (CGI) permite que o Apache execute scripts externos (Python, Perl, Shell) em resposta a requisições HTTP.
Para habilitar o CGI, envie o comando abaixo:

$ sudo a2enmod cgi

Após habilitar o módulo, é obrigatório reiniciar o Apache:

sudo systemctl restart apache2

Confirme que o serviço reiniciou corretamente:

$ sudo systemctl status apache2

Imagens 03 e 04 - Habilitação do Módulo CGI

04. Desenvolvimento

Para evidenciar o entendimento do projeto, o fluxo de funcionamento está ilustrado na imagem 05 abaixo. O curso do fluxo segue em forma de cascata, sendo dividido em etapas em que cada componente recebe uma entrada e dispara uma saída.

Imagem 05 - Esquema de Fluxo de Funcionamento do Projeto Sirios

Usuário: Solicita o acionamento do LED;
Navegador: Solicita o acionamento do script;
Apache: Executa o script Python;
CGI: Permite que o Python acesse a GPIO;
Python: acessa a GPIO;
GPIO: Define o estado lógico do pino;
LED: Acende ou apaga.

04.01 - Arquivos Python

Após realizar o login via SSH na Banana Pi, os scripts Python para controle de GPIO devem ser criados no diretório padrão para scripts CGI no Apache.

Acesse o diretório padrão:

$ cd /usr/lib/cgi-bin/

Para criar o arquivo para ligar o LED:

$ sudo nano gpio_on.py

Adicione o seguinte conteúdo:

#!/usr/bin/env python
print("Content-type: text/html\n")
import subprocess
import os
FNULL = open(os.devnull, 'w')
subprocess.call("echo 7 | sudo tee /sys/class/gpio/unexport", shell=True, stdout=FNULL, stderr=FNULL)
subprocess.call("echo 7 | sudo tee /sys/class/gpio/export", shell=True, stdout=FNULL, stderr=FNULL)
subprocess.call("echo out | sudo tee /sys/class/gpio/gpio7/direction", shell=True, stdout=FNULL, stderr=FNULL)
subprocess.call("echo 1 | sudo tee /sys/class/gpio/gpio7/value", shell=True, stdout=FNULL, stderr=FNULL)
print("LED LIGADO")

Explicação do conteúdo do script para ligar o LED:

#!/usr/bin/env python: Shebang indicando o interpretador Python
print("Content-type: text/html\n"): Header HTTP necessário para CGI
subprocess.call(): Executa comandos shell para manipular GPIO
FNULL: Redireciona stdout para /dev/null, suprimindo mensagens
GPIO 7: é configurado como saída (out) e valor alto (1)

Após criar o arquivo, é necessário adicionar a permissão para que ele seja executável:

$ sudo chmod +x /usr/lib/cgi-bin/gpio_on.py

Para criar o arquivo para desligar o LED:

$ sudo nano /usr/lib/cgi-bin/gpio_off.py

Adicione o seguinte conteúdo:

#!/usr/bin/env python
print("Content-type: text/html\n")
import subprocess
import os
FNULL = open(os.devnull, 'w')
subprocess.call("echo 0 | sudo tee /sys/class/gpio/gpio7/value", shell=True, stdout=FNULL, stderr=FNULL)
print("LED DESLIGADO")

Explicação do conteúdo do script para desligar o LED:

GPIO 7: configura valor baixo (0) para desligar o LED

Após criar o novo arquivo, é necessário adicionar a permissão para que ele também seja executável:

$ sudo chmod +x /usr/lib/cgi-bin/gpio_off.py

Após criar os dois arquivos acima e adicionar as permissões, é necessário reiniciar o apache para aplicar as configurações:

$ sudo systemctl restart apache2

04.02 - Interface Web

A interface é bem simples também e foi concebida como protótipo no Figma para orientar a implementação posterior em HTML e CSS.
A primeira ideia foi retornar os estados do led no próprio botão de ligar e desligar. Mas, para isso será necessário implementar uma página dinâmica utilizando o Javascript, ao invés da página estática utilizada no projeto.

Imagens 05 a 08- Protótipos do Projeto Sirios

Para capturar o estado do LED e retornar como mensagem ao usuário, foi utilizada o iframe do HTML, que funciona como uma janela para imprimir conteúdo externo.

Para criar o arquivo da página em HTML:

$ sudo nano /var/www/html/index.html

Adicione o seguinte conteúdo:

Arquivo da Página Web em HTML do Projeto Sirios

Cada botão de ligar e desligar o LED requisitam a execução de seus respectivos scripts como método GET do protocolo HTTP. Enquanto a resposta é apresentada no iframe, conforme mencionado anteriormente.

Explicação do funcionamento do iframe utilizado na página web:

action="/cgi-bin/gpio_on.py": Define o script CGI a ser executado
method="get": Método HTTP utilizado
target="message_iframe": Exibe a resposta do CGI em um iframe
onload: Atualiza a div de saída com o conteúdo retornado pelo CGI

Para criar o arquivo de estilos em CSS da página em HTML:

$ sudo nano /var/www/html/style.css

Adicione o seguinte conteúdo:

Arquivo de Estilos da Página Web em CSS do Projeto Sirios

04.03 - Acessar a Interface Web

Abra o navegador e acesse:

http://seu-ip/index.html

ou simplesmente:

http://seu-ip/

Imagens 09 e 10 da Página Web do Projeto Sirios na versão Desktop e Mobile

Vídeo de demonstração

05. Conclusão

Esse projeto apresentou a proposta de controle remoto de dispositivos gerenciados pela Banana Pi, permitindo que haja uma expansão para controle de periféricos mais complexos como equipamentos de internet das coisas (IoT).

Seguindo nessa direção, é possível implementar recursos que transformem uma simples placa eletrônica, como a Banana Pi, em um dispositivo central de pequenas automações futuras.

As maiores dificuldades enfrentadas foram no entendimento de como o Linux gerencia as permissões dos arquivos de GPIO em Python e configurações de usuário necessárias para o Apache conseguir solicitar a execução dos mesmos.

Além disso, foi muito importante entender como uma página web consegue interagir com os comandos de terminal e capturar a resposta para entregar ao usuário o estado do LED.

Muitas coisas desse projeto estão sendo aproveitadas de projetos de artigos anteriores, tanto no circuito eletrônico quanto em algumas configurações. Isso facilita o desenvolvimento, de modo a permitir o foco nas novas implementações, sem precisar explicar novamente tópicos mais básicos.

06. Referências

Apoie o meu conteúdo com um cafézinho!

Ficou alguma dúvida ou tem sugestões?
Comente aqui embaixo ou me chame em alguma das minhas redes.
Valeu! ✌🏻

Banana Pi — Como Habilitar o SSH no Raspbian

Henrique Otogami — Wed, 22 Oct 2025 03:52:03 +0000

Introdução

Neste artigo vou mostrar como habilitar o SSH na Banana Pi, rodando o Raspbian.

Versão do Raspbian: 4.4.55-BPI-M22-Kernel — Banana Pi Zero M2

O que é o SSH ?

O SSH, ou Secure Shell, é um protocolo de rede que permite a comunicação e administração remota de computadores de forma segura, utilizando criptografia para proteger os dados.

Ele permite fazer login, executar comandos e transferir arquivos em servidores remotos através de uma conexão segura, substituindo métodos menos seguros como o Telnet.

Opção 1 — raspi-config

O raspi-config é um utilitário de configuração de linha de comando pré-instalado no Raspberry Pi OS que permite ajustar facilmente várias configurações do sistema.

Ele oferece uma interface de menu para modificar definições comuns como a localidade, o nome do host, a resolução de tela, o comportamento de inicialização (como iniciar na área de trabalho gráfica) e habilitar/desabilitar serviços como SSH ou VNC.

Para realizar essa configuração, é necessário que a Banana Pi esteja conectada a um monitor externo via HDMI.

No Terminal do Raspbian, insira o seguinte comando: sudo raspi-config
A tela “Raspberry Pi Software Configuration Tool (raspi-config)” será aberta no Terminal
Navegue até “Interfacing Options” e selecione Enter
A tela de configuração dos periféricos será aberta
Navegue até “SSH” e selecione Enter
A tela de confirmação de habilitação será aberta
Navegue até “Yes” e selecione Enter
A tela de confirmação vai mostrar que o SSH foi habilitado

Opção 2 — systemctl

O systemctl é um comando de linha de comando no Linux usado para gerenciar o systemd, que é o sistema de inicialização e gerenciador de serviços padrão em muitas distribuições modernas.

Ele permite iniciar, parar, reiniciar, habilitar ou desabilitar serviços, verificar seus status, e gerenciar “unidades”, que podem ser serviços, dispositivos ou pontos de montagem.

Para realizar essa configuração, é necessário que a Banana Pi esteja conectada a um monitor externo via HDMI.

No Terminal do Raspbian, insira os seguintes comandos:

# Verificar status do SSH
sudo systemctl status ssh

# Habilitar o serviço SSH
sudo systemctl enable ssh

# Iniciar o serviço SSH
sudo systemctl start ssh

# Verificar se está rodando
sudo systemctl status ssh

Opção 3 — Habilitação Manual via Arquivo

Os arquivos SSH são usados para gerenciar autenticação e permissões, sendo os mais comuns as chaves SSH (pares de chave pública e privada) e os arquivos de configuração SSH.

Criar arquivo ssh na partição boot:

# No diretório /boot (partição boot do cartão SD)
sudo touch /boot/ssh

Ou editar configuração SSH:

# Editar arquivo de configuração SSH
sudo nano /etc/ssh/sshd_config
# Verificar se a linha está assim:
# Port 22
# PermitRootLogin no (recomendado)
# PasswordAuthentication yes

Opção 4 — Usando arquivo ssh.txt

Se a inicialização é a primeira vez, é possível criar um arquivo ssh (sem extensão) na partição boot do cartão SD antes de ligar o dispositivo.

Descobrir o IP da Banana Pi

# Na Banana Pi
ifconfig

# Ou mais específico para WiFi
ifconfig wlan0

Testar conexão SSH

# Em um computador secundário:
ssh pi@banana.local

# Ou usando IP específico (exemplo baseado nos logs do projeto)
ssh pi@192.168.100.27

Verificar se SSH está rodando

# Na Banana Pi
sudo netstat -tlnp | grep :22

# Ou
sudo ss -tlnp | grep :22

Configurações de Segurança

Pensando em aumentar a segurança, é possível alterar a porta padrão da comunicação via SSH. Isso é uma configuração opcional, considerando que bots sabem da existência dessa porta padrão e podem realizar ataques automatizados.

Alterar porta SSH padrão:

sudo nano /etc/ssh/sshd_config
# Alterar a linha:
# Port 22
# Para:
# Port 2222
# Reiniciar SSH
sudo systemctl restart ssh

Desabilitar login root via SSH:

sudo nano /etc/ssh/sshd_config
# Certificar que está:
# PermitRootLogin no

Problemas comuns

Problema 01: SSH não conecta

Verificar se SSH está rodando:

sudo systemctl status ssh

Verificar firewall:

sudo ufw status
sudo ufw allow ssh

Verificar conectividade de rede:

ping google.com

Problema 02: Conexão recusada

Verificar se a porta 22 está aberta:

sudo netstat -tlnp | grep :22

Verificar logs SSH:

sudo journalctl -u ssh -f

Problema 03: Autenticação falha

Resetar senha do usuário pi:

sudo passwd pi

Verificar configuração de autenticação:

Sudo nano /etc/ssh/sshd_config
# Certificar que PasswordAuthentication yes está ativo

Comandos Úteis

Nos projetos demonstrados nos meus artigos, os comandos mais utilizados são os seguintes:

# Conectar via SSH
ssh pi@banana.local

# Enviar arquivos via SCP (como no projeto)
scp /caminho/local/arquivo.py pi@bananapi-zero.local:

# Executar comandos remotamente
ssh pi@banana.local 'comando_aqui'

Notas Importantes

Segurança: Sempre altere a senha padrão do usuário pi
Rede: Certifique-se de que a Banana Pi está na mesma rede
Firewall: Alguns roteadores podem bloquear conexões SSH
Backup: Faça backup das configurações antes de alterar

https://ko-fi.com/henriqueotogami

Ficou alguma dúvida ou tem sugestões?
Comente aqui embaixo ou me chame em alguma das minhas redes.
Valeu! ✌🏻

Java — Tradução de Máscara de Bits (BitMask)

Henrique Otogami — Sat, 18 Oct 2025 03:55:50 +0000

Introdução

Imagine um sistema embarcado que possui alguns sensores conectados fisicamente e que informe o estado lógico de todos esses sensores em apenas um número. Essa é a estratégia de uma máscara de bits (BitMask).

O que é uma Máscara de Bits?

Uma máscara de bits é um valor (geralmente um número inteiro) usado para isolar, modificar ou verificar bits específicos dentro de outro valor binário, utilizando operações bit a bit (como AND, OR, XOR, NOT).

Por exemplo, usando a operação AND (&), é possível verificar se determinado bit está ativado (1) ou desativado (0) em um número.
Exemplo: Para verificar se o terceiro bit de um número está ativo:

int valor = 0b1010;                     // binário: 1010
int mascara = 0b0100;                   // binário: 0100 (terceiro bit)
boolean ativo = (valor & mascara) != 0; // true se o terceiro bit está 1

Assim, máscaras de bits são muito usadas para manipular flags, permissões e estados compactados em variáveis inteiras.

Exemplo de Estado Lógico de Sensores

Imagem 01 — Visão Panorâmica do Exemplo de Sistema Embarcado

Em um sistema embarcado qualquer, são conectados oito sensores:

Sensor de Temperatura;
Sensor de Umidade;
Sensor de Luminosidade;
Sensor de Presença;
Sensor de Fumaça;
Sensor de Pressão;
Acelerômetro;
Giroscópio.

O estado lógico de cada sensor é representado por um bit. Assim, os estados de todos os sensores são expressos em um único Byte em hexadecimal. E essa é a Máscara de Bits (BitMask).

Considere um segundo sistema, que recebe esse Byte e deseja identificar quais sensores estão habilitados e quais estão desabilitados. Para realizar essa tarefa, é necessário implementar uma "tradução" desse valor.

Tradução da Máscara de Bits

Imagem 02 — Explicação da Tradução de Máscara de Bits

A tradução da máscara de bits recebida pelo segundo sistema consiste nas seguintes etapas:

Receber o Byte contendo a Máscara de Bits (0x7F);
Iterar até o tamanho máximo de um Byte (8 bits);
Deslocar os bits do número 1 com o valor do índice da iteração. Esse deslocamento pode ser entendido como potência de 2;
Realizar operação lógica E (AND) com o valor recebido (0x7F) e o valor deslocado.

A Imagem 02 acima demonstra como essas etapas são realizadas com um pouco mais de detalhes.
Perceba que a etapa de deslocamento de bits é muito importante para localizar cada bit que representa o estado lógico de um sensor.
A figura abaixo demonstra graficamente o deslocamento e a operação AND, mostrando como cada bit é isolado.

Exemplo de Deslocamento de Bits

int mask0 = 1 << 0;
//  mask0 = (0000 0001)b << (0000 0000)b = 2^0 = (0000 0001)b = 1

int mask1 = 1 << 1;
//  mask1 = (0000 0001)b << (0000 0001)b = 2^1 = (0000 0010)b = 2

int mask2 = 1 << 2;
//  mask2 = (0000 0001)b << (0000 0010)b = 2^2 = (0000 0100)b = 4

int mask3 = 1 << 3;
//  mask3 = (0000 0001)b << (0000 0011)b = 2^3 = (0000 1000)b = 8

// [....]

int mask7 = 1 << 7;
//  mask7 = (0000 0001)b << (0000 0111)b = 2^7 = (1000 0000)b = 128

Implementação da Tradução da Máscara de Bits

Conclusão

O uso de máscaras de bits constitui uma prática essencial em sistemas embarcados e em diversas aplicações de baixo nível, permitindo o controle e a leitura eficiente de múltiplos estados lógicos dentro de uma única variável.
Por meio de operações simples de deslocamento e comparação, é possível representar informações complexas de forma compacta e performática, reduzindo o consumo de memória e otimizando o processamento.

A implementação apresentada demonstrou como o deslocamento de bits (1 << n) e a operação lógica AND (&) podem ser aplicados para identificar o estado individual de cada sensor em um sistema embarcado.
Esse método é amplamente utilizado em protocolos de comunicação, registradores de microcontroladores e mecanismos de controle de hardware, reforçando sua relevância prática.

ko-fi.com/henriqueotogami

Ficou alguma dúvida ou tem sugestões?
Comente aqui embaixo ou me chame em alguma das minhas redes.
Valeu! ✌🏻

Raspbian: Atualização de URL de repositório de pacotes APT do Linux

Henrique Otogami — Sat, 31 May 2025 18:47:29 +0000

Introdução

Esse artigo demonstrará como atualizar o endereço do repositório de pacotes APT do Linux embarcado de uma Banana Pi no arquivo etc/apt/sources.list, para possibilitar o download de bibliotecas.

Sumário

Detalhes do equipamento
Problema encontrado
Erro — comando $ sudo apt-get update
Erro — comando $ sudo apt-get install apache2 php
O que são pacotes APT do Linux ?
Como funciona um pacote APT no Linux ?
O que é o comando $ sudo apt-get update ?
O que é o comando $ sudo apt-get upgrade ?
Por que utilizar o comando “sudo”junto com o comando “apt-get”?
Como resolver o problema de conexão para baixar os pacotes ?
O que é o arquivo sources.list ?
Como editar o arquivo sources.list ?
Referências

Detalhes do equipamento

Versão de software: Raspbian Stretch kernel 4.4.55 (28/04/2020)
Versão de hardware: Banana Pi BPI-M2 Zero

Problema encontrado

Após instalar o Linux, é necessário atualizar os pacotes APT. Mas, quando a Banana Pi tentava se conectar com o repositório da distribuição Linux para realizar os downloads, a atualização falhava.

Abaixo serão demonstrados gists com os exemplos de falha.

Erro — comando $ sudo apt-get update

No exemplo acima, a falha de conexão do repositório está indicada nas seguinte linha:

Err:3 http://raspbian.raspberrypi.org/raspbian stretch Release
  404  Not Found [IP: 2a00:1098:0:80:1000:75:0:3 80]

Erro — comando $ sudo apt-get install apache2 php

Para resolver esse problema e atualizar o ambiente da Banana Pi, é necessário entender a seguir alguns conceitos básicos.

O que são pacotes APT do Linux ?

A sigla APT significa Advanced Package Tool e compõe o sistema de gerenciamento de pacotes do Linux, utilizado por distribuições baseadas no Debian (como o Ubuntu, Raspbian e etc). [02]

Como funciona um pacote APT no Linux ?

Um pacote APT no Linux é um arquivo que utiliza a extensão .deb, indicando formato de pacote Debian e que contém os seguintes itens:

Contém um software pronto para ser instalado no Linux;
Contém as dependências desse software;
Contém scripts de instalação ou configuração;
Contém informações de versão, descrição e autor. [02]

O que é o comando $ sudo apt-get update ?

Esse comando apenas atualiza a lista de pacotes disponíveis para a versão de Linux utilizada. E não instala nenhum pacote. [02]

O que é o comando $ sudo apt-get upgrade ?

Esse comando instala todos os pacotes disponíveis que foram listados pelo comando $ apt-get update. [02]

Por que utilizar o comando "sudo" junto com o comando "apt-get" ?

A utilização do comando "sudo" é necessária para possuir os privilégios de administrador (root) na instalação de pacotes. [03]

Como resolver o problema de conexão para baixar os pacotes ?

O problema de conexão ocorreu porque o endereço do repositório da versão Stretch foi alterado. [01]

URL anterior: http://raspbian.raspberrypi.org/raspbian/
URL correta: http://legacy.raspbian.org/raspbian/

O prefixo "legacy" na URL atual indica que é um repositório antigo, mantido apenas para compatibilidade com versões antigas do Raspbian.

Além disso, o codinome da versão estável no período de 2017 a 2019 do Debian/Raspbian é Stretch. Então, é uma versão bem antiga. [01]

Para resolver o problema, basta substituir a URL anterior pela URL correta do repositório do Stretch no arquivo /etc/apt/sources.liste enviar os comandos de atualização novamente.

O que é o arquivo sources.list ?

Esse arquivo é fundamental para o sistema de gerenciamento de pacotes APT no Debian e em distribuições baseadas nele (como Ubuntu e Raspbian).
Ele define de onde o sistema deve baixar os pacotes e atualizações. [04]

Como localizar o arquivo sources.list ?

Esse arquivo está no diretório /etc/apt/ e para navegar até lá, basta enviar os comandos abaixo: [04]

# mudar de diretório
$ cd /etc/apt/

# listar arquivos e diretórios
$ ls -la

Como editar o arquivo sources.list ?

Para editar, utilize o nano, que é um editor de texto simples no terminal do Linux. [04]

$ sudo nano sources.list

Adicione um "#" na frente dos repositórios existentes para comentar e depois adicione a linha abaixo:

deb http://legacy.raspbian.org/raspbian/ stretch main contrib non-free rpi

Após adicionar a nova URL, siga as seguintes etapas:

Presione CTRL + O para salvar o arquivo
Pressione ENTER para salvar com o mesmo nome atual (sources.list)
Pressione CTRL + X para sair do editor

Para conferir que o arquivo foi modificado e salvo corretamente, leia o conteúdo utilizando o comando cat:

$ cat sources.list

Localizando o arquivo sources.list no Linux e editando no Nano

Editando arquivo sources.list no Nano do Linux para adicionar a nova URL do repositório de pacotes APT — [05]

Localizando o arquivo source.list, editando no Nano e conferindo se foi alterado — [02]

Depois de atualizar o arquivo sources.list, para atualizar o sistema Linux e baixar os pacotes APT atualizados, basta enviar os comandos de atualização novamente. [01]

$ sudo apt-get update

$ sudo apt-get upgrade

Na Banana Pi utilizada, seguindo as etapas acima, foram atualizados 319 pacotes com sucesso, conforme imagem abaixo:

Atualização de 319 pacotes com sucesso na Banana Pi — [02]

Para validar a correção, o apache2 foi instalado.

Instalação do Apache na Banana Pi — [02]

Status do Apache na Banana Pi — [02]

Referências

01 — Fórum Raspberry Pi — Repository for … stretch Release “does not have a Release File”
02 — Documentação Debian — comando apt-get
03 — Documentação Debian — comando sudo
04 — Documentação Debian — arquivo /etc/apt/sources.list
05 — Documentação Debian — editor de texto Nano

Ficou alguma dúvida ou tem sugestões?
Comente aqui embaixo ou me chame em alguma das minhas redes.
Valeu! ✌🏻

Como publicar mensagens no Broker MQTT usando a BananaPi e Python

Henrique Otogami — Sun, 16 Mar 2025 18:48:51 +0000

Introdução

Este artigo demonstrará um sistema de notificação dos estados de um LED (ligado/desligado) para um Broker do protocolo MQTT do HiveMQ Cloud, com assinatura do tópico de destino das mensagens no Web Client da plataforma, utilizando o microcomputador BananaPi com Python e comandos Shell no Linux Debian embarcado.

Sumário

Requisitos
O que é o protocolo MQTT ?
O que é o HiveMQ ?
O que é a BananaPi ?
Visão panorâmica do projeto
Circuito Eletrônico
HiveMQ Cloud
Algoritmo
Código em Python
Conclusão
Referências

01. Requisitos

BananaPi: Python 3.9
BananaPi: Biblioteca Python — pyenv
BananaPi: Biblioteca Python — paho-mqtt
BananaPi: Biblioteca Python — python-dotenv
BananaPi: Arquivo de credenciais .env
HiveMQ: Credencial de Segurança

02. O que é o protocolo MQTT ?

MQTT é o protocolo de mensagens mais comumente usado para a Internet das Coisas (IoT).

MQTT significa Message Queuing Telemetry Transport.

O protocolo define como dispositivos IoT publicam e assinam tópicos para receber dados pela internet. O MQTT é usado para troca de mensagens e dados entre dispositivos IoT e IoT industrial (IIoT), como microcontroladores, sensores e CLPs industriais.

O protocolo é orientado a eventos e conecta dispositivos usando o padrão publicar/assinar (Publish/Subscribe).

O remetente (Publisher) e o assinante (Subscriber) se comunicam por meio de Tópicos e são desacoplados um do outro.

A conexão entre eles é tratada pelo mediador (Broker) MQTT.

O broker MQTT filtra todas as mensagens recebidas dos Publishers e as distribui corretamente para os Subscribers. [1]

Como funciona:

Publicador (Publisher): Dispositivo ou aplicação que envia mensagens para um tópico específico.
Mediador (Broker): Recebe as mensagens publicadas e distribui para os dispositivos que estão inscritos nesse tópico.
Assinante (Subscriber): Dispositivo ou aplicação que recebe mensagens ao estar inscrito em um ou mais tópicos.

Excalidraw — Visão panorâmica do funcionamento do protocolo MQTT — [05]

Características principais:

Mensagens baseadas em Tópicos: A comunicação é organizada em tópicos (exemplo: sensores/temperatura/sala).
Baixa latência: Ideal para IoT e redes com poucos recursos.
QoS (Quality of Service): Define garantias de entrega das mensagens (0, 1 ou 2).
Persistência: Pode armazenar mensagens para entregar a clientes desconectados.

Exemplos de Brokers MQTT populares:

Mosquitto (Open-source, muito usado para IoT)
EMQX (Escalável, boa para aplicações grandes)
HiveMQ (Focado em soluções empresariais)

03. O que é o HiveMQ ?

O HiveMQ Cloud é uma plataforma de mensagens de IoT nativa da nuvem e totalmente gerenciada que simplifica a conectividade confiável e escalável de dispositivos de IoT. [1]

Tela Inicial do HiveMQ — [15]

04. O que é a BananaPi ?

A BananaPi M2 Zero é um computador de placa única ultracompacto com dimensões de 60 mm x 30 mm. Ele usa um processador quad-core Cortex A7 allwinner H2+, com 512 MB de memória RAM.

É ideal para sistemas leves com alguns aplicativos com espaço limitado. Como outros dispositivos da BananaPi, ele suporta os sistemas operacionais Linux e Android. [1]

BananaPi BPI-M2 Zero — [02]

Principais características

CPU Quad Core ARM Cortex A7 H2+
512 MB de SDRAM.
WiFi (AP6212) e Bluetooth integrados.
Mini-HDMI.

05. Visão panorâmica do projeto

Para desenvolver esse projeto, utilizaremos a seguinte determinação dos componentes do protocolo MQTT:

Publicador (Publisher): BananaPi M2 Zero
Mediador (Broker): Amazon Web Services (AWS)
Assinante (Subscriber): Hive Web Client

BananaPi

Um LED estará conectado a um pino de GPIO e será acionado (acender / apagar) via Shell Script (comando de terminal) em uma classe Python. A cada acionamento do LED, o estado lógico do pino de GPIO será lido.

A BananaPi realizará login no Broker da HiveMQ Cloud e registro no tópico bananapi de mensagens, e enviará a notificação do estado lógico do pino, que foi consultado anteriormente.

Hive Web Client

Após o cadastro na plataforma HiveMQ, é necessário que seja configurada a credencial que será utilizada pela BananaPi e pelo Web Client, compondo usuário, senha e nível de acesso (publicação, assinatura ou publicação e assinatura).

Em seguida, é necessário fazer o login no Web Client utilizando a credencial cadastrada, e assinar o tópico bananapi. Uma vez conectada, todas as mensagens enviadas pela BananaPi serão lidas no Web Client.

Excalidraw — Exemplo do desacoplamento e do relacionamento dos componentes do MQTT — [04]

A imagem acima exemplifica o relacionamento entre os componentes do protocolo MQTT, destacando o desacoplamento entre eles.

Ou seja, o publicador não possui acesso ao(s) assinante(s) da(s) mensagem(ns) que são enviadas por ele ao mediador. Da mesma forma, o(s) assinante(s) também não tem acesso ao(s) publicador(es) da(s) mensagem(ns).

06. Circuito Eletrônico

Utilizaremos o pino de GPIO7 (pino físico 29) e o GND3 (pino físico 6), da mesma forma que foi demonstrado no artigo anterior:

Como piscar um LED utilizando BananaPi e Python via SSH

07. HiveMQ Cloud

Criação de conta

Para utilizar o serviço de Web Client da HiveMQ seguindo este artigo, é necessário criar uma conta gratuita. Clique aqui para o cadastro.

HiveMQ Cloud — Tela de Login — [15]

Cadastro de nova credencial de segurança

Para realizar a autenticação remota no Broker MQTT, no qual serão enviadas as mensagens da BananaPi, será necessário cadastrar uma credencial de segurança.

No cadastro de credencial de segurança, são necessários os seguintes campos:

Username: Nome de usuário
Password: Senha do usuário
Permission: Tipo de permissão do protocolo MQTT

Na seleção do tipo de permissão, estão disponíveis as seguintes opções:

Publish only: Apenas publicação
Subscribe only: Apenas assinatura
Publish and Subscribe: Publicação e Assinatura

Após isso, basta salvar a credencial de segurança, e ela estará disponível para utilização.

HiveMQ Cloud — Tela de configuração de credenciais para autenticação no Broker — [15]

Conexão Web Client

Para se conectar ao Web Client, basta inserir o nome de usuário e senha, conforme a credencial de segurança cadastrada na seção anterior.

Após se conectar, é necessário realizar a assinatura para receber as mensagens. Para fazer isso, são utilizados dois campos:

Topic: É um canal de comunicação, semelhante a um filtro de mensagens
QoS: Qualidade de Serviço, que define a garantia de entrega das mensagens, separada em três níveis

Os tópicos no protocolo MQTT são estruturados por hierarquia, assim como diretórios de arquivos. Por exemplo:

Os níveis de Qualidade de Serviço (QoS) são os seguintes:

QoS 0 — Mensagem entregue no máximo uma vez (sem garantia)
QoS 1 — Mensagem entregue pelo menos uma vez
QoS 2 — Mensagem entregue exatamente uma vez

Existem detalhes técnicos sobre cada um dos níveis citados acima, mas não será necessário aprofundar nesse momento. Então para a demonstração deste artigo, vamos considerar apenas o tipo QoS 0.

HiveMQ Cloud — Tela do Web Client para assinatura de tópicos de mensagens — [15]

08. Algoritmo

Do ponto de vista do publicador (BananaPi), o algoritmo será composto pelas seguintes etapas:

Login:
Estabelecer conexão remota via SSH entre o computador e BananaPi
Comando Shell:
Executar o arquivo BlinkPublishMQTT via terminal do Linux na BananaPi
BlinkPublishMQTT :
Iniciar a conexão remota com o Broker
BlinkPublishMQTT:
Enviar mensagem para o Broker sinalizando realização do login
BlinkPublishMQTT:
Configurar o pino GPIO7 da BananaPi para saída
BlinkPublishMQTT:
Imprimir a pergunta no terminal do Linux para ligar ou desligar o LED
BlinkPublishMQTT:
Escrever o estado lógico do pino de GPIO7, escolhido pelo usuário
BlinkPublishMQTT:
Ler o estado lógico do pino de GPIO7
BlinkPublishMQTT:
Enviar mensagem para o Broker notificando o estado lógico atual do pino de GPIO7
BlinkPublishMQTT:
Deportar o pino de GPIO7 da BananaPi
BlinkPublishMQTT:
Enviar mensagem para o Broker sinalizando a realização do logout

09. Código em Python

Configuração de credenciais — Arquivo .env

Para executar o código a seguir, é necessário criar o arquivo .env para armazenar as seguintes credenciais de segurança:

MQTT_CLIENT_USERNAME = nome de usuário cadastrado no HiveMQ
MQTT_CLIENT_PASSWORD = senha cadastrada no HiveMQ
MQTT_CLIENT_URL = endereço da URL do Cluster do HiveMQ

Essas credenciais de segurança são necessárias para a autenticação no Broker e o envio das mensagens posteriormente.

Confira abaixo um exemplo do arquivo .env:

Confira abaixo as duas telas com as informações necessárias para armazenar as credenciais de segurança no arquivo .env:

HiveMQ Cloud — Tela de configurações dos acessos para obter ou cadastrar novas credenciais — [15]

HiveMQ Cloud — Tela principal do Cluster para obter a URL do Broker — [15]

Uma vez que temos toda as etapas de configurações realizadas, tanto no ambiente local (na BananaPi) quanto no remoto (HiveMQ), podemos prosseguir para o desenvolvimento do código.

Implementação da classe BlinkPublishMQTT.py

Aviso:

A classe BlinkPublishMQTT foi implementada considerando que será executada apenas em ambiente Linux, como a BananaPi.

Por isso, se for executada em outros ambientes (Windows ou macOS), não funcionará.

Enviando o arquivo via SSH do computador para a BananaPi

Para executar esse projeto, é necessário enviar os seguintes dois arquivos:

Arquivo BlinkPublishMQTT.py
Arquivo .env com as credenciais de segurança

Para fazer isso, basta enviar os dois comandos Shell abaixo no terminal. A senha configurada na BananaPi será requisitada:

$ scp /Users/henriqueotogami/bananapi/python/.env 
pi@bananapi-zero.local:otogamidev/

$ scp /Users/henriqueotogami/bananapi/python/BlinkPublishMQTT.py 
pi@bananapi-zero.local:otogamidev/

Login via SSH na BananaPi

Para acessar a BananaPi, é necessário fazer a autenticação via SSH, utilizando a senha configurada, que será requisitada após o envio do comando abaixo:

$ ssh pi@bananapi-zero.local

Imagem do Terminal após realizar a autenticação via SSH na BananaPi

Verificar a existência do arquivo BlinkPublishMQTT.py na BananaPi

Enviamos o arquivo com o código em Python, mas não verificamos a existência dele internamente na BananaPi, para ter certeza que foi enviado corretamente, antes de preparar o ambiente.

Então basta enviar os dois comandos abaixo, para navegar até o diretório local do projeto e depois listar todos os arquivos presentes nessa pasta:

$ cd ~/otogamidev/

$ ls -la

Instalação da biblioteca python-dotenv na BananaPi

Para carregar as credenciais de segurança presentes no arquivo .env, é necessário utilizar essa biblioteca python-dotenv, utilizando o comando abaixo:

$ pip3 install python-dotenv

Instalação da biblioteca pyenv na BananaPi

Essa biblioteca é utilizada devido a versão do Python global da BananaPi não ser atualizada para uma versão mais recente que o Python 3.5.

A biblioteca paho-mqtt implementa o protocolo MQTT, que será mostrada mais a frente, utiliza versões do Python maiores que a versão 3.7, por isso estaremos utilizamos a versão 3.9 em um ambiente isolado.

$ curl -fsSL https://pyenv.run | bash

Após enviar o comando acima, é necessário configurar as variáveis de ambiente do Linux e baixar pacotes de bibliotecas de desenvolvimento, para que a BananaPi consiga isolar a versão que utilizaremos:

Os comandos para alterar as variáveis do Linux e para baixar os pacotes de bibliotecas de ambiente de desenvolvimento foram encontrados em dois sites:

Instalação biblioteca paho-mqtt na BananaPi

Essa biblioteca implementa o protocolo MQTT no Python, permitindo realizar as etapas de conexão, publicação de mensagens e assinatura no Broker, que serão utilizadas no arquivo BlinkPublishMQTT.py.

$ pip3 install paho-mqtt

Execução do arquivo BlinkPublishMQTT.py

Anteriormente, configuramos o ambiente local da BananaPi para utilizar a versão do Python 3.9, mas não é necessário especificar detalhadamente no momento da execução do arquivo com o código, basta enviar o comando abaixo:

$ python3 BlinkPublishMQTT.py

Após enviar o comando acima, o código em Python será executado conforme o exemplo abaixo:

Exemplo de execução do código em Python no terminal

Durante a execução do código acima no terminal do Linux, as notificações de mudança de estado lógico do LED são enviadas ao Broker conforme a imagem abaixo.

Além disso, implementamos a consulta de horário atual no código em Python para ser anexada em cada mensagem, permitindo a identificação do momento em que as mensagens foram enviadas para o Broker.

HiveMQ Cloud — Exemplo de notificação de mudanças de estado lógico do LED da BananaPi no Broker — [15]

10. Conclusão

O desenvolvimento do projeto demonstrado nesse artigo é relativamente simples, mas proporcionou o entendimento das seguintes tecnologias:

Gerenciamento de pinos de GPIO do hardware da BananaPi
Leitura e escrita em arquivos no Linux via comandos Shell
Acesso e controle remoto da BananaPi via SSH
Criação de ambiente isolado com versão específica do Python
Utilização de implementação do MQTT em Python
Utilização de arquivo com credenciais de segurança em Python
Arquitetura do Protocolo MQTT
Integração entre a BananaPi, Broker AWS e o Web Client HiveMQ

Dentre todo o conhecimento obtido através desse artigo, alguns pontos serão comentados mais detalhadamente a seguir:

Substituição do os.system() pelo subprocess.run()

Durante o desenvolvimento do código em Python, são utilizados comandos Shell para gerenciar o pino de GPIO para acender ou apagar o LED.

Inicialmente foi utilizado a função os.system(), mas a implementação dessa função cria um subshell , não fornece o controle sobre a saída e tratamentos de erros.

Exemplo:

Arquivo exemploLeituraGPIO7.py

import os

os.system("sudo echo 7 > /sys/class/gpio/export")
os.system('sudo echo out > /sys/class/gpio/gpio7/direction')

Principalmente nos casos mostrados acima, em que o comando sudo fornece os privilégios de administrador somente para o echo, mas não repassa para o operador ">", ocasionando em falha que será mostrada a seguir.

Execução exemploLeituraGPIO7.py

$ python3 exemploLeituraGPIO7.py

Execução do código exemploLeituraGPIO7.py no terminal com a falha de permissão

Mensagem de erro:
sh: 1: cannot create /sys/class/gpio/gpio7/direction: Permission denied

Para solucionar esse problema, utilizamos a função subprocess.run(), que permite controle de saída e impede a injeção de comandos, além de parecer mais estável durante os testes.

import subprocess

subprocess.run("sudo echo 7 > tmp", shell = True, check=True)
subprocess.run("sudo cp tmp /sys/class/gpio/export", shell = True, check=True)

subprocess.run("sudo echo out > tmp", shell = True, check=True)
subprocess.run("sudo cp tmp /sys/class/gpio/gpio7/direction", shell = True, check=True)

Um problema semelhante de falha na exportação de pinos de GPIO foi tratado no fórum da Raspberry Pi:

Raspberry Pi: Forum — Export GPIO Failed

Execução do código exemploLeituraGPIO7.py no terminal com sucesso

Desacoplamento da arquitetura do protocolo MQTT

Diferentemente de uma arquitetura cliente — servidor tradicional, o protocolo MQTT funciona de uma forma bem mais simples e distribuída. Isso se deve ao fato que as mensagens publicadas são recebidas pelo Broker e repassadas para os assinantes, então não existe tratamento de dados, apenas encaminhamento.

Então, observando o protocolo como um todo, ele vai servir como um intermediário, considerando que os assinantes podem ser servidores para persistir os dados recebidos do Broker.

Essa característica reduz a necessidade de que dispositivos IoT em campo, como microcontroladores, implementem protocolos complexos para estabelecer uma comunicação segura. Em vez disso, a segurança pode ser delegada ao Broker, que gerencia autenticação e criptografia quando necessário.

Isso também impacta na redução de exigência de hardware, permitindo que equipamentos IoT que utilizam o MQTT possuam um valor mais acessível ao mercado.

11. Referências

Ficou alguma dúvida ou tem sugestões?
Comente aqui embaixo ou me chame em alguma das minhas redes.
Valeu! ✌🏻

Como piscar um LED utilizando BananaPi e Python via SSH

Henrique Otogami — Sat, 15 Mar 2025 19:07:54 +0000

Introdução

Este artigo irá demonstrar como fazer um LED piscar, utilizando o microcomputador BananaPi e um script em Python, via SSH.

Sumário

Etapas do Desenvolvimento
Requisitos
Sobre a BananaPi - BPI-M2 Zero
Identificação de Pinos Disponíveis - GPIO
Ligação de Circuito Elétrico
Código em Python - Blink.py
Conexão via SSH
Vídeo Demonstrativo
Referências

01. Etapas do Desenvolvimento

01. Identificar o pino de GPIO disponível para uso na BananaPi
02. Realizar a ligação do circuito elétrico
03. Desenvolver o código
04. Enviar o arquivo de código para a BananaPi
05. Executar o arquivo de código

02. Requisitos

Configuração de conexão via SSH realizada na BananaPi
Versão do Python 3.10 instalado na BananaPi

03. Sobre a BananaPi - BPI-M2 Zero

A BananaPi M2 Zero é um computador de placa única ultracompacto que mede apenas 60 mm x 30 mm. Ela usa um processador quad-core Cortex A7 allwinner H2+, com 512 MB de memória RAM. É ideal para sistemas leves com alguns aplicativos com espaço limitado. Como outros dispositivos da BananaPi, ele suporta os sistemas operacionais Linux e Android. [1]

Principais características

CPU Quad Core ARM Cortex A7 H2+
512 MB de SDRAM.
WiFi (AP6212) e Bluetooth integrados.
Mini-HDMI.

A BananaPi que estou utilizando possui a distribuição Debian GNU/Linux.

04. Identificação de Pinos Disponíveis - GPIO

BananaPi - Documentação Técnica - Esquema Elétrico - GPIOs [3]

Os pinos disponíveis para entrada ou saída são identificados como "IO-xx".

Conforme recorte da documentação técnica mostrada acima, serão utilizados o pino físico 29 (GPIO 7) e o pino físico 6 (GND 3).
Utilizei o GPIO 7 porque os pinos GPIO 0 a GPIO 6 estão reservados para a UART.

GPIO = General Purpose Input/Output

05. Ligação de Circuito Elétrico

Foto em bancada - Circuito elétrico na protoboard

Software Fritzing - Circuito elétrico na protoboard [5]

O circuito elétrico mostrado na imagem acima, é composto dos seguintes itens:

Fio Jumper Vermelho Macho-Fêmea
Fio Jumper Marrom Macho-Fêmea
Resistor 330 Ohms
LED difuso 5mm Verde

Observação: A BananaPi foi inspirada no RaspberryPi Zero, por isso ambos tem formatos semelhantes. No software Fritzing, só existia o modelo do Raspberry.

06. Código em Python - Blink.py

Gist - Código em Python para fazer o led piscar a cada 3 segundos [4]

O código mostrado acima foi desenvolvido em Python para executar os comandos de Shell Script na BananaPi. Esses comandos vão gerenciar o pino de GPIO que alimenta o LED, conforme essas etapas:

Exportação do pino físico: 29 (GPIO 7)

$ sudo echo 7 > /sys/class/gpio/export

Definição de direção do pino: saída (out)

$ sudo echo out > /sys/class/gpio/gpio7/direction

Definição do valor de nível lógico: alto (1)

$ sudo echo 1 > /sys/class/gpio/gpio7/value

Definição do valor de nível lógico: baixo (0)

$ sudo echo 0 > /sys/class/gpio/gpio7/value

Consultar a direção do pino:

$ sudo cat /sys/class/gpio/gpio7/direction

Consultar o valor do pino:

$ sudo cat /sys/class/gpio/gpio7/value

Observação: Considerei utilizar o comando sudo em todas as etapas para garantir que teria permissões de nível de administrador para gerenciar o pino do GPIO.

07. Conexão via SSH

Envio do arquivo Blink.py para a BananaPi

Para enviar o arquivo com o código em Python, basta utilizar o comando abaixo:

$ scp /Users/henriqueotogami/bananapi/blink.py pi@bananapi-zero.local:

A senha será requerida e, após ser inserida, o arquivo será enviado.

Envio com sucesso do arquivo Blink.py

Observação: o envio do arquivo deve ser feito antes do acesso a BananaPi via SSH. Se o login já tiver sido feito, será necessário realizar o logout para enviar o arquivo e o login logo em seguida.

Acesso a BananaPi

Para realizar o acesso remotamente da BananaPi, envie o seguinte comando:

$ ssh pi@bananapi-zero.local

A senha de login da BananaPi será requerida e, após ser inserida, o login será iniciado.

Login e senha na BananaPi via SSH

Para confirmar que o arquivo Blink.py está na BananaPi, após o login, envie o comando:

$ ls

Consulta da existência do arquivo Blink.py na BananaPi após o login via SSH

Execução do código via terminal

Para que o arquivo com o script em Python seja executado, utilize o seguinte comando:

$ python3 blink.py

Executando o arquivo com o script em Python no terminal

08. Vídeo demonstrativo

Apenas para demonstrar a execução do código e dos logs no terminal que foram descritos acima, segue vídeo abaixo apenas demonstrando o led piscando.

09. Referências

[1] - BananaPi - Introdução
[2] - BananaPi - Documentação
[3] - BananaPi - Esquema Elétrico
[4] - Gist - Blink.py - Script em Python
[5] - Fritzing - Circuito Elétrico

Ficou alguma dúvida ou tem sugestões?
Comente aqui embaixo ou me chame em alguma das minhas redes.
Valeu! ✌🏻

Muito obrigado!

Desafio do LeetCode: Validação de Sequência de Parênteses

Henrique Otogami — Sat, 15 Mar 2025 15:49:52 +0000

Introdução

Neste artigo, vou apresentar a implementação de um desafio simples de validação de caracteres de texto em Java.

Se você não me conhece, meu nome é Henrique Otogami e seja bem-vindo(a) ao meu perfil no DevTo.

Comecei a utilizar a plataforma Leetcode para resolver outros desafios como esse. Esses desafios são utilizados em entrevistas, e na plataforma são separados por nível de dificuldade, por categorias, por listas de estudo e etc.

Desenvolvimento

01. Descrição

-- Certo, mas qual é o desafio?

O desafio consiste em analisar uma sequência de parênteses, colchetes e chaves, e verificar se a ordem de abertura e fechamento está correta.

Slide 01 - Quatro linhas de sequências de abertura e fechamento de parênteses

Slide 02 - Exemplos de sequências válidas (em verde) e inválidas (em vermelho) de parênteses

-- Parece simples, não é?
-- Na real, é simples mesmo.

A sequência deve ser informada em formato de texto, e deve conter apenas parênteses, colchetes e chaves. Outros caracteres não são permitidos.

Slide 03 - Descrição do desafio

No exemplo utilizado no slide 3, os caracteres são mostrados separadamente, mas foi feito dessa forma apenas para demonstrar os caracteres.

02. Requisitos

-- Agora, vamos aprofundar nas regras desse desafio.
-- Vem comigo.

Para realizar a validação da implementação da solução para esse problema, precisamos considerar os requisitos informados na descrição no Leetcode:

Os caracteres de abertura devem ser fechados por caracteres do mesmo tipo, porém de fechamento. Por exemplo, um parêntese deve ser aberto para ser fechado por outro parêntese. Ou, um parêntese não pode ser fechado por um colchete.
Os caracteres devem ser abertos para depois serem fechados. Embora pareça ser uma condição óbvia, é necessário explicitar todas as condições necessárias.
Todos os caracteres abertos devem ser fechados. Logo, o tamanho da sequência sempre é par e a quantidade de caracteres de abertura será igual a quantidade de caracteres de fechamento.

Slide 04- Requisitos de validação de sequências

03. Exemplos de validação

-- Tá, mas temos exemplos dessas regras de validação?
-- Temos.

Para exemplificar cada uma dessas condições de validação, separei em três exemplos:

Abertura e fechamento de um único par de parênteses:
Exemplo que representa apenas a condição mais simples possível.
Validação com retorno verdadeiro;
Sequência de abertura e fechamento de parênteses, colchetes e chaves:
Exemplo que representa a condição de tipos diferentes, respeitando a ordem de abertura e fechamento corretamente.
Validação com retorno verdadeiro;
Abertura de um tipo e fechamento de outro tipo:
Exemplo que representa a condição de ordem incorreta de abertura e fechamento.
Validação com retorno falso.

Slide 05 - Exemplos dos requisitos de validação de sequências

04. Considerações

-- E o código?
-- Já vamos chegar nessa etapa.

Antes disso, precisamos saber das duas restrições que foram impostas na descrição deste problema:

O tamanho da sequência deve ser maior que um e menor que dez mil caracteres;
A sequência deve conter apenas parênteses, colchetes e/ou chaves.

Durante a minha implementação, eu adicionei mais duas verificações:

Tamanho da sequência recebida deve ser par;
Tamanho da matriz de índices de fechamento deve ser zero no final do fluxo;

-- Não entendeu?
-- Maiores detalhes serão mostrados a seguir.

Slide 06 - Considerações de validação de sequências

05. Algoritmo

-- Ainda não é o código?
-- Não, mas esse é o algoritmo extraído do código implementado.

O algoritmo compõe a solução submetida e aceita no Leetcode, e será apresentado como uma visão panorâmica da implementação:

-- Iniciar o algoritmo recebendo a sequência de parênteses;
-- Verificar se o tamanho da sequência recebida é par;
-- Armazenar um caractere da sequência recebida;
-- Verificar se é um caractere de abertura:
---- É um caractere de abertura;
------ Armazenar o índice do caractere de fechamento;
------ Salvar o índice do caractere de fechamento na lista.
---- Não é um caractere de abertura;
------ Armazenar o último índice da lista;
------ Verificar se o caractere armazenado é igual ao último índice;
------ Remover o último índice da lista;
------ Definir que a sequência recebida é válida.

-- Verificar se terminou a sequência:
---- A sequência já terminou;
------ Verificar se o tamanho da lista é zero;
------ Retornar verdadeiro. A sequência recebida é válida;
------ Retornar falso. A sequência recebida é inválida.
---- A sequência não terminou;
------ Voltar a etapa 3.

Agora que sabemos as restrições, os requisitos, os exemplos e a visão panorâmica do algoritmo, vamos para a etapa de implementação dessa solução.

Slide 07 - Fluxograma do algoritmo para validação de parênteses

06. Implementação

A implementação desse algoritmo foi realizada utilizando o Java 8. Como desafio pessoal, tentei desenvolver da forma mais simples que eu consegui, pensando em deixar o código mais performático possível.

Slide 08 - Implementação do algoritmo de validação de parênteses

07. Conclusão

No momento de submissão desse código, a plataforma indica quanto tempo foi necessário para a execução e a quantidade de espaço utilizada. Nesta minha implementação, o tempo total foi de 13 milissegundos e 44MB de espaço.

Por fim, pretendo desenvolver mais desafios semelhantes a esse, para melhorar minhas competências técnicas, e trazê-los em forma de conteúdo.

LeetCode: implementação submetida

Ficou alguma dúvida ou tem sugestões?
Comente aqui embaixo ou me chame em alguma das minhas redes.
Valeu! ✌🏻

Muito obrigado!

Por que o Java converte números inteiros maiores que 127 para valores negativos em castings do tipo byte?

Henrique Otogami — Tue, 23 May 2023 00:48:49 +0000

Imagem 01 — Exemplo de “modelagem” de um número inteiro em um byte.

Pegue um cafézinho, vamos conversar

Tropecei na conversão e continuei (~andando~) programando

Durante meu dia a dia no trabalho, é recorrente trabalhar com conjuntos de dados em bytes. Em um desses dias, armazenei um número inteiro "modelando-o" (casting) em uma variável que esperava receber um byte, semelhantemente ao exemplo da Imagem 01.

Quando fui verificar o valor contido nessa variável, percebi o valor negativo, convertido e armazenado nela.

A princípio, não entendi a razão disso.

Depois de pesquisar, descobri que, internamente, o Java implementa o algoritmo do Complemento de Dois para alguns tipos primitivos de dados, como o de bytes.

Resumidamente, a função dele é converter um número inteiro positivo para outro número inteiro negativo, mantendo fixo o comprimento máximo de sua representação binária.

Photo by Amanda Sandlin on Unsplash.

Acabou o cafézinho, vamos a obra

Definição do algoritmo original do Complemento de Dois

Antes de entender como o Java está implementando o algoritmo, vamos conhecer um pouquinho da definição do algoritmo original, no trecho abaixo.

"Two’s complement is a mathematical operation to reversibly convert a positive binary number into a negative binary number with equivalent negative value, using the binary digit with the greatest place value as the sign to indicate whether the binary number is positive or negative.
It is used in computer science as the most common method of representing signed (positive, negative, and zero) integers on computers, and more generally, fixed point binary values.
When the most significant bit is 1, the number is signed as negative; and when the most significant bit is 0 the number is signed as positive."

Fonte [1]

GIF 01 — Imagem animada contendo uma pessoa com a mente caótica após ler a explicação técnica.

Se você não entendeu a definição do algoritmo, não se preocupe. Vamos ver a estrutura lógica, detalhada abaixo.

Lógica do algoritmo original do Complemento de Dois

Observação: Vamos considerar o nome “decimalToParser” para o número inteiro.

O decimalToParser deve ser inteiro (positivo ou negativo);
Utilize a Equação 01:

$secondComplement = [ (2 ^ n) - | decimalToParser | ]$ Equação 01 — Fórmula para calcular o segundo complemento do algoritmo de Complemento de Dois.
Obtenha o valor binário do resultado da Equação 01;
Inverta o valor binário do resultado;
Identifique o bit mais significativo (MSB) do valor binário invertido. O bit mais significativo está posicionado na extremidade esquerda;
Verificar o valor do bit mais significativo:
- Se for zero (“0”), o valor final do segundo complemento deve ser positivo;
- Se for zero (“1”), o valor final do segundo complemento deve ser negativo;

Parâmetros da Equação 01:

secondComplement é o valor calculado do segundo complemento;
2 é o número indicativo de um sistema binário;
n é o número indicativo do tamanho de bits (explicado abaixo);

Observação: O valor de decimalToParser está em módulo na equação 01.

Ainda não entendeu?
Não se preocupe, eu trouxe exemplos abaixo 😂 😂 😂 😂

GIF 02 — Imagem animada mostrando uma pessoa tranquilizando alguém em estado de desespero.

Algoritmo original: Exemplo da lógica de cálculo

Utilizando o valor (207 em decimal) que foi convertido (-49 em bytes) na Imagem 01, acompanhe a demonstração de cálculo do algoritmo em seis etapas, conforme mencionado acima, na Imagem 02 abaixo.

Imagem 02 — Demonstração de cálculo em seis etapas do algoritmo original do Complemento de Dois.

Algoritmo original: Exemplo de implementação de cálculo no Java

Utilizando a mesma estrutura da demonstração da Imagem 02, acompanhe abaixo a implementação em Java.

Código 01 — Implementação em Java da demonstração realizada na Imagem 02.

Se você quiser contribuir com o código acima no Gist, acesse:
TwosComplement.java

A implementação do algoritmo utilizada no Java

Definição do tipo de dados primitivo de byte

Primeiramente, é necessário entender a estrutura de dados primitivos, por isso considere a definição de byte na documentação do Java:

“byte: The byte data type is an 8-bit signed two's complement integer. It has a minimum value of -128 and a maximum value of 127 (inclusive).
The byte data type can be useful for saving memory in large arrays, where the memory savings actually matters.
They can also be used in place of int where their limits help to clarify your code; the fact that a variable's range is limited can serve as a form of documentation."

Fonte [2]

Para ficar mais fácil de perceber a diferença, podemos resumir a definição acima comparando os tamanhos de tipos de dados mencionados:

Imagem 03 — Exemplo do tamanho em bits dos tipos primitivos int e byte no Java.

Então, como diz no trecho citado da documentação, o objetivo da utilização do tipo de dados de byte é para economizar a memória interna disponível no hardware. Além disso, limitar a largura de bits dos dados implica em aumentar a performance do processamento ou de cálculos em baixo nível.

Algoritmo implementado no java: Exemplo em código

Código 02 — Implementação do algoritmo conforme padrão do Java.

Se você quiser contribuir com o código acima no Gist, acesse:
JavaTwosComplement.java

Exemplo executável

A vida do dev não se resume a teoria, não é mesmo? 😂 😂 😂 😂

Por isso, eu também trouxe um exemplo executável para simular a estrutura explicada acima, dos dois algoritmos.

Código 03 — Classe em Java com método de cálculo do complemento de dois implementado.

Se você quiser contribuir com o código acima, basta clicar em "Open on Replit".

Tá, mas qual é a vantagem de utilizar esse algoritmo?

1. Padronização para menor consumo de dados

Conforme foi explicado anteriormente, o Java define que o tipo primitivo byte possui o tamanho de oito bits, por padrão.

Ou seja, quando necessários, os cálculos a serem realizados com esses dados serão mais simples de serem realizados e exigirão bem pouco do hardware.

2. Soma e subtração sem verificar o sinal dos operandos

O algoritmo original do Complemento de Dois considera que todo número positivo será representado por um número negativo e vice-versa. Esse número negativo corresponde a outro decimal calculado pela Equação 01.

Considerando a afirmação acima do algoritmo original, a Imagem 04 abaixo mostra o exemplo do cálculo entre um número positivo e outro negativo.

Para realizar esse cálculo, não é necessário verificar o sinal de cada operando. Basta apenas encontrar o complemento de dois do número negativo e realizar a soma com o valor binário do número positivo, considerando as regras de soma binária.

O algoritmo ainda diz que a soma de um valor binário de um número decimal com o binário do seu complemento de dois deve resultar em zero. E essa verificação é demonstrada no item 1.2 da Imagem 04.

Imagem 04 — Exemplo de operação de soma / subtração utilizando o Complemento de Dois.

Fontes

01 - Artigo na Wikipedia ;

02 - Java makes use of the "two's complement" for representing signed numbers | by Jean Villete ;

03 - Two's complement solution very detailed explanation | by kapkan ;