UART device only responds when running in REPL, but not when running standalone on Raspberry Pi Pico W

[1-rafael-1]

Port, board and/or hardware

rp2 port, Raspberry Pi Pico W

MicroPython version

MicroPython v1.23.0 on 2024-06-02; Raspberry Pi Pico W with RP2040

Reproduction

I am fairly new to this, so assuming i am doing something wrong.
Full code is here: https://github.com/1-rafael-1/pi-pico-alarmclock

I have tried to strip down a smaller repro, but to my surprise the stripped-down code works as expected, while the full code does not. I am at a loss as to why and hopefully somebody can give me a hint.

Here is a stripped-down version:

file main.py in base folder:

import micropython
from classes.app_manager import ApplicationManager

@micropython.native
def main():
    micropython.alloc_emergency_exception_buf(100)
   
    try:
        app = ApplicationManager()
        app.initialize()
        app.run()
    except Exception as e:
        print("An unexpected error occurred in main.py: ", e)
    except KeyboardInterrupt:
        pass
    finally:
        pass

if __name__ == "__main__":
    main()

file dfplayer_mini.py in folder drivers:

# taken from https://github.com/tomdionysus/dfplayermini-micropython
# modified to choose uart instance
# fixed missing import of utime
# fixed accessing class-level constants
# fixed missing method validate_checksum
# fixed missing constants
# added option to control power to the module
# added option to check if the module is busy

import machine
import utime

class DFPlayerMini:

    # Start and End Bytes
    START_BYTE = 0x7E
    END_BYTE = 0xEF
    VERSION_BYTE = 0xFF

    # Command Codes
    CMD_PLAY = 0x0D
    CMD_PAUSE = 0x0E
    CMD_NEXT = 0x01
    CMD_PREV = 0x02
    CMD_PLAY_TRACK = 0x03
    CMD_INC_VOLUME = 0x04
    CMD_DEC_VOLUME = 0x05
    CMD_SET_VOLUME = 0x06
    CMD_SET_EQ = 0x07
    CMD_REPEAT_TRACK = 0x08
    CMD_SET_PLAYBACK_SRC = 0x09
    CMD_SLEEP_MODE = 0x0A
    CMD_WAKE_UP = 0x0B
    CMD_RESET = 0x0C
    CMD_PLAY_FOLDER_FILE = 0x0F
    CMD_VOLUME_ADJUST_SET = 0x10
    CMD_REPEAT_PLAY = 0x11
    CMD_PLAY_FOLDER = 0x17
    CMD_SHUFFLE_PLAY = 0x18
    CMD_PLAY_ADVERT = 0x13
    CMD_STOP_ADVERT = 0x15
    CMD_STOP = 0x16
    CMD_QUERY_STATUS = 0x42
    CMD_QUERY_VOLUME = 0x43
    CMD_QUERY_EQ = 0x44
    CMD_QUERY_PLAYBACK_MODE = 0x45

    # Feedback Types
    FEEDBACK_REPLY = 0x41
    FEEDBACK_ERROR = 0x40
    FEEDBACK_INIT_COMPLETE = 0x3F
    FEEDBACK_STATUS = 0x42
    FEEDBACK_VOLUME = 0x43
    FEEDBACK_EQ = 0x44
    FEEDBACK_PLAYBACK_MODE = 0x45
    FEEDBACK_VERSION = 0x46
    FEEDBACK_TOTAL_FILES_TF = 0x47
    FEEDBACK_KEEP_ON = 0x4A
    FEEDBACK_CURRENT_TRACK_TF = 0x4C
    FEEDBACK_CURRENT_TRACK_USB = 0x4D
    FEEDBACK_TOTAL_TRACKS_FOLDER = 0x4E
    FEEDBACK_TOTAL_TRACKS = 0x4F
    FEEDBACK_TOTAL_FOLDERS = 0x50

    # Specific Feedback Command Codes for Track Finished and Device Status
    TRACK_FINISHED_UDISK = 0x3C  # U-Disk track finished
    TRACK_FINISHED_TF = 0x3D     # TF Card track finished
    DEVICE_STATUS = 0x3A         # Device status (insertion, removal)

    # Event Parameters for Device Status (Used with DEVICE_STATUS)
    DEVICE_USB_INSERTED = 0x01   # USB inserted
    DEVICE_TF_INSERTED = 0x02    # TF card inserted
    DEVICE_USB_REMOVED = 0x01    # USB removed
    DEVICE_TF_REMOVED = 0x02     # TF card removed

    # Error Codes
    ERROR_BUSY = 0x01
    ERROR_SLEEPING = 0x02
    ERROR_SERIAL_WRONG_STACK = 0x03
    ERROR_CHECKSUM_NOT_MATCH = 0x04
    ERROR_FILE_INDEX_OUT = 0x05
    ERROR_FILE_MISMATCH = 0x06
    ERROR_ADVERTISE = 0x07

    # EQ Modes
    EQ_NORMAL = 0
    EQ_POP = 1
    EQ_ROCK = 2
    EQ_JAZZ = 3
    EQ_CLASSIC = 4
    EQ_BASIC = 5

    # Playback Source
    SRC_U_DISK = 1
    SRC_SD = 2
    SRC_AUX = 3
    SRC_SLEEP = 4
    SRC_FLASH = 5

    # Playback Modes
    MODE_REPEAT = 0
    MODE_FOLDER_REPEAT = 1
    MODE_SINGLE_REPEAT = 2
    MODE_RANDOM = 3

    # Initialization: Setting up serial communication.

    def __init__(self, tx_pin, rx_pin, uartinstance=1, power_pin=None, busy_pin=None, txbuf=32, rxbuf=32, timeout=10, timeout_char=10, bits=8):
        self.uart = machine.UART(uartinstance, baudrate=9600, tx=tx_pin, rx=rx_pin)
        if power_pin is not None:
            self.power_pin = machine.Pin(power_pin, machine.Pin.OUT)
        if busy_pin is not None:
            self.busy_pin = machine.Pin(busy_pin, machine.Pin.IN)
            
    def power_on(self):
        """
        Power on the DFPlayer Mini module. Requires a hardware power switch, using a GPIO pin and a MOSFET. Do NOT power the device from the GPIO pin directly!
        """
        if hasattr(self, 'power_pin'):
            self.power_pin.on()

    def power_off(self):
        """
        Power off the DFPlayer Mini module. equires a hardware power switch, using a GPIO pin and a MOSFET. Do NOT power the device from the GPIO pin directly!
        """
        if hasattr(self, 'power_pin'):
            self.power_pin.off()
    
    def begin(self):
        """
        Initialize communication with the DFPlayer Mini module.
        Call this method before performing any operations with the module.
        """
        self.wait_for_ready()

    def wait_for_ready(self):
        """
        Waits until the module is ready after power on.
        """
        # Wait for a specific time for DFPlayer Mini to initialize
        utime.sleep_ms(500)

    def is_busy(self):
        """
        Check if the DFPlayer Mini is busy.

        :return: True if the module is busy, False otherwise.
        """
        if hasattr(self, 'busy_pin'):
            return self.busy_pin.value() == 0 # low means busy
        return False

    # Sending Commands: General method to construct and send command packets.

    def send_command(self, command, parameter=0):
        """
        Sends a command to the DFPlayer Mini.

        :param command: The command byte.
        :param parameter: The parameter for the command, default to 0.
        """
        param_high = parameter >> 8
        param_low = parameter & 0xFF
        checksum = self.calculate_checksum(command, param_high, param_low)
        checksum_high = checksum >> 8
        checksum_low = checksum & 0xFF
        command_packet = bytearray([self.START_BYTE, self.VERSION_BYTE, 0x06, command, 0x00, param_high, param_low, checksum_high, checksum_low, self.END_BYTE])
        self.uart.write(command_packet)
        #print("Sent command: ", command_packet) 
        #self.uart.flush()
        i = 0
        while not self.uart.txdone():
            i += 1
            utime.sleep_ms(10)
        #print("Flushed UART after ", i, " attempts.")

    def calculate_checksum(self, command, param_high, param_low):
        """
        Calculates the checksum for a given command and parameter.

        :param command: The command byte.
        :param param_high: High byte of the parameter.
        :param param_low: Low byte of the parameter.
        :return: The calculated checksum.
        """
        checksum = -(self.VERSION_BYTE + 0x06 + command + 0x00 + param_high + param_low)
        return checksum & 0xFFFF

    def validate_checksum(self, response):
        """
        Validates the checksum in the response.
        :param response: The response data.
        :return: True if the checksum is valid, False otherwise.
        """
        # Extract the checksum from the response
        response_checksum = (response[7] << 8) | response[8]

        # Calculate the checksum of the command and parameters
        calculated_checksum = -sum(response[1:7]) & 0xFFFF

        # Compare the two checksums
        return response_checksum == calculated_checksum

    # Playing Tracks: Play a specific track, play next/previous.

    def play_track(self, track_number):
        """
        Play a specific track.

        :param track_number: Track number to play.
        """
        self.send_command(self.CMD_PLAY_TRACK, track_number)

    def play_next(self):
        """
        Play the next track.
        """
        self.send_command(self.CMD_NEXT)

    def play_previous(self):
        """
        Play the previous track.
        """
        self.send_command(self.CMD_PREV)

    # Volume Control: Set volume, increase/decrease volume.

    def set_volume(self, volume):
        """
        Set the volume level.

        :param volume: Volume level (0-30).
        """
        self.send_command(self.CMD_SET_VOLUME, volume)

    def volume_up(self):
        """
        Increase the volume by one level.
        """
        self.send_command(self.CMD_INC_VOLUME)

    def volume_down(self):
        """
        Decrease the volume by one level.
        """
        self.send_command(self.CMD_DEC_VOLUME)

    # Playback Control: Pause, resume, stop.

    def pause(self):
        """
        Pause playback.
        """
        self.send_command(self.CMD_PAUSE)

    def resume(self):
        """
        Resume playback.
        """
        self.send_command(self.CMD_PLAY)

    def stop(self):
        """
        Stop playback.
        """
        self.send_command(self.CMD_STOP)

    # Querying Status: Get the current status of the player.

    def read_response(self):
        start_time = utime.ticks_ms()
        while not self.uart.any():
            # Break the loop if no response is received within a timeout period (e.g., 2000 ms)
            if utime.ticks_diff(utime.ticks_ms(), start_time) > 2000:
                return "Timeout Error"
            utime.sleep_ms(10)  # Wait a bit before checking again

        response = self.uart.read(10)
        if len(response) == 10 and response[0] == self.START_BYTE and response[9] == self.END_BYTE:
            if self.validate_checksum(response):
                return response[6]  # The status byte
            else:
                return "Checksum Error"
        else:
            return "Invalid Response"
    
    def get_status(self):
        """
        Get the current status of the player.
        """
        self.send_command(self.CMD_QUERY_STATUS)
        return self.read_response()
    
    def get_current_volume(self):
        """
        Get the current volume level.
        """
        self.send_command(self.CMD_QUERY_VOLUME) 
        return self.read_response()
    
    def get_current_eq(self):
        """
        Get the current equalizer mode.
        """
        self.send_command(self.CMD_QUERY_EQ)
        return self.read_response()
    
    def get_playback_mode(self):
        """
        Get the current playback mode.
        """
        self.send_command(self.CMD_QUERY_PLAYBACK_MODE)
        return self.read_response()

    # Feedback Handling: Process feedback from the device, like track finished, error messages.

    def poll_feedback(self):
        """
        Polls the device for feedback, processing any available data.
        """
        if self.uart.any():
            response = self.uart.read(10)
            if len(response) == 10 and response[0] == self.START_BYTE and response[9] == self.END_BYTE:
                if self.validate_checksum(response):
                    return response[3], response[6]
                else:
                    return "Checksum Error"
            else:
                return "Invalid Response"
        return None

    # Advanced Playback Options: Repeat, shuffle, play from a specific folder.

    def repeat_track(self, track_number):
        """
        Repeat a specific track.

        :param track_number: Track number to repeat.
        """
        self.send_command(self.CMD_REPEAT_TRACK, track_number)

    def play_from_folder(self, folder_number, track_number):
        """
        Play a specific track from a specific folder.

        :param folder_number: Folder number.
        :param track_number: Track number in the folder.
        """
        # Combine folder and track number into one parameter
        parameter = (folder_number << 8) | track_number
        self.send_command(self.CMD_PLAY_FOLDER_FILE, parameter)

    def shuffle_play(self):
        """
        Enable shuffle playback.
        """
        self.send_command(self.CMD_SHUFFLE_PLAY)

    # Utility Functions: Reset, sleep, and other utility controls.

    def reset(self):
        """
        Reset the DFPlayer Mini module.
        """
        self.send_command(self.CMD_RESET)
        self.wait_for_ready()

    def sleep(self):
        """
        Put the DFPlayer Mini into sleep mode.
        """
        self.send_command(self.CMD_SLEEP_MODE)

    def wake_up(self):
        """
        Wake the DFPlayer Mini from sleep mode.
        """
        self.send_command(self.CMD_WAKE_UP)

    def set_playback_source(self, source):
        """
        Set the playback source.

        :param source: The source (e.g., SD card, USB).
        """
        self.send_command(self.CMD_SET_PLAYBACK_SRC, source)

    def set_equalizer(self, eq_mode):
        """
        Set the equalizer mode.

        :param eq_mode: Equalizer mode (e.g., rock, pop, jazz).
        """
        self.send_command(self.CMD_SET_EQ, eq_mode)

    def set_volume_adjustment(self, gain):
        """
        Set the volume adjustment.

        :param gain: Gain value.
        """
        self.send_command(self.CMD_VOLUME_ADJUST_SET, gain)

    def repeat_play(self, enable):
        """
        Set repeat play.

        :param enable: Enable or disable repeat.
        """
        self.send_command(self.CMD_REPEAT_PLAY, 0x01 if enable else 0x00)

file sound_mgr in folder classes:

from drivers.dfplayer_mini import DFPlayerMini
from utime import sleep
from machine import Pin

class SoundManager:
    def __init__(self, state_mgr):
        self.player = DFPlayerMini(uartinstance=1, tx_pin=4, rx_pin=5, power_pin=8, busy_pin=3, timeout=10)
        self.state_mgr = state_mgr

    def delay(self, times=1):
        for i in range(1, times):
            self.state_mgr.log_emit("Delaying", self.__class__.__name__)
            self.player.begin()
            i += 1

    def reset(self):
        self.state_mgr.log_emit("Resetting player", self.__class__.__name__)
        self.player.reset()

    def is_busy(self):
        return self.player.is_busy()

    def set_eq(self, eq):
        curr_eq = self.player.get_current_eq()
        if curr_eq == eq:
            self.state_mgr.log_emit("Equalizer already set to " + str(eq), self.__class__.__name__)
            return
        self.state_mgr.log_emit(f"Setting equalizer from {curr_eq} to {eq}", self.__class__.__name__)
        self.player.set_equalizer(eq)
        self.delay(1)
        i = 0
        while self.player.get_current_eq() != eq:
            self.state_mgr.log_emit(f"Equalizer not set to {eq}, current eq is {self.player.get_current_eq()}", self.__class__.__name__)
            self.player.set_equalizer(eq)
            sleep(0.2)
            i += 1
            if i > 20:
                self.state_mgr.log_emit(f"Equalizer not set to {eq}, current eq is {self.player.get_current_eq()}", self.__class__.__name__)
                break
        self.state_mgr.log_emit(f"Equalizer set to {eq} after {i} cycles", self.__class__.__name__)

    def set_volume(self, volume):
        curr_volume = self.player.get_current_volume()
        if curr_volume == volume:
            self.state_mgr.log_emit("Volume already set to " + str(volume), self.__class__.__name__)
            return
        self.state_mgr.log_emit(f"Setting volume from {curr_volume} to {volume}", self.__class__.__name__)
        self.player.set_volume(volume)
        self.delay(1)
        i = 0
        while self.player.get_current_volume() != volume:
            self.state_mgr.log_emit(f"Volume not set to {volume}, current volume is {self.player.get_current_volume()}", self.__class__.__name__)
            self.player.set_volume(volume)
            sleep(0.2)
            i += 1
            if i > 20:
                self.state_mgr.log_emit(f"Volume not set to {volume}, current volume is {self.player.get_current_volume()}", self.__class__.__name__)
                break
        self.state_mgr.log_emit(f"Volume set to {volume} after {i} cycles", self.__class__.__name__)

    def play(self, track):
        self.state_mgr.log_emit("Playing track " + str(track), self.__class__.__name__)
        self.player.play_track(track)
        self.delay(1)
        i = 0
        while not self.player.is_busy():
            self.state_mgr.log_emit("Not yet busy", self.__class__.__name__)
            self.player.play_track(track)
            sleep(0.2)
            i += 1
            if i > 20:
                self.state_mgr.log_emit("Not yet busy, giving up", self.__class__.__name__)
                break
        self.state_mgr.log_emit(f"Busy reached {self.player.is_busy()} after {i} cycles", self.__class__.__name__)

    def pause(self):
        self.state_mgr.log_emit("Pausing", self.__class__.__name__)
        self.player.pause()

    def resume(self):
        self.state_mgr.log_emit("Resuming", self.__class__.__name__)
        self.player.resume()

    def stop(self):
        self.state_mgr.log_emit("Stopping", self.__class__.__name__)
        self.player.stop()

    def standby(self):
        self.state_mgr.log_emit("Standing by", self.__class__.__name__)
        self.player.sleep()

    def wake_up(self):
        self.state_mgr.log_emit("Waking up", self.__class__.__name__)
        self.player.wake_up()

    def get_status(self):
        return self.player.get_status()
    
    def poll_feedback(self):
        return self.player.poll_feedback()

    def power_on(self):
        self.state_mgr.log_emit("Powering on", self.__class__.__name__)
        self.player.power_on()
        sleep(4)

    def power_off(self):
        self.state_mgr.log_emit("Powering off", self.__class__.__name__)
        self.player.power_off()

    def alarm_start(self):
        self.state_mgr.log_emit("Playing alarm sequence", self.__class__.__name__)
        self.power_on()
        self.set_eq(4) # classic
        self.set_volume(10) # medium volume
        self.play(1) # alarm track

    def alarm_stop(self):
        self.state_mgr.log_emit("Stopping alarm sequence", self.__class__.__name__)
        self.power_off()

    def deinit(self):
        self.delay()
        self.power_off()

file app_mgr in folder classes:

import micropython
from utime import sleep, time
from machine import idle, lightsleep
from classes import sound_mgr as SoundManager
from classes.sound_mgr import SoundManager

class MockStateManager: # use to test ApplicationManager in isolation
    def __init__(self):
        self.sound_manager = SoundManager(self)

    def log_emit(self, message, source):
        print(source + ": " + message)

    def sound_alarm_sequence(self):
        print("Sounding alarm")
        self.sound_manager.alarm_start()

class ApplicationManager:
    def __init__(self):
        self.state_mgr = MockStateManager()

    def initialize(self):
        pass

    @micropython.native
    def run(self):
        try:
            last_time = time()
            current_time = time()
            self.state_mgr.log_emit("Entering main loop", self.__class__.__name__)
            while True:
                idle()        
                sleep(.02)

                current_time = time()
                if current_time - last_time >= 10:
                    last_time = current_time
                    self.state_mgr.sound_alarm_sequence()

        except KeyboardInterrupt:
            pass
        except Exception as e:
            self.state_mgr.log_emit("An unexpected error occurred in app_mgr.py: " + str(e), self.__class__.__name__)
        finally:
            self.stop()

    def stop(self):
        self.state_mgr.log_emit("Exiting main loop", self.__class__.__name__)

Expected behaviour

I have connected a DFPlayer Mini (https://wiki.dfrobot.com/DFPlayer_Mini_SKU_DFR0299) and have found numerous drivers on GitHub. The device runs fine, when I run the code from VS Code through REPL. I can send commands, query status, ... pretty much what one would expect to happen does happen.

The mp3-player is part of a project and supposed to come online when an alarm time is reached and play one song. The entire systems works as expected under REPL, started from VS Code in my case.

(Code is here: https://github.com/1-rafael-1/pi-pico-alarmclock -> alarm_mgr holds the code calling the device and sound_mgr manages the device/loads the driver)

Observed behaviour

Run the system via VS Code/REPL: everything works.
Run the system after loading everything on the Pico by powering the pico: Everything works, except the sound.

I have tried to capture logs, basically in this mode all UART commands to read state from the mp3-player time out.

Change nothing, just attach the Pico back to VS Code, run main.py again: Everything works including the mp3-player.

Additional Information

I have tried to isolate things as much as I had ideas how to:

• move the sequence finally calling the device out of the thread it tuns in -> no change
• remove initiating threads altogether -> no change
• call the device independently of the rest of the system, just placing it in the main loop in app_mgr -> no change
• checked the wiring 100 times, measured voltage supplied to the device in both modes -> no clue
• and finally: for this issue strip down a version, removing basically all other components.... -> works, but I do not understand why

Code of Conduct

Yes, I agree

[TimHanewich]

Experiencing this with an RYLR988 LoRa module as well (interfaced over UART). Works well within REPL via Thonny, does not work when plugged in standalone.

[robert-hh]

@TimHanewich That looks like a Thonny problem. Please be sure that the code you want to run was actually copied permanently to the device. Thonny may hide the fact that it was not. Use another terminal emulator like mpremote, PuTTY, screen, picocom, ... Any of these are less intrusive than Thonny. The recommended tools is mpremote.

[TimHanewich]

@robert-hh thanks for your quick response. Shortly after posting this comment, I discovered in further research that the UART was in fact working properly, but oddly there were a series of random bytes coming across the receive line when initially connecting the Pico to power. After clearing those, things seem to be working as expected. Apologies for jumping the gun and commenting here!