diff --git a/HWconf.py b/HWconf.py
new file mode 100644
index 0000000000000000000000000000000000000000..497616312bfebd8d0e90c2b41f46a8f72030f95b
--- /dev/null
+++ b/HWconf.py
@@ -0,0 +1,93 @@
+from collections import namedtuple
+from enum import Enum
+
+#Mid plane address
+MPaddr=namedtuple("MPaddr","nI2C I2C nSwitch Switch");
+RCU_MPaddr=MPaddr(1,[1],4,[1,2,3,4])
+CLK_MPaddr=MPaddr(1,[1],1,[7])
+
+DevReg=namedtuple("DevReg","Addr Register_R Register_W store");
+#I2C:Addr=I2C addr (int)
+#BBdev: Addr=BBdev (pointer)
+
+#Control board switch
+#dev: TCA9548
+SW1_ch=DevReg(0x70,0,0,0)
+#I2C IO-Expanders
+#Device: TCA9539
+RCU_IO1_OUT1=DevReg(0x75,0,2,1)
+RCU_IO1_OUT2=DevReg(0x75,1,3,2)
+RCU_IO1_CONF1=DevReg(0x75,6,6,3)
+RCU_IO1_CONF2=DevReg(0x75,7,7,4)
+#Device: TCA9539
+RCU_IO2_OUT1=DevReg(0x76,0,2,5)
+RCU_IO2_OUT2=DevReg(0x76,1,3,6)
+RCU_IO2_CONF1=DevReg(0x76,6,6,7)
+RCU_IO2_CONF2=DevReg(0x76,7,7,8)
+#Device: TCA6416
+RCU_IO3_OUT1=DevReg(0x20,0,2,9)
+RCU_IO3_OUT2=DevReg(0x20,1,3,10)
+RCU_IO3_CONF1=DevReg(0x20,6,6,11)
+RCU_IO3_CONF2=DevReg(0x20,7,7,12)
+
+RCU_storeReg=13; #Number of stored registers
+
+#I2C monitor ADC
+RCU_AN_Ch0=DevReg(0x14,0xB080,-1,0)
+RCU_AN_Ch1=DevReg(0x14,0xB880,-1,0)
+RCU_AN_Ch2=DevReg(0x14,0xB180,-1,0)
+#etc
+RCU_AN_Temp=DevReg(0x14,0xA0C0,-1,0)
+
+#Bitbang devices
+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);
+SPIBB_ADC1=BBdev(4,[RCU_IO3_OUT1,RCU_IO3_OUT1,RCU_IO3_CONF1,RCU_IO3_OUT2],[1,0,0,0],0) #CLK,SDIO,SDIOdir,CS
+SPIBB_ADC2=BBdev(4,[RCU_IO3_OUT1,RCU_IO3_OUT1,RCU_IO3_CONF1,RCU_IO3_OUT2],[3,2,2,1],0) #CLK,SDIO,SDIOdir,CS
+SPIBB_ADC3=BBdev(4,[RCU_IO3_OUT1,RCU_IO3_OUT1,RCU_IO3_CONF1,RCU_IO3_OUT2],[5,4,4,2],0) #CLK,SDIO,SDIOdir,CS
+
+#SPI ADC
+#Dev: AD9683
+RCU_ADC1_PLL_stat =DevReg(SPIBB_ADC1,0X0A,0X0A,0) # PLL locked status
+RCU_ADC1_JESD_ctr =DevReg(SPIBB_ADC1,0X5F,0X5F,0) #JESD link control, ILAS mode
+RCU_ADC1_CML_level=DevReg(SPIBB_ADC1,0X15,0X15,0) #CML output adjust
+RCU_ADC1_SYNC_ctr =DevReg(SPIBB_ADC1,0X3A,0X3A,0) #SYNC / SYSREF control
+RCU_ADC1_update =DevReg(SPIBB_ADC1,0XFF,0xFF,0) # Global device update
+
+RCU_ADC2_PLL_stat =DevReg(SPIBB_ADC2,0X0A,0X0A,0) # PLL locked status
+RCU_ADC2_JESD_ctr =DevReg(SPIBB_ADC2,0X5F,0X5F,0) #JESD link control, ILAS mode
+RCU_ADC2_CML_level=DevReg(SPIBB_ADC2,0X15,0X15,0) #CML output adjust
+RCU_ADC2_SYNC_ctr =DevReg(SPIBB_ADC2,0X3A,0X3A,0) #SYNC / SYSREF control
+RCU_ADC2_update =DevReg(SPIBB_ADC2,0XFF,0xFF,0) # Global device update
+
+RCU_ADC3_PLL_stat =DevReg(SPIBB_ADC3,0X0A,0X0A,0) # PLL locked status
+RCU_ADC3_JESD_ctr =DevReg(SPIBB_ADC3,0X5F,0X5F,0) #JESD link control, ILAS mode
+RCU_ADC3_CML_level=DevReg(SPIBB_ADC3,0X15,0X15,0) #CML output adjust
+RCU_ADC3_SYNC_ctr =DevReg(SPIBB_ADC3,0X3A,0X3A,0) #SYNC / SYSREF control
+RCU_ADC3_update =DevReg(SPIBB_ADC3,0XFF,0xFF,0) # Global device update
+
+#I2C_dither
+#Dev: SI4010
+RCU_Dth1_Freq =DevReg(I2CBB_dth1,0x1140,0x1141,0) ##TBC
+RCU_Dth1_Prop =DevReg(I2CBB_dth1,0x11 ,0x11,0)
+RCU_Dth1_Start=DevReg(I2CBB_dth1,0x62 ,0x62,0)
+RCU_Dth1_Stop =DevReg(I2CBB_dth1,0x67 ,0x67,0)
+RCU_Dth2_Freq =DevReg(I2CBB_dth2,0x1140,0x1141,0) ##TBC
+RCU_Dth2_Prop =DevReg(I2CBB_dth2,0x11 ,0x11,0)
+RCU_Dth2_Start=DevReg(I2CBB_dth2,0x62 ,0x62,0)
+RCU_Dth2_Stop =DevReg(I2CBB_dth2,0x67 ,0x67,0)
+RCU_Dth3_Freq =DevReg(I2CBB_dth3,0x1140,0x1141,0) ##TBC
+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
diff --git a/I2C.py b/I2C.py
new file mode 100644
index 0000000000000000000000000000000000000000..037725621622007f7019883d53ab1bfdf446d8e1
--- /dev/null
+++ b/I2C.py
@@ -0,0 +1,38 @@
+import pylibi2c;
+import time
+import logging
+#bus = pylibi2c.I2CDevice('/dev/i2c-1'
+#read=0: write to register
+#read=1: read from register
+#read=2: write to register (common in group)
+#read=3: wait ms second
+I2Ccounter=0;
+
+def I2C1server(addr,data,reg=None,read=0):
+ try:
+ if read==3:
+ time.sleep(data[0]/1000.)
+ return True
+ logging.debug(str(("I2C",addr,reg,data,read)))
+
+# print("I2C",addr,reg,data,read)
+# return True;
+ bus=pylibi2c.I2CDevice('/dev/i2c-1',addr)
+ if read==1:
+ length=len(data)
+ bus.iaddr_bytes=0
+ if not(reg is None):
+ bus.ioctl_write(0,str(bytearray([reg])))
+ data[:]=[int(x) for x in bus.ioctl_read(0,length)]
+ else:
+ if reg is None:
+ bus.iaddr_bytes=0
+ reg=0;
+ bus.ioctl_write(reg,str(bytearray(data)))
+ bus.close()
+ return True;
+ except:
+ if bus: bus.close()
+ data[0]=0
+ return False;
+
diff --git a/I2C_dummy.py b/I2C_dummy.py
new file mode 100644
index 0000000000000000000000000000000000000000..09214ba6bbb078fdf1e0cb44ca023dce7bc7654f
--- /dev/null
+++ b/I2C_dummy.py
@@ -0,0 +1,20 @@
+#import pylibi2c;
+import time
+import logging
+#bus = pylibi2c.I2CDevice('/dev/i2c-1'
+#read=0: write to register
+#read=1: read from register
+#read=2: write to register (common in group)
+#read=3: wait ms second
+I2Ccounter=0;
+def I2C1server(addr,data,reg=None,read=0):
+ global I2Ccounter;
+ if read==3:
+ time.sleep(data[0]/1000.)
+ return True
+ if read==1:
+ data[0]=0
+ if reg: I2Ccounter+=1;
+ I2Ccounter+=len(data)
+ logging.debug(str(("I2C",addr,reg,data,read)))
+ return True
diff --git a/I2Cswitch1.py b/I2Cswitch1.py
new file mode 100644
index 0000000000000000000000000000000000000000..a877678ceec748bc6525de130e530655533ffb00
--- /dev/null
+++ b/I2Cswitch1.py
@@ -0,0 +1,17 @@
+import numpy as np
+import logging
+import HWconf
+class I2Cswitch1():
+ def __init__(self,callback1):
+ self.callback1=callback1;
+ self.CurrentChannel=0;
+
+ def SetChannel(self,channel):
+ if (channel)==self.CurrentChannel: return True;
+ logging.debug(str(("SetChannel",channel,self.CurrentChannel)))
+ self.CurrentChannel=channel
+ return self.callback1(HWconf.SW1_ch.Addr,[channel])
+
+ def I2Ccallback(self,RCU,addr,data,reg=None,read=0):
+ self.callback1(addr,data,reg,read)
+
diff --git a/RCU.py b/RCU.py
new file mode 100644
index 0000000000000000000000000000000000000000..4d2e55965c9f5e3d36fa122d0f62b9192b462bba
--- /dev/null
+++ b/RCU.py
@@ -0,0 +1,247 @@
+import Vars
+import numpy as np
+import logging
+from spibitbang1 import *
+
+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 SetVar(self,Instr,Mask=[]):
+ if Instr.type==Vars.DevType.Instr:
+ #Execute instructions
+ Iset=Instr.dev;
+ if len(Mask)==0: Mask=Vars.RCU_mask.OPCW.get_data_value().Value.Value
+ for i in Iset.instr:
+ logging.debug(str(("Inst",i)))
+ self.SetVar(i,Mask=Mask)
+ return;
+ if Instr.type in [Vars.DevType.I2C,Vars.DevType.SPIbb,Vars.DevType.I2Cbb]:
+ if len(Mask)==0: Mask=Vars.RCU_mask.OPCW.get_data_value().Value.Value
+ mask=0;
+ RCU0=-1;
+ for RCUi in range(self.N):
+ if (Mask[RCUi]):
+ 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
+ Mask=(Vars.RCU_mask if Step==1 else Vars.Ant_mask)
+ Mask=Mask.OPCW.get_data_value().Value.Value
+ 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):
+ if not(Mask[RCUi*Step+Vari]): continue
+ 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<<var.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<<V1.Vars[0].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<<V1.Vars[0].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<<V1.Vars[0].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<<var.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;
+
+
+
diff --git a/Vars.py b/Vars.py
new file mode 100644
index 0000000000000000000000000000000000000000..28ce0df7ef819a978995f1d672e0c4d9654687d8
--- /dev/null
+++ b/Vars.py
@@ -0,0 +1,156 @@
+from collections import namedtuple
+from recordclass import recordclass
+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)
+
+
+Ant_mask=VarArray("Ant_mask" ,3,[dummy,dummy,dummy] ,RW.WriteOnly,datatype.dInt,None,None)
+RCU_att =VarArray("RCU_attenuator" ,3,[RCU_att1 ,RCU_att2 ,RCU_att3] ,RW.ReadWrite,datatype.dInt,None,None)
+RCU_band=VarArray("RCU_band" ,3,[RCU_band1,RCU_band2,RCU_band3],RW.ReadWrite,datatype.dInt,None,None)
+
+RCU_mask=VarArray("RCU_mask" ,1,[dummy] ,RW.WriteOnly,datatype.dInt ,None,None)
+RCU_temp=VarArray("RCU_temperature",1,[RCU_temp1],RW.ReadOnly ,datatype.dfloat,None,None)
+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_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_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_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_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_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=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=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=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)
+RCU_OUT2=VarArray("RCU_OUT2",3,[RCU_IO1_2,RCU_IO2_2,RCU_IO3_2],RW.ReadOnly,datatype.dInt,None,None)
+#RCU_CNF1=VarArray("RCU_CONF1",3,[RCU_IO1_3,RCU_IO2_3,RCU_IO3_3],RW.ReadOnly,datatype.dInt,None,None)
+#RCU_CNF2=VarArray("RCU_CONF2",3,[RCU_IO1_4,RCU_IO2_4,RCU_IO3_4],RW.ReadOnly,datatype.dInt,None,None)
+
+
+
+OPC_devvars=[RCU_mask,Ant_mask,RCU_att,RCU_band,RCU_temp,RCU_pwrd,RCU_LED,RCU_ADC_lock,RCU_ADC_SYNC,RCU_ADC_JESD,RCU_ADC_CML,RCU_OUT1,RCU_OUT2]#,RCU_CNF1,RCU_CNF2]
+
+
+
+
+
+
+Instr=namedtuple("DevInstr","type dev nvalue value")
+
+#OPCUA methods
+Instrs=namedtuple("Instr","name ninstr instr")
+
+RCU_init=Instrs("ReadRegisters",2,[
+ Instr(DevType.VarUpdate,RCU_OUT1,3,[0,0,0]),
+ Instr(DevType.VarUpdate,RCU_OUT2,3,[0,0,0])
+])
+
+ADC_on=Instrs("ADC_on",15,[
+ Instr(DevType.SPIbb,RCU_ADC1_JESD_ctr,1,[14]),
+ Instr(DevType.SPIbb,RCU_ADC1_CML_level,1,[0x7]),
+ Instr(DevType.SPIbb,RCU_ADC1_SYNC_ctr,1,[1]),
+ Instr(DevType.SPIbb,RCU_ADC1_update,1,[1]),
+ Instr(DevType.SPIbb,RCU_ADC2_JESD_ctr,1,[14]),
+ Instr(DevType.SPIbb,RCU_ADC2_CML_level,1,[0x7]),
+ Instr(DevType.SPIbb,RCU_ADC2_SYNC_ctr,1,[1]),
+ Instr(DevType.SPIbb,RCU_ADC2_update,1,[1]),
+ Instr(DevType.SPIbb,RCU_ADC3_JESD_ctr,1,[14]),
+ Instr(DevType.SPIbb,RCU_ADC3_CML_level,1,[0x7]),
+ Instr(DevType.SPIbb,RCU_ADC3_SYNC_ctr,1,[1]),
+ Instr(DevType.SPIbb,RCU_ADC3_update,1,[1]),
+# Instr(DevType.VarUpdate,RCU_ADC_lock,3,[0,0,0]),
+ Instr(DevType.VarUpdate,RCU_ADC_SYNC,3,[0,0,0]),
+ Instr(DevType.VarUpdate,RCU_ADC_JESD,3,[0,0,0]),
+ Instr(DevType.VarUpdate,RCU_ADC_CML,3,[0,0,0])
+])
+
+RCU_on=Instrs("RCU_on",12,[
+ Instr(DevType.I2C,RCU_IO2_CONF1,1,[0]),
+ Instr(DevType.I2C,RCU_IO2_CONF2,1,[0]),
+ Instr(DevType.I2C,RCU_IO3_CONF1,1,[0]),
+ Instr(DevType.I2C,RCU_IO3_CONF2,1,[0]),
+ Instr(DevType.I2C,RCU_IO1_CONF1,1,[0]),
+ Instr(DevType.I2C,RCU_IO1_CONF2,1,[0]),
+ Instr(DevType.I2C,RCU_IO2_OUT1,1,[0x4A]),
+ Instr(DevType.I2C,RCU_IO2_OUT2,1,[0x55]),
+ Instr(DevType.I2C,RCU_IO3_OUT1,1,[0x15]),
+ Instr(DevType.I2C,RCU_IO3_OUT2,1,[0x47]),
+ Instr(DevType.I2C,RCU_IO1_OUT1,1,[0xCA]),
+ Instr(DevType.I2C,RCU_IO1_OUT2,1,[0xCA]),
+# Instr(DevType.VarUpdate,RCU_att,3,[0,0,0]),
+ Instr(DevType.VarUpdate,RCU_pwrd,1,[0]),
+ Instr(DevType.VarUpdate,RCU_OUT1,3,[0,0,0]),
+ Instr(DevType.VarUpdate,RCU_OUT2,3,[0,0,0]),
+# Instr(DevType.Instr,ADC1_on,0,[]),
+# Instr(DevType.Instr,ADC2_on,0,[]),
+# Instr(DevType.Instr,ADC3_on,0,[])
+# Instr(DevType.VarUpdate,RCU_ADC_lock,3,[0,0,0])
+])
+
+RCU_off=Instrs("RCU_off",1,[
+# Instr(DevType.Var,RCU_mask,4,[1,1,1,1]),
+ Instr(DevType.Var,RCU_pwrd,4,[0,0,0,0]),
+# Instr(DevType.Var,RCU_mask,4,[0,0,0,0])
+])
+
+
+OPC_methods=[RCU_on,RCU_off,ADC_on]
diff --git a/main.py b/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf7efd79fc95290170f48111d2ae6fe6d73f302d
--- /dev/null
+++ b/main.py
@@ -0,0 +1,123 @@
+import opcuaserv
+try:
+ import queue
+except ImportError:
+ import Queue as queue;
+import RCU
+import I2Cswitch1
+import threading
+import signal
+import sys
+import time
+import Vars
+import logging
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-s", "--simulator", help="Do not connect to I2c, but simulate behaviour.", action="store_true")
+parser.add_argument("-p", "--port", help="Port number to listen on [%(default)s].", type=int, default=4842)
+parser.add_argument("-l", "--loglevel", help="Log level [%(default)s].", type=str, choices=["DEBUG","INFO","WARNING","ERROR"], default="INFO")
+args = parser.parse_args()
+
+# set log level
+loglevel_nr = getattr(logging, args.loglevel.upper(), None)
+if not isinstance(loglevel_nr, int):
+ raise ValueError('Invalid log level: %s' % args.loglevel)
+#logging.basicConfig(level=loglevel_nr, format="%(asctime)s [%(levelname)8s] %(message)s")
+
+logging.basicConfig(level=loglevel_nr,format='%(asctime)s [%(levelname)-8s,%(filename)-20s:%(lineno)-3d] %(message)s')
+if args.simulator:
+ import I2C_dummy as I2C
+else:
+ import I2C
+
+#Queue used to pass instructions from opc-ua server to RCU
+Q1=queue.Queue()
+
+#Setup OPCUA server (running in its own thread)
+opcuaserv.EventPipes.append(Q1)
+opcuaserv.InitServer(port=args.port)
+logging.info("OPC-UA Server started")
+
+
+SW1=I2Cswitch1.I2Cswitch1(I2C.I2C1server)
+
+RCU=RCU.RCU1(4,I2C.I2C1server,SW1.SetChannel)
+
+#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)
+logging.debug(str(("I2C bytes=",I2C.I2Ccounter)))
+
+if False:
+ opcuaserv.server.stop()
+ exit()
+
+def RCUthread(Q1,RCU):
+ while True:
+ item = Q1.get()
+ if item is None: break;
+ RCU.SetVar(item)
+ logging.info("End RCU thread")
+
+RCUthread1 = threading.Thread(target=RCUthread, args=(Q1,RCU))
+RCUthread1.start()
+
+RunTimer=True;
+def TimerThread(Q1,RCU):
+ V1=opcuaserv.AddVar("RCU_monitor_rate",10)
+ cnt=0;#Count second ticks
+ while RunTimer:
+ time.sleep(1)
+ T1=V1.get_data_value().Value.Value
+ if T1==0:
+ continue;
+ cnt+=1;
+ if cnt>=T1:
+ if Q1.qsize()>3: continue;
+ cnt=0;
+ logging.debug(str(("I2C bytes=",I2C.I2Ccounter," Qlength=",Q1.qsize())))
+ Inst1=Vars.Instr(Vars.DevType.VarUpdate,Vars.RCU_temp,4,[0]*4)
+ Q1.put(Inst1)
+ Inst1=Vars.Instr(Vars.DevType.VarUpdate,Vars.RCU_ADC_lock,12,[0]*12)
+ Q1.put(Inst1)
+
+ logging.info("End Timer thread")
+
+Timerthread1 = threading.Thread(target=TimerThread, args=(Q1,RCU))
+Timerthread1.start()
+
+# on SIGINT: stop thread(s) by adding None to instruction queue(s)
+def signal_handler(sig, frame):
+ logging.info('Stop RCU thread')
+ Q1.put(None)
+ logging.info('Stop timer thread')
+ global RunTimer;
+ RunTimer=False
+signal.signal(signal.SIGINT, signal_handler)
+
+try:
+#Do nothing.
+ while RunTimer:
+ time.sleep(1)
+finally:
+ logging.info("Stop OPC-UA server")
+ opcuaserv.server.stop()
+ RCUthread1.join()
+ Timerthread1.join()
diff --git a/opcuaserv.py b/opcuaserv.py
index be0d9a9dfd12edbf2184c71f29d760470864959d..94d685e7ab2a9e81ecb97a72331828327a0634dc 100644
--- a/opcuaserv.py
+++ b/opcuaserv.py
@@ -5,33 +5,61 @@ sys.path.insert(0, "..")
import time
from opcua import ua, Server
from datetime import datetime;
-import argparse
import logging
+import Vars
+#import HWconf
-parser = argparse.ArgumentParser()
-parser.add_argument("-s", "--simulator", help="Do not connect to I2c, but simulate behaviour.", action="store_true")
-parser.add_argument("--no-lib-hack", help="Do not require a hacked opcua library. Breaks behaviour.", action="store_true")
-parser.add_argument("-p", "--port", help="Port number to listen on [%(default)s].", type=int, default=4842)
-parser.add_argument("-l", "--loglevel", help="Log level [%(default)s].", type=str, choices=["DEBUG","INFO","WARNING","ERROR"], default="DEBUG")
-args = parser.parse_args()
+Vars_R={}
+Vars_W={}
+EventPipes=[]
+running=False
+class SubHandler(object):
+ """
+ Subscription Handler. To receive events from server for a subscription
+ """
+ def datachange_notification(self, node, val, data):
+# print("Python: New data change event", node, val,data)
+ if not(running): return
+ vname,myvar,VarD=Vars_W[node.nodeid.Identifier]
+# val=(val if isinstance(val, list) else [val] )
+ logging.info(str(("Datachange callback",vname,val)))
+# myvar2.Value.Value=val
+# myvar2.SourceTimestamp = datetime.utcnow()
+
+ Inst=Vars.Instr(Vars.DevType.Var,VarD,len(val),val)
+ EventPipes[0].put(Inst)
+ # P1.SetVarValue(vname,val)
+ #readback
+# if True:
+# print(Vars_R,Vars_R.values())
+# for vname2,myvar2,oldvalue in Vars_R.values():
+# if vname2==vname:
+# res=P1.GetVarValue(vname,val)
+# print("Read callback",vname,": Result:",res,oldvalue)
+# if res:
+
+ def event_notification(self, event):
+ logging.info(str(("Python: New event", event)))
+
+
+def CallMethod(ObjectID,instrs):
+ logging.info(str(("Callmethod",ObjectID,instrs)))
+ Inst1=Vars.Instr(Vars.DevType.Instr,instrs,0,[])
+ EventPipes[0].put(Inst1)
-# set log level
-loglevel_nr = getattr(logging, args.loglevel.upper(), None)
-if not isinstance(loglevel_nr, int):
- raise ValueError('Invalid log level: %s' % args.loglevel)
-logging.basicConfig(level=loglevel_nr, format="%(asctime)s [%(levelname)8s] %(message)s")
+# P1.CallMethod(name,None)
-if args.simulator:
- import pypcc_test as pypcc
-else:
- import pypcc
+def AddVar(name,value):
+ myvar2 = PCCobj.add_variable(idx, name, value)
+ myvar2.set_writable()
+ return myvar2
-P1=pypcc.pypcc("LTS_pypcc.yaml")
+def InitServer(port=4840):
-if True:
# setup our server
+ global server,running,PCCobj,idx;
server = Server()
- server.set_endpoint("opc.tcp://0.0.0.0:{}/PCC/".format(args.port))
+ server.set_endpoint("opc.tcp://0.0.0.0:{}/PCC/".format(port))
idx = server.register_namespace("http://lofar.eu")
# uri = "http://examples.freeopcua.github.io"
@@ -41,140 +69,66 @@ if True:
# populating our address space
PCCobj = objects.add_object(idx, "PCC")
+# self.PCCobj=PCCobj
- # myvar = myobj.add_variable(idx, "MyVariable", 6.7)
-# myvar.set_writable() # Set MyVariable to be writable by clients
-
# starting!
-
-#Vars={}
-#Vars[1]='123'
-#logging.info("%s", Vars)
-#exit()
-def ValCallback(nodeid,force=False):
- vname,myvar,oldvalue=Vars_R[nodeid.Identifier]
-# logging.info("Value callback %s",vname)
-# vname=vname[vname.find('_')+1:]
-# logging.info("RCU variable: %s=%s",vname,oldvalue)
-# X=RCU1.Getvar2(vname)
-# if not(running):
- if False:
- myvar.Value.Value=(oldvalue[0] if len(oldvalue)==1 else oldvalue)
- myvar.SourceTimestamp = datetime.utcnow()
- return myvar
- timenow=datetime.utcnow()
- timediff=(timenow-myvar.SourceTimestamp).total_seconds()
-# logging.info("%s",timediff)
- if not(force) and timediff<90: return myvar;
- res=P1.GetVarValue(vname,oldvalue)
- logging.info("Read callback %s: Result: %s Value: %s",vname,res,oldvalue)
- if res:
- myvar.Value.Value=(oldvalue[0] if len(oldvalue)==1 else oldvalue)
- myvar.SourceTimestamp = datetime.utcnow()
-# Vars_R[nodeid.Identifier][3]=oldvalue
- return myvar
-
-
-
-class SubHandler(object):
- """
- Subscription Handler. To receive events from server for a subscription
- """
-
- def datachange_notification(self, node, val, data):
- # logging.info("Python: New data change event: %s %s %s", node, val,data)
- if not(running): return
- vname,myvar=Vars_W[node.nodeid.Identifier]
- val=(val if isinstance(val, list) else [val] )
- logging.info("Write callback %s=%s",vname,val)
- P1.SetVarValue(vname,val)
- #readback
-# if True:
-# logging.info(Vars_R,Vars_R.values())
- for vname2,myvar2,oldvalue in Vars_R.values():
- if vname2==vname:
- if args.simulator:
- res=True
- logging.info("Simulating fallthrough _RW->_R for",vname,": Result:",res,oldvalue)
- else:
- res=P1.GetVarValue(vname,val)
- logging.info("Read callback",vname,": Result:",res,oldvalue)
- if res:
- myvar2.Value.Value=(val[0] if len(val)==1 else val)
- myvar2.SourceTimestamp = datetime.utcnow()
-
-
- def event_notification(self, event):
- logging.debug("Python: New event %s", event)
-
-
-def CallMethod(ObjectID,name):
- logging.debug("Callmethod %s",name)
- P1.CallMethod(name,None)
-
-
-
-#P1.RunMethod("RCU_on",None)
-#P1.SetVarValue("Band1",3)
-Vars_R={}
-Vars_W={}
-def AddVar(name,dtype=0,RW=0,cnt=1):
- if dtype==1:
- varvalue2=([0.0] if cnt<=1 else cnt*[0.0])
- else:
- varvalue2=([0] if cnt<=1 else cnt*[0])
- if RW in [1,3]:
- vname=name+"_R";
- if dtype==1:
- myvar = (PCCobj.add_variable(idx, vname, 0.0) if cnt<=1 else PCCobj.add_variable(idx, vname, cnt*[0.0]))
- else:
- myvar = (PCCobj.add_variable(idx, vname, 0) if cnt<=1 else PCCobj.add_variable(idx, vname, cnt*[0]))
- logging.info("Variable added: %s",vname)
- Vars_R[myvar.nodeid.Identifier]=[name,myvar.get_data_value(),varvalue2]
- ValCallback(myvar.nodeid,force=True)
-# logging.info("%s",myvar.get_value())
- if not args.no_lib_hack:
- server.set_attribute_callback(myvar.nodeid, ValCallback)
+ logging.info("Start server");
+ server.start()
+ handler = SubHandler()
+ sub = server.create_subscription(500, handler)
+ running=False;
+ logging.info("Add variables:")
+#P1.GetVarNames("",AddVar);
+
+ for v in Vars.OPC_devvars:
+# print(v)
+ dim=v.Vars[0].MPaddr.nI2C*v.Vars[0].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]:
+ vname=v.name+"_R";
+ myvar = PCCobj.add_variable(idx, vname, varvalue2)
+ logging.info(str(("Variable added: ",vname,dim)))
+ Vars_R[myvar.nodeid.Identifier]=[v.name,myvar.get_data_value(),varvalue2,v]
+ v.OPCR=myvar
+
+ #Inst1=Vars.Instr(Vars.DevType.Var,Vars.RCU_att,12,[0,1,2,3,4,5,6,7,8,9,11])
+ #RCU.SetVar(Inst1)
+ Inst=Vars.Instr(Vars.DevType.VarUpdate,v,dim,varvalue2)
+ EventPipes[0].put(Inst)
+
+# ValCallback(myvar.nodeid,force=True)
+# print(myvar.get_value())
+# server.set_attribute_callback(myvar.nodeid, ValCallback)
# varvalue=myvar.get_data_value().Value
# Vars_R[myvar.nodeid.Identifier][2]=varvalue
-# logging.info("%s %s",varvalue2,varvalue)
-
- if RW in [2,3]:
- vname=name+"_RW";
- logging.info("Variable added: %s",vname)#,'=',varvalue2)
- myvar2 = PCCobj.add_variable(idx, vname, (varvalue2[0] if len(varvalue2)==1 else varvalue2))
- myvar2.set_writable()
- Vars_W[myvar2.nodeid.Identifier]=[name,myvar2.get_data_value()]
+# print(varvalue2,varvalue)
+ if v.RW in [Vars.RW.WriteOnly,Vars.RW.ReadWrite]:
+ vname=v.name+"_RW";
+ logging.info(str(("Variable added: ",vname)))#,'=',varvalue2)
+ myvar2 = PCCobj.add_variable(idx, vname, varvalue2)
+ myvar2.set_writable()
+ v.OPCW=myvar2
+ Vars_W[myvar2.nodeid.Identifier]=[v.name,myvar2.get_data_value(),v]
handle = sub.subscribe_data_change(myvar2)
-def AddMethod(name):
- vname=name;
- myvar = PCCobj.add_method(idx, vname, lambda ObjectId : CallMethod(ObjectId,name), [],[] )
- logging.info("AddMethod: %s",vname)
+ for v in Vars.OPC_methods:
+ vname=v.name;
+ myvar = PCCobj.add_method(idx, vname, lambda ObjectId,inst=v : CallMethod(ObjectId,inst), [],[] )
+ logging.info(str(("AddMethod:",vname)))
-logging.info("Start server");
-server.start()
-handler = SubHandler()
-sub = server.create_subscription(500, handler)
-running=False;
-logging.info("Add variables:")
-P1.GetVarNames("",AddVar);
-logging.info("Add modes:")
-P1.GetMethodNames("",AddMethod);
+ time.sleep(1)
+ running=True
+ return Vars_R,Vars_W
+
+#exit()
+
+#print("Add modes:")
+#P1.GetMethodNames("",AddMethod);
-time.sleep(1)
-running=True;
-logging.info("Server started")
-
-try:
- while True:
- time.sleep(1)
-finally:
- logging.info("Stop server");
- server.stop()
@@ -198,16 +152,16 @@ finally:
#RCU.Setvar2('Power_Ant1',[0])
-#logging.info(RCU.Getvar2('Amp_Gain0'))
+#print(RCU.Getvar2('Amp_Gain0'))
-#logging.info(RCU.Getvar2('ID'))
+#print(RCU.Getvar2('ID'))
-#logging.info(RCU.Getvar2('ADC_lock1'))
+#print(RCU.Getvar2('ADC_lock1'))
-#logging.info(RCU.Getvar2('HBA_DelayX1',element=1))
+#print(RCU.Getvar2('HBA_DelayX1',element=1))
diff --git a/spibitbang1.py b/spibitbang1.py
new file mode 100644
index 0000000000000000000000000000000000000000..14541d75b70c1961a206a5c39533afccccec0d6e
--- /dev/null
+++ b/spibitbang1.py
@@ -0,0 +1,138 @@
+from enum import Enum
+import logging
+import numpy as np
+
+class SPIBB_pins(Enum):
+ CLK = 0
+ SDIO = 1
+ SDIOdir = 2
+ CS = 3
+
+def SetSPIbb(SetI2C,RCUi,dev,value):
+ ADC_address=dev.Register_W
+ CSdev=dev.Addr.devs[SPIBB_pins.CS.value]
+ CSpin=dev.Addr.pins[SPIBB_pins.CS.value]
+ SDOdev=dev.Addr.devs[SPIBB_pins.SDIO.value]
+ SDOpin=dev.Addr.pins[SPIBB_pins.SDIO.value]
+ CLKdev=dev.Addr.devs[SPIBB_pins.CLK.value]
+ CLKpin=dev.Addr.pins[SPIBB_pins.CLK.value]
+
+ logging.info(str(("SPIbb set",ADC_address,value)))
+
+ ADC_bytes = 0x00
+ ADC_rw = 0x00 # 0 for write, 1 for read
+ data2 = ( ADC_rw << 23 ) + ( ADC_bytes << 21 ) + ( ADC_address << 8 ) + value[0]
+
+ bit_array = "{0:{fill}24b}".format(data2, fill='0')
+ # print(bit_array)
+ SetI2C(RCUi,CSdev,1,CSpin,[0]) #enable
+ for bit in bit_array:
+ SetI2C(RCUi,SDOdev,1,SDOpin,[int(bit)])
+ SetI2C(RCUi,CLKdev,1,CLKpin,[1])
+ SetI2C(RCUi,CLKdev,1,CLKpin,[0])
+ SetI2C(RCUi,CSdev,1,CSpin,[1]) #disable
+ SetI2C(RCUi,SDOdev,1,SDOpin,[1]) #high when finished
+ return True;
+
+def GetSPIbb(SetI2C,GetI2C,RCUi,dev,value):
+ ADC_reg_address=dev.Register_R
+ CSdev=dev.Addr.devs[Vars.SPIBB_pins.CS.value]
+ CSpin=dev.Addr.pins[Vars.SPIBB_pins.CS.value]
+ SDOdev=dev.Addr.devs[Vars.SPIBB_pins.SDIO.value]
+ SDOpin=dev.Addr.pins[Vars.SPIBB_pins.SDIO.value]
+ CLKdev=dev.Addr.devs[Vars.SPIBB_pins.CLK.value]
+ CLKpin=dev.Addr.pins[Vars.SPIBB_pins.CLK.value]
+ SDIOdirdev=dev.Addr.devs[Vars.SPIBB_pins.SDIOdir.value]
+ SDIOdirpin=dev.Addr.pins[Vars.SPIBB_pins.SDIOdir.value]
+
+ logging.info(str(("SPIbb get",ADC_reg_address)))
+
+ ADC_bytes = 0x00
+ ADC_rw = 0x01 # 0 for write, 1 for read
+
+ data = ( ADC_rw << 15) + ( ADC_bytes << 13 ) + ADC_reg_address
+
+ SetI2C(RCUi,CSdev,1,CSpin,[0]) #enable
+
+
+ bit_array = "{0:{fill}16b}".format(data, fill='0')
+ for bit in bit_array:
+ SetI2C(RCUi,SDOdev,1,SDOpin,[int(bit)])
+ SetI2C(RCUi,CLKdev,1,CLKpin,[1])
+ SetI2C(RCUi,CLKdev,1,CLKpin,[0])
+
+ SetI2C(RCUi,CSdev,1,CSpin,[1]) #disable
+
+ # print("read byte")
+ SetI2C(RCUi,SDIOdirdev,1,SDIOdirpin,[1]) #input
+ SetI2C(RCUi,CSdev,1,CSpin,[0]) #enable
+ a=[0]
+ N=len(value)
+ for i in range(N): value[i]=0
+ for cnt in range(8*(ADC_bytes+1)):
+ ret_value=GetI2C(RCUi,SDOdev,1,SDOpin) #enable
+ for i in range(N): value[i]=(value[i]<<1)+ ret_value[i]
+ SetI2C(RCUi,CLKdev,1,CLKpin,[1])
+ SetI2C(RCUi,CLKdev,1,CLKpin,[0]) #read after falling edge
+ SetI2C(RCUi,CSdev,1,CSpin,[1]) #disable
+ SetI2C(RCUi,SDIOdirdev,1,SDIOdirpin,[0]) #output
+ return True;
+
+def GetSPIbb2(SetI2C,GetI2C,RCUi,devs,value):
+ ADC_reg_address=devs[0].Register_R
+ def Setbit(pintype,value):
+ for dev in devs:
+ dev1=dev.Addr.devs[pintype.value]
+ pin1=dev.Addr.pins[pintype.value]
+ SetI2C(RCUi,dev1,1,pin1,[value],buffer=True)
+ SetI2C(RCUi,dev1,1,pin1,[value])
+ def Getbit(pintype):
+ retvalue=np.zeros_like(value)
+ step=len(devs)
+ dev1=devs[0].Addr.devs[pintype.value]
+ pin1=devs[0].Addr.pins[pintype.value]
+ retvalue[0::step]=GetI2C(RCUi,dev1,1,pin1)
+ for i,dev in enumerate(devs[1:]):
+ dev1=dev.Addr.devs[pintype.value]
+ pin1=dev.Addr.pins[pintype.value]
+ retvalue[i+1::step]=GetI2C(RCUi,dev1,1,pin1,buffer=True)
+ return retvalue
+
+ CS=SPIBB_pins.CS
+ SDIO=SPIBB_pins.SDIO
+ CLK=SPIBB_pins.CLK
+ SDIOdir=SPIBB_pins.SDIOdir
+
+ logging.debug(str(("SPIbb get",ADC_reg_address)))
+
+ ADC_bytes = 0x00
+ ADC_rw = 0x01 # 0 for write, 1 for read
+
+ data = ( ADC_rw << 15) + ( ADC_bytes << 13 ) + ADC_reg_address
+
+ Setbit(CS,0) #enable
+
+ bit_array = "{0:{fill}16b}".format(data, fill='0')
+ logging.debug(str(("SPI TX",bit_array)))
+ for bit in bit_array:
+ Setbit(SDIO,int(bit))
+ Setbit(CLK,1)
+ Setbit(CLK,0)
+
+ Setbit(CS,1) #disable
+
+ # print("read byte")
+ Setbit(SDIOdir,1) #input
+ Setbit(CS,0) #enable
+ a=[0]
+ N=len(value)
+ for i in range(N): value[i]=0
+ for cnt in range(8*(ADC_bytes+1)):
+ ret_value=Getbit(SDIO)
+ for i in range(N): value[i]=(value[i]<<1)+ ret_value[i]
+ Setbit(CLK,1)
+ Setbit(CLK,0) #read after falling edge
+ Setbit(CS,1) #disable
+ Setbit(SDIO,1)#High when finished
+ Setbit(SDIOdir,0) #output
+ return True;
\ No newline at end of file
diff --git a/test/test1.py b/test/test1.py
deleted file mode 100644
index ece510b6697587a741c470b62b45b4f744511f44..0000000000000000000000000000000000000000
--- a/test/test1.py
+++ /dev/null
@@ -1,29 +0,0 @@
-import pypcc;
-
-P1=pypcc.pypcc("pypcc.yaml")
-
-def AddMethod(name):
- print("Method:",name)
-P1.GetMethodNames("",AddMethod);
-
-P1.CallMethod("RCU01_RCU_on",None)
-P1.CallMethod("RCU02_RCU_on",None)
-
-def AddVar(name,dtype=0):
- print("Var:",name)
-P1.GetVarNames("",AddVar);
-
-
-a=[0]
-print(P1.GetVarValue("RCU01_Band1",a))
-assert(a[0]==1)
-print(P1.GetVarValue("RCU02_Band1",a))
-assert(a[0]==1)
-print(P1.SetVarValue("RCU01_Band1",3))
-print(P1.SetVarValue("RCU02_Band1",0))
-print(P1.GetVarValue("RCU01_Band1",a))
-assert(a[0]==3)
-print(P1.GetVarValue("RCU02_Band1",a))
-assert(a[0]==0)
-
-
diff --git a/test/test2.py b/test/test2.py
deleted file mode 100644
index b780d8ccd71c9334c46a6112a83ab0dc628a9d65..0000000000000000000000000000000000000000
--- a/test/test2.py
+++ /dev/null
@@ -1,116 +0,0 @@
-#import pypcc;
-import pypcc_test as pypcc;
-
-P1=pypcc.pypcc("LTS_pypcc.yaml")
-
-def Getvalue(name):
- a=[0]
- P1.GetVarValue("RCU01_"+name,a)
- print("GET:",name,a[0])
-
-def Setvalue(name,value):
- P1.SetVarValue("RCU01_"+name,[value])
- print("SET:",name,value)
-
-
-def AddMethod(name):
- print("Method:",name)
-P1.GetMethodNames("",AddMethod);
-
-def AddVar(name,dtype=0,RW=3):
- Types={0:'int',1:'float'}
- RWs={0:'hidden',1:'RO',2:'WO',3:'RW'}
- print("Var:",name,Types[dtype],RWs[RW])
-P1.GetVarNames("",AddVar);
-exit()
-#P1.CallMethod("RCU01_RCU_on",None)
-#P1.CallMethod("RCU01_Dither_on",None)
-#P1.CallMethod("RCU02_RCU_on",None)
-exit()
-if False:
- P1.CallMethod("RCU01_Init_ADCR",None)
- Getvalue("ADC_lock1")
-
-if False:
- Setvalue("Band1",1)
- Setvalue("Band2",0)
- Setvalue("Band3",1)
- Getvalue("Band1")
- Getvalue("Band2")
- Getvalue("Band3")
-#exit()
-
-if False:
-# Setvalue("Dth3_Pwr",0)
-# Setvalue("Dth2_Pwr",0)
-# Setvalue("Dth3_Pwr",1)
-# Setvalue("Dth2_Pwr",1)
- P1.CallMethod("RCU01_Dither1_Setup",None)
- P1.CallMethod("RCU01_Dither2_Setup",None)
- P1.CallMethod("RCU01_Dither3_Setup",None)
-
-# a=[0,0,0,0]
-# P1.GetVarValue("RCU01_Dth1_FREQ",a)
-# print("GET:",a[0])
-# Getvalue("Dither1_Frequency")
- Setvalue("Dither1_Frequency",101.0)
- Setvalue("Dither2_Frequency",101.2)
- Getvalue("Dither1_Frequency")
- Getvalue("Dither2_Frequency")
-# Getvalue("Dth1_FREQ")
-
-if False:
-# a=[0,0,0]
-# P1.GetVarValue("RCU01_V_x",a)
-# print("GET:",a[0])
-# import time
-# time.sleep(0.2)
-# Setvalue("V_x",0xC0)
-# time.sleep(0.2)
-# a=[0,0,0]
-# P1.GetVarValue("RCU01_Temp",a)
-# print("GET:",a[0])
- Getvalue("Temp")
-#exit()
-if False:
- P1.CallMethod("RCU01_ADC1_Switch_on",None)
- Getvalue("ADC1_locked")
- Getvalue("ADC2_locked")
- Getvalue("ADC3_locked")
-#Getvalue("ADC_lock3")
-#Getvalue("ADC_lock1")
-#Setvalue("LED0",1)
-#Getvalue("LED0")
-#Setvalue("Band2",1)
-#Getvalue("Band2")
-#Getvalue("LED0")
-exit()
-
-#Setvalue("Dth3_Pwr",1)
-Setvalue("Dth2_Pwr",0)
-Setvalue("Dth2_SDA",0)
-Setvalue("Dth2_SCL",0)
-Setvalue("Dth3_Pwr",0)
-Setvalue("Dth3_SDA",0)
-Setvalue("Dth3_SCL",0)
-
-Setvalue("LED0",2)
-
-Setvalue("Att1",10)
-Setvalue("Att2",10)
-Setvalue("Att3",10)
-
-
-#Setvalue("Dth3_Pwr",1)
-#Setvalue("Dth2_SCL",1)
-
-#assert(a[0]==1)
-#print(P1.SetVarValue("RCU01_Band1",3))
-#print(P1.SetVarValue("RCU02_Band1",0))
-#print(P1.GetVarValue("RCU01_Band1",a))
-#print(a[0])
-#assert(a[0]==3)
-#print(P1.GetVarValue("RCU02_Band1",a))
-#assert(a[0]==0)
-
-
diff --git a/test/test3.py b/test/test3.py
deleted file mode 100644
index d6bdca5b37e9d898a45f90c9581c68b0b9e56185..0000000000000000000000000000000000000000
--- a/test/test3.py
+++ /dev/null
@@ -1,36 +0,0 @@
-import pypcc;
-
-P1=pypcc.pypcc("pypcc.yaml")
-
-def AddMethod(name):
- print("Method:",name)
-P1.GetMethodNames("",AddMethod);
-
-P1.CallMethod("RCU01_RCU_on",None)
-P1.CallMethod("RCU02_RCU_on",None)
-#a=[0]
-#print(P1.GetVarValue("RCU01_ADC_lock",a))
-#print("ADC lock=",a[0])
-
-
-
-def AddVar(name,dtype=0):
- print("Var:",name)
-P1.GetVarNames("",AddVar);
-
-#print(P1.SetVarValue("RCU01_LED0",0))
-
-exit()
-a=[0]
-print(P1.GetVarValue("RCU01_Band1",a))
-print(a[0])
-#assert(a[0]==1)
-print(P1.SetVarValue("RCU01_Band1",3))
-#print(P1.SetVarValue("RCU02_Band1",0))
-print(P1.GetVarValue("RCU01_Band1",a))
-print(a[0])
-#assert(a[0]==3)
-#print(P1.GetVarValue("RCU02_Band1",a))
-#assert(a[0]==0)
-
-
diff --git a/test/test_ADCs.py b/test/test_ADCs.py
deleted file mode 100644
index 3be2fa979f976cb867efa14f351deaaeae88914e..0000000000000000000000000000000000000000
--- a/test/test_ADCs.py
+++ /dev/null
@@ -1,47 +0,0 @@
-import pypcc;
-#import pypcc_test as pypcc;
-
-P1=pypcc.pypcc("LTS_pypcc.yaml")
-
-##Print all the visible methods
-def AddMethod(name):
- print("Method:",name)
-P1.GetMethodNames("",AddMethod);
-
-##Print all the visible variables
-def AddVar(name,dtype=0,RW=3,cnt=1):
- Types={0:'int',1:'float'}
- RWs={0:'hidden',1:'RO',2:'WO',3:'RW'}
- print("Var:",name,Types[dtype],RWs[RW],cnt)
-P1.GetVarNames("",AddVar);
-
-a=[0]
-##Setup ADC RCU1
-P1.CallMethod("RCU01_RCU_off",None)
-P1.CallMethod("RCU01_RCU_on",None)
-#P1.GetVarValue("RCU01_ADC1_locked",a);print(a[0]);
-P1.GetVarValue("RCU01_ADC1_SYNC",a);print(a[0]);
-P1.GetVarValue("RCU01_ADC1_CML",a);print(a[0]);
-P1.GetVarValue("RCU01_ADC1_JESD",a);print(a[0]);
-P1.GetVarValue("RCU01_ADC2_SYNC",a);print(a[0]);
-P1.GetVarValue("RCU01_ADC2_CML",a);print(a[0]);
-P1.GetVarValue("RCU01_ADC2_JESD",a);print(a[0]);
-P1.GetVarValue("RCU01_ADC3_SYNC",a);print(a[0]);
-P1.GetVarValue("RCU01_ADC3_CML",a);print(a[0]);
-P1.GetVarValue("RCU01_ADC3_JESD",a);print(a[0]);
-#P1.GetVarValue("RCU01_ADC1_JESD_control1",a);print(a[0]);
-#P1.GetVarValue("RCU01_ADC1_CML_level",a);print(a[0]);
-#P1.GetVarValue("RCU01_ADC1_locked",a);print(a[0]);
-#P1.GetVarValue("RCU01_ADC1_locked",a);print(a[0]);
-# - ADC1.SYNC_control: [1] #Setup ADCs
-# - ADC1.JESD_control1: [14] #Setup ADCs
-# - ADC1.CML_level: [0x7]
-# - ADC1.Update: [1] #Needed to update ADC registers
-
-exit()
-##Setup ADC RCU3
-P1.CallMethod("RCU01_RCU_off",None)
-P1.CallMethod("RCU03_RCU_on",None)
-P1.GetVarValue("RCU03_ADC1_locked",a);print(a[0]);
-P1.GetVarValue("RCU03_ADC2_locked",a);print(a[0]);
-P1.GetVarValue("RCU03_ADC3_locked",a);print(a[0]);
diff --git a/test/test_clk.py b/test/test_clk.py
deleted file mode 100644
index da3e84bb7e72045d7ad03530f7438515958298eb..0000000000000000000000000000000000000000
--- a/test/test_clk.py
+++ /dev/null
@@ -1,41 +0,0 @@
-#import pypcc;
-import pypcc_test as pypcc;
-
-P1=pypcc.pypcc("LTS_pypcc.yaml")
-
-def Getvalue(name):
- a=[0]
- P1.GetVarValue("CLK_"+name,a)
- print("GET:",name,a[0])
-
-def Setvalue(name,value):
- P1.SetVarValue("CLK_"+name,[value])
- print("SET:",name,value)
-
-
-def AddMethod(name):
- print("Method:",name)
-P1.GetMethodNames("",AddMethod);
-
-def AddVar(name,dtype=0,RW=3,cnt=1):
- Types={0:'int',1:'float'}
- RWs={0:'hidden',1:'RO',2:'WO',3:'RW'}
- print("Var:",name,Types[dtype],RWs[RW],cnt)
-
-P1.GetVarNames("",AddVar);
-#exit()
-#P1.CallMethod("RCU01_RCU_on",None)
-#P1.CallMethod("RCU01_Dither_on",None)
-#P1.CallMethod("RCU02_RCU_on",None)
-if True:
- Getvalue("CONF")
- Getvalue("OUT")
- Getvalue("IN")
- P1.CallMethod("CLK_on1",None)
- Getvalue("CONF")
- Getvalue("OUT")
- Getvalue("IN")
- Getvalue("PLL_locked")
-# P1.CallMethod("CLK_PLL_Setup",None)
- Getvalue("PLL_locked")
-
diff --git a/test/test_dither.py b/test/test_dither.py
deleted file mode 100644
index 9a904f08c27e5ffd2efd8a2428d36f40b25752fa..0000000000000000000000000000000000000000
--- a/test/test_dither.py
+++ /dev/null
@@ -1,47 +0,0 @@
-import pypcc;
-
-P1=pypcc.pypcc("LTS_pypcc.yaml")
-
-def Getvalue(name):
- a=[0]
- P1.GetVarValue("RCU01_"+name,a)
- print("GET:",name,a[0])
-
-def Setvalue(name,value):
- P1.SetVarValue("RCU01_"+name,[value])
- print("SET:",name,value)
-
-
-def AddMethod(name):
- print("Method:",name)
-P1.GetMethodNames("",AddMethod);
-
-def AddVar(name,dtype=0,RW=3):
- Types={0:'int',1:'float'}
- RWs={0:'hidden',1:'RO',2:'WO',3:'RW'}
- print("Var:",name,Types[dtype],RWs[RW])
-P1.GetVarNames("",AddVar);
-
-#P1.CallMethod("RCU01_RCU_on",None)
-#P1.CallMethod("RCU01_Dither_on",None)
-#P1.CallMethod("RCU02_RCU_on",None)
-
-if True:
-# Setvalue("Dth3_Pwr",0)
-# Setvalue("Dth2_Pwr",0)
- Setvalue("Dth3_Pwr",1)
- Setvalue("Dth2_Pwr",1)
- P1.CallMethod("RCU01_Dither1_Setup",None)
- P1.CallMethod("RCU01_Dither2_Setup",None)
- P1.CallMethod("RCU01_Dither3_Setup",None)
-
-# a=[0,0,0,0]
-# P1.GetVarValue("RCU01_Dth1_FREQ",a)
-# print("GET:",a[0])
-# Getvalue("Dither1_Frequency")
- Setvalue("Dither1_Frequency",101.0)
- Setvalue("Dither2_Frequency",101.2)
- Getvalue("Dither1_Frequency")
- Getvalue("Dither2_Frequency")
-# Getvalue("Dth1_FREQ")
-