コード例 #1
0
class Node():
    def __init__(self):

        self._responses_cond = threading.Condition()
        self._responses = collections.deque()
        self._event_cond = threading.Condition()
        self._events = collections.deque()

        self._datas = queue.Queue()

        self.channels = {}

        self.ant = Ant()

        self._running = True

        self._worker_thread = threading.Thread(target=self._worker,
                                               name="ant.easy")
        self._worker_thread.start()

    def new_channel(self, ctype, network_number=0x00, ext_assign=None):
        size = len(self.channels)
        channel = Channel(size, self, self.ant)
        self.channels[size] = channel
        channel._assign(ctype, network_number, ext_assign)
        return channel

    def request_message(self, messageId):
        _logger.debug("requesting message %#02x", messageId)
        self.ant.request_message(0, messageId)
        _logger.debug("done requesting message %#02x", messageId)
        return self.wait_for_special(messageId)

    def set_network_key(self, network, key):
        self.ant.set_network_key(network, key)
        return self.wait_for_response(Message.ID.SET_NETWORK_KEY)

    def wait_for_event(self, ok_codes):
        return wait_for_event(ok_codes, self._events, self._event_cond)

    def wait_for_response(self, event_id):
        return wait_for_response(event_id, self._responses,
                                 self._responses_cond)

    def wait_for_special(self, event_id):
        return wait_for_special(event_id, self._responses,
                                self._responses_cond)

    def _worker_response(self, channel, event, data):
        self._responses_cond.acquire()
        self._responses.append((channel, event, data))
        self._responses_cond.notify()
        self._responses_cond.release()

    def _worker_event(self, channel, event, data):
        if event == Message.Code.EVENT_RX_BURST_PACKET:
            self._datas.put(('burst', channel, data))
        elif event == Message.Code.EVENT_RX_BROADCAST:
            self._datas.put(('broadcast', channel, data))
        else:
            self._event_cond.acquire()
            self._events.append((channel, event, data))
            self._event_cond.notify()
            self._event_cond.release()

    def _worker(self):
        self.ant.response_function = self._worker_response
        self.ant.channel_event_function = self._worker_event

        # TODO: check capabilities
        self.ant.start()

    def _main(self):
        while self._running:
            try:
                (data_type, channel, data) = self._datas.get(True, 1.0)
                self._datas.task_done()

                if data_type == 'broadcast':
                    self.channels[channel].on_broadcast_data(data)
                elif data_type == 'burst':
                    self.channels[channel].on_burst_data(data)
                else:
                    _logger.warning("Unknown data type '%s': %r", data_type,
                                    data)
            except queue.Empty as e:
                pass

    def start(self):
        self._main()

    def stop(self):
        if self._running:
            _logger.debug("Stoping ant.easy")
            self._running = False
            self.ant.stop()
            self._worker_thread.join()
コード例 #2
0
ファイル: node.py プロジェクト: pirower/openant
class Node:
    def __init__(self):

        self._responses_cond = threading.Condition()
        self._responses = collections.deque()
        self._event_cond = threading.Condition()
        self._events = collections.deque()
        self._main_thread = None

        self._datas = queue.Queue()

        self.ant = Ant()

        self._running = True

        self._worker_thread = threading.Thread(target=self._worker,
                                               name="ant.easy")
        self._worker_thread.start()

        self.capabilities = self.get_capabilities()

        self.channels = [None] * self.capabilities["max_channels"]

    def new_channel(self, ctype, network_number=0x00, ext_assign=None):
        for i in range(len(self.channels)):
            if self.channels[i] is None:
                channel = Channel(i, self, self.ant)
                self.channels[i] = channel
                channel._assign(ctype, network_number, ext_assign)
                return channel
        _logger.debug("No free channel available")
        return None

    def remove_channel(self, channel_id):
        for i in range(len(self.channels)):
            try:
                if self.channels[i].id == channel_id:
                    self.channels[i].close()
                    self.channels[i]._unassign()
                    self.channels[i] = None
            except:
                pass

    def get_capabilities(self):
        data = self.request_message(Message.ID.RESPONSE_CAPABILITIES)
        if data[1] == Message.ID.RESPONSE_CAPABILITIES:
            #The Standard Options bit field is encoded as follows:
            #   Bit 0 - CAPABILITIES_NO_RECEIVE_CHANNELS
            #   Bit 1 - CAPABILITIES_NO_TRANSMIT_CHANNELS
            #   Bit 2 - CAPABILITIES_NO_RECEIVE_MESSAGES
            #   Bit 3 - CAPABILITIES_NO_TRANSMIT_MESSAGES
            #   Bit 4 - CAPABILITIES_NO_ACKD_MESSAGES
            #   Bit 5 - CAPABILITIES_NO_BURST_MESSAGES
            #   Other bits are reserved
            #The Advanced Options bit field is encoded as follows:
            #   Bit 1 - CAPABILITIES_NETWORK_ENABLED
            #   Bit 3 - CAPABILITIES_SERIAL_NUMBER_ENABLED
            #   Bit 4 - CAPABILITIES_PER_CHANNEL_TX_POWER_ENABLED
            #   Bit 5 - CAPABILITIES_LOW_PRIORITY_SEARCH_ENABLED
            #   Bit 6 - CAPABILITIES_SCRIPT_ENABLED
            #   Bit 7 - CAPABILITIES_SEARCH_LIST_ENABLED
            #   Other bits are reserved
            #The Advanced Options 2 bit field is encoded as follows:
            #   Bit 0 - CAPABILITIES_LED_ENABLED
            #   Bit 1 - CAPABILITIES_EXT_MESSAGE_ENABLED
            #   Bit 2 - CAPABILITIES_SCAN_MODE_ENABLED
            #   Bit 3 - Reserved
            #   Bit 4 - CAPABILITIES_PROX_SEARCH_ENABLED
            #   Bit 5 - CAPABILITIES_EXT_ASSIGN_ENABLED
            #   Bit 6 - CAPABILITIES_FS_ANTFS_ENABLED
            #   Bit 7 - CAPABILITIES_FIT1_ENABLED
            #   Other bits are reserved
            #The Advanced Options 3 bit field is encoded as follows:
            #   Bit 0 - CAPABILITIES_ADVANCED_BURST_ENABLED
            #   Bit 1 - CAPABILITIES_EVENT_BUFFERING_ENABLED
            #   Bit 2 - CAPABILITIES_EVENT_FILTERING_ENABLED
            #   Bit 3 - CAPABILITIES_HIGH_DUTY_SEARCH_ENABLED
            #   Bit 4 - CAPABILITIES_SEARCH_SHARING_ENABLED
            #   Bit 5 - Reserved.
            #   Bit 6 - CAPABILITIES_SELECTIVE_DATA_UPDATES_ENABLED
            #   Bit 7 - CAPABILITIES_ENCRYPTED_CHANNEL_ENABLED
            #The Advanced Options 4 bit field is encoded as follows:
            #   Bit 0 - CAPABILITIES_RFACTIVE_NOTIFICATION_ENABLED
            #   Other bits are reserved
            result = {
                "max_channels": data[2][0],
                "max_networks": data[2][1],
                "standard_options": data[2][2],
                "advanced_options": data[2][3],
                "advanced_options2": data[2][4],
                "max_sensrcore_channels": data[2][5],
            }
            if len(data[2]) >= 7:
                result["advanced_options3"] = data[2][6]
            if len(data[2]) >= 8:
                result["advanced_options4"] = data[2][7]
            return result
        else:
            _logger.debug(
                "capabilities requested and not received (message id 0x{:02x} , but should be 0x{:02x})"
                .format(data[2][4], Message.ID.RESPONSE_CAPABILITIES))
            return

    def request_message(self, messageId):
        _logger.debug("requesting message %#02x", messageId)
        self.ant.request_message(0, messageId)
        _logger.debug("done requesting message %#02x", messageId)
        return self.wait_for_special(messageId)

    def set_network_key(self, network, key):
        self.ant.set_network_key(network, key)
        return self.wait_for_response(Message.ID.SET_NETWORK_KEY)

    def wait_for_event(self, ok_codes):
        return wait_for_event(ok_codes, self._events, self._event_cond)

    def wait_for_response(self, event_id):
        return wait_for_response(event_id, self._responses,
                                 self._responses_cond)

    def wait_for_special(self, event_id):
        return wait_for_special(event_id, self._responses,
                                self._responses_cond)

    def _worker_response(self, channel, event, data):
        self._responses_cond.acquire()
        self._responses.append((channel, event, data))
        self._responses_cond.notify()
        self._responses_cond.release()

    def _worker_event(self, channel, event, data):
        if event == Message.Code.EVENT_RX_BURST_PACKET:
            self._datas.put(("burst", channel, data))
        elif event == Message.Code.EVENT_RX_BROADCAST:
            self._datas.put(("broadcast", channel, data))
        elif event == Message.Code.EVENT_TX:
            self._datas.put(("broadcast_tx", channel, data))
        elif event == Message.Code.EVENT_RX_ACKNOWLEDGED:
            self._datas.put(("acknowledge", channel, data))
        else:
            self._event_cond.acquire()
            self._events.append((channel, event, data))
            self._event_cond.notify()
            self._event_cond.release()

    def _worker(self):
        self.ant.response_function = self._worker_response
        self.ant.channel_event_function = self._worker_event

        # TODO: check capabilities
        self.ant.start()

    def _main(self):
        while self._running:
            try:
                (data_type, channel, data) = self._datas.get(True, 1.0)
                self._datas.task_done()

                if data_type == "broadcast":
                    self.channels[channel].on_broadcast_data(data)
                elif data_type == "burst":
                    self.channels[channel].on_burst_data(data)
                elif data_type == "broadcast_tx":
                    self.channels[channel].on_broadcast_tx_data(data)
                elif data_type == "acknowledge":
                    self.channels[channel].on_acknowledge_data(data)
                else:
                    _logger.warning("Unknown data type '%s': %r", data_type,
                                    data)
            except queue.Empty as e:
                pass

    def start(self):
        self._main_thread = threading.Thread(target=self._main, name="_main")
        self._main_thread.start()

    def stop(self):
        if self._running:
            _logger.debug("Stoping ant.easy")
            self._running = False
            self.ant.stop()
            self._worker_thread.join()
            self._main_thread.join()
            self._main_thread = None
コード例 #3
0
ファイル: node.py プロジェクト: KunYi/openant
class Node():
    def __init__(self):

        self._responses_cond = threading.Condition()
        self._responses = collections.deque()
        self._event_cond = threading.Condition()
        self._events = collections.deque()

        self._datas = queue.Queue()

        self.channels = {}

        self.ant = Ant()

        self._running = True

        self._worker_thread = threading.Thread(target=self._worker, name="ant.easy")
        self._worker_thread.start()

    def new_channel(self, ctype):
        size = len(self.channels)
        channel = Channel(size, self, self.ant)
        self.channels[size] = channel
        channel._assign(ctype, 0x00)
        return channel

    def request_message(self, messageId):
        _logger.debug("requesting message %#02x", messageId)
        self.ant.request_message(0, messageId)
        _logger.debug("done requesting message %#02x", messageId)
        return self.wait_for_special(messageId)

    def set_network_key(self, network, key):
        self.ant.set_network_key(network, key)
        return self.wait_for_response(Message.ID.SET_NETWORK_KEY)

    def wait_for_event(self, ok_codes):
        return wait_for_event(ok_codes, self._events, self._event_cond)

    def wait_for_response(self, event_id):
        return wait_for_response(event_id, self._responses, self._responses_cond)

    def wait_for_special(self, event_id):
        return wait_for_special(event_id, self._responses, self._responses_cond)

    def _worker_response(self, channel, event, data):
        self._responses_cond.acquire()
        self._responses.append((channel, event, data))
        self._responses_cond.notify()
        self._responses_cond.release()

    def _worker_event(self, channel, event, data):
        if event == Message.Code.EVENT_RX_BURST_PACKET:
            self._datas.put(('burst', channel, data))
        elif event == Message.Code.EVENT_RX_BROADCAST:
            self._datas.put(('broadcast', channel, data))
        else:
            self._event_cond.acquire()
            self._events.append((channel, event, data))
            self._event_cond.notify()
            self._event_cond.release()

    def _worker(self):
        self.ant.response_function = self._worker_response
        self.ant.channel_event_function = self._worker_event

        # TODO: check capabilities
        self.ant.start()

    def _main(self):
        while self._running:
            try:
                (data_type, channel, data) = self._datas.get(True, 1.0)
                self._datas.task_done()

                if data_type == 'broadcast':
                    self.channels[channel].on_broadcast_data(data)
                elif data_type == 'burst':
                    self.channels[channel].on_burst_data(data)
                else:
                    _logger.warning("Unknown data type '%s': %r", data_type, data)
            except queue.Empty as e:
                pass

    def start(self):
        self._main()

    def stop(self):
        if self._running:
            _logger.debug("Stoping ant.easy")
            self._running = False
            self.ant.stop()
            self._worker_thread.join()
コード例 #4
0
class Node:
    def __init__(self):

        self._responses_cond = threading.Condition()
        self._responses = collections.deque()
        self._event_cond = threading.Condition()
        self._events = collections.deque()

        self._datas = queue.Queue()

        self.channels = {}

        self.ant = Ant()

        self._running = True

        self._worker_thread = threading.Thread(target=self._worker, name="ant.easy")
        self._worker_thread.start()

    def new_channel(self, ctype, network_number=0x00, ext_assign=None):
        size = len(self.channels)
        channel = Channel(size, self, self.ant)
        self.channels[size] = channel
        channel._assign(ctype, network_number, ext_assign)
        return channel

    def delete_channel(self):
        if len(self.channels) > 0:
            c = self.channels.pop(len(self.channels)-1)
            self.ant.unassign_channel(c.id)
            c.get_channel_status()
            del c

    def request_message(self, messageId):
        _logger.debug("requesting message %#02x", messageId)
        self.ant.request_message(0, messageId)
        _logger.debug("done requesting message %#02x", messageId)
        return self.wait_for_special(messageId)

    def set_network_key(self, network, key):
        self.ant.set_network_key(network, key)
        return self.wait_for_response(Message.ID.SET_NETWORK_KEY)

    def set_lib_config(self, value):
      # 0: Disabled
      # 0x20: Enables Rx Timestamp Output
      # 0x40: Enables RSSI Output
      # 0x80: Enables Channel ID Output
      self.ant.set_lib_config(value)
      return self.wait_for_response(Message.ID.LIB_CONFIG)

    def set_tx_power(self, value):
      # 0: low, 1...2, 3: High(0dBm), (4: N/A or High(4dbm))
      self.ant.set_tx_power(value)
      return self.wait_for_response(Message.ID.SET_TRANSMIT_POWER)

    def wait_for_event(self, ok_codes):
        return wait_for_event(ok_codes, self._events, self._event_cond)

    def wait_for_response(self, event_id):
        return wait_for_response(event_id, self._responses, self._responses_cond)

    def wait_for_special(self, event_id):
        return wait_for_special(event_id, self._responses, self._responses_cond)

    def _worker_response(self, channel, event, data):
        self._responses_cond.acquire()
        self._responses.append((channel, event, data))
        self._responses_cond.notify()
        self._responses_cond.release()

    def _worker_event(self, channel, event, data):
        if event == Message.Code.EVENT_RX_BURST_PACKET:
            self._datas.put(("burst", channel, data))
        elif event == Message.Code.EVENT_RX_BROADCAST:
            self._datas.put(("broadcast", channel, data))
        elif event == Message.Code.EVENT_TX:
            self._datas.put(("broadcast_tx", channel, data))
        elif event == Message.Code.EVENT_RX_ACKNOWLEDGED:
            self._datas.put(("acknowledge", channel, data))
        else:
            self._event_cond.acquire()
            self._events.append((channel, event, data))
            self._event_cond.notify()
            self._event_cond.release()

    def _worker(self):
        self.ant.response_function = self._worker_response
        self.ant.channel_event_function = self._worker_event

        # TODO: check capabilities
        self.ant.start()

    def _main(self):
        while self._running:
            try:
                (data_type, channel, data) = self._datas.get(True, 1.0)
                self._datas.task_done()

                if data_type == "broadcast":
                    self.channels[channel].on_broadcast_data(data)
                elif data_type == "burst":
                    self.channels[channel].on_burst_data(data)
                elif data_type == "broadcast_tx":
                    self.channels[channel].on_broadcast_tx_data(data)
                elif data_type == "acknowledge":
                    self.channels[channel].on_acknowledge_data(data)
                else:
                    _logger.warning("Unknown data type '%s': %r", data_type, data)
            except queue.Empty as e:
                pass

    def start(self):
        self._main()

    def stop(self):
        if self._running:
            _logger.debug("Stoping ant.easy")
            self._running = False
            self.ant.stop()
            self._worker_thread.join()
コード例 #5
0
class Node:
    def __init__(self):

        self._responses_cond = threading.Condition()
        self._responses = collections.deque()
        self._event_cond = threading.Condition()
        self._events = collections.deque()

        self._datas = queue.Queue()

        self.channels = {}

        self.ant = Ant()

        self._running = True

        self._worker_thread = threading.Thread(target=self._worker,
                                               name="ant.easy")
        self._worker_thread.start()

    def new_channel(self, ctype, network_number=0x00, ext_assign=None):
        size = len(self.channels)
        channel = Channel(size, self, self.ant)
        self.channels[size] = channel
        channel._assign(ctype, network_number, ext_assign)
        return channel

    def request_message(self, messageId):
        _logger.debug("requesting message %#02x", messageId)
        self.ant.request_message(0, messageId)
        _logger.debug("done requesting message %#02x", messageId)
        return self.wait_for_special(messageId)

    def set_network_key(self, network, key):
        self.ant.set_network_key(network, key)
        return self.wait_for_response(Message.ID.SET_NETWORK_KEY)

    # TODO: SDS wie gebruikt dit?? enkel channel.wait_for_event wordt blijkbaar gebruikt
    # en heb ik aangepast met extra chnum
    # dus deze call zal niet werken!!!
    def wait_for_event(self, ok_codes):
        return wait_for_event(ok_codes, self._events, self._event_cond)

    def wait_for_response(self, event_id):
        return wait_for_response(event_id, self._responses,
                                 self._responses_cond)

    def wait_for_special(self, event_id):
        return wait_for_special(event_id, self._responses,
                                self._responses_cond)

    def _worker_response(self, channel, event, data):
        self._responses_cond.acquire()
        self._responses.append((channel, event, data))
        self._responses_cond.notify()
        self._responses_cond.release()

    def _worker_event(self, channel, event, data):
        if event == Message.Code.EVENT_RX_BURST_PACKET:
            self._datas.put(("burst", channel, data))
        elif event == Message.Code.EVENT_RX_BROADCAST:
            self._datas.put(("broadcast", channel, data))
        elif event == Message.Code.EVENT_TX:
            self._datas.put(("broadcast_tx", channel, data))
        elif event == Message.Code.EVENT_RX_ACKNOWLEDGED:
            self._datas.put(("acknowledge", channel, data))
        else:
            self._event_cond.acquire()
            self._events.append((channel, event, data))
            self._event_cond.notify()
            self._event_cond.release()

    def _worker(self):
        self.ant.response_function = self._worker_response
        self.ant.channel_event_function = self._worker_event

        # TODO: check capabilities
        self.ant.start()

    def _main(self):
        _logger.debug("node._main started")

        while self._running:
            # SDS TODO : hier de self._events opkuisen/afhandelen
            # dan heeft die timeout op datas.get() nog zin
            # beter om dit per channel te doen ipv de volledige node?
            # SDS : voorlopige workaround
            # remove RX_FAILED, COLLISION events that keep piling up
            # TODO : nog niet ok, want als het [0] niet wordt gecleaned of gebruikt, stapelen de vuile events zich erachter op
            # hier moet een algo komen die systematisch alle events afhandelt!
            _logger.debug("SDS - cleaning node._events queue %r", self._events)

            # sds de .acquire() is niet echt nodig als je events.remove(message) gebruikt ipv popleft
            # zonder de .acquire() zou de node._events queue kunnen wijzigen tussen message=... en node._events.popleft()
            # om dezelfde reden kan je ook geen for message in node._events loop doen zonder lock acquire
            # deze cleaning vermijdt nog niet dat wait_for_event wordt genotified bij elke inkomend event (ook die van <> channel)
            # want deze cleaning routine krijgt niet noodzakelijk eerst toegang tot de gewijzigde node._events
            # dit is sowieso tijdelijk, maar eigenlijk kan je ook beter een lijst hebben van events die moeten blijven ipv op te sommen wat weg moet
            # ofwel moeten we hier die error events callbacken naar de applicatie
            self._event_cond.acquire()
            cleaning_done = False
            while cleaning_done == False and len(self._events) != 0:
                message = self._events[0]
                if message[1] == 1 and message[2][0] in [
                        Message.Code.EVENT_RX_FAIL,
                        Message.Code.EVENT_CHANNEL_COLLISION,
                        Message.Code.EVENT_QUE_OVERFLOW,
                        Message.Code.EVENT_SERIAL_QUE_OVERFLOW,
                ]:
                    self._events.popleft()
                elif message[1] == 1 and message[2][0] in [
                        Message.Code.EVENT_TRANSFER_TX_FAILED
                ]:
                    _logger.warning(
                        f"event cleanup(temp): TX_FAILED event on channel {message[0]}"
                    )
                    _logger.warning(message)
                    self._events.popleft()
                elif message[1] == 1 and message[2][0] in [
                        Message.Code.EVENT_RX_FAIL_GO_TO_SEARCH
                ]:
                    _logger.warning(
                        f"event cleanup(temp):EVENT_RX_FAIL_GO_TO_SEARCH event on channel {message[0]}"
                    )
                    _logger.warning(message)
                    self._events.popleft()
                else:
                    # no more events to clean from the left of the self._events
                    cleaning_done = True
            self._event_cond.release()

            try:
                # SDS info : timeout 1.0s enkel nodig om deze thread te kunnen terminate door self._running = False te zetten
                # zie ook ant.py
                (data_type, channel, data) = self._datas.get(True, 1.0)
                self._datas.task_done()

                if data_type == "broadcast":
                    self.channels[channel].on_broadcast_data(data)
                elif data_type == "burst":
                    self.channels[channel].on_burst_data(data)
                elif data_type == "broadcast_tx":
                    self.channels[channel].on_broadcast_tx_data(data)
                elif data_type == "acknowledge":
                    self.channels[channel].on_acknowledge_data(data)
                else:
                    _logger.warning("Unknown data type '%s': %r", data_type,
                                    data)
            except queue.Empty as e:
                pass
        _logger.debug("node._main stopped")

    def start(self):
        self._main()

    def stop(self):
        if self._running:
            _logger.debug("Stopping ant.easy")
            self._running = False
            self.ant.stop()
            self._worker_thread.join()
コード例 #6
0
class Node():
    def __init__(self):

        self._responses_cond = threading.Condition()
        self._responses = collections.deque()
        self._event_cond = threading.Condition()
        self._events = collections.deque()

        self._datas = queue.Queue()

        #self.channels = {}

        self.ant = Ant()

        self._running = True

        self._worker_thread = threading.Thread(target=self._worker,
                                               name="ant.easy")
        self._worker_thread.start()

        self.cap = self.get_capabilities()

        self.channels = [None] * self.cap["max_channels"]

    def new_channel(self, ctype, network_number=0x00, ext_assign=None):
        for i in range(len(self.channels)):
            if self.channels[i] is None:
                channel = Channel(i, self, self.ant)
                self.channels[i] = channel
                channel._assign(ctype, network_number, ext_assign)
                return channel
        _logger.debug("No free channel available")
        return None

    def remove_channel(self, channel_id):
        for i in range(len(self.channels)):
            try:
                if self.channels[i].id == channel_id:
                    self.channels[i].close()
                    self.channels[i]._unassign()
                    self.channels[i] = None
            except:
                pass

    def get_capabilities(self):
        data = self.request_message(Message.ID.RESPONSE_CAPABILITIES)
        if data[1] == 84:
            return {
                "max_channels": data[2][0],
                "max_networks": data[2][1],
                "options": data[2][2]
            }
        else:
            _logger.debug(
                "capabilities requested and not received (message id 0x{:02x} , but should be 0x{:02x})"
                .format(data[2][4], Message.ID.RESPONSE_CAPABILITIES))
            return

    def request_message(self, messageId):
        _logger.debug("requesting message %#02x", messageId)
        self.ant.request_message(0, messageId)
        _logger.debug("done requesting message %#02x", messageId)
        return self.wait_for_special(messageId)

    def set_network_key(self, network, key):
        self.ant.set_network_key(network, key)
        return self.wait_for_response(Message.ID.SET_NETWORK_KEY)

    def wait_for_event(self, ok_codes):
        return wait_for_event(ok_codes, self._events, self._event_cond)

    def wait_for_response(self, event_id):
        return wait_for_response(event_id, self._responses,
                                 self._responses_cond)

    def wait_for_special(self, event_id):
        return wait_for_special(event_id, self._responses,
                                self._responses_cond)

    def _worker_response(self, channel, event, data):
        self._responses_cond.acquire()
        self._responses.append((channel, event, data))
        self._responses_cond.notify()
        self._responses_cond.release()

    def _worker_event(self, channel, event, data):
        if event == Message.Code.EVENT_RX_BURST_PACKET:
            self._datas.put(('burst', channel, data))
        elif event == Message.Code.EVENT_RX_BROADCAST:
            self._datas.put(('broadcast', channel, data))
        else:
            self._event_cond.acquire()
            self._events.append((channel, event, data))
            self._event_cond.notify()
            self._event_cond.release()

    def _worker(self):
        self.ant.response_function = self._worker_response
        self.ant.channel_event_function = self._worker_event

        # TODO: check capabilities
        self.ant.start()

    def _main(self):
        while self._running:
            try:
                (data_type, channel, data) = self._datas.get(True, 1.0)
                self._datas.task_done()

                if data_type == 'broadcast':
                    self.channels[channel].on_broadcast_data(data)
                elif data_type == 'burst':
                    self.channels[channel].on_burst_data(data)
                else:
                    _logger.warning("Unknown data type '%s': %r", data_type,
                                    data)
            except queue.Empty as e:
                pass

    def start(self):
        self._main()

    def stop(self):
        if self._running:
            _logger.debug("Stoping ant.easy")
            self._running = False
            self.ant.stop()
            self._worker_thread.join()