Luft Temperaturregelstrecke

[Murphy.]

Moin, ich würde gerne in meiner Abschlussarbeit mit Phyton arbeiten, habe aber bis jetzt null Erfahrung damit.

Die Aufgabenstellung ist, die Reperatur eines Versuchsaufbaus einer Luft-Temperaturregelstrecke, da die Elektronik defekt ist. Die Reperatur soll mit einem Raspberry Pi in Verbindung mit einem Analog-/Digitalwandler (am liebsten MCP3008) erfolgen. Die Regelstrecke umfasst folgende Aktoren: Lüfterdrehzahl, Heizung und Drosselklappe. Die Drosselklappe dient als Störgröße und wird manuell betätigt. Als Sensoren werden zwei Temperaturmessungen, der Sensor der Drosselklappe, eine Druckmessung und eine thermische Luftmassenmessung eingesetzt. Zunächst sollen die analogen Signale (0-10V bzw 4...20mA) der Aktoren und Sensoren erfasst werden und auf dem Touchscreen des Pi's dargestellt werden. Eventuell folgt noch eine Regelung bei der ein definierter Massenstrom konstant gehalten werden soll.

Ich habe mich bereits etwas mit der Thematik beschäfftigt und habe jetzt einige Fragen.

Bis jetzt habe ich mit tkinter ein Fenster erstellt in dem die entsprechenden Labels abgebildet werden.

Die wichtigste Frage bezieht sich vor allem auf die Signalverarbeitung in Verbindung mit dem MCP3008. Ich habe mir das skript und die PDF von Erik Bartmann angeguckt und frage micht jetzt ob ich den gesamten Code für jeden Kanal am MCP3008 einzeln in das gesammte Skript einfügen muss bzw Wie kann ich den Kanal wählen um mir den Analogwert im entsprechenden Label anzeigen lassen?

Wie kann ich die Sensoren am besten kalibrieren?

Wie kann ich den Touchscreen ansteueren?


Über eure Unterstützung würde ich mich sehr freuen

Grüße aus Köln

[BlackJack]

@Murphy.: Aufgabe Nummer eins: Hundert mal ”Python” schreiben, damit die Reihenfolge von ”t” und ”h” richtig sitzt.

Das Skript und die PDF von Erik Bartmann? Wer? Wie? Wo? Was?

Irgendwelchen Code mehrfach irgendwo einfügen ist ziemlich sicher falsch. Genau das versucht man als Programmierer ja zu vermeiden, das man gleiche oder fast gleiche Quelltextfragmente per kopieren und einfügen vervielfältigt. Dafür gibt es im einfachsten Fall Schleifen und ansonsten Funktionen und Klassen um Gemeinsamkeiten zu isolieren und nur noch die Unterschiede kodieren zu müssen. Ausserdem kann man den Funktionn und Klassen Namen geben und damit beschreiben was der Code der da drin steckt tut, beziehungsweise für was für ein Objekt er steht. Damit lässt sich Quelltext dann leichter verstehen.

Kanal wählen und Sensor kalibrieren ist jetzt so ohne Wissen um die Hardware und den nötigen Code um sie anzusprechen, schlecht zu beantworten.

Was ist das Problem beim Touchscreen? Wenn Du Tk für die Darstellung verwendest, dann läuft doch ein X und der Touchscreen wird (hoffentlich?) als Maus funktionieren‽ Oder was meinst Du mit „ansteuern”?

[Murphy.]

python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python python

so Aufgabe 1 erledigt

Die PDF heißt: Erik Bartmann - PiMeUp AddOn "Der A/D-Wandler MCP3008" (http://erik-bartmann.de/component/attac ... ad/21.html)
Das Skript heißt: mcp3008 (http://www.erik-bartmann.de/component/a ... ad/19.html). Es soll das Auslesen der Analogwerte aus dem A/D-Wandler ermöglichen.

Meine Frage dazu ist, wie ich die einzelnen Sensoren auf die Kanäle des A/D-Wandlers bekomme und wie ich diese dann mit dem Pi auslese, so das Sie im entsprechendem Label angezeigt werden.

Irgendwelchen Code mehrfach irgendwo einfügen ist ziemlich sicher falsch. Genau das versucht man als Programmierer ja zu vermeiden, das man gleiche oder fast gleiche Quelltextfragmente per kopieren und einfügen vervielfältigt. Dafür gibt es im einfachsten Fall Schleifen und ansonsten Funktionen und Klassen um Gemeinsamkeiten zu isolieren und nur noch die Unterschiede kodieren zu müssen. Ausserdem kann man den Funktionn und Klassen Namen geben und damit beschreiben was der Code der da drin steckt tut, beziehungsweise für was für ein Objekt er steht. Damit lässt sich Quelltext dann leichter verstehen.

ich werde mich bemühen das zu verstehen;)

Meine restlichen Fragen stell ich besser erstmal zurück, da ich den PI und Zubehör erst noch bestellen muss. Außerdem muss ich erst schauen, ob die Sensoren und die zugehörigen Messumformer noch funktionieren.

Erstmal vielen Dank für die schnelle Antwort

Beste Grüße

[BlackJack]

@Murphy.: Den Skripten merkt man an, das der Autor wohl noch nicht lange in Python programmiert und noch in einer anderen Programmiersprache denkt. Mal ein überflüssiges Semikolon am Zeilenende, unnötige Klammern um Bedingungen bei ``if``, ein ``something not in range(n)``-Test der ineffizient ist was die Laufzeit angeht, und da es Python 2 ist auch noch ineffizient mit dem Speicher umgeht. Magische Zahlen (-1) als Fehlerrückgabewert statt eine Ausnahme auszulösen. Namenschreibweisen die sich nicht an den Style Guide for Python Code halten.

Eine Pause in die Auslesefunktion einzubauen die aber eigentlich die Textausgabe für den Benutzer verzögern soll ist auch schräg.

Bei den Namen fällt auch `actual_value` auf was der Autor im Kommentar als „aktuellen analogen Messwert“ bezeichnet. Das englische „actual“ heisst allerdings gar nicht „aktuell“ sondern „tatsächlich“. Normalerweise würde ich da `current_value` zu sagen, allerdings ist das im Elektronikbereich dann doppeldeutig.

Der Kommentar in folgender Zeile ist auch interessant:

Code: Alles auswählen

    prev_value = actual_value # Aktueller Wert wird alter Wert

Ich dachte erst, „Hey, der Code macht genau das Gegenteil vom Kommentar“, weil der Kommentar nicht wirklich eindeutig formuliert ist. Das kann man in beide Richtungen auffassen.

Letztlich ist der Kommentar, wie auch viele andere völlig überflüssig. Wer bei dieser Zuweisung nicht versteht was da passiert, dem wird auch ein Kommentar nicht helfen.

Ich würde ja eher nach etwas suchen was von mehr Leuten verwendet wird. Das `gpiozero`-Package wird beispielsweise von einem Mitglied der Raspberry Pi-Stiftung (und anderen) entwickelt und hat auch eine Klasse für den MCP3008. Recht praktisch ist dort auch, dass der Analogwert im Bereich von 0 bis 1 ausgegeben wird, egal wieviele Bits der Wandler liefert. So kann man den Wandler leichter tauschen ohne den Code ändern zu müssen, der die Werte verarbeitet.

Die Sensoren musst Du entsprechend an den A/D-Wandler anschliessen und mit irgendeiner der vorhandenen Lösungen dann auslesen. Wo liegt denn das *konkrete* Problem dabei? Probier das doch einfach mal mit so einer Schaltung wie in dem PDF mit einem Potentiometer aus.

Wenn die Hardware noch nicht da ist, weil noch nicht bestellt oder noch irgendwo unterwegs, dann kannst Du schon mal anfangen Python zu lernen. Und zwar inklusive objektorientierter Programmierung, denn ohne wird das schwierig bis unmöglich. Zumindest so schlimm das sich das niemand ernsthaft anschauen möchte und als erster und einziger Verbesserungsvorschlag bei Fragen immer kommen wird: mach das erstmal vernünftig mit Klassen damit man eine Chance hat durchzusteigen.

[Murphy.]

Moin,

ich habe wieder ein paar Fragen...

Ich habe mich dazu entschieden, einen AD-Wandler (MCP3208) und einen DA-Wandler (MCP4922) zu verwenden. Beide können ja SPI, daher würde ich gerne die SPI-Library verwenden.

Meine aktuelle brennenste Frage ist, wie die Aufteilung der Bits auf die Bytes funktioniert. Da ich diese benötige um den AD Wandler auszulesen bzw. den DAC zu steuern. Alles was ich dazu im Netz gefunden habe, hat mir nicht wirklich weitergeholfen.

Beispiel DAC:

Byte 1: 00011111 Byte 2: 11111111

Der Wert der Spannung die eingestellt werden soll versteckt sich hinter den letzten 4 Bits von Byte 1 und den Bits Byte 2.

Wenn ich jetzt eine Spannung vorgeben will muss ich ja beide Bytes beeinflussen. Wie mach ich das am besten?


Danke schonmal








Danke schonmal

[BlackJack]

@Murphy.: Fröhliches bitschieben und bitweise Verknüpfungen. Du hattest da doch ein PDF verlinkt, da wird so etwas gemacht, und ich denke mal auch erklärt.

[Murphy.]

Hi,

ich brauch nochmal kompetente Hilfe. Langsam finde ich mich im Thema ein und starte die ersten Versuche...

Im Moment probiere ich den AD-Wandler aus. Es handelt sich um einen MCP3208 ( http://cdn-reichelt.de/documents/datenb ... 08_MIC.pdf ) mit 12 bit und 8 Kanälen.

Ich versuche einen Wert auf Kanal 0 zu erhalten mit folgendem Skript:

Code: Alles auswählen

import spidev
import time

spi = spidev.SpiDev()
spi.open(0,0)

while True:
         rcv = spi.xfer2 ([6, 0 , 0])
         adcval = ((rcv[1] & 15) <<8) + rcv[2]
         print(adcval)
         time.spleep(1)

Leider erhalte ich immer 0 als Ausgabe ob wohl ich 3,3 V messe...

Sieht jemand auf anhieb den/die Fehler und kanns mir erklären?

[BlackJack]

@Murphy.: Ist der Baustein korrekt angeschlossen? Sind die Bedingungen die in Abschnitt 6.1 beschrieben sind, erfüllt?

[Murphy.]

Hallo,

der A/D-Wandler läuft inzwischen. Jetzt beschäftige ich mich mit dem DAC - MCP4922 ( http://ww1.microchip.com/downloads/en/D ... 22250A.pdf )

Die Verschaltung sieht wie folgt aus:

1 V_DD = 5V
2 NC
3 CS = CE1
4 SCK = SCLK
5 SDI = MOSI
6 NC
7 NC
8 LDAC = GND
9 SHND = 5V
10 V_OUT B
11 V_REF B = 5V
12 AVSS = GND
13 V_REF A = 5V
14 V_OUT A

Code: Alles auswählen

import spidev
import time

spi = spidev.SpiDev()
spi.open (0,1)
spi.xfer2 ([15, 255])

Ich möchte also das der DAC die maximal Spannung ausgibt. Leider bekomme ich garkeine Spannung am Ausgang...

Hat jemand Erfahrung mit dem Baustein oder nen Tipp?

[Murphy.]

Moin,

ich habs geschafft sowohl der ADC sowie der DAC funktionieren. Jetzt gehts an die Programmierung.

Die normale Programmierung bei der nur ein Kanal gelesen wird war kein Problem, jetzt sollen jedoch die Kanäl 0...4 "gleichzeitig" gelesen werden.

Da ich nicht für jeden Sensor alles wiederholen will habe ich angefangen eine Klasse für den Sensor zuschreiben. Leider funktioniert das nicht so wie ich mir das vorstelle.

Um die Klasse betreiben zu können brauche ich zwei Argumente für die Funktion lesen: 1. Bytearray (Wahl des Kanals) 2. eine Variable (t, p, d, m), hinter dieser Variable soll eine Gleichung zur Umrechnung der Inkremente in den entsprechenden Messwert hinterlegt sein.

Code: Alles auswählen

import spidev
import time

# SPI-Instance erzeugen und den Bus oeffen
spi = spidev.SpiDev()

# t = temperatur, d = drossel, p = druck, m = massenstrom 
# Kanal 0 = d
# Kanal 1 = t1
# Kanal 2 = t2
# Kanal 3 = p
# Kanal 4 = m

c0 = bytearray ([6, 0 , 0])         # Kanal1
c1 = bytearray ([6, 1 << 6 , 0])    # Kanal2
c2 = bytearray ([6, 1 << 7 , 0])    # Kanal3
c3 = bytearray ([6, 3 << 6, 0])     # Kanal4
c4 = bytearray ([7, 0 , 0])         # Kanal5
c5 = bytearray ([7, 1 << 6 , 0])    # Kanal6
c6 = bytearray ([6, 1 << 7 , 0])    # Kanal7
c7 = bytearray ([6, 3 << 6 , 0])    # Kanal8

# Liste mit Bytearrays für jeden Kanal zur Übergabe an die Funktion lesen
# Liste mit Gleichungen zur Umrechnung der entsprechenden Messgröße
# z.b. messwert = adcval * steigung [°C/Inkrement]



class sensor():
    def __init__(self):
        self.wert = 0

    def lesen (self):
        spi.open(0,0)
        rcv = spi.xfer2 (c0)
        adcval = ((rcv[1] & 15) << 8) + rcv[2]        
        # Umrechnung nach Sensortyp z.B. GradCelsius, Übergabe der Gleichung mit t, d, p, m
        self.wert = messwert
        spi.close(0,1)




t1 = sensor()
print (t1.wert)

# schleife die alle werte permanent einliest

Wäre schön wenn mir jemand helfen könnte, da die Zeit langsam knapp wird

[Sirius3]

@Murphy: gleichzeitig ist ja wohl bei einem Bauteil nicht möglich. Bleibt also nacheinander, was man einfach mit einer Schleife macht. Da bietet es sich auch an, die Kanalzuordnung nicht in 8 Variablen sondern in einer Liste zu speichern. Deine Klasse ist übrigens keine wirkliche, da sie nur aus einer Methode besteht.

Code: Alles auswählen

import spidev

def read_sensor(spi, channels):
    result = []
    spi.open(0,0)
    for channel in channels:
        rcv = spi.xfer2(((24 + channel) << 14).to_bytes(3, 'big'))
        result.append(int.from_bytes(rcv[1:3], 'big') & 0xfff)
    spi.close(0,1)
    return result

def main()
    # SPI-Instance erzeugen und den Bus oeffen
    spi = spidev.SpiDev()

    # t = temperatur, d = drossel, p = druck, m = massenstrom 
    # Kanal 0 = d
    # Kanal 1 = t1
    # Kanal 2 = t2
    # Kanal 3 = p
    # Kanal 4 = m
    d, t1, t2, p, m = read_sensor(spi, [0, 1, 2, 3, 4])
    print(d, t1, t2, p, m)
    
if __name__ == '__main__':
    main()

[Murphy.]

Hi,

danke für die Hilfe. Das Skript hat mich bereits etwas weiter gebracht. Folgende Zeile verursacht einen Fehler:

Code: Alles auswählen

rcv = spi.xfer2(((24 + channel) << 14).to_bytes(3, 'big'))

Ich denke die Funktion xfer2 kann nur ein Byte array senden, daher bekomme ich eine Fehlermeldung. Leider hab ich die Fehlermeldung gerade nicht zur Hand.

Das Skript das ich jetzt nutze sieht so aus:

Code: Alles auswählen

from spidev import SpiDev


class MCP3208:
    def __init__(self, bus = 0, device = 0):
        self.bus, self.device = bus, device
        self.spi = SpiDev()
        self.open()

    def open(self):
        self.spi.open(self.bus, self.device)
    
    def read(self, channel = 0):
        adc = self.spi.xfer2([1<<2, (8 + channel) << 6, 0])
        data = ((adc[1] & 15) << 8) + adc[2]
        return data
            
    def close(self):
        self.spi.close()

#Liste adc


while True:
    adc = MCP3208()
    value = adc.read( channel = 0 ) # Den auszulesenden Channel kannst du natürlich anpassen
    print(value)

Allerdings bekomme ich nur 1063 Inkremente als Wert, es fehlen also Bits.
Kann mir jemand helfen?

[Murphy.]

Ich habe mich entschieden doch das Skript von Sirius zu verwenden. Allerdings finde ich keine Lösung für die Fehlermeldung.

Skript :

Code: Alles auswählen

import spidev
     
def read_sensor(spi, channels):
      result = []
      spi.open(0,0)
      for channel in channels:
            rcv = spi.xfer2(((24 + channel) << 14).to_bytes(3, 'big'))
            result.append(int.from_bytes(rcv[1:2], 'big') & 0xfff)
      spi.close(0,0)
      return result
     
def main():
      spi = spidev.SpiDev()
     
        # t = temperatur, d = drossel, p = druck, m = massenstrom
        # Kanal 0 = d
        # Kanal 1 = t1
        # Kanal 2 = t2
        # Kanal 3 = p
        # Kanal 4 = m
      d, t1, t2, p, m = read_sensor(spi, [0, 1, 2, 3, 4])
      print(d, t1, t2, p, m)
       
if __name__ == '__main__':
      main()

Fehlermeldung:

Python 2.7.9 (default, Sep 17 2016, 20:26:04)
[GCC 4.9.2] on linux2
Type "copyright", "credits" or "license()" for more information.
>>> ================================ RESTART ================================
>>>

Traceback (most recent call last):
File "/home/pi/asd.py", line 25, in <module>
main()
File "/home/pi/asd.py", line 21, in main
d, t1, t2, p, m = read_sensor(spi, [0, 1, 2, 3, 4])
File "/home/pi/asd.py", line 7, in read_sensor
rcv = spi.xfer2(((24 + channel) << 14).to_bytes(3, 'big'))
AttributeError: 'int' object has no attribute 'to_bytes'
>>>


Wie kann ich die Fehlermeldung lösen?

[BlackJack]

@Murphy.: Die Methode gibt es erst in Python 3.

[Murphy.]

Achso ok das hab ich jetzt in den Eigenschaften der Datei geändert.

Allerdings bekomme ich jetzt keine Fehlermeldung mehr und keine Werte vom Print Befehl

Code: Alles auswählen

import spidev
     
def read_sensor(spi, channels):
      result = []
      spi.open(0,0)
      for channel in channels:
            rcv = spi.xfer2(((24 + channel) << 14).to_bytes(3, 'big'))
            result.append(int.from_bytes(rcv[1:2], 'big') & 0xfff)
      spi.close()
      return result
     
def main():
      spi = spidev.SpiDev()
     
        # t = temperatur, d = drossel, p = druck, m = massenstrom
        # Kanal 0 = d
        # Kanal 1 = t1
        # Kanal 2 = t2
        # Kanal 3 = p
        # Kanal 4 = m
      d, t1, t2, p, m = read_sensor(spi, [0, 1, 2, 3, 4])
      print(d, t1, t2, p, m)
       
if __name__ == '__main__':
      main()

[Murphy.]

Hallo

ich finde den Fehler beim Auslesen des A/D-Wandlers einfach nicht, ich habe das Skript von Sirius etwas angepasst und noch ein anderes Skript ausprobiert. Bei beiden Skripten habe ich das Problem das ich keine Werte angezeigt bekomme sondern nur eine leere Printzeile...

Zu erst die Version von Sirius:

Code: Alles auswählen

import spidev
     
def read_sensor(spi, channels):
      result = []
      spi.open(0,0)
      for channel in channels:
            rcv = spi.xfer2(((24 + channel) << 14).to_bytes(3, 'big'))
            result.append(int.from_bytes(rcv[1:2], 'big') & 0xfff)
      spi.close()
      return result
     
def main():
      spi = spidev.SpiDev()
     
        # t = temperatur, d = drossel, p = druck, m = massenstrom
        # Kanal 0 = d
        # Kanal 1 = t1
        # Kanal 2 = t2
        # Kanal 3 = p
        # Kanal 4 = m
      d, t1, t2, p, m = read_sensor(spi, [0, 1, 2, 3, 4])
      print(d, t1, t2, p, m)
       
if __name__ == '__main__':
      main()

und hier die andere Version:

Code: Alles auswählen

from spidev import SpiDev

class MCP3208:
    def __init__(self, bus = 0, device = 0):
        self.bus, self.device = bus, device
        self.spi = SpiDev()
        self.open()

    def open(self):
        self.spi.open(self.bus, self.device)
    
    def read(self, channel = 0):
        adc = self.spi.xfer2(((24 + channel) << 14).to_bytes(3, 'big'))
        data = int.from_bytes(adc[0:2],'big') & 0xfff
        return data
        self.close()
            
    def close(self):
        self.spi.close()

adc = MCP3208()

while True:
    p = adc.read(channel = 0)
    print (p)

Kann mir jemand erklären was ich falsch mache?

[Murphy.]

Moin,

weiter geht's...

channel = 0

Der Ausdruck

Code: Alles auswählen

a = ((24 + channel) << 14).to_bytes(3, 'big')

ergibt

Code: Alles auswählen

b'\x06\x00\x00'

Ich benötige für die Funktion spi.xfer2() allerdings folgenden Ausdruck [6, 0, 0]

Die Problematik die ich sehe ist, dass die Bits für die Auswahl des Kanals auf die ersten beiden Bytes aufgeteilt wird.

Gibt es noch andere Möglichkeiten das Problem zu lösen?

[Sirius3]

@Murphy: b'\x06\x00\x00' ist eine Folge der 3 Bytes 6, 0 und 0. Das ist für die Funktion xfer2 das selbe wie [6,0,0]. Falls Du das nicht glaubst, kannst Du ja das eine statt dem anderen Schreiben und wirst keinen Unterschied feststellen.

[Murphy.]

@Murphy: b'\x06\x00\x00' ist eine Folge der 3 Bytes 6, 0 und 0. Das ist für die Funktion xfer2 das selbe wie [6,0,0]. Falls Du das nicht glaubst, kannst Du ja das eine statt dem anderen Schreiben und wirst keinen Unterschied feststellen.

Hey Sirius, vielen Dank für die Antwort und das Skript. Ich würde es gerne glauben, da ich diese Lösung schöner finde, aber leider klappts bei mir nicht. Wenn ich b'\x06\x00\x00' schreibe bekomme ich eine leer Printzeile und wenn ich [6,0,0] wird der entsprechende Kanal ausgelesen.

Hab mich jetzt mit nem Zwischenschritt zur Lösung gemogelt, ist zwar nicht schön aber funktioniert erstmal.

Code: Alles auswählen

import spidev

def read_sensor(spi, channels):
      result = []
      spi.open(0,0)
      for channel in channels:
            a = ((24 + channel) << 14)
            rcv = spi.xfer2([a >> 16, (a & 65280) >> 8, a & 255])
            result.append(((rcv[1] & 15) << 8) + rcv[2])
      spi.close()
      return result
     
def main():
      spi = spidev.SpiDev() 
      d, t1, t2, p, m = read_sensor(spi, [0, 1, 2, 3, 4])
      print(d, t1, t2, p, m)
     

       
if __name__ == '__main__':
      main()

Wie kann ich den Code in einer Codebox anzeigen? Das scrollen nervt ziemlich