def __init__(self): #I am not shure this is correct. According to docs, you do not instantate a logger. os.system('sudo ifconfig wlan0 down') # Can't have this up at comp logging.basicConfig(filename="../logs/runLogs.log", level=logging.DEBUG) logging.debug("\n--------------------New run------------------") logging.debug("Run started at: ") logging.debug(datetime.datetime.now().strftime('%Y/%m/%d %H:%M:%S')) logging.debug("---------------------------------------------\n") self.windowName = "picamera" self.target = comm.Target() self.commChan = None self.parseArgs() print("testPCam pid: %d args:" % os.getpid()) print(self.args) print("OpenCV version: {}".format(cv2.__version__)) if self.args.robot != "none": if self.args.robot == "roborio": logging.debug( datetime.datetime.now().strftime('%Y/%m/%d %H:%M:%S')) logging.debug("Connecting to robot at 10.49.15.2...") ip = "10.49.15.2" else: ip = "localhost" print("starting comm to " + ip) self.commChan = comm.Comm(ip) self.picam = picam.PiCam(resolution=(self.args.iwidth, self.args.iheight), framerate=(self.args.fps)) # Push something down the pipe. self.commChan.SetTarget(self.target)
def __init__(self): self._ser = comm.Comm( ) #serial.Serial(port=dev, baudrate=57600, timeout=1.0) #self._queue = queue.LifoQueue(1) self._runEn = False self._dataCallBack = self._debugCallBack self._configCallBack = None self._file = None self._last = None self._respRate = 0 self._inhTime = 0 self._pipMax = 0 self._pipOffset = 0 self._volMax = 0 self._volFactor = 0 self._volInThold = 0 self._peepMin = 0 self._runState = 0 self._status = 0 self._prevmillis = 0 self._stime = 0 self._smillis = -1 self._refresh = time.time() self._version = 'unknown' self._cpuid = [0] * 4 self.artime = 0 self._tOffset = 0 self._timestamp = time.time() self._cfgSerialNum = 0 self._queue = None self._data = npfifo.npfifo(9, 6000)
def __init__(self): Thread.__init__(self) self.scheduler = Scheduler() self.comm = comm.Comm() self.money = Money() self.status = BOX_INIT self.button = NO_BUTTON self.products = Products()
def __init__(self): self.commChan = None self.parseArgs() # logger init: # - we write logging info to file, for performance this should be # minimized. # - during debugging, set the loglevel to debug and see the 'spew' # via: "tail -f /tmp/runPiCam.log" if self.args.debug: logLevel = logging.DEBUG else: logLevel = logging.INFO logging.basicConfig( level=logLevel, format="%(asctime)s %(levelname)-6s: %(message)s", datefmt="%m/%d %H:%M:%S", # This file is avible to write to, even when the pi is in 'read-only' mode filename="/tmp/runPiCam.log", filemode="a") logging.info("--------------------New run------------------") logging.info("pid: %d" % os.getpid()) logging.info("args: " + str(self.args)) logging.info("opencv version: {}".format(cv2.__version__)) logging.debug("Parsed the following args:") logging.debug(self.args) if self.args.robot != "none": if self.args.robot == "roborio": fmt = "%Y/%m/%d %H:%M:%S" logging.debug(datetime.datetime.now().strftime(fmt)) logging.debug("Connecting to robot at 10.49.15.2...") ip = "10.49.15.2" else: ip = self.args.robot logging.info("starting comm to " + ip) self.commChan = comm.Comm(ip) # parameter configuration ----- self.config = getattr(config, self.args.config) # reads named dict self.picam = picam.PiCam(self.config["picam"]) self.algoConfig = self.config["algo"] # Updating config with passed commands # XXX: Need logic to check if these values exist in the chosen config # Unsure if an error will be thrown # Overriding config values with passed values if (self.args.display): self.algoConfig["display"] = True if (self.args.algo is not None): self.algoConfig["algo"] = self.args.algo
def __init__(self, gui): # The current open design self.design = None self.gui = gui self.timer = None self.comm = comm.Comm() # A list of folder mappings for the source code. # This is useful if you are debugging on a different file # system than where the compile was done. self.folder_mapping = {} # Debugging state self._currentState = (None, None) self._executionMode = backend.BACKEND_FPGA_LIVE self._instruction_mode = None # Trigger functions self.executionModeChanged = signals.Signal() self.stateChanged = signals.Signal() self.comm_disconnected = signals.Signal() self.traceMaxChanged = signals.Signal() self.designClosed = signals.Signal() self.designOpened = signals.Signal() self.errorOccurred = signals.Signal() self.minorMessage = signals.Signal() self.majorMessage = signals.Signal() self.enteringLongWork = signals.Signal() self.leavingLongWork = signals.Signal() # Initialize back-ends self.backends = {} self.backends[backend.BACKEND_FPGA_LIVE] = hardware.Hardware(self) self.backends[backend.BACKEND_FPGA_REPLAY] = replay.Replay(self) self.backends[backend.BACKEND_MODELSIM] = sim.Simulate(self) # self.instruction_mode = self.DEFAULT_INSTRUCTION_MODE # self.backends[self.executionMode].updateState() if self.gui: self.timer = QtCore.QTimer() self.timer.setInterval(self.TIMER_INTERVAL * 1000) self.timer.timeout.connect(self.timer_timeout) self.timer.start()
def __init__(self): self.windowName = "picamera" self.target = comm.Target() self.commChan = None self.parseArgs() print("testPCam pid: %d args:" % os.getpid()) print(self.args) print("OpenCV version: {}".format(cv2.__version__)) if self.args.robot != "none": if self.args.robot == "roborio": ip = "10.49.15.2" else: ip = "localhost" print("starting comm on " + ip) self.commChan = comm.Comm(ip) self.picam = picam.PiCam(resolution=(self.args.iwidth, self.args.iheight), framerate=(self.args.fps))
def __init__(self): self.commChan = None self.parseArgs() # logger init: # - we write logging info to file, for performance this should be # minimized. # - during debugging, set the loglevel to debug and see the 'spew' # via: "tail -f /tmp/runPiCam.log" if self.args.debug: logLevel = logging.DEBUG else: logLevel = logging.INFO logging.basicConfig(level=logLevel, format="%(asctime)s %(levelname)-6s: %(message)s", datefmt="%m/%d %H:%M:%S", filename="/tmp/runPiCam.log", filemode="a") logging.info("--------------------New run------------------") logging.info("pid: %d" % os.getpid()) logging.info("args: " + str(self.args)) logging.info("opencv version: {}".format(cv2.__version__)) logging.debug("Parsed the following args:") logging.debug(self.args) if self.args.robot != "none": if self.args.robot == "roborio": fmt = "%Y/%m/%d %H:%M:%S" logging.debug(datetime.datetime.now().strftime(fmt)) logging.debug("Connecting to robot at 10.49.15.2...") ip = "10.49.15.2" else: ip = self.args.robot logging.info("starting comm to " + ip) self.commChan = comm.Comm(ip) # parameter configuration ----- self.config = getattr(config, self.args.config) # reads named dict self.picam = picam.PiCam(self.config["picam"])
def main(): global s_args global s_comm global s_config try: parser = argparse.ArgumentParser( description="Start the picam streamer") parser.add_argument("--robot", dest="robot", help="robot (none, localhost, roborio) [none]", default="none") parser.add_argument("--debug", dest="debug", help="debug: [0,1] ", default=0) parser.add_argument("--config", dest="config", help="config: default,greenled,noled...", default="default") s_args = parser.parse_args() s_config = getattr(config, s_args.config) if s_args.robot != "none": if s_args.robot == "roborio": ip = "10.49.15.2" else: ip = s_args.robot s_comm = comm.Comm(ip) logFmt = "streamer %(levelname)-6s %(message)s" dateFmt = "%H:%M" if s_args.debug: loglevel = logging.DEBUG else: loglevel = logging.INFO logging.basicConfig(level=loglevel, format=logFmt, datefmt=dateFmt) server = HTTPServer(('', 5080), CamHandler) logging.info("server started with config " + s_args.config) server.serve_forever() except KeyboardInterrupt: logging.warning("aborting server") server.socket.close()
getRotateCorners,\ getLocalTranslation,\ rotateLocalTranslation,\ getGlobalTranslation,\ sortRects,\ getLocalRotateType from util import mapToWorld, mapToImage, deg from math import sin, cos import preprocess import comm import protocol draw = True mycomm = comm.Comm(print) protocol.init(mycomm) sensor.reset() # grayscale is faster (160x120 max on OpenMV-M7) # sensor.set_pixformat(sensor.RGB565) sensor.set_pixformat(sensor.GRAYSCALE) sensor.set_framesize(sensor.QQVGA) sensor.skip_frames(time=2000) clock = time.clock() size = [160, 120] Size = [280, 240] equations = []
import comm import logging import time logging.basicConfig(level=logging.DEBUG) print("starting comm") c = comm.Comm("localhost") # connect to fake robot on localhost t = comm.Target() threshold = time.clock() - .01 while True: now = time.clock() if now > threshold: print(".") t.clock = now threshold = now + .01 # 100 hz if t.angleX == None: t.angleX = 0 t.angleY = 0 else: t.angleX += 1 t.angleY -= 1 c.SetTarget(t)
else: logf = None start_time = time.time() print('Initializing communications on {} {} ...'.format( args.port, args.baud)) if args.port.upper() == 'MOCK': import mock # unless we are reading out the chip firmware read a new file to load with open('mock.hex') as fp: mock_firmware = intelhex.Hexfile() mock_firmware.read(fp) ser = mock.ICSPHost('12F1822', mock_firmware) else: import serial ser = serial.Serial(args.port, baudrate=args.baud, bytesize=DATA, timeout=TOUT) # create wrapper with comm.Comm(ser, logf) as ser_com: print(ser_com) program(ser_com) print(f"elapsed time: {time.time() - start_time:0.2f} seconds")
def main(portName1, simulated): print "INITIALIZING TORSO..." ###Connection with ROS rospy.init_node("torso") jointStates = JointState() jointStates.name = [ "spine_connect", "waist_connect", "shoulders_connect", "shoulders_left_connect", "shoulders_right_connect" ] jointStates.position = [0.0, 0.0, 0.0, 0.0, 0.0] pubTorsoPos = rospy.Publisher("/hardware/torso/current_pose", Float32MultiArray, queue_size=1) pubGoalReached = rospy.Publisher("/hardware/torso/goal_reached", Bool, queue_size=1) pubJointStates = rospy.Publisher("/joint_states", JointState, queue_size=1) pubStop = rospy.Publisher("robot_state/stop", Empty, queue_size=1) pubEmergencyStop = rospy.Publisher("robot_state/emergency_stop", Bool, queue_size=1) subRelativeHeight = rospy.Subscriber("/hardware/torso/goal_rel_pose", Float32MultiArray, callbackRelative) subAbsoluteHeight = rospy.Subscriber("/hardware/torso/goal_pose", Float32MultiArray, callbackAbsolute) subStop = rospy.Subscriber("robot_state/stop", Empty, callbackStop) subEmergencyStop = rospy.Subscriber("robot_state/emergency_stop", Bool, callbackEmergency) subTorsoUp = rospy.Subscriber("/hardware/torso/torso_up", String, callbackTorsoUp) subTorsoDown = rospy.Subscriber("/hardware/torso/torso_down", String, callbackTorsoDown) rate = rospy.Rate(ITER_RATE) global valueRel global valueAbs global absH global relH global stop global torsoUp global torsoDown global eme_stop global new_eme_msg_recv valueAbs = False valueRel = False torsoUp = False torsoDown = False torsoPos = 0 bumper = 0 stop = False msgCurrentPose = Float32MultiArray() msgGoalReached = Bool() msgCurrentPose.data = [0, 0, 0] msgMotor = None initTimeMtrMsg = datetime.now() initTimeSnrMsg = datetime.now() timeoutSnr = 0 timeoutMtr = 0 ArdIfc = comm.Comm(portName1) msgSensor = comm.Msg(comm.ARDUINO_ID, comm.MOD_SENSORS, comm.OP_GETCURRENTDIST, [], 0) ArdIfc.send(msgSensor) goalPose = 0 new_eme_msg_recv = False eme_stop = Bool() eme_stop.data = False while not rospy.is_shutdown(): try: timeoutSnr = datetime.now() - initTimeSnrMsg if timeoutSnr.microseconds > MSG_SENSOR_TIMEOUT: ArdIfc.send(msgSensor) initTimeSnrMsg = datetime.now() newMsg = ArdIfc.recv() if newMsg != None: if newMsg.mod == comm.MOD_SENSORS: if newMsg.op == comm.OP_GETCURRENTDIST: torsoPos = newMsg.param[0] #rospy.loginfo("Torso-> Arduino ack GET CURRENT DIST msg received.") if newMsg.mod == comm.MOD_SYSTEM: if newMsg.op == comm.OP_PING: rospy.loginfo("Torso-> Arduino ack PING msg received.") if newMsg.op == comm.OP_STOP: rospy.loginfo( "Torso-> Arduino Emercenty STOP system received. " ) if eme_stop.data != bool(newMsg.param[0]): eme_stop.data = newMsg.param[0] pubEmergencyStop.publish(eme_stop) if newMsg.mod == comm.MOD_MOTORS: if newMsg.op == comm.OP_SETTORSOPOSE: msgMotor_ack_received = True rospy.loginfo( "Torso-> Arduino ack SETTORSOPOSE msg received.") if newMsg.op == comm.OP_GOUP: msgMotor_ack_received = True rospy.loginfo("Torso-> Arduino ack GOUP msg received.") if newMsg.op == comm.OP_GODOWN: msgMotor_ack_received = True rospy.loginfo( "Torso-> Arduino ack GODOWN msg received.") if newMsg.op == comm.OP_STOP_MOTOR: msgMotor_ack_received = True #rospy.loginfo("Torso-> Arduino ack STOP MOTOR msg received.") #until ack received timeoutMtr = datetime.now() - initTimeMtrMsg if msgMotor != None and timeoutMtr.microseconds > MSG_MOTOR_TIMEOUT and not msgMotor_ack_received: ArdIfc.send(msgMotor) initTimeMtrMsg = datetime.now() if valueAbs and not eme_stop.data and absH >= DIST_LIM_INF and absH <= DIST_LIM_SUP: msgMotor_ack_received = False msgMotor = comm.Msg(comm.ARDUINO_ID, comm.MOD_MOTORS, comm.OP_SETTORSOPOSE, int(absH), 1) ArdIfc.send(msgMotor) valueAbs = False goalPose = absH initTimeMtrMsg = datetime.now() elif valueRel and not eme_stop.data and ( torsoPos + relH) >= DIST_LIM_INF and ( torsoPos + relH) <= DIST_LIM_SUP: msgMotor_ack_received = False absCalH = torsoPos + relH msgMotor = comm.Msg(comm.ARDUINO_ID, comm.MOD_MOTORS, comm.OP_SETTORSOPOSE, int(absCalH), 1) ArdIfc.send(msgMotor) goalPose = absCalH valueRel = False initTimeMtrMsg = datetime.now() elif (valueAbs and (absH < DIST_LIM_INF or absH > DIST_LIM_SUP)) or ( valueRel and (torsoPos + relH > DIST_LIM_SUP or torsoPos + relH < DIST_LIM_INF)): rospy.logerr("Torso-> Can not reach te position.") valueAbs = False valueRel = False goalPose = torsoPos elif torsoUp and not eme_stop.data: rospy.loginfo("Torso-> Moving torso up.") msgMotor = comm.Msg(comm.ARDUINO_ID, comm.MOD_MOTORS, comm.OP_GOUP, [], 0) ArdIfc.send(msgMotor) torsoUp = False msgMotor_ack_received = False initTimeMtrMsg = datetime.now() goalPose = torsoPos elif torsoDown and not eme_stop.data: rospy.loginfo("Torso-> Moving torso down.") msgMotor = comm.Msg(comm.ARDUINO_ID, comm.MOD_MOTORS, comm.OP_GODOWN, [], 0) ArdIfc.send(msgMotor) torsoDown = False msgMotor_ack_received = False initTimeMtrMsg = datetime.now() goalPose = torsoPos elif eme_stop.data and new_eme_msg_recv: rospy.loginfo("Torso-> Stop message.") msgMotor = comm.Msg(comm.ARDUINO_ID, comm.MOD_MOTORS, comm.OP_STOP_MOTOR, [], 0) ArdIfc.send(msgMotor) msgMotor_ack_received = False initTimeMtrMsg = datetime.now() new_eme_msg_recv = False torsoDown = False torsoUp = False valueAbs = False valueRel = False jointStates.header.stamp = rospy.Time.now() jointStates.position = [(torsoPos - TORSO_ADJUSTMENT) / 100.0, 0.0, 0.0, 0.0, 0.0] pubJointStates.publish(jointStates) msgCurrentPose.data[0] = (torsoPos - TORSO_ADJUSTMENT) / 100.0 msgCurrentPose.data[1] = 0.0 msgCurrentPose.data[2] = 0.0 pubTorsoPos.publish(msgCurrentPose) msgGoalReached.data = abs(goalPose - torsoPos) < THR_DIFF_POS pubGoalReached.publish(msgGoalReached) rate.sleep() except: rospy.logerr( "Torso-> Oopps...we have some issues in this node :( ")
def main(): parser = argparse.ArgumentParser(prog='flash', description='icsp programming tool.') parser.add_argument('-p', '--port', default=DEFAULT_PORT, help='serial device') parser.add_argument('-b', '--baud', default=DEFAULT_BAUD, help='baud rate') group = parser.add_mutually_exclusive_group() group.add_argument('-i', '--id', action='store_true', help='read chip id info from target') group.add_argument('-w', '--write', action='store_true', help='write firmware to target') group.add_argument('-r', '--read', action='store_true', help='Read target and save to file') parser.add_argument('-1', '--mclr1', action='store_true', help="use mclr1 for 28 pin chips") parser.add_argument('-q', '--quiet', action='store_true', help="quiet mode. don't dump hex files") parser.add_argument('-e', '--enh', action='store_true', help='Enhanced midrange programming method') parser.add_argument('-f', '--fast', action='store_true', help='Fast mode. Do minimal verification') parser.add_argument('-l', '--log', nargs='?', const='bload.log', default=None, help='Log all I/O to file') parser.add_argument('-t', '--test', action='store_true', help='Test') parser.add_argument( '--version', action='version', version='$Id: flash.py 740 2017-11-25 02:25:22Z rnee $') parser.add_argument('filename', default=None, nargs='?', action='store', help='HEX filename') args = parser.parse_args() args.write = not args.read and not args.id if args.log: if os.path.exists(args.log): os.unlink(args.log) logf = open(args.log, 'a') else: logf = None # logf = sys.stdout # Check for a filename if not args.id and args.filename is None: parser.print_help() sys.exit() # unless we are reading out the chip firmware read a new file to load if not args.read and not args.id: with open(args.filename) as fp: file_firmware = intelhex.Hexfile() file_firmware.read(fp) if not args.quiet: print(args.filename) print(file_firmware.display()) else: file_firmware = None # Init comm (holds target in reset) print(f'Initializing communications on {args.port} at {args.baud} ...') if MOCK: # read firmware to simulate target and load and create mock target firmware = intelhex.Hexfile() with open(TMP + 'icsp.hex') as fp: firmware.read(fp) ser = mock.ICSPHost(firmware) else: ser = serial.Serial(args.port, baudrate=args.baud, bytesize=DATA, timeout=TOUT) # Create wrapper com = comm.Comm(ser, logf) # Bring target out of reset print('Reset...') time.sleep(0.050) com.pulse_dtr(0.250) time.sleep(0.050) # Trigger and look for prompt for _ in range(5): com.flush() com.write(b'K') (count, value) = com.read(1) if value == b'K': break else: com.close() print(f'[{count}, {value}] Could not find ICSP on {args.port}\n') sys.exit() print('Connected...') # flush input buffer so that we can start out synchronized com.flush() # Get host controller version print('Getting Version...') ver = icsp.get_version(com) print('KT150 firmware version:', ver) display_status(com) if args.mclr1: print('Start using MCLR1...') send_start1(com) else: print('Start using MCLR2...') send_start2(com) icsp.sync(com) display_status(com) print("\nDevice Info:") chip_id, cfg1, cfg2, cal1, cal2 = read_info(com) # enhanced and midrange have different id/rev bits for mask, shift in ((0x00F, 4), (0x01F, 5)): device_id = chip_id >> shift device_rev = chip_id & mask if device_id in picdevice.PARAM: break else: print(" ID: %04X not in device list" % chip_id) print("End...") icsp.release(com) sys.exit() device_param = picdevice.PARAM[device_id] device_name = device_param['name'] print(f" ID: {device_id:04X} {device_name} rev {device_rev:02X}") print(f"CFG: {cfg1:04X} {cfg2:04X}") print(f"CAL: {cal1:04X} {cal2:04X}") # Set ranges and addresses based on the bootloader config and device information min_page = 0 max_page = device_param['max_page'] min_data = device_param['min_data'] max_data = device_param['max_data'] conf_page_num = device_param['conf_page'] if args.read: print("Reset Address...") icsp.reset_address(com) print("Reading Firmware...") chip_firmware = read_firmware(com, device_param) print() with open(args.filename, mode='w') as fp: chip_firmware.write(fp) if not args.quiet: print(chip_firmware.display()) elif args.write: # Erase entire device including userid locations print("Erase Device...") icsp.load_config(com) icsp.erase_program(com) icsp.erase_data(com) icsp.reset_address(com) sys.stderr.flush() print(f"Writing Program 0x0 .. 0x{max_page:#0X} ...") icsp.write_program_pages(com, file_firmware, device_param) print(f"Writing Data {min_data:#0X} .. {max_data:#0X} ...") icsp.write_data_pages(com, file_firmware, device_param) print("Writing Config 0x%X ..." % conf_page_num) icsp.reset_address(com) icsp.write_config(com, file_firmware, device_param) print("Reading Firmware...") icsp.reset_address(com) verify_firmware = read_firmware(com, device_param) print() # Compare protected regions to ensure they are compatible print("Comparing firmware pages 0x%X .. 0x%X, 0x%X .. 0x%X, 0x%X..." % (min_page, max_page, min_data, max_data, conf_page_num)) check_list = list(range(min_page, max_page + 1)) + list( range(min_data, max_data)) + [conf_page_num] error_list = file_firmware.compare(verify_firmware, check_list) if error_list: print("\nWARNING!\nError verifying firmware.") for page_num in error_list: if file_firmware[page_num]: print("File:") print(file_firmware[page_num].display(page_num)) if verify_firmware[page_num]: print("Chip:") print(verify_firmware[page_num].display(page_num)) else: print(" OK") print("End...") icsp.release(com) com.close()
if __name__ == "__main__": import logging manager = Manager() import json state = manager.dict() state['time'] = time.time() state['log_lvl'] = zlog.DEBUG import worker1 import comm comm_obj = comm.Comm() # short cuts dm = msg_que.demux_lst mx = msg_que.mux_lst proc_lst = [{ 'target': comm_obj.incoming, 'args': (), 'kwargs': { 'state': state }, 'name': 'incoming' }, { 'target': comm_obj.outgoing, 'args': (),
import sys sys.path.append("python_client") import comm import message import time c=comm.Comm() c.connect() print("Found device id=%s, port=%s" % (c.id,c.port)) run=True count=0 first=0 last=0 start=0 while (run): line=c.readPacket() if(line is None): continue m=message.Message() try: m.decode(line) except: continue if(m.status!=m.ERR_OK): continue if(m.id == m.DATA and m.nFloat==5 and m.nInt==2): if(count==0): first=m.millis start=time.time() count=count+1
def run(argv=None): parser = argparse.ArgumentParser( prog='pyload', description='pyload Bload bootloader tool.') parser.add_argument('-p', '--port', default=DEFAULT_PORT, help=f'serial device ({DEFAULT_PORT})') parser.add_argument('-b', '--baud', default=DEFAULT_BAUD, help='baud rate') parser.add_argument('-q', '--quiet', action='store_true', help='quiet mode. dont dump hex files') parser.add_argument('-c', '--cdef', action='store_true', help='Convert filename to C definition statements') parser.add_argument('-f', '--fast', action='store_true', help='Fast mode. Do minimal verification') parser.add_argument('-r', '--read', action='store_true', help='Read target and save to filename') parser.add_argument('-x', '--reset', action='store_true', help='Reset target and exit') parser.add_argument('-t', '--term', action='store_true', help='Start terminal mode after processing') parser.add_argument('-l', '--log', nargs='?', const='bload.log', default=None, help='Log all I/O to file') parser.add_argument( '--version', action='version', version='$Id: pyload.py 901 2018-04-28 21:44:56Z rnee $') parser.add_argument('filename', default=None, nargs='?', action='store', help='HEX filename') args = parser.parse_args(args=argv if argv else sys.argv[1:]) # reading and fast mode are incompatible if args.read and args.fast: parser.print_help() sys.exit() if args.log: if os.path.exists(args.log): os.unlink(args.log) logf = open(args.log, 'a') else: logf = None print('Initializing communications on {} {} ...'.format( args.port, args.baud)) if args.port.upper() == 'MOCK': import mock # unless we are reading out the chip firmware read a new file to load with open('mock.hex') as fp: mock_firmware = intelhex.Hexfile() mock_firmware.read(fp) ser = mock.BLoadHost('12F1822', mock_firmware) else: import serial ser = serial.Serial(args.port, baudrate=args.baud, bytesize=DATA, timeout=TOUT) # create wrapper with comm.Comm(ser, logf) as ser_com: if args.reset: ser_com.pulse_dtr(0.250) if args.term: term.terminal(ser_com) # Check for commands that require a filename if args.filename is not None: program(ser_com, args) if args.term: ser_com.pulse_dtr(0.250) term.terminal(ser_com)