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()
