Initial commit

python/cable-check.py

@@ -0,0 +1,230 @@
+import smbus
+import time
+import json
+import sys
+
+pruefer1  = 0x20
+pruefer2  = 0x21
+observer1 = 0x22
+observer2 = 0x23
+spurkabel1 = 0x24
+spurkabel2 = 0x25
+
+adressen = [pruefer1, pruefer2, observer1, observer2, spurkabel1, spurkabel2]
+
+IODIRA = 0x00  # Eingang / Ausgang A
+IODIRB = 0x01  # Eingang / Ausgang B
+GPPUA = 0x0C  # Eingang / Ausgang A
+GPPUB = 0x0D  # Eingang / Ausgang B
+GPIOA = 0x12   # GPIO A
+GPIOB = 0x13   # GPIO B
+
+array = {}
+logs = {}
+data = []
+
+
+try:
+    # Initialisiere den I2C Bus
+    bus = smbus.SMBus(1)
+except:
+    logs["errorcode"] = 12
+    array["logs"] = logs
+    json_output = json.dumps(array)
+    print(json_output)
+    sys.exit(0)
+
+def default():
+
+    #Schleife für alle Registeradressen (0x00 bis 0x15)
+    for register in range(0x00, 0x16):
+        for adresse in adressen:
+            #print("Setze " + str(adresse) + " in Register " + str(register) + " auf Wert 0x00")
+            bus.write_byte_data(adresse, register, 0x00)
+    
+    
+    #print("Hallo! Es wird damit begonnen, alle Register zurpckzusetzen...")
+    #Aktiviere alle Pullups und setze alle als Eingang
+    time.sleep(0.05)
+    for adresse in adressen:
+        bus.write_byte_data(adresse, IODIRA, 0xFF)
+        bus.write_byte_data(adresse, GPPUA, 0xFF)
+        bus.write_byte_data(adresse, IODIRB, 0xFF)
+        bus.write_byte_data(adresse, GPPUB, 0xFF)
+
+    #print("============= Reset erfolgreich! =============")
+            
+def main():
+    try:
+        default()
+    except:
+        logs["errorcode"] = 11
+        return
+    for pin in range(32):  # 0 bis 31
+        aktuellAn = pin
+    
+        for adresse in adressen:
+            bus.write_byte_data(adresse, IODIRA, 0xFF)
+            bus.write_byte_data(adresse, GPPUA, 0xFF)
+            bus.write_byte_data(adresse, IODIRB, 0xFF)
+            bus.write_byte_data(adresse, GPPUB, 0xFF)
+    
+        time.sleep(0.05)
+        
+        if pin < 16:
+            # Setze den gewählten Pin auf HIGH
+            if pin < 8:  # Pins A0-A7
+            
+                wert = 0xFF & ~(1 << pin)  # Alle Bits auf 1, außer das eine gewünschte auf 0
+                
+                bus.write_byte_data(pruefer1, GPPUA, wert)
+                bus.write_byte_data(pruefer1, IODIRA, wert)
+                bus.write_byte_data(pruefer1, GPIOA, 0x00)
+
+            else:  # Pins B0-B7
+                wert = 0xFF & ~(1 << pin - 8)  # Alle Bits auf 1, außer das eine gewünschte auf 0
+                
+                bus.write_byte_data(pruefer1, GPPUB, wert)
+                bus.write_byte_data(pruefer1, IODIRB, wert)
+                bus.write_byte_data(pruefer1, GPIOB, 0x00)
+        else:
+            # Setze den gewählten Pin auf HIGH
+            if pin < 24:  # Pins A0-A7
+                wert = 0xFF & ~(1 << pin - 16)  # Alle Bits auf 1, außer das eine gewünschte auf 0
+                
+                bus.write_byte_data(pruefer2, GPPUA, wert)
+                bus.write_byte_data(pruefer2, IODIRA, wert)
+                bus.write_byte_data(pruefer2, GPIOA, 0x00)
+            else:  # Pins B0-B7
+                wert = 0xFF & ~(1 << pin - 24)  # Alle Bits auf 1, außer das eine gewünschte auf 0
+                
+                bus.write_byte_data(pruefer2, GPPUB, wert)
+                bus.write_byte_data(pruefer2, IODIRB, wert)
+                bus.write_byte_data(pruefer2, GPIOB, 0x00)
+        
+        time.sleep(0.05)
+        
+        ##print(f"i2cget -y 1 0x20 0x12")
+        pruefer1_A_value = bus.read_byte_data(pruefer1, GPIOA)
+        pruefer1_B_value = bus.read_byte_data(pruefer1, GPIOB)
+        pruefer2_A_value = bus.read_byte_data(pruefer2, GPIOA)
+        pruefer2_B_value = bus.read_byte_data(pruefer2, GPIOB)
+        
+        observer1_A_value = bus.read_byte_data(observer1, GPIOA)
+        observer1_B_value = bus.read_byte_data(observer1, GPIOB)
+        observer2_A_value = bus.read_byte_data(observer2, GPIOA)
+        observer2_B_value = bus.read_byte_data(observer2, GPIOB)
+        
+        spurkabel1_A_value = bus.read_byte_data(spurkabel1, GPIOA)
+        spurkabel1_B_value = bus.read_byte_data(spurkabel1, GPIOB)
+        spurkabel2_A_value = bus.read_byte_data(spurkabel2, GPIOA)
+        spurkabel2_B_value = bus.read_byte_data(spurkabel2, GPIOB)
+        
+        #print(f"------>>>>Es konnte vom pruefer1_A_value der Wert  {format(pruefer1_A_value, '08b')} festgetsellt werden")
+        #print(f"------>>>>Es konnte vom pruefer1_B_value der Wert  {format(pruefer1_B_value, '08b')} festgetsellt werden")
+        #print(f"------>>>>Es konnte vom pruefer2_A_value der Wert  {format(pruefer2_A_value, '08b')} festgetsellt werden")
+        #print(f"------>>>>Es konnte vom pruefer2_B_value der Wert  {format(pruefer2_B_value, '08b')} festgetsellt werden")
+        
+        #print(f"------>>>>Es konnte vom observer1_A_value der Wert  {format(observer1_A_value, '08b')} festgetsellt werden")
+        #print(f"------>>>>Es konnte vom observer1_B_value der Wert  {format(observer1_B_value, '08b')} festgetsellt werden")
+        #print(f"------>>>>Es konnte vom observer2_A_value der Wert  {format(observer2_A_value, '08b')} festgetsellt werden")
+        #print(f"------>>>>Es konnte vom observer2_B_value der Wert  {format(observer2_B_value, '08b')} festgetsellt werden")
+        
+        #print(f"------>>>>Es konnte vom spurkabel1_A_value der Wert  {format(spurkabel1_A_value, '08b')} festgetsellt werden")
+        #print(f"------>>>>Es konnte vom spurkabel1_B_value der Wert  {format(spurkabel1_B_value, '08b')} festgetsellt werden")
+        #print(f"------>>>>Es konnte vom spurkabel2_A_value der Wert  {format(spurkabel2_A_value, '08b')} festgetsellt werden")
+        #print(f"------>>>>Es konnte vom spurkabel2_B_value der Wert  {format(spurkabel2_B_value, '08b')} festgetsellt werden")
+        
+        #print("===========================================================================")
+        
+        
+        for j in range(8): # Verarbeite 4*8=32 Pins + Jeweils 32 Observer- und Spurkabel-Daten
+            bitmaske = 1 << j  # Erstelle eine Maske: 1, 2, 4, 8, 16, ...
+            
+            pruefer1_A_value_bit = bool(pruefer1_A_value & bitmaske) 
+            pruefer1_B_value_bit = bool(pruefer1_B_value & bitmaske)
+            pruefer2_A_value_bit = bool(pruefer2_A_value & bitmaske) 
+            pruefer2_B_value_bit = bool(pruefer2_B_value & bitmaske)
+            
+            observer1_A_value_bit = bool(observer1_A_value & bitmaske) 
+            observer1_B_value_bit = bool(observer1_B_value & bitmaske)
+            observer2_A_value_bit = bool(observer2_A_value & bitmaske) 
+            observer2_B_value_bit = bool(observer2_B_value & bitmaske)
+            
+            spurkabel1_A_value_bit = bool(spurkabel1_A_value & bitmaske) 
+            spurkabel1_B_value_bit = bool(spurkabel1_B_value & bitmaske)
+            spurkabel2_A_value_bit = bool(spurkabel2_A_value & bitmaske) 
+            spurkabel2_B_value_bit = bool(spurkabel2_B_value & bitmaske)
+            
+            
+            
+            i = j
+            
+
+
+            if spurkabel1_A_value_bit == False:
+                data.append([[pin ,i],0])
+
+            if pruefer1_A_value_bit == False and observer1_A_value_bit == True:
+                data.append([[pin ,i],2])
+                #print("Prüfer sagt NEIN, Observer sagt JA");
+            if pruefer1_A_value_bit == True and observer1_A_value_bit == False:
+                data.append([[pin ,i],3])
+                #print("Prüfer sagt JA, Observer sagt NEIN");
+            
+            
+            i = j + 8
+            
+
+            if spurkabel1_B_value_bit == False:
+                data.append([[pin ,i],0])
+
+            if pruefer1_B_value_bit == False and observer1_B_value_bit == True:
+                data.append([[pin ,i],2])
+                #print("Prüfer sagt NEIN, Observer sagt JA");
+            if pruefer1_B_value_bit == True and observer1_B_value_bit == False:
+                data.append([[pin ,i],3])
+                #print("Prüfer sagt JA, Observer sagt NEIN");
+                
+            
+            i = j + 16
+
+
+            if spurkabel2_A_value_bit == False:
+                data.append([[pin ,i],0])
+
+            if pruefer2_A_value_bit == False and observer2_A_value_bit == True:
+                data.append([[pin ,i],2])
+                #print("Prüfer sagt NEIN, Observer sagt JA");
+            if pruefer2_A_value_bit == True and observer2_A_value_bit == False:
+                data.append([[pin ,i],3])
+                #print("Prüfer sagt JA, Observer sagt NEIN");
+
+                
+            i = j + 24
+
+            if spurkabel2_B_value_bit == False:
+                data.append([[pin ,i],0])
+
+            if pruefer2_B_value_bit == False and observer2_B_value_bit == True:
+                data.append([[pin ,i],2])
+                #print("Prüfer sagt NEIN, Observer sagt JA");
+            if pruefer2_B_value_bit == True and observer2_B_value_bit == False:
+                data.append([[pin ,i],3])
+                #print("Prüfer sagt JA, Observer sagt NEIN");
+
+    logs["errorcode"] = 10
+    
+if __name__ == "__main__":
+    try:
+        main()
+    except:
+        logs["errorcode"] = 13
+    array["logs"] = logs
+    array["data"] = data
+    json_output = json.dumps(array)
+    print(json_output)
+
+
+
+        

python/observer-full.py

@@ -0,0 +1,219 @@
+import smbus
+import time
+import json
+import sys
+
+pruefer1  = 0x20
+pruefer2  = 0x21
+observer1 = 0x22
+observer2 = 0x23
+
+adressen = [pruefer1, pruefer2, observer1, observer2]
+
+IODIRA = 0x00  # Eingang / Ausgang A
+IODIRB = 0x01  # Eingang / Ausgang B
+GPPUA = 0x0C  # Eingang / Ausgang A
+GPPUB = 0x0D  # Eingang / Ausgang B
+GPIOA = 0x12   # GPIO A
+GPIOB = 0x13   # GPIO B
+
+array = {}
+logs = {}
+data = []
+
+
+try:
+    # Initialisiere den I2C Bus
+    bus = smbus.SMBus(1)
+except:
+    logs["errorcode"] = 12
+    array["logs"] = logs
+    json_output = json.dumps(array)
+    print(json_output)
+    sys.exit(0)
+
+def default():
+
+    #Schleife für alle Registeradressen (0x00 bis 0x15)
+    for register in range(0x00, 0x16):
+        for adresse in adressen:
+            #print("Setze " + str(adresse) + " in Register " + str(register) + " auf Wert 0x00")
+            bus.write_byte_data(adresse, register, 0x00)
+    
+    
+    #print("Hallo! Es wird damit begonnen, alle Register zurpckzusetzen...")
+    #Aktiviere alle Pullups und setze alle als Eingang
+    time.sleep(0.05)
+    for adresse in adressen:
+        bus.write_byte_data(adresse, IODIRA, 0xFF)
+        bus.write_byte_data(adresse, GPPUA, 0xFF)
+        bus.write_byte_data(adresse, IODIRB, 0xFF)
+        bus.write_byte_data(adresse, GPPUB, 0xFF)
+
+    #print("============= Reset erfolgreich! =============")
+            
+def main():
+    try:
+        default()
+    except:
+        logs["errorcode"] = 11
+        return
+    time.sleep(0.05)
+    for pin in range(32):  # 0 bis 31
+        aktuellAn = pin
+    
+        for adresse in adressen:
+            bus.write_byte_data(adresse, IODIRA, 0xFF)
+            bus.write_byte_data(adresse, GPPUA, 0xFF)
+            bus.write_byte_data(adresse, IODIRB, 0xFF)
+            bus.write_byte_data(adresse, GPPUB, 0xFF)
+    
+        time.sleep(0.05)
+        
+        if pin < 16:
+            # Setze den gewählten Pin auf HIGH
+            if pin < 8:  # Pins A0-A7
+            
+                wert = 0xFF & ~(1 << pin)  # Alle Bits auf 1, außer das eine gewünschte auf 0
+                
+                bus.write_byte_data(pruefer1, GPPUA, wert)
+                bus.write_byte_data(pruefer1, IODIRA, wert)
+                bus.write_byte_data(pruefer1, GPIOA, 0x00)
+
+            else:  # Pins B0-B7
+                wert = 0xFF & ~(1 << pin - 8)  # Alle Bits auf 1, außer das eine gewünschte auf 0
+                
+                bus.write_byte_data(pruefer1, GPPUB, wert)
+                bus.write_byte_data(pruefer1, IODIRB, wert)
+                bus.write_byte_data(pruefer1, GPIOB, 0x00)
+        else:
+            # Setze den gewählten Pin auf HIGH
+            if pin < 24:  # Pins A0-A7
+                wert = 0xFF & ~(1 << pin - 16)  # Alle Bits auf 1, außer das eine gewünschte auf 0
+                
+                bus.write_byte_data(pruefer2, GPPUA, wert)
+                bus.write_byte_data(pruefer2, IODIRA, wert)
+                bus.write_byte_data(pruefer2, GPIOA, 0x00)
+            else:  # Pins B0-B7
+                wert = 0xFF & ~(1 << pin - 24)  # Alle Bits auf 1, außer das eine gewünschte auf 0
+                
+                bus.write_byte_data(pruefer2, GPPUB, wert)
+                bus.write_byte_data(pruefer2, IODIRB, wert)
+                bus.write_byte_data(pruefer2, GPIOB, 0x00)
+        
+        time.sleep(0.05)
+        
+        ##print(f"i2cget -y 1 0x20 0x12")
+        pruefer1_A_value = bus.read_byte_data(pruefer1, GPIOA)
+        pruefer1_B_value = bus.read_byte_data(pruefer1, GPIOB)
+        pruefer2_A_value = bus.read_byte_data(pruefer2, GPIOA)
+        pruefer2_B_value = bus.read_byte_data(pruefer2, GPIOB)
+        
+        observer1_A_value = bus.read_byte_data(observer1, GPIOA)
+        observer1_B_value = bus.read_byte_data(observer1, GPIOB)
+        observer2_A_value = bus.read_byte_data(observer2, GPIOA)
+        observer2_B_value = bus.read_byte_data(observer2, GPIOB)
+        
+        #print(f"------>>>>Es konnte vom Pruefer der Wert   {format(Wert_pruefer, '08b')} festgetsellt werden")
+        #print(f"------>>>>Es konnte vom Observer der Wert  {format(Wert_observer, '08b')} festgetsellt werden")
+        
+        
+        for j in range(8): # Verarbeite 4*8=32 Pins + Jeweils 32 Observer-Daten
+            bitmaske = 1 << j  # Erstelle eine Maske: 1, 2, 4, 8, 16, ...
+            
+            pruefer1_A_value_bit = bool(pruefer1_A_value & bitmaske) 
+            pruefer1_B_value_bit = bool(pruefer1_B_value & bitmaske)
+            pruefer2_A_value_bit = bool(pruefer2_A_value & bitmaske) 
+            pruefer2_B_value_bit = bool(pruefer2_B_value & bitmaske)
+            
+            observer1_A_value_bit = bool(observer1_A_value & bitmaske) 
+            observer1_B_value_bit = bool(observer1_B_value & bitmaske)
+            observer2_A_value_bit = bool(observer2_A_value & bitmaske) 
+            observer2_B_value_bit = bool(observer2_B_value & bitmaske)
+            
+            
+            
+            i = j
+
+            if pruefer1_A_value_bit == False and i != pin:
+                #print("Gefunden: " + str(pin) + " <> " + str(j));
+                if observer1_A_value_bit == False:
+                    #print("Dies wurde vom Observer bestätigt!");
+                    data.append([[pin ,i],0])
+                else:
+                    #print("Konnte NICHT bestätigen!");
+                    data.append([[pin ,i],1])
+            if pruefer1_A_value_bit == False and observer1_A_value_bit == True:
+                data.append([[pin ,i],2])
+                #print("Prüfer sagt NEIN, Observer sagt JA");
+            if pruefer1_A_value_bit == True and observer1_A_value_bit == False:
+                data.append([[pin ,i],3])
+                #print("Prüfer sagt JA, Observer sagt NEIN");
+            
+            
+            i = j + 8
+     
+            if pruefer1_B_value_bit == False and i != pin:
+                #print("Gefunden: " + str(pin) + " <> " + str(j));
+                if observer1_B_value_bit == False:
+                    #print("Dies wurde vom Observer bestätigt!");
+                    data.append([[pin ,i],0])
+                else:
+                    #print("Konnte NICHT bestätigen!");
+                    data.append([[pin ,i],1])
+            if pruefer1_B_value_bit == False and observer1_B_value_bit == True:
+                data.append([[pin ,i],2])
+                #print("Prüfer sagt NEIN, Observer sagt JA");
+            if pruefer1_B_value_bit == True and observer1_B_value_bit == False:
+                data.append([[pin ,i],3])
+                #print("Prüfer sagt JA, Observer sagt NEIN");
+                
+            i = j + 16
+
+            if pruefer2_A_value_bit == False and i != pin:
+                #print("Gefunden: " + str(pin) + " <> " + str(j));
+                if observer2_A_value_bit == False:
+                    #print("Dies wurde vom Observer bestätigt!");
+                    data.append([[pin ,i],0])
+                else:
+                    #print("Konnte NICHT bestätigen!");
+                    data.append([[pin ,i],1])
+            if pruefer2_A_value_bit == False and observer2_A_value_bit == True:
+                data.append([[pin ,i],2])
+                #print("Prüfer sagt NEIN, Observer sagt JA");
+            if pruefer2_A_value_bit == True and observer2_A_value_bit == False:
+                data.append([[pin ,i],3])
+                #print("Prüfer sagt JA, Observer sagt NEIN");
+                
+            i = j + 24
+
+            if pruefer2_B_value_bit == False and i != pin:
+                #print("Gefunden: " + str(pin) + " <> " + str(j));
+                if observer2_B_value_bit == False:
+                    #print("Dies wurde vom Observer bestätigt!");
+                    data.append([[pin ,i],0])
+                else:
+                    #print("Konnte NICHT bestätigen!");
+                    data.append([[pin ,i],1])
+            if pruefer2_B_value_bit == False and observer2_B_value_bit == True:
+                data.append([[pin ,i],2])
+                #print("Prüfer sagt NEIN, Observer sagt JA");
+            if pruefer2_B_value_bit == True and observer2_B_value_bit == False:
+                data.append([[pin ,i],3])
+                #print("Prüfer sagt JA, Observer sagt NEIN");
+
+    logs["errorcode"] = 10
+    
+if __name__ == "__main__":
+    try:
+        main()
+    except:
+        logs["errorcode"] = 13
+    array["logs"] = logs
+    array["data"] = data
+    json_output = json.dumps(array)
+    print(json_output)
+
+
+
+        

python/observer.py

@@ -0,0 +1,127 @@
+import smbus
+import time
+import json
+import sys
+
+pruefer = 0x20
+observer = 0x22
+
+
+IODIRA = 0x00  # Eingang / Ausgang A
+IODIRB = 0x01  # Eingang / Ausgang B
+GPPUA = 0x0C  # Eingang / Ausgang A
+GPPUB = 0x0D  # Eingang / Ausgang B
+GPIOA = 0x12   # GPIO A
+GPIOB = 0x13   # GPIO B
+
+array = {}
+logs = {}
+data = []
+
+
+try:
+    # Initialisiere den I2C Bus
+    bus = smbus.SMBus(1)
+except:
+    logs["errorcode"] = 12
+    array["logs"] = logs
+    json_output = json.dumps(array)
+    print(json_output)
+    sys.exit(0)
+
+
+
+
+
+def default():
+    #adressen = [pruefer]
+
+    # Schleife für alle Registeradressen (0x00 bis 0x15)
+    #for register in range(0x00, 0x16):
+    #    for adresse in adressen:
+    #        time.sleep(0.05)
+    #        #print("Setze " + str(adresse) + " in Register " + str(register) + " auf Wert 0x00")
+    #        bus.write_byte_data(adresse, register, 0x00)
+    
+    
+    #print("Hallo! Es wird damit begonnen, alle Register zurpckzusetzen...")
+    time.sleep(0.05)
+    bus.write_byte_data(pruefer, IODIRA, 0xFF)
+    bus.write_byte_data(observer, IODIRA, 0xFF)
+    
+    bus.write_byte_data(pruefer, GPPUA, 0xFF)
+    bus.write_byte_data(observer, GPPUA, 0xFF)
+    #print("============= Reset erfolgreich! =============")
+            
+def main():
+    try:
+        default()
+    except:
+        logs["errorcode"] = 11
+        return
+    time.sleep(0.05)
+    for pin in range(8):  # 0 bis 7
+        wert = 0xFF & ~(1 << pin)  # Alle Bits auf 1, außer das eine gewünschte auf 0
+        #print("======== Setze Pin " + str(pin) + " auf den Wert " +  format(wert, '08b'));
+        
+
+        bus.write_byte_data(pruefer, GPPUA, wert)
+        bus.write_byte_data(pruefer, IODIRA, wert) # Setze einzeln als Ausgang    111011111 usw...
+        bus.write_byte_data(pruefer, GPIOA, 0x00) # Deaktiviere alle pins (es reagiert sowieso nur der Ausgang, dh keine Bitmaske erforderlich)  00000000 usw..
+        
+        time.sleep(0.05)
+        
+        ##print(f"i2cget -y 1 0x20 0x12")
+        Wert_pruefer = bus.read_byte_data(pruefer, GPIOA)
+        Wert_observer = bus.read_byte_data(observer, GPIOA)
+        
+        #print(f"------>>>>Es konnte vom Pruefer der Wert   {format(Wert_pruefer, '08b')} festgetsellt werden")
+        #print(f"------>>>>Es konnte vom Observer der Wert  {format(Wert_observer, '08b')} festgetsellt werden")
+        
+        ok = 0
+        
+        for j in range(8): # Lese 4*8=32 Pins
+            bitmaske = 1 << j  # Erstelle eine Maske: 1, 2, 4, 8, 16, ...
+            
+            Bit_pruefer = bool(Wert_pruefer & bitmaske) 
+            Bit_observer = bool(Wert_observer & bitmaske)
+
+            if Bit_observer == False: # Prüfe, ob aktueller Pin wirklich 0 sein darf
+                if j == pin:
+                    ok = 1
+            if Bit_pruefer == False and j != pin:
+                #print("Gefunden: " + str(pin) + " <> " + str(j));
+                if Bit_observer == False:
+                    #print("Dies wurde vom Observer bestätigt!");
+                    data.append([[pin ,j],0])
+                else:
+                    #print("Konnte NICHT bestätigen!");
+                    data.append([[pin ,j],1])
+            if Bit_pruefer == False and Bit_observer == True:
+                data.append([[pin ,j],2])
+                #print("Prüfer sagt NEIN, Observer sagt JA");
+            if Bit_pruefer == True and Bit_observer == False:
+                data.append([[pin ,j],3])
+                #print("Prüfer sagt JA, Observer sagt NEIN");
+                
+
+        
+        if ok != 1:
+            #print("Fehler beim Aufruf von Pin " + str(pin) + "! Es konnte nicht bestätigt werden, dass dieser Pin tatsächlich LOW ist!");
+            data.append([[pin ,"???"],4])
+
+    logs["errorcode"] = 10
+    
+if __name__ == "__main__":
+    try:
+        main()
+    except:
+        logs["errorcode"] = 13
+    array["logs"] = logs
+    array["data"] = data
+    json_output = json.dumps(array)
+    print(json_output)
+
+
+
+        

python/plug-check.py

@@ -0,0 +1,165 @@
+import smbus
+import time
+import json
+
+# Adressen der beiden MCP23017 Chips
+AusgangRechts = 0x20  # Ausgang rechte Hälfte
+AusgangLinks = 0x21  # Ausgang linke Hälfte
+EingangRechts = 0x24  # Eingang rechte Hälfte
+EingangLinks = 0x23  # Eingang linke Hälfte
+
+# Register-Adressen für den MCP23017
+IODIRA = 0x00  # Eingang / Ausgang A
+IODIRB = 0x01  # Eingang / Ausgang B
+GPIOA = 0x12   # GPIO A
+GPIOB = 0x13   # GPIO B
+
+# Initialisiere den I2C Bus
+bus = smbus.SMBus(1)
+
+RechtsA_ausgang = ["Z", "AA", "W", "AB", "AC", "AD", "AE", "AF"]
+RechtsB_ausgang = ["Q", "U", "V", "T", "S", "R", "Y", "X"]
+
+RechtsA_eingang = ["R", "T", "V", "X", "Z", "AB", "AD", "AE"]
+RechtsB_eingang = ["Q", "S", "W", "U", "AA", "Y", "AC", "AF"]
+
+LinksA_ausgang = ["C", "D", "E", "J", "F", "G", "H", "I"]
+LinksB_ausgang = ["A", "B", "P", "O", "K", "L", "M", "N"]
+
+LinksA_eingang = ["B", "D", "F", "H", "J", "K", "M", "I"]
+LinksB_eingang = ["A", "C", "E", "G", "L", "N", "O", "P"]
+
+
+array = []
+
+def default():
+    adressen = [AusgangRechts, AusgangLinks, EingangRechts, EingangLinks]
+
+    # Schleife für alle Registeradressen (0x00 bis 0x15)
+    for register in range(0x00, 0x16):
+        for adresse in adressen:
+            time.sleep(0.05)
+            print("Setze " + str(adresse) + " in Register " + str(register) + " auf Wert 0x00")
+            bus.write_byte_data(adresse, register, 0x00)
+
+# Konfiguriere alle Pins auf Chip 1 als Ausgang (A und B)
+def configure_chip1_as_output():
+    bus.write_byte_data(AusgangRechts, IODIRA, 0x00)  # Setze alle Pins von A als Ausgang
+    bus.write_byte_data(AusgangRechts, IODIRB, 0x00)  # Setze alle Pins von B als Ausgang
+    
+    bus.write_byte_data(AusgangLinks, IODIRA, 0x00)  # Setze alle Pins von A als Ausgang
+    bus.write_byte_data(AusgangLinks, IODIRB, 0x00)  # Setze alle Pins von B als Ausgang
+
+# Konfiguriere alle Pins auf Chip 2 als Eingang (A und B)
+def configure_chip2_as_input():
+    bus.write_byte_data(EingangRechts, IODIRA, 0xFF)  # Setze alle Pins von A als Eingang
+    bus.write_byte_data(EingangRechts, IODIRB, 0xFF)  # Setze alle Pins von B als Eingang
+    
+    bus.write_byte_data(EingangLinks, IODIRA, 0xFF)  # Setze alle Pins von A als Eingang
+    bus.write_byte_data(EingangLinks, IODIRB, 0xFF)  # Setze alle Pins von B als Eingang
+
+
+# Hauptprogramm
+def main():
+    default()
+    time.sleep(0.05)
+    configure_chip1_as_output()
+    time.sleep(0.05)
+    configure_chip2_as_input()
+
+    # Teste alle Pins auf Chip 1 (A0-A7, B0-B7)
+    for pin in range(32):  # 0 bis 31
+        #print(f"Setze Pin {pin} auf HIGH auf Chip 1")
+        
+        
+        
+        print("setze AusgangRechts GPIOA")
+        bus.write_byte_data(AusgangRechts, GPIOA, 0x00)
+        print("setze AusgangRechts GPIOB")
+        bus.write_byte_data(AusgangRechts, GPIOB, 0x00)
+        
+        print("setze AusgangLinks GPIOA")
+        bus.write_byte_data(AusgangLinks, GPIOA, 0x00)
+        print("setze AusgangLinks GPIOB")
+        bus.write_byte_data(AusgangLinks, GPIOB, 0x00)
+        
+        
+        if pin < 16:
+            # Setze den gewählten Pin auf HIGH
+            if pin < 8:  # Pins A0-A7
+                print("setze RechtsA_ausgang" + RechtsA_ausgang[pin])
+                bus.write_byte_data(AusgangRechts, GPIOA, 1 << pin)
+                
+                aktuellAn = RechtsA_ausgang[pin]
+            else:  # Pins B0-B7
+                print("setze RechtsB_ausgang" + RechtsB_ausgang[pin-8])
+                bus.write_byte_data(AusgangRechts, GPIOB, 1 << (pin - 8))
+                aktuellAn = RechtsB_ausgang[pin - 8]
+        else:
+            # Setze den gewählten Pin auf HIGH
+            if pin < 24:  # Pins A0-A7
+                print("setze LinksA_ausgang" + LinksA_ausgang[pin-16])
+                bus.write_byte_data(AusgangLinks, GPIOA, 1 << pin - 16)
+                aktuellAn = LinksA_ausgang[pin - 16]
+            else:  # Pins B0-B7
+                print("setze LinksB_ausgang" + LinksB_ausgang[pin-24])
+                bus.write_byte_data(AusgangLinks, GPIOB, 1 << (pin - 24))
+                aktuellAn = LinksB_ausgang[pin - 24]
+            
+        print("====================" + aktuellAn + "==========================")
+
+        time.sleep(0.2)  # Kurze Pause, damit die Änderung sichtbar wird
+        
+        print("Lese Wert_Rechts_A")
+        Wert_Rechts_A = bus.read_byte_data(EingangRechts, GPIOA)
+        print(Wert_Rechts_A)
+        print("Lese Wert_Links_A")
+        Wert_Links_A = bus.read_byte_data(EingangLinks, GPIOA)
+        print(Wert_Links_A)
+        
+        print("Lese Wert_Rechts_B")
+        Wert_Rechts_B = bus.read_byte_data(EingangRechts, GPIOB)
+        print(Wert_Rechts_B)
+        print("Lese Wert_Links_B")
+        Wert_Links_B = bus.read_byte_data(EingangLinks, GPIOB)
+        print(Wert_Links_B)
+        
+
+
+        for j in range(8): # Lese 4*8=32 Pins
+            bitmaske = 1 << j  # Erstelle eine Maske: 1, 2, 4, 8, 16, ...
+            
+            Bit_Rechts_A = bool(Wert_Rechts_A & bitmaske)  # Isoliere das entsprechende Bit
+            Bit_Links_A = bool(Wert_Links_A & bitmaske)  # Isoliere das entsprechende Bit
+            Bit_Rechts_B = bool(Wert_Rechts_B & bitmaske)  # Isoliere das entsprechende Bit
+            Bit_Links_B = bool(Wert_Links_B & bitmaske)  # Isoliere das entsprechende Bit
+            
+            if Bit_Rechts_A == True:
+                if aktuellAn != RechtsA_eingang[j]:
+                    array.append([aktuellAn ,RechtsA_eingang[j]])
+                print("Gefunden: " + RechtsA_eingang[j])
+                    
+            if Bit_Links_A == True:
+                if aktuellAn != LinksA_eingang[j]:
+                    array.append([aktuellAn ,LinksA_eingang[j]])
+                print("Gefunden: " + LinksA_eingang[j])
+                    
+            if Bit_Rechts_B == True:
+                if aktuellAn != RechtsB_eingang[j]:
+                    array.append([aktuellAn ,RechtsB_eingang[j]])
+                print("Gefunden: " + RechtsB_eingang[j])
+            
+            if Bit_Links_B == True:
+                if aktuellAn != LinksB_eingang[j]:
+                    array.append([aktuellAn ,LinksB_eingang[j]])
+                print("Gefunden: " + LinksB_eingang[j])
+
+
+
+
+    json_output = json.dumps(array)
+    print(json_output)
+
+if __name__ == "__main__":
+    main()
+

python/plug-check_external-pulldown.py

@@ -0,0 +1,75 @@
+import smbus
+import time
+import json
+
+# Adressen der beiden MCP23017 Chips
+MP = 0x20  # Ausgang rechte Hälfte
+
+
+# Register-Adressen für den MCP23017
+IODIRA = 0x00  # Eingang / Ausgang A
+IODIRB = 0x01  # Eingang / Ausgang B
+GPIOA = 0x12   # GPIO A
+GPIOB = 0x13   # GPIO B
+
+# Initialisiere den I2C Bus
+bus = smbus.SMBus(1)
+
+
+def default():
+    # Schleife für alle Registeradressen (0x00 bis 0x15)
+    for register in range(0x00, 0x16):
+        bus.write_byte_data(MP, register, 0x00)
+
+# Konfiguriere alle Pins auf Chip 1 als Ausgang (A und B)
+def configure_chip1_as_output():
+    bus.write_byte_data(MP, IODIRA, 0x00)  # Setze alle Pins von A als Ausgang
+    bus.write_byte_data(MP, IODIRB, 0x00)  # Setze alle Pins von B als Ausgang
+
+
+
+# Hauptprogramm
+def main():
+    default()
+    time.sleep(0.5)
+    configure_chip1_as_output()
+
+    # Teste alle Pins auf Chip 1 (A0-A7, B0-B7)
+    for pin in range(32):  # 0 bis 31
+        #print(f"Setze Pin {pin} auf HIGH auf Chip 1")
+        
+
+        bus.write_byte_data(MP, GPIOA, 0x00)
+        
+        
+        if pin < 16:
+            # Setze den gewählten Pin auf HIGH
+            if pin < 8:  # Pins A0-
+            
+                bus.write_byte_data(MP, IODIRA, ~(1 << pin))
+                
+                bus.write_byte_data(MP, GPIOA, 1 << pin)
+   
+            
+        print("====================" + str(pin) + "==========================")
+
+        time.sleep(0.2)  # Kurze Pause, damit die Änderung sichtbar wird
+        
+        wert = bus.read_byte_data(MP, GPIOA)
+        
+
+
+        for j in range(8): # Lese 4*8=32 Pins
+            bitmaske = 1 << j  # Erstelle eine Maske: 1, 2, 4, 8, 16, ...
+            
+            wert_bitweise = bool(wert & bitmaske)  # Isoliere das entsprechende Bit
+          
+            
+            if wert_bitweise == True:
+                print("Gefunden: " + str(j))
+           
+
+
+if __name__ == "__main__":
+    main()
+

python/plug-check_internal-pullup.py

@@ -0,0 +1,53 @@
+import smbus
+import time
+import json
+
+# Adressen der beiden MCP23017 Chips
+MP = 0x20  # Ausgang rechte Hälfte
+
+
+# Register-Adressen für den MCP23017
+IODIRA = 0x00  # Eingang / Ausgang A
+IODIRB = 0x01  # Eingang / Ausgang B
+GPIOA = 0x12   # GPIO A
+GPIOB = 0x13   # GPIO B
+
+PULLUPA = 0x0C
+PULLUPB = 0x0D
+
+# Initialisiere den I2C Bus
+bus = smbus.SMBus(1)
+
+# Hauptprogramm
+def main():
+    time.sleep(0.5)
+
+    for pin in range(8):
+        
+
+        bus.write_byte_data(MP, IODIRA, ~(1 << pin))
+        time.sleep(0.02)
+        bus.write_byte_data(MP, PULLUPA, ~(1 << pin))
+        time.sleep(0.02)
+        
+        bus.write_byte_data(MP, GPIOA, ~(1 << pin))
+        time.sleep(0.02)
+           
+            
+        print("====================" + str(pin) + "==========================")
+
+        wert = bus.read_byte_data(MP, GPIOA)
+        
+        for j in range(8): # Lese 4*8=32 Pins
+            bitmaske = 1 << j
+            
+            wert_bitweise = bool(wert & bitmaske)
+            
+            if wert_bitweise == False and j != pin:
+                print(str(j))
+
+        time.sleep(0.02)  # Kurze Pause, damit die Änderung sichtbar wird
+
+
+if __name__ == "__main__":
+    main()

python/selfcheck.py

@@ -0,0 +1,219 @@
+import smbus
+import time
+import json
+import sys
+
+pruefer1  = 0x20
+pruefer2  = 0x21
+observer1 = 0x22
+observer2 = 0x23
+
+adressen = [pruefer1, pruefer2, observer1, observer2]
+
+IODIRA = 0x00  # Eingang / Ausgang A
+IODIRB = 0x01  # Eingang / Ausgang B
+GPPUA = 0x0C  # Eingang / Ausgang A
+GPPUB = 0x0D  # Eingang / Ausgang B
+GPIOA = 0x12   # GPIO A
+GPIOB = 0x13   # GPIO B
+
+array = {}
+logs = {}
+data = []
+
+
+try:
+    # Initialisiere den I2C Bus
+    bus = smbus.SMBus(1)
+except:
+    logs["errorcode"] = 12
+    array["logs"] = logs
+    json_output = json.dumps(array)
+    print(json_output)
+    sys.exit(0)
+
+def default():
+
+    #Schleife für alle Registeradressen (0x00 bis 0x15)
+    for register in range(0x00, 0x16):
+        for adresse in adressen:
+            #print("Setze " + str(adresse) + " in Register " + str(register) + " auf Wert 0x00")
+            bus.write_byte_data(adresse, register, 0x00)
+    
+    
+    #print("Hallo! Es wird damit begonnen, alle Register zurpckzusetzen...")
+    #Aktiviere alle Pullups und setze alle als Eingang
+    time.sleep(0.05)
+    for adresse in adressen:
+        bus.write_byte_data(adresse, IODIRA, 0xFF)
+        bus.write_byte_data(adresse, GPPUA, 0xFF)
+        bus.write_byte_data(adresse, IODIRB, 0xFF)
+        bus.write_byte_data(adresse, GPPUB, 0xFF)
+
+    #print("============= Reset erfolgreich! =============")
+            
+def main():
+    try:
+        default()
+    except:
+        logs["errorcode"] = 11
+        return
+    time.sleep(0.05)
+    for pin in range(32):  # 0 bis 31
+        aktuellAn = pin
+    
+        for adresse in adressen:
+            bus.write_byte_data(adresse, IODIRA, 0xFF)
+            bus.write_byte_data(adresse, GPPUA, 0xFF)
+            bus.write_byte_data(adresse, IODIRB, 0xFF)
+            bus.write_byte_data(adresse, GPPUB, 0xFF)
+    
+        time.sleep(0.05)
+        
+        if pin < 16:
+            # Setze den gewählten Pin auf HIGH
+            if pin < 8:  # Pins A0-A7
+            
+                wert = 0xFF & ~(1 << pin)  # Alle Bits auf 1, außer das eine gewünschte auf 0
+                
+                bus.write_byte_data(pruefer1, GPPUA, wert)
+                bus.write_byte_data(pruefer1, IODIRA, wert)
+                bus.write_byte_data(pruefer1, GPIOA, 0x00)
+
+            else:  # Pins B0-B7
+                wert = 0xFF & ~(1 << pin - 8)  # Alle Bits auf 1, außer das eine gewünschte auf 0
+                
+                bus.write_byte_data(pruefer1, GPPUB, wert)
+                bus.write_byte_data(pruefer1, IODIRB, wert)
+                bus.write_byte_data(pruefer1, GPIOB, 0x00)
+        else:
+            # Setze den gewählten Pin auf HIGH
+            if pin < 24:  # Pins A0-A7
+                wert = 0xFF & ~(1 << pin - 16)  # Alle Bits auf 1, außer das eine gewünschte auf 0
+                
+                bus.write_byte_data(pruefer2, GPPUA, wert)
+                bus.write_byte_data(pruefer2, IODIRA, wert)
+                bus.write_byte_data(pruefer2, GPIOA, 0x00)
+            else:  # Pins B0-B7
+                wert = 0xFF & ~(1 << pin - 24)  # Alle Bits auf 1, außer das eine gewünschte auf 0
+                
+                bus.write_byte_data(pruefer2, GPPUB, wert)
+                bus.write_byte_data(pruefer2, IODIRB, wert)
+                bus.write_byte_data(pruefer2, GPIOB, 0x00)
+        
+        time.sleep(0.05)
+        
+        ##print(f"i2cget -y 1 0x20 0x12")
+        pruefer1_A_value = bus.read_byte_data(pruefer1, GPIOA)
+        pruefer1_B_value = bus.read_byte_data(pruefer1, GPIOB)
+        pruefer2_A_value = bus.read_byte_data(pruefer2, GPIOA)
+        pruefer2_B_value = bus.read_byte_data(pruefer2, GPIOB)
+        
+        observer1_A_value = bus.read_byte_data(observer1, GPIOA)
+        observer1_B_value = bus.read_byte_data(observer1, GPIOB)
+        observer2_A_value = bus.read_byte_data(observer2, GPIOA)
+        observer2_B_value = bus.read_byte_data(observer2, GPIOB)
+        
+        #print(f"------>>>>Es konnte vom Pruefer der Wert   {format(Wert_pruefer, '08b')} festgetsellt werden")
+        #print(f"------>>>>Es konnte vom Observer der Wert  {format(Wert_observer, '08b')} festgetsellt werden")
+        
+        
+        for j in range(8): # Verarbeite 4*8=32 Pins + Jeweils 32 Observer-Daten
+            bitmaske = 1 << j  # Erstelle eine Maske: 1, 2, 4, 8, 16, ...
+            
+            pruefer1_A_value_bit = bool(pruefer1_A_value & bitmaske) 
+            pruefer1_B_value_bit = bool(pruefer1_B_value & bitmaske)
+            pruefer2_A_value_bit = bool(pruefer2_A_value & bitmaske) 
+            pruefer2_B_value_bit = bool(pruefer2_B_value & bitmaske)
+            
+            observer1_A_value_bit = bool(observer1_A_value & bitmaske) 
+            observer1_B_value_bit = bool(observer1_B_value & bitmaske)
+            observer2_A_value_bit = bool(observer2_A_value & bitmaske) 
+            observer2_B_value_bit = bool(observer2_B_value & bitmaske)
+            
+            
+            
+            i = j
+
+            if pruefer1_A_value_bit == False:
+                #print("Gefunden: " + str(pin) + " <> " + str(j));
+                if observer1_A_value_bit == False:
+                    #print("Dies wurde vom Observer bestätigt!");
+                    data.append([[pin ,i],0])
+                else:
+                    #print("Konnte NICHT bestätigen!");
+                    data.append([[pin ,i],1])
+            if pruefer1_A_value_bit == False and observer1_A_value_bit == True:
+                data.append([[pin ,i],2])
+                #print("Prüfer sagt NEIN, Observer sagt JA");
+            if pruefer1_A_value_bit == True and observer1_A_value_bit == False:
+                data.append([[pin ,i],3])
+                #print("Prüfer sagt JA, Observer sagt NEIN");
+            
+            
+            i = j + 8
+     
+            if pruefer1_B_value_bit == False:
+                #print("Gefunden: " + str(pin) + " <> " + str(j));
+                if observer1_B_value_bit == False:
+                    #print("Dies wurde vom Observer bestätigt!");
+                    data.append([[pin ,i],0])
+                else:
+                    #print("Konnte NICHT bestätigen!");
+                    data.append([[pin ,i],1])
+            if pruefer1_B_value_bit == False and observer1_B_value_bit == True:
+                data.append([[pin ,i],2])
+                #print("Prüfer sagt NEIN, Observer sagt JA");
+            if pruefer1_B_value_bit == True and observer1_B_value_bit == False:
+                data.append([[pin ,i],3])
+                #print("Prüfer sagt JA, Observer sagt NEIN");
+                
+            i = j + 16
+
+            if pruefer2_A_value_bit == False:
+                #print("Gefunden: " + str(pin) + " <> " + str(j));
+                if observer2_A_value_bit == False:
+                    #print("Dies wurde vom Observer bestätigt!");
+                    data.append([[pin ,i],0])
+                else:
+                    #print("Konnte NICHT bestätigen!");
+                    data.append([[pin ,i],1])
+            if pruefer2_A_value_bit == False and observer2_A_value_bit == True:
+                data.append([[pin ,i],2])
+                #print("Prüfer sagt NEIN, Observer sagt JA");
+            if pruefer2_A_value_bit == True and observer2_A_value_bit == False:
+                data.append([[pin ,i],3])
+                #print("Prüfer sagt JA, Observer sagt NEIN");
+                
+            i = j + 24
+
+            if pruefer2_B_value_bit == False:
+                #print("Gefunden: " + str(pin) + " <> " + str(j));
+                if observer2_B_value_bit == False:
+                    #print("Dies wurde vom Observer bestätigt!");
+                    data.append([[pin ,i],0])
+                else:
+                    #print("Konnte NICHT bestätigen!");
+                    data.append([[pin ,i],1])
+            if pruefer2_B_value_bit == False and observer2_B_value_bit == True:
+                data.append([[pin ,i],2])
+                #print("Prüfer sagt NEIN, Observer sagt JA");
+            if pruefer2_B_value_bit == True and observer2_B_value_bit == False:
+                data.append([[pin ,i],3])
+                #print("Prüfer sagt JA, Observer sagt NEIN");
+
+    logs["errorcode"] = 10
+    
+if __name__ == "__main__":
+    try:
+        main()
+    except:
+        logs["errorcode"] = 13
+    array["logs"] = logs
+    array["data"] = data
+    json_output = json.dumps(array)
+    print(json_output)
+
+
+
+        

python/test.py

@@ -0,0 +1,53 @@
+import smbus
+import time
+import json
+
+# Adressen der beiden MCP23017 Chips
+MP = 0x20  # Ausgang rechte Hälfte
+
+
+# Register-Adressen für den MCP23017
+IODIRA = 0x00  # Eingang / Ausgang A
+IODIRB = 0x01  # Eingang / Ausgang B
+GPIOA = 0x12   # GPIO A
+GPIOB = 0x13   # GPIO B
+
+PULLUPA = 0x0C
+PULLUPB = 0x0D
+
+# Initialisiere den I2C Bus
+bus = smbus.SMBus(1)
+
+# Hauptprogramm
+def main():
+    time.sleep(0.5)
+
+    for pin in range(8):
+        
+
+        bus.write_byte_data(MP, IODIRA, ~(1 << pin))
+        time.sleep(0.02)
+        bus.write_byte_data(MP, PULLUPA, ~(1 << pin))
+        time.sleep(0.02)
+        
+        bus.write_byte_data(MP, GPIOA, ~(1 << pin))
+        time.sleep(0.02)
+           
+            
+        print("====================" + str(pin) + "==========================")
+
+        wert = bus.read_byte_data(MP, GPIOA)
+        
+        for j in range(8): # Lese 4*8=32 Pins
+            bitmaske = 1 << j
+            
+            wert_bitweise = bool(wert & bitmaske)
+            
+            if wert_bitweise == False and j != pin:
+                print(str(j))
+
+        time.sleep(0.02)  # Kurze Pause, damit die Änderung sichtbar wird
+
+
+if __name__ == "__main__":
+    main()