BlueFox/micropython-rp2-rs485-examples
1
0
Fork 0
Code

Added the programs described in README.md

Browse Source
This commit is contained in:
BlueFox 2024-09-14 23:09:27 +02:00
parent a3c7653ef3
commit b6af693e67
3 changed files with 200 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
rs485_pingpong.py Normal file
View File

@ -0,0 +1,101 @@
'''
A program supposed to run on two RP2040 connected over two channel of an RS485 bus over TTL-UART-to-RS485 converters, and illustrates a simple ping-pong.
Copyright (C) 2024 Benjamin Burkhardt
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
'''
from machine import UART, Pin
import time
# CHANGE THIS to 'True' on one of the machines (as it
# tells the rp2040 to do the first step in ping-pong communication ;)
INITIALIZER = True
# define the UART in-/outputs, named after their usage as either send or receive channels...
# ...depending on wether this is the INITIALIZER or not.
# sure, the in and out pins could be defined in other ways also, but this allows easy customizability...
# ...as just one variable needs to be changed.
print('[UART] Initializing UART for two channels...')
if INITIALIZER: # then read on ch0 and write on ch1
receiver = UART(0, baudrate=115200, tx=Pin(0), rx=Pin(1))
sender = UART(1, baudrate=115200, tx=Pin(4), rx=Pin(5))
else:
sender = UART(0, baudrate=115200, tx=Pin(0), rx=Pin(1))
receiver = UART(1, baudrate=115200, tx=Pin(4), rx=Pin(5))
print('[UART] Initialized UART for two channels.')
# initialize the read/write channels and set their value
print('[UART] Setting output/input for each channel...')
if INITIALIZER: # then enable read on ch0 and write on ch1
receiver_channel_mode = Pin(2, Pin.OUT) # define pinout for the receiver/driver enable pins of channel 0 (shortened together)
sender_channel_mode = Pin(3, Pin.OUT) # define pinout for the receiver/driver enable pins of channel 1 (shortened together)
else:
sender_channel_mode = Pin(2, Pin.OUT)
receiver_channel_mode = Pin(3, Pin.OUT)
receiver_channel_mode.low()
sender_channel_mode.high()
print(f'[UART] Set output/input for each channel. Pin 2 is now {"low" if INITIALIZER else "high"} (CH0 as {"input" if INITIALIZER else "output"}), Pin 3 is now {"high" if INITIALIZER else "low"} (CH1 as {"output" if INITIALIZER else "input"}).')
# some logging
print('[INFO] Set up RS485 ping-pong.')
# now, the REAL PING-PONG mechanism begins
# the counter variable will be increased with every ping
# received (which is a pong from the other side which resulted out of a ping there ;)
a = 0
# make the first step if INITIALIZER is True (see above at declaration)
if INITIALIZER:
sender.write(f'{a}\r\n')
sender.flush()
print(f'[UART] Sent initial ping: {a}')
print('[INFO] Now waiting for incoming pings/pongs.')
# now listen for a pong from the other side and answer to it
rxDataConcatenated = '' # to combine partial received data to one full packet (actually just a string that ends with \n :)
while True:
rxData = receiver.readline()
if rxData is not None:
rxDataDecoded = rxData.decode('utf-8')
if not '\n' in rxDataDecoded: # if the received data is not complete (does not end with a \n), just save the received part
rxDataConcatenated += rxDataDecoded
else: # if it's complete now, add the received part to the potentially saved parts and send the pong
rxDataConcatenated += rxDataDecoded
try:
a = int(rxDataConcatenated)
print(f"[UART] Received ping: {a}")
# send pong after some waiting (could also be left out completely!)
time.sleep(0.2)
a += 1
sender.write(f'{a}\r\n')
sender.flush()
print(f'[UART] Sent pong: {a}')
except:
receiver_error_details = repr(rxDataConcatenated)
print(f'[UART] Received invalid data? Wait until something good comes in! (received "{receiver_error_details}")')
rxDataConcatenated = '' # reset the received parts storage (see comments above!)

57
rs485_receive.py Normal file
View File

@ -0,0 +1,57 @@
'''
Simple program for receiving data over two UART channels to a TTL UART to RS485 converter, printing it out over Serial console.
Inspired by and partly based on Waveshare's example code to the 2 Channel RS485 HAT for the Pi Pico.
Copyright (C) 2024 Benjamin Burkhardt
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
'''
from machine import UART, Pin
import time
uart0 = UART(0, baudrate=115200, tx=Pin(0), rx=Pin(1))
uart1 = UART(1, baudrate=115200, tx=Pin(4), rx=Pin(5))
print('Starting RS485 simple receive...')
module0_mode = Pin(2, Pin.OUT) # define pinout for the receiver/driver enable pins (shortened together)
module1_mode = Pin(3, Pin.OUT) # define pinout for the receiver/driver enable pins (shortened together)
module0_mode.low() # logic 0 = receive; logic 1 = send
module1_mode.low() # logic 0 = receive; logic 1 = send
rxData0concatenated = ''
rxData1concatenated = ''
while True:
rxData0 = uart0.readline()
if rxData0 is not None:
rxData0decoded = rxData0.decode('utf-8')
if not '\n' in rxData0decoded:
rxData0concatenated += rxData0decoded
else:
rxData0concatenated += rxData0decoded
print(f"[CH0] Received data: {rxData0concatenated}", end="")
rxData0concatenated = ''
rxData1 = uart1.readline()
if rxData1 is not None:
rxData1decoded = rxData1.decode('utf-8')
if not '\n' in rxData1decoded:
rxData1concatenated += rxData1decoded
else:
rxData1concatenated += rxData1decoded
print(f"[CH1] Received data: {rxData1concatenated}", end="")
rxData1concatenated = ''

42
rs485_send.py Normal file
View File

@ -0,0 +1,42 @@
'''
Simple program sending an incrementing number over two UART channels to a TTL UART to RS485 converter.
Inspired by and partly based on Waveshare's example code to the 2 Channel RS485 HAT for the Pi Pico.
Copyright (C) 2024 Benjamin Burkhardt
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
'''
from machine import UART, Pin
import time
uart0 = UART(0, baudrate=115200, tx=Pin(0), rx=Pin(1))
uart1 = UART(1, baudrate=115200, tx=Pin(4), rx=Pin(5))
print('Starting RS485 simple send...')
txData = b'Starting RS485 simple send...\r\n'
uart0.write(txData)
uart1.write(txData)
a=0
time.sleep(0.1)
while True:
time.sleep(0.5)
a=a+1
uart0.write("{}\r\n".format(a))
print(f"[CH0]: Sent data: {a}")#shell output
time.sleep(0.5)
a=a+1
uart1.write("{}\r\n".format(a))
print(f"[CH1]: Sent data: {a}")#shell output