script/Devices/Elements.py

@@ -119,14 +119,14 @@ elements = (
     (DWSC, "S30CB05-DWSC440", 340.6330),
     (DBPM, "SATDI01-DBPM030", 340.8637),
     (DBPM, "SATDI01-DBPM060", 342.7637),
-    (DWSC, "SATDI01-DWSC065", 342.9837),
     (DBPM, "SATDI01-DBPM210", 349.2197),
     (DBPM, "S30CB06-DBPM420", 349.3150),
     (DBLM, "S30CB06-DBLM445", 349.7625),
     (DBLM, "SATDI01-DBLM225", 349.5613),    
     (DBPM, "SATDI01-DBPM240", 352.1997),
     (DBPM, "SATDI01-DBPM270", 355.1797),
-    #(DWSC, "SATDI01-DWSC290", 356.4797),
+    (DWSC, "SATDI01-DWSC290", 356.3100),
+    (DBLM, "SATDI01-DBLM305", 356.5500),
     (DBPM, "SATDI01-DBPM320", 357.0907),
     (DBPM, "S30CB07-DBPM420", 358.4150),
     (DBPM, "SATCB01-DBPM220", 361.5357),

script/Devices/ShellCommand.py

@@ -0,0 +1,68 @@
+#CAS.setServerPort(5064)
+import java.util.function.BiFunction as BiFunction
+
+class ShellCommand(RegisterBase, RegisterArray):
+    def __init__(self, name):
+        RegisterBase.__init__(self, name)
+        self.val = ""
+        self.debug=False
+        self.max_size = 10000
+
+    def getSize(self):
+        return 1
+        
+    def doRead(self):
+        if self.debug:
+            print "READ: ", self.val
+        return self.val
+        
+    def doWrite(self, val):
+        self.val = "RUNNING"
+        try:
+            if self.debug:            
+                print "WRITE: ", val
+            cmd = str(val[0])
+
+            class eval_callback(BiFunction):
+                def apply(self_callback, ret, ex):
+                    try:
+                        if ex is not None:
+                            err=ex.message
+                            if "Exception:" in err:
+                                err = err[err.index("Exception:")+10:].strip()
+                            self.val = "ERR:" + err  
+                        else:
+                            self.val = "RET:" + str(ret)  
+                        self.val = self.val[0:self.max_size]
+                    except:
+                        err=str(sys.exc_info()[1])
+                        self.val = "EXC: " + err
+                    if self.debug:
+                        print self.val
+                                            
+            #self.val = cmd           
+            get_context().evalLineBackgroundAsync(cmd).handle(eval_callback())
+        except:
+            err=str(sys.exc_info()[1])
+            if "Exception:" in err:
+                err = err[err.index("Exception:")+10:].strip()
+            self.val = "EXC: " + err
+            self.val = self.val[0:self.max_size]
+            if self.debug:
+                print self.val
+        
+
+        
+add_device(ShellCommand("sc"), True)
+cas = CAS("TESTCAS:sc", sc, 'string')
+
+
+
+#print caget("TESTCAS:sc","s")
+#/Users/gobbo_a/anaconda3/envs/epics/epics/bin/darwin-x86
+
+
+
+
+
+

script/Devices/StreamMerger.py

@@ -0,0 +1,93 @@
+import ch.psi.pshell.device.Startable as Startable
+import traceback
+
+class StreamListener (DeviceListener):
+    def __init__(self, merger):
+        self.merger = merger
+    def onCacheChanged(self, device, value, former, timestamp, valueChange):
+        self.merger.update()
+    
+    
+class StreamMerger(DeviceBase, Readable):
+    def __init__(self, name, st1, st2):
+        DeviceBase.__init__(self, name)
+        self.st1=st1
+        self.st2=st2
+        self.pulseId = -1
+        self.v1= None
+        self.v2= None
+        self.initialize()
+        self.running=False
+        self.listener = StreamListener(self)        
+        self.setComponents([st1,st2])
+   
+
+    def doUpdate(self):
+      try:
+        while True:
+            has_more_1 = has_more_2 = False
+            if (self.v1 is None) or ((self.v1 is not None) and (self.v2 is not None) and (self.v1.pulseId < self.v2.pulseId)):
+                if self.st1.bufferCapacity>0:
+                    tm_value = self.st1.popBuffer()
+                    self.v1 = None if tm_value is None else tm_value.value
+                    has_more_1 = (v1 is not None)
+                else: 
+                    self.v1 = self.st1.take()
+            if (self.v2 is None) or ((self.v1 is not None) and (self.v2 is not None) and (self.v1.pulseId > self.v2.pulseId)):
+                if self.st2.bufferCapacity>0:
+                    tm_value = self.st2.popBuffer()
+                    self.v2 = None if tm_value is None else tm_value.value
+                    has_more_2 = (v2 is not None)
+                else: 
+                    self.v2 = self.st2.take()
+            if ((self.v1 is not None) and (self.v2 is not None) and (self.v1.pulseId == self.v2.pulseId)):            
+                if self.v1.pulseId  > self.pulseId:                
+                    keys=self.v1.keys()
+                    keys.addAll(self.v2.keys())
+                    values=self.v1.values()
+                    values.addAll(self.v2.values())
+                    self.pulseId = self.v1.pulseId
+                    self.values, self.keys = values, keys
+                    self.setCache(values, None)            
+                self.v1=self.v2=None   
+            else:
+                if (not has_more_1) and (not has_more_2):
+                    break
+      except Exception, ex:
+            print >> sys.stderr, traceback.format_exc()
+    def doSetMonitored(self,value):
+        if (value):
+            self.st1.addListener(self.listener)
+            self.st2.addListener(self.listener)
+            
+        else:
+            self.st1.removeListener(self.listener)
+            self.st2.removeListener(self.listener)
+
+    def doClose(self):        
+        self.doSetMonitored(False)
+    
+    def getReadables(self):
+        ret = list(self.st1.children + self.st2.children)
+        ret = [item for item in ret if type(item)!=Stream.PidReader]
+        return  [self.st1.getPidReader(),] + ret
+        
+    def read(self):
+        return self.pulseId
+
+    def start(self):
+        if not self.st1.isStarted():
+            self.st1.start()
+        if not self.st2.isStarted():
+            self.st2.start()
+
+    def stop(self):
+        if self.st1.isStarted():
+            self.st1.stop()
+        if self.st2.isStarted():
+            self.st2.stop()
+
+    def isStarted(self):
+        return self.st1.isStarted() and self.st2.isStarted()
+
+    #TODO: Readable children devices