Stromwandler alle 10ms auslesen?

Tim Wendler · Jul 15th 2019

Hallo zusammen,

gerne würde ich die Leistung von einem Motor für zwei Sekunden aufzeichnen. Der Motor steuert ein Ventil an, er läuft ca. 1,8 Sek.

Währen der Motor das Ventil verfährt, möchte ich die Leistung (an allen drei Phasen) alle 10ms mit dieser Spule aufzeichnen: https://www.robotshop.com/de/d…elstromsensor-5a-max.html

Hätte jemand eine Idee, wie ich das mit dieser Geschwindigkeit an einem Raspi realisieren kann?

Ich habe vier von diesen Motoren, es wäre super wenn ich alle vier an einem Raspi auswerten/aufzeichnen könnte.

Vielen Dank für eure Hilfe

Grüße

Tim

Bernd666 · Jul 15th 2019

Moin Tim,

erstmal: Herzlich Willkommen im Forum!

Dir ist bekannt das der TA12-200 einen Spannungswert rausgibt?

Das der RPi von Haus aus nicht analog messen kann?

Das mal als Denkansatz.

Gruss Bernd

Tim Wendler · Jul 15th 2019

Hallo Bernd,

vielen Dank für den Willkommensgruß einen herzlichen Gruß zurück.

ja, die zwei Punkte sind mir bekannt. Die Kunst ist nun über einen ADC die Werte in den Raspi zu bringen.

Allerdings bin ich total ahnungslos, wie ich 12 Analogwerte alle 10ms in den Raspi bekomme.

Grüße

Tim

Bernd666 · Jul 15th 2019

Moin Tim,

Ja, das ist hier die Frage.

In welcher Sprache willst du programmieren?

Sollen die Werte erstmal nur gespeichert und später berechnet werden?

Warum testet du das Ganze nicht mit einem Messfühler. Dann hast du schon mal Zeiten und Lösungen.

Dann kann man sehen, ob es überhaupt möglich ist das Ganze mit einem RPi zu realisieren.

Immerhin willst du ca. 3000 Werte in ca. 2 Sekunden erfassen.

Gruss Bernd

Thotaa · Jul 15th 2019

Hallo,

habe so ein ähnliches Vorhaben, einlesen eines Zählerstandes, mit einem zeitgesteuerten Thread gelöst.

Nur sind es da ca. 500ms, für den Raspi gut ausreichend, ob so was bei 10ms noch geht müsste man probieren.

Code

#######################################################################
#
# Internetradio für Raspi Zero zum einbauen in Röhrenradios
# Mit pHAT DAC Soudkarte
# Selbstgebauter Auswerter des AM Drehkos
#
#######################################################################
#
# Zuerst mal die intergrierten Programme
# --------------------------------------
#
import threading 
import os
import time
import RPi.GPIO as IO # GPIO für Python laden
#
#######################################################################
#
# Ab hier stehen alle Board-Setups die nötig sind
# -----------------------------------------------
# Pinbelegung für Internetradio, mit pHAT DAC Soundkarte
#  1: 3,3V
#  2: 5V
#  3: GPIO2  - frei (I2C Data)
#  4: 5V
#  5: GPIO3  - frei (I2C Clock)
#  6: GRND
#  7: GPIO4  - frei
#  8: GPIO14 - frei (TXD0)
#  9: GRND
# 10: GPIO15 - frei (RXD0)
# 11: GPIO17 - frei
# 12: GPIO18 - reserviert für pHAT DAC+
# 13: GPIO27 - frei
# 14: GRND
# 15: GPIO22 - frei
# 16: GPIO23 - frei
# 17: 3,3V
# 18: GPIO24 - Eingang Break um den Pythonprozess stoppen zu können
# 19: GPIO10 - frei (SPI MOSI)
# 20: GRND
# 21: GPIO9  - frei (SPI MISO)
# 22: GPIO25 - Ausgang Zähler rücksetzen/Daten auslesen
# 23: GPIO11 - frei (SPI CLK)
# 24: GPIO8  - frei (SPI CE0)
# 25: GRND
# 26: GPIO7  - frei (SPI CE1)
# 27: ID_SD  - reserviert für System
# 28: ID_SC  - reserviert für System
# 29: GPIO5  - Binäreingang 2^0 (1)
# 30: GRND
# 31: GPIO6  - Binäreingang 2^1 (2)
# 32: GPIO12 - Binäreingang 2^2 (4)
# 33: GPIO13 - Binäreingang 2^3 (8)
# 34: GRND
# 35: GPIO19 - reserviert für pHAT DAC+
# 36: GPIO16 - Binäreingang 2^4 (16)
# 37: GPIO26 - Binäreingang 2^5 (32)
# 38: GPIO20 - Binäreingang 2^6 (64)
# 39: GRND
# 40: GPIO21 - reserviert für pHAT DAC+
#
#######################################################################################
#
# Setup Ein- und Ausgänge
# -----------------------
#
IO.setwarnings(False) # Fehlermeldungen für GPIO unterdrücken
IO.setmode(IO.BOARD) # Pinbelegung auf Board setzen ( 1 - 40 Pinnummer gilt)
IO.setup(22, IO.OUT) # Pin 29 (GPIO25) wird zum dig. Ausgang - Zähler rücksetzten/Wandler auslesen
IO.setup(18, IO.IN) # Pin 18 (GPIO24)  wird zum dig. Eingang - Programm unterbrechen
IO.setup(29, IO.IN) # Pin 29 (GPIO5)  wird zum dig. Eingang - Binär  1 für Sendervorwahl
IO.setup(31, IO.IN) # Pin 31 (GPIO6)  wird zum dig. Eingang - Binär  2 für Sendervorwahl
IO.setup(32, IO.IN) # Pin 32 (GPIO12) wird zum dig. Eingang - Binär  4 für Sendervorwahl
IO.setup(33, IO.IN) # Pin 33 (GPIO13) wird zum dig. Eingang - Binär  8 für Sendervorwahl
IO.setup(36, IO.IN) # Pin 36 (GPIO16) wird zum dig. Eingang - Binär 16 für Sendervorwahl
IO.setup(37, IO.IN) # Pin 37 (GPIO26) wird zum dig. Eingang - Binär 32 für Sendervorwahl
IO.setup(38, IO.IN) # Pin 38 (GPIO20) wird zum dig. Eingang - Binär 64 für Sendervorwahl
#
#######################################################################################
#
# Ab hier stehen ein paar Parameter die nötig sind mit den Startwerten
# --------------------------------------------------------------------
#
do_break = 0
statold = 1000 # damit im ersten Durchgang die Senderauswahl anspringt
IO.output(22,1) # Zähler reset bis alles bereit ist
#  ++++++++++++++++++++++++++++++++++++++++++++++++
##################################################################
# 500ms Zyklus einlesen Zählerstand
#
def Zaehler_einlesen():
    global statold
    global do_break
    num = 0
    if IO.input(29) == 1:
        num = 1
    if IO.input(31) == 1:
        num = num + 2
    if IO.input(32) == 1:
        num = num + 4
    if IO.input(33) == 1:
        num = num + 8
    if IO.input(36) == 1:
        num = num + 16
    if IO.input(37) == 1:
        num = num + 32
    if IO.input(38) == 1:
        num = num + 64
    IO.output(22, 1)
    send = [7,7,8,10,13,18,24,34,46,62,79,103,128]
    for x in range (1, 13, 1):
        if num <= send[x]:
            stat = x
            break        
    if stat != statold:
        bez_sender = Senderbez(stat)
        os.system("mpc play " + str(stat))
        print (bez_sender) # muss für dei Laufversion auskommentiert werden
        print (str(stat) + "  " + str(statold)) # muss für dei Laufversion auskommentiert werden
        statold = stat
    time.sleep(0.05)
    if IO.input(18) == 0:
        timer = threading.Timer(0.48, Zaehler_einlesen)
        timer.start()
        IO.output(22, 0)
    else:
        do_break = 1

###################################################################
#
# Subs für Senderumschaltung
# --------------------------
# Senderbezeichnung aus der Datei holen
#
def Senderbez(numbez):
    str_num = "bez"+(str(numbez))
    bez = open ("/home/pi/Radio/"+str_num+".txt", "r")
    str_bez = bez.read()
    bez.close
    return str_bez
#
# Senderurl aus der Datei holen
#
def Senderurl(numurl):
    str_num = "url"+(str(numurl))
    url = open ("/home/pi/Radio/"+str_num+".txt", "r")
    str_url = url.read()
    url.close
    return str_url
#
####################################################################
#
# Shutdown wenn Resettaster nach 2 Sec immer  noch gerückt
def Shutdown():
    if IO.input(18) == 1:
        os.system("shutdown -h now")
        
#
########################################################################
#
# Hauptschleife damit das ständig läuft
#
#
os.system("mpc clear")  # beim ertsen Durchlauf den Player vorbereiten
for x in range(1, 13):  # und dann die 12 URLs in die Playlist laden
    url_sender = Senderurl(x)
    os.system("mpc add "+url_sender)        
timer = threading.Timer(0.48, Zaehler_einlesen) # den Einlesezyklus das erste mal starten
timer.start()
IO.output(22, 0)
    

while 1:    
    if do_break == 1:
        os.system("mpc clear")
        timer = threading.Timer(2, Shutdown) 
        timer.start()
        break
    time.sleep(1) # Langeweile

#+++++++++++++++++++++++++++++++++++++
# Thomas Häußler
# Giengen

Display More

Tags