The operation was successful and I then proceeded to reboot the device.
But after reboot, when I ran the ls /dev command, it didn’t show any activated pins for UART or GPIO.
What could have possibly gone wrong. Please help!
Ok, so are you saying that peripherals get created and not highlighted once we configure the .json file? And the gpiochip6 and ttyPERI0 peripherals were not initialized beforehand?
I’ve tried a similar approach and didn’t face the issue you mentioned.
To resolve the problem, I recommend checking the following:
Pin connections: Ensure all UART pins are correctly connected.
Baud rate: Verify that both devices are using the same baud rate.
Instead of continuously sending data in a while() loop, try sending a simple message like "hello world" first and check if it is received correctly on your PC.
Test this code, and confirm if the "hello world" message is received on your PC
If you successfully receive the "hello world" message on your PC, you can then try sending a larger chunk of data. To do this, you can reintroduce the while loop you used previously and test continuous data transmission.
If you’re familiar with Linux, I recommend testing this on a Linux system instead of Windows. It might help you debug the issue more effectively, especially when working with UART and low-level device communication.
Thanks a lot, the code is finally working. Apparently there was an issue with the jumper cables I was using, sorry for that, it’s a pretty silly mistake.
However, one issue that I have noticed is that once I have run the code which is working, it gives perfect output, and then when I try to run another code, it doesn’t transmit or receive data. I presumed that the code was faulty, however when I tried to run the first working code again…it failed to do so. What could be the issue here? I would have to restart the Vaaman board everytime for it to work.
First of all Vatsal I am really thankful for the help that you have provided…I also had another question, its code related and probably related to how my UART is configured.
I had written a code in python (on Vaaman) to receive data from multiple UART peripherals. I am transmitting a string from an STM32 Microcontroller and the size of that string is 3380 bytes. I had written the following code in Python (On Vaaman) to receive that data :-
import serial
import time
# UART device paths and configurations
UART_CONFIGS = [
{
'port': '/dev/ttyPERI0',
'baudrate': 1500000,
'bytesize': serial.EIGHTBITS,
'parity': serial.PARITY_NONE,
'stopbits': serial.STOPBITS_ONE,
'timeout': 2, # Non-blocking read with a timeout of 0.1 seconds
'xonxoff': False,
'rtscts': False,
'dsrdtr': False
},
{
'port': '/dev/ttyPERI1',
'baudrate': 1500000,
'bytesize': serial.EIGHTBITS,
'parity': serial.PARITY_NONE,
'stopbits': serial.STOPBITS_ONE,
'timeout': 1,
'xonxoff': False,
'rtscts': False,
'dsrdtr': False
},
{
'port': '/dev/ttyPERI2',
'baudrate': 1500000,
'bytesize': serial.EIGHTBITS,
'parity': serial.PARITY_NONE,
'stopbits': serial.STOPBITS_ONE,
'timeout': 1,
'xonxoff': False,
'rtscts': False,
'dsrdtr': False
}
]
def main():
uarts = []
try:
# Initialize all UARTs
for config in UART_CONFIGS:
try:
uart = serial.Serial(**config)
uarts.append(uart)
print(f"Initialized UART: {config['port']}")
except serial.SerialException as e:
print(f"Error opening UART {config['port']}: {e}")
uarts.append(None) # Mark as unavailable
print("All UARTs initialized. Starting communication...")
while True:
for i, uart in enumerate(uarts):
if uart is None:
continue # Skip unavailable UARTs
# Transmit data
"""message = f"Hello from {UART_CONFIGS[i]['port']}!\r\n"
bytes_written = uart.write(message.encode())
if bytes_written > 0:
print(f"Sent to {UART_CONFIGS[i]['port']}: {message}", end='')"""
# Receive data
buffer = uart.read(10000) # Read up to 10000 bytes
if buffer:
received_message = buffer.decode('utf-8', errors='ignore')
print(f"Received from {UART_CONFIGS[i]['port']}: {received_message}")
# Small delay to avoid flooding the UARTs
time.sleep(0.2) # 100ms delay
except KeyboardInterrupt:
print("Exiting...")
finally:
# Close all UART devices
for uart in uarts:
if uart is not None and uart.is_open:
uart.close()
print(f"Closed UART: {uart.port}")
if __name__ == "__main__":
main()
The issue that I am facing here, is that I am not able to receive the full data which is being transmitted. It is being recieved in incomplete chunks and the code is also pretty slow. I used an FTDI module to check whether the data that is being transmitted is complete or not, and it was indeed complete so we can rule out the issue in transmission part.
I increased the baudrate from 115200 to 1500000 on both the devices and also increased the timeout of receiving that data and increased the size of the buffer variable , but still no luck.
Should I be running the code in non-blocking or blocking mode?.. and what other changes should I make in the code to make it fast and efficient? #Note : I was able to receive smaller sized data using the code before.
you can try this python script at 9600 baudrate and 1000 byte are receive correctly, and your issue will be solve in the next version of periplex
import serial
import time
import binascii
import sys
import os
# UART device paths and configurations
UART_CONFIGS = [
{
'port': '/dev/ttyPERI0',
'baudrate': 9600,
'bytesize': serial.EIGHTBITS,
'parity': serial.PARITY_NONE,
'stopbits': serial.STOPBITS_ONE,
'timeout': 2, # 2 second timeout
'xonxoff': False,
'rtscts': False,
'dsrdtr': False
}
]
# Debug flag - set to True for verbose output
DEBUG = True
def debug_print(message):
"""Print debug messages if DEBUG is enabled"""
if DEBUG:
print(f"[DEBUG] {message}")
def check_device_exists(port):
"""Check if the UART device exists in the system"""
if not os.path.exists(port):
print(f"Error: Device {port} does not exist")
return False
return True
def open_uart(config):
"""Attempt to open a UART with provided configuration"""
if not check_device_exists(config['port']):
return None
try:
uart = serial.Serial(**config)
print(f"Successfully opened {config['port']} at {config['baudrate']} baud")
return uart
except serial.SerialException as e:
print(f"Error opening {config['port']}: {e}")
return None
def read_uart(uart, max_bytes=3000):
"""Read data from UART with proper error handling"""
if uart is None or not uart.is_open:
return None
try:
# Check if there's data waiting
if uart.in_waiting > 0:
debug_print(f"{uart.port} has {uart.in_waiting} bytes waiting")
# Try to read data
data = uart.read(max_bytes)
if data:
debug_print(f"Read {len(data)} bytes from {uart.port}")
return data
return None
except serial.SerialException as e:
print(f"Error reading from {uart.port}: {e}")
return None
def write_uart(uart, message):
"""Write data to UART with proper error handling"""
if uart is None or not uart.is_open:
return False
try:
bytes_written = uart.write(message if isinstance(message, bytes) else message.encode())
uart.flush() # Ensure data is sent
debug_print(f"Wrote {bytes_written} bytes to {uart.port}")
return bytes_written > 0
except serial.SerialException as e:
print(f"Error writing to {uart.port}: {e}")
return False
def test_uart_loopback(uart):
"""Test UART by sending data and checking if it's received (loopback test)"""
if uart is None or not uart.is_open:
return False
print(f"Testing loopback on {uart.port}...")
# Clear any pending data
uart.reset_input_buffer()
uart.reset_output_buffer()
# Send test message
test_message = b"UART TEST\r\n"
if write_uart(uart, test_message):
# Give device time to respond
time.sleep(0.5)
# Read response
response = read_uart(uart)
if response:
print(f"Loopback test received: {response}")
return True
print("Loopback test failed - no data received")
return False
def display_data(data, port):
"""Display received data in multiple formats"""
if not data:
return
print(f"\nReceived from {port} ({len(data)} bytes):")
print(f" ASCII: {data.decode('ascii', errors='replace')}")
print(f" HEX: {binascii.hexlify(data).decode()}")
# Print byte by byte for detailed analysis
print(" Byte-by-byte:")
for i, byte in enumerate(data):
print(f" [{i}] {byte:02X} (Decimal: {byte}, ASCII: {chr(byte) if 32 <= byte <= 126 else '·'})")
def main():
uarts = []
try:
# Check system information
print(f"System: {sys.platform}")
print("Available serial ports:")
for port in UART_CONFIGS:
if check_device_exists(port['port']):
print(f" {port['port']} - exists")
else:
print(f" {port['port']} - NOT FOUND")
# Initialize UARTs
for config in UART_CONFIGS:
uart = open_uart(config)
uarts.append(uart)
if uart:
# Configure additional UART parameters
uart.reset_input_buffer() # Clear input buffer
uart.reset_output_buffer() # Clear output buffer
print("\nUART communication started. Press Ctrl+C to exit.")
print("Waiting for data...\n")
# Communication loop
while True:
for i, uart in enumerate(uarts):
if uart is None:
continue
# Optional: Send a ping to prompt a response
# write_uart(uart, "PING\r\n")
# Read available data
data = read_uart(uart)
if data:
display_data(data, uart.port)
# Small delay to prevent CPU hogging
time.sleep(0.1)
except KeyboardInterrupt:
print("\nExiting...")
except Exception as e:
print(f"Unexpected error: {e}")
finally:
# Close all UART devices
for uart in uarts:
if uart is not None and uart.is_open:
uart.close()
print(f"Closed {uart.port}")
if __name__ == "__main__":
main()
Hello Vatsal, sorry for replying so late, the code worked and we tried it a few days back we were testing UART Communication but today unexpectedly all the python codes that were working previously aren’t working now.
Also, during boot I am not receiving the U-boot data from the board that i receive from pins GPIOT_RXP28 and GPIOT_RXN28.
Am I right to assume a hardware fault here?
The problem got solved after I flashed the OS image containing periplex again. I am now able to receive and transmit data through UART and even the UI of the OS has been reverted to the one I was using previously.
However, I am still trying to receive 3000 bytes of data through UART using a baudrate of 115200, but there is some data that is not received through this code. I am receivng 2300, 2800 and varied packets (bytes) of data but never the whole 3000 bytes that I am transmitting.
This problem got fixed when I used a slower baudrate of 2595 (slowest baudrate allowed by the G474RE STM board) and increased the timeout to 20 seconds. But, the data takes almost 14 seconds to transmit which is too slow. I need the whole data to be received in under 500 ms. So is there anyway in which I can use a higher baudrate without actually losing any data during transmission?
Below is the python code I am using to receive the data byte-by-byte :-
import serial
# UART configuration
UART_PORT = '/dev/ttyPERI0' # Replace with your UART device
BAUDRATE = 115200
TIMEOUT = 0.1 # Non-blocking read with a timeout of 0.1 seconds
def main():
try:
# Open the UART device
uart = serial.Serial(
port=UART_PORT,
baudrate=BAUDRATE,
bytesize=serial.EIGHTBITS,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
timeout=TIMEOUT
)
print(f"UART initialized on {UART_PORT}. Waiting for data...")
buffer = bytearray() # Buffer to store received bytes
in_packet = False # Flag to indicate if we are inside a packet
while True:
# Read 1 byte from UART
byte = uart.read(1)
if byte:
if byte == b'{': # Start of packet
buffer.clear() # Clear the buffer
buffer.extend(byte) # Add the start byte
in_packet = True
print("Start of packet detected.")
elif byte == b'}': # End of packet
if in_packet:
buffer.extend(byte) # Add the end byte
in_packet = False
# Process the complete packet
packet = buffer.decode('utf-8', errors='ignore')
print(f"Received packet: {packet}")
print(f"Packet length: {len(packet)} bytes")
buffer.clear() # Clear the buffer for the next packet
elif in_packet:
buffer.extend(byte) # Add the byte to the buffer
except serial.SerialException as e:
print(f"Error opening or configuring UART: {e}")
except KeyboardInterrupt:
print("Exiting...")
finally:
if 'uart' in locals() and uart.is_open:
uart.close()
print("UART device closed.")
if __name__ == "__main__":
main()
We will be releasing a new, updated version of Periplex package very soon, which will address this issue. Your problem will be resolved in the upcoming update.
