Temperaturkompensation Spannungsdrift mit Software (RPI3, ADS1115DGST, MP3V5050DP)

PYTHON SCRIPT::::

#!/usr/bin/python

import time

# Import the ADS1x15 module.

import Adafruit_ADS1x15

#aus der Beispielconfiguration von Pypi

import logging

import fhem

# import time module

import time

#logging.basicConfig(logging.DEBUG)

logging.basicConfig()

# Connect via default protocol telnet, default port 7072:

fh = fhem.Fhem('pegelrpi.fritz.box', port=7072, use_ssl=False, password='CndoOS39#')

fh.connect()

# Note you can change the I2C address from its default (0x48), and/or the I2C

# bus by passing in these optional parameters:

#adc = Adafruit_ADS1x15.ADS1015(address=0x49, busnum=1)

  # Create an ADS1115 ADC (16-bit) instance.

adc = Adafruit_ADS1x15.ADS1115()

  # Or create an ADS1015 ADC (12-bit) instance.

#adc = Adafruit_ADS1x15.ADS1015()

# Choose a gain of 1 for reading voltages from 0 to 4.09V.

# Or pick a different gain to change the range of voltages that are read:

#  - 2/3 = +/-6.144V

#  -   1 = +/-4.096V

#  -   2 = +/-2.048V

#  -   4 = +/-1.024V

#  -   8 = +/-0.512V

#  -  16 = +/-0.256V

# See table 3 in the ADS1015/ADS1115 datasheet for more info on gain.

GAIN = 1

#Hier werden die Variablendefintion

SizeMeasBuffer = 20                                    #Defniert die Groesse des Buffers, ueber die gemittelt werden soll                      

AN0_RAW_Array = [0]*SizeMeasBuffer                     #Array, das die Anzahl von SizeMeasBuffer an alten gemessenen Werten des AN0 AD - Kanals speichert

AN1_RAW_Array = [0]*SizeMeasBuffer                     #Array, das die Anzahl von SizeMeasBuffer an alten gemessenen Werten des AN1 AD - Kanals speichert

AN0_RAW_sum = 0                                        #Summe aller in AN0_RAW_Array gespeicherten AD - Messwerte

AN1_RAW_sum = 0                                        #Summe aller in AN1_RAW_Array gespeicherten AD - Messwerte

AN0_RAW_avg = 0                                        #Quotient aus der Summe von AN0_RAW_Array und SizeMeasBuffer --> Mittelwert des Arrays

AN0_CON_avg = 0                                        #AN0_RAW_avg auf Pegel umgerechnet

AN1_RAW_avg = 0                                        #Quotient aus der Summe von AN0_RAW_Array und SizeMeasBuffer --> Mittelwert des Arrays

AN1_CON_avg = 0                                        #AN1_RAW_avg auf Referenzspannung umgerechnet

AN0_RAW_act = 0                                        #Momentanwert des AD - Kanals mit der Geradengleichung umgerechnet

AN1_RAW_act = 0                                        #Momentanwert des AD - Kanals mit der Geradengleichung umgerechnet

AN0_CON_act = 0                                        #Momentanwert des AD - Kanals mit der Geradengleichung umgerechnet

AN1_CON_act = 0                                        #Momentanwert des AD - Kanals mit der Geradengleichung umgerechnet

TempDriftRaw = 0                                       #DifferenAD - Wert, wenn der Festspannungsregler weglaeuft zur Kompensation des Spannungsdrifts am Spannungsausgang des Sensors

Time_Sleep = 1                                         #Zeit in Sekunden, wie lange die While Schleife wartet, um den naechsten Wert zu capturen

Time_SleepSlow = 60                                    #Zeit in Sekunden, wie lange die While Schleife im Slow wartet, um den naechsten Wert zu capturen

Time_SleepFast = 1                                     #Zeit in Sekunden, wie lange die While Schleife im Fast wartet, um den naechsten Wert zu capturen

Time_SleepHysSlFs = 10                                 #Schwellwert in AD - Rohwert, ab dem von slow auf fast umgestellt wird

Time_SleepHysFsSl = 3                                  #Schwellwert in AD - Rohwert, ab dem von fast auf slow umgestellt wird

Time_SleepCycleLock = 100                              #Wenn eine Umschaltung erfolgt ist, muss eine kann eine erneute umschaltung erst nach "Lock" Zyklen erfolgen

Time_SleepCycleLockFor = 0                             #Momentanwert in Sekunden der Zyklenumschaltsperre

AN0_RAW_Dif = 0                                        #Unterschied zwischen Mittelwert und aktuellen Messwert von AD - Kanal AN0

AN1_RAW_Dif = 0                                        #Unterschied zwischen Mittelwert und aktuellen Messwert von AD - Kanal AN0

AN0_RAW_sum = 0                                        #Summe aller in AN0_RAW_Array gespeicherten Werte

AN1_RAW_sum = 0                                        #Summe aller in AN1_RAW_Array gespeicherten Werte

Voffset_constant = 0.1416                              #Offsetspannung, die der Sensor ohne Eingangsdruck, d.h. ohne Pegel misst

LinEq_quotient = 0                                     #Quotient aus Offsetspannung des Sensors und Faktor aus der linearen Gleichung Sensorspannung als Funktion des Wasserpegels. Vsens=0.0046*Pegel+Offestspannung y=ax+b entsp. b

LinEq_Fac = 216.35                                     #Faktor, der mit der Sensorspannung multipliziet wird. y=ax+b. Hier also a

Vref_fac = 1.47                                        #Faktor fuer die Sensorversorgungsspannung, der aus dem Spannungsteiler von VDD und Masse kommt. 

#Hier wird der String defniert, der spaeter zum senden an FHEM benutzt wird

op = "setreading"                                      #Befehl, der in FHEM Syntax zu beginn steht

dev = "Pegel"                                          #FHEM - Device, dass mit dem befehl angesprochen werden soll

usrReadPegel = "Wasserstand"                           #FHEM - userReading zum FHEM Device, 

                                                       #z.B: attr Pegel userReading Wasserstand { ReadingsVal("Pegel", "Wasserstand", 0);; }

usrReadVRev = "VRef_Spannung"                          #FHEM - userReading zum FHEM Device

usrReadPegel_avg = "Wasserstand_AVG"                   #FHEM - userReading zum FHEM Device,

usrReadVRev_avg = "VRef_Spannung_AVG"                  #FHEM - userReading zum FHEM Device,

usrReadAN0_act = "AN0_Spannung_act"                    #FHEM - userReading zum FHEM Device,

usrReadAN1_act = "AN1_Spannung_act"                    #FHEM - userReading zum FHEM Device,

usrReadAN0_raw = "AN0_Spannung_act_raw"                #FHEM - userReading zum FHEM Device,

usrReadAN1_raw = "AN1_Spannung_act_raw"                #FHEM - userReading zum FHEM Device,

unit_cm = "cm"                                         #Einheit, die mit dem userReading ueertragen werden koennte

unit_volt  = "V"                                       #Einheit, die mit dem userReading ueertragen werden koennte

#AN0 misst die Spannung am Sensorausgang des Drucksensors

AN0_RAW_act = adc.read_adc(0, gain=GAIN)                   # Setzten der Variable mit dem ersten AN0 Messwert

for i in range (SizeMeasBuffer):                       # Durch iterieren des gesamten Arrays und erstbefuellung mit dem AN0 Messwert

    AN0_RAW_Array[i]=AN0_RAW_act                            

    print(AN0_RAW_Array[i])

#AN1 misst die Versorgungsspannung des Sensors, da die Ausgangsspannung immer im Verhaeltnis zur Eingangsspannung steht.

AN1_RAW_act = adc.read_adc(1, gain=GAIN)                   # Setzten der Variable mit dem ersten AN0 Messwert

for i in range (SizeMeasBuffer):                       # Durch iterieren des gesamten Arrays und erstbefuellung mit dem AN0 Messwert

    AN1_RAW_Array[i]=AN1_RAW_act

    print(AN1_RAW_Array[i])

#________________________________________________

n=0

while n<50 :

    print ("_____________________________________________________________________________________________")

    print ("Start : %s" % time.ctime())

# Konzept:

# Beim Durchlaufen der Whileschleife wird der AD - Wandler einmal eingelesen. Jeder Wert wird in einem Array der Groesse SizeMeasBuffer abgelegt. In jedem Schleifendurchlauf wird n um eins Inkrementiert, bis n SizeMeasBuffer entspricht. Dann wird n Zurueckgesetzt. Zum indizieren der SizeMeasBuffer grossen Arrays wird n verwendet. Wenn n == SizeMeasBuffer ist, wird n wieder nach 0 gesetzt. Die Oben mit den AN - Werten initalisierten Arrays werden in jedem Schleifendurchlauf durchlaufen und jedes element des Arrays aufsummiert. Durch Teilen der Summe ANx_RAW_sum durch SizeMeasBuffer bekommt man nun den Mittelwert der im Array gespeicherten Werte ANx_RAW_avg. Wenn nun der aktuelle Messwert AN0_RAW_Array[n] um einen Bestimmten Schwellwert vom Mittelwert des Arrays abweicht, und zusaetzlich die Zyklusumschaltsperre Time_SleepCycleLockFor = 0 ist, wird in den schnellen Messzyklus umgeschaltet und eine Rueckschaltung in den Langsamen Zyklus fuer Time_SleepCycleLock gesperrt. So kann die Anfallende Datenmenge in FHEM reduziert werden, wenn der Pegel sich nicht aendert. Es kann immer in den schnellen Zyklus umgeschaltet werden, eine Rueckschaltung in den langsamen kann aber erst erfolgen, wenn der Istwert des Analogkanals kleiner Time_SleepHysFsSl ist und die Umschaltsperre Time_SleepCycleLockFor = 0 abgelaufen ist. 

#Einlesen, der in Konstante fuer die Offsetspannung aus FHEM. Diese kann per 'setreading Pegel Voffset_constant WERT' im FHEM Eingabefenster gesetzt werden. Die Anfrage fh.get_device_Reding liefert fuer ein userReading aus FHEM den Wert und das dazugehoerige Datum im dict - Format "{u'Value': 0.2, u'Time': datetime.datetime(2019, 1 , 9, 21, 1, 45)}". Damit nun auf den Wert zugegriffen werden kann, muss dieser mit u'Value als Schluessel aus dem Dictionary herausgeloesen werden. print(Voffset_constant[u'Value'])   

    Voffset_constant = fh.get_device_reading('Pegel', 'Voffset_constant')

  # Berechnung des Quotienten fuer die linieare Gleichung

    LinEq_quotient=Voffset_constant[u'Value']/0.0046

    if n == SizeMeasBuffer :                             # Schleifenzaehler, der maximal bis SizeMeasBuffer laeuft. Je schleifendurchlauf werden die AD - Kanaele

        n=0                                                # eingelesen    

    n += 1

    #valuesRAW[i] = adc.read_adc(i, gain=GAIN)

    #valuesComp[i] = adc.read_adc(i, gain=GAIN)*0.000125# At a convertion Gain of 0 the LSB resulution is 125uV. The ADC Read should therefore multiplied bei 125uV 

                                                       # Note you can also pass in an optional data_rate parameter that controls

                                                       # the ADC conversion time (in samples/second). Each chip has a different

                                                       # set of allowed data rate values, see datasheet Table 9 config register

                                                       # DR bit values.

                                                       #values[i] = adc.read_adc(i, gain=GAIN, data_rate=128)

                                                       # Each value will be a 12 or 16 bit signed integer value depending on the

                                                       # ADC (ADS1015 = 12-bit, ADS1115 = 16-bit).      

# Read the specified ADC channel using the previously set gain value.                                                  

    AN1_RAW_act = adc.read_adc(1, gain=GAIN)             #Einlesen des AN1 AD - Kanals

    TempDriftRaw = 16185 - adc.read_adc(1, gain=GAIN)    #Bilden der Temperaturdifferenzkonstante: 16185*125uV = 2,023125V Referenzspannung

    AN0_RAW_act = adc.read_adc(0, gain=GAIN) + TempDriftRaw

    AN0_RAW_Array[n-1]=AN0_RAW_act                       #Am AN0 ist der Spannungsausgang des Drucksensors angeschlossen

    AN1_RAW_Array[n-1]=AN1_RAW_act                       #Am AN1 wird die Versorgungsspannung des Drucksensors gemessen

    AN0_RAW_sum = 0                                    #Summe aller in AN0_RAW_Array gespeicherten Werte muessen zurueckgesetzt werden

    AN1_RAW_sum = 0                                    #Summe aller in AN1_RAW_Array gespeicherten Werte muessen zurueckgesetzt werden

    for i in range (SizeMeasBuffer):                   #Durchlaufen des Arrays und Bilden der summe

        AN0_RAW_sum = AN0_RAW_sum + AN0_RAW_Array[i]     #Aufaddieren der Werte an Stelle I auf das Ergebniss des letzten for - Schleifendurchlaufs

        AN1_RAW_sum = AN1_RAW_sum + AN1_RAW_Array[i]     #Aufaddieren der Werte an Stelle I auf das Ergebniss des letzten for - Schleifendurchlaufs

    AN0_RAW_avg = AN0_RAW_sum/SizeMeasBuffer           #Bilden des Mittelwertes / Quotienten durch Teilen der Summe durch die Puffergroesse

    AN1_RAW_avg = AN1_RAW_sum/SizeMeasBuffer           #Bilden des Mittelwertes / Quotienten durch Teilen der Summe durch die Puffergroesse

    AN0_RAW_Dif =  AN0_RAW_Array[n-1] - AN0_RAW_avg    #Bilden der Differenz zwischen aktuellen Messwert und des Mittelwertes

    AN1_RAW_Dif =  AN1_RAW_Array[n-1] - AN1_RAW_avg    #Bilden der Differenz zwischen aktuellen Messwert und des Mittelwertes

# Umrechnung der AD - Kanal - Werte auf Pegel und Referenzspannung

#AD - Kanal einlesen -> AD Integer -> Multiplikation mit 125uV aus AD - Kanalaufoesung --> AD - Spannung --> Multiplikation mit factor aus Lin. Gleichung -> Sensorspannung --> Subtraktion Quotienten aus der Geradensteigung.

    AN0_CON_act = AN0_RAW_act*0.000125*LinEq_Fac-LinEq_quotient  #Sensorspannung                                  

    AN1_CON_act = AN1_RAW_act*0.000125*Vref_fac                  #Sensorversorgungsspannung

    AN0_CON_avg = AN0_RAW_avg*0.000125*LinEq_Fac-LinEq_quotient                 #Sensorspannung

    AN1_CON_avg = AN1_RAW_avg*0.000125*Vref_fac                                 #Sensorversorgungsspannung 

# Defaulttextausgabe

    print('')

    print('')

    print('X' * 45)

    print('Reading ADS1x15 values, press Ctrl-C to quit')

    print('%s %f' % ('Schleifendurchlauf                        ', n))

    print('%s %d' % ('AN0 Summe                                 ', AN0_RAW_sum))

    print('%s %d' % ('AN0 Mittelwert                            ', AN0_RAW_avg))

    print('%s %d %s' % ('AN0 Messwert umgerechnet                  ', AN0_CON_act, 'cm'))

    print('%s %d %s' % ('AN0 Mittelwert umgerechnet                ', AN0_CON_avg, 'cm'))

    print('%s %d' % ('AN1 Summe                                 ', AN1_RAW_sum))

    print('%s %d' % ('AN1 Mittelwert                            ', AN1_RAW_avg))

    print('%s %f %s' % ('AN1 Messwert umgerechnet                  ', AN1_CON_act, 'Volt'))

    print('%s %f %s' % ('AN1 Mittelwert umgerechnet                ', AN1_CON_avg, 'Volt'))

    print('%s %d' % ('AN0 Differenz                             ', AN0_RAW_Dif))

    print('%s %d' % ('AN1 Differenz                             ', AN1_RAW_Dif))  

    print('%s %f' % ('Sensoroffsetspannung                      ', Voffset_constant[u'Value']))

    print('%s %s' % ('Sensoroffsetspannung gesetzt am           ', str(Voffset_constant[u'Time'])))

    print('%s %f' % ('Schleifendurchlaufzeit [Sekunden]         ', Time_Sleep))

    print('%s %d' % ('Zyklen bis Umschaltfreigabe               ', Time_SleepCycleLockFor))

    print('X' * 45)                                                              #Ende der Textausgabe

# Send a command to FHEM (this automatically connects() in case of telnet)

    cmd = '%s %s %s %f' % (op, dev, usrReadPegel, AN0_CON_act)                   #Zusammenbau des ersten FHEM - Kommandos aus Befehl, Geraet, Reading, Wert, Einheit

    print(cmd)                                                                   #debugging

    fh.send_cmd(cmd,0)                                                           #Senden des Kommandos an FHEM durch nutzung des FHEM - Objekts

    cmd1 = '%s %s %s %f' % (op, dev, usrReadVRev, AN1_CON_act)                   #Zusammenbau des ersten FHEM - Kommandos aus Befehl, Geraet, Reading, Wert, Einheit

    print(cmd1)                                                                  #debugging

    fh.send_cmd(cmd1,0)                                                          #Senden des Kommandos an FHEM durch nutzung des FHEM - Objekts

    cmd2 = '%s %s %s %f' % (op, dev, usrReadPegel_avg, AN0_CON_avg)              #Zusammenbau des ersten FHEM - Kommandos aus Befehl, Geraet, Reading, Wert, Einheit

    print(cmd2)                                                                  #debugging

    fh.send_cmd(cmd2,0)                                                          #Senden des Kommandos an FHEM durch nutzung des FHEM - Objekts

    cmd3 = '%s %s %s %f' % (op, dev, usrReadVRev_avg, AN1_CON_avg)               #Zusammenbau des ersten FHEM - Kommandos aus Befehl, Geraet, Reading, Wert, Einheit

    print(cmd3)                                                                  #debugging

    fh.send_cmd(cmd3,0)                                                          #Senden des Kommandos an FHEM durch nutzung des FHEM - Objekts

    cmd4 = '%s %s %s %f' % (op, dev, usrReadAN0_act, AN0_RAW_act*0.000125)       #Zusammenbau des ersten FHEM - Kommandos aus Befehl, Geraet, Reading, Wert, Einheit

    print(cmd4)                                                                  #debugging

    fh.send_cmd(cmd4,0)                                                          #Senden des Kommandos an FHEM durch nutzung des FHEM - Objekts

    cmd5 = '%s %s %s %f' % (op, dev, usrReadAN1_act, AN1_RAW_act*0.000125)       #Zusammenbau des ersten FHEM - Kommandos aus Befehl, Geraet, Reading, Wert, Einheit

    print(cmd5)                                                                  #debugging

    fh.send_cmd(cmd5,0)                                                          #Senden des Kommandos an FHEM durch nutzung des FHEM - Objekts

    cmd6 = '%s %s %s %f' % (op, dev, usrReadAN0_raw, AN0_RAW_act)                #Zusammenbau des ersten FHEM - Kommandos aus Befehl, Geraet, Reading, Wert, Einheit

    print(cmd6)                                                                  #debugging

    fh.send_cmd(cmd6,0)                                                          #Senden des Kommandos an FHEM durch nutzung des FHEM - Objekts

    cmd7 = '%s %s %s %f' % (op, dev, usrReadAN1_raw, AN1_RAW_act)                #Zusammenbau des ersten FHEM - Kommandos aus Befehl, Geraet, Reading, Wert, Einheit

    print(cmd7)                                                                  #debugging

    fh.send_cmd(cmd7,0)                                                          #Senden des Kommandos an FHEM durch nutzung des FHEM - Objekts

  #fh.send_cmd("setreading Pegel Wasserpegel 300cm")                           #debugging

    print('X' * 45)                                                              #Ende der Textausgabe

# Dekrementiert die Zyklussperre, falls eine Umschaltung erfolgt ist

    if Time_SleepCycleLockFor > 0:

        print('Dekrementiert die Zyklussperre, falls eine Umschaltung erfolgt ist')                                    #debugging

        Time_SleepCycleLockFor -= 1    

# Umschaltung in den schnellen Zyklus (immer moeglich, ohne Zyklussperrung). Schnelle, aufeinanderfolgende Signalaenderungen initialisieren die Zyklussperre immer wieder von neuem)

    if AN0_RAW_Dif > Time_SleepHysSlFs or AN0_RAW_Dif *(-1) > Time_SleepHysSlFs:         #Wenn der Abstand des aktuellen Analogmesswertes gross genug ist wird umgeschaltet

        print('AN0_RAW_Dif > Time_SleepHysSlFs or AN0_RAW_Dif *(-1) > Time_SleepHysSlFs')                                    #debugging

        Time_SleepCycleLockFor = Time_SleepCycleLock     #Setzten der Zyklusumschaltsperre auf Time_SleepCycleLock

        Time_Sleep = Time_SleepFast                      #Setzten der Zykluswartezeit auf das kurze Zeitintervall

    if AN1_RAW_Dif > Time_SleepHysSlFs or AN1_RAW_Dif *(-1) > Time_SleepHysSlFs:         #Wenn der Abstand des aktuellen Analogmesswertes gross genug ist wird umgeschaltet

        print('AN1_RAW_Dif > Time_SleepHysSlFs or AN1_RAW_Dif *(-1) > Time_SleepHysSlFs')                                    #debugging

        Time_SleepCycleLockFor = Time_SleepCycleLock     #Setzten der Zyklusumschaltsperre auf Time_SleepCycleLock

        Time_Sleep = Time_SleepFast                      #Setzten der Zykluswartezeit auf das kurze Zeitintervall  

  # Umschaltung in den langsamen Zyklus (Nur moeglich, wenn die Zyklussperre abgelaufen ist)

# Kurze Impulse fuehren deshalb zu einer sofortigen Abtatstungsumschaltung, wenn dann die Signale und Mittelwerte sich stabilisieren, beispiel bei einem

# Sprung, wird erst nach Time_SleepCycleLock der langsame Zyklus wieder aktiviert

    if Time_SleepCycleLockFor == 0 and  (AN0_RAW_Dif < Time_SleepHysFsSl or AN0_RAW_Dif *(-1) < Time_SleepHysFsSl):

        print('Time_SleepCycleLockFor == 0 and  (AN0_RAW_Dif < Time_SleepHysFsSl or AN0_RAW_Dif *(-1) < Time_SleepHysFsSl)')                                    #debugging

        Time_SleepCycleLockFor = Time_SleepCycleLock     #Setzten der Zyklusumschaltsperre auf Time_SleepCycleLock

        Time_Sleep = Time_SleepSlow                      #Setzten der Zykluswartezeit auf das lange Zeitintervall

    if Time_SleepCycleLockFor == 0 and  (AN1_RAW_Dif < Time_SleepHysFsSl or AN1_RAW_Dif *(-1) < Time_SleepHysFsSl):

        print('Time_SleepCycleLockFor == 0 and  (AN1_RAW_Dif < Time_SleepHysFsSl or AN1_RAW_Dif *(-1) < Time_SleepHysFsSl)')                                    #debugging

        Time_SleepCycleLockFor = Time_SleepCycleLock     #Setzten der Zyklusumschaltsperre auf Time_SleepCycleLock

        Time_Sleep = Time_SleepSlow                      #Setzten der Zykluswartezeit auf das lange Zeitintervall

    print(Time_Sleep)                                  #Ausgeben der Sleeptime

    time.sleep(2)                             #aktivieren der Wartezeit