Discussion :

[keokaz]

Bonjour,

j'ai un pi pico et un mfplayer mp3 mini, je n'arrive pas à faire fonctionner ce lecteur avec python.
Avec arduino j'ai pu jouer une musique mais dès que je passe en python , je n'arrive pas à trouver un bon tuto ?
j'ai suivis ce lien:
https://wiki.dfrobot.com/DFPlayer_Mini_SKU_DFR0299

Comment envoyé par l'UART la tram qui permet de lire la première piste en python?
Dans la librairie en C voici l'action de faire jouer la première piste:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
void DFRobotDFPlayerMini::play(int fileNumber){
  sendStack(0x03, fileNumber);
}

Tout ce que j'ai pu testé c'est ceci:

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from machine import UART, Pin
from time import sleep_us
 
class myUART(UART):
    def readUntil(self, termination, maxlen=-1, includeTermination=True):
        result = ''
        while maxlen < 0 or len(result) < maxlen:
            if self.any():
                print("here")
                result += chr(self.read(1)[0])
                print(result)
                if result.endswith(termination):
                    if not includeTermination:
                        result = result[:-len(termination)]
                    break
            sleep_us(10)
        return result
 
uart = myUART(0, baudrate=9600, tx=Pin(6), rx=Pin(7), bits=8, parity=None, stop=1)
 
uart.write("AT+GMR\r\n")
print(uart.readUntil('OK',maxlen=-1, includeTermination=True))

Avec la class UART comment je doit faire pour envoyer 0x03 par liaison série sur le port du pi pico jusqu'au port d'entrée du mfplayer mini?

Avez vous déjà essayé de le faire et de trouver un tuto qui fonctionne sans utiliser une autre plaque autre que le pi pico ?


merci de votre réponse.

[f-leb]

Salut,

Avec la class UART comment je doit faire pour envoyer 0x03 par liaison série sur le port du pi pico jusqu'au port d'entrée du mfplayer mini?

L'utilisation de la classe UART n'est pas difficile en soi, voir Using UART on the Raspberry Pi Pico. voir aussi la doc micropython class UART – duplex serial communication bus

Le plus délicat est de s'approprier le protocole pour envoyer des commandes avec le format spécial :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$S VER Len CMD  Feedback para1 para2 checksum $O

avec :
$S = 0x7E, début du message
VER : numéro de version
Len : taille du message
CMD : la commande, comme 0X03 pour spécifier le numéro de la piste
etc.

Il faut s'approprier ce protocole pour comprendre ce que fait la version C/C++. Il y a du boulot...

Edit : une piste peut-être https://github.com/ShrimpingIt/micropython-dfplayer

[keokaz]

Merci de ta réponse ,

j'ai trouvé et testé ceci :

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
from dfplayer import Player
from utime import sleep_ms
from machine import Pin
from time import sleep
 
 
class ScanPlayer(Player):
    def __init__(self, folders=10, scan=True, *a, **k ):
        if 'busy_pin' not in k: 
            k['busy_pin'] = Pin(0) # configure D3/GPIO0 as default busy pin
        super().__init__(*a, **k) 
        if folders > 99:
            raise AssertionError("Max 99 folders (00-99)")
        self.folders = folders
        self.tracks = None
        self.recent = {}
        if scan:
            self.scan()
        # TODO handle resetting volume after scan
 
    def scan(self):
        self.awaitconfig()
        self.volume(0.1)
        self.awaitvolume()
        self.tracks = {}
        for folderNum in range(0,self.folders): 
            for fileNum in range(0,256):                # max tracks-per-folder supported by dfplayer
                self.play(folderNum,fileNum)
                if self.playing():
                    if not(folderNum in self.tracks):
                        self.tracks[folderNum] = []
                    self.tracks[folderNum].append(fileNum)
                    continue
                else:
                    break
        self.volume(1.0) # TODO find principled way to set this, or remove volume control from scan
 
    def playNext(self, folderNum, wrap=True):
        if self.tracks is not None:
            if folderNum in self.tracks:
                files = self.tracks[folderNum]
                if folderNum in self.recent:
                    fileNum = self.recent[folderNum]
                    fileNum = (fileNum + 1)
                    if fileNum == len(files):
                        if wrap:
                            fileNum = fileNum % len(files) # increment with wraparound
                        else:
                            return False
                else:
                    fileNum = 0
                self.recent[folderNum] = fileNum
                self.play(folderNum, fileNum)
                return True
            else:
                raise AssertionError("Scan found no '{}' folder".format(folderNum))
        else:
            raise AssertionError("No scan available, run player.scan() first.")
 
    def finishAll(self, folderNum):
        if self.tracks is not None:
            if folderNum in self.tracks:
                folderTracks = self.tracks[folderNum]
                for trackNum in folderTracks:
                    self.finish(folderNum, trackNum)
            else:
                raise AssertionError("Scan found no '{}' folder".format(folderNum))
        else:
            raise AssertionError("No scan available, run player.scan() first.")

je ne comprend pas le constructeur sur le "a" et "k"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
  def __init__(self, folders=10, scan=True, *a, **k ):

[keokaz]

j'ai trouvé mais cela à fonctionné mais plus rien ...

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
from machine import UART
from utime import sleep_ms
 
 
class SimpleDFPlayerMini:
 
    def __init__(self, uart_id, volume, mode):
        self._uart = UART(uart_id, baudrate=9600)
        self._send_cmd(0x09, 1)
        self.set_eq(1)
        self.set_vol(volume)
        self.set_mode(mode)
        self.pause()
 
    def _send_cmd(self, cmd, data_low=0, data_high=0):
        self._uart.write(b'\x7E')
        self._uart.write(b'\xFF')
        self._uart.write(b'\x06')
        self._uart.write(bytes([cmd]))
        self._uart.write(b'\x00')
        self._uart.write(bytes([data_high]))
        self._uart.write(bytes([data_low]))
        self._uart.write(b'\xEF')
        sleep_ms(200)
 
    def next_track(self):
        self._send_cmd(0x01)
 
    def prev_track(self):
        self._send_cmd(0x02)
 
    def sel_track(self, track_index):
        self._send_cmd(0x03, track_index)
 
    def inc_vol(self):
        self._send_cmd(0x04)
 
    def dec_vol(self):
        self._send_cmd(0x05)
 
    def set_vol(self, volume):
        self._send_cmd(0x06, volume)
 
    def set_eq(self, equalizer):
        self._send_cmd(0x07, equalizer)
 
    def set_mode(self, mode):
        self._send_cmd(0x08, mode)
 
    def suspend(self):
        self._send_cmd(0x0A)
 
    def resume(self):
        self._send_cmd(0x0B)
 
    def reset(self):
        self._send_cmd(0x0C)
 
    def play(self):
        self._send_cmd(0x0D)
 
    def pause(self):
        self._send_cmd(0x0E)
 
    def set_folder(self, folder_index):
        self._send_cmd(0x0F, folder_index)
 
    def enable_loop(self):
        self._send_cmd(0x11, 1)
 
    def disable_loop(self):
        self._send_cmd(0x11, 0)
 
p1 = SimpleDFPlayerMini(1,1,0)

je pense que séquence de l'UART est ceci:

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
    def _send_cmd(self, cmd, data_low=0, data_high=0):
        self._uart.write(b'\x7E')
        self._uart.write(b'\xFF')
        self._uart.write(b'\x06')
        self._uart.write(bytes([cmd]))
        self._uart.write(b'\x00')
        self._uart.write(bytes([data_high]))
        self._uart.write(bytes([data_low]))
        self._uart.write(b'\xEF')
        sleep_ms(200)

par contre on dirai que le lecteur souhaite démarer mais s'arrête subitement , d'ailleur je vois la led rouge du lecteur s'allumer briefement ..

edit, j'ai pu lire correctement une piste cela vient de cette ligne:

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
    def __init__(self, uart_id, volume, mode):
        self._uart = UART(uart_id, baudrate=9600)
       ==>  self._send_cmd(0x09, 1)  ==> il faut mettre 0 à la place de 1 !

Ca fonctionne très bien, voici la vidéo de démo:

[f-leb]

Sympa la vidéo, bien joué

Bonne continuation

[keokaz]

merci