clk added

clk/CLK.py

+from . import Vars
+import numpy as np
+import logging
+#from .spibitbang1 import *
+import threading
+
+
+def ApplyMask(value,width=8,bitoffset=0,previous=0):
+    mask=(1<<width)-1
+    if bitoffset>0:
+      value<<=bitoffset;
+      mask<<=bitoffset;
+    return (value & mask) + (previous - (previous & mask));
+def UnMask(value,width=8,bitoffset=0):
+    mask=(1<<width)-1
+    if bitoffset>0:
+      value>>=bitoffset;
+    value=value&mask;
+    return value;
+
+def bytes2int(bts):
+   x=0;
+   for b in bts:
+     x=x*256+b;
+   return x;
+def int2bytes(i):
+   b=[];
+   while i>255: 
+        b=[i%256]+b;
+        i>>=8;
+   return [i]+b;
+
+class RCU1():
+    def __init__(self,number,I2Ccallback,Switchcallback):
+        self.N=number;
+        self.I2Ccallback=I2Ccallback
+        self.SWcallback=Switchcallback
+        self.previous=np.zeros([number,Vars.RCU_storeReg],dtype='int')
+
+    def load(self):
+        Inst1=Vars.Instr(Vars.DevType.Instr,Vars.RCU_init,0,[])  #Read the current status of GPIO IOs
+        self.SetVar(Inst1)
+      
+#Vars.RCU_mask.OPCW.get_data_value().Value.Value=[1,1,0,0]
+#Vars.Ant_mask.OPCW.get_data_value().Value.Value=[1,1,0,0,0,0,0,0,0,0,1,0]
+
+#Inst1=Vars.Instr(Vars.DevType.Instr,Vars.RCU_init,0,[])  #Read the current status of GPIO IOs
+#RCU.SetVar(Inst1)
+
+#Inst1=Vars.Instr(Vars.DevType.Var,Vars.RCU_att,12,[0,1,2,3,4,5,6,7,8,9,11])
+#RCU.SetVar(Inst1)
+
+#Inst1=Vars.Instr(Vars.DevType.Instr,Vars.RCU_off,0,[])
+#RCU.SetVar(Inst1)
+
+#Inst1=Vars.Instr(Vars.DevType.Instr,Vars.RCU_on,0,[])
+#RCU.SetVar(Inst1)
+
+#Inst1=Vars.Instr(Vars.DevType.Instr,Vars.ADC1_on,0,[])
+#RCU.SetVar(Inst1)
+
+#print(Vars.RCU)
+
+    def SetVar(self,Instr):
+        if Instr.type==Vars.DevType.Instr:
+              #Execute instructions
+              Iset=Instr.dev;
+              for i in Iset.instr:
+                  logging.debug(str(("Inst",i)))
+                  self.SetVar(i)
+              return;
+        if Instr.type in [Vars.DevType.I2C,Vars.DevType.SPIbb,Vars.DevType.I2Cbb]:
+            RCU0=-1;
+            mask=0
+            for RCUi in range(self.N):
+                      mask|=1<<Vars.RCU_MPaddr.Switch[RCUi]
+                      if RCU0<0: RCU0=RCUi;
+            if RCU0<0: return; #Mask all zero
+            self.SWcallback(mask)
+            if Instr.type==Vars.DevType.I2C:
+              logging.info(str(('** Set I2C:',Instr.dev,Instr.value)))
+              self.SetI2C(RCU0,Instr.dev,8,0,Instr.value)
+              return;
+            elif Instr.type==Vars.DevType.SPIbb:
+              logging.debug(str(('** Set SPIbb:',Instr.dev,Instr.value)))
+              SetSPIbb(self.SetI2C,RCU0,Instr.dev,Instr.value)
+              return;
+            elif Instr.type==Vars.DevType.I2Cbb:
+              logging.info(str(('** Set I2Cbb:',Instr.dev,Instr.value)))
+#              self.SetI2C(RCUi,Instr.dev,8,0,Instr.value)
+              return;
+        V1=Instr.dev
+        if not((Instr.nvalue==V1.nVars) and (Instr.type==Vars.DevType.VarUpdate)) and not(Instr.nvalue==V1.nVars*self.N):
+             logging.error("Wrong size of value")
+             return False
+        if V1.Vars[0].type==Vars.DevType.Internal:
+          Instr.dev.OPCW.get_data_value().Value.Value=Instr.value
+          logging.debug("Update internal variable")
+          return
+#        if V1.Vars[0].type==Vars.DevType.Internal: return;
+        Step=V1.nVars
+        value1=Instr.value if V1.OPCR is None else V1.OPCR.get_data_value().Value.Value
+        if (len(value1)==V1.nVars) and (self.N>1):  value1=(value1*self.N);
+        if Instr.type==Vars.DevType.Var:
+          logging.info(str(('** Set Var:',V1.name,value1)))
+          for RCUi in range(self.N):
+            for Vari in range(Step):
+                self.SetVarValue(RCUi,V1.Vars[Vari],Instr.value[RCUi*Step+Vari:RCUi*Step+Vari+1])
+                value2=value1[RCUi*Step+Vari:RCUi*Step+Vari+1]
+                self.GetVarValue(RCUi,V1.Vars[Vari],value2)
+                value1[RCUi*Step+Vari:RCUi*Step+Vari+1]=value2
+          if not(V1.OPCR is None): V1.OPCR.get_data_value().Value.Value=value1
+
+        elif Instr.type==Vars.DevType.VarUpdate:
+          self.GetVarValueAll(V1,value1)
+          if not(V1.OPCR is None): V1.OPCR.get_data_value().Value.Value=value1
+#          V1.OPCR.get_data_value().Value.Value=value1
+
+        logging.info(str(('** Readback:',V1.name,value1)))
+
+    def GetVarValue(self,RCUi,var,value):
+            logging.info(str(("RCU1 Get ",RCUi,var,value)))
+            if var.type==Vars.DevType.I2C:
+                self.SWcallback(1<<Vars.RCU_MPaddr.Switch[RCUi])
+                self.GetI2C(RCUi,var.devreg,var.width,var.bitoffset,value)
+            elif var.type==Vars.DevType.I2Cbb:
+                logging.error("I2Cbb Implemented")
+            elif var.type==Vars.DevType.SPIbb:
+                logging.error("SPIbb Implemented")
+            else:
+                logging.error("Not Implemented")
+
+    def GetVarValueAll(self,V1,value1):
+            mask=0;
+            for RCUi in range(self.N):
+                mask|=1<<Vars.RCU_MPaddr.Switch[RCUi]
+            Step=V1.nVars
+            if V1.Vars[0].type==Vars.DevType.I2C:
+              for Vari in range(Step):  
+                DevReg=V1.Vars[Vari].devreg
+                self.SWcallback(mask)
+                self.SetI2CAddr(self,DevReg)
+                if DevReg.Register_R>255: self.I2Ccallback(DevReg.Addr,[250],read=3) #Wait for ADC
+                for RCUi in range(self.N):
+                    self.SWcallback(1<<Vars.RCU_MPaddr.Switch[RCUi])
+                    value2=value1[RCUi*Step+Vari:RCUi*Step+Vari+1]
+                    var=V1.Vars[Vari]
+                    self.GetI2Cnoreg(RCUi,var.devreg,var.width,var.bitoffset,value2)
+                    if (var.Scale!=0): value2[0]*=var.Scale;
+                    value1[RCUi*Step+Vari:RCUi*Step+Vari+1]=value2
+            elif V1.Vars[0].type==Vars.DevType.SPIbb:
+              self.GetBBValueAll(V1,value1,mask)
+#              logging.info("SPIbb all not implemented yet")
+            else:
+               logging.error("Type not implemented")
+    def GetBBValueAll(self,V1,value1,mask):
+        def SetBit(RCUi,dev,width,bitoffset,value,buffer=False):
+            if not(buffer): self.SWcallback(mask)
+            self.SetI2C(RCUi,dev,width,bitoffset,value,buffer=buffer)
+        def GetBit(RCUixx,dev,width,bitoffset,buffer=False):
+            value=[0 for RCUi in range(self.N)]
+            value2=[0]
+            if buffer: 
+                for RCUi in range(self.N):
+                  self.GetI2Cbuffer(RCUi,dev,width,bitoffset,value2)
+                  value[RCUi]=value2[0]
+                return value
+            self.SWcallback(mask)
+            self.SetI2CAddr(self,dev)
+            for RCUi in range(self.N):
+                self.SWcallback(1<<Vars.RCU_MPaddr.Switch[RCUi])
+                self.GetI2Cnoreg(RCUi,dev,width,bitoffset,value2)
+                value[RCUi]=value2[0]
+            return value;
+        devs=[V1.Vars[Vari].devreg for Vari in range(V1.nVars)]
+        GetSPIbb2(SetBit,GetBit,0,devs,value1)
+
+
+    def SetVarValue(self,RCUi,var,value):
+            if var.devreg.Register_W==-1: return True; #We can not set it, only read it e.g. temperature
+            logging.debug(str(("RCU1 Set ",RCUi,var,value)))
+            if var.type==Vars.DevType.I2C:
+                self.SWcallback(1<<Vars.RCU_MPaddr.Switch[RCUi])
+                self.SetI2C(RCUi,var.devreg,var.width,var.bitoffset,value)
+            elif var.type==Vars.DevType.I2Cbb:
+                logging.error("I2Cbb Implemented")
+            elif var.type==Vars.DevType.SPIbb:
+                logging.error("SPIbb Implemented")
+            else:
+                logging.error("Not Implemented")
+
+    def SetI2C(self,RCUi,dev,width,bitoffset,value,buffer=False):
+        if dev.store>0:
+            previous=self.previous[RCUi,dev.store-1];
+            value[0]=ApplyMask(value[0],width,bitoffset,previous);
+            self.previous[RCUi,dev.store-1]=value[0]
+#            logging.debug(str(('masked to',value)))
+#            logging.debug(str(("Store buffer",RCUi,dev.store,value[0])))
+        if buffer: return True;
+        return self.I2Ccallback(dev.Addr,value,reg=dev.Register_W)
+
+    def GetI2Cbuffer(self,RCUi,dev,width,bitoffset,value):
+        if not(dev.store>0): return False;
+        value[0]=self.previous[RCUi,dev.store-1];
+#        logging.debug(str(("GetI2Cbuffer",RCUi,dev.store,value)))
+        l1=int(np.floor((width+bitoffset+7)/8))
+        if (width!=l1*8) or (bitoffset>0): 
+            value[0]=UnMask(value[0],width,bitoffset)      
+        return True
+
+    def GetI2C(self,RCUi,dev,width,bitoffset,value):
+#        if dev.store>0:
+#            value[0]=self.previous[RCUi,dev.store-1]
+#        return True          
+        l1=int(np.floor((width+bitoffset+7)/8))
+#        print(width,bitoffset,l1)
+        makesinglevalue=((len(value)==1) and (l1>1));
+        if makesinglevalue: value2=[0 for x in range(l1)]
+        else: value2=value
+        reg=dev.Register_R
+        if reg>255: #This is for the monitor ADC
+          if not(self.I2Ccallback(dev.Addr,int2bytes(reg),read=2)): return False;
+          I2Ccallback(Addr,[250],read=3)
+          if not(self.I2Ccallback(dev.Addr,value2,read=1)): return False;
+        else:
+          if not(self.I2Ccallback(dev.Addr,value2,reg=reg,read=1)): return False;
+        if value2[0] is None:  return False
+        if makesinglevalue: value[0]=bytes2int(value2)
+        else: value[:]=value2[:];
+        if dev.store>0:
+            self.previous[RCUi,dev.store-1]=value[0]
+#            logging.debug(str(("Store buffer",RCUi,dev.store,value[0])))
+        if (width!=l1*8) or (bitoffset>0): 
+            value[0]=UnMask(value[0],width,bitoffset)      
+        else: value[0]=value2[0]
+        return True;
+    def GetI2Cbit(self,RCUi,dev,pin):
+           value2=[value]
+           self.I2CGet(RCUi,dev,1,1<<pin,value2)
+           return value2[0]
+
+
+    def SetI2CAddr(self,RCUi,dev):
+        return self.I2Ccallback(dev.Addr,int2bytes(dev.Register_R),read=2)
+
+
+
+    def GetI2Cnoreg(self,RCUi,dev,width,bitoffset,value):
+        l1=int(np.floor((width+bitoffset+7)/8))
+        makesinglevalue=((len(value)==1) and (l1>1));
+        if makesinglevalue: value2=[0 for x in range(l1)]
+        else: value2=value
+        reg=dev.Register_R
+        if not(self.I2Ccallback(dev.Addr,value2,read=1)): return False;
+        if value2[0] is None:  return False
+        if makesinglevalue: value[0]=bytes2int(value2)
+        else: value[:]=value2[:];
+        if dev.store>0:
+            self.previous[RCUi,dev.store-1]=value[0]
+#            logging.debug(str(("Store buffer",RCUi,dev.store,value[0])))
+        if (width!=l1*8) or (bitoffset>0): 
+            value[0]=UnMask(value[0],width,bitoffset)      
+        #else: value[0]=value2[0]
+        return True;
+
+    def start(self,Q1):
+      def RCUthread(Q1):
+         while True:
+           item = Q1.get()
+           if item is None: break;
+           self.SetVar(item)
+         logging.info("End RCU thread")
+
+      RCUthread1 = threading.Thread(target=RCUthread, args=(Q1,))
+      RCUthread1.start()
+      
+      return RCUthread1 
+ 
+#    def Queue_Monitor(self,Q1):
+#         Inst1=Vars.Instr(Vars.DevType.VarUpdate,Vars.RCU_temp,32,[0]*32)
+#         Q1.put(Inst1)
+#         Inst1=Vars.Instr(Vars.DevType.VarUpdate,Vars.RCU_ADC_lock,96,[0]*96)
+#         Q1.put(Inst1)
+
+
+    def AddVars(self,Q1,AddVarR,AddVarW):
+     for v in Vars.OPC_devvars:
+        dim=Vars.RCU_MPaddr.nI2C*Vars.RCU_MPaddr.nSwitch*v.nVars
+        varvalue2=(dim*[0.0] if v.type==Vars.datatype.dfloat else dim*[0])
+        if v.RW in [Vars.RW.ReadOnly,Vars.RW.ReadWrite]:
+            var1=AddVarR(v.name+"_R",varvalue2,v)
+            v.OPCR=var1
+            Inst=Vars.Instr(Vars.DevType.VarUpdate,v,dim,varvalue2)
+            Q1.put(Inst)
+
+        if v.RW in [Vars.RW.WriteOnly,Vars.RW.ReadWrite]:
+            var1=AddVarW(v.name+"_RW",varvalue2,v,Q1)
+            v.OPCW=var1
+
+    def AddMethod(self,Q1,Addmethod):
+      for v in Vars.OPC_methods:
+        Inst1=Vars.Instr(Vars.DevType.Instr,v,0,[])
+        Addmethod(v.name,Inst1,Q1)

clk/HWconf.py

+#from collections import namedtuple
+#from enum import Enum
+from pcctypes import *
+
+#Mid plane address
+RCU_MPaddr=MPaddr(1,[1],1,[7])
+
+CLK_IO3_OUT1=DevReg(0x20,0,2,1)
+CLK_IO3_OUT2=DevReg(0x20,1,3,2)
+CLK_IO3_CONF1=DevReg(0x20,6,6,3)
+CLK_IO3_CONF2=DevReg(0x20,7,7,4)
+
+RCU_storeReg=4; #Number of stored registers

clk/Vars.py

+from .HWconf import *
+
+CLK_IGNORE_PPS= VarArray("CLK_Ignore_PPS",1,[Var2dev("",I2Cmodules.CLK,DevType.I2C,CLK_IO3_OUT1,1 ,6,1)],RW.ReadOnly,datatype.dInt,None,None)
+CLK_Enable_PWR= VarArray("CLK_Enable_PWR",1,[Var2dev("",I2Cmodules.CLK,DevType.I2C,CLK_IO3_OUT1,1 ,7,1)],RW.ReadOnly,datatype.dInt,None,None)
+CLK_Stat1     = VarArray("CLK_Stat"      ,1,[Var2dev("",I2Cmodules.CLK,DevType.I2C,CLK_IO3_OUT1,1 ,4,1)],RW.ReadOnly,datatype.dInt,None,None)
+
+OPC_devvars=[CLK_IGNORE_PPS,CLK_Enable_PWR,CLK_Stat1]
+
+RCU_init=Instrs("ReadRegisters",2,[
+   Instr(DevType.VarUpdate,CLK_IGNORE_PPS,1,[0]),
+   Instr(DevType.VarUpdate,CLK_Enable_PWR,1,[0])
+])
+
+CLK_on=Instrs("CLK_on",2,[
+   Instr(DevType.I2C,CLK_IO3_CONF1,1,[0x2C]),
+   Instr(DevType.I2C,CLK_IO3_OUT1 ,1,[0x42]),
+])
+
+CLK_off=Instrs("CLK_off",2,[
+   Instr(DevType.I2C,CLK_IO3_CONF1,1,[0x2C]),
+   Instr(DevType.I2C,CLK_IO3_OUT1 ,1,[0x40]),
+])
+
+OPC_methods=[CLK_on]

pcctypes.py

+#For capnproto
+from collections import namedtuple
+from enum import Enum
+from recordclass import recordclass
+
+MPaddr=namedtuple("MPaddr","nI2C I2C nSwitch Switch"); 
+DevReg=namedtuple("DevReg","Addr Register_R Register_W store"); 
+BBdev=namedtuple("BBdev","nPins devs pins addr")
+
+class I2Cmodules(Enum):
+   Switch = 0
+   RCU = 1
+   CLK = 2
+   UNB2 = 3
+
+class DevType(Enum):
+    Var = 0
+    I2C  = 1
+    SPIbb= 2
+    I2Cbb= 3
+    Instr =4
+    VarUpdate = 5
+    Internal = 6
+
+class RW(Enum):
+    Hidden = 0  #Not an OPC_UA variable
+    ReadOnly = 1  #OPC_variable name_R
+    WriteOnly = 2 #OPC_variable name_RW
+    ReadWrite = 3  #both of above
+
+class datatype(Enum):
+   dInt = 0
+   dfloat = 1
+
+Var2dev=namedtuple("Var2dev","name module type devreg width bitoffset Scale")
+VarArray=recordclass("VarArray","name nVars Vars RW type OPCR OPCW") #OPCR and OPCW linked at runtime
+
+Instr=namedtuple("DevInstr","type dev nvalue value")
+Instrs=namedtuple("Instr","name ninstr instr")

pypcc2.py

@@ -4,6 +4,7 @@ try:
 except ImportError:
  import Queue as queue;
 from rcu import RCU
+from clk import CLK
 from i2c import I2Cswitch1
 import threading
 import signal
@@ -32,7 +33,8 @@ else:
     from i2c import I2C
 
 #Queue used to pass instructions from opc-ua server to RCU
-Q1=queue.Queue()
+Q1=queue.Queue() #RCUs
+Q2=queue.Queue() #CLK
 
 #Setup OPCUA server (running in its own thread)
 opcuaserv.InitServer(port=args.port)
@@ -41,12 +43,15 @@ logging.info("OPC-UA Server started")
 SW1=I2Cswitch1.I2Cswitch1(I2C.I2C1server)
 
 RCU=RCU.RCU1(32,I2C.I2C1server,SW1.SetChannel)
-
 RCU.AddVars(Q1,opcuaserv.AddVarR,opcuaserv.AddVarW)
 RCU.AddMethod(Q1,opcuaserv.Addmethod)
-
 RCU.load() #Load current register values from HW
 
+#CLK=CLK.RCU1(1,I2C.I2C1server,SW1.SetChannel)
+#CLK.AddVars(Q2,opcuaserv.AddVarR,opcuaserv.AddVarW)
+#CLK.AddMethod(Q2,opcuaserv.Addmethod)
+#CLK.load() #Load current register values from HW
+
 #logging.debug(str(("I2C bytes=",I2C.I2Ccounter)))
 
 if False:
@@ -54,6 +59,7 @@ if False:
   exit()
 
 RCUthread1=RCU.start(Q1)
+#CLKthread1=CLK.start(Q2)
 
 RunTimer=True;
 def TimerThread(Q1,RCU):
@@ -80,6 +86,7 @@ Timerthread1.start()
 def signal_handler(sig, frame):
     logging.info('Stop RCU thread')
     Q1.put(None)
+    Q2.put(None)
     logging.info('Stop timer thread')
     global RunTimer; 
     RunTimer=False
@@ -96,4 +103,5 @@ finally:
         logging.info("Stop OPC-UA server")
         opcuaserv.server.stop()
         RCUthread1.join()
+#        CLKthread1.join()
         Timerthread1.join()

rcu/HWconf.py

-from collections import namedtuple
-from enum import Enum
-
+#from collections import namedtuple
+#from enum import Enum
+from pcctypes import *
 #Mid plane address
-MPaddr=namedtuple("MPaddr","nI2C I2C nSwitch Switch"); 
+#MPaddr=namedtuple("MPaddr","nI2C I2C nSwitch Switch"); 
 RCU_MPaddr=MPaddr(1,[1],32,[1,2,3,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5])
-CLK_MPaddr=MPaddr(1,[1],1,[7])
+#CLK_MPaddr=MPaddr(1,[1],1,[7])
 
-DevReg=namedtuple("DevReg","Addr Register_R Register_W store"); 
+#DevReg=namedtuple("DevReg","Addr Register_R Register_W store"); 
 #I2C:Addr=I2C addr (int)
 #BBdev: Addr=BBdev (pointer)
 
@@ -40,7 +40,7 @@ RCU_AN_Ch2=DevReg(0x14,0xB180,-1,0)
 RCU_AN_Temp=DevReg(0x14,0xA0C0,-1,0)
 
 #Bitbang devices
-BBdev=namedtuple("BBdev","nPins devs pins addr")
+#BBdev=namedtuple("BBdev","nPins devs pins addr")
 I2CBB_dth3=BBdev(3,[RCU_IO1_OUT1,RCU_IO2_OUT2,RCU_IO2_CONF2],[6,3,3],0x70); #SCL,SDIO,SDIOdir
 I2CBB_dth2=BBdev(3,[RCU_IO1_OUT2,RCU_IO2_OUT1,RCU_IO1_CONF1],[7,7,7],0x70);
 I2CBB_dth1=BBdev(3,[RCU_IO1_OUT2,RCU_IO2_OUT1,RCU_IO1_CONF1],[7,7,7],0x70);
@@ -83,11 +83,11 @@ RCU_Dth3_Prop =DevReg(I2CBB_dth3,0x11  ,0x11,0)
 RCU_Dth3_Start=DevReg(I2CBB_dth3,0x62  ,0x62,0) 
 RCU_Dth3_Stop =DevReg(I2CBB_dth3,0x67  ,0x67,0) 
 
-class DevType(Enum):
-    Var = 0
-    I2C  = 1
-    SPIbb= 2
-    I2Cbb= 3
-    Instr =4
-    VarUpdate = 5
-    Internal = 6
+#class DevType(Enum):
+#    Var = 0
+#    I2C  = 1
+#    SPIbb= 2
+#    I2Cbb= 3
+#    Instr =4
+#    VarUpdate = 5
+#    Internal = 6

rcu/RCU.py

@@ -126,7 +126,7 @@ class RCU1():
     def GetVarValue(self,RCUi,var,value):
             logging.info(str(("RCU1 Get ",RCUi,var,value)))
             if var.type==Vars.DevType.I2C:
-                self.SWcallback(1<<var.MPaddr.Switch[RCUi])
+                self.SWcallback(1<<Vars.RCU_MPaddr.Switch[RCUi])
                 self.GetI2C(RCUi,var.devreg,var.width,var.bitoffset,value)
             elif var.type==Vars.DevType.I2Cbb:
                 logging.error("I2Cbb Implemented")
@@ -138,7 +138,7 @@ class RCU1():
     def GetVarValueAll(self,V1,value1):
             mask=0;
             for RCUi in range(self.N):
-                mask|=1<<V1.Vars[0].MPaddr.Switch[RCUi]
+                mask|=1<<Vars.RCU_MPaddr.Switch[RCUi]
             Step=V1.nVars
             if V1.Vars[0].type==Vars.DevType.I2C:
               for Vari in range(Step):  
@@ -147,7 +147,7 @@ class RCU1():
                 self.SetI2CAddr(self,DevReg)
                 if DevReg.Register_R>255: self.I2Ccallback(DevReg.Addr,[250],read=3) #Wait for ADC
                 for RCUi in range(self.N):
-                    self.SWcallback(1<<V1.Vars[0].MPaddr.Switch[RCUi])
+                    self.SWcallback(1<<Vars.RCU_MPaddr.Switch[RCUi])
                     value2=value1[RCUi*Step+Vari:RCUi*Step+Vari+1]
                     var=V1.Vars[Vari]
                     self.GetI2Cnoreg(RCUi,var.devreg,var.width,var.bitoffset,value2)
@@ -173,7 +173,7 @@ class RCU1():
             self.SWcallback(mask)
             self.SetI2CAddr(self,dev)
             for RCUi in range(self.N):
-                self.SWcallback(1<<V1.Vars[0].MPaddr.Switch[RCUi])
+                self.SWcallback(1<<Vars.RCU_MPaddr.Switch[RCUi])
                 self.GetI2Cnoreg(RCUi,dev,width,bitoffset,value2)
                 value[RCUi]=value2[0]
             return value;
@@ -185,7 +185,7 @@ class RCU1():
             if var.devreg.Register_W==-1: return True; #We can not set it, only read it e.g. temperature
             logging.debug(str(("RCU1 Set ",RCUi,var,value)))
             if var.type==Vars.DevType.I2C:
-                self.SWcallback(1<<var.MPaddr.Switch[RCUi])
+                self.SWcallback(1<<Vars.RCU_MPaddr.Switch[RCUi])
                 self.SetI2C(RCUi,var.devreg,var.width,var.bitoffset,value)
             elif var.type==Vars.DevType.I2Cbb:
                 logging.error("I2Cbb Implemented")
@@ -290,7 +290,7 @@ class RCU1():
 
     def AddVars(self,Q1,AddVarR,AddVarW):
      for v in Vars.OPC_devvars:
-        dim=v.Vars[0].MPaddr.nI2C*v.Vars[0].MPaddr.nSwitch*v.nVars
+        dim=Vars.RCU_MPaddr.nI2C*Vars.RCU_MPaddr.nSwitch*v.nVars
         #print(v.name,dim)
         varvalue2=(dim*[0.0] if v.type==Vars.datatype.dfloat else dim*[0])
         if v.RW in [Vars.RW.ReadOnly,Vars.RW.ReadWrite]:

rcu/Vars.py

-from collections import namedtuple
+#from collections import namedtuple
 from recordclass import recordclass
-from enum import Enum
+#from enum import Enum
 from .HWconf import *
 
 #OPCUA variables
-class RW(Enum):
-    Hidden = 0  #Not an OPC_UA variable
-    ReadOnly = 1  #OPC_variable name_R
-    WriteOnly = 2 #OPC_variable name_RW
-    ReadWrite = 3  #both of above
-
-class datatype(Enum):
-   dInt = 0
-   dfloat = 1
-
-Var2dev=namedtuple("Var2dev","name MPaddr type devreg width bitoffset Scale")
-VarArray=recordclass("VarArray","name nVars Vars RW type OPCR OPCW") #OPCR and OPCW linked at runtime
-RCU_att1= Var2dev("RCU_att1" ,RCU_MPaddr,DevType.I2C,RCU_IO1_OUT1,5 ,0,1)
-RCU_att2= Var2dev("RCU_att2" ,RCU_MPaddr,DevType.I2C,RCU_IO1_OUT2,5 ,0,1)
-RCU_att3= Var2dev("RCU_att3" ,RCU_MPaddr,DevType.I2C,RCU_IO2_OUT1,5 ,0,1)
-RCU_band1=Var2dev("RCU_band1",RCU_MPaddr,DevType.I2C,RCU_IO2_OUT2,2 ,0,1)
-RCU_band2=Var2dev("RCU_band2",RCU_MPaddr,DevType.I2C,RCU_IO2_OUT2,2 ,2,1)
-RCU_band3=Var2dev("RCU_band3",RCU_MPaddr,DevType.I2C,RCU_IO2_OUT2,2 ,4,1)
-RCU_led0= Var2dev("RCU_led0" ,RCU_MPaddr,DevType.I2C,RCU_IO2_OUT2,2 ,6,1)
-RCU_pwrd1=Var2dev("RCU_pwrd1",RCU_MPaddr,DevType.I2C,RCU_IO2_OUT1,1 ,6,1)
-RCU_temp1=Var2dev("RCU_temp1",RCU_MPaddr,DevType.I2C,RCU_AN_Temp ,23,0,4.21e-3)
-
-dummy=Var2dev("Dummy",RCU_MPaddr,DevType.Internal,None,8,0,1)
+RCUmod=I2Cmodules.RCU
+
+#Var2dev=namedtuple("Var2dev","name MPaddr type devreg width bitoffset Scale")
+#VarArray=recordclass("VarArray","name nVars Vars RW type OPCR OPCW") #OPCR and OPCW linked at runtime
+RCU_att1= Var2dev("RCU_att1" ,RCUmod,DevType.I2C,RCU_IO1_OUT1,5 ,0,1)
+RCU_att2= Var2dev("RCU_att2" ,RCUmod,DevType.I2C,RCU_IO1_OUT2,5 ,0,1)
+RCU_att3= Var2dev("RCU_att3" ,RCUmod,DevType.I2C,RCU_IO2_OUT1,5 ,0,1)
+RCU_band1=Var2dev("RCU_band1",RCUmod,DevType.I2C,RCU_IO2_OUT2,2 ,0,1)
+RCU_band2=Var2dev("RCU_band2",RCUmod,DevType.I2C,RCU_IO2_OUT2,2 ,2,1)
+RCU_band3=Var2dev("RCU_band3",RCUmod,DevType.I2C,RCU_IO2_OUT2,2 ,4,1)
+RCU_led0= Var2dev("RCU_led0" ,RCUmod,DevType.I2C,RCU_IO2_OUT2,2 ,6,1)
+RCU_pwrd1=Var2dev("RCU_pwrd1",RCUmod,DevType.I2C,RCU_IO2_OUT1,1 ,6,1)
+RCU_temp1=Var2dev("RCU_temp1",RCUmod,DevType.I2C,RCU_AN_Temp ,23,0,4.21e-3)
+
+dummy=Var2dev("Dummy",RCUmod,DevType.Internal,None,8,0,1)
 
 
 Ant_mask=VarArray("Ant_mask"       ,3,[dummy,dummy,dummy]            ,RW.WriteOnly,datatype.dInt,None,None)
@@ -38,46 +30,46 @@ RCU_temp=VarArray("RCU_temperature",1,[RCU_temp1],RW.ReadOnly ,datatype.dfloat,N
 RCU_pwrd=VarArray("RCU_Pwr_dig"    ,1,[RCU_pwrd1],RW.ReadOnly ,datatype.dInt  ,None,None)
 RCU_LED =VarArray("RCU_LED0"       ,1,[RCU_led0] ,RW.ReadWrite,datatype.dInt  ,None,None)
 
-RCU_Dth3_freq=Var2dev("RCU_dth1_freq",RCU_MPaddr,DevType.I2Cbb,RCU_Dth3_Freq,32,0,1e-6)
-RCU_Dth2_freq=Var2dev("RCU_dth1_freq",RCU_MPaddr,DevType.I2Cbb,RCU_Dth2_Freq,32,0,1e-6)
-RCU_Dth1_freq=Var2dev("RCU_dth1_freq",RCU_MPaddr,DevType.I2Cbb,RCU_Dth1_Freq,32,0,1e-6)
+RCU_Dth3_freq=Var2dev("RCU_dth1_freq",RCUmod,DevType.I2Cbb,RCU_Dth3_Freq,32,0,1e-6)
+RCU_Dth2_freq=Var2dev("RCU_dth1_freq",RCUmod,DevType.I2Cbb,RCU_Dth2_Freq,32,0,1e-6)
+RCU_Dth1_freq=Var2dev("RCU_dth1_freq",RCUmod,DevType.I2Cbb,RCU_Dth1_Freq,32,0,1e-6)
 RCU_dth_freq=VarArray("RCU_dither_freq",3,[RCU_Dth1_freq,RCU_Dth2_freq,RCU_Dth3_freq],RW.ReadWrite,datatype.dfloat,None,None)
 
-RCU_ADC1_lock=Var2dev("RCU_ADC1_lock",RCU_MPaddr,DevType.SPIbb,RCU_ADC1_PLL_stat,8,0,1)
-RCU_ADC2_lock=Var2dev("RCU_ADC2_lock",RCU_MPaddr,DevType.SPIbb,RCU_ADC2_PLL_stat,8,0,1)
-RCU_ADC3_lock=Var2dev("RCU_ADC3_lock",RCU_MPaddr,DevType.SPIbb,RCU_ADC3_PLL_stat,8,0,1)
+RCU_ADC1_lock=Var2dev("RCU_ADC1_lock",RCUmod,DevType.SPIbb,RCU_ADC1_PLL_stat,8,0,1)
+RCU_ADC2_lock=Var2dev("RCU_ADC2_lock",RCUmod,DevType.SPIbb,RCU_ADC2_PLL_stat,8,0,1)
+RCU_ADC3_lock=Var2dev("RCU_ADC3_lock",RCUmod,DevType.SPIbb,RCU_ADC3_PLL_stat,8,0,1)
 RCU_ADC_lock=VarArray("RCU_ADC_lock",3,[RCU_ADC1_lock,RCU_ADC2_lock,RCU_ADC3_lock],RW.ReadOnly,datatype.dInt,None,None)
 
-RCU_ADC1_SYNC=Var2dev("RCU_ADC1_SYNC",RCU_MPaddr,DevType.SPIbb,RCU_ADC1_SYNC_ctr,8,0,1)
-RCU_ADC2_SYNC=Var2dev("RCU_ADC2_SYNC",RCU_MPaddr,DevType.SPIbb,RCU_ADC2_SYNC_ctr,8,0,1)
-RCU_ADC3_SYNC=Var2dev("RCU_ADC3_SYNC",RCU_MPaddr,DevType.SPIbb,RCU_ADC3_SYNC_ctr,8,0,1)
+RCU_ADC1_SYNC=Var2dev("RCU_ADC1_SYNC",RCUmod,DevType.SPIbb,RCU_ADC1_SYNC_ctr,8,0,1)
+RCU_ADC2_SYNC=Var2dev("RCU_ADC2_SYNC",RCUmod,DevType.SPIbb,RCU_ADC2_SYNC_ctr,8,0,1)
+RCU_ADC3_SYNC=Var2dev("RCU_ADC3_SYNC",RCUmod,DevType.SPIbb,RCU_ADC3_SYNC_ctr,8,0,1)
 RCU_ADC_SYNC=VarArray("RCU_ADC_SYNC",3,[RCU_ADC1_SYNC,RCU_ADC2_SYNC,RCU_ADC3_SYNC],RW.ReadOnly,datatype.dInt,None,None)
 
-RCU_ADC1_JESD=Var2dev("RCU_ADC1_SYNC",RCU_MPaddr,DevType.SPIbb,RCU_ADC1_JESD_ctr,8,0,1)
-RCU_ADC2_JESD=Var2dev("RCU_ADC2_SYNC",RCU_MPaddr,DevType.SPIbb,RCU_ADC2_JESD_ctr,8,0,1)
-RCU_ADC3_JESD=Var2dev("RCU_ADC3_SYNC",RCU_MPaddr,DevType.SPIbb,RCU_ADC3_JESD_ctr,8,0,1)
+RCU_ADC1_JESD=Var2dev("RCU_ADC1_SYNC",RCUmod,DevType.SPIbb,RCU_ADC1_JESD_ctr,8,0,1)
+RCU_ADC2_JESD=Var2dev("RCU_ADC2_SYNC",RCUmod,DevType.SPIbb,RCU_ADC2_JESD_ctr,8,0,1)
+RCU_ADC3_JESD=Var2dev("RCU_ADC3_SYNC",RCUmod,DevType.SPIbb,RCU_ADC3_JESD_ctr,8,0,1)
 RCU_ADC_JESD=VarArray("RCU_ADC_JESD",3,[RCU_ADC1_JESD,RCU_ADC2_JESD,RCU_ADC3_JESD],RW.ReadOnly,datatype.dInt,None,None)
 
-RCU_ADC1_CML=Var2dev("RCU_ADC1_SYNC",RCU_MPaddr,DevType.SPIbb,RCU_ADC1_CML_level,8,0,1)
-RCU_ADC2_CML=Var2dev("RCU_ADC2_SYNC",RCU_MPaddr,DevType.SPIbb,RCU_ADC2_CML_level,8,0,1)
-RCU_ADC3_CML=Var2dev("RCU_ADC3_SYNC",RCU_MPaddr,DevType.SPIbb,RCU_ADC3_CML_level,8,0,1)
+RCU_ADC1_CML=Var2dev("RCU_ADC1_SYNC",RCUmod,DevType.SPIbb,RCU_ADC1_CML_level,8,0,1)
+RCU_ADC2_CML=Var2dev("RCU_ADC2_SYNC",RCUmod,DevType.SPIbb,RCU_ADC2_CML_level,8,0,1)
+RCU_ADC3_CML=Var2dev("RCU_ADC3_SYNC",RCUmod,DevType.SPIbb,RCU_ADC3_CML_level,8,0,1)
 RCU_ADC_CML=VarArray("RCU_ADC_CML",3,[RCU_ADC1_CML,RCU_ADC2_CML,RCU_ADC3_CML],RW.ReadOnly,datatype.dInt,None,None)
 
 
-RCU_IO1_1= Var2dev("" ,RCU_MPaddr,DevType.I2C,RCU_IO1_OUT1,8,0,1)
-RCU_IO1_2= Var2dev("" ,RCU_MPaddr,DevType.I2C,RCU_IO1_OUT2,8,0,1)
-#RCU_IO1_3= Var2dev("" ,RCU_MPaddr,DevType.I2C,RCU_IO1_CONF1,8,0,1)
-#RCU_IO1_4= Var2dev("" ,RCU_MPaddr,DevType.I2C,RCU_IO1_CONF2,8,0,1)
+RCU_IO1_1= Var2dev("" ,RCUmod,DevType.I2C,RCU_IO1_OUT1,8,0,1)
+RCU_IO1_2= Var2dev("" ,RCUmod,DevType.I2C,RCU_IO1_OUT2,8,0,1)
+#RCU_IO1_3= Var2dev("" ,RCUmod,DevType.I2C,RCU_IO1_CONF1,8,0,1)
+#RCU_IO1_4= Var2dev("" ,RCUmod,DevType.I2C,RCU_IO1_CONF2,8,0,1)
 #RCU_IO1=VarArray("RCU_IO1",3,[RCU_IO1_1,RCU_IO1_2,RCU_IO1_3],RW.ReadOnly,datatype.dInt,None,None)
-RCU_IO2_1= Var2dev("" ,RCU_MPaddr,DevType.I2C,RCU_IO2_OUT1,8,0,1)
-RCU_IO2_2= Var2dev("" ,RCU_MPaddr,DevType.I2C,RCU_IO2_OUT2,8,0,1)
-#RCU_IO2_3= Var2dev("" ,RCU_MPaddr,DevType.I2C,RCU_IO2_CONF1,8,0,1)
-#RCU_IO2_4= Var2dev("" ,RCU_MPaddr,DevType.I2C,RCU_IO2_CONF2,8,0,1)
+RCU_IO2_1= Var2dev("" ,RCUmod,DevType.I2C,RCU_IO2_OUT1,8,0,1)
+RCU_IO2_2= Var2dev("" ,RCUmod,DevType.I2C,RCU_IO2_OUT2,8,0,1)
+#RCU_IO2_3= Var2dev("" ,RCUmod,DevType.I2C,RCU_IO2_CONF1,8,0,1)
+#RCU_IO2_4= Var2dev("" ,RCUmod,DevType.I2C,RCU_IO2_CONF2,8,0,1)
 #RCU_IO2=VarArray("RCU_IO2",3,[RCU_IO2_1,RCU_IO2_2,RCU_IO2_3],RW.ReadOnly,datatype.dInt,None,None)
-RCU_IO3_1= Var2dev("" ,RCU_MPaddr,DevType.I2C,RCU_IO3_OUT1,8,0,1)
-RCU_IO3_2= Var2dev("" ,RCU_MPaddr,DevType.I2C,RCU_IO3_OUT2,8,0,1)
-#RCU_IO3_3= Var2dev("" ,RCU_MPaddr,DevType.I2C,RCU_IO3_CONF1,8,0,1)
-#RCU_IO3_4= Var2dev("" ,RCU_MPaddr,DevType.I2C,RCU_IO3_CONF2,8,0,1)
+RCU_IO3_1= Var2dev("" ,RCUmod,DevType.I2C,RCU_IO3_OUT1,8,0,1)
+RCU_IO3_2= Var2dev("" ,RCUmod,DevType.I2C,RCU_IO3_OUT2,8,0,1)
+#RCU_IO3_3= Var2dev("" ,RCUmod,DevType.I2C,RCU_IO3_CONF1,8,0,1)
+#RCU_IO3_4= Var2dev("" ,RCUmod,DevType.I2C,RCU_IO3_CONF2,8,0,1)
 #RCU_IO3=VarArray("RCU_IO3",3,[RCU_IO3_1,RCU_IO3_2,RCU_IO3_3],RW.ReadOnly,datatype.dInt,None,None)
 
 RCU_OUT1=VarArray("RCU_OUT1",3,[RCU_IO1_1,RCU_IO2_1,RCU_IO3_1],RW.ReadOnly,datatype.dInt,None,None)
@@ -94,10 +86,10 @@ OPC_devvars=[RCU_mask,Ant_mask,RCU_att,RCU_band,RCU_temp,RCU_pwrd,RCU_LED,RCU_AD
 
 
 
-Instr=namedtuple("DevInstr","type dev nvalue value")
+#Instr=namedtuple("DevInstr","type dev nvalue value")
+#Instrs=namedtuple("Instr","name ninstr instr")
 
 #OPCUA methods
-Instrs=namedtuple("Instr","name ninstr instr")
 
 RCU_init=Instrs("ReadRegisters",2,[
    Instr(DevType.VarUpdate,RCU_OUT1,3,[0,0,0]),