Programm für Rapsberry PI Pico mit RP2040

[Hans-Joachim M. (mausbaer)]

Hallo
ich benötige ein Programm für einen Rapsberry PI Pico mit RP 2040. Das 
Programm sollte, wenn mit einem Taster ein Eingang angesteuert wird, 
einen Ausgang 1 mal betätigen. Beim zweiten Takt 2 mal, beim 3. 3 mal 
usw. bis zum 8. Takt 8 mal, dann wieder von vorne, d.h. beim 9. Takt 
wieder 1 mal. Da ich leider vom Programmieren so gut wie keine Ahnung 
habe, wäre ich für Hilfe sehr dankbar.

[Hans-Joachim M. (mausbaer)]

Zum Programmieren benutze ich Thonny.

[Mario M. (thelonging)]

Wie sollen die Zeiten von Impuls und Pause am Ausgang sein? Was soll 
passieren, wenn während der Pulsausgabe die Taste erneut gedrückt wird?

[Falk B. (falk)]

Hans-Joachim M. schrieb:
> ich benötige ein Programm für einen Rapsberry PI Pico mit RP 2040. Das
> Programm sollte, wenn mit einem Taster ein Eingang angesteuert wird,
> einen Ausgang 1 mal betätigen. Beim zweiten Takt 2 mal, beim 3. 3 mal
> usw. bis zum 8. Takt 8 mal, dann wieder von vorne, d.h. beim 9. Takt
> wieder 1 mal.

Warum willst du dafür den RP2040 benutzen? Das geht zwar, ist aber 
maximal überdimensioniert. So wie wenn man mit einem 40t LKW zum 
Einkaufen fährt.

> Da ich leider vom Programmieren so gut wie keine Ahnung
> habe, wäre ich für Hilfe sehr dankbar.

Wie lang sollen die Einzelpulse sein? Wie lang die Pausen dazwischen?

[Andreas B. (bitverdreher)]

Dazu reicht ein ATtiny 4

[Falk B. (falk)]

An welchen Pins hängt dein Taster und wo sollen die Pulse rauskommen?

[Sebastian R. (sebastian_r569)]

Ich bin zwar kein Freund von der stromfressenden Zufallsgeneratoren, 
aber das würde ChatGPT sicherlich binnen weniger Sekunden 
zusammenhalluzinieren können...

[Mario M. (thelonging)]

Voila:

from machine import Pin
import time

# Pins definieren
input_pin = Pin(14, Pin.IN, Pin.PULL_DOWN)
output_pin = Pin(15, Pin.OUT)

# Konfiguration
pulse_count = 1
DEBOUNCE_MS = 50  # Zeit zum Entprellen in Millisekunden

def send_pulses(n):
    """Erzeugt n Pulse am Ausgang (100ms an, 100ms aus)."""
    for _ in range(n):
        output_pin.value(1)
        time.sleep_ms(100)
        output_pin.value(0)
        time.sleep_ms(100)

print("Programm läuft (Polling-Mode)...")

while True:
    # 1. Schritt: Prüfen, ob der Eingang auf HIGH geht
    if input_pin.value() == 1:
        # Software-Entprellung: Kurz warten und nochmal prüfen
        time.sleep_ms(DEBOUNCE_MS)
        
        if input_pin.value() == 1:
            # Gültiger Impuls erkannt!
            print(f"Impuls erkannt! Sende {pulse_count} Pulse...")
            send_pulses(pulse_count)
            
            # Zähler erhöhen und bei 9 zurücksetzen
            pulse_count += 1
            if pulse_count > 8:
                pulse_count = 1
            
            # Warten, bis der Eingang wieder LOW ist (Edge-Detection Ersatz)
            # Verhindert, dass ein langer Druck als mehrere Impulse zählt
            while input_pin.value() == 1:
                time.sleep_ms(10)
    
    # Kurze Pause für die CPU-Entlastung
    time.sleep_ms(10)

[Norbert (der_norbert)]

Hans-Joachim M. schrieb:
> Hallo
> ich benötige ein Programm für einen Rapsberry PI Pico mit RP 2040. Das
> Programm sollte, wenn mit einem Taster ein Eingang angesteuert wird,
> einen Ausgang 1 mal betätigen. Beim zweiten Takt 2 mal, beim 3. 3 mal
> usw. bis zum 8. Takt 8 mal, dann wieder von vorne, d.h. beim 9. Takt
> wieder 1 mal. Da ich leider vom Programmieren so gut wie keine Ahnung
> habe, wäre ich für Hilfe sehr dankbar.

Versuch das hier mal:

#!/python
# vim: fileencoding=utf-8: ts=4: sw=4: expandtab:

from machine import Pin,Timer
from time import sleep_ms

class Button:

    def __timcb(self, tim):
        if self.b():
            self.count = max(0, self.count - 1)     # Entprellung
            if self.count == 0:                     #
                self.state = False
        else:
            self.count = min(self.count + 1, 5)     # Entprellung
            if self.count == 5:                     #
                if not self.state:                  # Eingabe erkannt
                    self.state = not self.state
                    self.events.append(1)           # In die Liste aufnehmen

    def __init__(self, gpio, ramp=10):
        self.b = Pin(gpio, Pin.IN, Pin.PULL_UP)
        sleep_ms(50)
        self.state = False
        self.count = 0
        self.events = []
        self.rampn = ramp
        self.tim = Timer(mode=Timer.PERIODIC, freq=1000, callback=self.__timcb)

    @property
    def event(self):
        if len(self.events):
            self.events.pop(0)
            return True
        return False


ramp = 5                            # Entprellung in Millisekunden
led = Pin(25, Pin.OUT)              # Ausgabe Pin
button = Button(24, ramp)           # Button gegen Ground/Masse
led.off()
outseq = 0
while True:
    if button.event:                # Liste abfragen
        for _ in range(outseq+1):
            led.on()
            sleep_ms(200)           # Ein-Dauer
            led.off()
            sleep_ms(200)           # Aus-Dauer
        sleep_ms(500)               # Pause zwischen den Sequenzen
        outseq = (outseq + 1) % 8
    else:
        sleep_ms(50)

[Hans-Joachim M. (mausbaer)]

Hallo nochmal,
@ Mario M. (thelonging) - das Programm funktioniert super. Jetzt sollte 
nur noch ein MP3 Signal mit dem Ausgangssignal verbunden werden, welches 
auf dem Rapsberry gespeichert werden sollte und mit Hilfe eines MAX 
98375 A an einem Lautsprecher wiedergegeben. Hat hierfür auch jemand 
eine Idee?

[Mario M. (thelonging)]

Entweder einen DFPlayer mini anschließen oder wenn die Qualität nicht so 
wichtig ist, mit AudioMP3 im Hintergrund als PWM ausgeben lassen. Die 
PWM muss man dann noch mit einem Tiefpass glätten, damit es keine 
Interferenzen mit der Class-D-Endstufe gibt. Die KI spuckt folgendes 
Beispiel aus:

import utime
import _thread
from audiomp3 import MP3Player
from audiopwm import AudioPWM

# Initialize PWM audio output on a pin (e.g., GPIO 0)
audio = AudioPWM(0)

# Function to play MP3 file
def play_mp3(file_path):
    player = MP3Player(audio, file_path)
    player.play()
    # Keep playing until the file ends
    while player.is_playing():
        utime.sleep(0.1)

# Run in a background thread
def background_play():
    play_mp3('yourfile.mp3')  # replace with your MP3 filename

# Start playback in a background thread
_thread.start_new_thread(background_play, ())

# Main program continues here
while True:
    print("Playing in background...")
    utime.sleep(5)

[Daniel D. (Firma: Robotic Engineer) (daniel_dsouza)]

This can be done with a simple counter that increases on every button 
press and resets after 8. Each time the button is pressed, the output is 
toggled as many times as the current counter value.

Here is a very basic MicroPython example for the Raspberry Pi Pico that 
should be easy to understand:

#define BUTTON_PIN 14
#define OUTPUT_PIN 15

int count = 0;
int lastButtonState = LOW;

void setup() {
pinMode(BUTTON_PIN, INPUT_PULLDOWN);
pinMode(OUTPUT_PIN, OUTPUT);
}

void loop() {
int buttonState = digitalRead(BUTTON_PIN);

// Detect rising edge (button press)
if (buttonState == HIGH && lastButtonState == LOW) {
count++;

if (count > 8) {
  count = 1;
}

// Activate output "count" times
for (int i = 0; i < count; i++) {
  digitalWrite(OUTPUT_PIN, HIGH);
  delay(200);
  digitalWrite(OUTPUT_PIN, LOW);
  delay(200);
}


}

lastButtonState = buttonState;
delay(50); // simple debounce
}

[Loco M. (loco)]

Daniel D. schrieb:
> Here is a very basic MicroPython example for the Raspberry Pi Pico that
> should be easy to understand:
>
> [c]
> #define BUTTON_PIN 14
> #define OUTPUT_PIN 15
>
> int count = 0;
> int lastButtonState = LOW;
>
> void setup() {
> pinMode(BUTTON_PIN, INPUT_PULLDOWN);
> pinMode(OUTPUT_PIN, OUTPUT);
> }

Oh oh, das ist also ein MicroPython Programm für den Pico? Du solltest 
deine KI neu kalibrieren, wenn es schon für NI nicht reicht.

[Rene K. (xdraconix)]

Das schlimme ist, das Leute dann diese Rotz hier reinhauen ohne selbst 
mal drüber geschaut zu haben.

[Falk B. (falk)]

Rene K. schrieb:
> Das schlimme ist, das Leute dann diese Rotz hier reinhauen ohne selbst
> mal drüber geschaut zu haben.

Scheinbar nehmen jetzt auch KI-Agenten am Forum teil. Das wird lustig 
;-)