def main(): # Set up a simple argument parser. parser = binhoArgumentParser(description="Utility for I2C communication via Binho host adapter") parser.add_argument( "-u", "--pullup", action="store_true", help="Enable 2.2k pullup resistors (3.3V)", ) parser.add_argument("-f", "--frequency", default=None, help="Set clock frequency") parser.add_argument( "-a", "--address", nargs=1, type=ast.literal_eval, help="7-bit address for communication over the I2C Bus", ) parser.add_argument( "-r", "--read", default=0, help="Number of bytes expecting to receive from the I2C Bus", ) parser.add_argument( "-w", "--write", nargs="*", type=ast.literal_eval, default=[], help="Bytes to send over the I2C Bus", ) parser.add_argument("-z", "--scan", action="store_true", help="Scan all possible i2c addresses") args = parser.parse_args() log_function = log_verbose if args.verbose else log_silent try: log_function("Trying to find a Binho host adapter...") device = parser.find_specified_device() if device.inBootloaderMode: print( "{} found on {}, but it cannot be used now because it's in DFU mode".format( device.productName, device.commPort ) ) sys.exit(errno.ENODEV) elif device.inDAPLinkMode: print( "{} found on {}, but it cannot be used now because it's in DAPlink mode".format( device.productName, device.commPort ) ) print("Tip: Exit DAPLink mode using 'binho daplink -q' command") sys.exit(errno.ENODEV) else: log_function("{} found on {}. (Device ID: {})".format(device.productName, device.commPort, device.deviceID)) except DeviceNotFoundError: if args.serial: print( "No Binho host adapter found matching Device ID '{}'.".format(args.serial), file=sys.stderr, ) else: print("No Binho host adapter found!", file=sys.stderr) sys.exit(errno.ENODEV) # if we fail before here, no connection to the device was opened yet. # however, if we fail after this point, we need to make sure we don't # leave the serial port open. try: device.operationMode = "I2C" if args.frequency: log_function("Setting I2C clock frequency to {}Hz".format(args.frequency)) device.i2c.frequency = int(args.frequency) if args.pullup: log_function( "Engaging the internal 2.2kOhm PullUp resistors. (Pulled to 3.3V). Remove the '-u' flag to rely on " + "external resistors." ) device.i2c.useInternalPullUps = True else: log_function( "Internal 2.2kOhm PullUp resistors are disengaged. Add the '-u' flag to engage the internal resistors." ) device.i2c.useInternalPullUps = False if args.scan: if args.frequency: scan(device, args.pullup, [int(args.frequency)]) else: scan(device, args.pullup, [100000, 400000, 1000000, 3200000]) if args.write and args.read: transmit(device, args.address[0], args.write, int(args.read), log_function) elif args.write: write(device, args.address[0], args.write, log_function) elif args.read: read(device, args.address[0], int(args.read), log_function) else: if not args.scan: log_function( "No transaction performed. Please specify data to write with '-w' or a number of bytes to read " + "using '-r'." ) log_function("You can type 'binho i2c --help' for more information.") # close the connection to the host adapter device.close() except Exception: # pylint: disable=broad-except # Catch any exception that was raised and display it binho_error_hander() # close the connection to the host adapter device.close()
def main(): # Set up a simple argument parser. parser = binhoArgumentParser( description="Utility for SPI communication via Binho host adapter") parser.add_argument( "-r", "--read", default=0, help="Number of bytes expecting to receive from the SPI Bus", ) parser.add_argument( "-w", "--write", nargs="*", type=ast.literal_eval, default=[], help="Bytes to send over the SPI Bus", ) parser.add_argument("-f", "--frequency", default=None, help="Set clock frequency") parser.add_argument("-c", "--chipselect", default=0, help="Set CS signal IO pin") parser.add_argument( "-n", "--invertCS", action="store_true", help="Set CS signal as inverted (Active High)", ) parser.add_argument("-m", "--mode", default=0, help="Set SPI mode") args = parser.parse_args() log_function = log_verbose if args.verbose else log_silent try: log_function("Trying to find a Binho host adapter...") device = parser.find_specified_device() if device.inBootloaderMode: print( "{} found on {}, but it cannot be used now because it's in DFU mode" .format(device.productName, device.commPort)) sys.exit(errno.ENODEV) elif device.inDAPLinkMode: print( "{} found on {}, but it cannot be used now because it's in DAPlink mode" .format(device.productName, device.commPort)) print("Tip: Exit DAPLink mode using 'binho daplink -q' command") sys.exit(errno.ENODEV) else: log_function("{} found on {}. (Device ID: {})".format( device.productName, device.commPort, device.deviceID)) except DeviceNotFoundError: if args.serial: print( "No Binho host adapter found matching Device ID '{}'.".format( args.serial), file=sys.stderr, ) else: print("No Binho host adapter found!", file=sys.stderr) sys.exit(errno.ENODEV) # if we fail before here, no connection to the device was opened yet. # however, if we fail after this point, we need to make sure we don't # leave the serial port open. try: if args.write or int(args.read) > 0: if args.frequency: log_function("SPI clock set to {}Hz".format(args.frequency)) if args.mode: if int(args.mode) < 0 or int(args.mode) > 3: print( "SPI mode must be 0, 1, 2, or 3. mode = {} is not a valid setting." .format(args.mode)) device.close() sys.exit(errno.EINVAL) else: log_function("SPI mode set to mode {}".format(args.mode)) csPin = {} if args.chipselect: if args.chipselect.isnumeric(): chipSelectStr = "IO" + str(args.chipselect) else: chipSelectStr = args.chipselect csPin = device.gpio.getPin(chipSelectStr) else: csPin = None if csPin: if args.invertCS: log_function( "Using IO{} as an Active-High (inverted) ChipSelect signal" .format(csPin.pinNumber)) else: log_function( "Using IO{} as an Active-Low (standard) ChipSelect signal" .format(csPin.pinNumber)) else: log_function( "No ChipSelect signal specified, will not be used for this transaction. Use -c to specify IO pin to\ use for ChipSelect if desired.") transmit( device, args.write, int(args.read), csPin, args.invertCS, args.mode, log_function, ) else: log_function( "No transaction performed. Please specify data to write with '-w' or a number of bytes to read using \ '-r'.") log_function( "You can type 'binho spi --help' for more information.") # close the connection to the host adapter device.close() except Exception: # pylint: disable=broad-except # Catch any exception that was raised and display it binho_error_hander() finally: # close the connection to the host adapter device.close()
def main(): # Set up a simple argument parser. parser = binhoArgumentParser( description= "Utility for experimenting with Binho host adapters on-board DAC") parser.add_argument( "-f", "--format", dest="format", type=str, default="voltage", choices=["voltage", "raw"], help= "Format for the input.\nVoltage string, or binary value to be loaded into the DAC.", ) parser.add_argument( "value", metavar="[value]", type=float, help= "The desired voltage (default) or raw value to load into DAC (with -f raw).", ) args = parser.parse_args() log_function = log_verbose if args.verbose else log_silent try: log_function("Trying to find a Binho host adapter...") device = parser.find_specified_device() if device.inBootloaderMode: print( "{} found on {}, but it cannot be used now because it's in DFU mode" .format(device.productName, device.commPort)) sys.exit(errno.ENODEV) elif device.inDAPLinkMode: print( "{} found on {}, but it cannot be used now because it's in DAPlink mode" .format(device.productName, device.commPort)) print("Tip: Exit DAPLink mode using 'binho daplink -q' command") sys.exit(errno.ENODEV) else: log_function("{} found on {}. (Device ID: {})".format( device.productName, device.commPort, device.deviceID)) except DeviceNotFoundError: if args.serial: print( "No Binho host adapter found matching Device ID '{}'.".format( args.serial), file=sys.stderr, ) else: print("No Binho host adapter found!", file=sys.stderr) sys.exit(errno.ENODEV) # if we fail before here, no connection to the device was opened yet. # however, if we fail after this point, we need to make sure we don't # leave the serial port open. try: pinNumber = device.dac.getDefaultDACPin() if args.format == "voltage": device.dac.setOutputVoltage(args.value) log_function("DAC channel {} set to {} Volts".format( pinNumber, args.value)) else: device.dac.setOutputRaw(int(args.value)) log_function("DAC channel {} set to {}".format( pinNumber, int(args.value))) # close the connection to the host adapter device.close() except Exception: # pylint: disable=broad-except # Catch any exception that was raised and display it binho_error_hander() # close the connection to the host adapter device.close()
# Finally read back the newly written data from the EEPROM writeData = [0xF0, 0x00, 0x00] readCount = 4 rxData, status = binho.oneWire.transfer(writeData, readCount, command="SKIP") if status: rcvdBytes = "Read from EEPROM - Resp: {} byte(s):\t".format(len(rxData)) for byte in rxData: rcvdBytes += "\t " + "0x{:02x}".format(byte) print(rcvdBytes) else: print("5. Read Back From EEPROM Failed!") print() print("Finished!") # It's generally bad practice to indiscriminately catch all exceptions, however the # binho_error_handler() simply prints out all the debug info as the script terminates # it does not try to continue execution under any circumstances except Exception: # Catch any exception that was raised and display it binho_error_hander() finally: # close the connection to the host adapter binho.close()
def main(): # pylint: disable=too-many-locals # Set up a simple argument parser. parser = binhoArgumentParser(description="Utility for working with I2C EEPROMs") parser.add_argument( "-u", "--pullup", action="store_true", help="Enable 2.2k pullup resistors (3.3V)", ) parser.add_argument( "-n", "--partnumber", default=None, help="Look up device parameters based on EEPROM manufacturer part number. These parameters can be provided \ individually.", ) parser.add_argument( "-f", "--frequency", default=400000, help="Max supported clock frequency of the EEPROM", ) parser.add_argument( "-a", "--address", default=0, help="Offset from base address set on pins A0-A2, if present on package. Defaults to 0b000", ) parser.add_argument("-c", "--capacity", default=None, type=int, help="EEPROM capacity in bytes") parser.add_argument("-t", "--writetime", default=0.005, type=float, help="EEPROM write cycle time") parser.add_argument( "-m", "--bitmask", default="AAA", help="Bitmask to determine how to use lowest three bits of EEPROM I2C Address", ) parser.add_argument("-g", "--pagesize", default=None, type=int, help="EEPROM page size in bytes") parser.add_argument( "-b", "--blank", action="store_true", help="Check if the EEPROM is blank. No other operation will be performed.", ) parser.add_argument("-e", "--erase", action="store_true", help="Erase the EEPROM before writing") parser.add_argument( "-y", "--verify", action="store_true", help="Verify the EEPROM contents after writing", ) parser.add_argument( "-r", "--read", default=None, type=str, help="Read EEPROM data and save it to the provided file", ) parser.add_argument( "-w", "--write", default=None, type=str, help="Write the data from the provided file to the EEPROM", ) args = parser.parse_args() log_function = log_verbose if args.verbose else log_silent try: log_function("Trying to find a Binho host adapter...") device = parser.find_specified_device() if device.inBootloaderMode: print( "{} found on {}, but it cannot be used now because it's in DFU mode".format( device.productName, device.commPort ) ) sys.exit(errno.ENODEV) elif device.inDAPLinkMode: print( "{} found on {}, but it cannot be used now because it's in DAPlink mode".format( device.productName, device.commPort ) ) print("Tip: Exit DAPLink mode using 'binho daplink -q' command") sys.exit(errno.ENODEV) else: log_function("{} found on {}. (Device ID: {})".format(device.productName, device.commPort, device.deviceID)) except DeviceNotFoundError: if args.serial: print( "No Binho host adapter found matching Device ID '{}'.".format(args.serial), file=sys.stderr, ) else: print("No Binho host adapter found!", file=sys.stderr) sys.exit(errno.ENODEV) # if we fail before here, no connection to the device was opened yet. # however, if we fail after this point, we need to make sure we don't # leave the serial port open. try: t0 = time.time() # pylint: disable=unused-variable ih = IntelHex() # pylint: disable=unused-variable programmer = [] # pylint: disable=unused-variable device.operationMode = "I2C" if args.partnumber: # programmer = device.create_programmer('eeprom', device='24FC512') log_function("Using predefined parameters for EEPROM part number {}".format(args.partnumber.upper())) programmer = device.create_programmer("eeprom", device=args.partnumber.upper()) elif args.frequency and args.capacity and args.writetime and args.bitmask and args.pagesize: log_function("EEPROM manually defined:") log_function( "Max Clock Frequency: {}, Base Address Offset: {}, Bitmask: {}".format( args.frequency, args.address, args.bitmask ) ) log_function( "Capacity: {} bytes, Page Size: {} bytes, Write Cycle Time: {} s".format( args.capacity, args.pagesize, args.writetime ) ) programmer = device.create_programmer( "eeprom", args.capacity, args.pagesize, bitmask=str(args.bitmask), slave_address=args.address, write_cycle_length=args.writetime, ) else: log_function("EEPROM part number not provided, parameters must be manually supplied.") log_function("Flags -f, -a, -c, -t, -m, -g should be used to supply the device parameters") log_function("when the device part number cannot be used.") device.close() sys.exit(1) log_function("") if args.pullup: log_function( "Engaging the internal 2.2kOhm PullUp resistors. (Pulled to 3.3V). Remove the '-u' flag to rely on " "external resistors." ) device.i2c.useInternalPullUps = True else: log_function( "Internal 2.2kOhm PullUp resistors are disengaged. Add the '-u' flag to engage the internal resistors." ) device.i2c.useInternalPullUps = False log_function("") if args.read and args.write: log_function( "Cannot perform read and write in the same operation! Please perform these operations separately" ) device.close() sys.exit(1) if args.verify and not args.write: log_function("Cannot perform verify without writing a file at this time.") device.close() sys.exit(1) if args.blank: log_function("Checking if the EEPROM is blank...") t_start = time.time() isBlank = programmer.blankCheck() t_stop = time.time() elapsedTime = "%.3f" % (t_stop - t_start) if isBlank: log_function("EEPROM is blank! Elapsed time: {} seconds".format(elapsedTime)) device.close() sys.exit(0) else: log_function("EEPROM is NOT blank! Elapsed time: {} seconds".format(elapsedTime)) device.close() sys.exit(1) if args.erase: log_function("Erasing the EEPROM...") te_start = time.time() programmer.erase() te_stop = time.time() elapsedTime = "%.3f" % (te_stop - te_start) log_function("EEPROM Erase completed! Elapsed time: {} seconds".format(elapsedTime)) if args.read: filename, file_extension = os.path.splitext(args.read) # pylint: disable=unused-variable fileFormat = "bin" if file_extension == ".hex": fileFormat = "hex" log_function("Reading from the EEPROM...") tr_start = time.time() programmer.readToFile(args.read, format=fileFormat) tr_stop = time.time() elapsedTime = "%.3f" % (tr_stop - tr_start) log_function("EEPROM Read completed! Elapsed time: {} seconds".format(elapsedTime)) log_function("EEPROM Data saved as {} file to : {}".format(fileFormat, args.read)) if args.write: filename, file_extension = os.path.splitext(args.write) fileFormat = "bin" if file_extension == ".hex": fileFormat = "hex" log_function("Writing Data to EEPROM from {} file: {}".format(fileFormat, args.write)) tw_start = time.time() programmer.writeFromFile(args.write, format=fileFormat) tw_stop = time.time() elapsedTime = "%.3f" % (tw_stop - tw_start) log_function("EEPROM Write completed! Elapsed time: {} seconds".format(elapsedTime)) if args.verify: log_function("Verifying Data written to EEPROM from {} file: {}".format(fileFormat, args.write)) ty_start = time.time() programmer.verifyFile(args.write, format=fileFormat) ty_stop = time.time() elapsedTime = "%.3f" % (ty_stop - ty_start) log_function("EEPROM Verify completed! Elapsed time: {} seconds".format(elapsedTime)) # close the connection to the host adapter device.close() except Exception: # pylint: disable=broad-except # Catch any exception that was raised and display it binho_error_hander() # close the connection to the host adapter device.close()
def main(): # Set up a simple argument parser. parser = binhoArgumentParser(description="utility for updating firmware on Binho host adapters") parser.add_argument( "-q", "--quit", action="store_true", help="Exit DFU mode, return to normal operation.", ) parser.add_argument( "-b", "--btldr", action="store_true", help="Enter DFU mode. Note that this will be done automatically during firmware upgrade commands.", ) parser.add_argument( "-l", "--latest", action="store_true", help="Update the firmware of the target device to the latest release available", ) parser.add_argument( "-r", "--release", default=None, help="Update the firmware of the desired device to a specific release version", ) args = parser.parse_args() log_function = log_verbose if args.verbose else log_silent try: log_function("Trying to find a Binho host adapter...") device = parser.find_specified_device() log_function("{} found on {}. (Device ID: {})".format(device.productName, device.commPort, device.deviceID)) except DeviceNotFoundError: if args.serial: print( "No Binho host adapter found matching Device ID '{}'.".format(args.serial), file=sys.stderr, ) else: print("No Binho host adapter found!", file=sys.stderr) sys.exit(errno.ENODEV) # if we fail before here, no connection to the device was opened yet. # however, if we fail after this point, we need to make sure we don't # leave the serial port open. try: if args.quit: if device.inBootloaderMode: log_function("Exiting bootloader...") device.exit_bootloader() log_function("Completed!") elif device.inDAPLinkMode: log_function("{} is not in bootloader, cannot exit!".format(device.productName)) log_function("Note: You can exit DAPLink mode using the 'binho daplink -q' command.") else: log_function("{} is not in bootloader, cannot exit!".format(device.productName)) log_function("Note: You can enter bootloader mode using the 'binho dfu' command.") elif args.btldr: if device.inBootloaderMode: log_function( "{}:{} on {} is already in it's bootloader".format( device.productName, device.deviceID, device.commPort ) ) else: log_function("Resetting {} into it's bootloader".format(device.productName)) binhoDFUManager.switchToBootloader(device) log_function("Bootloader Details:") log_function("Version: {}".format(binhoDFUManager.bootloaderInfo["version"])) log_function("Model: {}".format(binhoDFUManager.bootloaderInfo["model"])) log_function("BoardID: {}".format(binhoDFUManager.bootloaderInfo["boardID"])) log_function("Completed!") else: if args.latest and args.release: print("Invalid arguments. -l/--latest cannot be used with -r/--release") sys.exit(1) if args.latest: log_function("Getting latest firmware release...") latestVersion = binhoDFUManager.getLatestFirmwareVersion(device.FIRMWARE_UPDATE_URL) log_function("Latest Version: {}".format(latestVersion)) if device.firmwareVersion == latestVersion: print("This {} is already running the latest firmware.".format(device.productName)) else: log_function("Updating device...") binhoDFUManager.switchToNormal(device) log_function("Firmware Update Complete!") elif args.release: if device.firmwareVersion == args.release: print( "This {} is already running firmware version {}.".format( device.productName, device.firmwareVersion ) ) else: log_function("Looking for {} Release...".format(args.release)) is_available = binhoDFUManager.isFirmwareVersionAvailable(device.FIRMWARE_UPDATE_URL, args.release) if not is_available: print("{} is not available.".format(args.release)) sys.exit(1) log_function("Found it. Preparing to update device.") binhoDFUManager.switchToNormal(device, args.release) log_function("Firmware Update Complete!") device.close() except Exception: # pylint: disable=broad-except # Catch any exception that was raised and display it binho_error_hander() # close the connection to the host adapter device.close()
def main(): # Set up a simple argument parser. parser = binhoArgumentParser(description="utility for using supported Binho host adapters in DAPLink mode") parser.add_argument( "-q", "--quit", action="store_true", help="Quit DAPlink mode, return to host adapter mode", ) args = parser.parse_args() log_function = log_verbose if args.verbose else log_silent try: log_function("Trying to find a Binho host adapter...") device = parser.find_specified_device() if device.inDAPLinkMode: log_function("{} found on {} in DAPLink mode".format(device.productName, device.commPort)) else: log_function("{} found on {}. (Device ID: {})".format(device.productName, device.commPort, device.deviceID)) except DeviceNotFoundError: if args.serial: print( "No Binho host adapter found matching Device ID '{}'.".format(args.serial), file=sys.stderr, ) else: print("No Binho host adapter found!", file=sys.stderr) sys.exit(errno.ENODEV) # if we fail before here, no connection to the device was opened yet. # however, if we fail after this point, we need to make sure we don't # leave the serial port open. try: if device.inBootloaderMode: log_function( "{} is in DFU mode, exiting to application mode before continuing...".format(device.productName) ) device.exit_bootloader() time.sleep(5) device = parser.find_specified_device() if args.quit: if device.inDAPLinkMode: log_function("Returning to host adapter mode... This will cause the device to reset.") binhoDFUManager.switchToNormal(device) log_function("Completed!") else: log_function("{} is not in DAPLink mode.".format(device.productName)) else: if device.inDAPLinkMode: log_function("{} is already in DAPLink mode.".format(device.productName)) else: log_function("Switching to DAPLink mode... This will cause the device to reset.") binhoDFUManager.switchToDAPLink(device) log_function("Completed!") device.close() except Exception: # pylint: disable=broad-except # Catch any exception that was raised and display it binho_error_hander() # close the connection to the host adapter device.close()
def main(): # pylint: disable=too-many-locals # Set up a simple argument parser. parser = binhoArgumentParser( description="Utility for working with SPI FLASH memory devices") parser.add_argument("-c", "--chipselect", default=0, help="Set CS signal IO pin") parser.add_argument( "-n", "--invertCS", action="store_true", help="Set CS signal as inverted (Active High)", ) parser.add_argument("-m", "--mode", default=0, help="Set SPI mode") parser.add_argument( "-f", "--frequency", default=12000000, help="Specifies the frequency for the SPI Clock", ) args = parser.parse_args() log_function = log_verbose if args.verbose else log_silent try: log_function("Trying to find a Binho host adapter...") device = parser.find_specified_device() if device.inBootloaderMode: print( "{} found on {}, but it cannot be used now because it's in DFU mode" .format(device.productName, device.commPort)) sys.exit(errno.ENODEV) elif device.inDAPLinkMode: print( "{} found on {}, but it cannot be used now because it's in DAPlink mode" .format(device.productName, device.commPort)) print("Tip: Exit DAPLink mode using 'binho daplink -q' command") sys.exit(errno.ENODEV) else: log_function("{} found on {}. (Device ID: {})".format( device.productName, device.commPort, device.deviceID)) except DeviceNotFoundError: if args.serial: print( "No Binho host adapter found matching Device ID '{}'.".format( args.serial), file=sys.stderr, ) else: print("No Binho host adapter found!", file=sys.stderr) sys.exit(errno.ENODEV) # if we fail before here, no connection to the device was opened yet. # however, if we fail after this point, we need to make sure we don't # leave the serial port open. try: # set the host adapter operationMode to 'SPI' device.operationMode = "SPI" if args.frequency: log_function("SPI clock set to {}Hz".format(args.frequency)) if args.mode: if int(args.mode) < 0 or int(args.mode) > 3: print( "SPI mode must be 0, 1, 2, or 3. mode = {} is not a valid setting." .format(args.mode)) device.close() sys.exit(errno.EINVAL) else: log_function("SPI mode set to mode {}".format(args.mode)) csPin = {} if args.chipselect: if args.chipselect.isnumeric(): chipSelectStr = "IO" + str(args.chipselect) else: chipSelectStr = args.chipselect csPin = device.gpio.getPin(chipSelectStr) else: csPin = None if csPin: if args.invertCS: log_function( "Using IO{} as an Active-High (inverted) ChipSelect signal" .format(csPin.pinNumber)) else: log_function( "Using IO{} as an Active-Low (standard) ChipSelect signal". format(csPin.pinNumber)) else: log_function( "No ChipSelect signal specified, will not be used for this transaction. Use -c to specify IO pin to\ use for ChipSelect if desired.") # Now that we've got the SPI CS pin configuration, let's go ahead and create the programmer object # This function accepts a number of parameters, not all shown or demo'd here # spiFlash = device.create_programmer( # "spiFlash", chip_select_pin=csPin, autodetect=True, mode=args.mode, # clocK_frequency=args.frequency # ) print( "This command is still under construction. Please come back again later!" ) sys.exit(1) except Exception: # pylint: disable=broad-except # Catch any exception that was raised and display it binho_error_hander() finally: # close the connection to the host adapter device.close()
def main(): # Set up a simple argument parser. parser = binhoArgumentParser(description="Utility for 1-Wire communication via Binho host adapter") parser.add_argument("-n", "--iopin", default=0, help="Use the given IO pin number for the 1Wire bus") parser.add_argument("-u", "--pullup", action="store_true", help="Enable 2.2k pullup resistor (3.3V)") parser.add_argument( "-r", "--read", default=0, help="Number of bytes expecting to receive from the 1Wire Bus", ) parser.add_argument( "-w", "--write", nargs="*", type=ast.literal_eval, default=[], help="Bytes to send over the 1Wire Bus", ) parser.add_argument("-k", "--skip", action="store_true", help="SKIP device selection") parser.add_argument("-z", "--search", action="store_true", help="Search") args = parser.parse_args() log_function = log_verbose if args.verbose else log_silent try: log_function("Trying to find a Binho host adapter...") device = parser.find_specified_device() if device.inBootloaderMode: print( "{} found on {}, but it cannot be used now because it's in DFU mode".format( device.productName, device.commPort ) ) sys.exit(errno.ENODEV) elif device.inDAPLinkMode: print( "{} found on {}, but it cannot be used now because it's in DAPlink mode".format( device.productName, device.commPort ) ) print("Tip: Exit DAPLink mode using 'binho daplink -q' command") sys.exit(errno.ENODEV) else: log_function("{} found on {}. (Device ID: {})".format(device.productName, device.commPort, device.deviceID)) except DeviceNotFoundError: if args.serial: print( "No Binho host adapter found matching Device ID '{}'.".format(args.serial), file=sys.stderr, ) else: print("No Binho host adapter found!", file=sys.stderr) sys.exit(errno.ENODEV) # if we fail before here, no connection to the device was opened yet. # however, if we fail after this point, we need to make sure we don't # leave the serial port open. try: device.oneWire.begin(args.iopin, args.pullup) if args.search: address = device.oneWire.search() full_addr = "0x" for byte in address: full_addr += "{:02x}".format(byte) log_function("Search discovered device with address = {}".format(full_addr)) if args.write and args.read: transfer(device, args.skip, args.write, int(args.read), log_function) elif args.write: write(device, args.skip, args.write, log_function) elif args.read: read(device, args.skip, int(args.read), log_function) # close the connection to the host adapter device.close() except Exception: # pylint: disable=broad-except # Catch any exception that was raised and display it binho_error_hander() # close the connection to the host adapter device.close()
def main(): # Set up a simple argument parser. parser = binhoArgumentParser( description="utility for controller Binho host adapter's GPIO pins") parser.add_argument( "-m", "--mode", dest="mode", type=str, default="DIN", choices=["DIN", "DOUT"], help="Set the mode of the IO pin", ) parser.add_argument("-n", "--iopin", default=0, help="Provide the IO pin to use for this operation") parser.add_argument("-o", "--output", default=None, help="Set the output value") args = parser.parse_args() log_function = log_verbose if args.verbose else log_silent try: log_function("Trying to find a Binho host adapter...") device = parser.find_specified_device() if device.inBootloaderMode: print( "{} found on {}, but it cannot be used now because it's in DFU mode" .format(device.productName, device.commPort)) sys.exit(errno.ENODEV) elif device.inDAPLinkMode: print( "{} found on {}, but it cannot be used now because it's in DAPlink mode" .format(device.productName, device.commPort)) print("Tip: Exit DAPLink mode using 'binho daplink -q' command") sys.exit(errno.ENODEV) else: log_function("{} found on {}. (Device ID: {})".format( device.productName, device.commPort, device.deviceID)) except DeviceNotFoundError: if args.serial: print( "No Binho host adapter found matching Device ID '{}'.".format( args.serial), file=sys.stderr, ) else: print("No Binho host adapter found!", file=sys.stderr) sys.exit(errno.ENODEV) # if we fail before here, no connection to the device was opened yet. # however, if we fail after this point, we need to make sure we don't # leave the serial port open. try: device.operationMode = "IO" pin = {} if args.iopin: if args.iopin.isnumeric(): pinStr = "IO" + str(args.iopin) else: pinStr = args.iopin.upper() else: pinStr = "IO0" # get the desired pin pin = device.gpio.getPin(pinStr) # set the pin mode if args.output: pin.mode = "DOUT" if args.output.isnumeric(): if int(args.output) == 0: pin.value = 0 elif int(args.output) == 1: pin.value = 1 else: raise ValueError( "Output can only be set to 0 or 1, not {}".format( args.output)) log_function("Configured {} as a digital output = {} ".format( pinStr, int(args.output))) elif args.output.upper() == "HIGH": pin.value = 1 log_function( "Configured {} as a digital output and drove the signal {} " .format(pinStr, args.output.upper())) elif args.output.upper() == "LOW": pin.value = 0 log_function( "Configured {} as a digital output and drove the signal {} " .format(pinStr, args.output.upper())) else: raise ValueError( "Output can only be set to LOW or HIGH, not {}".format( args.output)) else: pin.mode = "DIN" value = pin.value if value == 0: log_function("{} is 0 (LOW)".format(pinStr)) elif value == 1: log_function("{} is 1 (HIGH)".format(pinStr)) # close the connection to the host adapter device.close() except Exception: # pylint: disable=broad-except # Catch any exception that was raised and display it binho_error_hander() # close the connection to the host adapter device.close()
def main(): # Set up a simple argument parser. parser = binhoArgumentParser( description="utility for reading from Binho host adapter's ADC") parser.add_argument( "-f", "--frequency", default=None, help="Set PWM frequency from 750Hz to 80000Hz", ) parser.add_argument("-n", "--iopin", default=0, help="Provide the IO pin to use for the pwm output") parser.add_argument( "value", metavar="[value]", help= "The desired duty cycle or raw value to load into the pwm generator.", ) args = parser.parse_args() log_function = log_verbose if args.verbose else log_silent try: log_function("Trying to find a Binho host adapter...") device = parser.find_specified_device() if device.inBootloaderMode: print( "{} found on {}, but it cannot be used now because it's in DFU mode" .format(device.productName, device.commPort)) sys.exit(errno.ENODEV) elif device.inDAPLinkMode: print( "{} found on {}, but it cannot be used now because it's in DAPlink mode" .format(device.productName, device.commPort)) print("Tip: Exit DAPLink mode using 'binho daplink -q' command") sys.exit(errno.ENODEV) else: log_function("{} found on {}. (Device ID: {})".format( device.productName, device.commPort, device.deviceID)) except serial.SerialException: print( "The target Binho host adapter was found, but failed to connect because another application already has an \ open connection to it.") print( "Please close the connection in the other application and try again." ) sys.exit(errno.ENODEV) except DeviceNotFoundError: if args.serial: print( "No Binho host adapter found matching Device ID '{}'.".format( args.serial), file=sys.stderr, ) else: print("No Binho host adapter found!", file=sys.stderr) sys.exit(errno.ENODEV) # if we fail before here, no connection to the device was opened yet. # however, if we fail after this point, we need to make sure we don't # leave the serial port open. try: device.operationMode = "IO" pin = {} if args.iopin: if args.iopin.isnumeric(): pinStr = "IO" + str(args.iopin) else: pinStr = args.iopin.upper() else: pinStr = "IO0" # Will need to clean this up later to support other products # however, will need to do some plumbing to make that work, don't want it to delay the # initial release of this library if pinStr == "IO1": raise ValueError( "PWM Functionality is not supported on IO1 - please choose another pin!" ) # get the desired pin pin = device.gpio.getPin(pinStr) # set the pin mode pin.mode = "PWM" log_function("Configuring {} for PWM output".format(pinStr)) if args.frequency: if args.frequency.isnumeric(): targetFreq = int(args.frequency) if targetFreq < 750 or targetFreq > 80000: raise ValueError( "PWM Frequency must be a number from 750 to 80000 (Hz), not {}" .format(args.frequency)) pin.pwmFreq = targetFreq log_function("Setting PWM Frequency to {} Hz".format( args.frequency)) else: raise ValueError( "PWM Frequency must be a number from 750 to 80000 (Hz), not {}" .format(args.frequency)) if args.value.isnumeric(): if 0 <= int(args.value) <= 1024: pin.value = args.value log_function( "Setting PWM output to {} (~{}% duty cycle)".format( args.value, "%.1f" % (int(args.value) / 1024 * 100.0))) else: raise ValueError( "PWM value must be a number from 0 to 1023 (or 0% to 100%), not {}" .format(args.value)) elif "%" in args.value: dutyCycle = args.value.strip("%") if dutyCycle.isnumeric(): convValue = float(dutyCycle) / 100.0 * 1024 if 0 <= int(convValue) <= 1024: pin.value = int(convValue) log_function( "Setting PWM output to {} (~{}% duty cycle)".format( int(convValue), "%.1f" % (int(convValue) / 1024 * 100.0))) else: raise ValueError( "PWM value must be a number from 0 to 1023 (or 0% to 100%), not {}%" .format(dutyCycle)) else: raise ValueError( "PWM value must be a number from 0 to 1023 (or 0% to 100%), not {}" .format(args.value)) else: raise ValueError( "PWM value must be a number from 0 to 1023 (or 0% to 100%), not {}" .format(args.value)) # close the connection to the host adapter device.close() except Exception: # pylint: disable=broad-except # Catch any exception that was raised and display it binho_error_hander() # close the connection to the host adapter device.close()