structured in directories

I2Cswitch1.py → i2c/I2Cswitch1.py

 import numpy as np
 import logging
-import HWconf
+#import HWconf
+SWaddr=0x70
 class I2Cswitch1():
     def __init__(self,callback1):
         self.callback1=callback1;
@@ -10,7 +11,7 @@ class I2Cswitch1():
         if (channel)==self.CurrentChannel: return True;
         logging.debug(str(("SetChannel",channel,self.CurrentChannel)))
         self.CurrentChannel=channel
-        return self.callback1(HWconf.SW1_ch.Addr,[channel])
+        return self.callback1(SWaddr,[channel])
 
     def I2Ccallback(self,RCU,addr,data,reg=None,read=0):
         self.callback1(addr,data,reg,read)    

opcuaserv.py

@@ -6,13 +6,13 @@ import time
 from opcua import ua, Server
 from datetime import datetime;
 import logging
-import Vars
+#import Vars
 #import HWconf
 
 Vars_R={}
 Vars_W={}
-EventPipes=[]
 running=False
+
 class SubHandler(object):
     """
     Subscription Handler. To receive events from server for a subscription
@@ -20,14 +20,14 @@ class SubHandler(object):
     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]
+        vname,myvar,VarD,Q1=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)
+        Q1.put(Inst)
  #       P1.SetVarValue(vname,val)
         #readback
 #        if True:
@@ -42,10 +42,10 @@ class SubHandler(object):
         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)
+def CallMethod(ObjectID,name,Inst1,Q1):
+        logging.info(str(("Callmethod",ObjectID,name)))
+#        Inst1=Vars.Instr(Vars.DevType.Instr,instrs,0,[])
+        Q1.put(Inst1)
 
 #        P1.CallMethod(name,None)
 
@@ -54,10 +54,29 @@ def AddVar(name,value):
     myvar2.set_writable()
     return myvar2
 
+def AddVarR(vname,varvalue2,v):
+    myvar = PCCobj.add_variable(idx, vname, varvalue2)
+    logging.info(str(("Variable added: ",vname,len(varvalue2))))
+    Vars_R[myvar.nodeid.Identifier]=[v.name,myvar.get_data_value(),varvalue2,v]
+    return myvar
+
+def AddVarW(vname,varvalue2,v,Q1):
+    logging.info(str(("Variable added: ",vname)))#,'=',varvalue2)
+    myvar2 = PCCobj.add_variable(idx, vname, varvalue2)
+    myvar2.set_writable()
+    Vars_W[myvar2.nodeid.Identifier]=[v.name,myvar2.get_data_value(),v,Q1]
+    handle = sub.subscribe_data_change(myvar2)
+    return myvar2
+
+
+def Addmethod(vname,v,Q1):
+    myvar = PCCobj.add_method(idx, vname, lambda ObjectId,name=vname,inst=v,Q1=Q1 : CallMethod(ObjectId,name,inst,Q1), [],[] )
+    logging.info(str(("AddMethod:",vname)))
+
 def InitServer(port=4840):
 
 # setup our server
-    global server,running,PCCobj,idx;
+    global server,running,PCCobj,idx,sub;
     server = Server()
     server.set_endpoint("opc.tcp://0.0.0.0:{}/PCC/".format(port))
 
@@ -80,50 +99,14 @@ def InitServer(port=4840):
     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
-#        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)
-
-
-    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)))
-
+#    time.sleep(1)
+#    running=True
+#    return Vars_R,Vars_W
+    return
+#exit()
 
-    time.sleep(1)
+def start():
     running=True
-    return Vars_R,Vars_W
-
-#exit()
 
 #print("Add modes:")
 #P1.GetMethodNames("",AddMethod);

pypcc2.py

@@ -3,13 +3,13 @@ try:
  import queue
 except ImportError:
  import Queue as queue;
-import RCU
-import I2Cswitch1
+from rcu import RCU
+from i2c import I2Cswitch1
 import threading
 import signal
 import sys
 import time
-import Vars
+#import Vars
 import logging
 import argparse
 
@@ -27,57 +27,33 @@ if not isinstance(loglevel_nr, int):
 
 logging.basicConfig(level=loglevel_nr,format='%(asctime)s [%(levelname)-8s,%(filename)-20s:%(lineno)-3d] %(message)s')
 if args.simulator:
-    import I2C_dummy as I2C
+    from i2c import I2C_dummy as I2C
 else:
-    import I2C
+    from i2c 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(32,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)
+RCU.AddVars(Q1,opcuaserv.AddVarR,opcuaserv.AddVarW)
+RCU.AddMethod(Q1,opcuaserv.Addmethod)
 
-#Inst1=Vars.Instr(Vars.DevType.Instr,Vars.RCU_on,0,[])
-#RCU.SetVar(Inst1)
+RCU.load() #Load current register values from HW
 
-#Inst1=Vars.Instr(Vars.DevType.Instr,Vars.ADC1_on,0,[])
-#RCU.SetVar(Inst1)
-
-#print(Vars.RCU)
-logging.debug(str(("I2C bytes=",I2C.I2Ccounter)))
+#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()
+RCUthread1=RCU.start(Q1)
 
 RunTimer=True;
 def TimerThread(Q1,RCU):
@@ -93,10 +69,7 @@ def TimerThread(Q1,RCU):
          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,32,[0]*32)
-         Q1.put(Inst1)
-         Inst1=Vars.Instr(Vars.DevType.VarUpdate,Vars.RCU_ADC_lock,96,[0]*96)
-         Q1.put(Inst1)
+         RCU.Queue_Monitor(Q1)
 
     logging.info("End Timer thread")
 
@@ -112,6 +85,9 @@ def signal_handler(sig, frame):
     RunTimer=False
 signal.signal(signal.SIGINT, signal_handler)
 
+time.sleep(1)
+opcuaserv.start()
+
 try:
 #Do nothing.
  while RunTimer:

RCU.py → rcu/RCU.py

-import Vars
+from . import Vars
 import numpy as np
 import logging
-from spibitbang1 import *
+from .spibitbang1 import *
+import threading
+
 
 def ApplyMask(value,width=8,bitoffset=0,previous=0):
     mask=(1<<width)-1
@@ -35,6 +37,29 @@ class RCU1():
         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,Mask=[]):
         if Instr.type==Vars.DevType.Instr:
               #Execute instructions
@@ -243,5 +268,42 @@ class RCU1():
         #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=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]:
+            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)

Vars.py → rcu/Vars.py

 from collections import namedtuple
 from recordclass import recordclass
 from enum import Enum
-from HWconf import *
+from .HWconf import *
 
 #OPCUA variables
 class RW(Enum):