def start(): global antnode global speed_sensor global power_meter from vpower.config import DEBUG, LOG, NETKEY, POWER_CALCULATOR, POWER_SENSOR_ID, SENSOR_TYPE, SPEED_SENSOR_ID xbmc.log("Using " + POWER_CALCULATOR.__class__.__name__, level=xbmc.LOGDEBUG) stick = driver.USB2Driver(None, log=LOG, debug=DEBUG) antnode = node.Node(stick) xbmc.log("Starting ANT node", level=xbmc.LOGDEBUG) antnode.start() key = node.NetworkKey('N:ANT+', NETKEY) antnode.setNetworkKey(0, key) xbmc.log("Starting speed sensor", level=xbmc.LOGDEBUG) # Create the speed sensor object and open it speed_sensor = SpeedCadenceSensorRx( antnode, SENSOR_TYPE, SPEED_SENSOR_ID) speed_sensor.open() # Notify the power calculator every time we get a speed event speed_sensor.notify_change(POWER_CALCULATOR) xbmc.log("Starting power meter with ANT+ ID " + repr(POWER_SENSOR_ID), level=xbmc.LOGDEBUG) # Create the power meter object and open it power_meter = PowerMeterTx(antnode, POWER_SENSOR_ID) power_meter.open() # Notify the power meter every time we get a calculated power value POWER_CALCULATOR.notify_change(power_meter)
def start(self): # todo USB device configuration input if self.usb_product_id == 'fake': print("Faking HR device with randomness") return try: print("Opening USB...") self.usb_device = driver.USB2Driver(debug=True, idProduct=0x1009) print("Got USB: {0}".format(self.usb_device)) except DriverError as e: print("Unable to open USB device.") return except Exception as e: print("Unexpected exception: {0}".format(e)) return try: print("Creating node...") self.node = node.Node(self.usb_device) print("Starting node {0}".format(self.node)) self.node.start() print("Node started.") except NodeError as e: self.node = None print("Unable to start node: {0}".format(e)) except ChannelError as e: self.node = None print("Unable to open channel: {0}".format(e)) except Exception as e: self.node = None print("Unexpected exception...: {0}".format(e))
def _start_antnode(self): stick = driver.USB2Driver(self.serial) self.antnode = node.Node(stick) print('node running:{}'.format(self.antnode.running)) #if self.antnode.running == False: self.antnode.start() print('Antnode capabilities-Channels: {}, Networks: {}').format(self.antnode.getCapabilities()[0], self.antnode.getCapabilities()[1])
def _start_antnode(self): print(">> TRACEIN HRM:_start_antnode") stick = driver.USB2Driver(self.serial) print("driver assigned to " + self.serial) self.antnode = node.Node(stick) print("antnode created from stick") self.antnode.start() print("antnode started") print("<< TRACEOUT HRM:_start_antnode")
def _initialize(self): if self.driver is None: # actually doesn't matter what parameter we put since USB2 # doesn't use /dev self.driver = driver.USB2Driver(DEFAULT_ADDR) if self.node is None: self.node = node.Node(self.driver) self.node.start() self.key = node.NetworkKey(self.DEFAULT_NET_NAME, self.netkey) self.node.setNetworkKey(0, self.key)
def __init__(self, search_timeout_sec=120): """ Create Ant+ node, network, and initialize all attributes """ self.search_timeout_sec = search_timeout_sec self.device = driver.USB2Driver() self.antnode = Node(self.device) self.network = Network(key=NETWORK_KEY_ANT_PLUS, name='N:ANT+') # Start search for sensors and register callbacks: self.device_power_meter = BicyclePower(self.antnode, self.network, callbacks={ 'onDevicePaired': self._on_device_found, 'onPowerData': self._on_power_data, 'onChannelClosed': self._on_channel_closed, 'onSearchTimeout': self._on_search_timeout }) self._power_meter_status = AntSensors.SensorStatus(fresh_time_s=2) self.device_heart_rate = HeartRate(self.antnode, self.network, callbacks={ 'onDevicePaired': self._on_device_found, 'onHeartRateData': self._on_heartrate_data, 'onChannelClosed': self._on_channel_closed, 'onSearchTimeout': self._on_search_timeout }) self._heart_rate_status = AntSensors.SensorStatus(fresh_time_s=2) self._reconnect = True # Heartrate fields self._heartrate_bpm = None self._rr_interval_ms = None self._hr_event_time_ms = None # Power meter fields self._instantaneous_power_watts = None self._cadence_rpm = None self._accumulated_power_watts = None self._power_event_count = None
from ant.core import driver, node from ant.core.constants import * from PowerMeterTx import PowerMeterTx from SpeedCadenceSensorRx import SpeedCadenceSensorRx from config import DEBUG, LOG, NETKEY, POWER_CALCULATOR, POWER_SENSOR_ID, SENSOR_TYPE, SPEED_SENSOR_ID antnode = None speed_sensor = None power_meter = None try: print "Using " + POWER_CALCULATOR.__class__.__name__ stick = driver.USB2Driver(None) antnode = node.Node(stick) print "Starting ANT node" antnode.start() network = node.NetworkKey(name='N:ANT+', key=NETKEY) antnode.setNetworkKey(0, network) print "Starting speed sensor" try: # Create the speed sensor object and open it speed_sensor = SpeedCadenceSensorRx(antnode, SENSOR_TYPE, SPEED_SENSOR_ID) speed_sensor.open() # Notify the power calculator every time we get a speed event speed_sensor.notify_change(POWER_CALCULATOR) except Exception as e:
def process(self, msg): if isinstance(msg, message.ChannelBroadcastDataMessage): print 'Heart Rate:', ord(msg.payload[-1]) if datetime.now() > self.last_insertion_time + timedelta( seconds=10): print "Inserting" connection = Connection() db = connection.developerhealth doc = {'time': time.time(), 'value': ord(msg.payload[-1])} db.hrm.insert(doc) self.last_insertion_time = datetime.now() # Initialize stick = driver.USB2Driver(SERIAL) antnode = node.Node(stick) antnode.start() # Setup channel key = node.NetworkKey('N:ANT+', NETKEY) antnode.setNetworkKey(0, key) channel = antnode.getFreeChannel() channel.name = 'C:HRM' channel.assign('N:ANT+', CHANNEL_TYPE_TWOWAY_RECEIVE) channel.setID(120, 0, 0) channel.setSearchTimeout(TIMEOUT_NEVER) channel.setPeriod(8070) channel.setFrequency(57) channel.open()
''' print "Speed: " , spd print "Cadence: " , cadence print "Power: " , power ''' root.after(1000, myMainLoop) except (KeyboardInterrupt, SystemExit): exit() try: # print "Using " + POWER_CALCULATOR.__class__.__name__ stick = driver.USB2Driver(None, log=LOG, debug=DEBUG) antnode = node.Node(stick) print "Starting ANT node" antnode.start() key = node.NetworkKey('N:ANT+', NETKEY) antnode.setNetworkKey(0, key) print "Starting speed sensor" try: # Create the speed sensor object and open it speed_sensor = SpeedSensorRx(antnode, SPEED_SENSOR_TYPE) speed_sensor.start() # Notify the power calculator every time we get a speed event # speed_sensor.notify_change(POWER_CALCULATOR) except Exception as e: print "speed_sensor error: " + e.message
decoded.cadence) + '}') self.previousMessageSpeedCadence = decoded # Power if channel.name == "power": if msg.payload[1] == 0x10: # Standard Power Only! decoded = PowerMessage(self.previousMessagePower, msg.payload) print("Power: %f" % decoded.averagePower) print("") # print(".", end="") ws.send('{"cmd":"bike-update", "power":' + str(decoded.averagePower) + '}') self.previousMessagePower = None # Initialize stick = driver.USB2Driver(idProduct=0x1009) antnode = node.Node(stick) antnode.start() network = node.Network(NETKEY, 'N:ANT+') antnode.setNetworkKey(0, network) # Setup Speed & Cadence sensor channel channel1 = antnode.getFreeChannel() channel1.name = "speedcadence" channel1.assign(network, CHANNEL_TYPE_TWOWAY_RECEIVE) channel1.setID(121, int(bikeId), 0) channel1.searchTimeout = TIMEOUT_NEVER channel1.period = 8086 channel1.frequency = 57 channel1.open()
cadence, power): print("Speed Km/h {} Cadence {} Power {}".format(str(kmSpeed), str(cadence), str(power))) print("#########################################################") #-------------------------------------------------# # Initialization # #-------------------------------------------------# try: reset_USB_Device() except Exception as ex: print(ex) antnode = Node(driver.USB2Driver(log=LOG, debug=DEBUG, idProduct=0x1008)) try: antnode.start() network = Network(key=NETWORK_KEY_ANT_PLUS, name='N:ANT+') antnode.setNetworkKey(NETWORK_NUMBER_PUBLIC, network) myTrainer = bikeTrainer( antnode, network, { 'onDevicePaired': device_paired, 'onSearchTimeout': search_timed_out, 'onChannelClosed': channel_closed, 'onBikeTrainer': bike_Trainer }) # Unpaired, search: myTrainer.open() print('ANT started. Connecting to devices...') except ANTException as err:
def main(): global mainloop idProduct = prepare_usb("ANTUSB") device = driver.USB2Driver(log=LOG, debug=DEBUG, idProduct=idProduct) antnode = Node(device) antnode.start() network = Network(key=NETWORK_KEY_ANT_PLUS, name='N:ANT+') antnode.setNetworkKey(NETWORK_NUMBER_PUBLIC, network) POWER_SENSOR_ID = id_from_serial(1) #POWER_SENSOR_ID = 12345 print("Start power meter ID %d" % POWER_SENSOR_ID) pm = PowerMeterTx(antnode, network, POWER_SENSOR_ID) def device_found(self, channelID): print("Detect %s" % str(channelID)) def updatePower(self, cadence, accPower, power): pm.update(cadence, accPower, power) def heartrate_data(computed_heartrate, event_time_ms, rr_interval_ms): if HR_DEBUG: if rr_interval_ms is not None: print( "Heart rate: %d, event time(ms): %d, rr interval (ms): %d" % (computed_heartrate, event_time_ms, rr_interval_ms)) else: print("Heart rate: %d" % (computed_heartrate, )) ble_hrm_update_hr(computed_heartrate) hr = HeartRate(antnode, network, callbacks={ 'onDevicePaired': device_found, 'onHeartRateData': heartrate_data }) fe = FitnessEquipment(antnode, network, callbacks={ 'onDevicePaired': device_found, 'onPowerUpdated': updatePower }) # Unpaired, search: hr.open() pm.open() fe.open() # Paired to a specific device: #fe.open(ChannelID(53708, 17, 37)) #hr.open(ChannelID(21840, 120 ,81)) print("++++++++++++++++++++++++++++++++++") monitor = None mainloop = GLib.MainLoop() ble_hrm_start() #while True: # try: # time.sleep(1) # except KeyboardInterrupt: # break try: mainloop.run() except KeyboardInterrupt: print("KeyboardInterrupt") ble_hrm_stop() print("+++++++++++++++++++---------------") fe.close() pm.close() hr.close() antnode.stop()
# -*- coding: utf-8 -*- """Demonstrate the use of the ANT+ Heart Rate Device Profile """ import time from ant.core import driver from ant.core.node import Node from ant.plus.heartrate import * from config import * device = driver.USB2Driver(log=LOG, debug=DEBUG) antnode = Node(device) antnode.start() # Unpaired, search: hr = HeartRate(antnode) # Paired to a specific device: #hr = HeartRate(antnode, 23359, 1) #hr = HeartRate(antnode, 21840, 81) monitor = None while True: try: time.sleep(1) if hr.state == STATE_RUNNING: print "Computed heart rate: {}".format(hr.computed_heart_rate)
def __init__(self, serial, network_key_type="ant+"): self.node = node.Node(driver.USB2Driver(serial)) self.network_key_type = network_key_type self.channel = None
from config import * NETKEY = '\xB9\xA5\x21\xFB\xBD\x72\xC3\x45' # Event callback class MyCallback(event.EventCallback): def process(self, msg): print msg if isinstance(msg, ChannelBroadcastDataMessage): print 'Beat Count:', ord(msg.get_payload()[7]) print 'Heart Rate:', ord(msg.get_payload()[8]) # Initialize driver stick = driver.USB2Driver(SERIAL, log=LOG) # No debug, too much data stick.open() # Initialize event machine evm = event.EventMachine(stick) evm.registerCallback(MyCallback()) evm.start() # Reset msg = SystemResetMessage() stick.write(msg.encode()) time.sleep(1) # Set network key msg = NetworkKeyMessage(key=NETKEY) stick.write(msg.encode())
win32api.SetConsoleCtrlHandler(on_exit, True) try: devs = find(find_all=True) for dev in devs: if dev.idVendor == 0x0fcf and dev.idProduct in [0x1008, 0x1009]: break else: print("No ANT device found") if getattr(sys, 'frozen', False): input() sys.exit() stick = driver.USB2Driver(log=LOG, debug=DEBUG, idProduct=dev.idProduct) antnode = node.Node(stick) print("Starting ANT node") antnode.start() network = node.Network(NETKEY, 'N:ANT+') antnode.setNetworkKey(0, network) print("Starting cadence sensor") try: cadence_sensor = antnode.getFreeChannel() cadence_sensor.assign(network, CHANNEL_TYPE_TWOWAY_RECEIVE) cadence_sensor.setID(122, 0, 0) cadence_sensor.searchTimeout = TIMEOUT_NEVER cadence_sensor.period = 8102 cadence_sensor.frequency = 57 cadence_sensor.open()
# -*- coding: utf-8 -*- """Demonstrate the use of the ANT+ Heart Rate Device Profile """ import time from ant.core import driver from ant.core.node import Node, Network, ChannelID from ant.core.constants import NETWORK_KEY_ANT_PLUS, NETWORK_NUMBER_PUBLIC from ant.plus.heartrate import * from config import * device = driver.USB2Driver(log=LOG, debug=DEBUG, idProduct=0x1009) antnode = Node(device) antnode.start() network = Network(key=NETWORK_KEY_ANT_PLUS, name='N:ANT+') antnode.setNetworkKey(NETWORK_NUMBER_PUBLIC, network) def device_found(self, device_number, transmission_type): print("Detect monitor device number: %d, transmission type: %d" % (device_number, transmission_type)) def heartrate_data(self, computed_heartrate, event_time_ms, rr_interval_ms): if rr_interval_ms is not None: print("Heart rate: %d, event time(ms): %d, rr interval (ms): %d" % (computed_heartrate, event_time_ms, rr_interval_ms)) else:
def _start_antnode(self): stick = driver.USB2Driver(self.serial) self.antnode = node.Node(stick) self.antnode.start()
try: print("Using " + POWER_CALCULATOR.__class__.__name__) devs = find(find_all=True) for dev in devs: if dev.idVendor == 0x0fcf and dev.idProduct in [0x1008, 0x1009]: print "Found device with Vendor " + repr( dev.idVendor) + " and Product " + repr(dev.idProduct) break else: print("No ANT device found") exit() dev.reset() stick = driver.USB2Driver(log=LOG, debug=False, idProduct=dev.idProduct) antnode = node.Node(stick) print("Starting ANT node") antnode.start() print("Started") key = node.Network(NETKEY, 'N:ANT+') antnode.setNetworkKey(0, key) print("Starting speed sensor") try: # Create the speed sensor object and open it speed_sensor = SpeedCadenceSensorRx(antnode, SENSOR_TYPE, SPEED_SENSOR_ID & 0xffff) speed_sensor.open() # Notify the power calculator every time we get a speed event speed_sensor.notify_change(POWER_CALCULATOR)
""" Do a system reset using raw messages. """ import sys import time from ant.core import driver from ant.core import message from ant.core.constants import * from config import * # Initialize stick = driver.USB2Driver(SERIAL, log=LOG, debug=DEBUG) stick.open() # Prepare system reset message msg = message.Message() msg.set_msg_id(MESSAGE_CHANNEL_BROADCAST_DATA) msg.set_payload('\xFF' * 8) # Send stick.write(msg.encode()) # # Wait for reset to complete # time.sleep(1) # # # Alternatively, we could have done this: # msg = message.SystemResetMessage()
def __init__(self): os.system("usbreset 0fcf:1008") self.node = Node(driver.USB2Driver()) self.network = Network(key=NETWORK_KEY_ANT_PLUS, name='N:ANT+')
pywin32 = False if platform.system() == 'Windows': def on_exit(sig, func=None): stop_ant() try: import win32api win32api.SetConsoleCtrlHandler(on_exit, True) pywin32 = True except ImportError: print("Warning: pywin32 is not installed, use Ctrl+C to stop") try: devs = find(find_all=True, idVendor=0x0fcf) for dev in devs: if dev.idProduct in [0x1008, 0x1009]: stick = driver.USB2Driver(log=LOG, debug=DEBUG, idProduct=dev.idProduct, bus=dev.bus, address=dev.address) try: stick.open() except: continue stick.close() break else: print("No ANT devices available") if getattr(sys, 'frozen', False): input() sys.exit() antnode = node.Node(stick) print("Starting ANT node") antnode.start()
def _start_antnode(self): stick = driver.USB2Driver(SERIAL, log=LOG, debug=DEBUG) self.antnode = node.Node(stick) self.antnode.start()