ESP32 Modbus Master TCP: 7 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

Nesta aula, você irá programar o processador ESP32 para ser Modbus TCP Master.

Usaremos dois dispositivos, que contêm este processador: Moduino ESP32 e Pycom. Ambos os dispositivos estão funcionando em ambiente MicroPytthon. Nosso Modbus Slave será um computador PC com o software simulador Modbus rodando nele.

Você vai precisar de:

• Dispositivo Moduino ESP32 ou Moduino Pycom (verifique este site para saber mais sobre o dispositivo Moduino ESP32 e este para verificar o dispositivo Pycom)
• PC com sistema operacional Linux
• Porta RS-232 / RS-485 em seu computador ou conversor USB para RS-232 / RS-485

Etapa 1: Baixe e inicie o simulador Modbus TCP Slave

Baixe o simulador Modbus Slave em https://www.modbusdriver.com/diagslave.html. Abra o arquivo baixado e descompacte a versão do sistema operacional Linux.

Execute o programa do console com o argumento -p:

./diagslave -p

é uma porta onde o servidor Modbus Slave funcionará. Para o protocolo Modbus, é por padrão 502, mas você pode usar outro.

No Linux, as portas abaixo de 1024 não podem ser usadas por programas executados a partir de um usuário normal (não com privilégios de root).

Lembre-se de qual porta você está usando. Este valor será necessário posteriormente.

Etapa 2: Prepare seu computador para se conectar ao dispositivo

Você precisará de alguns programas para se conectar ao dispositivo e enviar arquivos para ele.

Instale o ambiente Python e pip (se você não tiver):

apt-get install python3

apt-get install python3-dev curl "https://bootstrap.pypa.io/get-pip.py" -o "get-pip.py" python3 get-pip.py

Instale o picocom:

apt-get install picocom

Este programa é necessário para se conectar ao dispositivo e executar comandos nele. Instale o mpfshell:

pip instalar mpfshell

Este programa permite que você envie arquivos para o dispositivo.

Você também pode instalá-lo em fontes de formulário. Consulte esta página:

Etapa 3: preparar o dispositivo e conectar-se a ele

Para conectar o dispositivo Moduino ou Pycom ao PC, você precisa de uma porta ou conversor RS-232 / RS-485. Verifique a versão do seu dispositivo (que tipo de porta ele usa) e encontre a porta ou conversor apropriado.

1. Conecte o dispositivo ao PC
2. Em seguida, conecte a fonte de alimentação a ele

Conecte o dispositivo ao PC e, em seguida, conecte a fonte de alimentação a ele. Você também pode conectar o cabo Ethernet ao Moduino ESP32 (se tiver essa porta).

A conexão deve ser como nas fotos acima

Encontre o caminho para a porta, que é usada para a conexão do dispositivo. Pode ser, por exemplo: / dev / ttyS1, / dev / ttyUSB0.

Para conversores usb, o caminho conterá a palavra USB.

Você pode se conectar ao dispositivo com o programa picocom:

picocom / dev / ttyUSB0 -b 115200

O prompt de comando do dispositivo é semelhante a uma das imagens abaixo.

Moduino ESP32: Veja aqui

Moduino Pycom: Veja aqui

Etapa 4: Carregar a Biblioteca Mestre Modbus

github.com/pycom/pycom-modbus/Para se comunicar com o Modbus Slave, você precisa da biblioteca apropriada. Bibliotecas para Pycom não são compatíveis com Moduino. Verifique as instruções que estão em conformidade com o seu dispositivo.

Feche o picocom antes de enviar os arquivos: pressione Ctrl + A e depois as teclas Ctrl + X.

Biblioteca uModBus para Moduino ESP32 baseia-se na biblioteca pycom-modbus para Moduino Pycom. Ele foi modificado para funcionar em um dispositivo ESP32 normal. Ele também possui métodos close () adicionais para classes de conector.

1) Moduino ESP32

Baixe a biblioteca em https://github.com/techbase123/micropython-modbus. Descompacte o arquivo e envie todos os 4 arquivos para o dispositivo Moduino.

Use mpfshell para carregá-los. Execute este programa no diretório com esses arquivos.

Conecte-se ao dispositivo executando: ISTO

ttyUSB0 é o nome da porta serial onde o dispositivo está conectado.

Mude o diretório para / flash / lib com o comando:

cd / flash / lib

Coloque todos os arquivos com comandos:

coloque uModBusConst.py

put uModBusFunctions.py put uModBusTCP.py put uModBusSerial.py

EXEMPLO

Em seguida, saia do console com o comando exit e reinicie o dispositivo com o botão Reset.

2) Moduino Pycom

Baixe a biblioteca em https://github.com/pycom/pycom-modbus/. Descompacte o arquivo e envie o conteúdo do diretório uModbus para o dispositivo. Use o mpfshell para carregá-los. Execute este programa no diretório com esses arquivos.

Conecte-se ao dispositivo executando:

abrir ttyUSB0

ttyUSB0 é o nome da porta serial onde o dispositivo está conectado.

Mude o diretório para / flash / lib, crie o diretório uModbus e insira-o com os comandos:

cd / flash / libmd uModbus cd uModbus

Coloque todos os arquivos com comandos:

coloque const.py

put functions.py put tcp.py put serial.py

Em seguida, saia do console com o comando exit e reinicie o dispositivo com o botão Reset.

EXEMPLO

Etapa 5: conectar-se à rede

Os comandos para estabelecer a conexão diferem entre Moduino e Pycom.

Conecte-se ao dispositivo com picocom para executar os comandos apropriados. Você pode conectar o dispositivo Moduino à rede por fio ou sem fio. Os exemplos a seguir pressupõem que sua rede tenha um servidor DHCP funcionando.

Em outro caso, o dispositivo não obterá o endereço IP. O suporte Wi-Fi está disponível em todos os Moduino. A porta Ethernet é uma opção e nem todos os dispositivos a possuem.

1) Moduino ESP32

Conectando ao Wi-Fi

Execute os seguintes comandos no dispositivo:

from netWiFi import netWiFiwifi = netWiFi (netWiFi. WIFI_STA, 'ESSID', 'PASS') wifi.start ()

Substitua ESSID pelo nome da sua rede WiFi e PASS pela senha dela.

Depois de algum tempo após executar start (), você deve obter um endereço IP que foi atribuído ao seu dispositivo.

Conectando-se à rede Ethernet

Conecte o dispositivo à rede com fio com o cabo Ethernet.

Em seguida, execute os seguintes comandos:

from netETH import netETHeth = netETH () eth.start ()

Depois de algum tempo após executar start (), você deve obter o endereço IP que foi atribuído ao seu dispositivo.

2) Moduino Pycom

Conectar-se ao Wi-Fi

Execute os seguintes comandos no dispositivo:

da rede importar WLANwlan = WLAN (modo = WLAN. STA) nets = wlan.scan () para rede em redes: if net.ssid == 'ESSID': print ('Rede encontrada!') wlan.connect (net.ssid, auth = (net.sec, 'PASS'), tempo limite = 5000) enquanto não wlan.isconnected (): machine.idle () print ('conexão WLAN bem-sucedida!') interromper

Substitua ESSID pelo nome da sua rede WiFi e PASS pela senha dela.

Etapa 6: inicializar a comunicação com Modbus Slave

Bibliotecas Modbus Master são semelhantes para ambos os dispositivos

Eles variam na inicialização.

1) Inicialize o uModBus no Moduino ESP32

Executar:

de uModBusTCP importe uModBusTCP como TCP

2) Inicialize o uModBus no Pycom

Executar:

de uModbus.tcp import TCP

Conexão aberta

Em seguida, abra a conexão com:

modbus = TCP ('IP', PORTA, 60)

Onde:

• IP - endereço ip do seu PC com simulador Modbus Slave
• PORT - porta do Modbus Slave
• 60 é um tempo limite

Se o seguinte erro ocorrer durante a execução de comandos de leitura / gravação: EXEMPLO

executar:

para Moduino ESP32:

modbus.close ()

para Moduino Pycom:

modbus._sock.close ()

e recriar a conexão:

modbus = TCP ('IP', PORTA, 60)

Isso é importante para fechar o soquete antes de recriar a conexão. O dispositivo restringiu a quantidade de conexão de soquete disponível.

Etapa 7: Ler e gravar registros

O Modbus suporta várias funções para ler e escrever registros.

A biblioteca uModBus possui método para cada função:

1. read_coils
2. read_discrete_inputs
3. read_holding_registers
4. read_input_registers
5. write_single_coil
6. write_single_register

Em primeiro lugar, vamos escrever alguns valores.

1) Bobinas de gravação (função: 5)

Escreva 1 valor no registro 200 do escravo 1:

modbus.write_single_coil (1, 200, 0xFF00)

O primeiro argumento é para o id do escravo, em nosso caso 1.

O segundo é o número do registro e treze é um valor. Para 1, você deve colocar 0xFF00 aqui. Grave o registro de 0 a 201 do escravo 1:

modbus.write_single_coil (1, 201, 0)

Este método permite escrever apenas valores booleanos: 0 ou 1.

2) Registros de gravação (função: 6)

Agora escreva alguns valores inteiros em vários registradores.

Escreva o valor 111 com sinal no registro 100 do escravo 1:

modbus.write_single_register (1, 100, 111, Verdadeiro)

O primeiro argumento é o id do escravo, o segundo número de registro e o terceiro é o novo valor. O último argumento define se o valor deve ser definido como um número com sinal. O valor padrão para isso é True. Você não precisa configurá-lo.

Grave o valor -457 com sinal no registrador 101 do escravo 1:

modbus.write_single_register (1, 101, -457)

Grava o valor 50 não assinado para o registro 100 do escravo 3:

modbus.write_single_register (3, 100, 50, False)

Este método permite gravar valores inteiros em um único registro.

O registro único pode conter valores de 16 bits.

O método retorna True se o valor de entrada for válido e False se não for. O valor é escrito mesmo se for inválido (muito grande para registrar)

3) Ler bobinas / entradas discretas

Agora vamos ler os valores booleanos escritos. Para ler o registro com a função 1, leia a bobina, execute:

modbus.read_coils (slaveId, registro, contagem) [0: contagem]

Para ler o registro com a função 2, leia a entrada discreta, execute:

modbus.read_discrete_inputs (slaveId, registro, contagem) [0: contagem]

Onde:

• slave-id - id do escravo virtual (o simulador Slave aceita todos os ids válidos)
• registro - número de registro para leitura
• contagem - quantidade de registros a serem lidos (coloque a quantidade desejada em ambos os lugares)

Esses métodos retornam array com valores booleanos. Cada valor corresponde a cada registro.

O fragmento: [0: contagem] é necessário, porque este método retorna mais valores do que contagem. Ele retorna sempre a quantidade de valores que é divisível por 8. Os valores adicionais são falsos e não correspondem a nenhum registro.

Leia nossos valores booleanos com os dois métodos:

modbus.read_coils (1, 200, 2) [0: 2] modbus.read_discrete_inputs (1, 200, 2) [0: 2]

O resultado será assim: EXAMPLE

Verdadeiro refere-se a 1 valor, Falso a 0.

4) Ler registros

Agora leia os valores dos registradores escritos com 6 funções.

Para ler os registros com a função 3, leia os registros de retenção, execute:

modbus.read_holding_registers (slaveId, registro, contagem, assinado = Verdadeiro)

Para ler os registros com a função 4, leia os registros de entrada, execute:

modbus.read_input_registers (slaveId, registro, contagem, assinado = Verdadeiro)

Onde:

• slave-id - id do escravo virtual
• registro - número de registro para leitura
• contagem - quantidade de registros a serem lidos
• assinado - indica se os valores lidos devem ser tratados como números com sinal ou não. Estado padrão: Verdadeiro

O valor de retorno é uma tupla com a quantidade desejada de registros.

Leia os registros definidos no ponto anterior:

modbus.read_holding_registers (1, 100, 2, True) modbus.read_input_registers (1, 100, 2, True) modbus.read_holding_registers (3, 100, 1, False) modbus.read_input_registers (3, 100, 1, False)

Os resultados devem ser semelhantes a esta captura de tela: EXEMPLO

Na próxima lição, você aprenderá como criar Modbus RTU Master em um dispositivo compatível com ESP32.