Em artigo anterior, saídas digitais foram adicionadas a um PC por meio de um conversor USB-Serial. Este artigo introduz uma expansão da ideia anteriormente apresentada, adicionando entradas digitais, para os casos em que o PC precisa, além de saídas digitais para controle, de entradas digitais para monitorar o estado do dispositivo externo.
A interface física de controle
Para o projeto, foram usados os conversores USB-Serial mostrados na Figura 1. Os pinos TxD, DTR e RTS podem ser usados como saídas, e os pinos CTS, DCD, DSR e RI podem ser usados como entradas. Esses conversores permitem fácil acesso aos pinos de entrada e saída, por meio de barras de pinos ou fios soldados aos furos metalizados. A tensão de alimentação conversor da esquerda, baseado no FT232RL, pode ser configurada para 3,3V ou 5,0V, enquanto a tensão de alimentação do conversor da direita, baseado no CP2102N é de 3,3V. Os dois conversores têm pontos de acesso à tensão VBUS da porta USB, permitindo alimentar circuitos a ele conectados, respeitando-se os limites da porta USB do PC e tomando os devidos cuidados para evitar danificá-la.
A Figura 2 apresenta um diagrama de conexões entre o conversor USB-Serial com o CP2102N e uma placa de relés usada no teste descrito adiante. As saídas DTR, RTS e TxD do conversor USB-Serial são ligadas, respectivamente, às entradas IN1, IN2 e IN3 da placa de relés. As entradas CTS, DCD, DSR e RI são ligadas a chaves tácteis, que simulam sensores ou saídas digitais de um sistema externo.
Os Melhores Treinamentos sobre Sistemas embarcados e IoT
Cursos com professores qualificados para acelerar sua carreira e projetos
As saídas e entradas da UART do conversor usam lógica negativa, isto é, são ativas quando o nível lógico/tensão é baixo. As bobinas dos relés dessa placa são energizadas quando as respectivas entradas (IN1 a IN4) têm nível de tensão 0V. As entradas da UART são ativas (nível lógico zero) quando a chave táctil correspondente aterra a entrada ao ser pressionada.
A placa de relés é alimentada pela saída de 5V do conversor, ligada ao VBUS do conector USB. A bobina de cada relé dessa placa consome cerca de 70mA, portanto o consumo total de corrente é inferior ao limite de uma porta USB 2.0, de 500mA. Em uma aplicação real, recomenda-se avaliar se essa é uma opção segura e confiável, verificando se o chaveamento dos relés não causa transientes de tensão que podem comprometer a confiabilidade da aplicação ou mesmo a integridade da porta USB.
O software: o código em Python
O código a seguir (usb_uart_io.py) apresenta uma pequena classe para controlar as saídas e monitorar o estado das entradas do conversor USB-Serial.
#! /usr/bin/env python3
from serial import Serial
ON, OFF = True, False
class UsbUartIo(Serial):
def __init__(self, port='/dev/ttyUSB0'):
super().__init__(port)
self.dtr = False
self.rts = False
def __del__(self):
self.break_condition = False
self.dtr = False
self.rts = False
super().__del__()
def out1(self, state):
self.dtr = state
def out2(self, state):
self.rts = state
def out3(self, state):
self.break_condition = state
def inp1(self):
return self.cts
def inp2(self):
return self.dsr
def inp3(self):
return self.cd
def inp4(self):
return self.ri
A classe UsbUartIo herda da classe Serial, que faz parte dos pacotes do Python instalados no Linux. Quando instanciada, a classe coloca as saídas DTR e RTS no estado inativo. As considerações sobre essas saídas feitas no artigo anterior se aplicam. Foram usados identificadores genéricos (outX/inpX) nesta classe, mas identificadores autoexplicativos podem ser usados em aplicações reais.
Juntando as partes: o teste
O código a seguir apresenta o script tst_uuio.py usado para executar o teste, usando a classe UsbUartIo.
#! /usr/bin/env python3
from usb_uart_io import UsbUartIo
import time
def main():
uio = UsbUartIo()
while True:
uio.out1(uio.inp1() or uio.inp4())
uio.out2(uio.inp2() or uio.inp4())
uio.out3(uio.inp3() or uio.inp4())
time.sleep(0.2)
if __name__ == "__main__":
main()
Esse script deve estar no mesmo diretório do módulo usb_uart_io.py e ele deve ser tornado executável com o chmod. O teste monitora o estado das chaves e, se uma chave é pressionada, o relé correspondente é acionado (sua bobina é energizada). A quarta chave, quando pressionada, faz com que os três relés sejam acionados.
A Figura 3 apresenta o setup de teste com o conversor USB-Serial baseado no CP2102N. A Figura 4 apresenta o setup com o conversor baseado no FT232RL.
Um vídeo do teste feito com o setup da Figura 4 pode ser visto a seguir:
O código-fonte do teste pode ser baixado de https://github.com/cve2022/usb-uart-io .
Conclusão
Este artigo apresentou uma forma de adicionar entradas e saídas digitais a um PC. Essas entradas e saídas podem ser usadas para implementar ferramentas de desenvolvimento de sistemas embarcados, para prototipação rápida ou testes de prova de conceito, ou mesmo sistemas de controle baseados em PC, para projetos em que plataformas como Arduino, Raspberry Pi e similares não consigam atender os requisitos do projeto.
Muito interessante. Me lembro de quando havia artigos em Delphi ou Vbasic e artigos do tipo em revistas de eletrônica tipo saber eletrônica. Bela matéria.