4-Byte-Floats per Modbus TCP auslesen

rpi.io.L_N_A1_U_L1_N.replace_io("l_n_a1_u_l1_n", "f")
print(rpi.io.l_n_a1_u_l1_n.value)

#!/usr/bin/python3

import fcntl
import struct
import time
import numpy as np
import math



f = open("/dev/piControl0","wb+",0);

def filterNan(value):
    
    if math.isnan(value)== False:
         return value


def readFloat32(offset): 

    f.seek(offset);
    x = f.read(2);
    print(x)
    a = struct.unpack('<H',x)
    print(a)
    byte0 = np.int_(a[0]);

    f.seek(offset+2);
    x = f.read(2);
    b = struct.unpack('<H',x);
    byte1 = np.int_(b[0]);
    
    volt = floatConverter(inputArray = [byte0, byte1]);
    
    return volt


def floatConverter(inputArray):
    int32Val = np.int_(inputArray[1] + (inputArray[0] << 16)); 
    newFloat = struct.unpack('f', struct.pack('i', int32Val))[0]
    return newFloat

L_N_A2_U_L1_N = (readFloat32(802))
L_N_A2_U_L2_N = (readFloat32(806))
L_N_A2_U_L3_N = (readFloat32(810))
L_N_A2_U_L1_L2 = (readFloat32(814))
L_N_A2_U_L2_L3 = (readFloat32(818))
L_N_A2_U_L3_L1 = (readFloat32(822))
L_N_A2_I_L1 = (readFloat32(826))
L_N_A2_I_L2 = (readFloat32(830))
L_N_A2_I_L3 = (readFloat32(834))
L_N_A2_S_L1 = (readFloat32(838))
L_N_A2_S_L2 = (readFloat32(842))
L_N_A2_S_L3 = (readFloat32(846))
L_N_A2_P_L1 = (readFloat32(850))
L_N_A2_P_L2 = (readFloat32(854))
L_N_A2_P_L3 = (readFloat32(858))
L_N_A2_Q_L1 = (readFloat32(862))

# -*- coding: utf-8 -*-
"""
Viele Modbuswerte vereinfacht lesen.

In piCtory ist auf einem Modbus Master Modul eine Aktion hinterlegt:
Action ID | Unit ID |    Function Code       | Register Addr. | Quantity of Reg. | Action Int. | Device Value
   1      |    1    | READ_HOLDING_REGISTERS |        2       |         32       |    900      | Input_Word_1

Diese Aktion holt 32 Wörter = 64 Bytes von einem Modbus-Teilnehmer und setzt diesen Wert bei Input_Word_1 ein. Da
dieser Input nur 1 Wort = 2 Byte lang ist, werden die nachfolgenden Inputs von dieser Aktion auch überschrieben,
aber nicht gelöscht.

Die Werte von dem Modbus-Teilnehmer sind 16 float-Werte (4 Byte pro Wert).
"""
import revpimodio2
import struct


def cycle(ct):
    """
    Zyklusfunktion für Demonstration.

    Zu Beginn des Zyklus werden die 16 float-Werte aus den 64 Bytes entpackt
    und stehen als <class 'tuple'> zur Verfügung. Danach weisen wir diese
    unseren "richtigen" Variablen hinzu.
    """

    # Die 64 Byte in 16 float-Werte entpacken
    my_floats = struct.unpack("16f", rpi.io.all_float_values.value)

    # Werte des Tuples können nun frei verwendet werden
    L_N_A2_U_L1_N = my_floats[0]
    L_N_A2_U_L2_N = my_floats[1]
    L_N_A2_U_L3_N = my_floats[2]
    L_N_A2_U_L1_L2 = my_floats[3]
    L_N_A2_U_L2_L3 = my_floats[4]
    L_N_A2_U_L3_L1 = my_floats[5]
    L_N_A2_I_L1 = my_floats[6]
    L_N_A2_I_L2 = my_floats[7]
    L_N_A2_I_L3 = my_floats[8]
    L_N_A2_S_L1 = my_floats[9]
    L_N_A2_S_L2 = my_floats[10]
    L_N_A2_S_L3 = my_floats[11]
    L_N_A2_P_L1 = my_floats[12]
    L_N_A2_P_L2 = my_floats[13]
    L_N_A2_P_L3 = my_floats[14]
    L_N_A2_Q_L1 = my_floats[15]

    # Zum Testen einfach ausgeben:
    print("L_N_A2_U_L1_N", L_N_A2_U_L1_N)
    print("L_N_A2_U_L2_N", L_N_A2_U_L2_N)
    print("L_N_A2_U_L3_N", L_N_A2_U_L3_N)
    print("L_N_A2_U_L1_L2", L_N_A2_U_L1_L2)
    print("L_N_A2_U_L2_L3", L_N_A2_U_L2_L3)
    print("L_N_A2_U_L3_L1", L_N_A2_U_L3_L1)
    print("L_N_A2_I_L1", L_N_A2_I_L1)
    print("L_N_A2_I_L2", L_N_A2_I_L2)
    print("L_N_A2_I_L3", L_N_A2_I_L3)
    print("L_N_A2_S_L1", L_N_A2_S_L1)
    print("L_N_A2_S_L2", L_N_A2_S_L2)
    print("L_N_A2_S_L3", L_N_A2_S_L3)
    print("L_N_A2_P_L1", L_N_A2_P_L1)
    print("L_N_A2_P_L2", L_N_A2_P_L2)
    print("L_N_A2_P_L3", L_N_A2_P_L3)
    print("L_N_A2_Q_L1", L_N_A2_Q_L1)


rpi = revpimodio2.RevPiModIO(autorefresh=True)
rpi.handlesignalend()

# Wir verwenden "s64", was diesen IO zu einem reinen, 64 byte langen <class 'bytes'> IO macht!
rpi.io.Input_Word_1.replace_io("all_float_values", "64s")

# Zyklusfunktion starten mit 1000 ms Zukluszeit
rpi.cycleloop(cycle, cycletime=1000)