doug.py

# pip3 install pyserial 
# pip3 install serial


# from doug. normally the radio is disabled now?
# can enable it like this
# https://groups.io/g/picoballoon/message/13652

# If you want to play with it yourself, enable the debug mode by pressing "?".
# At the bottom, in the debug json input, type in {"type":"REQ_RADIO_OUTPUT_ENABLE"}.

# can turn it off with REQ_RADIO_OUTPUT_DISABLE ??

#***********************************
# doug on 
#  the precedent is for wspr, that I don't have to turn tx on explicitlyy.

# > The firmware turns it on now if it's off
# > I'm assuming you don't turn the tx off after a wspr command. maybe you do? don't know,
#
# The API documentation says "This will send regardless of radio power and enable state.  State will be restored once complete."
#
# This means, if the radio is off, or disabled, and you issue a send request, the radio will be turned on and enabled before the message is sent.  If the radio was off or disabled before the send, that state will be restored afterward.
#
# So yes, if the power was off beforehand, it will be turned off afterward, automatically.

# The send command leaves the traquito in the same state it was before sending.
# > the gps reset doesn't turn power on?
# Correct.
#
# The API documentation doesn't talk about any relationship because there isn't any.
#
# The Hot/Warm/Cold reset is a software thing.  If the GPS is physically powered off, the software command to reset is conceptually meaningless and does nothing.
#
# There is no "memory" of a reset or any other state.

# decoding AT6558 chip
# https://wiki.dfrobot.com/GPS_+_BDS_BeiDou_Dual_Module_SKU_TEL0132

# look for GPGSV and BDGSV sentences?

# can we detect this? can we get the firmware version
# hmm. what if we don't detect it right?
# default to true
API_MODE_FIRMWARE = False
# API_MODE_VERSION="2023-07-10_16:10:15"
API_MODE_VERSION="2023-07-11_10:56:46"
FLIGHT_MODE_VERSION="2023-07-11_10:54:38"
# {"type":"REP_GET_DEVICE_INFO","swVersion":"2023-07-11_10:54:38","mode":"TRACKER"}

import operator
from functools import reduce

# FIX! can get stuck in file manage new directory name dialog..can't cntrl-q out of it

import json
import serial
import sys
from termcolor import colored
import time
from time import sleep
import random
import string

import datetime
# from datetime import timedelta
from pytz import timezone
#****************************
USE_SHORT_CALLS=True
MULTIPLE_FIX = True
PREFIX = ""
FIX_PREFIX = "FIX_0"

BAND="15m"
BAND="17m"
BAND="10m"
BAND="20m"

# 20m 14095600
# traquito ? says 14095600 + 1500
# 22m 13710000
if BAND == "10m":
    BASE_FREQ = 28124600
elif BAND == "15m":
    BASE_FREQ = 21094600
elif BAND == "17m":
    BASE_FREQ = 18104600
elif BAND == "20m":
    BASE_FREQ = 14095600
else:
    print("ERROR: BASE_FREQ decode missing: BAND", BAND)
    sys.exit(1)


# hdsdr
# 20m 14095600
# traquito ? says 14095600 + 1500
# 22m 13710000
# each 100 correction is 1 hz
# worked..made it more negative than this limit the website has

# 500 correction does  ~7 hz lower on 20M (14095.600 base freq)
# 500 correction does ~14 hz lower on 10M (28124.600 base freq)

# parts per billion (14 / 28124600) is 500 parts per billion

# (14/28124600) * 1e9  498

# this works for determining correction?
# (14/28124600) * 1e9 = 497.78
# probably has to be int
# (14/28124600) * 1e9 = 498


# this will bring us higher if we start with CORRECTION negative
# this will bring us lower if we start with CORRECTION positive
# starting with CORRECTION 0 means it won't change

# this should always be a positive number
CORRECTION_DELTA = 500
# this is dropping by 42-43  hz each time at 14010000 base freq
# 1e9 * (43 / 14095600) = 3050
# 1e9 * (42 / 14095600) = 2979
CORRECTION_DELTA = 3000
# by around 14 for 20M?
CORRECTION_DELTA = 1000
CORRECTION_DELTA = 0

CHANNEL_DELTA = 0
CHANNEL_DELTA = 5 # so it just bumps the frequency

# correction of 10000 to 11000 is not causing 10 hz change
# (correction 1000 delta)
# which is what you expect if correction is * 0.01hz
# causing 14 hz change (lower)

# for the traquito under test, wsjtx reports 14.097003 for channel 0
# the normal base freq is 14.095600 for 20M 
# the audio offset is added to that base freq to get the reported freq)

# the hdsdr base freq normally matches what wsjtx is told, but can be shifted
# to match the freq shift implied by the computed 'correction' value

#************************************
# wsjtx results
# 14097004 reported - 14095600 base = 1404 offset?
# 13711403 reported - 13710000 base = 1403 offset ..add 1 below

if BAND == "10m":
    # works normally
    # 16 hz correction to get in the bin?
    # does it have to be 2x on 10M?
    # this got me to 0026 on the freq with channel 0
    # FUDGE = 4
    # TARGET_BASE_FREQ = 28124600 + 2 * (FUDGE + 16)


    # good enough for af6im-18
    # will use AF6IM 10M channel 447 with "correction":-1208
    # apparently a saved correction is sticky. even if not shown 
    # on the web gui
    # testing outside with channel 447
    # I get 28.266066 on the wsjtx (around 3.5v)
    # af6im qr2jyd nq23 33

    # trying initially it was 008 for channel 0

    if False:
        # AF6IM-18
        FUDGE = 1
        # why did it need 2x?
        TARGET_BASE_FREQ = BASE_FREQ + (2 * (FUDGE + 16))
    else:
        # AD6Z-19 12/16/23
        # this is the fully chopped down traquito (AD6Z-18?)
        # this cased ..6011
        # TARGET_BASE_FREQ = BASE_FREQ 

        # with default channel 0 freq is 6010 ..so want 10 hz?
        # DON'T 2X it and see what happens

        # got ..6021 so good with FUDGE=0. why did it not need 2x??
        # correction is -355
        # 11/29/23 channel 427 getting 6056 (6060 is center)
        # is this adjusting it to 2 * 5 (6015)
        FUDGE=0
        # TARGET_BASE_FREQ = BASE_FREQ + (1 * (FUDGE + 10))
        TARGET_BASE_FREQ = BASE_FREQ + (2 * (FUDGE + 5))
        # new 11/30/23 -640 correction
        # wrong. brought us to 6065 (added 9)
        TARGET_BASE_FREQ = BASE_FREQ + (2 * (FUDGE + 9))

        # 11/3023 -462 correction
        # now 6059 or 6060 for channel 427
        TARGET_BASE_FREQ = BASE_FREQ + (1 * (FUDGE + 13))

        # 12/27/23 -960 correction
        TARGET_BASE_FREQ = BASE_FREQ + (1 * (FUDGE + 27))


    # TARGET_BASE_FREQ = BASE_FREQ + (2 * (FUDGE + 16)) + 1


elif True and BAND == "20m":
    # works normally
    FUDGE = 0
    TARGET_BASE_FREQ = BASE_FREQ + FUDGE

elif False and BAND == "20m":
    # worked. wsjtx reported 14.097003 when setup for 20m 
    # hdsdr had 14.094.000 base freq
    # no adjustment needed
    FUDGE = 0
    TARGET_BASE_FREQ = 14094000 + FUDGE

elif False and BAND == "20m":
    FUDGE = -514
    # this worked for the 14010000 shift
    # 514 / (14095600 - 14010000)
    TARGET_BASE_FREQ = 14010000 + FUDGE

elif False and BAND == "20m":
    FUDGE = -2730
    TARGET_BASE_FREQ = 13900000 + FUDGE

elif False and BAND == "20m":
    # FUDGE = -10804
    FUDGE = -10804
    TARGET_BASE_FREQ = 13710000 + FUDGE

elif False and BAND == "20m":
    # to play with the correction equation without fudge
    FUDGE = 0
    TARGET_BASE_FREQ = 13710000

else:
    FUDGE = 0
    TARGET_BASE_FREQ = BASE_FREQ

print("final BASE_FREQ", BASE_FREQ)
print("final TARGET_BASE_FREQ", TARGET_BASE_FREQ)
print("final FUDGE", FUDGE)

DELTA_FREQ = TARGET_BASE_FREQ - BASE_FREQ
print("final DELTA_FREQ", DELTA_FREQ)
#************************************

if True:
    # should be positive number. positive makes freq lower
    # every 1000 of correction shifts frequency 14

    # (14/28124600) * 1e9 = 498
    CORRECTION = int(-1 * ((TARGET_BASE_FREQ - BASE_FREQ)/BASE_FREQ)  * 1e9)
    # NEW_CORRECTION = int(-1 * ((TARGET_BASE_FREQ - BASE_FREQ) * 10))
    # NEW_CORRECTION = int(-1 * ((TARGET_BASE_FREQ - BASE_FREQ)/TARGET_BASE_FREQ)  * 1e9)

    # DELTA = NEW_CORRECTION - CORRECTION
    # print("CORRECTION", CORRECTION, "NEW_CORRECTION", NEW_CORRECTION, "DELTA", DELTA)
    # sys.exit(1)

    # hack needed when I went to 14.010000 base
    # needed to shift down another 300 hz ?
    # FIX! this is reflecting test for 20M 
    # with this, I got a 14.07177 print for channel 0
    # CORRECTION += (300 / 7) * 500
    # add 174 to the 300

    # 496.6 correction actually gets you 7 hz for 20M
    # this worked for
    # TARGET_BASE_FREQ = 14010000
    # but freq was a little high
    # CORRECTION += int( (474 / 7) * 496.6 )

    # this should make it 200 hz higher
    # CORRECTION += int( (274 / BASE_FREQ) * 1e9 )

else:
    # will cause increasing freq corrections in loop
    CORRECTION = -1
    # will cause decreasing freq corrections in loop
    CORRECTION = +1

# FIX! is it half this when shifting 10M up?
FREQ_CORRECTION = int( round( (-1 * CORRECTION * BASE_FREQ) / 1e9) )
print("Assuming Channel 0, Initial base FREQ_CORRECTION", FREQ_CORRECTION, "with", "CORRECTION", CORRECTION)
### sys.exit(1)


# if CORRECTION < -3500 or CORRECTION > 3500:
#     print("ERROR: illegal CORRECTION", CORRECTION, "should be between -3500 and 3500")
#     sys.exit(1)

# no check for legal bands!

#****************************
# why are we getting stuck on 106?  
# was before 11/11/23
# BYTES_NEEDED_BEFORE_READING=150

# this TEMP line has 52 chars
# two of these would be 104 plus two line ends ? 106
# {"type":"TEMP","tempC":13.635676,"tempF":56.5442168}

# BYTES_NEEDED_BEFORE_READING=106

# I suppose we could go with 53 min?
# .HackIt: in_waiting_hack 0 serReader.in_waiting 53
BYTES_NEEDED_BEFORE_READING=53

#****************************
DO_GET_DEVICE_INFO = True
# /dev/ttyACM0 by default?
ACM_DIGIT = 0

GPS_TESTING = False
DO_TX_OFF_ACK_TEST = False

# appropriate u4b usb virtual serial.
# make sure you're in the dialout group so we can access without sudo
from serial_ports import serial_ports
# to use
# ports, TTY_PORT  = serial_ports()

# TTY_PORT="/dev/ttyACM0"
# TTY_PORT="/dev/ttyACM1"
# print("WARNING: if it doesn't work, change TTY_PORT. Currently:", TTY_PORT)

DELAY_AFTER_CHAR=0.03 # secs

# don't need these for traquito
controlQ=''
controlA='
'
controlC=''
controlD=''
controlO=''
controlR=''
controlS=''
controlV=''
controlX=''
yes='Y'
no='N'

escape=''
enter = '\r'
backspace=''
delete='[3;5~'

print("ASSUMES you're not running putty..wants serial output port for reads!")
# this was wrong after a quick reset??
ports, TTY_PORT  = serial_ports()
print("")
print("ports", ports)
print("")

#*******************
if len(sys.argv) < 2:
    # leave ACM_DIGIT to whatever it is above
    pass
else:
    if not (sys.argv[1] in ["0", "1", "2", "3"]):
        print("ERROR: ARG1 should be 0|1|2|3 for /dev/ttyACM0,1,2,3")
        sys.exit(1)
    ACM_DIGIT = int(sys.argv[1])

#*******************
if len(sys.argv) < 3:
    # leave MULTIPLE_FIX to whatever it is above
    pass
else:
    if sys.argv[2] == "MULTIPLE_FIX":
        MULTIPLE_FIX = True
        GPS_TESTING = True
    elif sys.argv[2] == "SINGLE_FIX":
        MULTIPLE_FIX = False
        GPS_TESTING = True
    elif sys.argv[2] == "WSPR":
        MULTIPLE_FIX = False
        GPS_TESTING = False
    else:
        print("ERROR: ARG2", sys.argv[2], "should be MULTIPLE_FIX or SINGLE_FIX")
        sys.exit(1)

#*******************
if len(sys.argv) < 4:
    # leave DO_RESET to whatever it is above
    pass
else:
    # FIX! should we power GPS off/on?
    if sys.argv[3] == "RESET":
        DO_RESET = True
    elif sys.argv[3] == "NO_RESET":
        DO_RESET = False
    else:
        print("ERROR: ARG3 should RESET or NO_RESET")
        sys.exit(1)

#*******************
if len(sys.argv) < 5:
    # leave GPS_RESET_TYPE to default above
    pass
else:
    if sys.argv[4] == "COLD":
        GPS_RESET_TYPE = "cold"
    elif sys.argv[4] == "WARM":
        GPS_RESET_TYPE = "warm"
    elif sys.argv[4] == "HOT":
        GPS_RESET_TYPE = "hot"
    else:
        print("ERROR: ARG4 should HOT WARM or COLD")
        sys.exit(1)

#*******************
if MULTIPLE_FIX:
    # 24 hours
    MAX_TIMEOUT_SECS = 60 * 60 * 24
else:
    # 3 minutes ..timeout for ptest.sh single fixes
    MAX_TIMEOUT_SECS = 180
    MAX_TIMEOUT_SECS = 50
    MAX_TIMEOUT_SECS = 400
#*******************
if GPS_TESTING or DO_TX_OFF_ACK_TEST:
    DO_WSPR = False
    DO_RESET = True
    # messes up gps fix? if off at higher freq?
    # or is it just missing the ack
    DO_TX_OFF = True

    # automatically turns on if necessary now?
    DO_TX_ON = False
    DO_SLOW_CONFIG = False

    DO_GPS_POWER_ON = False
    DO_GPS_POWER_OFF_BATT_ON = False
    DO_GPS_RESET = True

    # should be hot warm or cold (only)
    GPS_RESET_TYPE="cold"


else:
    DO_WSPR = True
    DO_RESET = True
    # messes up gps fix? if off at higher freq?
    DO_TX_OFF = True
    # automatically turns on if necessary now?
    DO_TX_ON = False
    DO_SLOW_CONFIG = False

    DO_GPS_POWER_ON = False
    DO_GPS_POWER_OFF_BATT_ON = True
    DO_GPS_RESET = False
    GPS_RESET_TYPE="warm"

TTY_PORT = "/dev/ttyACM" + str(ACM_DIGIT)

# remember to rm this if you want fresh start
hw_test_filename = "hw_test_" + str(ACM_DIGIT) + ".txt"
all_lines_filename = "all_lines_" + str(ACM_DIGIT) + ".txt"
print(TTY_PORT, "and writing to",  hw_test_filename)
print(TTY_PORT, "and writing to", all_lines_filename)

global fa
fa = open(all_lines_filename, "w")
global fhw
fhw = open(hw_test_filename, "w")

#*********************
# https://github.com/pyserial/pyserial/issues/216
# also http://pyserial.readthedocs.io/en/latest/pyserial_api.html#serial.threaded.LineReader (usage example at the bottom of the page)
# http://pyserial.readthedocs.io/en/latest/url_handlers.html#spy to see what its doing on the serial port

# Here's a class that serves as a wrapper to a pyserial object.
# It allows you to read lines without 100% CPU.
# It does not contain any timeout logic.
# If a timeout occurs, self.s.read(i) returns an empty string and
# you might want to throw an exception to indicate the timeout.

# to use:
# ser = serial.Serial(...)
# reader = ReadLine(ser)
# while True:
#    print(reader.readline())

class ReadLine:
    def __init__(self, s):
        self.buf = bytearray()
        self.s = s

    # should add this to ser.in_waiting to decide if any buffered data is available.
    @property
    def in_waiting(self):
        return len(self.buf)

    def readline(self):
        i = self.buf.find(b"\n")
        # return a line if we have one in our buffer already
        if i >= 0:
            r = self.buf[:i+1]
            self.buf = self.buf[i+1:]
            return r

        # otherwise
        while True:
            # grab no more than 2048 bytes
            # why was this always reading 1 byte? does it block looking for 1 byte?
            bb = max(1, min(2048, self.s.in_waiting))
            data = self.s.read(bb)
    
            ii = data.find(b"\n")
            # if there's a \n just return up to the \n and save the rest
            if ii >= 0:
                r = self.buf + data[:ii+1]
                self.buf[0:] = data[ii+1:]
                return r
            else:
                # otherwise just save what you got in the buffer, and continue looping (wait a little first)
                self.buf.extend(data)
                sleep(3)


#****************
def getTime():
    todayMountain   = datetime.datetime.now(timezone('America/Denver'))
    MountainDateHMS = todayMountain.strftime("%m-%d-%Y %H:%M:%S")
    return todayMountain, MountainDateHMS

#****************
global ser
ser = None

def OpenSer():
    global ser
    ser = serial.Serial(TTY_PORT, baudrate=115200, timeout=10, exclusive=True)
    # ser = serial.Serial(TTY_PORT, baudrate=57600, timeout=10, exclusive=True)

    # losing the acks with 9600 baud
    # and the device info replies?
    # ser = serial.Serial(TTY_PORT, baudrate=9600, timeout=10, exclusive=True)
    ser.flushInput()

    # readline replacement? has internal buffering itself
    global serReader
    serReader = ReadLine(ser)
    return ser, serReader

#****************

# globals
global startTime
global TTFF_elapsedTIme
global TTFF_firstLockDuration
global TTFF_dataArrived

# Could have a rolling fix at the very beginning?
startTime = time.time()
TTFF_firstLockDuration = None
TTFF_elapsedTime = None
TTFF_dataArrived = None

# set in GNGGA. DoTemp wants to print them on timeout
# note we don't reinit these per iteration, that should be fine though (as long as we get NMEA messages before
# any reason to print/use them. TTFF_elapsedTime is None is the main iteration boundary check
global Position_Fix_Indicator, Satellites_Used, MSL_Altitude, HDOP
Position_Fix_Indicator = None
Satellites_Used = None
MSL_Altitude = None

global GPGSV_Satellites_In_View, BDGSV_Satellites_In_View
GPGSV_Satellites_In_View = None
BDGSV_Satellites_In_View = None

# the last temp we got. Used when we print gpsFixFound info
global last_tempC
last_tempC = None
global last_tempF
last_tempF = None

global maxSNR_GPGSV
global maxSNR_BDGSV
global meanSNR_GPGSV
global meanSNR_BDGSV
maxSNR_GPGSV = None
maxSNR_BDGSV = None
meanSNR_GPGSV = None
meanSNR_BDGSV = None

#**************************
def hwprint(*args):
    # hw_test_filename is global
    # args is a tuple
    print(" ".join(map(str, args)), file=fhw)

def allprint(*args):
    todayMountain, MountainDateHMS = getTime()

    # append one element to tuple
    datePlusArgs = ( MountainDateHMS, ) + args
    # fa was set by global
    print(" ".join(map(str, datePlusArgs)), file=fa)
    fa.flush()

#****************************
# (14/28124600) * 1e9 = 498
def FreqCorrection():
    # if positive CORRECTION, the FREQ_CORRECTION is negative. etc
    # so always multiply by -1

    # FIX! is it half this when shifting 10M up?
    FREQ_CORRECTION = int(round( (-1 * CORRECTION * BASE_FREQ) / 1e9 ))
    CORRECTED_BASE_FREQ = BASE_FREQ + FREQ_CORRECTION

    sstr = " ".join(map(str, ["Assuming Channel 0...Causing CORRECTED_BASE_FREQ", CORRECTED_BASE_FREQ, "FREQ_CORRECTION", FREQ_CORRECTION, "for CORRECTION", CORRECTION ]))

    print(sstr)
    hwprint(sstr)
    allprint(sstr)
#**************************

def sendit(mytty, name=None, delay=None):
    myttyEncoded = mytty.encode('utf-8')
    if name:
        print("send", myttyEncoded, name, file=sys.stderr)
    else:
        print("send", myttyEncoded, file=sys.stderr)
    ser.write(myttyEncoded)
    # see the doc https://pyserial.readthedocs.io/en/latest/pyserial_api.html#serial.Serial.reset_input_buffer
    ser.flush() # flush the serial buffer (doesn't discard?)

    # Clear output buffer, aborting the current output and discarding all that is in the buffer.
    # For some USB serial adapters, this may only flush the buffer of the OS and
    # not all the data that may be present in the USB part.
    # ser.reset_output_buffer() # flush the serial buffer (discards?). probably don't need this one too.

    # no implicit delay?
    # sleep(DELAY_AFTER_CHAR)
    if delay:
        sleep(int(delay))

    allprint("TO_JETPACK", myttyEncoded)
    return myttyEncoded

#********************************
def senditn(mytty, name=None, delay=None):
    # send with a newline
    myttyr = mytty + "\n"
    myttyEncoded = myttyr .encode('utf-8')
    if name:
        print("send", myttyEncoded, name, file=sys.stderr)
    else:
        print("send", myttyEncoded, file=sys.stderr)
    ser.write(myttyEncoded)
    ser.flush() # flush the serial buffer (doesn't discard?)
    # ser.reset_output_buffer() # flush the serial buffer (discards?). probably don't need this one too.

    sleep(DELAY_AFTER_CHAR)
    if delay:
        sleep(int(delay))

    allprint("TO_JETPACK", myttyEncoded)
    return myttyEncoded

#**************************
# {"type":"ACK","inType":"REQ_GPS_RESET"}
# {"type":"GPS_FIX_TIME","time":"17:54:33","firstLockDuration":1354}

# fullLine is str here (originally bytes)
def DoAck(fullLine):
    print("INFO: ACK", fullLine)

    try:
        fulljson = json.loads(fullLine)
        dougType = fulljson["type"]
        inType = fulljson["inType"]
        ackFound = True
        ackError = False
    except Exception as e:
        print("ERROR: DoAck exception", e)
        ackFound = False
        ackError = True

    # does this ever happen? haven't seen it?
    if "err" in fulljson and fulljson["err"] != "":
        print("ERROR: DoAck 'err' in fulljson", fullLine)
        ackFound = False
        ackError = True
        sys.exit(1)

    return ackError, ackFound

#**************************
def DoRep(fullLine):
    print("INFO: REP", fullLine)
    fulljson = json.loads(fullLine)
    # can have err?
    # {"type":"REP_SET_CONFIG","ok":false,"err":"Invalid channel (0 not allowed)"}
    # okay
    # {"type":"REP_SET_CONFIG","ok":true,"err":""}

    repError = False
    repFound = False
    dougType = fulljson["type"]
    if dougType == "REP_WSPR_SEND":
        repFound = True
    elif dougType == "REP_SET_CONFIG":
        repFound = True
    elif dougType == "REP_GET_CONFIG":
        repFound = True
    elif dougType == "REP_GET_DEVICE_INFO":
        repFound = True
    else:
        print("ERROR: unknown rep type", dougType)
        repError = True
        repFound = False

    if "err" in fulljson and fulljson["err"] != "":
        print("ERROR: DoRep 'err' in fulljson", fullLine)
        repError = True
        repFound = False
        sys.exit(1)
    return repError, repFound

#**************************
def DoGpsFixTime(fullLine):
    print("INFO: GPS_FIX_TIME", fullLine)
    fulljson = json.loads(fullLine)
    # utc time

    dougType = fulljson["type"]
    # FIX! got spaces in "time"
    try:
        dougTime = fulljson["time"]
    except Exception as e:
        print("ERROR: DoGpsFixTime exception", e)
        return None

    firstLockDuration = None
    if "firstLockDuration" in fulljson:
        firstLockDuration = fulljson["firstLockDuration"]

    return firstLockDuration

#**************************
# 07-08-2023 13:41:39 {"type":"TEMP","tempC":33.97269,"tempF":94.1967446}
def DoTemp(fullLine):
    print("INFO: TEMP", fullLine)
    fulljson = json.loads(fullLine)
    # utc time

    # has to be there, to get here
    dougType = fulljson["type"]

    tempFound = True
    try:
        # should be a float
        tempC = float(fulljson["tempC"])
        tempC_int = str(int(round(tempC,0)))+"C"
    except Exception as e:
        print("ERROR: DoTemp exception 2c", e)
        # example error
        # fullLine {"type":"TEMP","tepC":39.202208,"tempF":102.5639744}
        tempFound = False
    try:
        tempF = float(fulljson["tempF"])
        # should be a float
        tempF_int = str(int(round(tempC,0)))+"C"
    except Exception as e:
        print("ERROR: DoTemp exception 2f", e)
        tempFound = False

    if not tempFound:
        tempC = None
        tempF = None
        tempC_int = None
        tempF_int = None

    # good to check here..we always get TEMP
    if startTime is None:
        elapsedTime = 0
    else:
        endTime = time.time()
        elapsedTime = int(endTime - startTime)
        print("DoTemp elapsedTime", elapsedTime, "secs", "tempC", tempC_int)
        hwprint("DoTemp elapsedTime", elapsedTime, "secs", "tempC", tempC_int)

    if elapsedTime > MAX_TIMEOUT_SECS:
        global PREFIX
        PREFIX = FIX_PREFIX
        todayMountain, MountainDateHMS = getTime()
        # basically whatever info we have at the time of timeout
        # identified by gpsFixTimeout so gpsFixFound grep will find in hw_test*.txt file
        if tempC_int is not None:
            ppp_temp = tempC_int
        else:
            ppp_temp = "None"

        ppp = " ".join(map(str, [MountainDateHMS,
            ppp_temp,
            "gpsFixTimeout",
            Position_Fix_Indicator, Satellites_Used, MSL_Altitude, HDOP,
            GPGSV_Satellites_In_View, BDGSV_Satellites_In_View,
            # these are globals
            maxSNR_GPGSV, maxSNR_BDGSV,
            meanSNR_GPGSV, meanSNR_BDGSV,
            # TTFF_elapsedTime, TTFF_firstLockDuration]))
            # so any histogram gathering doesn't barf
            MAX_TIMEOUT_SECS, MAX_TIMEOUT_SECS]))

        print(colored("NO" + PREFIX + ppp, "red", attrs=["bold"]))
        hwprint("NO"+ PREFIX + ppp)
        print("ERROR: elapsedTime", elapsedTime, "> MAX_TIMEOUT_SECS", MAX_TIMEOUT_SECS)
        print("exit without error exitcode")
        if DO_GPS_RESET and GPS_RESET_TYPE == "cold":
            print("turn off GPS power after a timeout? (cold)")
            senditn('{"type":"REQ_GPS_POWER_OFF"}')
        else:
            # didn't do hack here
            print("turn off GPS power after a timeout? Leave backup power on")
            senditn('{"type":"REQ_GPS_POWER_OFF_BATT_ON"}')

        # don't wait for the ack, in case it doesn't come
        # new firmware okay?
        WaitForAck(waitMessage="Waiting for change gps power after timeout, before exit")
        # note this doesn' work if we were testing multiple fixes in doug.py
        # but that's okay to stop
        sys.exit(0)

    # can return None or float
    return tempFound, tempC_int, tempF_int

#**************************
def DoRepGetDeviceInfo(fullLine):
    print("INFO: REP GET_DEVICE_INFO", fullLine)

    # we already know the type must be the rep for device info, to be called
    fulljson = json.loads(fullLine)

    repError = False
    repFound = True

    try:
        swMode = fulljson["mode"]
        hwprint(PREFIX + "REP_GET_DEVICE_INFO swMode", swMode)
        # {"type":"REP_GET_DEVICE_INFO","swVersion":"2023-07-11_10:54:38","mode":"TRACKER"}
        if swMode!="API" and swMode!="TRACKER":
            print("ERROR: DoRepGetDeviceInfo api mode!='API' and !='TRACKER'..ignoring", swMode)
            swMode = None
    except Exception as e:
        # swMode field is not in normal software. hmm. How do I know if it's missing or corrupted?
        print("ERROR: DoRepGetDeviceInfo swMode exception ..ignoring", e)
        repError = True
        repFound = False
        swMode = "API"

    try:
        swVersion = fulljson["swVersion"]
        hwprint(PREFIX + "REP_GET_DEVICE_INFO swVersion", swVersion)
        if swMode == "API" and swVersion != API_MODE_VERSION:
            print("ERROR: DoRepGetDeviceInfo unexpected swVersion", swVersion, "expecting api mode version:", API_MODE_VERSION)
            ### sys.exit(1)

        # FIX! what is the right normal sw version?
        elif (swMode == "TRACKER") and swVersion != FLIGHT_MODE_VERSION:
            print("ERROR: DoRepGetDeviceInfo unexpected swVersion", swVersion, "expecting flight mode version:", FLIGHT_MODE_VERSION)
            ### sys.exit(1)

        elif swMode is None:
            print("ERROR: DoRepGetDeviceInfo api mode!='API' and !='TRACKER'", swMode)
            ### sys.exit(1)

    except Exception as e:
        print("ERROR: DoRepGetDeviceInfo swVersion exception ..ignoring", e)
        repError = True
        repFound = False
        swVersion = None

    # should we retry on repError?
    return repError, repFound, swVersion, swMode

#**************************
def DoRepSetConfig(fullLine):
    print("INFO: REP SET_CONFIG", fullLine)

    # we already know the type must be the rep for device info, to be called
    fulljson = json.loads(fullLine)

    repError = False
    repFound = True

    #****************
    # can have err?
    # {"type":"REP_SET_CONFIG","ok":false,"err":"Invalid channel (0 not allowed)"}
    # okay
    # {"type":"REP_SET_CONFIG","ok":true,"err":""}
    try:
        err = fulljson["err"]
        hwprint(PREFIX + "REP_SET_CONFIG err:", err)

    except Exception as e:
        print("ERROR: DoRepSetConfig err exception ..ignoring", e)
        repError = True
        repFound = False
        err = None

    if err!="":
        print("ERROR: DoRepSetConfig err not blank:", err, "...exittingi")
        sys.exit(1)


    #****************
    # should we retry on repError?
    return repError, repFound

#**************************
def DoRepGetConfig(fullLine):
    # {"type":"REP_GET_CONFIG","band":"20m","channel":5,"callsign":"AD6Z","correction":0,"callsignOk":true}
    # repError, repFound, band, channel, callsign, correction, callsignOk =  DoRepGetConfig(fullLine)

    print("INFO: REP GET_CONFIG", fullLine)

    # we already know the type must be the rep for device info, to be called
    fulljson = json.loads(fullLine)

    repError = False
    repFound = True

    # band, channel, callsign, correction, callsignOk
    #****************
    try:
        band = fulljson["band"]
        hwprint(PREFIX + "REP_GET_CONFIG band", band)

    except Exception as e:
        print("ERROR: DoRepGetConfig band exception ..ignoring", e)
        repError = True
        repFound = False
        band = None
    #****************
    try:
        channel = fulljson["channel"]
        hwprint(PREFIX + "REP_GET_CONFIG channel", channel)

    except Exception as e:
        print("ERROR: DoRepGetConfig channel exception ..ignoring", e)
        repError = True
        repFound = False
        channel = None
    #****************
    try:
        callsign = fulljson["callsign"]
        hwprint(PREFIX + "REP_GET_CONFIG callsign", callsign)

    except Exception as e:
        print("ERROR: DoRepGetConfig callsign exception ..ignoring", e)
        repError = True
        repFound = False
        callsign = None

    #****************
    try:
        correction = fulljson["correction"]
        hwprint(PREFIX + "REP_GET_CONFIG correction", correction)

    except Exception as e:
        print("ERROR: DoRepGetConfig correction exception ..ignoring", e)
        repError = True
        repFound = False
        correction = None

    #****************
    try:
        callsignOk = fulljson["callsignOk"]
        hwprint(PREFIX + "REP_GET_CONFIG callsignOk", callsignOk)

    except Exception as e:
        print("ERROR: DoRepGetConfig callsignOk exception ..ignoring", e)
        repError = True
        repFound = False
        callsignOk = None

    #****************
    # should we retry on repError?
    return repError, repFound, band, channel, callsign, correction, callsignOk

#**************************
def DoGpsFix3D(fullLine):
    # comes on all there of them?
    # {"type":"GPS_FIX_2D","latDeg":38.02367,"lngDeg":-107.670789,"firstLockDuration":69946}
    # {"type":"GPS_FIX_3D","altM":2389,"altF":7837,"speedK":0,"courseDeg":0,"firstLockDuration":71183}
    # {"type":"GPS_FIX_TIME","time":"17:42:39","firstLockDuration":1357}

    # error case (spK)
    # INFO: GPS_FIX_3D {"type":"GPS_FIX_3D","altM":2359,"altF":7739,"spK":0,"courseDeg":212}
    print("INFO: GPS_FIX_3D", fullLine)
    fulljson = json.loads(fullLine)

    try:
        dougType = fulljson["type"]
        altM = fulljson["altM"]
        altF = fulljson["altF"]
        speedK = fulljson["speedK"]
        courseDeg = fulljson["courseDeg"]
    except Exception as e:
        print("ERROR: DoGpsFix3D exception ..ignoring", e)
        return None, None

    global TTFF_firstLockDuration
    if startTime is None:
        elapsedTime = 0
    else:
        endTime = time.time()
        elapsedTime = int(endTime - startTime)
        print("DoGps3D elapsedTime", elapsedTime, "secs")

    firstLockDuration = None
    if "firstLockDuration" in fulljson:

        firstLockDuration = fulljson["firstLockDuration"]
        # round this millisecs to secs
        TTFF_firstLockDuration = int(round(firstLockDuration/1000,0))
        todayMountain, MountainDateHMS = getTime()
        print(PREFIX + "GPS_FIX_3D TTFF_firstLockDuration", TTFF_firstLockDuration, "secs")
        hwprint(PREFIX + "GPS_FIX_3D " + MountainDateHMS)
        hwprint(PREFIX + "GPS_FIX_3D TTFF_firstLockDuration", TTFF_firstLockDuration, "secs")

    return altM, firstLockDuration

#**************************
def DoGpsFix2D(fullLine):
    # comes on all there of them?
    # {"type":"GPS_FIX_2D","latDeg":38.02367,"lngDeg":-107.670789,"firstLockDuration":69946}
    # {"type":"GPS_FIX_3D","altM":2389,"altF":7837,"speedK":0,"courseDeg":0,"firstLockDuration":71183}
    # {"type":"GPS_FIX_TIME","time":"17:42:39","firstLockDuration":1357}

    print("INFO: GPS_FIX_3D", fullLine)
    fulljson = json.loads(fullLine)

    # got lateg instead of latDeg
    # INFO: GPS_FIX_3D {"type":"GPS_FIX_2D","lateg":38.023632,"lngDeg":-107.670729}

    try:
        dougType = fulljson["type"]
        latDeg = fulljson["latDeg"]
        lngDeg = fulljson["lngDeg"]
    except Exception as e:
        print("ERROR: DoGpsFixTime exception", e)
        return None, None, None

    if startTime is None:
        elapsedTime = 0
    else:
        endTime = time.time()
        elapsedTime = int(endTime - startTime)
        print("DoGpsFix2D elapsedTime", elapsedTime, "secs")

    firstLockDuration = None
    if "firstLockDuration" in fulljson:
        firstLockDuration = fulljson["firstLockDuration"]

    return latDeg, lngDeg, firstLockDuration

#**************************
def NMEA_checksum(sentence):
    # last 3 chars are the checksum
    noChecksum = sentence[:-3]
    checksum = sentence[-3:]
    if not (len(sentence)>=4):
        print("ERROR: NMEA sentence needs at least 4 chars", checksum)
        # sys.exit(1)
        return False
    if len(checksum)!=3:
        print("ERROR: NMEA sentence needs * + 2 chars in checksum", checksum)
        # sys.exit(1)
        return False
    if checksum[0]!="*":
        print("ERROR: NMEA sentence needs * in checksum[0]", checksum)
        # sys.exit(1)
        return False
    if noChecksum[0]!="$":
        print("ERROR: NMEA sentence needs to start with $", noChecksum)
        # sys.exit(1)
        return False

    # checks the validity of an NMEA string using it's checksum
    sentence = sentence.strip("$\n")
    nmeadata, checksum = sentence.split("*", 1)
    calculated_checksum = reduce(operator.xor, (ord(s) for s in nmeadata), 0)
    if int(checksum, base=16) == calculated_checksum:
        # return nmeadata
        return True
    else:
        print("ERROR: The NMEA data does not match it's checksum")
        # sys.exit(1)
        return False

#****************************************
def DoGNRMC(nmeaLine):
    # last 3 chars are the checksum
    noChecksum = nmeaLine[:-3]
    fields = noChecksum.split(",")
    checksum = nmeaLine[-3:]

    print("GNRMC Message_ID", fields[0])
    print("GNRMC UTC_Time", fields[1])
    print("")

    # FIX! this isn't right for local time if you're not in MDT time zone
    todayMountain, MountainDateHMS = getTime()

    # nonlocal Status, Latitude, Longitude
    Status = fields[2]
    Latitude = fields[3]
    Longitude = fields[5]

    ### print(colored(PREFIX + MountainDateHMS, "red", attrs=["bold"]))
    print(colored(PREFIX + "GNRMC Status " + Status, "red", attrs=["bold"])) # A is data valid. V is data not valid
    print(colored(PREFIX + "GNRMC Latitude " + Latitude, "red", attrs=["bold"]))
    print(colored(PREFIX + "GNRMC Longitude "+ Longitude, "red", attrs=["bold"]))
    print("")

    hwprint("")
    hwprint(PREFIX + "GNRMC Status " + Status)
    hwprint(PREFIX + "GNRMC Latitude " + Latitude)
    hwprint(PREFIX + "GNRMC Longitude "+ Longitude)
    hwprint("")

    try:
        print("GNRMC N/S_Indicator", fields[4])
        print("GNRMC E/W Indicator", fields[6])
        print("GNRMC Speed_Over_Ground", fields[7])
        print("GNRMC Course_Over_Ground", fields[8])
        print("GNRMC Date", fields[9])
        # can these two fields be missing sometimes?
        print("GNRMC Magnetic_Variation", fields[10])
        print("GNRMC East/West_Indicator", fields[11])
        # this can be stuck in the last field if the prior two are missing
        print("GNRMC Mode", fields[12]) # Autonomous A, DGPS D

    except Exception as e:
        print("ERROR: GNRMC exception ..ignoring", e)
        # apparently we can get missing fields above?, not due to serial issues?
        # sys.exit(1)
        return False, None, None, None

    print("Checksum", checksum)
    GNRMC_done = (TTFF_elapsedTime is not None) and \
            Status!="" and \
            Latitude!="" and \
            Longitude!=""

    if GNRMC_done:
        print("GNRMC_done", GNRMC_done)
    return GNRMC_done, Status, Latitude, Longitude

#****************************
def DoGNGSA(nmeaLine):
    # last 3 chars are the checksum
    noChecksum = nmeaLine[:-3]
    fields = noChecksum.split(",")
    checksum = nmeaLine[-3:]

    print("GNGSA Message_ID", fields[0])
    print("GNGSA Satellite_Used_1", fields[3])
    print("GNGSA Satellite_Used_2", fields[4])
    print("GNGSA Satellite_Used_3", fields[5])
    print("GNGSA Satellite_Used_4", fields[6])
    print("GNGSA Satellite_Used_5", fields[7])
    print("GNGSA Satellite_Used_6", fields[8])
    print("GNGSA Satellite_Used_7", fields[9])
    print("GNGSA Satellite_Used_8", fields[10])
    print("GNGSA Satellite_Used_9", fields[11])
    print("GNGSA Satellite_Used_10", fields[12])
    print("GNGSA Satellite_Used_11", fields[13])
    print("GNGSA Satellite_Used_12", fields[14])

    todayMountain, MountainDateHMS = getTime()

    # nonlocal Mode_1, Mode_2, PDOP, HDOP, VDOP
    Mode_1 = fields[1]
    Mode_2 = fields[2]
    PDOP = fields[15]
    HDOP = fields[16]
    VDOP = fields[17]

    print("")
    ### print(colored(MountainDateHMS, "red", attrs=["bold"]))
    print(colored(PREFIX + "GNGSA Mode_1 " + Mode_1, "red", attrs=["bold"]))
    print(colored(PREFIX + "GNGSA Mode_2 " + Mode_2, "red", attrs=["bold"]))
    print(colored(PREFIX + "GNGSA PDOP " + PDOP, "red", attrs=["bold"]))
    print(colored(PREFIX + "GNGSA HDOP " + HDOP, "red", attrs=["bold"]))
    print(colored(PREFIX + "GNGSA VDOP " + VDOP, "red", attrs=["bold"]))
    print("")

    hwprint("")
    hwprint(PREFIX + "GNGSA Mode_1", Mode_1)
    hwprint(PREFIX + "GNGSA Mode_2", Mode_2)
    hwprint(PREFIX + "GNGSA PDOP", PDOP)
    hwprint(PREFIX + "GNGSA HDOP", HDOP)
    hwprint(PREFIX + "GNGSA VDOP", VDOP)
    hwprint("")

    print("Checksum", checksum)
    GNGSA_done = (TTFF_elapsedTime is not None) and \
            Mode_1!="" and \
            Mode_2!="" and \
            PDOP!="" and \
            HDOP!="" and \
            VDOP!=""

    if GNGSA_done:
        print("GNGSA_done", GNGSA_done)

    return GNGSA_done, Mode_1, Mode_2, PDOP, HDOP, VDOP

#**************************
def DoGNGGA(nmeaLine, raiseException=True):
    # last 3 chars are the checksum
    noChecksum = nmeaLine[:-3]
    fields = noChecksum.split(",")
    checksum = nmeaLine[-3:]

    print("GNGGA Message_ID", fields[0])
    print("GNGGA UTC_Time", fields[1])
    print("GNGGA Latitude", fields[2])
    print("GNGGA N/S_Indicator", fields[3])
    print("GNGGA Longitude", fields[4])
    print("GNGGA E/W_Indicator", fields[5])
    print("")

    # elapsedTime 72.39345860481262
    # Position_Fix_Indicator 1
    # Satellites_Used 4
    # HDOP 1.84
    # MSL_Altitude 2376.4
    # 0 Fix not available or invalid
    # 1 GPS SPS Mode, fix valid
    # 2 Differential GPS, SPS Mode, fix valid
    # 3-5 Not supported
    # 6 Dead Reckoning Mode, fix valid

    # why did I get 6?
    # this shouldn't be in balloon mode
    # Position_Fix_Indicator 6
    # Satellites_Used 3
    # HDOP 2.41
    # MSL_Altitude 2647.3

    # is this stuff missing from the GGA? sometimes? all the time
    if len(fields) == 6:
        print("WEIRD: GGA only has 6 fields?", fields)
        # return GNGGA_done, Position_Fix_Indicator, Satellites_Used, HDOP, MSL_Altitude
        return False, "0", "-", "-", "-"

    #********************************
    # DoTemp wants to print the last values on timeout. so make them global
    global Position_Fix_Indicator, Satellites_Used, MSL_Altitude, HDOP
    Position_Fix_Indicator = str(fields[6])

    global TTFF_elapsedTime
    global TTFF_dataArrived
    global PREFIX
    if startTime is None:
        # hmm means we're not doing a gps reset test yet?
        if (Position_Fix_Indicator=="1"):
            todayMountain, MountainDateHMS = getTime()
            if (TTFF_elapsedTime is None):
                p = " Ignored startTime None and Position_Fix_Indicator 1 when TTFF_elapsedTime is None"
                print(colored(PREFIX + MountainDateHMS + p, "green", attrs=["bold"]))
            else:
                p = " Ignored startTime None and Position_Fix_Indicator 1 when TTFF_elapsedTime is not None"
                print(colored(PREFIX + MountainDateHMS + p, "green", attrs=["bold"]))
    else:
        endTime = time.time()
        elapsedTime = int(endTime - startTime)
        print("elapsedTime", elapsedTime, "secs")
        # don't do anything unless elapsedTime > 4 secs (minimum time? is this okay for hot and warm too?)
        if (elapsedTime > 4) and (Position_Fix_Indicator=="1") and (TTFF_elapsedTime is None):
            TTFF_elapsedTime = elapsedTime
            TTFF_dataArrived = None

            PREFIX = FIX_PREFIX
            todayMountain, MountainDateHMS = getTime()
            print(PREFIX + "GNGGA TTFF_elapsedTime", TTFF_elapsedTime, "secs")
            hwprint(PREFIX + "GNGGA " + MountainDateHMS)
            hwprint(PREFIX + "GNGGA TTFF_elapsedTime", TTFF_elapsedTime, "secs")

    # shouldn't need?
    # if Position_Fix_Indicator=="0":
    #     PREFIX = ""
    #     TTFF_elapsedTime = None

    if (TTFF_elapsedTime is not None):
        print("(0) TTFF_elapsedTime", TTFF_elapsedTime, "secs")

    #********************************

    todayMountain, MountainDateHMS = getTime()
    Satellites_Used = fields[7]
    HDOP = fields[8]
    MSL_Altitude = fields[9]

    print("")
    print(colored(PREFIX + MountainDateHMS, "red", attrs=["bold"]))
    print(colored(PREFIX + "GNGGA Position_Fix_Indicator " + Position_Fix_Indicator + " TTFF_elapsedTime " + str(TTFF_elapsedTime), "red", attrs=["bold"]))
    print(colored(PREFIX + "GNGGA Satellites_Used " + Satellites_Used, "red", attrs=["bold"]))
    print(colored(PREFIX + "GNGGA HDOP " + HDOP, "red", attrs=["bold"]))
    print(colored(PREFIX + "GNGGA MSL_Altitude " + MSL_Altitude, "red", attrs=["bold"]))

    print("")

    hwprint("")
    hwprint(PREFIX + MountainDateHMS)
    hwprint(PREFIX + "GNGGA Position_Fix_Indicator " + Position_Fix_Indicator + " TTFF_elapsedTime " + str(TTFF_elapsedTime))
    hwprint(PREFIX + "GNGGA Satellites_Used " + Satellites_Used)
    hwprint(PREFIX + "GNGGA HDOP " + HDOP)
    hwprint(PREFIX + "GNGGA MSL_Altitude " + MSL_Altitude)
    hwprint("")

    print("")
    print("GNGGA Units", fields[10])
    print("GNGGA Geoid_Separation", fields[11])
    print("GNGGA Units", fields[12])

    # not present if not doing diff gps?
    try:
        print("GNGGA Age_of_Diff_Corr", fields[13])
    except:
        print("GNGGA Age_of_Diff_Corr", "-")

    # not present if not doing diff gps?
    try:
        print("GNGGA Diff_Ref_Station_ID", fields[14])
    except:
        print("GNGGA Diff_Ref_Station_ID", "-")

    print("Checksum", checksum)

    if False and (Position_Fix_Indicator == "1") and raiseException:
        raise Exception("Set TTFF_elapsedTime " + str(TTFF_elapsedTime) + " secs")

    GNGGA_done = (TTFF_elapsedTime is not None) and \
            Position_Fix_Indicator!="" and \
            Satellites_Used!="" and \
            HDOP!="" and \
            MSL_Altitude!=""

    # this shouldn't be in balloon mode
    # Position_Fix_Indicator 6
    if fields[6] == "6":
        print(colored("ERROR: why did we get a Dead Reckoning Modefix? Position_Fix_Indicator == 6", "green", attrs=["bold"]))
        ### sys.exit(1)

    if GNGGA_done:
        print("GNGGA_done", GNGGA_done)
    return GNGGA_done, Position_Fix_Indicator, Satellites_Used, HDOP, MSL_Altitude

#**********************************
# used in DoGPGSV and DoBDGSV
def Extract4Sats(fields, group=0, satnum=1):
    i = (group * 4) + 4
    j = (group * 4) + 5
    k = (group * 4) + 6
    l = (group * 4) + 7

    Elevation = "-"
    Azimuth = "-"
    SNR = "-"
    satnum = str(satnum)
    if len(fields) > i and fields[i]!="":
        print("Satellite_ID_" + satnum, fields[i])
        try:
            Elevation = fields[j]
        except:
            Elevation = ""
        if Elevation == "":
            Elevation = "-"
        print("Elevation_" + satnum, Elevation)

        try:
            Azimuth = fields[k]
        except:
            Azimuth = ""
        if Azimuth == "":
            Azimuth = "-"
        print("Azimuth_" + satnum, Azimuth)

        try:
            SNR = fields[l]
        except:
            SNR = ""
        if SNR == "":
            SNR = "-"
        print("SNR_" + satnum, SNR)

    return Elevation, Azimuth, SNR



#**********************************
# used in DoGPGSV and DoBDGSV
def CreateStrFromList(sList):
    if False:
        sStr = ""
        for s in sList:
            if s != "-":
                sStr += "-" + s
    # keep the dashes
    else:
        sStr = " ".join(sList)
    # this clears the list!
    # sList = []
    # return sList, sStr
    return sStr

#***************************
# the lists get cleared so do it now
# figure out current max and mean
# figure out current max and mean
def MakeSnrMaxMean(snrList, sat="BD"):
    snrNum = 0
    snrSum = 0
    snrMax = 0
    for snr in snrList:
        if snr != "" and snr != "-":
            snrInt = int(snr)
            if snrInt > snrMax:
                snrMax = snrInt
            snrNum += 1
            snrSum += snrInt

    if snrNum > 0:
        meanSNR = int(round(snrSum / snrNum, 0))
        maxSNR = snrMax
    else:
        meanSNR = "-"
        maxSNR = "-"

    if sat == "GP":
        global meanSNR_GPGSV
        global maxSNR_GPGSV
        meanSNR_GPGSV = meanSNR
        maxSNR_GPGSV = maxSNR
    elif sat == "BD":
        global meanSNR_BDGSV
        global maxSNR_BDGSV
        meanSNR_BDGSV = meanSNR
        maxSNR_BDGSV = maxSNR
    else:
        print("ERROR: MakeSnrMaxMean sat should be 'GP' or 'BD")
        sys.exit(1)

#****************************
def DoGPGSV(nmeaLine, snrList, elevationList, azimuthList):
    # last 3 chars are the checksum
    GPGSV_done = False
    noChecksum = nmeaLine[:-3]
    fields = noChecksum.split(",")
    checksum = nmeaLine[-3:]

    # smallest!
    # $GPGSV,1,1,00*79
    if len(fields) <= 4:
        # don't do anything
        # return GPGSV_done, Satellites_In_View, snrList, elevationList, azimuthList
        return False, None, None, None, None

    Message_ID = fields[0]
    Number_of_Messages = fields[1]
    Message_Number = fields[2]
    Satellites_In_View = fields[3]

    print("GPGSV Message_ID", Message_ID)
    print("GPGSV Number_of_Messages", Number_of_Messages)
    print("GPGSV Message_Number", Message_Number)
    print("GPGSV GP_Satellites_In_View", Satellites_In_View)


    if int(Message_Number) > int(Number_of_Messages):
        print("ERROR: bad Message_Number", Message_Number, "Number_of_Messages", Number_of_Messages)
        sys.exit(1)

    # a most 4 messages to accumulate (by Message_Number)
    # FIX! what happens if the messages are out of order?
    if Message_Number == "1":
        satnum = 1
        elevationList = []
        azimuthList = []
        snrList = []
    # 4 per
    elif Message_Number == "2":
        satnum = 5
    elif Message_Number == "3":
        satnum = 9
    elif Message_Number == "4":
        satnum = 13
    # got 5 with jetpack
    elif Message_Number == "5":
        satnum = 17
    # got 6 with jetpack
    elif Message_Number == "6":
        satnum = 21
    else:
        print("ERROR: bad Message_Number", Message_Number)
        sys.exit(1)

    #**********************************
    for group in [0, 1, 2, 3]:
        Elevation, Azimuth, SNR = Extract4Sats(fields, group=group, satnum=satnum)
        elevationList.append(Elevation)
        azimuthList.append(Azimuth)
        snrList.append(SNR)
        satnum += 1
    #**********************************

    print("GPGSV Checksum", checksum)

    # print("Number_of_Messages", fields[1])
    # kprint("Message_Number", fields[2])
    # last message

    # blank means it hasn't been created (see GPGSV_done)
    # not used if not created
    snrStr = ""
    elevationStr = ""
    azimuthStr = ""

    # last message
    if Number_of_Messages == Message_Number:
        #***************************
        # the lists get cleared so do it now
        # figure out current max and mean and put in the globals
        MakeSnrMaxMean(snrList, sat="GP")

        #***************************
        snrStr = CreateStrFromList(snrList)
        elevationStr = CreateStrFromList(elevationList)
        azimuthStr = CreateStrFromList(azimuthList)

        print("")
        todayMountain, MountainDateHMS = getTime()
        ### print(colored(PREFIX + MountainDateHMS, "red", attrs=["bold"]))
        print(colored(PREFIX + "GPGSV Satellites_In_View " + fields[3], "red", attrs=["bold"]))
        print(colored(PREFIX + "GPGSV snrStr " + snrStr, "red", attrs=["bold"]))
        print(colored(PREFIX + "GPGSV azimuthStr " + azimuthStr, "red", attrs=["bold"]))
        print(colored(PREFIX + "GPGSV elevationStr " + elevationStr, "red", attrs=["bold"]))
        print("")

        hwprint("")
        hwprint(PREFIX + "GPGSV Satellites_In_View " + fields[3])
        hwprint(PREFIX + "GPGSV snrStr " + snrStr)
        hwprint(PREFIX + "GPGSV elevationStr " + elevationStr)
        hwprint(PREFIX + "GPGSV azimuthStr " + azimuthStr)
        hwprint("")


        # only on the last sentence for multiple sentences?

        # sometimes the elevationStr and azimuthStr is empty? don't look for that..just look for snrStr
        # GPGSV Satellites_In_View 05
        # GPGSV snrStr 25 29 25 19 30 - - -
        # GPGSV elevationStr - - - - - - - -
        # GPGSV azimuthStr - - - - - - - -
        # (elevationStr!="") and (azimuthStr!="") and (snrStr!="") and \
        GPGSV_done = \
            (snrStr!="") and \
            (Satellites_In_View != "") and (TTFF_elapsedTime is not None)

        if GPGSV_done:
            print("GPGSV_done", GPGSV_done)

        snrList = []
        elevationList = []
        azimuthList = []

    return GPGSV_done, Satellites_In_View, snrList, elevationList, azimuthList

#****************************
def DoBDGSV(nmeaLine, snrList, elevationList, azimuthList):
    BDGSV_done = False
    # last 3 chars are the checksum
    noChecksum = nmeaLine[:-3]
    fields = noChecksum.split(",")
    checksum = nmeaLine[-3:]

    # nonlocal Message_ID, Number_of_Messages, Message_Number, Satellites_In_View
    # smallest!
    # $BDGSV,1,1,00*79
    if len(fields) <= 4:
        # don't do anytin
        BDGSV_done = False
        Satellites_In_View = 0
        return BDGSV_done, Satellites_In_View, snrList, elevationList, azimuthList

    Message_ID = fields[0]
    Number_of_Messages = fields[1]
    Message_Number = fields[2]
    Satellites_In_View = fields[3]

    print("BDGSV Message_ID", Message_ID)
    print("BDGSV Number_of_Messages", Number_of_Messages)
    print("BDGSV Message_Number", Message_Number)
    print("BDGSV Satellites_In_View", Satellites_In_View)

    # a most 4 messages to accumulate (by Message_Number)
    if Message_Number == "1":
        satnum = 1
        elevationList = []
        azimuthList = []
        snrList = []
    # 4 per
    elif Message_Number == "2":
        satnum = 5
    elif Message_Number == "3":
        satnum = 9
    elif Message_Number == "4":
        satnum = 13
    else:
        print("ERROR: bad Message_Number", Message_Number)
        sys.exit(1)

    #**********************************
    for group in [0, 1, 2, 3]:
        Elevation, Azimuth, SNR = Extract4Sats(fields, group=group, satnum=satnum)
        elevationList.append(Elevation)
        azimuthList.append(Azimuth)
        snrList.append(SNR)
        satnum += 1
    #**********************************

    print("BDGSV Checksum", checksum)

    # print("Number_of_Messages", fields[1])
    # kprint("Message_Number", fields[2])
    # last message

    # blank means it hasn't been created (see BDGSV_done)
    # not used if not created
    snrStr = ""
    elevationStr = ""
    azimuthStr = ""

    # last message
    if Number_of_Messages == Message_Number:
        # figure out current max and mean and put in the globals
        # cause the snrList gets cleared out!
        MakeSnrMaxMean(snrList, sat="BD")

        snrStr = CreateStrFromList(snrList)
        elevationStr = CreateStrFromList(elevationList)
        azimuthStr = CreateStrFromList(azimuthList)

        print("")
        todayMountain, MountainDateHMS = getTime()
        print(colored(PREFIX + "BDGSV Satellites_In_View " + fields[3], "red", attrs=["bold"]))
        print(colored(PREFIX + "BDGSV snrStr " + snrStr, "red", attrs=["bold"]))
        print(colored(PREFIX + "BDGSV azimuthStr " + azimuthStr, "red", attrs=["bold"]))
        print(colored(PREFIX + "BDGSV elevationStr " + elevationStr, "red", attrs=["bold"]))
        print("")

        hwprint("")
        hwprint(PREFIX + "BDGSV Satellites_In_View " + fields[3])
        hwprint(PREFIX + "BDGSV snrStr " + snrStr)
        hwprint(PREFIX + "BDGSV elevationStr " + elevationStr)
        hwprint(PREFIX + "BDGSV azimuthStr " + azimuthStr)
        hwprint("")


        # only on the last sentence for multiple sentences?
        # sometimes the elevationStr and azimuthStr is empty? don't look for that..just look for snrStr
        # GPGSV Satellites_In_View 05
        # GPGSV snrStr 25 29 25 19 30 - - -
        # GPGSV elevationStr - - - - - - - -
        # GPGSV azimuthStr - - - - - - - -

        # (elevationStr!="") and (azimuthStr!="") and (snrStr!="") and \
        BDGSV_done = \
            (snrStr!="") and \
            (Satellites_In_View != "") and (TTFF_elapsedTime is not None)

        if BDGSV_done:
            print("BDGSV_done", BDGSV_done)

        snrList = []
        elevationList = []
        azimuthList = []

    return BDGSV_done, Satellites_In_View, snrList, elevationList, azimuthList

#********************************

global firstBDGSV, firstGPGSV, firstGNGGA, firstGNGSA, firstGNRMC
firstBDGSV = None
firstGPGSV = None
firstGNGGA = None
firstGNGSA = None
firstGNRMC = None

def ReadBytes(stopOnTemp=False, stopOnRep=False, stopOnAck=False, stopOnGpsFix=False, stopOnEmpty=False, stopOnAlmostEmpty=False, waitMessage=None):
    if waitMessage:
        waitMessageStr = waitMessage + " "
    else:
        waitMessageStr = ""

    repError = False
    ackError = False
    tempFound = False
    repFound = False
    ackFound = False
    emptyFound = False
    almostEmptyFound = False
    gpsFixFound = False

    GNGGA_done = False
    BDGSV_done = False
    GPGSV_done = False
    GNGSA_done = False
    GNRMC_done = False
    Position_Fix_Indicator = None
    firstLockDurationTime = None
    firstLockDuration2D = None
    firstLockDuration = None
    tempC = None

    # print("ReadBytes")
    line = []
    timeout = int(time.time()) + 3

    charCnt = 0
    c2DetectStr = ""
    nmeaLine = ""

    GPGSV_snrList = []
    GPGSV_elevationList = []
    GPGSV_azimuthList = []

    BDGSV_snrList = []
    BDGSV_elevationList = []
    BDGSV_azimuthList = []

    last_doneList = []
    last_doneCnt = 0

    # we return it!
    # nonlocal in DoGNRMC
    # Status, Latitude, Longitude = None, None, None
    # nonlocal in DOGNGSA
    # Mode_1, Mode_2, PDOP, HDOP, VDOP = None, None, None, None, None
    # already have a HDOP
    # nonlocal in DoGNGGA
    # Position_Fix_Indicator, Satellites_Used, MSL_Altitude = None, None, None
    # nonlocal in GPSSV
    # Message_ID, Number_of_Messages, Message_Number, Satellites_In_View = None, None, None, None


    while True:
        # always stop when we have a fix?
        # TTTF_elapsedTime now incorporates a minimum wait time for Position_Fix_Indicator
        global TTFF_elapsedTime
        global TTFF_dataArrived
        #***************************

        global ser
        # what is the most it can hold
        # what happens if it loads faster than we unload
        # ser.in_waiting 4095

        # https://stackoverflow.com/questions/16306816/losing-data-in-received-serial-string

        # hmm..don't run into the end of the buffer
        # 120 chars should have at last one sentence in there?
        # the nmea is always flowing?
        # while ser.in_waiting < 120:

        #*******************
        # this failed with sys io error
        # hmm. if ser.in_waiting gets an exception, just use 0
        # maybe it gets "right" eventually??
        def HackIt():
            try:
                in_waiting_hack  = ser.in_waiting
            except Exception as e:
                print("ERROR: ser.in_waiting got exception", e, "..using 0 instead")
                in_waiting_hack = 0

            # print("HackIt: in_waiting_hack", in_waiting_hack, "serReader.in_waiting", serReader.in_waiting)

            return in_waiting_hack + serReader.in_waiting

        #*******************
        inWaiting = HackIt()
        lastWaiting = None
        waitCnt = 0

        while inWaiting < BYTES_NEEDED_BEFORE_READING:
            waitCnt += 1
            if inWaiting != lastWaiting:
                print(waitMessageStr + "not enough inWaiting", inWaiting, )
            else:
                # just print a dot if it hasn't changed
                # print("." + str(inWaiting), end="")
                print(".", end="")
                sys.stdout.flush()

            lastWaiting = inWaiting
            if waitCnt > 5:
                sleepTime = 5
            else:
                sleepTime = waitCnt
            sleep(sleepTime)

            # only do the no-output thing after 50 checks?
            if waitCnt > 50 and inWaiting == 0:
                emptyFound = True
                print(
                    waitMessageStr + "repError", repError,
                    "ackError", ackError,
                    "tempFound", tempFound,
                    "repFound", repFound,
                    "ackFound", ackFound,
                    "gpsFixFound", gpsFixFound,
                    "emptyFound", emptyFound,
                    "almostEmptyFound", almostEmptyFound)

                return repError, ackError, tempFound, repFound, ackFound, gpsFixFound, emptyFound, almostEmptyFound

            # this failed with sys io error
            # hmm. if ser.in_waiting gets an exception, just use 0
            # maybe it gets "right" eventually??
            inWaiting = HackIt()

        todayMountain, MountainDateHMS = getTime()
        print(MountainDateHMS, waitMessageStr + "inWaiting", inWaiting)
        if inWaiting >= 4095:
            print("ERROR:", waitMessageStr + "too much backup, exceeds input buffer?",
                "ser.in_waiting", ser.in_waiting, "+ serReader.in_waiting", serReader.in_waiting,
                "=", inWaiting)
            # only stop if ser.in_waiting is 4095 or greater?
            if ser.in_waiting >= 4095:
                sys.exit(1)


        # https://stackoverflow.com/questions/61166544/readline-in-pyserial-sometimes-captures-incomplete-values-being-streamed-from

        # might not need this
        while True:
            # read complete line from serial output. can end with \n or no more chars
            # hmm. no timeout (is there implicit timeout?)
            # fullLine = ser.readline()
            fullLine = serReader.readline()

            # check if full data is received.
            # FIX! why does fullLine.decode() not work?
            while not ('\\n' in str(fullLine)):
                # This loop is entered only if serial read value doesn't contain \n
                # which indicates end of a sentence.
                # str(val) - val is byte where string operation to check `\\n`
                # can't be performed
                time.sleep(0.1)
                # read complete line from serial output. can end with \n or no more chars
                # temp = ser.readline()
                temp = serReader.readline()
                if temp:
                    fullLine += temp

            fullLine = fullLine.strip()
            print("fullLine", fullLine.decode())
            if fullLine != "":
                # fullLine can be chopped? missing the front
                try:
                    fulljson = json.loads(fullLine)
                    break
                except:
                    print("ERROR:", waitMessageStr + "fullLine is probably chopped? missing some? Ignoring ..", fullLine)
                    ## sys.exit(1)
                    fullLine = None
                    fulljson = None

            time.sleep(0.1)


        # fullLine is bytes above. change to str
        # can have extra spaces?
        # INFO: GPS_FIX_3D {"type":"GPS_FIX_3D","altM":2347,"altF":7699,"speedK":0,"cour s e D e g " : 142 }
        fullLine = fullLine.decode()
        # remove any exra space
        fullLine = fullLine.replace(" ","")
        allprint(fullLine)
        # FIX! enhance to look for the ACK (any ack?)

        dougType = None
        try:
            # got "tye" once
            dougType = fulljson["type"]
        except:
            # if not good json?
            break

        #***************************
        nmeaLine = None
        if dougType == "ACK":
            # FIX! should I check on the type of ack? assume just one outstanding for now
            ackError, ackFound = DoAck(fullLine)

        elif dougType == "REP_WSPR_SEND":
            repError, repFound = DoRep(fullLine)

        elif dougType == "REP_SET_CONFIG":
            # stops on any err nonblank message
            repError, repFound =  DoRepSetConfig(fullLine)

        elif dougType == "REP_GET_CONFIG":
            # {"type":"REP_GET_CONFIG","band":"20m","channel":5,"callsign":"AD6Z","correction":0,"callsignOk":true}
            print("KEVIN>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.")
            repError, repFound, band, channel, callsign, correction, callsignOk =  DoRepGetConfig(fullLine)
            # repError, repFound = DoRep(fullLine)

        elif dougType == "REP_GET_DEVICE_INFO":
            repError, repFound, swVersion, swMode = DoRepGetDeviceInfo(fullLine)
            if swMode is None:
                # do nothing to change whatever we currently have
                # the reply could be garbled??
                pass
            elif swMode == "API":
                global API_MODE_FIRMWARE
                # this has side effects elsewhwere!
                API_MODE_FIRMWARE = True
            else:
                API_MODE_FIRMWARE = False

        elif dougType == "GPS_FIX_TIME":
            # not used
            firstLockDurationTime = DoGpsFixTime(fullLine)

        elif dougType == "TEMP":
            global last_tempC
            tempFound, last_tempC, last_tempF = DoTemp(fullLine)

        elif dougType == "GPS_FIX_2D":
            # don't use this info
            latDeg2D, lngDeg2D, firstLockDuration2D = DoGpsFix2D(fullLine)

        elif dougType == "GPS_FIX_3D":
            altM, firstLockDuration  = DoGpsFix3D(fullLine)


        elif dougType == "GPS_LINE":
            try:
                nmeaLine = fulljson["line"]
                # nmeaLine has everyting from $ to the checksum
                nmeaGood = NMEA_checksum(nmeaLine)
            except Exception as e:
                # getting extra spaces in nmeaLine??
                print("ERROR: GPS_LINE exception ..ignoring", e)
                # hmm. we got "lie" instead of "line"
                nmeaGood = False
                ### sys.exit(1)

            if not nmeaGood:
                nmeaLine = None
        else:
            print("ERROR: Ignoring ...unknown dougType", dougType, fullLine)
            nmeaLine = None
            # can have corrupted lines?
            # ERROR: unknown dougType T,2,1,06,11,82,332,34,14,39,220,31,33,13,222,43,34,73,139,36*65 {"type":"T,2,1,06,11,82,332,34,14,39,220,31,33,13,222,43,34,73,139,36*65"}

            # note we don't have anything like a doError to say when we say bad broadcast data?
            # we just won't have found anything, and return
            return repError, ackError, tempFound, repFound, ackFound, gpsFixFound, emptyFound, almostEmptyFound
            # sys.exit(1)

        #***************************
        if nmeaLine and nmeaLine[0:6] == "$BDGSV":
            global BDGSV_Satellites_In_View
            BDGSV_done, BDGSV_Satellites_In_View, BDGSV_snrList, BDGSV_elevationList, BDGSV_azimuthList = \
                DoBDGSV(nmeaLine, BDGSV_snrList, BDGSV_elevationList, BDGSV_azimuthList)
            # save the first one as a global. why isn't it blank the first time always
            # what if the ephemeris was already loaded
            global firstBDGSV
            if firstBDGSV is None:
                firstBDGSV = (BDGSV_done, BDGSV_Satellites_In_View, BDGSV_snrList, BDGSV_elevationList, BDGSV_azimuthList)

        elif nmeaLine and nmeaLine[0:6] == "$GPGSV":
            # so DoTemp can print on timeout
            global GPGSV_Satellites_In_View
            GPGSV_done, GPGSV_Satellites_In_View, GPGSV_snrList, GPGSV_elevationList, GPGSV_azimuthList = \
                DoGPGSV(nmeaLine, GPGSV_snrList, GPGSV_elevationList, GPGSV_azimuthList)
            # save the first one as a global. why isn't it blank the first time always
            # what if the ephemeris was already loaded
            global firstGPGSV
            if firstGPGSV is None:
                firstGPGSV = (GPGSV_done, GPGSV_Satellites_In_View, GPGSV_snrList, GPGSV_elevationList, GPGSV_azimuthList)

        elif nmeaLine and nmeaLine[0:6] == "$GNGGA":
            # Traquito doesn't broadcast this. u4b does
            # don't get exception on position fix
            raiseException = False
            # string "1" means got a fix ("6" is Dead Reckoning Mode fix?
            GNGGA_done, Position_Fix_Indicator, Satellites_Used, HDOP, MSL_Altitude = DoGNGGA(nmeaLine, raiseException)
            # save the first one as a global. why isn't it blank the first time always
            global firstGNGGA
            if firstGNGGA is None:
                firstGNGGA = (GNGGA_done, Position_Fix_Indicator, Satellites_Used, HDOP, MSL_Altitude)

        elif nmeaLine and nmeaLine[0:6] == "$GNGSA":
            # Traquito doesn't broadcast this. u4b does
            GNGSA_done, Mode_1, Mode_2, PDOP, HDOP, VDOP = DoGNGSA(nmeaLine)
            # save the first one as a global. why isn't it blank the first time always
            global firstGNGSA
            if firstGNGSA is None:
                firstGNGSA = (GNGSA_done, Mode_1, Mode_2, PDOP, HDOP, VDOP)

        elif nmeaLine and nmeaLine[0:6] == "$GNRMC":
            GNRMC_done, Status, Latitude, Longitude = DoGNRMC(nmeaLine)
            # save the first one as a global. why isn't it blank the first time always
            global firstGNRMC
            if firstGNRMC is None:
                firstGNRMC = (GNRMC_done, Status, Latitude, Longitude)


        #*********************************************
        doneList = [
            "GPGSV_done", GPGSV_done,
            "BDGSV_done", BDGSV_done,
            "GNGGA_done", GNGGA_done,
            "GNRMC_done", GNRMC_done,
            "GNGSA_done", GNGSA_done,
            "TTFF_elapsedTime", TTFF_elapsedTime,
            "TTFF_firstLockDuration", TTFF_firstLockDuration
        ]

        # doneCnt = GNGGA_done + GPGSV_done + GNGSA_done + GNRMC_done + (TTFF_elapsedTime is not None)
        # doneCnt = GNGGA_done + GNRMC_done + (TTFF_elapsedTime is not None)
        doneCnt = GPGSV_done + BDGSV_done + GNGGA_done + GNRMC_done + \
            (TTFF_elapsedTime is not None) + (TTFF_firstLockDuration is not None)

        # did anything change?
        # https://www.digitalocean.com/community/tutorials/how-to-compare-two-lists-in-python
        # You can use the set() function to create set objects using the given lists and
        # then compare the sets for equality using the == operator.
        # The order of the original list items is not important,
        # because the == operator returns true when each set contains identical items in any order.
        # Note: Duplicate list items appear only once in a set.

        #  if not (set(doneList) == set(last_doneList)):

        #***************************
        # debug
        if doneCnt != last_doneCnt:
            print("doneCnt", doneCnt, doneList)
            hwprint("doneCnt", doneCnt, doneList)

            # 3 ['GNGGA_done', True, 'GPGSV_done', False, 'GNGSA_done', False, 'GNRMC_done', True, 'TTFF_elapsedTime', 17]
            if False and doneCnt >= 5:
                print("EXIT: doneCnt >=5")
                sys.exit(1)

        last_doneList = doneList
        last_doneCnt = doneCnt

        #********************
        # fix! Do we get multiple with different fields?

        # old checks for u4b (getting info from all of them before saying "all done"
        # if GNGGA_done and GPGSV_done and GNGSA_done and GNRMC_done and (TTFF_elapsedTime is not None):
        # if GNGGA_done and GPGSV_done and GNGSA_done and GNRMC_done and Position_Fix_Indicator=="1":
        # traquito
        # if GNGGA_done and GNRMC_done and (TTFF_elapsedTime is not None):
        # traquito with debug firmware
        if API_MODE_FIRMWARE:
            # using BDGSV_done and GPGSV_done assumes we get at least one sat from GPS and BAIDU when we get a fix
            # if we set TTFF_elapsedTime because everything is cool for an instant
            # these done's might go away while waiting for TTFF_firstLockDuration to arrive?
            # if not already here
            # maybe have a countdown that starts with TTFF_elapsedTime
            # the _done aren't sticky?

            # if GPGSV_done and BDGSV_done and GNGGA_done and GNRMC_done and \
            #    (TTFF_elapsedTime is not None) and (TTFF_firstLockDuration is not None):

            # Or in the arriving states so it's sticky
            TTFF_data = [GPGSV_done, BDGSV_done, GNGGA_done, GNRMC_done, (TTFF_elapsedTime is not None), (TTFF_firstLockDuration is not None)]

            # does firstLockDuration not come sometimes?? Don't wait for it.
            # if GPGSV_done and BDGSV_done and GNGGA_done and GNRMC_done and (TTFF_elapsedTime is not None):

        else:
            #  just 4 things
            TTFF_data = (GNGGA_done, GNRMC_done, (TTFF_elapsedTime is not None), (TTFF_firstLockDuration is not None))
            # if GNGGA_done and GNRMC_done and \
            #     (TTFF_elapsedTime is not None) and (TTFF_firstLockDuration is not None):

        #***************************
        # sticky once set
        if TTFF_elapsedTime is not None:
            if TTFF_dataArrived is None:
                TTFF_dataArrived = TTFF_data
            else:
                TTFF_dataNew = []
                for d,a in zip(TTFF_data, TTFF_dataArrived):
                    TTFF_dataNew.append(d | a)
                TTFF_dataArrived = TTFF_dataNew

            #*******************
            if (TTFF_dataArrived is not None) and TTFF_dataArrived == ([True] * len(TTFF_dataArrived)):
                gpsFixFound = True
                # grep for gpsFixFound single fix wants to hit just one match..don't use name exactly
                print("ReadBytes: gps Fix Found set to True")
                hwprint("ReadBytes: gps Fix Found set to True")

        #*******************
        # gpsFixFound is sticky? Does it need to be?
        if gpsFixFound:
            todayMountain, MountainDateHMS = getTime()
            # ppp = " ".join(map(str, ["gpsFixFound", Position_Fix_Indicator, Satellites_Used, MSL_Altitude, Mode_1, Mode_2, PDOP, HDOP, VDOP, Satellites_In_View, Status]))


            # only use the "gpsFixFound" string if we're looking for a gps fix
            # otherwise print "gpsFixButNotLooking"
            # because we could be doing req/ack stuff after we've decided we're done
            # and don't want multiple gpsFixFound in the hw_test*txt file

            if stopOnGpsFix:
                gpsFixFoundStr = "gpsFixFound"
            else:
                gpsFixFoundStr = "gpsFixButNotLooking"

            if last_tempC is not None:
                # should be int
                ppp_temp = last_tempC
            else:
                ppp_temp = "None"

            ppp = " ".join(map(str, [MountainDateHMS,
                ppp_temp,
                gpsFixFoundStr,
                # these are all globals now too
                Position_Fix_Indicator, Satellites_Used, MSL_Altitude, HDOP,
                GPGSV_Satellites_In_View, BDGSV_Satellites_In_View,
                # these are globals
                maxSNR_GPGSV, maxSNR_BDGSV,
                meanSNR_GPGSV, meanSNR_BDGSV,
                TTFF_elapsedTime, TTFF_firstLockDuration]))

            global PREFIX
            print(colored(PREFIX + ppp, "green", attrs=["bold"]))
            hwprint(PREFIX + ppp)

        #***********************************************
        # in case we want to keep reading to make sure no backup in the input buffer
        # can't wait for empty because it never goes empty
        if (ser.in_waiting + serReader.in_waiting) < 250:
            almostEmptyFound = True
        else:
            almostEmptyFound = False

        #***********************************************
        if  \
            (stopOnTemp        and tempFound) or \
            (stopOnRep         and repFound) or \
            (stopOnAck         and ackFound) or \
            (stopOnGpsFix      and gpsFixFound) or \
            (stopOnEmpty       and emptyFound) or \
            (stopOnAlmostEmpty and almostEmptyFound):
            break

        if stopOnTemp and not tempFound:
            print("stopOnTemp but not tempFound")
        if stopOnRep and not repFound:
            print("stopOnRep but not repFound")
        if stopOnAck and not ackFound:
            print("stopOnAck but not ackFound")
        if stopOnGpsFix and not gpsFixFound:
            print("stopOnGpsFix but not gpsFixFound")
        if stopOnEmpty and not emptyFound:
            print("stopOnEmpty but not emptyFound")
        if stopOnAlmostEmpty and not almostEmptyFound:
            print("stopOnAlmostEmpty but not almostEmptyFound")

        if stopOnTemp and tempFound:
            print("stopOnTemp and tempFound")
        if stopOnRep and repFound:
            print("stopOnRep and repFound")
        if stopOnAck and ackFound:
            print("stopOnAck and ackFound")
        if stopOnGpsFix and gpsFixFound:
            print("stopOnGpsFix and gpsFixFound")
        if stopOnEmpty and emptyFound:
            print("stopOnEmpty and emptyFound")
        if stopOnAlmostEmpty and almostEmptyFound:
            print("stopOnAlmostEmpty and almostEmptyFound")


    print(
        "repError", repError,
        "ackError", ackError,
        "tempFound", tempFound,
        "repFound", repFound,
        "ackFound", ackFound,
        "gpsFixFound", gpsFixFound,
        "emptyFound", emptyFound,
        "almostEmptyFound", almostEmptyFound)

    # we have ack retry in case an important command somehow had a failed ack (get device info) and it was garbled
    # so we can retry?
    return repError, ackError, tempFound, repFound, ackFound, gpsFixFound, emptyFound, almostEmptyFound

#********************************
def ReadBytesUntil(wantTemp=False, wantRep=False, wantAck=False, wantGpsFix=False, wantEmpty=False, wantAlmostEmpty=False, waitMessage=None):
    global TTFF_elapsedTime
    global TTFF_dataArrived
    TTFF_elapsedTime = None
    TTFF_dataArrived = None

    # will go endlessly if no wants
    while True:
        repError, ackError, tempFound, repFound, ackFound, gpsFixFound, emptyFound, almostEmptyFound = \
            ReadBytes(
                stopOnTemp=wantTemp,
                stopOnRep=wantRep,
                stopOnAck=wantAck,
                stopOnGpsFix=wantGpsFix,
                stopOnEmpty=wantEmpty,
                stopOnAlmostEmpty=wantAlmostEmpty,
                waitMessage=waitMessage
            )

        if  \
            (wantTemp and tempFound) or \
            (wantRep and repFound) or \
            (wantAck and ackFound) or \
            (wantGpsFix and gpsFixFound) or \
            (wantEmpty and emptyFound) or \
            (wantAlmostEmpty and almostEmptyFound):
            break

    return repError, ackError, tempFound, repFound, ackFound, gpsFixFound, emptyFound, almostEmptyFound


#********************************

# possible messages
#                 case "REP_WSPR_SEND": this.OnMsgRepWsprSend(evt.msg); break;
#                 case "GPS_LINE": this.OnMsgGpsLine(evt.msg); break;
#                 case "GPS_FIX_TIME": this.OnMsgGpsFixTime(evt.msg); break;
#                 case "GPS_FIX_2D": this.OnMsgGpsFix2D(evt.msg); break;
#                 case "GPS_FIX_3D": this.OnMsgGpsFix3D(evt.msg); break;
#                 case "TEMP": this.OnMsgTemp(evt.msg); break;

# You can tell the tracker to shut off the transmitter by sending this:
# {"type":"SHELL_COMMAND","cmd":"app.tx off"}.
# This cuts power to the si5351.
# You can also tell the tracker to reboot (back to its initial state) by sending this:
# {"type":"SHELL_COMMAND","cmd":"sys.reset"}.


#****************
def DoSysReset():
    # turn gps power back on so we get some output
    # what if we were in the middle of a wspr? should reset the device
    # senditn('{"type":"REQ_GPS_POWER_ON"}')
    # WaitForAck()
    # reboot!
    # don't do this if we want to preserve almanac ephmeris?
    # old
    senditn('{"type":"SHELL_COMMAND","cmd":"sys.reset"}')

    # wrong? will this be a "type" ?
    # senditn('{"type":"SHELL_COMMAND","cmd":"REQ_SYS_RESET"}')

    # we need this to turn tx on in case we had turned it off?
    global ser
    ser.close()
    # do we have to wait more?
    # fails if only wait 1, 3
    # 5 failed?
    # 6 failed? (9600 baud?)
    sleep(8)

    # sleep(5)
    # sleep(10)
    # the reset closed the port. reopen
    # hmm. opens new /dev/ttyACM1?
    ser, serReader  = OpenSer()
    print("Takes about 11 secs after reset to get first TEMP after REQ_SYS_RESET")
    WaitForTemp()
    print("wait 5 secs more after TEMP (after REQ_) ??? then flush")
    sleep(5)
    ser.flushInput()
    return

#****************
def WaitForAck(waitMessage=None):
    # We don't specify what kind of ack?
    # only have one outstanding req/ack at a time?
    # hmm. what if we don't wait for an ack? there can be overlap then?
    waitStartTime = time.time()

    while True:
        repError, ackError, tempFound, repFound, ackFound, gpsFixFound, emptyFound, almostEmptyFound = ReadBytesUntil(
            wantAck=True,
            wantEmpty=True,
            waitMessage=waitMessage
        )
        if ackFound:
            print("WaitForAck: ackFound", waitMessage)
            break

        waitElapsedTime = time.time() - waitStartTime
        if waitElapsedTime > 10:
            print("ERROR: WaitForAck waitElapsedTime > 10", waitMessage)
            sys.exit(1)
    return

#****************
def WaitForTemp(waitMessage=None):
    waitStartTime = time.time()
    while True:
        repError, ackError, tempFound, repFound, ackFound, gpsFixFound, emptyFound, almostEmptyFound = ReadBytesUntil(
            wantTemp=True,
            # wantEmpty=True,
            waitMessage=waitMessage
        )
        if tempFound:
            print("WaitForTemp: tempFound", waitMessage)
            break

        waitElapsedTime = time.time() - waitStartTime
        if waitElapsedTime > 15:
            print("ERROR: WaitForTemp waitElapsedTime > 15", waitMessage)
            sys.exit(1)
    return

#****************
def WaitForRep(waitMessage=None, maxWaitSecs=120):
    waitStartTime = time.time()
    while True:
        repError, AckError, tempFound, repFound, ackFound, gpsFixFound, emptyFound, almostEmptyFound = ReadBytesUntil(
            wantRep=True,
            wantEmpty=True,
            waitMessage=waitMessage
        )
        if repFound:
            print("WaitForRep: repFound", waitMessage)
            break
        waitElapsedTime = time.time() - waitStartTime

        if waitElapsedTime > maxWaitSecs:
            # max 2 minutes for wspr message to go thru?
            # no alignment time in the req/ack
            print("ERROR: WaitForRep waitElapsedTime >", maxWaitSecs, waitMessage)
            sys.exit(1)

    return

#****************
# https://stackoverflow.com/questions/3463930/how-to-round-the-minute-of-a-datetime-object
def Align2Time():
    while True:
        dt = datetime.datetime.now()
        # don't have to worry about utc time vs local times. minute align should be the same
        seconds = (dt.replace(tzinfo=None) - dt.min).seconds
        secondsToWait = 120 - (seconds % 120)
        print("secondsToWait", secondsToWait, "to align to 2 minute utc")

        # 2 secs slop
        if secondsToWait > 12:
            print("Sleep for 10 secs")
            sleep(10)
        else:
            print("Sleep for secondsToWait", secondsToWait)
            sleep(secondsToWait)
            print("Aligned for WSPRing", datetime.datetime.now())
            break

    print(datetime.datetime.now())
    # flush the input buffer. it will just have the TEMP stuff we we don't care about
    # don't want the input buffer to get filled (4095 ?)
    ser.flushInput()
    return

#***********************************************
def Do_WSPR():
    global CORRECTION
    # frequency is set by band and channel in the config?
    # could try random channels by setting config info

    #    type : "REQ_WSPR_SEND",
    #    callsign: this.dom.callsign.value.trim(),
    #    grid: this.dom.grid4.value.trim(),
    #    power: this.dom.power.value.trim(),
    # callsign
    # 3rd char has to be a number. space in front if necessary. pad short callsigns to 6 chars at end
    # 37 allowed chars (alphanumeric plus space
    # final 3 chars can only be letters or space
    # has to be upper case
    # REP_WSPR_SEND?

    legalCallsigns = [
    "AB2ABC",
    "AB2AB",
    "AB2A",
    "AB2", # does this fail and cause 0A0AAA
    "B2ABC",
    "B2AB",
    "B2A", # fails and causes 0A0AAA
    "B2",  # fails and causes 0A0AAA
    ]

    #******************
    def randomCallsign():
        # is three digits legal? Should I rechoose if 3 digits? what about 2 leading digits?
        char1 = random.choice(' ' + string.digits + string.ascii_uppercase)
        if char1.isdigit() or char1 == " ":
            char2 = random.choice(string.ascii_uppercase)
        else:
            char2 = random.choice(string.digits + string.ascii_uppercase)

        char3 = random.choice(string.digits)
        # char4 = random.choice(' ' + string.digits + string.ascii_uppercase)
        char4 = random.choice(string.ascii_uppercase)
        char5 = random.choice(' ' + string.ascii_uppercase)
        char6 = random.choice(' ' + string.ascii_uppercase)

        if char1 == " " and char5 == "" and char6 == "":
            # don't allow just 2/3/4 to be not space
            char5 = random.choice(string.ascii_uppercase)

        # no embedded space
        # if char4=="": # is 3 spaces ever really legal? should char4 not have space choice?
        #     char5 = "" ; char6 = ""
        if char5=="":
            char6 = ""
        callsign = char1 + char2 + char3 + char4 + char5 + char6
        # try 3 spaces at end (always fails with jetpack)
        # callsign = char1 + char2 + char3
        # try 2 spaces at end
        # got L0Z how?
        callsign = char1 + char2 + char3 + char4

        # remove leading/trailing spaces
        callsign = callsign.strip()
        print("randomCallsign", callsign)
        return callsign

    def randomGrid4():
        # maidenhead A-R (2) then 0-9 (2)
        char1 = random.choice('ABCDEFGHIJKLMNOPQR')
        char2 = random.choice('ABCDEFGHIJKLMNOPQR')
        char3 = random.choice(string.digits)
        char4 = random.choice(string.digits)
        grid4 = char1 + char2 + char3 + char4

        print("randomGrid", grid4)
        # debug
        grid4 = random.choice(["RR99", "AR00", "RA99", "RR00", "RA00"])
        # why can't I get grid RR55?
        grid4 = random.choice(["AA01", "AA99", "AA90", "AA55", "RR55", "RR44", "RR33", "RR22", "RR11", "RR99", "AR00", "RA99", "RR00", "RA00"])
        return grid4

    def randomPower():
        # power can be 0 3 7 10 13 17 20 23 27 30 33 37 40 43 47 50 53 57 60
        powers = [0,3,7,10,13,17,20,23,27,30,33,37,40,43,47,50,53,57,60]
        power = random.choice(powers)
        print("randomPower", power)
        return str(power)

    #******************
    grid4List = ["AA01", "AA99", "AA90", "AA55", "RR55", "RR44", "RR33", "RR22", "RR11", "RR99", "AR00", "RA99", "RR00", "RA00"]
    with open("short_calls.txt", "r") as f:
        short_calls = f.readlines()

    #***************************************************
    tries = 0
    channel = 0
    # channel 0 was not allowed
    # channel = 1
    while channel <= 599:
        tries += 1
        ## grid4 = randomGrid4()
        i = (tries - 1) % len(grid4List)
        grid4 = grid4List[i]
        # HACK
        grid4 = "JUNK"

        power = randomPower()
        if USE_SHORT_CALLS:
            while True:
                callsign = random.choice(short_calls).strip()
                if callsign[0] != "#":
                    break
        else:
            callsign = randomCallsign()

        # HACK
        callsign = "RANDOM"
        print("callsign used:", callsign)

        # V0 thru V9 not itu assigned? does doug check?
        # FIX what about other non itu assigned?
        if False and callsign[0] == "V" and callsign[1].isdigit():
            print("illegal (non-ITU) randomCallsign", callsign, "try again")


        # V9 is detected as illegal prefix in config
        # {"type":"REQ_SET_CONFIG","band":"20m","channel":86,"callsign":" V9SYZ","correction":0}
        # {"type":"REP_SET_CONFIG","ok":false,"err":"Invalid callsign"}

        # senditn('{"type":"REQ_GET_CONFIG"}')
        # {"type":"REP_GET_CONFIG","band":"20m","channel":5,"callsign":"AD6Z","correction":0,"callsignOk":true}

        # enabling the slider (click in config blank area and type ? then slider appears)
        # can be 3500 to -3500
        # 28,124,600 + 1500 ?

        # channel map shows center bin freqs of
        # 28,126,020
        # 28,126,060
        # 28,126,140
        # 28,126,180


        # does this set the si5351 to the right frequency after I turn it on??
        # i should see red line in the waterfall if so.

        # report on effect of current correction
        FreqCorrection()
        sendStr = '{"type":"REQ_SET_CONFIG","band":"' + str(BAND) + '","channel":' + str(channel) + ',"callsign":"' + callsign +'","correction":' + str(CORRECTION) + '}'
        senditn(sendStr)

        # doesn't always REP?
        # New firmware okay? why do I get reply here but not above?
        WaitForRep(waitMessage="Waiting for SET_CONFIG reply in test loop", maxWaitSecs=30)

        # note we don't do a get config here..not necessary

        print("Now doing aligned wspr for callsign", callsign)
        Align2Time()
        # power can be 0 3 7 10 13 17 20 23 27 30 33 37 40 43 47 50 53 57 60
        # maidenhead A-R (2) then 0-9 (2)
        # grid has to be upper case
        senditn('{"type":"REQ_WSPR_SEND","callsign":"' + callsign + '","grid":"' + grid4 + '","power":' + power + '}')

        # no..because then we'll back up with more than 4095 bytes?
        # print("Sleep for 80 secs before looking for REQ_WSPR_SEND because output will stop anyhow")
        # time.sleep(80)
        # senditn('{"type":"REQ_WSPR_SEND","callsign":"' + callsign + '","grid":"DM69"}')

        # FIX! should we say what kind of reply?
        WaitForRep(waitMessage="Waiting for WSPR_SEND in main loop")

        # increment by 5 each time so the frequency changes each time
        if False:
            channel += 5
        else:
            # keep channel 0 if 0
            channel += CHANNEL_DELTA

            # don't change correction if 0 ???
            if CORRECTION == 0:
                pass
            elif CORRECTION > 0:
                # 100 is 1 hz lower
                # 1000 is 100 hz lower
                # keep inc'ing it if positive (should decrease freq?)
                CORRECTION = CORRECTION + CORRECTION_DELTA
            else:
                # keep adding -100 to the correction. (should increase freq)
                CORRECTION = CORRECTION - CORRECTION_DELTA

    #***************************************************
    # turn gps power back on
    if DO_GPS_POWER_ON:
        senditn('{"type":"REQ_GPS_POWER_ON"}')
        # this doesn't always ack either?
        # new firmware okay?

        # wasn't working 7/30/23
        ### WaitForAck(waitMessage="Waiting for GPS_POWER_ON in SendCmds" )
        # replaced 7/30/23
        sleep(5)
        sleep(3)
        print("okay to flush buffer because we shouldn't have any parallel activity we don't want to lose")
        ser.flushInput()

    # senditn('{"type":"REQ_GPS_RESET","temp":"warm"}')
    # senditn('{"type":"REQ_GPS_RESET","temp":"hot"}')

    # senditn('{"type":"REQ_GPS_POWER_ON"}')
    # senditn('{"type":"REQ_GPS_POWER_OFF"}')
    # senditn('{"type":"REQ_GPS_POWER_OFF_BATT_ON"}')

    # eventually returns these acks
    # {"type":"ACK","inType":"REQ_GPS_RESET"}
    # {"type":"ACK","inType":"REQ_GPS_POWER_OFF"}
    return

#**********************************
def SendCmds(trials):
    if trials==1 and DO_GET_DEVICE_INFO:
        senditn('{"type":"REQ_GET_DEVICE_INFO"}')
        # did we miss this?
        # failed after 161 on 8/2/23 with highest baud rate
        # maybe only do this once?
        WaitForRep("Waiting for GET_DEVICE_INFO reply in SendCmds", maxWaitSecs=30)

    # {"type":"REP_GET_DEVICE_INFO","hwVersion":"1.0","swVersion":"2023-06-20_13:20:30"}
    # sleep(4)
    # senditn('{"type":"REQ_PINGX"}')
    # {"type":"REP_PINGX","timeNow":327521197}
    # sleep(4)
    # doesn't work
    # senditn('{"type":"REQ_GET_CONFIG"}')
    # {"type":"REP_GET_CONFIG","band":"20m","channel":5,"callsign":"AD6Z","correction":0,"callsignOk":true}

    # sleep(4)
    # doesn't work?
    # senditn('{"type":"SHELL_COMMAND", "cmd": "date"}')
    # sleep(4)
    # JUST DO one req at a time. I don't look for the exact ack. so only one outstanding req/ack
    # I would think this gps reset turns the gps on if it's off?

    # senditn('{"type":"REQ_GPS_RESET","temp":"hot"}')
    # senditn('{"type":"REQ_GPS_RESET","temp":"cold"}')
    if DO_SLOW_CONFIG:
        FreqCorrection()
        sendStr = '{"type":"REQ_SET_CONFIG","band":"80m","channel":1,"callsign":"AD6Z","correction:"' + str(CORRECTION) + '}'
        senditn(sendStr)

        # doesn't always REP here. But reps below..odd
        # new firmware okay
        # WaitForRep(waitMessage="Waiting for SET_CONFIG reply in SendCmds" )

        # failed?
        if False:
            sendStr = '{"type":"REQ_GET_CONFIG"}'
            senditn(sendStr)
            WaitForRep(waitMessage="Waiting for GET_CONFIG reply in SendCmds" )

    else:
        ## senditn('{"type":"REQ_SET_CONFIG","band":"20m","channel":1,"callsign":"AD6Z","correction":0}')
        # doesn't always REP?
        # new firmware okay?
        # WaitForRep()
        pass

    if DO_TX_OFF or DO_TX_OFF_ACK_TEST:
        if DO_TX_OFF_ACK_TEST:
            j = 100
        else:
            j = 1
        for i in range(1,j):
            f = open(hw_test_filename, "a")
            print("test: DO_TX_OFF REQ", i)
            f.close()
            ## senditn('{"type":"SHELL_COMMAND","cmd":"app.tx off"}')
            # does this not always ack?
            senditn('{"type":"REQ_RADIO_OUTPUT_DISABLE"}')
            # senditn('{"type":"REQ_RADIO_OUTPUT_ENABLE"}')
            # does this not always ack?
            # don't wait for it
            WaitForAck(waitMessage="Waiting for RADIO_OUTPUT_DISABLE in SendCmds" )

            # so the buffer doesn't back up
            # don't need this now that we flush
            # ReadBytesUntil(wantAlmostEmpty=True, waitMessage="test: After tx off ack, Waiting for almost empty input buffer "+ str(i))
            print("test: DO_TX_OFF ACK okay", i)
            # don't want buffer to get more than 4095 bytes?
            # so don't delay too much
            sleep(5)
            # print("okay to flush buffer because we shouldn't have any parallel activity we don't want to lose")
            ser.flushInput()

    if DO_TX_ON:
        # senditn('{"type":"SHELL_COMMAND","cmd":"app.tx on"}')
        # does this not always ack?
        senditn('{"type":"REQ_RADIO_OUTPUT_ENABLE"}')
        # does this not always ack? We'll need a timeout if we do this
        WaitForAck(waitMessage="Waiting for RADIO_OUTPUT_ENABLE in SendCmds" )

    # need a lock before we can wspr?
    if DO_GPS_RESET or DO_WSPR:
        # this REQ_GPS_RESET turn power on? Maybe not
        # turn it off to make sure nmea messages stop

        # works for warm/hot reset too, and should similarly stop nmea broadcast
        senditn('{"type":"REQ_GPS_POWER_OFF_BATT_ON"}')

        # don't wait for it, in case it doesn't come
        # new firmware okay? hmm. failing 7/30/23
        ### WaitForAck(waitMessage="Waiting for transition to backup GPS power in SendCmds" )
        # is this needed before gsp reset?
        # serial buffer shouldn't overflow? but just in case
        # don't want buffer to get more than 4095 bytes?
        print("wait 15 secs for caps on gps power to drain? (shouldn't drain if backup power is left on)")
        sleep(15)
        print("okay to flush buffer because we shouldn't have any parallel activity we don't want to lose")
        ser.flushInput()

        # turn it back on
        senditn('{"type":"REQ_GPS_POWER_ON"}')

        # don't wait for it, in case it doesn't come
        # new firmware okay?
        # fail 7/23/22
        # WaitForAck(waitMessage="Waiting for GPS_POWER_ON in SendCmds" )
        # new
        sleep(5)

        # is this needed before gsp reset?
        # serial buffer shouldn't overflow? but just in case
        # don't want buffer to get more than 4095 bytes?
        # shouldn't get a fix in 3 secs? Want some separation between the power on and the cold reset?
        sleep(3)
        print("okay to flush buffer because we shouldn't have any parallel activity we don't want to lose")
        ser.flushInput()

        # start the clock from here, if doing single fix gps testing
        if GPS_TESTING:
            startTime = time.time()
            TTFF_elapsedTime = None
            TTFF_dataArrived = None

        senditn('{"type":"REQ_GPS_RESET","temp":"' + GPS_RESET_TYPE + '"}')
        # not working 7/30/23?
        # WaitForAck(waitMessage="Waiting for GPS_RESET in SendCmds" )


#**********************************
if __name__ == "__main__":
    trials = 0

    try:
        ser, serReader  = OpenSer()
    except Exception as e:
        sys.exit(1)
        print("ERROR: exception on first try to open serial", e, "...retrying after 5 secs with ACM_DIGIT", ACM_DIGIT)
        sleep(5)

        try:
            ser, serReader  = OpenSer()
        except Exception as e:
            print("ERROR: exception on second try to open serial", e, "...retrying after 5 secs with ACM_DIGIT", ACM_DIGIT)
            sleep(5)
            ser, serReader  = OpenSer()

    # we may have turned off tx accidently
    # we used to need a reset to turn it on.
    if DO_RESET:
        # what about turn GPS power off to make sure we lose the nvram?

        senditn('{"type":"REQ_GPS_POWER_OFF"}')
        # no ack??
        # new firmware okay? no, 8/2/23
        # WaitForAck(waitMessage="Waiting for GPS_POWER_OFF because of DO_RESET before main loop")
        # how long should we wait here to make sure nvram goes away
        sleep(5)
        sleep(3)
        ser.flushInput()

        DoSysReset()

    while(True):
        trials += 1
        # global
        FIX_PREFIX = "FIX_" + str(trials) + " "

        if trials == 1 or not DO_WSPR:
            # we only need gps fix once for DO_WSPR
            # otherwise do every loop (covers DO_GPS_TEST)
            SendCmds(trials)

        # globals. don't need to say global
        startTime = time.time()
        TTFF_elapsedTime = None
        TTFF_dataArrived = None
        PREFIX = ""

        if (trials == 1 or not DO_WSPR):
            waitMessage = "Waiting for gps fix in main loop"
            while True:
                repError, ackError, tempFound, repFound, ackFound, gpsFixFound, emptyFound, almostEmptyFound = ReadBytesUntil(
                    wantGpsFix=True,
                    wantEmpty=True,
                    waitMessage=waitMessage,
                )
                if gpsFixFound:
                    print("DoIt: gpsFixFound")
                    break

        if trials == 1 and DO_WSPR:
            # gps has to be off when we do wspr?
            if DO_GPS_POWER_OFF_BATT_ON:
                senditn('{"type":"REQ_GPS_POWER_OFF_BATT_ON"}')
                WaitForAck(waitMessage="Waiting for changing gps power to backup before wspr")
                print("After GPS power_off_batt_on we need to wait 5 secs?")
                # don't want buffer to get more than 4095 bytes?
                sleep(5)
                ser.flushInput()

        if DO_WSPR:
            Do_WSPR()

        print("Doit after final ReadBytes")
        print("TTFF_elapsedTime", TTFF_elapsedTime)
        print("TTFF_dataArrived", TTFF_dataArrived)
        print("")

        # TODO: what should the first one I get look like? anything?
        print("firstBDGSV", firstBDGSV)
        print("firstGPGSV", firstGPGSV)
        print("firstGNGGA", firstGNGGA)
        print("firstGNGSA", firstGNGSA)
        print("firstGNRMC", firstGNRMC)

        if not MULTIPLE_FIX:
            break


    if DO_GPS_RESET and GPS_RESET_TYPE == "cold":
        print("turn off GPS power after a good test?")
        senditn('{"type":"REQ_GPS_POWER_OFF"}')
    else:
        # print("hack leave power on fully between warm/hot tests")
        pass

        # print("turn off GPS power after a good test? Leave backup power on")
        # senditn('{"type":"REQ_GPS_POWER_OFF_BATT_ON"}')

    # don't wait for the ack, in case it doesn't come
    # new firmware okay?
    # we don't want multiple gpsFixFound reports while waiting, for the single fix ptest.sh
    # maybe just sleep 3 secs and be done
    # WaitForAck(waitMessage="Waiting for transition to backup GPS power at end of testing" )

    print("Doit All Done!")
    print("Look at",  hw_test_filename)
    print("Look at", all_lines_filename)


fhw.flush()
fhw.close()
fa.flush()
fa.close()
sys.exit(0)