with this code from machine import UART, Pin, I2C from ssd1306 import SSD1306I2C import…
- User
with this code from machine import UART, Pin, I2C from ssd1306 import SSD1306_I2C import utime from oled import Write, GFX, SSD1306_I2C from oled.fonts import ubuntu_mono_15, ubuntu_mono_20 from rotary_irq_rp2 import RotaryIRQ
Initialize UART and other peripherals
uart = UART(1, timeout=100, baudrate=56000, tx=Pin(4), rx=Pin(5), bits=8, parity=None, stop=1) led = Pin(25, Pin.OUT)
SW = Pin(20, Pin.IN, Pin.PULL_UP) r = RotaryIRQ(pin_num_clk=18, pin_num_dt=19, min_val=0, reverse=False, range_mode=RotaryIRQ.RANGE_UNBOUNDED)
val_old = r.value() menu_options = ["Instructions", "Setup", "Calibration", "Help"] current_selection = 0 # Start with the first menu item
Push button setup
butPinValueUp = 14 myButtonValueUp = Pin(butPinValueUp, Pin.IN, Pin.PULL_UP)
butPinValueDown = 13 myButtonValueDown = Pin(butPinValueDown, Pin.IN, Pin.PULL_UP)
butPinValueReset = 10 myButtonValueReset = Pin(butPinValueReset, Pin.IN, Pin.PULL_UP)
OLED and I2C setup
i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000) oled = SSD1306_I2C(128, 64, i2c) gfx = GFX(128, 64, oled.pixel)
Initial values
cellValue = 100000 incValue = 100 randValue = 9 data = "awaiting input"
Fonts
write15 = Write(oled, ubuntu_mono_15) write20 = Write(oled, ubuntu_mono_20)
Initial display
oled.fill(0) write20.text("JMS AERO AG", 7, 0) write20.text("Data Logger", 7, 20) write20.text("Simulator", 19, 40) oled.show() utime.sleep(5)
for i in range(64): oled.scroll(0, -2) oled.show() utime.sleep_ms(10)
Function to display the menu
def display_menu(): oled.fill(0) # Clear the display for i, option in enumerate(menu_options): if i == current_selection: oled.text(">" + option, 10, i * 10) # Highlight selected option else: oled.text(option, 10, i * 10) oled.show()
Functions for Menu Options
def instructions(): oled.fill(0) write20.text("Instructions:", 0, 0) write15.text("1. Step A", 0, 20) write15.text("2. Step B", 0, 30) write15.text("3. Step C", 0, 40) oled.show() utime.sleep(5) # Display for 5 seconds
def setup(): oled.fill(0) write20.text("Setup Menu", 0, 0) write15.text("Configure options", 0, 20) oled.show() utime.sleep(5) # Display for 5 seconds
def calibration(): oled.fill(0) write20.text("Calibration Menu", 0, 0) write15.text("Adjust settings", 0, 20) oled.show() utime.sleep(5) # Display for 5 seconds
def help_menu(): oled.fill(0) write20.text("Help Menu", 0, 0) write15.text("Help information", 0, 20) oled.show() utime.sleep(5) # Display for 5 seconds
Main loop for handling buttons and rotary encoder
while True: try: # Update the menu display display_menu()
# Check rotary encoder to navigate menu val_new = r.value() if val_old != val_new: # Update current selection current_selection = (current_selection + (val_new - val_old)) % len(menu_options) val_old = val_new # Select menu item if SW.value() == 0: # If the switch button is pressed print("Selected:", menu_options[current_selection]) if menu_options[current_selection] == "Instructions": instructions() elif menu_options[current_selection] == "Setup": setup() elif menu_options[current_selection] == "Calibration": calibration() elif menu_options[current_selection] == "Help": help_menu() # Check for UART data if uart.any(): data = uart.readline() print(data) if data == b'<<INITIALIZE\r\n': led.toggle() if data == b'<<CANCEL\r\n': led.toggle() if data == b'<<START TEST\r\n': led.toggle() if data == b'wei.zrp\r\n': led.toggle() uart.write("wei.zrp Zero Emulated\r\n") utime.sleep(1) if data == b'wei.mdf\r\n': led.toggle() # Fill rectangle and respond gfx.fill_rect(120, 0, 8, 8, 1) from random import randrange randEndValue = randrange(randValue) uart.write(f"wei.mdf.A:RAW:+ 20617;1;ST;GS;GRO:+ {cellValue};NET:+ 0.000; TAR:+ 0.000;{randEndValue}e\r\n") utime.sleep_ms(100) # Small delay to prevent excessive CPU usage except KeyboardInterrupt: breakwhich had menu added, i no longer get to see the data from the serial port. How to fix
- Assistant
The issue with not seeing data from the serial port after adding the menu could be due to the way the main loop is structured. When you are continuously updating the display, it can be a blocking operation if you're drawing a lot of text or doing lengthy operations.
Here's how to adequately structure the loop to ensure you can see the data from the UART while still allowing for the menu to function. This can be achieved by adding specific checks or restructuring the loop to better accommodate both the display updates and UART reads without missing data.
Suggested Changes
-
Use a separate function for UART processing. This will allow you to keep the UART reading and processing logic separate from the display logic.
-
Reduce blocking operations. Make sure that the display update does not block the rest of the loop from executing.
-
Simplify the display update logic. Instead of constantly redrawing the entire menu, you can check whether the selection has changed and only redraw when necessary.
Here's your modified code implementing these suggestions:
# Rest of your imports and initializations here... # Main loop for handling buttons and rotary encoder while True: try: # Check rotary encoder val_new = r.value() if val_old != val_new: # Update current selection current_selection = (current_selection + (val_new - val_old)) % len(menu_options) val_old = val_new display_menu() # Update display only when the selection changes # Select menu item if SW.value() == 0: # If the switch button is pressed print("Selected:", menu_options[current_selection]) if menu_options[current_selection] == "Instructions": instructions() elif menu_options[current_selection] == "Setup": setup() elif menu_options[current_selection] == "Calibration": calibration() elif menu_options[current_selection] == "Help": help_menu() # Check for UART data if uart.any(): data = uart.readline() print(data) if data == b'<<INITIALIZE\r\n': led.toggle() if data == b'<<CANCEL\r\n': led.toggle() if data == b'<<START TEST\r\n': led.toggle() if data == b'wei.zrp\r\n': led.toggle() uart.write("wei.zrp Zero Emulated\r\n") utime.sleep(1) if data == b'wei.mdf\r\n': led.toggle() # Fill rectangle and respond gfx.fill_rect(120, 0, 8, 8, 1) from random import randrange randEndValue = randrange(randValue) uart.write(f"wei.mdf.A:RAW:+ 20617;1;ST;GS;GRO:+ {cellValue};NET:+ 0.000; TAR:+ 0.000;{randEndValue}e\r\n") utime.sleep_ms(100) # Small delay to prevent excessive CPU usage except KeyboardInterrupt: breakKey Changes Made:
display_menu()is called only when the rotary encoder value changes. This reduces the number of times you need to update the OLED and allows for less blocking.- UART checks remain as they are since this should be actively monitored.
By making these adjustments, you should be able to see the data from the UART while still interacting with the menu without issues. Test it out to ensure that both the menu and the UART communication work as expected in the loop.
-
- User
Traceback (most recent call last): File "", line 7, in NameError: name 'r' isn't defined
- Assistant
The error message you are encountering,
NameError: name 'r' isn't defined, indicates that the variabler(which is presumably your RotaryIRQ instance) is not defined in the scope where you are trying to access it. This can happen if the initialization ofrdid not occur properly, or if the code is being executed in a different context that does not have access to the variable.Steps to Resolve the Issue
-
Ensure
ris Initialized: Make sure you have the initialization code for the RotaryIRQ object (r) included and executed before you enter the main loop. -
Check the Entire Code: If your code is spread across multiple files or sections, make sure that the variable
ris defined in the global scope if you are trying to access it inside a function or if it hasn't been declared before the loop. -
Local Scope Issue: If you are trying to access
rinside a function without passing it as an argument, Python won't recognize it unless it's declared global within that function.
Example Code Structure
Here is how to correctly structure your code to ensure that all variables are defined and accessible:
from machine import UART, Pin, I2C from ssd1306 import SSD1306_I2C import utime from oled import Write, GFX, SSD1306_I2C from oled.fonts import ubuntu_mono_15, ubuntu_mono_20 from rotary_irq_rp2 import RotaryIRQ # Initialize UART and other peripherals uart = UART(1, timeout=100, baudrate=56000, tx=Pin(4), rx=Pin(5), bits=8, parity=None, stop=1) led = Pin(25, Pin.OUT) SW = Pin(20, Pin.IN, Pin.PULL_UP) r = RotaryIRQ(pin_num_clk=18, pin_num_dt=19, min_val=0, reverse=False, range_mode=RotaryIRQ.RANGE_UNBOUNDED) val_old = r.value() menu_options = ["Instructions", "Setup", "Calibration", "Help"] current_selection = 0 # Start with the first menu item # Push button setup butPinValueUp = 14 myButtonValueUp = Pin(butPinValueUp, Pin.IN, Pin.PULL_UP) butPinValueDown = 13 myButtonValueDown = Pin(butPinValueDown, Pin.IN, Pin.PULL_UP) butPinValueReset = 10 myButtonValueReset = Pin(butPinValueReset, Pin.IN, Pin.PULL_UP) # OLED and I2C setup i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000) oled = SSD1306_I2C(128, 64, i2c) gfx = GFX(128, 64, oled.pixel) # Fonts write15 = Write(oled, ubuntu_mono_15) write20 = Write(oled, ubuntu_mono_20) # Initial display oled.fill(0) write20.text("JMS AERO AG", 7, 0) write20.text("Data Logger", 7, 20) write20.text("Simulator", 19, 40) oled.show() utime.sleep(5) # Function to display the menu def display_menu(): oled.fill(0) # Clear the display for i, option in enumerate(menu_options): if i == current_selection: oled.text(">" + option, 10, i * 10) # Highlight selected option else: oled.text(option, 10, i * 10) oled.show() # Functions for menu options (not shown for brevity) # Main loop for handling buttons and rotary encoder while True: try: # Check rotary encoder val_new = r.value() if val_old != val_new: # Update current selection current_selection = (current_selection + (val_new - val_old)) % len(menu_options) val_old = val_new display_menu() # Update display only when the selection changes # Select menu item if SW.value() == 0: # If the switch button is pressed print("Selected:", menu_options[current_selection]) # Call respective menu option function (not shown for brevity) # Check for UART data if uart.any(): data = uart.readline() print(data) # Process UART data (not shown for brevity) utime.sleep_ms(100) # Small delay to prevent excessive CPU usage except KeyboardInterrupt: breakKey Points to Ensure:
- Order of Execution: The initialization lines must occur before their usage. Ensure that
ris created right after any necessary imports and device initializations. - Avoid Scoping Issues: If you need to use
rin a function instead of the global scope, declare it global within that function.
If you make these adjustments and ensure all initializations occur in the correct order and scope, the
NameErrorshould be resolved, and you should be able to access the RotaryIRQ instance correctly. -
- User
full code please
- Assistant
Sure! Below is the complete code, incorporating your original requirements along with the necessary components to ensure the rotary encoder and UART communications work seamlessly with the OLED display menu.
from machine import UART, Pin, I2C from ssd1306 import SSD1306_I2C import utime from oled import Write, GFX, SSD1306_I2C from oled.fonts import ubuntu_mono_15, ubuntu_mono_20 from rotary_irq_rp2 import RotaryIRQ from random import randrange # Initialize UART and other peripherals uart = UART(1, timeout=100, baudrate=56000, tx=Pin(4), rx=Pin(5), bits=8, parity=None, stop=1) led = Pin(25, Pin.OUT) SW = Pin(20, Pin.IN, Pin.PULL_UP) r = RotaryIRQ(pin_num_clk=18, pin_num_dt=19, min_val=0, reverse=False, range_mode=RotaryIRQ.RANGE_UNBOUNDED) val_old = r.value() menu_options = ["Instructions", "Setup", "Calibration", "Help"] current_selection = 0 # Start with the first menu item # Push button setup butPinValueUp = 14 myButtonValueUp = Pin(butPinValueUp, Pin.IN, Pin.PULL_UP) butPinValueDown = 13 myButtonValueDown = Pin(butPinValueDown, Pin.IN, Pin.PULL_UP) butPinValueReset = 10 myButtonValueReset = Pin(butPinValueReset, Pin.IN, Pin.PULL_UP) # OLED and I2C setup i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000) oled = SSD1306_I2C(128, 64, i2c) gfx = GFX(128, 64, oled.pixel) # Fonts write15 = Write(oled, ubuntu_mono_15) write20 = Write(oled, ubuntu_mono_20) # Initial display oled.fill(0) write20.text("JMS AERO AG", 7, 0) write20.text("Data Logger", 7, 20) write20.text("Simulator", 19, 40) oled.show() utime.sleep(5) for i in range(64): oled.scroll(0, -2) oled.show() utime.sleep_ms(10) # Function to display the menu def display_menu(): oled.fill(0) # Clear the display for i, option in enumerate(menu_options): if i == current_selection: oled.text(">" + option, 10, i * 10) # Highlight selected option else: oled.text(option, 10, i * 10) oled.show() # Functions for Menu Options def instructions(): oled.fill(0) write20.text("Instructions:", 0, 0) write15.text("1. Step A", 0, 20) write15.text("2. Step B", 0, 30) write15.text("3. Step C", 0, 40) oled.show() utime.sleep(5) # Display for 5 seconds def setup(): oled.fill(0) write20.text("Setup Menu", 0, 0) write15.text("Configure options", 0, 20) oled.show() utime.sleep(5) # Display for 5 seconds def calibration(): oled.fill(0) write20.text("Calibration Menu", 0, 0) write15.text("Adjust settings", 0, 20) oled.show() utime.sleep(5) # Display for 5 seconds def help_menu(): oled.fill(0) write20.text("Help Menu", 0, 0) write15.text("Help information", 0, 20) oled.show() utime.sleep(5) # Display for 5 seconds # Main loop for handling buttons and rotary encoder while True: try: # Check rotary encoder val_new = r.value() if val_old != val_new: # Update current selection current_selection = (current_selection + (val_new - val_old)) % len(menu_options) val_old = val_new display_menu() # Update display only when the selection changes # Select menu item if SW.value() == 0: # If the switch button is pressed print("Selected:", menu_options[current_selection]) if menu_options[current_selection] == "Instructions": instructions() elif menu_options[current_selection] == "Setup": setup() elif menu_options[current_selection] == "Calibration": calibration() elif menu_options[current_selection] == "Help": help_menu() # Check for UART data if uart.any(): data = uart.readline() print(data) if data == b'<<INITIALIZE\r\n': led.toggle() if data == b'<<CANCEL\r\n': led.toggle() if data == b'<<START TEST\r\n': led.toggle() if data == b'wei.zrp\r\n': led.toggle() uart.write("wei.zrp Zero Emulated\r\n") utime.sleep(1) if data == b'wei.mdf\r\n': led.toggle() # Fill rectangle and respond gfx.fill_rect(120, 0, 8, 8, 1) randEndValue = randrange(9) # Generate a random number (0-8) cellValue = 100000 # Example value uart.write(f"wei.mdf.A:RAW:+ 20617;1;ST;GS;GRO:+ {cellValue};NET:+ 0.000; TAR:+ 0.000;{randEndValue}e\r\n") utime.sleep_ms(100) # Small delay to prevent excessive CPU usage except KeyboardInterrupt: breakExplanation of the Code:
- Initialization of Components: The code initializes UART for serial communication, IO pins for buttons and rotary encoders, and the OLED display.
- Menu System: The
display_menu()function refreshes the menu display based on the current selection. It highlights the currently selected option. - Menu Options: Functions (
instructions(),setup(),calibration(),help_menu()) are created for displaying relevant information for each menu item with a 5-second delay for viewing. - Main Loop: The main loop checks for rotary encoder input to navigate through the menu, button presses to select options, and UART data coming in for processing commands.
- UART Communication: The code listens for specific command strings and responds appropriately, including toggling the LED and sending responses.
Testing
To test the code, load it to your microcontroller and ensure all necessary hardware (like the rotary encoder, buttons, and OLED) are correctly connected. After loading, you should see the menu system functioning while UART communication happens simultaneously without issues.
- User
uart coms do work but im not able to displaz info from the com port on the display while the menu is active
- Assistant
To display incoming UART data on the OLED display while the menu is active, you need to modify the loop so that it updates the display with the data received from the UART. This involves adding a mechanism to refresh the OLED display based on UART data without blocking the menu functionality.
Approach
- Check for UART Data Continuously: After displaying the menu or menu options, check for incoming UART data.
- Update Display with Incoming Data: Send the received UART data to the OLED to be displayed immediately after it is received.
Here's how to implement this in your existing code:
from machine import UART, Pin, I2C from ssd1306 import SSD1306_I2C import utime from oled import Write, GFX from oled.fonts import ubuntu_mono_15, ubuntu_mono_20 from rotary_irq_rp2 import RotaryIRQ from random import randrange # Initialize UART and other peripherals uart = UART(1, timeout=100, baudrate=56000, tx=Pin(4), rx=Pin(5), bits=8, parity=None, stop=1) led = Pin(25, Pin.OUT) SW = Pin(20, Pin.IN, Pin.PULL_UP) r = RotaryIRQ(pin_num_clk=18, pin_num_dt=19, min_val=0, reverse=False, range_mode=RotaryIRQ.RANGE_UNBOUNDED) val_old = r.value() menu_options = ["Instructions", "Setup", "Calibration", "Help"] current_selection = 0 # Start with the first menu item # Push button setup butPinValueUp = 14 myButtonValueUp = Pin(butPinValueUp, Pin.IN, Pin.PULL_UP) butPinValueDown = 13 myButtonValueDown = Pin(butPinValueDown, Pin.IN, Pin.PULL_UP) butPinValueReset = 10 myButtonValueReset = Pin(butPinValueReset, Pin.IN, Pin.PULL_UP) # OLED and I2C setup i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000) oled = SSD1306_I2C(128, 64, i2c) gfx = GFX(128, 64, oled.pixel) # Fonts write15 = Write(oled, ubuntu_mono_15) write20 = Write(oled, ubuntu_mono_20) # Initial display oled.fill(0) write20.text("JMS AERO AG", 7, 0) write20.text("Data Logger", 7, 20) write20.text("Simulator", 19, 40) oled.show() utime.sleep(5) # Clear the display after the initial screen oled.fill(0) oled.show() # Function to display the menu def display_menu(): oled.fill(0) # Clear the display for i, option in enumerate(menu_options): if i == current_selection: oled.text(">" + option, 10, i * 10) # Highlight selected option else: oled.text(option, 10, i * 10) oled.show() # Functions for Menu Options def instructions(): oled.fill(0) write20.text("Instructions:", 0, 0) write15.text("1. Step A", 0, 20) write15.text("2. Step B", 0, 30) write15.text("3. Step C", 0, 40) oled.show() utime.sleep(5) # Display for 5 seconds def setup(): oled.fill(0) write20.text("Setup Menu", 0, 0) write15.text("Configure options", 0, 20) oled.show() utime.sleep(5) # Display for 5 seconds def calibration(): oled.fill(0) write20.text("Calibration Menu", 0, 0) write15.text("Adjust settings", 0, 20) oled.show() utime.sleep(5) # Display for 5 seconds def help_menu(): oled.fill(0) write20.text("Help Menu", 0, 0) write15.text("Help information", 0, 20) oled.show() utime.sleep(5) # Display for 5 seconds # Function to display UART data on OLED def display_uart_data(data): oled.fill(0) # Clear the display for new data write20.text("UART Data:", 0, 0) oled.text(data.decode(), 0, 20) # Display the data received from UART oled.show() # Main loop for handling buttons, rotary encoder, and UART communication while True: try: # Check rotary encoder val_new = r.value() if val_old != val_new: # Update current selection current_selection = (current_selection + (val_new - val_old)) % len(menu_options) val_old = val_new display_menu() # Update display only when the selection changes # Select menu item if SW.value() == 0: # If the switch button is pressed print("Selected:", menu_options[current_selection]) if menu_options[current_selection] == "Instructions": instructions() elif menu_options[current_selection] == "Setup": setup() elif menu_options[current_selection] == "Calibration": calibration() elif menu_options[current_selection] == "Help": help_menu() # Check for UART data if uart.any(): data = uart.readline() print(data) display_uart_data(data) # Display the received data on the OLED # Perform actions based on UART commands if data == b'<<INITIALIZE\r\n': led.toggle() elif data == b'<<CANCEL\r\n': led.toggle() elif data == b'<<START TEST\r\n': led.toggle() elif data == b'wei.zrp\r\n': led.toggle() uart.write("wei.zrp Zero Emulated\r\n") utime.sleep(1) elif data == b'wei.mdf\r\n': led.toggle() # Fill rectangle and respond gfx.fill_rect(120, 0, 8, 8, 1) randEndValue = randrange(9) # Generate a random number (0-8) cellValue = 100000 # Example value uart.write(f"wei.mdf.A:RAW:+ 20617;1;ST;GS;GRO:+ {cellValue};NET:+ 0.000; TAR:+ 0.000;{randEndValue}e\r\n") utime.sleep_ms(100) # Small delay to prevent excessive CPU usage except KeyboardInterrupt: breakKey Changes Explained:
-
Added
display_uart_data(data)Function: This function takes the UART data that comes in, clears the OLED display, and shows the UART data. This keeps the OLED contents updated with incoming UART messages. -
Continuous UART Checking: The loop continuously checks for UART data and calls
display_uart_data(data)to show the newly received messages on the OLED display. -
OLED Display Management: The
oled.fill(0)indisplay_uart_data()clears the display before writing new content. This is useful so that every time new data arrives, it's presented clearly without remnants of previous messages.
Considerations:
- Message Lengths: Ensure that the data messages are not too long, as they may not fit within the OLED display's dimensions. You might need to implement scrolling text for long messages.
- Menu Functionality: While displaying UART data, you may want to ensure that the user can still navigate the menu without interruptions. You might consider adding a "status" display mode or a dedicated section in the display to show both menu options and UART data simultaneously if needed.
By implementing these changes, you should be able to see real-time UART messages on your OLED display while still interacting with the menu system.
- User
displays wei.mdf but no data going out or returned
- Assistant
If the code is displaying "wei.mdf" but not sending data or returning responses as expected, there may be issues with the UART communication or the conditions based on the received UART data. Below are some steps to debug the problem and ensure that the code correctly handles UART communication.
Debugging Steps
-
Check UART Configuration: Ensure that the baud rate and other UART configuration settings match those of the sending device and that the pins used (TX and RX) are correctly connected.
-
Print Debug Messages: Add debug print statements to confirm that the incoming data is being processed as expected and detect where the flow might fail.
-
Check Response Conditions: Ensure that the conditions for sending responses (i.e., handling received data) are correctly implemented and that they match the incoming data.
-
Return Data Formatting: Ensure that the response strings you send back over UART are properly formatted. Any unexpected whitespace or line endings could cause problems.
Revised Code with Debugging Statements
Here's a modified version of your code with additional debug prints and checks to help diagnose the problem:
from machine import UART, Pin, I2C from ssd1306 import SSD1306_I2C import utime from oled import Write, GFX from oled.fonts import ubuntu_mono_15, ubuntu_mono_20 from rotary_irq_rp2 import RotaryIRQ from random import randrange # Initialize UART and other peripherals uart = UART(1, timeout=100, baudrate=56000, tx=Pin(4), rx=Pin(5), bits=8, parity=None, stop=1) led = Pin(25, Pin.OUT) SW = Pin(20, Pin.IN, Pin.PULL_UP) r = RotaryIRQ(pin_num_clk=18, pin_num_dt=19, min_val=0, reverse=False, range_mode=RotaryIRQ.RANGE_UNBOUNDED) val_old = r.value() menu_options = ["Instructions", "Setup", "Calibration", "Help"] current_selection = 0 # Start with the first menu item # Push button setup butPinValueUp = 14 myButtonValueUp = Pin(butPinValueUp, Pin.IN, Pin.PULL_UP) butPinValueDown = 13 myButtonValueDown = Pin(butPinValueDown, Pin.IN, Pin.PULL_UP) butPinValueReset = 10 myButtonValueReset = Pin(butPinValueReset, Pin.IN, Pin.PULL_UP) # OLED and I2C setup i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000) oled = SSD1306_I2C(128, 64, i2c) gfx = GFX(128, 64, oled.pixel) # Fonts write15 = Write(oled, ubuntu_mono_15) write20 = Write(oled, ubuntu_mono_20) # Initial display oled.fill(0) write20.text("JMS AERO AG", 7, 0) write20.text("Data Logger", 7, 20) write20.text("Simulator", 19, 40) oled.show() utime.sleep(5) # Clear the display after the initial screen oled.fill(0) oled.show() # Function to display the menu def display_menu(): oled.fill(0) # Clear the display for i, option in enumerate(menu_options): if i == current_selection: oled.text(">" + option, 10, i * 10) # Highlight selected option else: oled.text(option, 10, i * 10) oled.show() # Functions for Menu Options (not displayed for brevity) # Function to display UART data on OLED def display_uart_data(data): oled.fill(0) # Clear the display for new data write20.text("UART Data:", 0, 0) oled.text(data.decode().strip(), 0, 20) # Display the data received from UART with .strip() oled.show() # Main loop for handling buttons and rotary encoder while True: try: # Check rotary encoder val_new = r.value() if val_old != val_new: # Update current selection current_selection = (current_selection + (val_new - val_old)) % len(menu_options) val_old = val_new display_menu() # Update display only when the selection changes # Select menu item if SW.value() == 0: # If the switch button is pressed print("Selected:", menu_options[current_selection]) if menu_options[current_selection] == "Instructions": instructions() elif menu_options[current_selection] == "Setup": setup() elif menu_options[current_selection] == "Calibration": calibration() elif menu_options[current_selection] == "Help": help_menu() # Check for UART data if uart.any(): data = uart.readline() print("Received UART data:", data) # Debug print display_uart_data(data) # Display the received data on the OLED # Respond based on received UART commands if data.startswith(b'<<INITIALIZE'): print("Processing Initialize Command") # Debug print led.toggle() elif data.startswith(b'<<CANCEL'): print("Processing Cancel Command") # Debug print led.toggle() elif data.startswith(b'<<START TEST'): print("Processing Start Test Command") # Debug print led.toggle() elif data.startswith(b'wei.zrp'): print("Processing wei.zrp Command") # Debug print led.toggle() uart.write("wei.zrp Zero Emulated\r\n") utime.sleep(1) elif data.startswith(b'wei.mdf'): print("Processing wei.mdf Command") # Debug print led.toggle() # Fill rectangle and respond gfx.fill_rect(120, 0, 8, 8, 1) randEndValue = randrange(9) # Generate a random number (0-8) cellValue = 100000 # Example value response = f"wei.mdf.A:RAW:+ 20617;1;ST;GS;GRO:+ {cellValue};NET:+ 0.000; TAR:+ 0.000;{randEndValue}e\r\n" print("Sending response:", response) # Debug print uart.write(response) utime.sleep_ms(100) # Small delay to prevent excessive CPU usage except KeyboardInterrupt: breakChanges and Debug Enhancements:
-
Debug Prints: I've added
printstatements to log what is being received over UART and what commands are being processed. This should help you diagnose if specific commands are being missed or if response commands are not being sent. -
Data Handling: The check for
startswithin UART data makes it more flexible in handling commands. Ensure you're matching parts of the command that are significant (likewei.zrp,<<START TEST, etc.), allowing for the possibility of additional data in some cases. -
Response Handling: The response string in the
wei.mdfcase is constructed and printed before sending, to verify that it’s formatted correctly before transmission.
Testing:
- Load the revised code onto your microcontroller.
- Monitor the serial output to see printed debug messages for any received commands or actions taken.
- Make sure that the device sending commands to your UART interface is sending exactly what's being checked, including any line endings.
By following these steps and using the debug prints, you should be able to identify where things might be going wrong in the communication process and ensure proper data transmission and reception.
-
- User
the print statements here
# Respond based on received UART commands if data.startswith(b'<<INITIALIZE'): print("Processing Initialize Command") # Debug print led.toggle() elif data.startswith(b'<<CANCEL'): print("Processing Cancel Command") # Debug print led.toggle() elif data.startswith(b'<<START TEST'): print("Processing Start Test Command") # Debug print led.toggle() elif data.startswith(b'wei.zrp'): print("Processing wei.zrp Command") # Debug print led.toggle() uart.write("wei.zrp Zero Emulated\r\n") utime.sleep(1) elif data.startswith(b'wei.mdf'): print("Processing wei.mdf Command") # Debug print led.toggle() # Fill rectangle and respond gfx.fill_rect(120, 0, 8, 8, 1) randEndValue = randrange(9) # Generate a random number (0-8) cellValue = 100000 # Example value response = f"wei.mdf.A:RAW:+ 20617;1;ST;GS;GRO:+ {cellValue};NET:+ 0.000; TAR:+ 0.000;{randEndValue}e\r\n" print("Sending response:", response) # Debug print uart.write(response)are not being displayed on the display. Data sent to and from the uart is correct
- Assistant
If the intended debug messages are not being displayed on the OLED while the UART communication is functioning correctly, it may be due to the OLED being cleared or updated before the messages can be printed.
The current design logic does not allow for multi-line messages or combining UART communication responses with menu navigation and display updates. If you want to monitor UART commands on the display while handling menu interactions, you'll have to design a mechanism that allows for both:
- Showing UART responses even when the menu is visible.
- Optionally allowing scrolling or cycling through messages if they are too long to fit on the display.
Implementation Approach
- Create a Separate Area for UART Messages: Allocate part of the display to show UART messages.
- Display UART Messages without Clearing the Menu: Update the OLED display in a way that only the UART message area is updated when new data arrives.
- Scrolling if messages are too long: If the messages are long, consider scrolling them instead of clearing the entire display.
Here's an updated version of your code that incorporates the UART display without losing the menu context:
from machine import UART, Pin, I2C from ssd1306 import SSD1306_I2C import utime from oled import Write, GFX from oled.fonts import ubuntu_mono_15, ubuntu_mono_20 from rotary_irq_rp2 import RotaryIRQ from random import randrange # Initialize UART and other peripherals uart = UART(1, timeout=100, baudrate=56000, tx=Pin(4), rx=Pin(5), bits=8, parity=None, stop=1) led = Pin(25, Pin.OUT) SW = Pin(20, Pin.IN, Pin.PULL_UP) r = RotaryIRQ(pin_num_clk=18, pin_num_dt=19, min_val=0, reverse=False, range_mode=RotaryIRQ.RANGE_UNBOUNDED) val_old = r.value() menu_options = ["Instructions", "Setup", "Calibration", "Help"] current_selection = 0 # Start with the first menu item # Push button setup butPinValueUp = 14 myButtonValueUp = Pin(butPinValueUp, Pin.IN, Pin.PULL_UP) butPinValueDown = 13 myButtonValueDown = Pin(butPinValueDown, Pin.IN, Pin.PULL_UP) butPinValueReset = 10 myButtonValueReset = Pin(butPinValueReset, Pin.IN, Pin.PULL_UP) # OLED and I2C setup i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000) oled = SSD1306_I2C(128, 64, i2c) gfx = GFX(128, 64, oled.pixel) # Fonts write15 = Write(oled, ubuntu_mono_15) write20 = Write(oled, ubuntu_mono_20) # Initial display oled.fill(0) write20.text("JMS AERO AG", 7, 0) write20.text("Data Logger", 7, 20) write20.text("Simulator", 19, 40) oled.show() utime.sleep(5) # Clear the display after the initial screen oled.fill(0) oled.show() # Function to display the menu def display_menu(): oled.fill(0) # Clear the display for i, option in enumerate(menu_options): if i == current_selection: oled.text(">" + option, 10, i * 10) # Highlight selected option else: oled.text(option, 10, i * 10) # Variable to hold the latest UART message last_uart_message = "" # Function to display UART data on OLED def display_uart_data(data): global last_uart_message last_uart_message = data.decode().strip() # Store and decode the data oled.fill_rect(0, 50, 128, 14, 0) # Clear the UART message area oled.text("UART Data: " + last_uart_message, 0, 50) # Display the updated UART message oled.show() # Main loop for handling buttons and rotary encoder while True: try: # Check rotary encoder val_new = r.value() if val_old != val_new: # Update current selection current_selection = (current_selection + (val_new - val_old)) % len(menu_options) val_old = val_new display_menu() # Update display only when the selection changes # Select menu item if SW.value() == 0: # If the switch button is pressed print("Selected:", menu_options[current_selection]) if menu_options[current_selection] == "Instructions": instructions() elif menu_options[current_selection] == "Setup": setup() elif menu_options[current_selection] == "Calibration": calibration() elif menu_options[current_selection] == "Help": help_menu() # Display current menu display_menu() # Refresh the menu display # Check for UART data if uart.any(): data = uart.readline() print("Received UART data:", data) # Debug print display_uart_data(data) # Display the received data on the OLED # Respond based on received UART commands if data.startswith(b'<<INITIALIZE'): led.toggle() elif data.startswith(b'<<CANCEL'): led.toggle() elif data.startswith(b'<<START TEST'): led.toggle() elif data.startswith(b'wei.zrp'): led.toggle() uart.write("wei.zrp Zero Emulated\r\n") utime.sleep(1) elif data.startswith(b'wei.mdf'): led.toggle() # Fill rectangle and respond gfx.fill_rect(120, 0, 8, 8, 1) randEndValue = randrange(9) # Generate a random number (0-8) cellValue = 100000 # Example value response = f"wei.mdf.A:RAW:+ 20617;1;ST;GS;GRO:+ {cellValue};NET:+ 0.000; TAR:+ 0.000;{randEndValue}e\r\n" uart.write(response) utime.sleep_ms(100) # Small delay to prevent excessive CPU usage except KeyboardInterrupt: breakKey Changes Implemented:
-
UART Message Area: The
display_uart_data(data)function is adjusted to update only the area of the display below the menu (at y=50) for showing UART data. This area is cleared and then updated with the latest message. -
Global Variable for Last UART Message: A global variable
last_uart_messageholds the most recent UART message, allowing efficient updates on the screen without losing menu visibility. -
Display Menu Call: Ensure that the menu display is refreshed constantly within the main loop, making it interactive while still allowing UART messages to be displayed.
Result:
With this change, when UART data is received, it will show right below the menu options, allowing you to always see any incoming UART messages while interacting with the menu system. If the messages are too long for one line, you might consider additional scrolling or truncation logic.
Load and test this updated code on your hardware, and it should resolve the issue of displaying UART data alongside interactive menu functionality.
- User
ok lets change the menu so that option 1 is Data. When selected this displays all uart data untill the encoder button is pressed which activates the menu
- Assistant
To modify the menu system so that option 1 ("Data") displays all incoming UART data continuously until the rotary encoder button is pressed (which will take you back to the main menu), you will need to structure the code to handle this case.
Revised Code
Here’s how the revised implementation will look:
- Change Menu Options: Rename the first menu option to "Data".
- Implement a Loop for Displaying UART Data: When the "Data" option is selected, enter a loop that continuously displays received UART data until the rotary encoder button is pressed.
Here’s the complete modified code:
from machine import UART, Pin, I2C from ssd1306 import SSD1306_I2C import utime from oled import Write, GFX from oled.fonts import ubuntu_mono_15, ubuntu_mono_20 from rotary_irq_rp2 import RotaryIRQ from random import randrange # Initialize UART and other peripherals uart = UART(1, timeout=100, baudrate=56000, tx=Pin(4), rx=Pin(5), bits=8, parity=None, stop=1) led = Pin(25, Pin.OUT) SW = Pin(20, Pin.IN, Pin.PULL_UP) r = RotaryIRQ(pin_num_clk=18, pin_num_dt=19, min_val=0, reverse=False, range_mode=RotaryIRQ.RANGE_UNBOUNDED) val_old = r.value() menu_options = ["Data", "Instructions", "Setup", "Calibration", "Help"] current_selection = 0 # Start with the first menu item # Push button setup butPinValueUp = 14 myButtonValueUp = Pin(butPinValueUp, Pin.IN, Pin.PULL_UP) butPinValueDown = 13 myButtonValueDown = Pin(butPinValueDown, Pin.IN, Pin.PULL_UP) butPinValueReset = 10 myButtonValueReset = Pin(butPinValueReset, Pin.IN, Pin.PULL_UP) # OLED and I2C setup i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000) oled = SSD1306_I2C(128, 64, i2c) gfx = GFX(128, 64, oled.pixel) # Fonts write15 = Write(oled, ubuntu_mono_15) write20 = Write(oled, ubuntu_mono_20) # Initial display oled.fill(0) write20.text("JMS AERO AG", 7, 0) write20.text("Data Logger", 7, 20) write20.text("Simulator", 19, 40) oled.show() utime.sleep(5) # Clear the display after the initial screen oled.fill(0) oled.show() # Function to display the menu def display_menu(): oled.fill(0) # Clear the display for i, option in enumerate(menu_options): if i == current_selection: oled.text(">" + option, 10, i * 10) # Highlight selected option else: oled.text(option, 10, i * 10) oled.show() # Function to display UART data on OLED def display_uart_data(data): oled.fill(0) # Clear the display for new data write20.text("UART Data:", 0, 0) oled.text(data.decode().strip(), 0, 20) # Display the updated UART message oled.show() # Function to handle UART data display def handle_uart_data_display(): global current_selection oled.fill(0) # Clear the display write20.text("Receiving Data...", 0, 0) oled.show() while True: if uart.any(): data = uart.readline() print("Received UART data:", data) # Debug print display_uart_data(data) # Display the received data on the OLED # Check if the rotary encoder button is pressed if SW.value() == 0: # If the switch button is pressed utime.sleep(0.1) # Debounce delay break # Main loop for handling buttons and rotary encoder while True: try: # Check rotary encoder val_new = r.value() if val_old != val_new: # Update current selection current_selection = (current_selection + (val_new - val_old)) % len(menu_options) val_old = val_new display_menu() # Update display only when the selection changes # Select menu item if SW.value() == 0: # If the switch button is pressed print("Selected:", menu_options[current_selection]) if menu_options[current_selection] == "Data": handle_uart_data_display() # Enter data receiving mode elif menu_options[current_selection] == "Instructions": instructions() elif menu_options[current_selection] == "Setup": setup() elif menu_options[current_selection] == "Calibration": calibration() elif menu_options[current_selection] == "Help": help_menu() # Display current menu display_menu() # Refresh the menu display utime.sleep_ms(100) # Small delay to prevent excessive CPU usage except KeyboardInterrupt: breakKey Modifications Explained:
-
Changed Menu Options: The first option in the menu is changed to "Data" to allow users to view incoming UART data.
-
Function
handle_uart_data_display():- Enters a loop that continuously checks for UART data.
- If data is received, it displays the content on the OLED with
display_uart_data(data). - The loop breaks when the rotary encoder button (
SW) is pressed, allowing the user to return to the menu.
-
Main Loop Adjustments:
- The main loop listens for the rotary encoder button press, which allows users to access the new “Data” feature.
- Keeps the menu updated for the other options.
Operation
- Load the modified code onto your microcontroller.
- Navigate to "Data" in the menu and select it. The OLED will continuously update with incoming UART data.
- Press the rotary encoder button to revert to the menu where you can select other options.
This implementation allows for a seamless transition between viewing UART data and interacting with the menu, providing a convenient user experience.
- User
now not sending data to the com port
- Assistant
If the device is no longer sending data to the COM port after making the changes, we should double-check the code to ensure that the relevant UART communication sections are still operational. Here’s a checklist and an updated version of the code to ensure it's correctly processing and sending data back:
-
Check UART Command Handling: Ensure that the conditions for handling UART commands are still part of the code, specifically in the portion handling
wei.mdfor any other UART commands you wish to respond to. -
Verify Writing Responses to UART: Whenever you need to respond to specific UART commands, make sure the correct
uart.write()statements are still active. -
Testing the Basic Communication: You can add simple send and receive functionality to check if data is being sent out correctly.
Updated Code with Both Sending and UART Handling
Here’s the revised code, ensuring that it continues to send data back to the UART as required while also displaying data when "Data" is selected.
from machine import UART, Pin, I2C from ssd1306 import SSD1306_I2C import utime from oled import Write, GFX from oled.fonts import ubuntu_mono_15, ubuntu_mono_20 from rotary_irq_rp2 import RotaryIRQ from random import randrange # Initialize UART and other peripherals uart = UART(1, timeout=100, baudrate=56000, tx=Pin(4), rx=Pin(5), bits=8, parity=None, stop=1) led = Pin(25, Pin.OUT) SW = Pin(20, Pin.IN, Pin.PULL_UP) r = RotaryIRQ(pin_num_clk=18, pin_num_dt=19, min_val=0, reverse=False, range_mode=RotaryIRQ.RANGE_UNBOUNDED) val_old = r.value() menu_options = ["Data", "Instructions", "Setup", "Calibration", "Help"] current_selection = 0 # Start with the first menu item # Push button setup butPinValueUp = 14 myButtonValueUp = Pin(butPinValueUp, Pin.IN, Pin.PULL_UP) butPinValueDown = 13 myButtonValueDown = Pin(butPinValueDown, Pin.IN, Pin.PULL_UP) butPinValueReset = 10 myButtonValueReset = Pin(butPinValueReset, Pin.IN, Pin.PULL_UP) # OLED and I2C setup i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000) oled = SSD1306_I2C(128, 64, i2c) gfx = GFX(128, 64, oled.pixel) # Fonts write15 = Write(oled, ubuntu_mono_15) write20 = Write(oled, ubuntu_mono_20) # Initial display oled.fill(0) write20.text("JMS AERO AG", 7, 0) write20.text("Data Logger", 7, 20) write20.text("Simulator", 19, 40) oled.show() utime.sleep(5) # Clear the display after the initial screen oled.fill(0) oled.show() # Function to display the menu def display_menu(): oled.fill(0) # Clear the display for i, option in enumerate(menu_options): if i == current_selection: oled.text(">" + option, 10, i * 10) # Highlight selected option else: oled.text(option, 10, i * 10) oled.show() # Function to display UART data on OLED def display_uart_data(data): oled.fill(0) # Clear the display for new data write20.text("UART Data:", 0, 0) oled.text(data.decode().strip(), 0, 20) # Display the updated UART message oled.show() # Function to handle UART data display def handle_uart_data_display(): global current_selection oled.fill(0) # Clear the display write20.text("Receiving Data...", 0, 0) oled.show() while True: if uart.any(): data = uart.readline() print("Received UART data:", data) # Debug print display_uart_data(data) # Display the received data on the OLED # Respond based on received UART commands if data.startswith(b'<<INITIALIZE'): led.toggle() # Toggle LED for debug uart.write(b'Initialized\r\n') # Send response elif data.startswith(b'<<CANCEL'): led.toggle() uart.write(b'Cancelled\r\n') # Send response elif data.startswith(b'<<START TEST'): led.toggle() uart.write(b'Starting Test\r\n') # Send response elif data.startswith(b'wei.zrp'): led.toggle() uart.write(b'wei.zrp Zero Emulated\r\n') # Send response utime.sleep(1) elif data.startswith(b'wei.mdf'): led.toggle() randEndValue = randrange(9) # Generate a random number (0-8) cellValue = 100000 # Example value response = f"wei.mdf.A:RAW:+ 20617;1;ST;GS;GRO:+ {cellValue};NET:+ 0.000;TAR:+ 0.000;{randEndValue}e\r\n" uart.write(response.encode()) # Send response print("Sent response:", response) # Debug print # Check if the rotary encoder button is pressed if SW.value() == 0: # If the switch button is pressed utime.sleep(0.1) # Debounce delay break # Main loop for handling buttons and rotary encoder while True: try: # Check rotary encoder val_new = r.value() if val_old != val_new: # Update current selection current_selection = (current_selection + (val_new - val_old)) % len(menu_options) val_old = val_new display_menu() # Update display only when the selection changes # Select menu item if SW.value() == 0: # If the switch button is pressed print("Selected:", menu_options[current_selection]) if menu_options[current_selection] == "Data": handle_uart_data_display() # Enter data receiving mode elif menu_options[current_selection] == "Instructions": instructions() # Your existing function for instructions elif menu_options[current_selection] == "Setup": setup() # Your existing function for setup elif menu_options[current_selection] == "Calibration": calibration() # Your existing function for calibration elif menu_options[current_selection] == "Help": help_menu() # Your existing function for help # Display current menu display_menu() # Refresh the menu display utime.sleep_ms(100) # Small delay to prevent excessive CPU usage except KeyboardInterrupt: breakKey Changes and Debugging Enhancements:
-
Sending Responses: The code ensures that UART responses are sent back for each recognized command, including
<<INITIALIZE,<<CANCEL,<<START TEST,wei.zrp, andwei.mdf. -
Print Statements for Debugging: I've retained print statements to log received data and responses sent back to the UART, which will help you verify the behavior in the terminal.
-
Encoding Strings for UART: When sending response strings over the UART, make sure to encode the string using
.encode(). -
Ensure Proper Handling: The loop for receiving and displaying UART messages is kept intact in the
handle_uart_data_display()function, ensuring you handle incoming data properly when this mode is active.
Testing:
- Upload this code to your microcontroller and ensure your UART device is properly connected.
- Send the appropriate commands to the device and observe the responses to ensure they are being sent and displayed correctly in your terminal.
- Use a serial terminal application to observe both incoming and outgoing data to check if everything is working as expected.
This setup should allow you to continuously read and send UART data while still interacting with the menu system correctly. Let me know if you have any further questions!
-
- User
data now being sent, but one a menu item other than Data is selected the menu locks
- Assistant
The issue of the menu locking or becoming unresponsive when selecting any item other than "Data" likely arises from how the functions for the other menu items (like
instructions(),setup(),calibration(), andhelp_menu()) are implemented.Troubleshooting Steps
-
Blocking Functions: Ensure that the functions for these menu items do not block the main loop for an extended amount of time. For instance, if a function displays something for several seconds without returning control back to the main loop, it will seem as if the menu has locked up.
-
Keep Menu Active: Ideally, pressing the rotary encoder should return to the main menu immediately after a menu item is selected or an action is taken.
-
Provide Context for Options: Instead of having long-blocking sleep periods or lengthy displays in each menu option, consider providing a back option or prompt to return to the main menu.
Here’s how you can modify the functions to prevent locking and allow for smooth interaction:
Revised Code Snippet for Other Menu Options
Below is a restructured version of the menu option functions and modified main loop to allow for immediate return:
# Function to display Instructions def instructions(): oled.fill(0) write20.text("Instructions:", 0, 0) write15.text("1. Step A", 0, 20) write15.text("2. Step B", 0, 30) write15.text("3. Step C", 0, 40) write15.text("Press SW to exit", 0, 55) oled.show() while SW.value() == 1: # Wait for button press to exit utime.sleep(0.1) # Reduce CPU usage in the loop # Function to display Setup Menu def setup(): oled.fill(0) write20.text("Setup Menu", 0, 0) write15.text("Configure options", 0, 20) write15.text("Press SW to exit", 0, 55) oled.show() while SW.value() == 1: # Wait for button press to exit utime.sleep(0.1) # Reduce CPU usage in the loop # Function for Calibration Menu def calibration(): oled.fill(0) write20.text("Calibration Menu", 0, 0) write15.text("Adjust settings", 0, 20) write15.text("Press SW to exit", 0, 55) oled.show() while SW.value() == 1: # Wait for button press to exit utime.sleep(0.1) # Reduce CPU usage in the loop # Function for Help Menu def help_menu(): oled.fill(0) write20.text("Help Menu", 0, 0) write15.text("Help information", 0, 20) write15.text("Press SW to exit", 0, 55) oled.show() while SW.value() == 1: # Wait for button press to exit utime.sleep(0.1) # Reduce CPU usage in the loop # Main loop for handling buttons and rotary encoder while True: try: # Check rotary encoder val_new = r.value() if val_old != val_new: # Update current selection current_selection = (current_selection + (val_new - val_old)) % len(menu_options) val_old = val_new display_menu() # Update display only when the selection changes # Select menu item if SW.value() == 0: # If the switch button is pressed print("Selected:", menu_options[current_selection]) if menu_options[current_selection] == "Data": handle_uart_data_display() # Enter data receiving mode elif menu_options[current_selection] == "Instructions": instructions() elif menu_options[current_selection] == "Setup": setup() elif menu_options[current_selection] == "Calibration": calibration() elif menu_options[current_selection] == "Help": help_menu() # Display current menu display_menu() # Refresh the menu display utime.sleep_ms(100) # Small delay to prevent excessive CPU usage except KeyboardInterrupt: breakKey Changes Made:
-
Non-blocking Menu Item Functions: The
instructions(),setup(),calibration(), andhelp_menu()functions now contain a loop that waits for the user to press the switch button (SW) to exit. This allows control to return immediately when the user wants to go back. -
Reduced Sleep Calls: The inner loop uses a small sleep to check the button state without hogging the CPU unnecessarily.
Result:
This revised functionality should prevent the menu from becoming unresponsive when selecting options other than "Data." When any menu item is selected, users can read the instructions or other information and simply press the rotary encoder switch button to return to the main menu promptly.
Load the updated code onto your microcontroller, and you should find that the menu works without locking, allowing for a responsive user interface while still displaying UART data. If further adjustments are needed, let me know!
-
- User
full code please
- Assistant
Certainly! Below is the complete code implementing all the features discussed, including a responsive menu that displays UART data, navigates through menu options, and allows returning to the main menu from any of the submenu options without locking.
Full Code Implementation
from machine import UART, Pin, I2C from ssd1306 import SSD1306_I2C import utime from oled import Write, GFX from oled.fonts import ubuntu_mono_15, ubuntu_mono_20 from rotary_irq_rp2 import RotaryIRQ from random import randrange # Initialize UART and other peripherals uart = UART(1, timeout=100, baudrate=56000, tx=Pin(4), rx=Pin(5), bits=8, parity=None, stop=1) led = Pin(25, Pin.OUT) SW = Pin(20, Pin.IN, Pin.PULL_UP) r = RotaryIRQ(pin_num_clk=18, pin_num_dt=19, min_val=0, reverse=False, range_mode=RotaryIRQ.RANGE_UNBOUNDED) val_old = r.value() menu_options = ["Data", "Instructions", "Setup", "Calibration", "Help"] current_selection = 0 # Start with the first menu item # Push button setup butPinValueUp = 14 myButtonValueUp = Pin(butPinValueUp, Pin.IN, Pin.PULL_UP) butPinValueDown = 13 myButtonValueDown = Pin(butPinValueDown, Pin.IN, Pin.PULL_UP) butPinValueReset = 10 myButtonValueReset = Pin(butPinValueReset, Pin.IN, Pin.PULL_UP) # OLED and I2C setup i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000) oled = SSD1306_I2C(128, 64, i2c) gfx = GFX(128, 64, oled.pixel) # Fonts write15 = Write(oled, ubuntu_mono_15) write20 = Write(oled, ubuntu_mono_20) # Initial display oled.fill(0) write20.text("JMS AERO AG", 7, 0) write20.text("Data Logger", 7, 20) write20.text("Simulator", 19, 40) oled.show() utime.sleep(5) # Clear the display after the initial screen oled.fill(0) oled.show() # Function to display the menu def display_menu(): oled.fill(0) # Clear the display for i, option in enumerate(menu_options): if i == current_selection: oled.text(">" + option, 10, i * 10) # Highlight selected option else: oled.text(option, 10, i * 10) oled.show() # Function to display UART data on OLED def display_uart_data(data): oled.fill(0) # Clear the display for new data write20.text("UART Data:", 0, 0) oled.text(data.decode().strip(), 0, 20) # Display the updated UART message oled.show() # Function to handle UART data display def handle_uart_data_display(): global current_selection oled.fill(0) # Clear the display write20.text("Receiving Data...", 0, 0) oled.show() while True: if uart.any(): data = uart.readline() print("Received UART data:", data) # Debug print display_uart_data(data) # Display the received data on the OLED # Respond based on received UART commands if data.startswith(b'<<INITIALIZE'): led.toggle() # Toggle LED for debug uart.write(b'Initialized\r\n') # Send response elif data.startswith(b'<<CANCEL'): led.toggle() uart.write(b'Cancelled\r\n') # Send response elif data.startswith(b'<<START TEST'): led.toggle() uart.write(b'Starting Test\r\n') # Send response elif data.startswith(b'wei.zrp'): led.toggle() uart.write(b'wei.zrp Zero Emulated\r\n') # Send response utime.sleep(1) elif data.startswith(b'wei.mdf'): led.toggle() randEndValue = randrange(9) # Generate a random number (0-8) cellValue = 100000 # Example value response = f"wei.mdf.A:RAW:+ 20617;1;ST;GS;GRO:+ {cellValue};NET:+ 0.000;TAR:+ 0.000;{randEndValue}e\r\n" uart.write(response.encode()) # Send response print("Sent response:", response) # Debug print # Check if the rotary encoder button is pressed if SW.value() == 0: # If the switch button is pressed utime.sleep(0.1) # Debounce delay break # Function to display Instructions def instructions(): oled.fill(0) write20.text("Instructions:", 0, 0) write15.text("1. Step A", 0, 20) write15.text("2. Step B", 0, 30) write15.text("3. Step C", 0, 40) write15.text("Press SW to exit", 0, 55) oled.show() while SW.value() == 1: # Wait for button press to exit utime.sleep(0.1) # Reduce CPU usage in the loop # Function to display Setup Menu def setup(): oled.fill(0) write20.text("Setup Menu", 0, 0) write15.text("Configure options", 0, 20) write15.text("Press SW to exit", 0, 55) oled.show() while SW.value() == 1: # Wait for button press to exit utime.sleep(0.1) # Reduce CPU usage in the loop # Function for Calibration Menu def calibration(): oled.fill(0) write20.text("Calibration Menu", 0, 0) write15.text("Adjust settings", 0, 20) write15.text("Press SW to exit", 0, 55) oled.show() while SW.value() == 1: # Wait for button press to exit utime.sleep(0.1) # Reduce CPU usage in the loop # Function for Help Menu def help_menu(): oled.fill(0) write20.text("Help Menu", 0, 0) write15.text("Help information", 0, 20) write15.text("Press SW to exit", 0, 55) oled.show() while SW.value() == 1: # Wait for button press to exit utime.sleep(0.1) # Reduce CPU usage in the loop # Main loop for handling buttons and rotary encoder while True: try: # Check rotary encoder val_new = r.value() if val_old != val_new: # Update current selection current_selection = (current_selection + (val_new - val_old)) % len(menu_options) val_old = val_new display_menu() # Update display only when the selection changes # Select menu item if SW.value() == 0: # If the switch button is pressed print("Selected:", menu_options[current_selection]) if menu_options[current_selection] == "Data": handle_uart_data_display() # Enter data receiving mode elif menu_options[current_selection] == "Instructions": instructions() elif menu_options[current_selection] == "Setup": setup() elif menu_options[current_selection] == "Calibration": calibration() elif menu_options[current_selection] == "Help": help_menu() # Display current menu display_menu() # Refresh the menu display utime.sleep_ms(100) # Small delay to prevent excessive CPU usage except KeyboardInterrupt: breakCode Components Explained:
-
UART Initialization: The UART interface is initialized for communication.
-
Menu Structure: The menu allows navigation for "Data" and other options like "Instructions", "Setup", "Calibration", and "Help".
-
Serial Data Handling: The code continuously listens for incoming UART commands when "Data" is selected, processing these commands and sending appropriate responses.
-
Non-Blocking Menu Options: Each menu option that displays instructions, setup info, calibration, or help waits for the user to press the switch button before returning to the main menu, avoiding any locking or unresponsive behavior.
-
OLED Display Updates: Functions are provided to update the OLED display for both the menu and UART data.
Testing
- Upload the code to your microcontroller.
- Use a serial terminal application to send commands and observe responses for confirmation of UART functionality.
- Navigate through the menu options, ensuring you can return to the main menu promptly after viewing other information.
This setup should now fully meet your requirements. If there are any further changes or issues you'd like to address, let me know!
-
- User
working. please add this data to the display of data sent print("Sent response:", response) # Debug print
- Assistant
To display the response sent over UART on the OLED screen right after sending it, you can modify the
handle_uart_data_display()function to include a call to a display function for the sent response.Below is the code with the necessary modifications to show the sent data on the OLED display as well:
Full Code with Sent Response Display
from machine import UART, Pin, I2C from ssd1306 import SSD1306_I2C import utime from oled import Write, GFX from oled.fonts import ubuntu_mono_15, ubuntu_mono_20 from rotary_irq_rp2 import RotaryIRQ from random import randrange # Initialize UART and other peripherals uart = UART(1, timeout=100, baudrate=56000, tx=Pin(4), rx=Pin(5), bits=8, parity=None, stop=1) led = Pin(25, Pin.OUT) SW = Pin(20, Pin.IN, Pin.PULL_UP) r = RotaryIRQ(pin_num_clk=18, pin_num_dt=19, min_val=0, reverse=False, range_mode=RotaryIRQ.RANGE_UNBOUNDED) val_old = r.value() menu_options = ["Data", "Instructions", "Setup", "Calibration", "Help"] current_selection = 0 # Start with the first menu item # Push button setup butPinValueUp = 14 myButtonValueUp = Pin(butPinValueUp, Pin.IN, Pin.PULL_UP) butPinValueDown = 13 myButtonValueDown = Pin(butPinValueDown, Pin.IN, Pin.PULL_UP) butPinValueReset = 10 myButtonValueReset = Pin(butPinValueReset, Pin.IN, Pin.PULL_UP) # OLED and I2C setup i2c = I2C(0, sda=Pin(0), scl=Pin(1), freq=400000) oled = SSD1306_I2C(128, 64, i2c) gfx = GFX(128, 64, oled.pixel) # Fonts write15 = Write(oled, ubuntu_mono_15) write20 = Write(oled, ubuntu_mono_20) # Initial display oled.fill(0) write20.text("JMS AERO AG", 7, 0) write20.text("Data Logger", 7, 20) write20.text("Simulator", 19, 40) oled.show() utime.sleep(5) # Clear the display after the initial screen oled.fill(0) oled.show() # Function to display the menu def display_menu(): oled.fill(0) # Clear the display for i, option in enumerate(menu_options): if i == current_selection: oled.text(">" + option, 10, i * 10) # Highlight selected option else: oled.text(option, 10, i * 10) oled.show() # Function to display UART data on OLED def display_uart_data(data): oled.fill(0) # Clear the display for new data write20.text("UART Data:", 0, 0) oled.text(data.decode().strip(), 0, 20) # Display the updated UART message oled.show() # Function to display sent response def display_sent_response(response): oled.fill(0) # Clear the display for new data write20.text("Sent Response:", 0, 0) oled.text(response.decode().strip(), 0, 20) # Display the sent response oled.show() # Function to handle UART data display def handle_uart_data_display(): global current_selection oled.fill(0) # Clear the display write20.text("Receiving Data...", 0, 0) oled.show() while True: if uart.any(): data = uart.readline() print("Received UART data:", data) # Debug print display_uart_data(data) # Display the received data on the OLED # Respond based on received UART commands if data.startswith(b'<<INITIALIZE'): led.toggle() # Toggle LED for debug uart.write(b'Initialized\r\n') # Send response elif data.startswith(b'<<CANCEL'): led.toggle() uart.write(b'Cancelled\r\n') # Send response elif data.startswith(b'<<START TEST'): led.toggle() uart.write(b'Starting Test\r\n') # Send response elif data.startswith(b'wei.zrp'): led.toggle() uart.write(b'wei.zrp Zero Emulated\r\n') # Send response utime.sleep(1) elif data.startswith(b'wei.mdf'): led.toggle() randEndValue = randrange(9) # Generate a random number (0-8) cellValue = 100000 # Example value response = f"wei.mdf.A:RAW:+ 20617;1;ST;GS;GRO:+ {cellValue};NET:+ 0.000;TAR:+ 0.000;{randEndValue}e\r\n" uart.write(response.encode()) # Send response print("Sent response:", response) # Debug print display_sent_response(response.encode()) # Display sent response # Check if the rotary encoder button is pressed if SW.value() == 0: # If the switch button is pressed utime.sleep(0.1) # Debounce delay break # Function to display Instructions def instructions(): oled.fill(0) write20.text("Instructions:", 0, 0) write15.text("1. Step A", 0, 20) write15.text("2. Step B", 0, 30) write15.text("3. Step C", 0, 40) write15.text("Press SW to exit", 0, 55) oled.show() while SW.value() == 1: # Wait for button press to exit utime.sleep(0.1) # Reduce CPU usage in the loop # Function to display Setup Menu def setup(): oled.fill(0) write20.text("Setup Menu", 0, 0) write15.text("Configure options", 0, 20) write15.text("Press SW to exit", 0, 55) oled.show() while SW.value() == 1: # Wait for button press to exit utime.sleep(0.1) # Reduce CPU usage in the loop # Function for Calibration Menu def calibration(): oled.fill(0) write20.text("Calibration Menu", 0, 0) write15.text("Adjust settings", 0, 20) write15.text("Press SW to exit", 0, 55) oled.show() while SW.value() == 1: # Wait for button press to exit utime.sleep(0.1) # Reduce CPU usage in the loop # Function for Help Menu def help_menu(): oled.fill(0) write20.text("Help Menu", 0, 0) write15.text("Help information", 0, 20) write15.text("Press SW to exit", 0, 55) oled.show() while SW.value() == 1: # Wait for button press to exit utime.sleep(0.1) # Reduce CPU usage in the loop # Main loop for handling buttons and rotary encoder while True: try: # Check rotary encoder val_new = r.value() if val_old != val_new: # Update current selection current_selection = (current_selection + (val_new - val_old)) % len(menu_options) val_old = val_new display_menu() # Update display only when the selection changes # Select menu item if SW.value() == 0: # If the switch button is pressed print("Selected:", menu_options[current_selection]) if menu_options[current_selection] == "Data": handle_uart_data_display() # Enter data receiving mode elif menu_options[current_selection] == "Instructions": instructions() elif menu_options[current_selection] == "Setup": setup() elif menu_options[current_selection] == "Calibration": calibration() elif menu_options[current_selection] == "Help": help_menu() # Display current menu display_menu() # Refresh the menu display utime.sleep_ms(100) # Small delay to prevent excessive CPU usage except KeyboardInterrupt: breakKey Modifications:
-
New Function
display_sent_response(response): This function is created to display the sent UART response on the OLED. It takes the response string, clears the display, and shows the formatted response received from the UART in a dedicated area. -
Call to
display_sent_response(): After constructing the response string in thehandle_uart_data_display()function, the code now callsdisplay_sent_response(response.encode())to show the sent response on the OLED display right after it is sent.
Expected Behavior:
- When a command is received and processed that generates a response (like
wei.mdf), the LED will toggle, and the response will be sent back via UART. - Alongside that, the OLED display will show the response sent, providing real-time feedback on the actions taken by the device.
Load this complete code onto your microcontroller, and it should function according to your specifications. Let me know if you need further adjustments!
-