Create a branch that contains the only working copy as of 2020-12-7

I2Cdevices.py

-from hwdev import hwdev;
+from hwdev import *;
 import numpy as np
 
-def Find(L,name,value):
-  for x in L:
-    if x[name]==value:
-        return x;
-  return False;
 
 def GetField(D,name,dev_number):
     X=D.get(name)
@@ -224,7 +219,13 @@ class I2Cdevices(hwdev):
         makesinglevalue=((len(value)==1) and (l1>1));
         if makesinglevalue: value2=[0 for x in range(l1)]
         else: value2=value
-        if not(I2Ccallback(Addr,value2,reg=Reg['reg_addr'],read=l1)): return False;
+        reg=Reg['reg_addr']
+        if reg>255: #This is for the monitor ADC
+          if not(I2Ccallback(Addr,int2bytes(reg),read=2)): return False;
+          I2Ccallback(Addr,[250],read=3)
+          if not(I2Ccallback(Addr,value2,read=1)): return False;
+        else:
+          if not(I2Ccallback(Addr,value2,reg=Reg['reg_addr'],read=1)): return False;
         if value2[0] is None:  return False
         if makesinglevalue: value[0]=bytes2int(value2)
         else: value[:]=value2[:];

I2Cswitch.py

-from hwdev import hwdev;
+from hwdev import *;
 import numpy as np
+
+def I2C_dummy(addr,data,reg=None,read=0):
+#            print("I2C dummy",addr,data)
+            return True;
+
 class I2Cswitch(hwdev):
     def SetChannel(self,channel,I2Ccallback):
         if not(hasattr(self,'CurrentChannel')): self.CurrentChannel=0
-        if (1<<channel)==self.CurrentChannel: return True;
-        self.CurrentChannel=(1<<channel)
-        return I2Ccallback(self.D['dev_address'],[self.CurrentChannel])
+        print("SetChannel",channel,self.CurrentChannel)
+        if (channel)==self.CurrentChannel: return True;
+        self.CurrentChannel=channel
+        return I2Ccallback(self.D['dev_address'],[channel])
         
 #    def GetVarNames(self,parentname,callback):
 #        for c in self.D['dev_children']:
@@ -18,28 +24,107 @@ class I2Cswitch(hwdev):
 #        return True;
 
     def GetVarValue(self,name,value,I2Ccallback):
+        def I2Ccallback2(addr,data,reg=None,read=0):
+#            print("Getvarcallback",x)
+            if (read==2):
+                if (cnt>0): return True;
+                if not(self.SetChannel(gchannel,I2Ccallback)): return False;
+            elif (read==3):
+                if (cnt>0): return True;
+                return I2Ccallback(addr,data,reg,read)
+            elif not(self.SetChannel(cchannel,I2Ccallback)): return False;
+            return I2Ccallback(addr,data,reg,read)
+
         childname=name.split('_')[0]
-        for c in self.D['dev_children']:
-          if childname==c['child_name']:
-              if not(self.SetChannel(c['child_addr'],I2Ccallback)): return False; 
-              return c['obj'].GetVarValue(name[len(childname)+1:],value,I2Ccallback)
+        child=Find(self.D['dev_children'],'child_name',childname)
+        if child:
+              if not(self.SetChannel(1<<child['child_addr'],I2Ccallback)): return False; 
+              return child['obj'].GetVarValue(name[len(childname)+1:],value,I2Ccallback)
+        group=Find(self.D['dev_groups'],'group_name',childname)
+        if group:
+              devcnt=len(group['group_members'])
+              stride=len(value)//devcnt;
+              gchannel=0;
+              for childname2 in group['group_members']:
+                   gchannel+=1<<(Find(self.D['dev_children'],'child_name',childname2)['child_addr'])
+
+              for cnt,childname2 in enumerate(group['group_members']):
+                    child=Find(self.D['dev_children'],'child_name',childname2)
+                    if not(child): return False;
+                    print("Get:",childname2)
+                    cchannel=1<<child['child_addr']
+                    value2=value[cnt*stride:(cnt+1)*stride]
+                    if not(child['obj'].GetVarValue(name[len(childname)+1:],value2,I2Ccallback2)): return False; 
+                    value[cnt*stride:(cnt+1)*stride]=value2
+              return True;
         return False
 
     def SetVarValue(self,name,value,I2Ccallback):
         childname=name.split('_')[0]
-        for c in self.D['dev_children']:
-          if childname==c['child_name']: 
-              if not(self.SetChannel(c['child_addr'],I2Ccallback)): return False; 
-              return c['obj'].SetVarValue(name[len(childname)+1:],value,I2Ccallback)
+        child=Find(self.D['dev_children'],'child_name',childname)
+        if child:
+              if not(self.SetChannel(1<<child['child_addr'],I2Ccallback)): return False; 
+              return child['obj'].SetVarValue(name[len(childname)+1:],value,I2Ccallback)
+        group=Find(self.D['dev_groups'],'group_name',childname)
+        if group:
+              devcnt=len(group['group_members'])
+              stride=len(value)//devcnt;
+              AllSame=True;
+              for x in range(devcnt-1):
+                  for y in range(stride):
+                      if value[x*stride+y]!=value[(x+1)*stride+y]: AllSame=False;
+              if AllSame: 
+                print("Allsame");              
+                channel=0;
+                for childname2 in group['group_members']:
+                    channel+=1<<(Find(self.D['dev_children'],'child_name',childname2)['child_addr'])
+                print(channel)
+                if not(self.SetChannel(channel,I2Ccallback)): return False; 
+                for x,childname2 in enumerate(group['group_members']):
+                    child=Find(self.D['dev_children'],'child_name',childname2)
+                    if not(child): return False;
+                    callback=(I2Ccallback if x==0 else I2C_dummy)
+                    if not(child['obj'].SetVarValue(name[len(childname)+1:],value[:stride],callback)): return false; 
+                return True;
+              else:
+                for x,childname2 in enumerate(group['group_members']):
+                    child=Find(self.D['dev_children'],'child_name',childname2)
+                    if not(child): return False;
+                    print("Set:",childname2)
+                    if not(self.SetChannel(1<<child['child_addr'],I2Ccallback)): return False; 
+                    if not(child['obj'].SetVarValue(name[len(childname)+1:],value[x*stride:(x+1)*stride],I2Ccallback)): return false; 
+                return True;
         return False
 
     def CallMethod(self,name,params,I2Ccallback):
         childname=name.split('_')[0]
-        for c in self.D['dev_children']:
-           if not(self.SetChannel(c['child_addr'],I2Ccallback)): return False; 
-           if childname==c['child_name']: return c['obj'].CallMethod(name[len(childname)+1:],params,I2Ccallback)
-        return False
-
-
+        child=Find(self.D['dev_children'],'child_name',childname)
+        if child:
+            if not(self.SetChannel(1<<child['child_addr'],I2Ccallback)): return False; 
+            return child['obj'].CallMethod(name[len(childname)+1:],params,I2Ccallback)
+        group=Find(self.D['dev_groups'],'group_name',childname)
+        if group:
+              channel=0;
+              for childname2 in group['group_members']:
+                 channel+=1<<(Find(self.D['dev_children'],'child_name',childname2)['child_addr'])
+              if not(self.SetChannel(channel,I2Ccallback)): return False; 
+              for x,childname2 in enumerate(group['group_members']):
+                 child=Find(self.D['dev_children'],'child_name',childname2)
+                 if not(child): return False;
+                 callback=(I2Ccallback if x==0 else I2C_dummy)
+                 if not(child['obj'].CallMethod(name[len(childname)+1:],params,callback)): return false; 
+              return True;
+        return False;
 
+    def GetVarNames(self,parentname,callback):
+        if not(hwdev.GetVarNames(self,parentname,callback)): return False;
+        def AddVar(name,dtype=0,RW=3,cnt=1):
+            callback(name,dtype,RW,cnt*devcnt)
+        for group in self.D['dev_groups']:
+                childname=group['group_members'][0]
+                devcnt=len(group['group_members'])
+                child=Find(self.D['dev_children'],'child_name',childname)
+                if not(child): return False;
+                child['obj'].GetVarNames(parentname+group['group_name']+'_',AddVar)
+        return True;
      

hwdev.py

 import yaml;
 import importlib
 import sys, inspect
+YAMLDIR='yaml/'
 class hwdev:
     def __init__(self,configfile):
         print("Loading:",configfile)
-        self.D=yaml.load(open(configfile))
+        self.D=yaml.load(open(YAMLDIR+configfile))
         self.loadchildren(self.D)
     def loadchildren(self,D):
       self.children=[]
@@ -53,3 +54,8 @@ class hwdev:
             elif cname[:-1]==childname: return child.CallMethod(name[len(childname)+1:],params,I2Ccallback)
         return False
 
+def Find(L,name,value):
+  for x in L:
+    if x[name]==value:
+        return x;
+  return False;
\ No newline at end of file

opcuaserv.py

@@ -6,14 +6,16 @@ import time
 from opcua import ua, Server
 from datetime import datetime;
 
+
 import pypcc;
+#import pypcc_test as pypcc;
 P1=pypcc.pypcc("LTS_pypcc.yaml")
 
 
 if True:
 # setup our server
     server = Server()
-    server.set_endpoint("opc.tcp://0.0.0.0:4848/PCC/")
+    server.set_endpoint("opc.tcp://0.0.0.0:4842/PCC/")
 
     idx = server.register_namespace("http://lofar.eu")
 #    uri = "http://examples.freeopcua.github.io"
@@ -33,18 +35,27 @@ if True:
 #Vars[1]='123'
 #print(Vars)
 #exit()
-def ValCallback(nodeid):
-    vname,myvar=Vars_R[nodeid.Identifier]
-    print("Value callback",vname)
+def ValCallback(nodeid,force=False):
+    vname,myvar,oldvalue=Vars_R[nodeid.Identifier]
+#    print("Value callback",vname)
 #    vname=vname[vname.find('_')+1:]
-#    print("RCU variable:",vname)
+#    print("RCU variable:",vname,oldvalue)
 #    X=RCU1.Getvar2(vname)
-    a=[0]
-    res=P1.GetVarValue(vname,a)
-    print("Result from RCU:",res,a)
+#    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()
+#    print(timediff)
+    if not(force) and timediff<90: return myvar;
+    res=P1.GetVarValue(vname,oldvalue)
+    print("Read callback",vname,": Result:",res,oldvalue)
     if res:
-        myvar.Value.Value=a[0]
+        myvar.Value.Value=(oldvalue[0] if len(oldvalue)==1 else oldvalue)
         myvar.SourceTimestamp = datetime.utcnow()
+#        Vars_R[nodeid.Identifier][3]=oldvalue
     return myvar
 
 
@@ -56,10 +67,22 @@ class SubHandler(object):
 
     def datachange_notification(self, node, val, data):
 #        print("Python: New data change event", node, val,data)
-        vname,myvar=Vars_W[node.nodeid.Identifier]
-        print("Value callback",vname,val)
         if not(running): return
-        P1.SetVarValue(vname,[val])
+        vname,myvar=Vars_W[node.nodeid.Identifier]
+        val=(val if isinstance(val, list) else [val] )
+        print("Write callback",vname,val)
+        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:
+                myvar2.Value.Value=(val[0] if len(val)==1 else val)
+                myvar2.SourceTimestamp = datetime.utcnow()
+
 
     def event_notification(self, event):
         print("Python: New event", event)
@@ -75,58 +98,34 @@ def CallMethod(ObjectID,name):
 #P1.SetVarValue("Band1",3)
 Vars_R={}
 Vars_W={}
-def AddVar(name,dtype=0,RW=0):
+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)
+            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)
+            myvar = (PCCobj.add_variable(idx, vname, 0)   if cnt<=1 else PCCobj.add_variable(idx, vname, cnt*[0]))
         print("Variable added: ",vname)
-        Vars_R[myvar.nodeid.Identifier]=[name,myvar.get_data_value()]
-        ValCallback(myvar.nodeid)
+        Vars_R[myvar.nodeid.Identifier]=[name,myvar.get_data_value(),varvalue2]
+        ValCallback(myvar.nodeid,force=True)
 #        print(myvar.get_value())
         server.set_attribute_callback(myvar.nodeid, ValCallback)
-        varvalue=myvar.get_data_value().Value
-   else:
-        if dtype==1:
-          varvalue=0.0
-        else:
-          varvalue=0
+#        varvalue=myvar.get_data_value().Value
+#        Vars_R[myvar.nodeid.Identifier][2]=varvalue
+#        print(varvalue2,varvalue)
 
    if RW in [2,3]:
         vname=name+"_RW";
-        print("Variable added: ",vname,'=',varvalue)
-        myvar2 = PCCobj.add_variable(idx, vname, varvalue)
+        print("Variable added: ",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()]
         handle = sub.subscribe_data_change(myvar2)
 
-if False:
-        varvalue=[0.0 if dtype==1 else 0];
- #  if RW in [1,3]:
-        vname=name+"_R";
-        if dtype==1:
-          myvar = PCCobj.add_variable(idx, vname, varvalue)
-        else:
-          myvar = PCCobj.add_variable(idx, vname, varvalue)
-        Vars_R[myvar.nodeid.Identifier]=[name,myvar.get_data_value()]
-#        ValCallback(myvar.nodeid)
-#        print(myvar.get_value())
-        server.set_attribute_callback(myvar.nodeid, ValCallback)
-        varvalue=myvar.get_data_value().Value
-        print("Variable added: ",vname,varvalue)
-
- #  if RW in [2,3]:
-        vname=name+"_RW";
-        print("Variable added: ",vname,'=',varvalue)
-        myvar2 = PCCobj.add_variable(idx, vname, varvalue)
-        myvar2.set_writable()
-        Vars_W[myvar2.nodeid.Identifier]=[name,myvar2.get_data_value()]
-        handle = sub.subscribe_data_change(myvar2)
-#        print(myvar.value_callback)
-#        myvar.value=1
-#        myvar.value_callback=ValCallback;
 
 def AddMethod(name):
         vname=name;
@@ -147,38 +146,7 @@ P1.GetMethodNames("",AddMethod);
 time.sleep(1)
 running=True;
 
-#RCU=[]
-#for key, value in RCUs.items():
-if False:
- RCU1=rcu.RCU()
- RCU1.loadfile(value)
- RCU1.number=key
- RCU.append(RCU1)
-
- print("Add variables:")
- vals=RCU1.GetVars()
- for v in vals:
-        vname='RCU'+str(key)+"_"+v;
-        myvar = PCCobj.add_variable(idx, vname, 0)
-        Vars[myvar.nodeid.Identifier]=[RCU1,vname,myvar.get_data_value()]
-        ValCallback(myvar.nodeid)
-#        print(myvar.get_value())
-        server.set_attribute_callback(myvar.nodeid, ValCallback)
-
-        vname='RCU'+str(key)+"_"+v;
-        myvar = PCCobj.add_variable(idx, vname, 0)
-
-#        print(myvar.value_callback)
-#        myvar.value=1
-#        myvar.value_callback=ValCallback;
-        print(vname)
- print("Add modes:")
- vals=RCU1.GetModes()
- for v in vals:
-        vname='RCU'+str(key)+"_"+str(v);
-        myvar = PCCobj.add_method(idx, vname, lambda parent: RCU1.changemode(v), [],[] )
-        print(vname)
-      
+print("Server started")   
     
 try:
     while True:

pypcc.py

@@ -2,29 +2,27 @@ from hwdev import hwdev;
 import pylibi2c;
 import time
 #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
 def I2C1server(addr,data,reg=None,read=0):
   try:
+       if read==3:
+           time.sleep(data[0]/1000.)
+           return True
 #       print("I2C",addr,reg,data,read)
        bus=pylibi2c.I2CDevice('/dev/i2c-1',addr)
-       if reg is None: 
-             bus.iaddr_bytes=0
-             reg=0;
-       IsADC=(reg>256)  #This is a hack to get ADC timing right!!
-#       print((bytearray([0x0102])))
-       if read>0:
+       if read==1:
          length=len(data)
-#         if reg>256:
-#         data[:]=bus.ioctl_read(reg,length)
          bus.iaddr_bytes=0
-         if IsADC:
-            time.sleep(0.25) #Neet to be at least 200ms
-            bus.ioctl_write(0,str(bytearray([reg>>8,reg%256])))
-            time.sleep(0.25)
-         else:
-            bus.ioctl_write(0,str(bytearray([reg])))
+         if not(reg is None):
+             bus.ioctl_write(0,str(bytearray([reg])))
          data[:]=[int(x) for x in bus.ioctl_read(0,length)]
-#         print(data)
        else:
+            if reg is None: 
+               bus.iaddr_bytes=0
+               reg=0;
             bus.ioctl_write(reg,str(bytearray(data)))
        return True;
   except:

pypcc_test.py

@@ -2,6 +2,7 @@ from hwdev import hwdev;
 import time
 
 def I2C1server(addr,data,reg=None,read=0):
+       print("I2C:",addr,data,reg,read)
        return True;
 
 class pypcc(hwdev):

test/test_ADCs.py

+#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=0):
+    print("Var:",name,dtype,RW)
+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]);

test_ADCs.py

-#import pypcc;
-import pypcc_test as pypcc;
+import pypcc;
+#import pypcc_test as pypcc;
 
 P1=pypcc.pypcc("LTS_pypcc.yaml")
 
@@ -9,8 +9,8 @@ def AddMethod(name):
 P1.GetMethodNames("",AddMethod);
 
 ##Print all the visible variables
-def AddVar(name,dtype=0,RW=0):
-    print("Var:",name,dtype,RW)
+def AddVar(name,dtype=0,RW=0,dim=1):
+    print("Var:",name,dtype,RW,dim)
 P1.GetVarNames("",AddVar);
 
 a=[0]

test_array.py

+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,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);
+#P1.CallMethod("RCUx_RCU_on",None)
+a=[1.,2.,3.]
+#assert(P1.SetVarValue("RCUx_LED0",[0,0,0]))
+#assert(P1.SetVarValue("RCUx_LED0",[0,0,1]))
+P1.GetVarValue("RCUx_Temperature",a)
+print(a)
+
+#a=[1,2,3]
+#assert(P1.SetVarValue("RCUx_LED0",[0,0,0]))
+#assert(P1.SetVarValue("RCUx_LED0",[0,0,1]))
+#P1.GetVarValue("RCUx_LED0",a)
+#print(a)
+exit()
+#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)
+
+

LTS_RCU2_ADC.yaml → yaml/LTS_RCU2_ADC.yaml

@@ -23,6 +23,7 @@ Variables:
    - var_name: locked
      var_dev:  ADC1.PLL_stat
      var_width: 8
+#     var_R/W:  RO
    - var_name: SYNC
      var_dev:  ADC1.SYNC_control
      var_width: 8
@@ -32,6 +33,7 @@ Variables:
    - var_name: JESD
      var_dev:  ADC1.JESD_control1
      var_width: 8
+     var_R/W:  RO
 
 Methods:
    - method_name: Setup