MP3-Player mit Pico und DFPlayer Mini

import time
from machine import Pin
from dfplayermini import DFPlayerMini
import random  # Für zufällige Liedauswahl


player1 = DFPlayerMini(1, 4, 5)


button1 = Pin(3, Pin.IN, Pin.PULL_UP)
button2 = Pin(0, Pin.IN, Pin.PULL_UP)
aux_detect = Pin(8, Pin.IN, Pin.PULL_UP)
relay = Pin(9, Pin.OUT)


S0 = Pin(6, Pin.OUT)
S1 = Pin(7, Pin.OUT)
S2 = Pin(10, Pin.OUT)


x = 0
y = 0
relay_timer = 0  # Timer für BT-Wechsel
relay.value(0)
switched = False  # Für AUX-Kabel-Erkennung
current_channel = 0

# Modusvariable (0 = Reihenfolge, 1 = Shuffle)
mode = 0
current_song = 0  # Aktueller Song (für Reihenfolge-Modus)

# Funktion zum Wechseln des Multiplexer-Kanals
def switch_channel(channel):
   S0.value((channel >> 0) & 1)
   S1.value((channel >> 1) & 1)
   S2.value((channel >> 2) & 1)
   

switch_channel(0)
read_value = player1.set_volume(15)
read_value = player1.stop()

# Überprüfen der Knöpfe
def check_buttons():
   """Überprüft, ob einer der Knöpfe gedrückt wird"""
   if button1.value() == 0 or button2.value() == 0:
       return True
   return False
   
# Funktion für die Zufallswiedergabe
def play_random():
   """Spielt ein zufälliges Lied aus der SD-Karte"""
   song = random.randint(1, 5)  # Anzahl der Lieder anpassen
   print(f"Playing random song: {song}")
   player1.play(song)
   
# Funktion zum Wechseln zwischen Reihenfolge und Shuffle
def switch_mode():
   global mode, current_song
   if mode == 0:  # Von Reihenfolge zu Shuffle wechseln
       print("Switching to shuffle mode")
       current_song = 0  # Zurücksetzen der Reihenfolgenummer
       play_random()
       mode = 1
   else:  # Von Shuffle zu Reihenfolge wechseln
       print("Switching to sequence mode")
       mode = 0
       
# Funktion zur Wiedergabe des nächsten Liedes im Reihenfolge-Modus
def play_next_in_sequence():
   """Spielt das nächste Lied in der Reihenfolge ab"""
   global current_song
   current_song += 1
   print(f"Playing next song in sequence: {current_song}")
   player1.play(current_song)
   
# Haupt-Schleife
while True:
   # Überprüfen des AUX-Eingangs
   if aux_detect.value() == 0 and not switched:  # Nur prüfen, wenn das Kabel eingesteckt ist und noch nicht gewechselt wurde
       print("AUX-Kabel eingesteckt")
       switch_channel(1)  # Kanal wechseln
       y = 1
       switched = True  # Setze die Variable auf True, um zu verhindern, dass der Kanal wieder gewechselt wird
       relay.value(0)
       time.sleep(0.1)
   
   if aux_detect.value() == 1 and switched:  # Überprüfe, ob das Kabel entfernt wurde
       switched = False  # Erlaube den Wechsel wieder, falls das Kabel entfernt wird
       time.sleep(0.1)
   # Überprüfen von Button 2 (AUX, BT, SD Steuerung)
   if button2.value() == 0:
       while button2.value() == 0:
           pass
       time.sleep(0.1)
       if y == 0:
           print("AUX")
           switch_channel(1)
           y = 1
           time.sleep(0.2)
       elif y == 1:
           print("BT")
           switch_channel(2)
           relay.value(1)  # Relais einschalten
           relay_timer = time.ticks_ms()  # Timer zurücksetzen, wenn zu BT gewechselt wird
           y = 2
           time.sleep(0.2)
       elif y == 2:
           print("SD")
           relay_timer = time.ticks_ms()  # Timer zurücksetzen, wenn zu BT gewechselt wird
           switch_channel(0)
           time.sleep(1)  # 1 Sekunde warten, bevor das Lied startet (Warten auf Knopfdruck)
           if check_buttons():  # Überprüfen, ob ein Knopf gedrückt wurde
               print("Aktion durch Knopfdruck unterbrochen")
           else:
               read_value = player1.set_volume(15)
               player1.play_next()
           y = 0
           time.sleep(0.2)
           
   # Überwachen des Timers, um das Relais auszuschalten, wenn 5 Minuten vergangen sind
   if y != 2 and relay.value() == 1:  # Wenn der Status "SD" ist und das Relais an ist
       if time.ticks_diff(time.ticks_ms(), relay_timer) > 3000:  # 3 Sekunden für Testzwecke
           print("Deactivating relay due to inactivity.")
           relay.value(0)  # Relais ausschalten, wenn 3 Sekunden vergangen sind
           time.sleep(0.1)
           
   # Überprüfen von Button 1 (Play/Pause und Zufallsmodus)
   if button1.value() == 0 and y == 0:
       time.sleep(0.1)  # Entprellung
       button1_time = time.ticks_ms()
       click_count = 1  # Anzahl der Klicks
       # Prüfe auf langen Druck (> 1 Sekunde)
       while button1.value() == 0:
           if time.ticks_diff(time.ticks_ms(), button1_time) > 1000:
               switch_mode()  # Wechsel zwischen Modus
               time.sleep(0.1)
               break  # Kein Mehrfachklick mehr möglich
       # Falls kein langer Druck: Prüfe auf Mehrfachklicks
       else:
           double_click_time = time.ticks_ms()
           while time.ticks_diff(time.ticks_ms(), double_click_time) < 400:
               if button1.value() == 0:  # Zweiter Klick erkannt
                   click_count += 1
                   time.sleep(0.1)  # Nochmals entprellen
                   while button1.value() == 0:
                       pass  # Warten, bis losgelassen
                   time.sleep(0.1)  # Kurzes Debouncing nach Loslassen
                   if click_count == 2:
                       double_click_time = time.ticks_ms()  # Warte auf dritten Klick
                       continue
                   if click_count == 3:
                       print("prev")  # Dreifach-Klick → "prev"
                       time.sleep(0.1)
                       break
           else:  # Falls innerhalb der Wartezeit kein dritter Klick kommt
               if click_count == 2:
                   print("next")  # Doppel-Klick → "next"
                   if mode == 0:
                       play_next_in_sequence()
                   elif mode == 1:
                       play_random()  # Im Shuffle-Modus zufälliges Lied abspielen
               elif click_count == 1:
                   if x == 0:
                       print("play")
                       player1.start()
                   else:
                       print("pause")
                       player1.pause()
                   x = 1 if x == 0 else 0
                   
       time.sleep(0.2)  # Letztes Debouncing

import time
from machine import Pin
from dfplayermini import DFPlayerMini
import random

# DFPlayer Mini Pins
player1 = DFPlayerMini(1, 4, 5)




#Main Control-Button
button1 = Pin(3, Pin.IN, Pin.PULL_UP)

# Initialisiere Variablen

playing = False   #Play/pause (status)
b = 1   #Filenumber
y = 0   #channel (in diesem Fall 0 = SD)
v = 10	#Volume

started = False

player1.set_volume(v)			#might be needed for future Volume-control
player1.stop()	#"reset" player (might be unnessecary)

   

# timers for button presses
click_times = []
click_timeout = 400 
long_press_time = 700

while y == 0:
    if button1.value() == 0:
        press_start = time.ticks_ms()
        while button1.value() == 0:
            time.sleep(0.005)
            if time.ticks_diff(time.ticks_ms(), press_start) > long_press_time:
                print("random")  # Long Press
                while button1.value() == 0:
                    pass  # wait to let go
                time.sleep(0.05)
                click_times = []  # reset click number
                break
        else:
            click_times.append(time.ticks_ms())  #register click
            time.sleep(0.05)  

        # watch for further clicks
        start_wait = time.ticks_ms()
        while time.ticks_diff(time.ticks_ms(), start_wait) < click_timeout:
            if button1.value() == 0:
                break
        else:
            # analyse click-number
            num_clicks = len(click_times)
            if num_clicks == 1:
                if playing == False:
                    print("play")
                    player1.start()
                    started = True     

                else:
                    print("pause")
                    player1.pause()
                playing = True if playing == False else False		#controls wether to play or pause
                time.sleep(0.05)
                
            elif num_clicks == 2:
                print("next")
                player1.play_next()
                time.sleep(0.05)
                
            elif num_clicks >= 3:
                print("previous")
                player1.play_previous()
                time.sleep(0.05)
            click_times = []

   
    """if player1.get_status() == 0:
        if started == True:
            player1.play_next()
"""

# A library to control the DFPlayer MP3 player
# Only partial implementation
# For more details of protocol see https://www.dfrobot.com/
# Created by Stewart Watkiss @PenguinTutor
# https://www.penguintutor.com 


from machine import UART, Pin
import time

class DFPlayerMini ():
    
    # how long to pause between read and write / subsequent reads
    sleep_time = 0.2
    debug = False
    
    sources = {
        'usb': 1,
        'sdcard': 2,
        'sd': 2,         # Allow sd as well as sd card
        'aux': 3,
        'sleep': 4,
        'flash': 5
        }
    
    def __init__ (self, uart_no, tx, rx):
        self.uart = UART(uart_no, baudrate=9600, tx=Pin(tx), rx=Pin(rx))
        self.uart.init(9600, bits=8, parity=None, stop=1)
        # Set to source when configured
        self.source = None
        # Keep track of if paused
        # Eg. allows resuming paused track when play is pressed
        self.paused = False
        
       
    # Simple check that looks for a standard 0x40 return code
    def check_return (self, byte_string):
        if byte_string[3] == 0x40:
            print ("Error receiving data")
            return False
        return True 
        
        
    # Send a byte string (bytes should alread be fully encoded)
    # then return the response
    def send_bytes (self, byte_string):
        sent_count = self.uart.write(byte_string)
        time.sleep(self.sleep_time)
        return self.read_reply()
        
    # Get a response - part of send_bytes, but also called seperately
    # where multiple replies are expected
    def read_reply (self):
        read_value = self.uart.read(10)
        if self.debug:
            if read_value == None:
                print ("None received")
                return None
            string_received = "".join([f"\\x{byte:02x}" for byte in read_value])
            print (f"Received {string_received}")
        return read_value
    
    
    def calc_checksum(self, data):
        # Data string
        sum = 0
        for byte in data:
            sum += byte
        #Convert to twos complement
        twos = (0xFFFF + 1 - sum)
        return twos
    
    def send_command (self, command, value=0, feedback=1):
        # Start = 7E
        # Version = FF
        # Len = 06
        # cmd
        # feedback = 1 or 0 (Whether response required) typically 1 for yes
        # para 1 (high data byte)
        # para 2 (low data byte)
        # checksum (from Version to para2) - 2 bytes
        # End = EF
        
        # Data without start, end or checksum
        data = b'\xFF\x06' + command.to_bytes(1) + feedback.to_bytes(1) + value.to_bytes(2)
        # Add checksum to data
        checksum = self.calc_checksum(data)
        data += checksum.to_bytes(2)
        # Add start and end bytes
        data_string = b'\x7E' + data + b'\xEF'
        string_sent = "".join([f"\\x{byte:02x}" for byte in data_string])
        if self.debug:
            print (f"Sending: {string_sent}")
        
        return self.send_bytes (data_string)
    
    def reset(self):
        self.paused = False
        #'reset' : b'\x7E\xFF\x06\x0C\x01\x00\x00\xFE\xEE\xEF'
        return_value = self.send_command(0x0C)
        #print (f"Return 1: {return_value}")
        # First return will be x41 with 0,0,0
        # Check for no return value or length of value is not correct
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        # Reset wait 2 x sleep as sometimes needs to stabilise first
        time.sleep(self.sleep_time)
        time.sleep(self.sleep_time)
        # Next value should be x3f with 0,0,<response>
        return_value = self.read_reply()
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        #print (f"Return 2: {return_value}")
        # Now check for a valid return value - lower data byte = [6]
        # 0 = Timeout
        #string_recv = "".join([f"\\x{byte:02x}" for byte in return_value])
        if return_value[3] != 0x3f:
            # Expecting 3f - if not then just return false
            return False
        # 2 = Cardinserted, 4 = CardOnline, 7 = USBInserted, 9 = USBOnline, 10 = CardUSBOnline
        if return_value[6] in (0x02, 0x04, 0x07, 0x09, 0x10):
            return True
        # Any other value return False
        return False


    # Get number of files on card / disk / flash
    # If source is default or None then uses current source
    def query_num_files(self, source=None):
        query_code = None
        # If no source set use current, otherwise return false
        if source == None:
            if self.source == None:
                return False
            source = self.source

        # Now source is set from parameter or using defult
        # Different from datasheet which says x47 - TF card, x48 = U-disk
        if source in ('sdcard', 'sd'):
            query_code = 0x48
        elif source == 'usb':
            query_code = 0x47
        elif source == 'flash':
            query_code = 0x49
            
        
        return_value = self.send_command(query_code)
        print (f"query_num_files {return_value}")
        # Check for no return value or length of value is not correct
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        time.sleep(self.sleep_time)
        # Now check for a valid return value - lower data byte = [6]
        return_value = self.read_reply()
        # Now check for a valid return value - lower data byte = [6]
        # 0 = Timeout
        #string_recv = "".join([f"\\x{byte:02x}" for byte in return_value])
        if return_value[3] != query_code:
            # Expecting 3f - if not then just return false
            return False

        # Return value of lower byte + upper byte x (FF+1)
        eval_value = (return_value[5] * 256) + return_value[6]
        print (f"Eval {eval_value}")
        return eval_value


    def get_volume(self):
        # eg.  b'\x7E\xFF\x06\x06\x01\x00\x0A\xFE\xEA\xEF' (10)
        return_value = self.send_command(0x43)
        # First return just confirm command
        # Check for no return value or length of value is not correct
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        time.sleep(self.sleep_time)
        # Retrieve actual value
        return_value = self.read_reply()
        # Check for no return value or length of value is not correct
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        if return_value[3] != 0x43:
            # Expecting 3f - if not then just return false
            return False
        return return_value[6]

    def set_volume(self, volume):
        # eg.  b'\x7E\xFF\x06\x06\x01\x00\x0A\xFE\xEA\xEF' (10)
        return_value = self.send_command(0x06, volume)
        # Check for no return value or length of value is not correct
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        return self.check_return(return_value)
    
    def volume_up(self):
        return_value = self.send_command(0x04)
        # Check for no return value or length of value is not correct
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        return self.check_return(return_value)

    def volume_down(self):
        return_value = self.send_command(0x05)
        # Check for no return value or length of value is not correct
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        return self.check_return(return_value)


    # select source of audio - eg. "usb", "sdcard", "aux", "sleep", "flash"
    def select_source(self, source):
        self.paused = False
        #'sdcard' : b'\x7E\xFF\x06\x09\x01\x00\x02\xFE\xEF\xEF'
        return_value = self.send_command(0x09, self.sources[source])
        # Check for no return value or length of value is not correct
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        self.source = source
        return True

    def stop(self):
        self.paused = False
        return_value = self.send_command(0x16)
        # Check for no return value or length of value is not correct
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        return True
    
    def play (self, track_num):
        self.paused = False
        #'play1' : b'\x7E\xFF\x06\x03\x01\x00\x01\xFE\xF6\xEF',
        return_value = self.send_command(0x03, track_num)
        # Check for no return value or length of value is not correct
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        return True
    
    def play_next (self):
        self.paused = False
        return_value = self.send_command(0x01)
        # Check for no return value or length of value is not correct
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        return True
    
    def play_previous (self):
        self.paused = False
        return_value = self.send_command(0x02)
        # Check for no return value or length of value is not correct
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        return True

    def play_loop (self, track_num):
        self.paused = False
        return_value = self.send_command(0x08, track_num)
        # Check for no return value or length of value is not correct
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        return True

    def pause (self):
        self.paused = True
        return_value = self.send_command(0x0E)
        # Check for no return value or length of value is not correct
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        return True
    
    # Play / resume if paused
    def start (self):
        self.paused = False
        return_value = self.send_command(0x0D)
        # Check for no return value or length of value is not correct
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        return True
    
    # Returns False if out of sync / error, 0 if stopped, 1 if playing, 2 if paused
    def get_status(self):
        #print ("\nChecking status")
        return_value = self.send_command(0x42)
        # First return just confirm command
        # Check for no return value or length of value is not correct        
        if return_value == None or len(return_value) != 10:
            #print ("No response - retry")
            # First retry:
            return_value = self.read_reply()
            if return_value == None or len(return_value) != 10:
                # If still not a valid reply return without checking for a value
                return False
        #print (f"Pre-return value {return_value[3]} - {return_value[5]}:{return_value[6]}")
        time.sleep(self.sleep_time)
        # Retrieve actual value
        return_value = self.read_reply()
        # Check for no return value or length of value is not correct
        if return_value == None or len(return_value) != 10:
            # If so just return without checking for a value
            return False
        # If get a generic reply - then likely missed previously, so check again for the value reply
        if return_value[3] == 0x41:
            time.sleep(self.sleep_time)
            return_value = self.read_reply()
        #print (f"Return value {return_value[3]} - {return_value[5]}:{return_value[6]}")
        if return_value[3] != 0x42:
            # Expecting 42 - if not then just return false
            return False
        return return_value[6]