def ch_disable(self, channel): """Disable a channel. Args: channel (int): Channel to be disabled. Raises: ILStateError: The poller is already running. ILValueError: Channel out of range. Returns: int: Status code. """ if self.__running: logger.warning("Poller is running") raise_err(IL_ESTATE) if channel > self.num_channels: logger.error("Channel out of range") raise_err(IL_EINVAL) # Set channel required as disabled self.__mappings_enabled[channel] = False return 0
def trigger_configure(self, mode, delay_samples=0, source=None, th_pos=0., th_neg=0., din_msk=0): """Configure the trigger. Args: mode (MONITOR_TRIGGER): Trigger mode. delay_samples (int, optional): Delay samples. source (str, Register, optional): Source register, required for MONITOR_TRIGGER.POS, MONITOR_TRIGGER.NEG and MONITOR_TRIGGER.WINDOW. th_pos (int, float, optional): Positive threshold, used for MONITOR_TRIGGER.POS, MONITOR_TRIGGER.WINDOW th_neg (int, float, optional): Negative threshold, used for MONITOR_TRIGGER.NEG, MONITOR_TRIGGER.WINDOW din_msk (int, optional): Digital input mask, used for MONITOR_TRIGGER.DIN """ if not isinstance(mode, MONITOR_TRIGGER): raise TypeError('Invalid trigger mode') _source_required = (MONITOR_TRIGGER.POS, MONITOR_TRIGGER.NEG, MONITOR_TRIGGER.WINDOW) if mode in _source_required: _reg, _id = _get_reg_id(source) else: _reg, _id = ffi.NULL, ffi.NULL r = lib.il_monitor_trigger_configure( self._monitor, mode.value, delay_samples, _reg, _id, th_pos, th_neg, din_msk) raise_err(r)
def ch_configure(self, channel, reg): """Configure a poller channel mapping. Args: channel (int): Channel to be configured. reg (Register): Register to associate to the given channel. Returns: int: Status code. Raises: ILStateError: The poller is already running. ILValueError: Channel out of range. TypeError: If the register is not valid. """ if self.__running: logger.warning("Poller is running") raise_err(IL_ESTATE) if channel > self.num_channels: logger.error("Channel out of range") raise_err(IL_EINVAL) # Obtain register _reg = self.servo._get_reg(reg) # Reg identifier obtained and set enabled self.__mappings[channel] = {} self.__mappings[channel][_reg.identifier] = int(_reg.subnode) self.__mappings_enabled[channel] = True return 0
def configure(self, t_s, sz): """Configure data. Args: t_s (int, float): Polling period (s). sz (int): Buffer size. Returns: int: Status code. Raises: ILStateError: The poller is already running. """ if self.__running: logger.warning("Poller is running") raise_err(IL_ESTATE) # Configure data and sizes with empty data self._reset_acq() self.__sz = sz self.__refresh_time = t_s self.__acq['t'] = [0] * sz for channel in range(0, self.num_channels): data_channel = [0] * sz self.__acq['d'].append(data_channel) self.__mappings.append('') self.__mappings_enabled.append(False) return 0
def wait(self, timeout): """Wait until the current acquisition finishes. Args: timeout (int, float): Timeout (s). """ r = lib.il_monitor_wait(self._monitor, to_ms(timeout)) raise_err(r)
def ch_disable(self, ch): """Disable a channel. Args: ch (int): Channel to be disabled. """ r = lib.il_poller_ch_disable(self._poller, ch) raise_err(r)
def save(self, filename): """Save dictionary. Args: filename (str): Output file name/path. """ r = lib.il_dict_save(self._cffi_dictionary, cstr(filename)) raise_err(r)
def ch_disable(self, ch): """Disable a channel. Args: ch (int): Channel identifier. """ r = lib.il_monitor_ch_disable(self._monitor, ch) raise_err(r)
def configure(self, t_s, sz): """Configure the poller. Args: t_s (int, float): Polling period (s). sz (int): Buffer size. """ r = lib.il_poller_configure(self._poller, to_ms(t_s), sz) raise_err(r)
def ch_configure(self, ch, reg): """Configure a channel mapping. Args: ch (int): Channel. reg (str, Register): Register to be mapped to the channel. """ _reg, _id = _get_reg_id(reg) r = lib.il_monitor_ch_configure(self._monitor, ch, _reg, _id) raise_err(r)
def configure(self, t_s, delay_samples=0, max_samples=0): """Configure the monitor parameters. Args: t_s (int, float): Sampling period (s, resolution: 1e-4 s). delay_samples (int, optional): Delay samples. max_samples (int, optional): Maximum acquisition samples. """ r = lib.il_monitor_configure(self._monitor, int(t_s * 1e6), delay_samples, max_samples) raise_err(r)
def ch_disable_all(self): """Disable all channels. Returns: int: Status code. """ for channel in range(self.num_channels): r = self.ch_disable(channel) if r < 0: raise_err(r) return 0
def labels(self, category_id): """Obtain labels for a certain category ID. Returns: dict: Labels dictionary. """ labels_p = ffi.new('il_dict_labels_t **') r = lib.il_dict_cat_get(self.__ipb_dictionary._cffi_dictionary, cstr(category_id), labels_p) raise_err(r) return LabelsDictionary._from_labels(labels_p[0])
def labels(self, scat_id): """Obtain labels for a certain sub-category identifiers. Returns: dict: Labels dictionary. """ labels_p = ffi.new('il_dict_labels_t **') r = lib.il_dict_scat_get(self._dict, cstr(self._cat_id), cstr(scat_id), labels_p) raise_err(r) return LabelsDictionary._from_labels(labels_p[0])
def ch_configure(self, ch, reg): """Configure a poller channel mapping. Args: ch (int): Channel to be configured. reg (Register): Register to associate to the given channel. Raises: TypeError: If the register is not valid. """ _reg, _id = _get_reg_id(reg) r = lib.il_poller_ch_configure(self._poller, ch, _reg, _id) raise_err(r)
def start(self): """Start the poller.""" if self.__running: logger.warning("Poller already running") raise_err(IL_EALREADY) # Activate timer self.__timer = PollerTimer(self.__refresh_time, self._acquire_callback_poller_data) self.__timer.start() self.__time_start = datetime.now() self.__running = True return 0
def start(self): """Start the monitor.""" r = lib.il_monitor_start(self._monitor) raise_err(r)
def ch_disable_all(self): """Disable all channels.""" r = lib.il_poller_ch_disable_all(self._poller) raise_err(r)
def stop(self): """Stop the monitor.""" r = lib.il_monitor_stop(self._monitor) raise_err(r)
def ch_disable_all(self): """Disable all channels.""" r = lib.il_monitor_ch_disable_all(self._monitor) raise_err(r)
def start(self): """Start poller.""" r = lib.il_poller_start(self._poller) raise_err(r)