Raspberry Pico mit MIcroPython, Dfplayer, TSOP 4838 und Servomotor Problem

gogo · December 10, 2023 at 9:50 PM

Hallo zusammen,

Ich habe hier einen Raspberry Pico mit MicroPython v.1.21.0 auf einem Breadboard mit einer LED, TSOP 4838 (Infrarot) mit Fernbedienung und einem Servomotor (ählich sg90) zusammen gefrickelt.

Via Fernbedienung z.B. Taste 1 wird eine Mp3 abgespielt und nach einer sleep Zeit bewegt sich der Servomotor. Läuft alles prima.

Nun folgendes Problem, während der sleep Zeit von 26 Sekunden kann ich mit der Fernbedienung nichts Anderes wählen. Ist mir schon klar, dass das Script durchläuft und nix zulässt.

Ich hoffe das war soweit verständlich…

Hat jemand eine Idee wie ich das lösen könnte?

Lg gogo

Python

from time import sleep
from machine import Pin, freq, PWM
from ir_rx.print_error import print_error
from ir_rx.nec import NEC_8
from picodfplayer import DFPlayer

# Initialisierung DFPlayer (UART, TX-Pin, RX-Pin, Busy-Pin)

player = DFPlayer(0, 16, 17, 18)

player.setVolume(5) # Lautstärke einstellen: 0 bis 30

led = Pin(15, Pin.OUT)

#Define the IR receiver pin and led pins
pin_ir = Pin(8, Pin.IN)

# GPIO für Steuersignal
servo_pin = 28

# 0 Grad
grad000 = 500000
# 45 Grad
grad045 = 1000000
# 90 Grad
grad090 = 1500000
# 135 Grad
grad135 = 2000000
# 180 Grad
grad180 = 2500000

pwm = PWM(Pin(servo_pin))
pwm.freq(50)


Taste1 = 69

Leiser = 82

Left = 8

Right = 90

Stop = 28

Lauter = 24

OK = 28


def decodeKeyValue(data):

    return data


# User callback

def callback(data, addr, ctrl):

    if data < 0:  # NEC protocol sends repeat codes.

        pass

    else:

        print(data)

        if data == Taste1:

            led.value(1)

            player.playTrack(1,1)
        
            
            sleep(26)
            print('Position: Mitte (90 Grad)')
            pwm.duty_ns(grad045)
            sleep(0.8)

            print('Position: Ganz Links (0 Grad)')
            pwm.duty_ns(grad000)
            sleep(0.8)

            print('Position: Mitte (90 Grad)')
            pwm.duty_ns(grad045)
            sleep(0.8)

            print('Position: Ganz Rechts (180 Grad)')
            pwm.duty_ns(grad180)
            sleep(0.4)

            print('Position: Mitte (90 Grad)')
            pwm.duty_ns(grad090)
            sleep(0.8)
            
            print('Position: Mitte (90 Grad)')
            pwm.duty_ns(grad045)
            sleep(0.8)

            print('Position: Ganz Links (0 Grad)')
            pwm.duty_ns(grad000)
            sleep(0.8)

            print('Position: Mitte (90 Grad)')
            pwm.duty_ns(grad045)
            sleep(0.8)

            print('Position: Ganz Rechts (180 Grad)')
            pwm.duty_ns(grad180)
            sleep(0.4)

            print('Position: Mitte (90 Grad)')
            pwm.duty_ns(grad090)
            sleep(0.8)

            pwm.deinit()
            print('Ende')
            
                   
        elif data == OK:

            player.pause()   
             
             
        elif data == Leiser:

            player.decreaseVolume()  
             

        elif data == Taste2:

            led.value(0)

            player.playTrack(1,2)

        elif data == Left:

            execfile("laufschrift.py")

            left()

        elif data == Right:
            
            execfile("spring_point.py")

            right()
            

        elif data == Stop:

            stop()


ir = NEC_8(pin_ir, callback)  # Instantiate receiver

ir.error_function(print_error)  # Show debug information


try:

    while True:

        pass

except KeyboardInterrupt:

    ir.close()

Display More

Bot · Vor 5 Minuten

Raspberry Pico mit MIcroPython, Dfplayer, TSOP 4838 und Servomotor Problem? Schau mal ob du hier fündig wirst!

Dennis89 · December 10, 2023 at 10:02 PM

Hallo,

ich finde das nicht verständlich. Dir ist klar, dass während der Zeit in der das Programm schläft, nichts weiters passiert. Was ist denn dann die eigentliche Frage?

Wenn du für eine gewisse Zeit nur bestimmte Sachen nicht machen willst, dann ist 'sleep' falsch. Du musst die Zeit messen und solange sie nicht deinen gewünschten Wert erreicht hat, lässt du eine weitere Abarbeitung nicht zu bzw. startest du eine weitere Funktion erst, wenn der gewünschte Wert erreicht wurde.

Grüße

Dennis

gogo · December 10, 2023 at 10:16 PM

Hallo Dennis,

schonmal vielen Dank dafür.

Also könnte ich das mit einer If Anweisung lösen, aber habe ich dann nicht das gleiche Problem?

Die eingentliche Frage ist: Wie kann ich es schreiben das die Fernbedienung funktioniert auch wenn der Motor läuft?

Lg gogo

Bot · Vor einem Moment

Schau mal ob du hier fündig wirst:

Franky07 · December 10, 2023 at 10:41 PM

Moinsen

in dem du deine Bewegungschoreographie in eine LIST packst,
Dann einen Timer startest , der diese LIST als Step Punkt für Punkt abarbeitet, denn das Setzen des PWM Wertes ist nur ein einmalige Aktion.

Python

class Bewegung:
    Ablauf = [45, 90 , 45, 0, 90]
    def __init__(self, pin, waits):
        self.pwm = PWM(Pin(pin))
        self.pwm.duty_u16(0)
        self.counter = 0
        self.waits = waits

    def run(self):
        self.timer = Timer(period = self.waits, mode = Timer.PERIODIC,
                           callback = lambda t : self.set_pos())


    def set_pos(self):
        if self.counter < len(self.Ablauf):
            self.pwm.duty_U16(self.Ablauf[counter])
            self.counter += 1
        else:
            self.counter = 0
            self.timer.deinit()

Display More

Wenn du dann deine Bewegungsablauf starten willst, muss du zu eine diese Class initiieren. Mit der Angabe des PWM / Servo Pins, und der Verzögerungszeit in ms.
Mit dem Befehl <name>.run() wird dann der Ablauf gestartet. Aller dieser "waits" Milisekunden, wird der nächste Schritt ausgeführt, bis diese Liste abgearbeitet ist. Dann wird der Counter ge-resetet, und der Timer wieder abgestellt. Inzwischen läuft das Programm in __MAIN__ weiter.

[ Programm nicht getestet ]

gogo · December 11, 2023 at 6:26 PM

Hallo Franky

Danke dafür!

So ich hab das mal ausprobiert und muss zugeben, ja ich hab keine Ahnung davon.

Kannst du mir bitte weiterhelfen. Hier der Code:

Python

from time import sleep
from machine import Pin, freq, PWM, Timer


# GPIO für Steuersignal
servo_pin = 28

# 0 Grad
grad000 = 1638
# 45 Grad
grad045 = 2457
# 90 Grad
grad090 = 4915
# 135 Grad
grad135 = 7372
# 180 Grad
grad180 = 8192

pwm = PWM(Pin(servo_pin))
pwm.freq(50)




class Bewegung:
    Ablauf = [pwm.duty_u16(grad045), sleep(0.8), pwm.duty_u16(grad000), sleep(0.8), pwm.deinit()]
    def __init__(self, pin, waits):
        self.pwm = PWM(Pin(pin))
        self.pwm.duty_u16(26000)
        self.counter = 0
        self.waits = waits

    def run(self):
        self.timer = Timer(period = self.waits, mode = Timer.PERIODIC,
                           callback = lambda t : self.set_pos())


    def set_pos(self):
        if self.counter < len(self.Ablauf):
            self.pwm.duty_u16(self.Ablauf[counter])
            self.counter += 1
        else:
            self.counter = 0
            self.timer.deinit()

Display More

Die Datei heist test.py und in der main rufe ich sie mit "from test import Bewegung" auf.

Der Motor bewegt sich sofort und es kommt leider kein Timer zu stande. Was mache ich falsch???

Besten Dank.

Lg gogo

gogo · December 17, 2023 at 9:46 AM

Danke Franky das du mir geholfen hast.

Hier der fertige Code von Franky.

Python

from time import sleep_ms
from machine import Pin, freq, PWM, Timer
from ir_rx.print_error import print_error
from ir_rx.nec import NEC_8
from picodfplayer import DFPlayer

class Bewegung():
    def __init__(self, pin, bussy = None, middle = 4952):
        self.neutral = middle
        self.pwm = PWM(Pin(pin))
        self.pwm.freq(50)
        self.pwm.duty_u16(self.neutral)
        self.active = False
        self.bussy =(Pin(bussy, Pin.IN, Pin.PULL_UP) if bussy != None else None)
        
    def run(self, table, waits = 0):
        self.ablauf = table
        self.counter = 0
        self.active = True
        if waits > 0:
            timer = Timer(period = waits, mode = Timer.ONE_SHOT,
                          callback = lambda t: self._get_start())
        else:
            self._get_start()
            
    def _get_start(self):
        if self.bussy != None:
            self.bussy.irq(trigger = Pin.IRQ_FALLING,
                           handler = lambda p: self._stopp())
        self._start()
        
    def _start(self):
        if self.counter < len(self.ablauf):
            self.timer = Timer(period = int(self.ablauf[self.counter][1] * 1_000), mode = Timer.ONE_SHOT,
                               callback = lambda t: self._get_pos(self.ablauf[self.counter]))
        else:
            self.counter = 0
            self.pwm.duty_u16(self.neutral)
            
    def _get_pos(self, table):
        if not self.active:
            return 
        self.pwm.duty_u16(table[0])
        self.timer = None
        self.counter += 1
        self._start()

    def _stopp(self):
        self.active = False
        if self.bussy != None:
            self.bussy.irq(handler = None)
        self.set_neutral()

    def set_neutral(self):
        self.active = False
        self.pwm.duty_u16(self.neutral)
        self.counter = 0  

#------------------------------------------------------------
def callback(data, addr, ctrl):
    if data < 0:  # NEC protocol sends repeat codes.
        return
    print(data)
    if data == Taste1:
        led.value(1)
        player.playTrack(1,1)
        sport.run(ablauf, 4_000) #26_000 ist erste verzögerung
                   
    elif data == Stop:
        player.pause()   
                  
    elif data == Leiser:
        player.decreaseVolume()  
             
    elif data == Taste2:
        led.value(0)
        player.playTrack(1,2)
       
    elif data == OK:
        #sport.set_neutral()
        player.reset()
        

# -------------------------------------------------------
def decodeKeyValue(data):
    return data


PWM_Pin = 28
sport = Bewegung(PWM_Pin, bussy = 18 )

# Initialisierung DFPlayer (UART, TX-Pin, RX-Pin, Busy-Pin)

player = DFPlayer(0, 16, 17, 18)
player.setVolume(5) # Lautstärke einstellen: 0 bis 30

led = Pin(15, Pin.OUT)

#Define the IR receiver pin and led pins
pin_ir = Pin(8, Pin.IN)

#Fernbedienung Codes
Taste1 = 69
Taste2 = 70
Leiser = 82
Left = 8
Right = 90
Stop = 22
Lauter = 24
OK = 28


ablauf = [(1962, 0.6),
           (4852, 0.8),
           (2618, 1.2),
           (6954, 0.4),
           (4260, 0.5),
           (1962, 0.7),
           (4852, 1.1),
           (2618, 0.4),
           (6954, 0.9)]

ir = NEC_8(pin_ir, callback)  # Instantiate receiver
ir.error_function(print_error)  # Show debug information

try:
    while True:
        sleep_ms(100)

except KeyboardInterrupt:
    ir.close()

Display More

Bot · Vor einem Moment

Schau mal ob du hier fündig wirst:

Raspberry Pico mit MIcroPython, Dfplayer, TSOP 4838 und Servomotor Problem

Participate now!

Tags