Leitura de porta serial utilizando Python e Raspberry PI · /dev/ser
Passo 1 – Obtenha a documentação do fabricante
Sempre que você deseja se comunicar com um produto de terceiros (seja ele um hardware, ou até mesmo um webservice), o primeiro passo é obter a documentação do fabricante, para entender como a comunicação deve ser realizada.
Estudando os manuais dos dois produtos (balança Toledo 820J/XIV e display Toledo 8540), você irá descobrir que o fabricante disponibilizou uma porta serial RS232 no display Toledo 8540 que publica, em uma taxa de 4 a 5 vezes por segundo, o valor medido no display.
Faça download da documentação do display Toledo 8540
O manual pode parecer confuso, mas, com certo esforço e paciência, é possível identificar os principais pontos da comunicação.
Passo 2 – Obtenha um emulador do hardware
Este passo é opcional, mas com certeza ajuda muito durante o desenvolvimento quando você não tem um hardware real à sua disposição para os testes iniciais.
Pesquise se existe um emulador oficial produzido pelo próprio fabricante, ou então se alguma alma caridosa implementou e disponibilizou algum emulador extra-oficial em algum fórum especializado, ou blog.
No caso do display Toledo 8540, após 1 ou 2 horas de pesquisa, não encontrei nenhum emulador para o meu sistema operacional Linux (distribuição Debian). Encontrei alguns links somente para Windows.
Sendo assim, pulei esta etapa e prossegui para o próximo passo.
Passo 3 – Emule uma porta serial com o programa socatdo Linux
O programa socatdo Linux permite criar portas seriais virtuais (emuladas). Elas podem ser muito úteis para fazer testes rápidos.
Exemplo de execução de comando:
Na minha máquina, o comando acima imprimiu a seguinte saída (pode variar para o seu caso):
2018/03/02 14:14:51 socat[27691] N PTY is /dev/pts/29
2018/03/02 14:14:51 socat[27691] N PTY is /dev/pts/30
2018/03/02 14:14:51 socat[27691] N starting data transfer loop with FDs [5,5] and [7,7]
Passo 4 – Explore a comunicação serial utilizando o programa screen do Linux
O programa screen do Linux, entre outras coisas, é capaz de ler continuamente de uma porta serial e imprimir no terminal tudo o que está sendo lido.
É uma ótima ferramenta exploratória.
Por exemplo, para conectarmos o screen às portas virtuais criadas no passo anterior, executamos em uma janela do terminal o comando a seguir:
screen /dev/pts/29
Em outra janela do terminal, conectamos à segunda porta (ver número da porta conforme saída do comando socat)
screen /dev/pts/30
Agora, abra as janelas 1 e 2 do terminal lado a lado. Clique na janela 1, e digite alguns caracteres. Surpresa! Os caracteres digitados serão imprimidos na janela 2.
Isso acontece porque o programa socat simulou uma conexão serial RS232. Ao digitar caracteres em um lado da conexão, você na verdade está enviando um "sinal elétrico" para o outro lado do cabo.
Passo 5 – Programa em Python de leitura serial
Após algumas análises exploratórias do seu hardware e da comunicação serial, você está pronto para criar um programa em Python para fazer a leitura.
Eu utilizei o Python 2.7, mas provavelmente você não terá dificuldades em migrar esse script para Python 3.
# Arquivo config.py
# Serial port (COM port)
# Webservice endpoint
webservice = "https://webservice.mydomain.com/publicar-dados-balanca"
# Webservice authentication token (see weighing_scale class)
webservice_token = "4ff86e02514dd8f3610b83ee6947ccf9"
# Name of the scale
weighing_scale_identifier = "MINHA_BALANCA_1"
# Unit of the scale
unit = 'kg'
# Interval, in seconds, for updating data into the webservice
webservice_publication_interval = 1
# Arquivo reader.py
config.serial_port,
) as ser:
line = ser.read(18)
formattedLine = ":".join("{:02x}".format(ord(c)) for c in line)
print formattedLine
O que o programa acima faz é muito simples, mas já é um grande passo rumo ao nosso objetivo.
O programa simplesmente define um loop infinito, lendo tudo que chega por meio da porta /dev/ttyUSB0, convertendo para hexadecimal, e imprimindo no terminal, permitindo monitorar com mais qualidade tudo que o hardware (ou emulador) enviou via porta serial, já que nem sempre serão enviados somente dados correspondentes às letras da tabela ASCII.
Agora podemos testar o nosso programa utilizando a conexão serial criada com o comando socat anteriormente. Para isso, temos que fazer as seguintes modificações:
Alterar a porta "/dev/ttyUSB0″ para a porta virtual. No meu caso, "/dev/pts/29″.
Importante! Precisamos comentar os parâmetros byteserial=… e parity=… do script acima, pois esses dois parâmetros não funcionam com a porta serial emulada. Entretanto, quando formos utilizar o hardware real, devemos reabilitar esses 2 parâmetros, respeitando as especificações do hardware.
Com o programa do passo anterior, podemos gravar, por alguns minutos, a leitura real proveniente do hardware. Verifique se a porta "/dev/ttyUSB0″ realmente se refere ao hardware do seu display Toledo 8540, e em seguida rode o programa usando o python, redirecionando o output para um arquivo de texto.
python reader.py > serial_output
Deixe o programa rodando por alguns minutos. O arquivo /tmp/serial_output será util para você testar o restante do programa sem depender do hardware real. O que estamos fazendo é gravar um arquivo de "replay", assim podemos emular fielmente o hardware real, sempre que precisarmos.
Se você não tem um hardware real disponível para gravar esse arquivo de "replay", baixe aqui o arquivo serial_output.txt que eu gerei com o meu hardware.
Passo 7 – Programa em python para traduzir a saída hexadecimal (gerada pelo programa anterior)
Agora que já temos um arquivo de replay (/tmp/serial_output), podemos emular mais fielmente os dados enviados pelo hardware. Usaremos esse arquivo para testar o restante do nosso programa.
O próximo programa que criaremos será responsável por traduzir a saída hexadecimal para uma saída legível para humanos.
# Arquivo processor.py
def validate(byteArray):
if len(byteArray) != 18:
if byteArray[0] != '02':
if byteArray[16] != '0d':
def weight(byteArray):
weightString = ""
weightString += intValue(byteArray[i])
return weightString
def intValue(byteString):
return chr(int(byteString, 16))
bytes = line.split(":")
if (validate(bytes)):
return weight(bytes)
formattedWeight = parse(line)
if (formattedWeight):
print "%s ::: %s ::: %s" % (time.time(), formattedWeight, config.unit)
O programa acima lê, linha a linha, o output gerado pelo programa 1 (reader.py), e converte para o formato desejado. Além disso, o método validate() confere que o primeiro byte da linha é 02, e que o byte da posição 17 é 0d. Esses dois bytes estão especificados na documentação obtida no passo 1, e nos permitem descartar qualquer dado com ruído que possa ter sido recebido pela conexão serial.
Para testar esse programa, vamos imprimir o conteúdo do arquivo de replay de dados (/tmp/serial_output) e fazer um pipe para o programa tradutor.
cat /tmp/serial_output | python processor.py
Ao rodar o comando acima, você deverá visualizar a seguinte saída em seu terminal:
Para rodar junto ao harware real, o comando é similar:
python reader.py | python processor.py
Passo 8 – Publicar os dados traduzidos via webservice
Este passo é opcional, e vai depender da necessidade do seu cliente. No meu caso, optei por publicar via webservice, a cada 1 segundo, o valor lido da balança.
# Arquivo publisher.py
LAST_PUBLICATION_TIMESTAMP = time.time()
data = line.strip().split(" ::: ")
if (validate(data)):
return sanitize(data)
data[2] = re.sub("[^a-zA-Z]", "", data[2])
def needsPublishing():
interval = time.time() - LAST_PUBLICATION_TIMESTAMP
return (interval > config.webservice_publication_interval)
global LAST_PUBLICATION_TIMESTAMP
if not needsPublishing():
'token': config.webservice_token,
'weighing_scale_identifier': config.weighing_scale_identifier,
'timestamp': data[0],
'weight': data[1],
'unit': data[2]
cmd = ["curl", "-X", "POST", "--max-time", "10", "--data", urllib.urlencode(data), config.webservice]
p = Popen(cmd)
Para testar o último programa, podemos usar os dados de replay, ou então o hardware real.
Opção 1 – Arquivo de replay
cat /tmp/serial_output | python processor.py | python publisher.py
Opção 2 - Hardware real
python reader.py | python processor.py | python publisher.py
Se tudo deu certo, você terá uma leitura contínua (com taxa de 1 publicação por segundo) sendo publicada em seu webservice.
Passo 9 – Testar software para o Raspberry PI
Felizmente, o Raspberry PI utiliza a distribuição Raspbian, baseada no Debian. Portanto, não precisei fazer nenhum tipo de adaptação para que o meu programa que estava rodando no meu notebook com Debian 9 funcionasse sem problemas no Raspberry PI.
Tive apenas que instalar algumas dependências que não são instaladas por padrão, como por exemplo o python. Mas nada que alguns apt-get install não resolvessem rapidamente.
Para conectar o display Toledo 8540 no Raspberry PI, utilizei um cabo conversor RS232/USB da marca Digitus, com chipset FT232RL. Enfim, qualquer conversor comprado no Mercado Livre deve funcionar bem também.
Passo 10 – Configurar programa para rodar sempre que o Raspberry for conectado à tomada
Essa etapa também é muito simples, já que o próprio Linux possui esse recurso.
Precisamos apenas editar o arquivo /etc/rc.local e incluir o comando que execute os nossos programas. No meu caso, o arquivo /etc/rc.local ficou assim:
# Start Balança
cd /home/pi/balanca/ && (python reader.py | python processor.py | python publisher.py) >> /dev/null 2>&1 &
Sendo que as únicas alterações que fiz nesse arquivo foram inicializar o servidor SSH (que antes eu instalei com apt-get install), e adicionei a linha que executa o nosso programa em python.
Passo 11 – Instalação do watchdog
Nosso projeto já está funcionando muito bem, mas podemos dar mais robustez ao nosso sistema instalando e configurando o programa watchdog do Linux. Não detalherei neste artigo como fazer isso, mas recomendo que você tente estudar e configurar esse programa por sua própria conta.
Com ele, podemos definir alguns critérios de saúde do sistema operacional do nosso Raspberry PI. Quando qualquer desses critérios não estiver sendo respeitado, o aplicativo irá automaticamente rebootar a placa. Assim, não precisamos nos preocupar (tanto!) com desperdício de memória RAM, perda de conexão de rede, CPU load altíssimo, etc.
Dica bônus - Armazene seus dados no banco NoSQL AWS DynamoDB Você deve ter percebido que, 1 vez por segundo, toda nova leitura da balança é publicada no webservice, mesmo quando o peso é 0kg. Isso pode parecer desperdício à primeira vista, mas é muito útil pois nos passa uma garantia maior de que o sistema está funcionando a todo instante, mesmo quando não há peso na balança.
Mesmo com essa importante vantagem, não podemos ignorar o fato de que essa escolha acarreta um alto custo de armazenamento. Sendo assim, aproveito aqui para oferecer uma dica adicional: o sistema AWS DynamoDB permite armazenar até 25GB de dados gratuitamente, o que estimei que será suficiente para gravar um registro por segundo por mais de 8 anos.
Sendo assim, optei por configurar o webservice para armazenar os meus dados no DynamoDB, e recomendo que você também estude essa opção. Para mais informações, acesse https://aws.amazon.com/pt/dynamodb/.
Pronto, se você chegou até aqui, tem um projeto totalmente funcional que faz a leitura contínua do valor medido pelo display Toledo 8540. Em caso de dúvidas, me avise pelos comentários!