Beispiel #1
0
def caget_cached(PV_name):
    """Value of Channel Access (CA) Process Variable (PV)"""
    from CA import caget, camonitor
    camonitor(PV_name, callback=CA_cache_update)
    value = caget(PV_name, timeout=0)
    if value is None:
        if cache.exists(PV_name): value = cache.get(PV_name)
    if value is None: value = caget(PV_name)
    if value is None: warn("Failed to get PV %r" % PV_name)
    return value
Beispiel #2
0
 def read(self,nchar=1):
     """Receive data, until either nchar bytes have received or a timeout has
     occurred"""
     caput(self.port+".TMOD",2) # 2 = read
     caput(self.port+".IEOS","\0",wait=True) # no input terminator
     caput(self.port+".NRRD",nchar,wait=True)
     # For unknown reason, following fails at the first try, but succeed at
     # the second try.
     try: caput(self.port+".PROC","1",wait=True) # this will cause it to wait for data
     except: caput(self.port+".PROC","1",wait=True)
     try: return caget(self.port+".TINP")
     except: return caget(self.port+".TINP")
Beispiel #3
0
 def get_integer_register(self, i):
     """Target position in dial units"""
     t0 = time()
     msg = False
     register = caget("NIH:ENSEMBLE.integer_registers[%d]" % i)
     while register is None:
         if time() - t0 > 1 and not msg:
             debug("Ensemble: reading integer register %d: retrying..." % i)
             msg = True
         sleep(0.1)
         register = caget("NIH:ENSEMBLE.integer_registers[%d]" % i)
     if time() - t0 > 1: debug("Ensemble: integer register %d read" % i)
     return register
 def query(self, string, terminator="\n", count=0):
     """Receive data, until either the terminator character was received,
     the number of bytes given by 'count' have have received or
     a timeout has occurred."""
     # The first 'caget' after python statup always fails. As a work-around, use a
     # dummy caget just in case.
     if caget(self.port + ".TMOD") != 0:
         caput(self.port + ".TMOD", 0, wait=True)  # 0 = write/read
     if string.endswith("\n"):
         caput(self.port + ".OEOS", "\n", wait=True)
         string = string[0:-1]
     elif caget(self.port + ".OEOS") != "":
         caput(self.port + ".OEOS", "\0",
               wait=True)  # not output terminator
     if count:
         if caget(self.port + ".IEOS") != "":
             caput(self.port + ".IEOS", "\0", wait=True)  # "\0" = none
     elif terminator:
         if caget(self.port + ".IEOS") != terminator:
             caput(self.port + ".IEOS", terminator,
                   wait=True)  # input terminator
     if caget(self.port + ".IFMT") != 1:
         caput(self.port + ".IFMT", 1, wait=True)  # 1 = hybrid
     if caget(self.port + ".SCAN") != 0:
         caput(self.port + ".SCAN", 0, wait=True)  # 0 = passive
     if caget(self.port + ".NRRD") != count:
         caput(self.port + ".NRRD", count,
               wait=True)  # number of chars (0 = unlimited)
     # If case string contains binary data, EpicsCA would strip away trailing
     # null characters. Sending non-ASCII chacters as except codes
     # makes sure that null characters are sent, too.
     encoded_string = repr(string)[1:-1]
     caput(self.port + ".AOUT", encoded_string, wait=True)
     n = caget(self.port + ".NORD")
     if n == None: n = 0
     if n == 0: return ""  # nothing read
     # With EpicsCA it is (as of June 2009) not possible to reliably retreive
     # special characters from the BINP (binary input) variable, because
     # EpicsCA strips off trailing  carriage return and null characters
     # before passing back a string. Thus, I read the TINP (Text input)
     # variable instead.
     reply = caget(self.port + ".TINP")
     if not reply: reply = ""
     # Special characters in the TINP field are encoded as octal
     # escape sequences. Decode them.
     ##print "reply",repr(reply)
     reply = eval("'" + reply + "'")
     if caget(self.port + ".EOMR") == 2:  # 2 = EOS
         return reply + terminator  # terminator was stripped off, add it back
     return reply
Beispiel #5
0
def remote_shutter_state():
    """Tell the status of 'Remote Shutter' (in beamline frontend).
    Return 'open' or 'closed'"""
    from CA import caget
    state = caget("PA:14ID:A_SHTRS_CLOSED.VAL")
    if state == 1: return "closed"
    if state == 0: return "open"
Beispiel #6
0
 def get_readback_PV(self):
     """Process variable value for the actual position as measured.
 Ususually the value of the RBV process variable, but may me overriden."""
     if not ":" in self.__readback__:
         return getattr(self, self.__readback__)
     else:
         return caget(self.__readback__)
Beispiel #7
0
 def get_value(self):
     PV_state = caget(self.state_PV)
     if PV_state == 1:   state =True
     elif PV_state == 0: state = False
     elif PV_state is None: state = nan
     else: state = False
     return state
Beispiel #8
0
    def save_images(self):
        from PIL import Image
        import logging
        from tempfile import gettempdir
        #/var/folders/y4/cw92kt415kz7wtk13fkjhh2r0000gn/T/samplr_frozen_opt.log'
        import os

        file_path = gettempdir(
        ) + "/Images/Optical_images_march4/log.log"  # gettempdir + "/Optical_images/log.log"
        directory = os.path.dirname(file_path)

        try:
            os.stat(directory)
        except:
            os.mkdir(directory)

        for i in range(360):
            sleep(10)
            while self.is_new_image() != True:
                sleep(0.05)
            if self.is_new_image():
                img = Image.fromarray(
                    camera.RGB_array.transpose((-1, 0, 1)).transpose(
                        (-1, 0, 1)))
                temp = str(caget("NIH:TEMP.RBV"))
                img.save(directory + '/_T_' + temp + '_t_' + str(time()) +
                         '.tiff')
                print('saving',
                      directory + '_T_' + temp + '_t_' + str(time()) + '.tiff')
def scan_once(dT=5, T=22.0, mode=''):
    (P, I, D) = caget('NIH:LIGHTWAVE.PCOF'), caget(
        'NIH:LIGHTWAVE.ICOF'), caget('NIH:LIGHTWAVE.DCOF')
    if mode == 'advance':
        caput('NIH:TEMP.VAL_ADV', T)
        cawait('NIH:TEMP.VAL_ADV')
    else:
        caput('NIH:TEMP.VAL', T)
        cawait('NIH:TEMP.VAL')
    sleep(1)

    while not caget('NIH:TEMP.DMOV'):
        sleep(0.05)
    sleep(1)
    caget('NIH:TEMP.DMOV')

    t_start = time()
    if mode == 'advance':
        caput('NIH:TEMP.VAL_ADV', T + dT)
        cawait('NIH:TEMP.VAL_ADV')
    else:
        caput('NIH:TEMP.VAL', T + dT)
        cawait('NIH:TEMP.VAL')
    sleep(1)

    while not caget('NIH:TEMP.DMOV'):
        sleep(0.05)
    t_end = time()
    sleep(5)
    current = caget('NIH:TEMP.I')
    res = {}
    res['temperature'] = T + dT
    res['current'] = current
    res['t start'] = t_start
    res['t end'] = t_end
    res['dt'] = t_end - t_start
    res['dT'] = dT
    res['P'] = P
    res['I'] = I
    res['D'] = D
    res['oasis_T'] = caget('NIH:CHILLER.VAL')
    if mode == 'advance':
        res['mode'] = 1
    else:
        res['mode'] = 0
    res['data_rbv'] = asarray(
        channel_archiver.history('NIH:LIGHTWAVE.RBV', t_start, t_end))
    res['data_current'] = asarray(
        channel_archiver.history('NIH:LIGHTWAVE.I', t_start, t_end))
    res['data_val'] = asarray(
        channel_archiver.history('NIH:LIGHTWAVE.VAL', t_start, t_end))
    return res
 def get_auto(self):
     from CA import caget
     from numpy import nan
     PV_state = caget(self.auto_PV_name)
     state = nan
     if PV_state == 0: state = False
     if PV_state == 1: state = True
     return state
    def _connect(self):
        try:
            debug("Creating socket")
            self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            debug("Connecting to %r on port 9900" % self.ip_address_server)
            from CA import caget
            try:
                port = int(caget('NIH:DI245.SOCKET')[1])
                ip_address = caget('NIH:DI245.SOCKET')[0]
            except:
                error(traceback.format_exc())
                port = nan

            self.server.connect((self.ip_address_server, port))
            debug("Connection success!")
        except socket.error, msg:
            error("Failed to create and connect. Error code: %s , Error message : %r" % (str(msg[0]), msg[1]))
Beispiel #12
0
 def test(self, event):
     """Check if PVs are working b yreading their current value"""
     from CA import caget
     for i in range(0, self.Table.GetNumberRows()):
         enabled = self.Table.GetCellValue(i, 0) == "Yes"
         PV = str(self.Table.GetCellValue(i, 2))
         value = str(caget(PV)) if (PV and enabled) else ""
         self.Table.SetCellValue(i, 3, value)
     self.update_layout()
 def get_value(self):
     """Is the laser shutter open?"""
     from CA import caget
     PV_state = caget("14IDB:B1Bi0.VAL")
     from numpy import nan
     if PV_state == 0: state = True
     elif PV_state == 1: state = False
     elif PV_state is None: state = nan
     else: state = False
     return state
Beispiel #14
0
 def get(self):
     from timing_system import timing_system
     from CA import caget
     PV_name = eval("timing_system.%s.PV_name" % name)
     # Use "caget" to circumvent caching in the "timing_system" module
     value = caget(PV_name)
     try:
         value = type(default_value)(value)
     except:
         value = default_value
     return value
Beispiel #15
0
def value(name):
    """The value of a process variable, if name is a process variable.
    Otherwise, name is assumed to be the name of a Python object and
    its 'value' property is used.
    name: string, name of EPICS process variable or name of Python variable
    """
    from CA import caget
    try:
        x = eval(name)
    except:
        return tofloat(caget(name))
    return tofloat(getattr(x, "value", x))
 def get(self):
     from CA import caget
     value = caget(prefix(self) + name)
     if value is None: value = default_value
     if type(value) != type(default_value):
         if type(default_value) == list: value = [value]
         else:
             try:
                 value = type(default_value)(value)
             except:
                 value = default_value
     return value
def monitor_PVS(pv):
    from numpy import nan
    from CA import caget
    from time import sleep
    dic[pv] = (0, 0)
    while True:
        sleep(0.5)
        value = caget(pv)
        if type(value) == None or value == nan:
            print('WARNING: %r IS %r' % (pv, value))
            dic[pv] = (dic[pv][0], dic[pv][1] + 1)
        else:
            dic[pv] = (dic[pv][0] + 1, dic[pv][1])
Beispiel #18
0
 def get_integer_registers(self):
     """Target position in dial units"""
     t0 = time()
     msg = False
     registers = None
     while registers is None:
         registers = caget("NIH:ENSEMBLE.integer_registers[:]")
         if registers is None:
             if time() - t0 > 1 and not msg:
                 debug("Ensemble: reading integer registers: retrying...")
                 msg = True
             sleep(0.1)
     if time() - t0 > 1: debug("Ensemble: read integer registers")
     return asarray(registers)
 def get_value(self):
     """Current position in user units"""
     n = self.motor_number
     value = tofloat(caget("NIH:ENSEMBLE.values[%d]" % n))
     value = round_next(value, self.stepsize)
     return value
Beispiel #20
0
 def get_moving(self):
   return (caget(self.rec_name+":Busy.VAL") != 0)
Beispiel #21
0
 def get_name(self):
   name = caget(self.rec_name+":Device")
   if name == None: name = ""
   return name
Beispiel #22
0
 def get_readback_value(self):
   value = caget(self.rec_name+":Gap.VAL")
   if value == None: value = NaN
   return value
Beispiel #23
0
 def get_command_value(self):
   value = caget(self.rec_name+":GapSet.VAL")
   if value == None: value = NaN
   return value
 def get_count_time(self):
     return caget(self.ioc_name + ".S1") / 1e7
 def get_name(self):
     return caget(self.ioc_name + ".NM" + self.channel)
 def get_count(self):
     return caget(self.ioc_name + ".S" + self.channel)
Beispiel #27
0
 def get_value(self):
     """Is the illuminator currently in the X-ray beam?"""
     from CA import caget
     inserted = (caget("14IDB:Dliepcr1:Out1Mbbi") == 1)
     if self.moving: return not inserted
     return inserted
Beispiel #28
0
 def get_command_PV(self):
     """Process variable value for the motor target position.
 Ususually the value of the VAL process variable, but may me overriden."""
     if not ":" in self.__command__: return getattr(self, self.__command__)
     else: return caget(self.__command__)
 def get_enabled(self):
     """Is holding the current turned on?"""
     n = self.motor_number
     return tobool(caget("NIH:ENSEMBLE.enabled[%d]" % n))
 def get_moving(self):
     """Target position"""
     n = self.motor_number
     return tobool(caget("NIH:ENSEMBLE.moving[%d]" % n))