Ejemplo n.º 1
0
 def avantesSetMeasAttribute(self):
     data = np.ctypeslib.as_array(self.data.c_double_array)
     data = np.resize(data, GLOBAL_VARS['MAXIMUM_PIXELS_RANGE'])
     try:
         setattr(self.data, self.data.type, data)
     except AttributeError:
         if __debug__:
             log.error('Uspecified attribute for data storing')
Ejemplo n.º 2
0
    def __init__(self, args):
        super().__init__()
        self.device = dev.Device(args.dev, args.cfg)

        if not self.device.cfg:
            if __debug__:
                log.error('Config was not loaded')
            exit(-1)
Ejemplo n.º 3
0
def garbageCollect(): #Run this when we have an empty server (or during a map change...)
    global THREADS
    alives = 0
    for x, i in enumerate(THREADS):
        if not i.isAlive(): del THREADS[x]
        else: alives += 1
    log.info('Garbage Collected Threads. %s still alive...' % alives)
    if alives > config_maxthreads:
        log.error('Wow... way too many threads for our thread limit! Somethings wrong...')
Ejemplo n.º 4
0
    def channelStartingError(self, channelnum, code, desc):
        """
        Action to take when a negative RPY to a channel
        start message is received.

        @param channelnum: the channel number that failed to start
        """
        log.error("Failed to start channel: %d %s" % (code, desc))
        self.shutdown()
Ejemplo n.º 5
0
 def next(self):
     message = self._sock.recv()
     log.info("Recieved message: %s", message)
     try:
         has, wants, user, type, amount, ts = self.__match_request(message).groups()
         return Request(user, type, amount, has, wants, ts)
     except AttributeError:
         log.error("Malformed message! %s did not match: %s", self.__match_request, message)
         return None
Ejemplo n.º 6
0
 def __init__(self, devType, devCfg):
     self.cfg = None
     self.handler = None
     self.devList = None
     self.data = data.Data()
     self.devType = devType
     self.cfgType = devCfg
     self.initialize()
     if not self.deviceSelfTest():
         if __debug__:
             log.error('Unsuccessful device self test')
         exit(-6)
Ejemplo n.º 7
0
    def avantes(self):
        """
        Value '0' means communication via 'USB'
        """
        if ava.init(ct.c_short(0)) <= 0:
            if __debug__:
                log.error('Unsuccessful initialization')
            exit(-2)
        else:
            self.devList = (AvsIdentityType
                            * GLOBAL_VARS['DEVICES_AMOUNT'])()

            ava.getListOfDevices(sizeof(self.devList),
                                 ct.c_uint(1), self.devList)

            """
            Activation of the first 'not used' device
            in the device list.
            Probably should be changed to device ID
            (serial number which is a message queue name)
            """
            for device in self.devList:
                if device._status[0] == 1:
                    self.handler = ava.activate(device)
                    break

            if not self.handler:
                if __debug__:
                    log.error('No handler for device')
                exit(-3)

            pixelRange = ct.c_ushort(0)
            ava.getNumPixels(self.handler, pixelRange)
            pixelRange.value -= 1
            GLOBAL_VARS['MAXIMUM_PIXELS_RANGE'] = pixelRange.value
            self.cfg = MeasConfigType(self.cfgType)
            """
            If the config was set to 'user'
            the stop pixel value won't be updated
            """
            if self.cfgType != 'user':
                self.cfg.loadCfg({'_stopPixel': pixelRange.value})
            
            """
            Pickle cannot handle such types in a raw
            format
            """
            self.devList = None

            return self.deviceSelfTest()
        return False
Ejemplo n.º 8
0
    def createChannelZero(self):
        """
        Create the Channel 0 for the Session.
        A special case of createChannel that explicitly binds the channel
        to the BEEPManagementProfile.
        
        Should only get called once when a Session initialises
        """
        if self.channels.has_key(0):
            log.error("Attempted to create a Channel 0 when one already exists!")
            raise SessionException("Can't create more than one Channel 0")

        else:
            profile = beepmgmtprofile.BEEPManagementProfile()
            channel = self.createChannel(0, profile)
            profile.channelStarted(channel, "", "")
Ejemplo n.º 9
0
 def receive(self, timeout=5):
     try:
         # loading message from queue
         self.message = pickle.loads(
             self.queues[0][1].receive(timeout=timeout)[0])
         """
         Setting name of a queue in order
         to send a response
         """
         if 'response' in self.message.keys():
             self.queues[1][0] = self.message['response']
             self.setSendQueue()
         return True
     except posix.BusyError:
         if __debug__:
             log.error('Timeout occur while receiving message')
         return False
Ejemplo n.º 10
0
    def measure_avantes(self):
        global MEASUREMENT_TIMEOUT
        global is_measurement_available
        global measuring_thread

        exitStatus = ava.prepareMeasure(self.handler, self.cfg)
        if __debug__:
            log.warning('Prepare measurenet function return %s',
                        ERROR_CODES_MESSAGES[exitStatus])
        if exitStatus == 0:
            if self.data.type != 'black':
                ava.setDigitalOut(self.handler, c_ubyte(3), c_ubyte(1))
            else:
                ava.setDigitalOut(self.handler, c_ubyte(3), c_ubyte(0))

            if self.cfg.amount == -1:
                # infinite measurement
                exitStatus = ava.measure(self.handler,
                                         call_back,
                                         c_short(self.cfg.amount))

                measuring_thread = threading.Thread(target=self.infinite_measure)
                measuring_thread.start()
            else:
                exitStatus = ava.measure(self.handler,
                                         call_back,
                                         c_short(self.cfg.amount))
                if __debug__:
                    log.warning('Measurement function return %s',
                                ERROR_CODES_MESSAGES[exitStatus])

                if exitStatus == 0:
                    """
                    Main thread stop as a workaround for
                    Incorrect behavior
                    """
                    if not is_measurement_available.wait(timeout=MEASUREMENT_TIMEOUT):
                        if __debug__:
                            log.error('Measurement timeout occur %s',
                                      ERROR_CODES_MESSAGES[exitStatus])
                        return False
                    else:
                        is_measurement_available.clear()
                        # arbitrary defined timeout time
                        return self.avantesGetScopeData()
        return False
Ejemplo n.º 11
0
    def infinite_measure(self):
        global stop_measuring
        while not stop_measuring.is_set():
            time.sleep(0.5)
            exitStatus = ava.getScopeData(self.handler,
                                          c_uint(1),
                                          self.data.c_double_array)
            if exitStatus == 0:
                avantesSetMeasAttribute()
                if self.data.type == 'analyte':
                    self.data.calcAbsorbance()

            if __debug__:
                log.error('While loop return %s',
                          ERROR_CODES_MESSAGES[exitStatus])
            # hook to update the graph
            # socket io for flask
            # js on web page
        return True
Ejemplo n.º 12
0
    def closeAllChannels(self):
        """
        Attempts to close all channels on this Session
        """
        try:
            for channelnum in self.channels.keys():
                if channelnum != 0:
                    self.closeChannel(channelnum)
                    log.debug("Finished queueing closure of %d" % channelnum)
            ## Close channel 0 last
            # FIXME: We DO NOT close channel 0 to avoid race condition because
            # the client should close it
            # self.closeChannel(0)

        except Exception, e:
            # If we can't close a channel, we must remain active
            # FIXME: more detailed error handling required here
            log.error("Unable to close Session: %s" % e)
            traceback.print_exc()
Ejemplo n.º 13
0
    def setSendQueue(self, qname=None):
        """
        Name of a queue, where all messages
        will be sent should be specified in first use

        After that, the queue will be set to appropriate one
        which comes in 'response' key in message dict
        Might be changed with appopriate function call
        """
        if qname is not None:
            qname = '/' + qname
            self.queues[1][0] = qname
        try:
            if ((qname is None) and (self.queues[1][0]) is not None):
                qname = self.queues[1][0]
            """
            Setting receiver message queue if exist
            in order to send messages
            """
            self.queues[1][1] = posix.MessageQueue(qname)
            return True

        except ValueError as error:
            if __debug__:
                log.error(error)
                log.error('Queue name should be specified')
            return False

        except posix.ExistentialError:
            if __debug__:
                log.error('Cannot open queue %s', qname)
            return False
        return False
Ejemplo n.º 14
0
    def avantesGetScopeData(self):
        """
        Scoped data should be collected as many times,
        as measurement amount was set
        (amount of measurements)
        """
        for i in range (0, self.cfg.amount):
            """
            Data might not be ready yet,
            so a procedure will be repeated a few more times,
            for successful data collection
            """
            timeout = time.time() + 6
            while time.time() < timeout:
                time.sleep(0.5)
                exitStatus = ava.getScopeData(self.handler,
                                              c_uint(1),
                                              self.data.c_double_array)

                if exitStatus != 0:
                    if __debug__:
                        log.error('Cannot get scoped data %s',
                                  ERROR_CODES_MESSAGES[exitStatus])
                else:
                    break

            """
            Device hadn't sent the data
            errors in communication might be
            """
            if exitStatus != 0:
                if __debug__:
                    log.warning('Data receiving timeout')
                return False

            self.avantesSetMeasAttribute()
            if self.data.type == 'analyte':
                exitStatus = self.data.calcAbsorbance()

        return True
Ejemplo n.º 15
0
 def authenticationFailed(self, errorCode, errorReason):
     log.error('Authentication failed: [%s] %s' % (errorCode, errorReason) )
     raise SessionException('Authentication Failed')