Ausgänge direkt am GPIO Steuern

[Heiner]

Die ganz einfache Lösung mit der PWM-Ausgabe an einem GPIO funktioniert leider nicht:
Habe einmal mit meinem Raspi einen PWM-Script laufen lassen, und dabei feststellen müssen,
dass dieser offenbar ein PWM-Signal mit 20kHz überhaupt nicht generieren kann. Selbst wenn ich 30kHz eingegeben hatte,
hat er nicht mehr als ca. 7kHz geschafft. Und das auch noch total unregelmäßig, also Frequenz-Moduliert.
Das macht aber nichts.
Da machen wir es so ähnlich, wie Du hier ganz am Anfang vor hattest, mit 3 Bit = 7 Stufen.
Ich muss dann eben noch einen 3 bit zu PWM Wandler hardwaremäßig dazubauen.
Bin gerade dabei, sowas aufzubauen und dann zu testen...

[Kelomat]

Der raspi hat einen Hardware PWM Ausgang... Hast du den genommen? Bei mir war es der GPIO2 glaub ich... Müsste mal genau nachsehen.
Da sollte es besser Funktionieren.

[Heiner]

Danke für den Hinweis; hatte ich aber schon bedacht.

PWM (pulse-width modulation) GPIOs am Raspi:
• Software PWM available on all pins
• Hardware PWM available on GPIO12, GPIO13, GPIO18, GPIO19

... ist aber bei allen GPIOs das gleiche...

[Heiner]

Wenn Du lust hast, kannst Du es ja auch mal selbst ausprobieren:

# https://www.elektronik-labor.de/Raspberry/RpiGPIO5.html
# Tk_GPIO13_PWM.py Port 13 PWM-Ausgabe mit Schieberegler-
# Modifiziert by Heiner

from Tkinter import * # oder: tkinter
import RPi.GPIO as GPIO
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM) # Broadcom
GPIO.setup(13, GPIO.OUT) # Port 13 Ausgang
p = GPIO.PWM(13, 20000) # Port 13 PWM 500 Hz in 20kHz geändert
p.start(0) # 0%

global d
d=0
global du
du=0

def anzeige(lb):
global d
lb.config(text="U = " + str(d) + " mV")
lb.after(100, anzeige, lb)

def pwm_aus(sc):
global d
global du
pwm=0.0
d = sc.get()
d=d+du
if d>3300:
d=3300
if d<0:
d=0
sc.set(d)
pwm = d
pwm=pwm/33.0
p.ChangeDutyCycle(pwm)
sc.after(500, pwm_aus, sc)

def hoch():
global du
du=100
def runter():
global du
du=-100
def stop():
global du
du=0

def on_closing():
GPIO.cleanup()
root.destroy()


root = Tk()
root.title("PWM")
root.font=('Helvetica', 20, 'normal')
lb = Label(root, font = root.font)
lb.pack()
sc = Scale(root, from_=3300, to=0, length=300,tickinterval=1000, orient=VERTICAL) #HORIZONTAL)
sc.set(0)
sc.pack()
Button(root, text="+100 mV/s", width=30,command=hoch).pack()
Button(root, text='-100 mV/s',width=30, command=runter).pack()
Button(root, text='Stop',width=30, command=stop).pack()


anzeige(lb)
pwm_aus(sc)
root.protocol("WM_DELETE_WINDOW", on_closing)
root.mainloop()

[Heiner]

Hallo Kelomat,
ich habe eine Weihnachtsüberraschung:

1. Der Raspi kann doch ganz leicht ein PWM mit 20kHz generieren.
Hier nützt es nicht einen Hardware-PWM-Pin mit Software PWM zu programmieren,
man muss eben auch einen Hardware-PWM-Daemon starten:
Siehe https://www.elektronik-kompendium.de/si ... 202121.htm

Hier mein Test-Programm mit GUI:

Code: Alles auswählen

# Achtung!
# Vor dem Ausfuehren muss im Terminal 'sudo pigpiod' ausgefuehrt werden!
# Oder besser gleich in Systemstart eintragen: 'sudo systemctl enable pigpiod' 
#                                                            danach neu booten
from Tkinter import *
import pigpio
import time
GPIO = pigpio.pi()
PORT = 13
fqz = 20000      # Frequenz 20kHz
pwm = 0          # Duty Cycle 0...1000000 (entspricht 0...100%)

GPIO.hardware_PWM(PORT, fqz, pwm) # Start the signal generation

global d
d=0
global du
du=0

def anzeige(lb):
  global d
  lb.config(text="PWM " + str(d) + " %") 
  lb.after(100, anzeige, lb)

def pwm_aus(sc):
  global d
  global du
  pwm=0.0
  d = sc.get()
  d=d+du
  if d>100:
     d=100
  if d<0:
    d=0 
  sc.set(d)
  pwm = d*10000
  GPIO.hardware_PWM(PORT, fqz, pwm)
  sc.after(500, pwm_aus, sc)

def hoch():
  global du
  du=5
def runter():
  global du
  du=-5
def stop():
  global du
  du=0
 
def on_closing():
    root.destroy()
               
  
root = Tk()
root.title("20kHz Hardware-PWM @GPIO13")
root.font=('Helvetica', 24, 'normal')
Label(root, text=" ", font = root.font).pack()
lb = Label(root, font = root.font)
lb.pack()
#Label(root, text="------------------", font = root.font).pack()
sc = Scale(root, from_=0, to=100, length=500, tickinterval=20, orient=HORIZONTAL) 
sc.set(0)
sc.pack()
Button(root, text="hochregeln", width=20,command=hoch).pack()
Button(root, text="'runterregeln",width=20, command=runter).pack()
Button(root, text='Stop',width=20, command=stop).pack()

anzeige(lb)
pwm_aus(sc)
root.protocol("WM_DELETE_WINDOW", on_closing)
root.mainloop()

Für unser Projekt reicht:

Code: Alles auswählen

# Achtung! Damit der pigpiod daemon immer aktiv ist - 
# in Systemstart eintragen: 'sudo systemctl enable pigpiod' 

import pigpio
import time

PIN = pigpio.pi()
PORT = 13
fqz = 20000        # signal frequency = 20kHz
pwm = 500000       # Duty Cycle 0...1000000 (500000 = 50%)
d = 0

pwm = d*10000

PIN.hardware_PWM(PORT, fqz, pwm) # start signal generation

Nun müssen wir nur noch die Variable 'd' (0...100%) von der Solaranzeige intelligent aufbereitet übergeben...
(evtl. als 'global d' ?)

2. Habe inzwischen auch eine PWM-Hochleistungs-Endstufe gebaut.
Mit der kann man 2kW problemlos proportional regeln.

Eingang ist ein Opto(Photo)-Koppler mit Gate-Treiber, Typ: FOD3182
Der kann direkt über einen Vorwiderstand von einer Raspi-GPIO angesteuert werden.

[Kelomat]

Super lösung!

Ich dachte mir ja das es funktionieren muss... Ich hab es damals mit NodeRed getestet und es hat ja auch funktioniert.

lg

[reinernippes]

'tschuldigung, wenn ich einfach so dazwischen frage:

Könnte man den Heizstab auch mit einem KEMO M028N + M150 (+ Arduino) steuern?

https://www.kemo-electronic.de/de/Licht ... 000-VA.php
https://www.kemo-electronic.de/de/Wandl ... verter.php

Der Kemo M028N kann 4kVA schalten.

Beispiel Aufbau:
https://reprap.org/forum/file.php?251,file=101489

[Heiner]

@reinernippes
... natürlich ginge das auch.
Wie ich aber weiter vorn geschrieben habe:
1. Ist eine Phasenanschnittsregelung (schlagartige Änderung der Last während eine Sinus-Halbwelle) für einen WR,
der den AC Ausgang elektronisch in ein 230V-Sinus formt, sicher ein gewaltiger Stress.
2. Habe ich auch irgendwo gelesen, dass in Deutschland Phasenanschnittsregelungen über 200W verboten sein sollen...

In unserer Variante hier, soll die Last aber mit 20kHz-PWM betrieben werden. Das ist, wenn man noch eine Drossel in den Ausgang schaltet, eine gleichmäßige Last über der ganzen 50Hz-AC-Sinuswelle.

Außerdem denke ich, dass Deine Kemo-Module auch viel teurer sind als dieses DIY Projekt.
Seltsamerweise gibt's kein Shop und keine Preise hinter Deinen Links.

Und beim "Beispiel Aufbau:" kommt:
Permission denied: links to files in the forum are only allowed from this web site.

[reinernippes]

Auf den Kemos sind CE Zeichen und die werden bei Amazon, Reichelt und Conrad verkauft. Das M028N kostet um die 25€.

Wenn die in Deutschland verboten wären oder nur bis 200W betrieben werden dürfen, würde ich einen deutlichen Hinweis und kein CE Zeichen erwarten.

Das M150 setzt das PWM Signal für den Poti Eingang des M028N und kostet ca. 15€.

Für 40€ ziehe ich ein CE Zeichen dem Selberlöten im 240V Bereich vor.

Das Form mit dem Bild läßt keine direkten Links auf Bilder zu. Der folgende Link sollte gehen.
https://reprap.org/forum/read.php?251,805328
Ansonsten hilft die Google Bilersuche: kemo m028n m150

[Heiner]

Super lösung!
Ich dachte mir ja das es funktionieren muss... Ich hab es damals mit NodeRed getestet und es hat ja auch funktioniert.
lg

Wann kann ich denn nun mit Deiner Hilfe rechnen?
Meine Hardware ist schon eine Weile fertig...