def githubWindowTitle():
rtn = WindowTitle
url = 'https://raw.githubusercontent.com/WouterJD/FortiusANT/master/pythoncode/FortiusAntTitle.py'
try:
file = urllib.request.urlopen(url)
except:
if debug.on(debug.Function):
logfile.Write ('No access to FortiusAntTitle.py on github')
pass
else:
if debug.on(debug.Function):
logfile.Write ('Check FortiusAntTitle.py on github')
for line in file:
DecodedLine = line.decode('utf-8')
if DecodedLine[:len('WindowTitle')] == 'WindowTitle':
#---------------------------------------------------------------
# We read ourselves, so second token must be WindowTitle
#---------------------------------------------------------------
githubWindowTitle = DecodedLine.split('"')[1]
#---------------------------------------------------------------
# Check if equal; unequal is considered newer
#---------------------------------------------------------------
if debug.on(debug.Any):
logfile.Write ('Version='+ WindowTitle + ', on github=' + githubWindowTitle + '.')
if githubWindowTitle == WindowTitle:
pass
else:
rtn = rtn + ' [version on github=' + githubWindowTitle + ']'
break
file = None
return rtn
def Read(self):
if debug.on(debug.Ble): logfile.Write("BleInterface.Read() ...")
rtn = False
self.jsondata = None
if self.interface:
#-----------------------------------------------------------
# Read from bluetooth interface
#-----------------------------------------------------------
try:
r = requests.get(f'http://{self.host}:{self.port}/ant')
except Exception as e:
logfile.Console("... requests.get() error " + str(e))
else:
#-------------------------------------------------------
# Now we have a response object r
# Which should contain a JSON object
#-------------------------------------------------------
if r.ok and r.text != "":
try:
self.jsondata = json.loads(r.text)
except Exception as e:
logfile.Console("... json.loads() error " + str(e))
else:
rtn = True
if debug.on(debug.Ble):
logfile.Write("... returns: %s (%s)" % (rtn, self.jsondata))
return rtn
def LocateHW(self):
global devTrainer, devAntDongle
if debug.on(debug.Application): logfile.Write("Scan for hardware")
#---------------------------------------------------------------------------
# Get ANT dongle
#---------------------------------------------------------------------------
if not devAntDongle:
devAntDongle, msg = ant.GetDongle()
SetDongleMsg(self, msg)
#---------------------------------------------------------------------------
# Get Trainer and find trainer model for Windows and Linux
#---------------------------------------------------------------------------
if debug.on(debug.Application): logfile.Write("Get USB trainer")
if not devTrainer:
if clv.SimulateTrainer:
SetTacxMsg(self, "Simulated Trainer")
else:
devTrainer = usbTrainer.GetTrainer()
if not devTrainer:
SetTacxMsg(self, "Trainer not detected")
else:
SetTacxMsg(self, "Trainer detected")
usbTrainer.InitialiseTrainer(devTrainer) #initialise trainer
#---------------------------------------------------------------------------
# Done
#---------------------------------------------------------------------------
if debug.on(debug.Application): logfile.Write("Scan for hardware - end")
if devAntDongle and (clv.SimulateTrainer or devTrainer):
return True
else:
return False
def GuiMessageToMain(self, command, wait=True, p1=None, p2=None):
# ----------------------------------------------------------------------
# Step 1. GUI sends a command to main
# ----------------------------------------------------------------------
if debug.on(debug.MultiProcessing) and not (command == cmd_Idle):
logfile.Write("mp-GuiMessageToMain(conn, %s, %s, %s, %s)" %
(command, wait, p1, p2))
self.gui_conn.send((command, p1, p2))
rtn = True
while wait:
# ------------------------------------------------------------------
# Check if requested command is ended
# OR that information is received from Main
# ------------------------------------------------------------------
# Will be more efficient than self.gui_conn.poll() / sleep loop...
# ------------------------------------------------------------------
# Step 4. GUI receives the response (command, rtn)
# ------------------------------------------------------------------
msg = self.gui_conn.recv()
cmd = msg[0]
rtn = msg[1]
if debug.on(debug.MultiProcessing) and not (command == cmd_Idle
and rtn == 0):
logfile.Write(
"mp-GuiAnswerFromMain(conn) returns (%s, %s)" %
(cmd, rtn))
# ------------------------------------------------------------------
# We wait for the response on the command
# and in the meantime receive data to displayed
#
# cmd_StopButton is treated differently, since that command is sent
# while we are waiting for the response on cmd_Runoff or cmd_Tacx2Dongle
# we ignore the response here and cmd_StopButton does not start wait-loop
# to avoid some sort of nesting or so.
# ------------------------------------------------------------------
if cmd == command:
break # command is ready
elif cmd == cmd_StopButton:
pass
elif cmd == cmd_SetValues:
self.SetValues(rtn[0], rtn[1], rtn[2], rtn[3], rtn[4],
rtn[5], rtn[6], rtn[7], rtn[8], rtn[9],
rtn[10]) # rtn is tuple
elif cmd == cmd_SetMessages:
self.SetMessages(
rtn[0], rtn[1],
rtn[2]) # rtn is (Tacx, Dongle, HRM) tuple
elif cmd == cmd_PedalStrokeAnalysis:
self.PedalStrokeAnalysis(
rtn[0], rtn[1]) # rtn is (info, Cadence) tuple
pass
else:
logfile.Console(
'%s active but unknown response received (%s, %s); the message is ignored.'
% (command, cmd, rtn))
break
return rtn
def Open(self):
self.OK = False
self.Message = ", Bluetooth interface cannot be opened"
if debug.on(debug.Ble): logfile.Write("BleInterface.Open() ...")
if self.interface:
if debug.on(debug.Ble): logfile.Write('... already open')
else:
#-----------------------------------------------------------
# path to find ./node (in the parent of the directory where
# 'we' are located) assuming directory structure:
# ./node
# ./pythoncode
# ./WindowsExecutable
#-----------------------------------------------------------
if getattr(sys, 'frozen', False):
dirname = os.path.realpath(
sys.argv[0]) # the started executable
else:
dirname = str(lib_programname.get_path_executed_script()
) # type: pathlib.Path
dirname = os.path.dirname(
dirname) # Remove /filename.py or /filename.exe
dirname = dirname.replace('\\', '/') # Unify separator = /
dirname = dirname[0:dirname.rfind('/')] # Remove last level
#-----------------------------------------------------------
# Create interface as sub-process
#-----------------------------------------------------------
command = ["node", "server.js"]
directory = dirname + "/node"
if debug.on(debug.Ble):
logfile.Write("... Popen(%s,%s)" % (directory, command))
try:
if debug.on(debug.Any):
self.interface = subprocess.Popen(
command,
cwd=directory,
stdout=logfile.fLogfile,
stderr=logfile.fLogfile)
else:
self.interface = subprocess.Popen(command,
cwd=directory)
except Exception as e:
self.Message += "; " + str(e)
if debug.on(debug.Ble): logfile.Write("... " + str(e))
else:
if debug.on(debug.Ble): logfile.Write('... completed')
self.Message = ", Bluetooth interface open"
self.OK = True
if self.OK:
logfile.Console(
"FortiusANT exchanges data with a bluetooth Cycling Training Program"
)
return self.OK
def Close(self):
if self.interface:
if debug.on(debug.Ble):
logfile.Write("BleInterface.Close() ...")
self.interface.terminate()
self.interface.wait()
self.interface = None
self.Message = ", Bluetooth interface closed"
self.OK = False
if debug.on(debug.Ble): logfile.Write("... completed")
else:
pass
def SetValues(self, fSpeed, iRevs, iPower, iTargetMode, iTargetPower,
fTargetGrade, iTacx, iHeartRate):
# --------------------------------------------------------------------------
# Calculate delta time since previous call
# --------------------------------------------------------------------------
delta = time.time() - staticVariables.LastTime # Delta time since previous
# --------------------------------------------------------------------------
# Update current readings
# --------------------------------------------------------------------------
if clv.gui:
self.SetValues(fSpeed, iRevs, iPower, iTargetMode, iTargetPower,
fTargetGrade, iTacx, iHeartRate)
if delta >= 1 and (not clv.gui or debug.on(debug.Any)):
staticVariables.LastTime = time.time() # Time in seconds
if iTargetMode == gui.mode_Power:
sTarget = "%3.0fW" % iTargetPower
elif iTargetMode == gui.mode_Grade:
sTarget = "%3.1f%%" % fTargetGrade
else:
sTarget = "None"
msg = "Target=%s Speed=%4.1fkmh hr=%3.0f Current=%3.0fW Cad=%3.0f r=%4.0f %3.0f%%" % \
(sTarget, fSpeed, iHeartRate, iPower, iRevs, iTacx, int(clv.PowerFactor * 100) )
logfile.Write(msg)
def PedalStrokeAnalysis(self, info, Cadence):
self.Cadence = Cadence
self.StartTime = info[0][0] # First element = at pedelecho
data = []
logfile.Write('PedalStrokeAnalysis - Cadence=%3s info=%3s StartTime=%s' % \
(self.Cadence, len(info), self.StartTime))
for i in info:
Angle = self.Angle(i[0])
if Angle == -1: break
Power = i[1]
d = (Angle, Power)
logfile.Write('Angle=%3s power=%5s Time=%s' % (Angle, Power, i[0]))
data.append(d)
self.ShowRadarGraph(data)
def SetValues(self, fSpeed, iRevs, iPower, iTargetMode, iTargetPower, fTargetGrade, iTacx, iHeartRate, iCrancksetIndex, iCassetteIndex, fReduction):
delta = time.time() - self.LastTime # Delta time since previous call
if delta >= 1: # Do not send faster than once per second
self.LastTime = time.time() # Time in seconds
if debug.on(debug.MultiProcessing): logfile.Write ("mp-MainDataToGUI(%s, (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s))" % \
(cmd_SetValues, fSpeed, iRevs, iPower, iTargetMode, iTargetPower, fTargetGrade, iTacx, iHeartRate, iCrancksetIndex, iCassetteIndex, fReduction))
self.app_conn.send((cmd_SetValues, (fSpeed, iRevs, iPower, iTargetMode, iTargetPower, fTargetGrade, iTacx, iHeartRate, iCrancksetIndex, iCassetteIndex, fReduction)))
def g(name, fn, t, f, conn):
debug.activate(debug.All)
logfile.Open(fn, name)
logfile.Write(fn)
for i in range(0, 100):
logfile.Write(name, i)
# Communicate "results" to parent_conn
# Then receive whether to proceed or to stop
if i % f == 0:
conn.send([i, None, 'hello', name])
if conn.recv(): break
# Wait, so we cycle once per second
time.sleep(t)
def MainCommandFromGui(self): # Step 2. Main receives command from GUI
msg = self.app_conn.recv()
command = msg[0]
p1 = msg[1]
p2 = msg[2]
if debug.on(debug.MultiProcessing) and not (command == cmd_Idle):
logfile.Write ("mp-MainCommandFromGui() returns (%s, %s, %s)" % (command, p1, p2))
return command, p1, p2
def InitialiseTrainer(dev):
# will not read cadence until initialisation byte is sent
data = struct.pack(sc.unsigned_int, 0x00000002)
if debug.on(debug.Data2):
logfile.Write("InitialiseTrainer data=%s (len=%s)" %
(logfile.HexSpace(data), len(data)))
dev.write(0x02, data)
def PedalStrokeAnalysis(self, info, Cadence):
if debug.on(debug.MultiProcessing):
logfile.Write("mp-MainDataToGUI(%s, (info, %s))" %
(cmd_PedalStrokeAnalysis, Cadence))
self.app_conn.send(
(cmd_PedalStrokeAnalysis,
(info,
Cadence))) # x. Main sends messages to GUI; no response expected
pass
def print(self):
try:
if self.args.autostart: logfile.Write("-a")
if self.args.bicycle:
logfile.Write("-b %s,%s/%s,%s/%s" %
(self.tyre, self.fL, self.fS, self.rS, self.rL))
if self.args.debug:
logfile.Write("-d %s (%s)" % (self.debug, bin(self.debug)))
if self.args.ftp: logfile.Write("-f %s" % self.ftp)
if self.args.gui: logfile.Write("-g")
if self.args.manual: logfile.Write("-m")
if not self.args.calibrate: logfile.Write("-n")
if self.args.factor: logfile.Write("-p %s" % self.PowerFactor)
if self.args.resistance:
logfile.Write("-r %s/%s" %
(self.ResistanceH, self.ResistanceL))
if self.args.simulate: logfile.Write("-s")
except:
pass # May occur when incorrect command line parameters, error already given before
def SetMessages(self, Tacx=None, Dongle=None, HRM=None):
newMessages = (Tacx, Dongle, HRM)
if newMessages != self.PreviousMessages: # Send immediatly if changed
self.PreviousMessages = newMessages
if debug.on(debug.MultiProcessing):
logfile.Write("mp-MainDataToGUI(%s, (%s, %s, %s))" %
(cmd_SetMessages, Tacx, Dongle, HRM))
self.app_conn.send(
(cmd_SetMessages,
(Tacx, Dongle,
HRM))) # x. Main sends messages to GUI; no response expected
def Write(self, data):
rtn = False
retry = 10
if debug.on(debug.Ble):
logfile.Write('BleInterface.Write(%s)' % data)
while retry and not rtn and self.interface:
url = f'http://{self.host}:{self.port}/ant'
try:
r = requests.post(url, data=data)
except Exception as e:
msg = "... requests.post() error " + str(e)
if retry and '[Errno 111]' in msg:
retry -= 1
time.sleep(0.250)
logfile.Write(msg)
else:
retry = 0
logfile.Console(msg)
else:
rtn = r.ok
return rtn
def Write(self, data):
rtn = False
if debug.on(debug.Ble):
logfile.Write('BleInterface.Write(%s)' % data)
if self.interface:
url = f'http://{self.host}:{self.port}/ant'
try:
r = requests.post(url, data=data)
except Exception as e:
logfile.Console("... requests.post() error " + str(e))
else:
rtn = r.ok
return rtn
def Open(self):
self.OK = False
self.Message = ", Bluetooth interface cannot be opened"
if debug.on(debug.Ble): logfile.Write("BleInterface.Open() ...")
if self.interface:
if debug.on(debug.Ble): logfile.Write('... already open')
else:
#-----------------------------------------------------------
# Create interface as sub-process
#-----------------------------------------------------------
command = ["node", "server.js"]
directory = Path.cwd().parent / "node"
if debug.on(debug.Ble):
logfile.Write("... Popen(%s,%s)" % (directory, command))
try:
if debug.on(debug.Any):
self.interface = subprocess.Popen(
command,
cwd=directory,
stdout=logfile.fLogfile,
stderr=logfile.fLogfile)
else:
self.interface = subprocess.Popen(command,
cwd=directory)
except Exception as e:
self.Message += "; " + str(e)
if debug.on(debug.Ble): logfile.Write("... " + str(e))
else:
if debug.on(debug.Ble): logfile.Write('... completed')
self.Message = ", Bluetooth interface opened to CTP"
self.OK = True
if self.OK:
logfile.Console(
"FortiusANT exchanges data with a bluetooth Cycling Training Program"
)
return self.OK
def Settings(self, pRestartApplication, pclv):
global RestartApplication, clv
RestartApplication = pRestartApplication
clv = pclv
if debug.on(debug.Function):
logfile.Write ("FortiusAnt.Settings(%s, %s)" % (pRestartApplication, pclv.debug))
if testMode:
print('')
logfile.Console ('Transfer settings')
time.sleep(1)
logfile.Console ('Done')
rtn = True
else:
rtn = FortiusAntBody.Settings(self, pRestartApplication, pclv)
return rtn
def print(self):
try:
v = debug.on(
debug.Any
) # Verbose: print all command-line variables with values
if self.autostart: logfile.Write("-a")
if self.SimulateTrainer: logfile.Write("-s")
if v or self.args.debug:
logfile.Write("-d %s (%s)" % (self.debug, bin(self.debug)))
if v or self.args.dongle:
logfile.Write("-D %s (%s)" % (self.dongle, hex(self.dongle)))
if v or self.args.hrm:
logfile.Write("-H %s (%s)" % (self.hrm, hex(self.hrm)))
if v or self.args.fe:
logfile.Write("-F %s (%s)" % (self.fe, hex(self.fe)))
if v or self.args.scs:
logfile.Write("-S %s (%s)" % (self.scs, hex(self.scs)))
if v or self.args.vtx:
logfile.Write("-V %s (%s)" % (self.vtx, hex(self.vtx)))
except:
pass # May occur when incorrect command line parameters, error already given before
def OnPaint(self, event):
# ----------------------------------------------------------------------
# Draw background
# ----------------------------------------------------------------------
dc = wx.PaintDC(self)
dc.DrawBitmap(self.BackgroundBitmap, 0, 0) # LeftTop in pixels
# ----------------------------------------------------------------------
# Draw HeartRate
# Image functions done once, instead of every OnPaint()
# ----------------------------------------------------------------------
if self.HeartRateImage and self.HeartRate > 40:
# img = self.HeartRateImage.Scale(self.HeartRateWH, self.HeartRateWH, wx.IMAGE_QUALITY_HIGH)
# bmp = wx.Bitmap(img)
if self.HeartRateWH == 36:
dc.DrawBitmap(self.bmp36x36, self.HeartRateX, self.HeartRateY)
elif self.HeartRateWH == 40:
dc.DrawBitmap(self.bmp40x40, self.HeartRateX, self.HeartRateY)
else:
logfile.Write("Unsupported image size")
else:
pass
def __init__(self):
#-----------------------------------------------------------------------
# Define and process command line
#-----------------------------------------------------------------------
parser = argparse.ArgumentParser(
description=
'Program to broadcast data from USB Tacx Fortius trainer, and to receive resistance data for the trainer'
)
parser.add_argument('-a',
'--autostart',
help='Automatically start',
required=False,
action='store_true')
s = '%s,%s/%s,%s/%s' % (self.__tyre__, self.__fL__, self.__fS__,
self.__rS__, self.__rL__)
parser.add_argument('-b',
'--bicycle',
help='Bicycle definition, default=' + s,
required=False,
default=False)
parser.add_argument('-d',
'--debug',
help='Show debugging data',
required=False,
default=False)
parser.add_argument('-f',
'--ftp',
help='FTP of the rider, default=%s' % self.__ftp__,
required=False,
default=False)
parser.add_argument('-g',
'--gui',
help='Run with graphical user interface',
required=False,
action='store_true')
parser.add_argument(
'-H',
'--hrm',
help='Use this Heart Rate Monitor (0: default, -1: none)',
required=False,
default=False)
parser.add_argument(
'-m',
'--manual',
help='Run manual power (ignore target from antDongle)',
required=False,
action='store_true')
parser.add_argument(
'-M',
'--manualGrade',
help='Run manual grade (ignore target from antDongle)',
required=False,
action='store_true')
parser.add_argument('-n',
'--calibrate',
help='Do not calibrate before start',
required=False,
action='store_false')
parser.add_argument(
'-p',
'--factor',
help='Adjust target Power by multiplying by this factor',
required=False,
default=False)
parser.add_argument(
'-r',
'--resistance',
help='FTP percentages for resistance mode, default=150/100',
required=False,
default=False)
parser.add_argument('-s',
'--simulate',
help='Simulated trainer to test ANT+ connectivity',
required=False,
action='store_true')
#scs parser.add_argument('-S','--scs', help='Use this Speed Cadence Sensor (0: default device)', required=False, default=False)
args = parser.parse_args()
self.args = args
#-----------------------------------------------------------------------
# Booleans; either True or False
#-----------------------------------------------------------------------
self.autostart = args.autostart
self.gui = args.gui
self.manual = args.manual
self.manualGrade = args.manualGrade
self.calibrate = args.calibrate
self.SimulateTrainer = args.simulate
if self.manual and self.manualGrade:
logfile.Write(
"-m and -M are mutually exclusive; manual power selected")
self.manualGrade = False # Mutually exclusive
if (self.manual or self.manualGrade) and self.SimulateTrainer:
logfile.Write(
"-m/-M and -s both specified, most likely for program test purpose"
)
#-----------------------------------------------------------------------
# Bicycle definition to be parsed; three parameters
# format=tyre,chainring,cassette, e.g. "2.096,50/34,15/25"
#-----------------------------------------------------------------------
if args.bicycle:
b = args.bicycle.split(",")
#-------------------------------------------------------------------
# parameter1: Tyre defined?
#-------------------------------------------------------------------
if len(b) >= 1:
try:
self.tyre = float(b[0])
if self.tyre < 1: self.tyre = self.__tyre__
except:
logfile.Write('Command line error; -b incorrect tyre=%s' %
b[0])
self.tyre = self.__tyre__
#-------------------------------------------------------------------
# parameter2: Chainring, large/small separated by /
# format=large/small, e.g. 50/34
# If one value is specified, e.g. "50" 50/50 is assumed
#-------------------------------------------------------------------
if len(b) >= 2:
s = b[1].split('/')
if len(s) >= 0:
try:
self.fL = int(s[0])
except:
logfile.Write(
'Command line error; -b incorrect large chainring=%s'
% s[0])
self.fS = self.fL # Default is single chainring
if len(s) >= 1:
try:
self.fS = int(s[1])
except:
logfile.Write(
'Command line error; -b incorrect small chainring=%s'
% s[1])
#-------------------------------------------------------------------
# parameter3: Cassette, small/large separated by /
# If one value is specified, e.g. "15" 15/15 is assumed
#-------------------------------------------------------------------
if len(b) >= 3:
s = b[2].split('/')
if len(s) >= 0:
try:
self.rS = int(s[0])
except:
logfile.Write(
'Command line error; -b incorrect small cassette=%s'
% s[0])
self.rL = self.rS # Default is single speed cassette
if len(s) >= 1:
try:
self.rL = int(s[1])
except:
logfile.Write(
'Command line error; -b incorrect large cassette=%s'
% s[1])
#-----------------------------------------------------------------------
# Get debug-flags, used in debug module
#-----------------------------------------------------------------------
if args.debug:
try:
self.debug = int(args.debug)
except:
logfile.Write(
'Command line error; -d incorrect debugging flags=%s' %
args.debug)
#-----------------------------------------------------------------------
# Get riders FTP
#-----------------------------------------------------------------------
if args.ftp:
try:
self.ftp = int(args.ftp)
if self.ftp < 50: self.ftp = self.__ftp__
except:
logfile.Write('Command line error; -f incorrect ftp=%s' %
args.ftp)
#-----------------------------------------------------------------------
# Get HRM
# - None: read HRM from Tacx Fortius and broadcast as HRM master device
# - -1 : no master and no slave device
# - 0 : pair with the first ANT+ HRM that is found
# - next: pair with the defined ANT+ HRM monitor
# the number can be found with ExplorANT
#-----------------------------------------------------------------------
if args.hrm:
try:
self.hrm = int(args.hrm)
except:
logfile.Write('Command line error; -H incorrect HRM=%s' %
args.hrm)
#-----------------------------------------------------------------------
# Get SCS
# - None: No Speed Cadence Sensor
# - 0 : pair with the first ANT+ SCS that is found
# - next: pair with the defined ANT+ SCS
# the number can be found with ExplorANT
#-----------------------------------------------------------------------
#scs if args.scs:
#scs try:
#scs self.scs = int(args.scs)
#scs except:
#scs logfile.Write('Command line error; -S incorrect SCS=%s' % args.scs)
#-----------------------------------------------------------------------
# Get powerfactor
#-----------------------------------------------------------------------
if args.factor:
try:
self.PowerFactor = float(args.factor)
except:
logfile.Write(
'Command line error; -f incorrect power factor=%s' %
args.factor)
#-----------------------------------------------------------------------
# Parse Resistance
#-----------------------------------------------------------------------
if args.resistance:
s = args.resistance.split('/')
if len(s) >= 0:
try:
self.ResistanceH = int(s[0])
except:
logfile.Write(
'Command line error; -r incorrect high resistance=%s' %
s[0])
if len(s) >= 1:
try:
self.ResistanceL = int(s[1])
except:
logfile.Write(
'Command line error; -r incorrect low resistance=%s' %
s[1])
def mainProgram():
global RestartApplication, clv
# --------------------------------------------------------------------------
# Initialize
# --------------------------------------------------------------------------
debug.deactivate()
if not RestartApplication: clv = cmd.CommandLineVariables()
debug.activate(clv.debug)
FortiusAntBody.Initialize(clv)
if debug.on(debug.Any):
logfile.Open()
logfile.Console("FortiusANT started")
logfile.Write (' Restart=%s debug=%s' % (RestartApplication, clv.debug))
clv.print()
logfile.Console("------------------")
RestartApplication = False
#-------------------------------------------------------------------------------
# Component info
#-------------------------------------------------------------------------------
if debug.on(debug.Any):
# ----------------------------------------------------------------------
if getattr(sys, 'frozen', False):
logfile.Write('Windows executable started')
else:
logfile.Write('Python version started')
# ----------------------------------------------------------------------
logfile.Write('Version info for the components' )
logfile.Write(githubWindowTitle())
s = " %20s = %s"
logfile.Write(s % ('FortiusAnt', __version__ ))
logfile.Write(s % ('antDongle', ant.__version__ ))
logfile.Write(s % ('antFE', fe.__version__ ))
logfile.Write(s % ('antHRM', hrm.__version__ ))
logfile.Write(s % ('antPWR', pwr.__version__ ))
logfile.Write(s % ('antSCS', scs.__version__ ))
logfile.Write(s % ('bleDongle', bleDongle.__version__ ))
logfile.Write(s % ('constants', constants.__version__ ))
logfile.Write(s % ('debug', debug.__version__ ))
logfile.Write(s % ('FortiusAntBody', FortiusAntBody.__version__ ))
logfile.Write(s % ('FortiusAntCommand', cmd.__version__ ))
if UseGui:
logfile.Write(s % ('FortiusAntGui', gui.__version__ ))
logfile.Write(s % ('logfile', logfile.__version__ ))
if UseGui:
logfile.Write(s % ('RadarGraph', RadarGraph.__version__ ))
logfile.Write(s % ('settings', settings.__version__ ))
logfile.Write(s % ('structConstants', sc.__version__ ))
logfile.Write(s % ('TCXexport', TCXexport.__version__ ))
logfile.Write(s % ('usbTrainer', usbTrainer.__version__ ))
logfile.Write(s % ('argparse', argparse.__version__ ))
# logfile.Write(s % ('binascii', binascii.__version__ ))
# logfile.Write(s % ('math', math.__version__ ))
logfile.Write(s % ('numpy', numpy.__version__ ))
logfile.Write(s % ('os', os.name ))
if os.name == 'nt':
v = sys.getwindowsversion()
logfile.Write((s + '.%s') % ('windows', v.major, v.minor))
logfile.Write(s % ('pickle', pickle.format_version ))
logfile.Write(s % ('platform', platform.__version__ ))
# logfile.Write(s % ('glob', glob.__version__ ))
# logfile.Write(s % ('random', random.__version__ ))
logfile.Write(s % ('sys (python)', sys.version ))
# logfile.Write(s % ('struct', struct.__version__ ))
# logfile.Write(s % ('threading', threading.__version__ ))
# logfile.Write(s % ('time', time.__version__ ))
logfile.Write(s % ('usb', usb.__version__ ))
if UseGui:
logfile.Write(s % ('wx', wx.__version__ ))
logfile.Write('FortiusANT code flags')
logfile.Write(s % ('UseMultiProcessing', UseMultiProcessing))
logfile.Write(s % ('UseGui', UseGui))
logfile.Write(s % ('UseBluetooth', UseBluetooth))
logfile.Write("------------------")
if not clv.gui:
# --------------------------------------------------------------------------
# Console only, no multiprocessing required to separate GUI
# --------------------------------------------------------------------------
Console = clsFortiusAntConsole()
Console.Autostart()
elif not UseMultiProcessing:
# --------------------------------------------------------------------------
# No multiprocessing wanted, start GUI immediatly
# --------------------------------------------------------------------------
clv.PedalStrokeAnalysis = False
app = wx.App(0)
frame = frmFortiusAnt(None, clv)
app.SetTopWindow(frame)
frame.Show()
if clv.autostart:
frame.Autostart()
app.MainLoop()
else:
# --------------------------------------------------------------------------
# Multiprocessing wanted, start GUI in it's own process
# --------------------------------------------------------------------------
# https://docs.python.org/3/library/multiprocessing.html
# Create queue and sub-process
# --------------------------------------------------------------------------
app_conn, gui_conn = multiprocessing.Pipe(True)
pChild = multiprocessing.Process(target=FortiusAntChild, args=(clv, gui_conn) )
pChild.start()
# --------------------------------------------------------------------------
# Poll child-process untill done
# --------------------------------------------------------------------------
parent = clsFortiusAntParent(app_conn) # The child process has the GUI
parent.ListenToChild()
# --------------------------------------------------------------------------
# Wait for child-process to complete
# --------------------------------------------------------------------------
pChild.join()
# ------------------------------------------------------------------------------
# We're done
# ------------------------------------------------------------------------------
if debug.on(debug.Any):
logfile.Console('FortiusAnt ended')
logfile.Close()
def SetLeds(self, ANT=None, BLE=None, Cadence=None, Shutdown=None, Tacx=None):
if debug.on(debug.MultiProcessing): logfile.Write ("mp-MainDataToGUI(%s, (%s, %s, %s, %d, %s))" % (cmd_SetLeds, Tacx, Shutdown, Cadence, BLE, ANT))
self.app_conn.send((cmd_SetLeds, (ANT, BLE, Cadence, Shutdown, Tacx))) # x. Main sends messages to GUI; no response expected
def MainRespondToGUI(self, command, rtn):
if debug.on(debug.MultiProcessing) and not (command == cmd_Idle and rtn == 0):
logfile.Write ("mp-MainRespondToGUI(%s, %s)" % (command, rtn))
self.app_conn.send((command, rtn)) # Step 3. Main sends the response to GUI
def print(self):
try:
v = debug.on(
debug.Any
) # Verbose: print all command-line variables with values
if self.autostart: logfile.Write("-a")
if v or self.args.bicycle:
logfile.Write("-b %s,%s/%s,%s/%s" %
(self.tyre, self.fL, self.fS, self.rS, self.rL))
if v or self.args.debug:
logfile.Write("-d %s (%s)" % (self.debug, bin(self.debug)))
if v or self.args.ftp: logfile.Write("-f %s" % self.ftp)
if self.gui: logfile.Write("-g")
if v or self.args.hrm: logfile.Write("-H %s" % self.hrm)
if self.manual: logfile.Write("-m")
if self.manualGrade: logfile.Write("-M")
if not self.args.calibrate: logfile.Write("-n")
if v or self.args.factor: logfile.Write("-p %s" % self.PowerFactor)
if v or self.args.resistance:
logfile.Write("-r %s/%s" %
(self.ResistanceH, self.ResistanceL))
if self.args.simulate: logfile.Write("-s")
#scs if self.args.scs: logfile.Write ("-S %s" % self.scs )
except:
pass # May occur when incorrect command line parameters, error already given before
else:
DeviceType = '?'
#-----------------------------------------------------------
# Store in device table, so we print at the end of loop
#-----------------------------------------------------------
deviceID = clsDeviceID(Channel, DeviceType, DeviceNumber,
DeviceTypeID, TransmissionType)
# print (Channel, end=' ')
if DeviceNumber == 0: # No device paired, request again
AntDongle.Write([ant.msg4D_RequestMessage(Channel, ant.msgID_ChannelID)], \
False, False)
pass
else:
d = deviceID
logfile.Write ("ExplorANT: %3s discovered on channel=%s, number=%5s typeID=%3s TrType=%3s" % \
(d.DeviceType, d.Channel, d.DeviceNumber, d.DeviceTypeID, d.TransmissionType) )
if not deviceID in deviceIDs:
print('%s=%s' % (d.Channel, DeviceType), end=' ')
logfile.Write('ExplorANT: added to list')
deviceIDs.append(deviceID)
#---------------------------------------------------
# Ask the found device for more info; page 70
#---------------------------------------------------
info = ant.msgPage70_RequestDataPage(
Channel, ant.DeviceNumber_EA, 255, 255, 1, 70,
0)
d = ant.ComposeMessage(ant.msgID_AcknowledgedData,
info)
AntDongle.Write([d], False)
# Description: Show all dongles available
# Open defined dongle
# Start listening what's going on in the air
#
# Output: Console/logfile
#
# Returns: None
# ------------------------------------------------------------------------------
debug.deactivate()
clv = cmd.Create()
debug.activate(clv.debug)
if True or debug.on(debug.Any):
logfile.Open('ExplorANT')
logfile.Write("ExplorANT started")
clv.print()
logfile.Write("--------------------")
# ------------------------------------------------------------------------------
# First enumerate all dongles
# ------------------------------------------------------------------------------
ant.EnumerateAll()
# ------------------------------------------------------------------------------
# Open dongle; either the defined one or default
#
# Note, it does not matter which dongle you open.
# The dongle itself means a connection to the ANT+ network
# Each application starting can use any ANT+ dongle
# ------------------------------------------------------------------------------
debug.deactivate()
clv = cmd.CommandLineVariables()
debug.activate(clv.debug)
FortiusAntBody.Initialize(clv)
if debug.on(debug.Any):
logfile.Open()
logfile.Console("FortiusANT started")
clv.print()
logfile.Console("------------------")
#-------------------------------------------------------------------------------
# Component info
#-------------------------------------------------------------------------------
if debug.on(debug.Any):
logfile.Write('Version info for the components')
s = " %20s = %s"
logfile.Write(s % ('FortiusAnt', __version__))
logfile.Write(s % ('antDongle', ant.__version__))
logfile.Write(s % ('antHRM', hrm.__version__))
logfile.Write(s % ('antFE', fe.__version__))
logfile.Write(s % ('debug', debug.__version__))
logfile.Write(s % ('FortiusAntBody', FortiusAntBody.__version__))
logfile.Write(s % ('FortiusAntCommand', cmd.__version__))
logfile.Write(s % ('FortiusAntGui', gui.__version__))
logfile.Write(s % ('logfile', logfile.__version__))
logfile.Write(s % ('structConstants', sc.__version__))
logfile.Write(s % ('usbTrainer', usbTrainer.__version__))
logfile.Write(s % ('argparse', argparse.__version__))
# logfile.Write(s % ('binascii', binascii.__version__ ))
def MainCommandFromGui(self): # Step 2. Main receives command from GUI
command = self.app_conn.recv()
if debug.on(debug.MultiProcessing) and not (command == cmd_Idle):
logfile.Write("mp-MainCommandFromGui() returns %s" % (command))
return command
