From 008302ff8f7411d7b0b07607166d654cf29bd0c5 Mon Sep 17 00:00:00 2001
From: kruger <kruger@astron.nl>
Date: Tue, 12 Jan 2021 16:55:25 +0100
Subject: [PATCH] clk added
---
clk/CLK.py | 303 ++++++++++++++++++++++++++++++++++++++++++++++++++
clk/HWconf.py | 13 +++
clk/Vars.py | 24 ++++
pcctypes.py | 39 +++++++
pypcc2.py | 14 ++-
rcu/HWconf.py | 30 ++---
rcu/RCU.py | 12 +-
rcu/Vars.py | 100 ++++++++---------
8 files changed, 457 insertions(+), 78 deletions(-)
create mode 100644 clk/CLK.py
create mode 100644 clk/HWconf.py
create mode 100644 clk/Vars.py
create mode 100644 pcctypes.py
diff --git a/clk/CLK.py b/clk/CLK.py
new file mode 100644
index 0000000..a7dee31
--- /dev/null
+++ b/clk/CLK.py
@@ -0,0 +1,303 @@
+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)
diff --git a/clk/HWconf.py b/clk/HWconf.py
new file mode 100644
index 0000000..95060df
--- /dev/null
+++ b/clk/HWconf.py
@@ -0,0 +1,13 @@
+#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
diff --git a/clk/Vars.py b/clk/Vars.py
new file mode 100644
index 0000000..35d7660
--- /dev/null
+++ b/clk/Vars.py
@@ -0,0 +1,24 @@
+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]
diff --git a/pcctypes.py b/pcctypes.py
new file mode 100644
index 0000000..8669628
--- /dev/null
+++ b/pcctypes.py
@@ -0,0 +1,39 @@
+#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")
diff --git a/pypcc2.py b/pypcc2.py
index de1112f..ab54a2a 100644
--- a/pypcc2.py
+++ b/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()
diff --git a/rcu/HWconf.py b/rcu/HWconf.py
index 25c10af..0b00a7f 100644
--- a/rcu/HWconf.py
+++ b/rcu/HWconf.py
@@ -1,12 +1,12 @@
-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
diff --git a/rcu/RCU.py b/rcu/RCU.py
index 130db87..93b325d 100644
--- a/rcu/RCU.py
+++ b/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]:
diff --git a/rcu/Vars.py b/rcu/Vars.py
index 966a5de..f3b5de3 100644
--- a/rcu/Vars.py
+++ b/rcu/Vars.py
@@ -1,32 +1,24 @@
-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]),
--
GitLab