1 of 26

Python Libraries

Automation of Binho Nova is made to be extremely easy using the Binho Python Package. This library also includes a command line interface for Nova such that it's possible to perform simple tasks like I2C or SPI transactions right from the command line / shell.

Stable Release

Binho Python Package

Legacy

This library is still supported, but is not recommended for new designs.

Python Wrapper (legacy)

Notice!

Our initial python library was actually what would best be described as a 'wrapper'. It simply wrapped our ASCII commands into a set of equivalent Python functions. This served as well, but was a temporary solution to buy us time to produce a much more powerful library. We highly encourage everyone to use our new Python package which is packed with features:

Binho Python Package

This page and the others in this section are left for historical purposes. This 'wrapper' library remains available and we'll continue to support customers using it, however all future improvements will be implemented only in our new library.

Documentation

The packaged releases contains two libraries:

binhoHostAdapter

This library is essentially a wrapper for all of the commands presented in the documentation. The library is written in such a way to support multiple devices as well as by making use of threads.

binhoUtilities

This library provides a handful of functions which aid in device management, as in identifying COM ports and Binho devices attached to the host computer.

Here's where the releases live on PyPi:

Installation

The officially-supported Python library can easily be installed using pip:

This library is cross-platform and is intended for use with Python 3.x.

Example Usage

There are also many examples of the python libraries in action in the examples section of the support portal:

API Reference

The library contains two classes, each with a distinct purpose. Please see the following pages for the documentation on each of these classes.

Functions to connect to a host adapter and interact with it:

Utility functions for device discovery and management:

binhoHostAdapter

We highly encourage everyone to use our which is packed with features. This library is still supported, but is not recommended for new design.

The binhoHostAdapter class contains all the necessary functions to programmatically control / automate all of the functionality of your binho Multi-Protocol USB Host Adapter. This class can be included in your code as show below.

This class contains a multitude of functions split into several different categories. The documentation has been split up accordingly.

Device Functions

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

echo()

This function toggles whether or not the device echos back all the commands it receives. This really has no practical use in automation, but was included in the python library for the sake of completion. Turning the echo on is best for manual use in a terminal application which doesn't support local echo. Aside from this use case, it is not recommended to turn on echo. The default state of the device is with echo turned off.

Inputs:

This function takes no parameters.

Outputs:

The host adapter will respond with -OK upon successful execution of the command.

Example Usage:

ping()

This function provides for a simple way to solicit a response from the device. This can be useful when verifying the connection status with the device.

Inputs:

This function takes no parameters.

Outputs:

The host adapter will respond with -OK upon successful execution of the command.

Example Usage:

setOperationMode(index, mode)

This function sets the mode of operation of the given adapter interface. This determines which protocol is being used, and therefore the pin functions. Any IO pins which are not assigned a function for the set protocol will continue to be available for concurrent use. The default operation mode on power up is IO.

Inputs:

This function takes 2 parameters, index, as an integer, and mode, as a string.

Note that for Binho Multi-Protocol USB Host Adapter, the only valid index is 0. This aspect of the protocol is design to support future products which may have more than one adapter interface.

The following list of values are valid values for mode parameter:

'I2C'
'SPI'
'UART'
'1-WIRE'

The list of possible device modes will grow as new protocols added to the firmware. Note that it will be important to ensure your device has the latest version of firmware loaded on to it.

Outputs:

The host adapter will respond with -OK upon successful execution of the command. In case of an invalid parameter, the host adapter will respond with -NG indicating the command did not execute successfully.

Example Usage:

getOperationMode(index)

This function gets the host adapter operation mode. This determines which protocol is being used, and therefore the pin functions. Any IO pins which are not assigned a function for the set protocol will continue to be available for concurrent use. The default operation mode on power up is IO.

Inputs:

This function takes 1 parameters, index, as an integer. Note that for Binho Multi-Protocol USB Host Adapter, the only valid index is 0. This aspect of the protocol is design to support future products which may have more than one adapter interface.

Outputs:

The host adapter will respond with one of the following responses:

-MODE [index] IO when the host adapter is in IO mode (default).
-MODE [index] I2C when the host adapter is in I2C mode.
-MODE [index] SPI when the host adapter is in SPI mode.

The list of possible device modes will grow as new protocols added to the firmware. Note that it will be important to ensure your device has the latest version of firmware loaded on to it.

Example Usage:

setNumericalBase(base)

This function sets the host adapter display base. This determines which radix is being used when data is sent back as ASCII characters. The supported numerical bases are binary, decimal, and hexadecimal. The default numerical base on power up is hex.

Inputs:

This function takes 1 parameter, base, as a string. The following list of values are valid for this parameter:

'BIN' or '2' sets the numerical base to base-2 (binary).
'DEC' or '10' sets the numerical base to base-10 (decimal).
'HEX' or '16' sets the numerical base to base-16 (hexadecimal).

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command. In case of an invalid parameter, the host adapter will respond with '-NG' indicating the command did not execute successfully.

Example Usage:

getNumericalBase()

This function gets the host adapter display base. This determines which radix is being used when data is sent back as ASCII characters. The supported numerical bases are binary, decimal, and hexadecimal. The default numerical base on power up is hex.

Inputs:

This function takes no parameters.

Outputs:

The host adapter will respond with one of the following responses:

'-BASE BIN' when the host adapter is set to base-2 (binary).
'-BASE DEC' when the host adapter is set to base-10 (decimal).
'-BASE HEX' when the host adapter is set to base-16 (hexadecimal, default).

Example Usage:

setLEDRGB(r, g, b)

This function sets the color of the internal RGB LED by setting the 8-bit red, green, and blue values.

Inputs:

This function takes three parameters, each as integer values:

r - red value expressed as 0 - 255
g - green value expressed as 0 - 255
b - blue value expressed as 0 - 255

Note that any value passed in less than 0 will be rounded up to 0. Conversely, any value passed in greater than 255 will be rounded down to 255.

Outputs:

Example Usage:

setLEDColor(color)

This function sets the color of the internal RGB LED by passing the name of a common color.

Inputs:

This function takes a single input parameter, color, as a string. The following list of values are valid inputs for this parameter:

'WHITE'
'RED'
'LIME'
'GREEN'

Outputs:

Example Usage:

getFirmwareVer()

This function returns the firmware version information of the host adapter.

Inputs:

This function takes no parameters.

Outputs:

The host adapter will respond with '-FWVER' followed by a space followed by the version.

Example Usage:

getHardwareVer()

This function returns the hardware version information of the host adapter.

Inputs:

This function takes no parameters.

Outputs:

The host adapter will respond with '-HWVER' followed by a space followed by the version.

Example Usage:

resetToBtldr()

This function performs a reset but will remain in the bootloader upon power-up. This will cause the USB connection to drop and re-enumerate. The host adapter will remain in the bootloader until a new firmware image is loaded, or until it is power cycled by unplugging it from USB and plugging it back in. Note that while the device is in the bootloader, it will act as a USB mass storage device, and will not respond to any of protocol commands.

Inputs:

This function takes no parameters.

Outputs:

The host adapter will respond with '-BTLDR OK' immediately before resetting.

Example Usage:

reset()

This function performs a reset. This will cause the USB connection to drop and re-enumerate. This also restores all device settings to their defaults.

Inputs:

This function takes no parameters.

Outputs:

The host adapter will respond with '-RESET OK' immediately before resetting.

Example Usage:

getDeviceID()

This function returns the globally-unique device identifier. This deviceID can be particularly useful to reference the device when using multiple host adapters on the same computer.

Inputs:

This function takes no parameters.

Outputs:

The host adapter will respond with '-ID 0x' followed by the 16-byte device ID. The ID will be displayed in hex regardless of the current Numerical Base setting.

Example Usage:

IO Functions

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

setIOpinMode(ioNumber, mode)

This function sets the operation mode of a specific pin.

Inputs:

This function takes two parameters:

ioNumber, which is the index of the pin to be configured, can be 0 - 4.
mode, which is the desired operation mode for the pin. Valid modes include DIN(Digital Input), DOUT (Digital Output), AIN (Analog Input), AOUT (Analog Output), and PWM.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

getIOpinMode(ioNumber)

This function gets the operation mode of a specific pin.

Inputs:

This function takes one parameter:

ioNumber, which is the index of the pin for which the mode is being queried.

Outputs:

The host adapter will respond with IO[n] followed by 'MODE' followed by the current mode of the specified IO pin. See the details for the command above for the possible values of MODE.

Example Usage:

setIOpinPWMFreq(ioNumber, freq)

This function sets the PWM frequency of the provided IO pin. This function is only available on IO pins which support PWM output. Please see the ASCII command for additional info.

Inputs:

This function takes two parameters:

ioNumber, which is the index of the pin for which the PWM frequency shall be applied.
freq, which is the frequency in Hz. Acceptable range is from 750Hz to 80000Hz.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

getIOpinPWMFreq(ioNumber)

This function gets the PWM frequency of the provided IO pin. This function is only available on IO pins which support PWM output. Please see the ASCII command for additional info.

Inputs:

This function takes one parameter:

ioNumber, which is the index of the pin for which the PWM frequency is being queried.

Outputs:

The host adapter will respond with 'IOn' followed by 'PWMFREQ' followed up the configured frequency in Hz upon successful execution of the command.

Example Usage:

setIOpinInterrupt(ioNumber, intMode)

This function configures the given IO pin to be used as an interrupt source. Interrupts can be on rising edge, falling edge, or any edge. Additional information on which pins can be used as interrupts can be found on the ASCII command documentation.

Inputs:

This function takes two parameters:

ioNumber, which is the index of the pin which will be configured as an interrupt source.
intMode, which can be either RISE, FALL, CHANGE, or NONE.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

getIOpinInterrupt(ioNumber)

This function returns the currently configured interrupt settings for the provided IO pin.

Inputs:

This function takes one parameter:

ioNumber, which is the index of the pin for which the interrupt configuration is being queried.

Outputs:

The host adapter will respond with 'IO[n]' followed by 'INT' followed by the current configured interrupt mode.

Example Usage:

setIOpinValue(ioNumber, value)

This function sets the current value of the provided IO pin. Note that the meaning of value and the acceptable range and units depends on the currently configured MODE of the given IO pin. Please see the documentation of the ASCII command for additional information.

Inputs:

This function takes two parameters:

ioNumber, which is the index of the pin which will be set to the given value.
value, which can be :
- 0 or 1 when operating as a digital output,

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

getIOpinValue(ioNumber)

This function returns the current value of the provided IO pin. Note that the meaning of value and the acceptable range and units depends on the currently configured MODE of the given IO pin. Please see the documentation of the ASCII command for additional information.

Inputs:

This function takes one parameter:

ioNumber, which is the index of the pin for which the value is being queried.

Outputs:

The host adapter will respond with 'IO[n]' followed by 'VALUE' followed by the current value.

Example Usage:

getIOpinInterruptFlag(ioNumber)

This function checks to see if an interrupt has been received from the host adapter. Note that this function does not involve any direct communication with the host adapter, rather it just checks to see if the python library has already received an interrupt from the device. More details about how interrupts are implemented can be found .

Inputs:

This function takes one parameter:

ioNumber, which is the index of the pin which is being checked for the interrupt flag.

Outputs:

This function returns either Trueor False . A value of True indicates that an interrupt event has occurred on the given IO pin.

Example Usage:

clearIOpinInterruptFlag(ioNumber)

This function clears the interrupt flag. Note that this function does not involve any direct communication with the host adapter, rather it just clears the interrupt flag in the python library. More details about how interrupts are implemented can be found .

Inputs:

This function takes one parameter:

ioNumber, which is the index of the pin which is being checked for the interrupt flag.

Outputs:

This function does not return any value.

Example Usage:

I2C Functions

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

setClockI2C(i2cIndex, frequency)

This function sets the clock frequency of the I2C bus. The Binho Nova Multi-Protocol USB Host Adapter supports I2C bus speeds from 100kHz to 4MHz. Per the I2C specification, the common clock frequencies are 100kHz, 400kHz, and 1MHz, although it's possible to run the bus at other frequencies.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
frequency, which is an integer value in Hertz in the range of 100000 to 4000000. Note that the frequency value is truncated to 1kHz resolution. For example, a frequency value of will 200800 will result in an I2C clock frequency of 200kHz.

Outputs:

Example Usage:

getClockI2C(i2cIndex)

This function gets the clock frequency of the I2C bus. The Binho Nova supports I2C bus speeds from 100kHz to 4MHz. Per the I2C specification, the common clock frequencies are 100kHz, 400kHz, and 1MHz, although it's possible to run the bus at other frequencies.

Inputs:

This function takes one parameter:

i2cIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with '-I2C0 CLK' followed by a space followed by the current I2C clock frequency in Hertz.

Example Usage:

setPullUpStateI2C(i2cIndex, state)

This function is used to engage / disengage the 2.2kOhm internal pull-up resistors on the SDA and SCL signals.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
state, which is the desired state of the pullup resistors, either 'EN' for enable or 'DIS' for disable. See the example below for additional acceptable values for convenience.

Outputs:

Example Usage:

getPullUpStateI2C(i2cIndex)

This function is used to get the status of the 2.2kOhm internal pull-up resistors on the SDA and SCL signals, as in whether they are currently engaged or disengaged.

Inputs:

This function takes one parameter:

i2cIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with '-I2C0 PULL' followed by a space followed by the current state of the pull-up resistors, either 'ENABLED' or 'DISABLED'.

Example Usage:

scanAddrI2C(i2cIndex, address)

This function is used to scan a single address to determine if a slave device is present and responding.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
address, which is the address of the target peripheral device on the I2C bus.

Outputs:

The host adapter will respond with '-I2C0 SCAN' followed by a space followed by the address scanned, followed by the scan result, which will be either 'OK' or 'NG'.

Example Usage:

writeByteI2C(i2cIndex, data)

This function is used to write a single byte to a peripheral device on the I2C bus.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
data, which is the value to write to the target slave device.

Outputs:

Example Usage:

readByteI2C(i2cIndex, address)

This function is used to request a single byte from a peripheral device on the I2C bus.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
address, which is the address of the target peripheral device on the I2C bus.

Outputs:

The host adapter will respond with '-I2C0 RXD' followed by a space followed by the received byte. If no data is received or an error occurs during the read, the response will be 'NG'.

Example Usage:

readBytesI2C(i2cIndex, address, numBytes)

This function is used to request data from a peripheral device on the I2C bus. The maximum number of bytes in a single request is 256.

Inputs:

This function takes three parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
address, which is the address of the target peripheral device on the I2C bus.
numBytes, which is the number of bytes to request from the peripheral device.

Outputs:

The host adapter will respond with '-I2C0 RXD' followed by a space followed by the received bytes. If no data is received or an error occurs during the read, the response will be 'NG'.

Example Usage:

writeFromBufferI2C(i2cIndex, numBytes)

This function is used to send data to a peripheral device on the I2C bus from the internal buffer.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
numBytes, which is the number of bytes to send from the internal buffer. The data from the buffer is sent beginning with index 0 in the buffer.

Outputs:

Example Usage:

readToBufferI2C(i2cIndex, address, numBytes)

This function is used to request data from a peripheral device on the I2C bus and receive it into BUF0. The maximum number of bytes in a single request is 256.

Inputs:

This function takes three parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
address, which is the address of the target peripheral device on the I2C bus.
numBytes, which is the number of bytes to request from the peripheral device.

Outputs:

Example Usage:

startI2C(i2cIndex, address)

This function is used to start an I2C transmission to a target peripheral device on the I2C bus.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
address, which is the address of the target slave device on the I2C bus.

Outputs:

Example Usage:

endI2C(i2cIndex, repeat)

This function ends an I2C transmission. It can be used to send a stop bit or a repeated start bit.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
repeat, which shall be set to True to send a repeated start bit, otherwise the transmission will be terminated with a stop bit.

Outputs:

Example Usage:

writeToReadFromI2C(i2cIndex, addr, stop, numRBytes, numWBytes, data)

This function performs a write of 0 to 1024 bytes followed by a read of 0 to 1024 bytes in a single transaction. This function minimizes the number of round-trips between the PC and Nova in order to maximize I2C throughput. This function is highly recommended for reading/writing I2C memory devices or in any other application where multibyte transactions are frequently used.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
addr, which is the address of the target I2C peripheral device on the bus. Note the address must be formatted as 7bit address in hex, without the leading "0x".
stop, which is used to indicate a stop bit should be sent at the end of the transaction. 0 = no stop bit sent, 1 = terminate transaction with stop bit.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command if numRBytes is 0. If numRBytes > 0, then the response will be 'I2C0 RXD' followed by the received data in Hex. In case of an invalid parameter, the host adapter will respond with '-NG' indicating the command did not execute successfully.

Example Usage:

setSlaveAddressI2C(i2cIndex, address)

This function configures Nova to behave as an I2C peripheral device assigned to the provided address.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
address, which can be any valid 8-bit I2C peripheral device address.

Outputs:

Example Usage:

getSlaveAddressI2C(i2cIndex)

This function returns the address assigned to Nova while operating in I2C peripheral mode.

Inputs:

This function takes one parameter:

i2cIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with 'I2C0 SLAVE' followed by the configured device address upon successful execution of the command. In case of an invalid parameter, the host adapter will respond with '-NG' indicating the command did not execute successfully.

Example Usage:

setSlaveModeI2C(i2cIndex, mode)

This function configures the behavior of the emulated I2C peripheral device. At this time, the Binho Nova I2C peripheral supports two modes of operation which allow it to behave like some of the most common I2C peripheral devices. Please see the description of the modes on the page.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
mode, which can be either USEPTR or STARTZERO.

Outputs:

Example Usage:

getSlaveModeI2C(i2cIndex)

This function returns the configured mode of the emulated I2C peripheral device. At this time, the Binho Nova I2C peripheral supports two modes of operation which allow it to behave like some of the most common I2C peripheral devices. Please see the description of the modes on the page.

Inputs:

This function takes one parameter:

i2cIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with 'I2C0 SLAVE MODE' followed by either USEPTR or STARTZERO upon successful execution of the command. In case of an invalid parameter, the host adapter will respond with '-NG' indicating the command did not execute successfully.

Example Usage:

setSlaveRegisterCount(i2cIndex, registerCount)

This function configures the number of registers to emulate in the I2C peripheral device memory bank while operating in I2C peripheral mode.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
registerCount, which can be any integer value from 1 to 256.

Outputs:

Example Usage:

getSlaveRegisterCount(i2cIndex)

This function returns the number of registers being emulated in the I2C peripheral device memory bank while operating in I2C peripheral mode.

Inputs:

This function takes one parameter:

i2cIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with 'I2C0 SLAVE REGCNT' followed by the number of registers upon successful execution of the command. In case of an invalid parameter, the host adapter will respond with '-NG' indicating the command did not execute successfully.

Example Usage:

setSlaveRegister(i2cIndex, register, value)

This function sets the value stored in a given register in the emulated I2C peripheral device to the provided value while operating in I2C peripheral mode.

Inputs:

This function takes three parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
register, which can be any integer value from 0 to the number of registers configured in the device.
value, which can be any integer value from 0 to 255

Outputs:

Example Usage:

getSlaveRegisterI2C(i2cIndex, register)

This function returns the value stored in a given register in the emulated I2C peripheral device while operating in I2C peripheral mode.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
register, which can be any integer value from 0 to the number of registers configured in the device.

Outputs:

The host adapter will respond with 'I2C0 SLAVE REG' followed by the register number and the value stored in that register. In case of an invalid parameter, the host adapter will respond with '-NG' indicating the command did not execute successfully.

Example Usage:

setSlaveWriteMaskI2C(i2cIndex, register, mask)

This function sets the value of any register's writemask which is used to determine which bits in a register can be written to by an I2C controller on the bus.

Inputs:

This function takes three parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
register, which can be any integer value from 0 to the number of registers configured in the device.
mask, which can be any integer value from 0 to 255, where a 1 corresponds to granting write access to the corresponding bit in the register.

Outputs:

Example Usage:

getSlaveWriteMaskI2C(i2cIndex, register)

This function returns the value of any register's writemask which is used to determine which bits in a register can be written to by an I2C controller on the bus.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
register, which can be any integer value from 0 to the number of registers configured in the device.

Outputs:

The host adapter will respond with '-I2C0 SLAVE WRITEMASK' followed by the mask value upon successful execution of the command. In case of an invalid parameter, the host adapter will respond with '-NG' indicating the command did not execute successfully.

Example Usage:

setSlaveReadMaskI2C(i2cIndex, register, mask)

This function sets the value of any register's readmask which is used to determine which bits in a register can be read from by an I2C controller on the bus. This can be used to emulate strobe bits in a register.

Inputs:

This function takes three parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
register, which can be any integer value from 0 to the number of registers configured in the device.
mask, which can be any integer value from 0 to 255, where a 1 corresponds to granting read access to the corresponding bit in the register.

Outputs:

Example Usage:

getSlaveReadMaskI2C(i2cIndex, register)

This function returns the value of any register's readmask which is used to determine which bits in a register can be read from by an I2C controller on the bus.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
register, which can be any integer value from 0 to the number of registers configured in the device.

Outputs:

The host adapter will respond with '-I2C0 SLAVE READMASK' followed by the mask value upon successful execution of the command. In case of an invalid parameter, the host adapter will respond with '-NG' indicating the command did not execute successfully.

Example Usage:

1-WIRE Functions

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

begin1WIRE(oneWireIndex, pin, pullup)

This function starts the 1-WIRE host on the given IO pin. The 1-Wire protocol can be used on any of the IO pins, however it is especially convenient to use it on IO0 and IO2 as the internal pull-up resistor can be used thus eliminating the need for an external pull-up resistor.

Inputs:

This function takes three parameters:

oneWireIndex, which is always 0 on the Binho Nova host adapter.
pin, which can be any of the IO pins 0 through 4.
pullup, which can be either True or

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

reset1WIRE(oneWireIndex)

This function instructions the 1-Wire host to send the reset command. Sending the reset command is the first step of selecting a target device to communicate with.

Inputs:

This function takes one parameter:

oneWireIndexIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with '-OK' if the device on the 1-Wire bus asserted a presence pulse as a result of the result on the 1-WIRE bus. If the command fails or no device asserts a pulse after the reset, the function will return '-NG'.

Example Usage:

writeByte1WIRE(oneWireIndex, data, powered = False)

This function sends one byte of data on the 1-WIRE bus.

Inputs:

This function takes two parameters:

oneWireIndexIndex, which is always 0 on Binho Nova host adapter.
powered, [optional], which will continue to leave the bus powered upon completion of the write if set to True.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

readByte1WIRE(oneWireIndex)

This function reads one byte of data from the 1-WIRE bus.

Inputs:

This function takes one parameter:

oneWireIndexIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with '1WIRE0' followed by 'READ' followed by one byte of data read from the bus.

Example Usage:

select1WIRE(oneWireIndex)

This function selects the device whose address is currently in the internal address buffer to be the target for communication. The address in the internal address buffer is set by discovering the device via the search process.

Inputs:

This function takes one parameter:

oneWireIndexIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

skip1WIRE(oneWireIndex)

This function allows one to skip the search process and enables communication with the device right away. This can only be used when there is only one 1-Wire device on the bus.

Inputs:

This function takes one parameter:

oneWireIndexIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

depower1WIRE(oneWireIndex)

This function is used to power down the 1-WIRE bus.

Inputs:

This function takes one parameter:

oneWireIndexIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

getAddress1WIRE(oneWireIndex)

This function returns the address that was found by performing a search.

Inputs:

This function takes one parameter:

oneWireIndexIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with '1WIRE0' followed by 'ADDR' followed by the 8-byte long address of the device discovered by the search.

Example Usage:

search1WIRE(oneWireIndex, normalSearch = True)

This function begins the process of searching for devices on the 1-WIRE bus. The address of the found device will be stored in internal address buffer.

Inputs:

This function takes up to two parameters:

oneWireIndexIndex, which is always 0 on Binho Nova host adapter.
normalSearch, [optional], which can be True or False. In the case of False, an Alarm / Conditional search will be performed, which only returns devices in some sort of alarm state. See this for additional information on this topic.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

resetSearch1WIRE(oneWireIndex)

This function resets the search so that a new search can be started from the beginning.

Inputs:

This function takes one parameter:

oneWireIndexIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

targetSearch1WIRE(oneWireIndex, target)

This function searches the 1-WIRE bus for devices belonging to the same family code as the target.

Inputs:

This function takes two parameters:

oneWireIndexIndex, which is always 0 on Binho Nova host adapter.
target, which is a 1-byte long device family code for which to search.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

UART Functions

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

The UART functionality is different than the other supported protocols, as it operates as a bridge, rather than transmitting commands only when functions are called. More information about this can be found in the User Guide.

setBaudRateUART(uartIndex, baud)

This function sets the baudrate of the UART bridge. The default baudrate is 9600bps.

Inputs:

This function takes two parameters:

uartIndex, which is always 0 on Binho Nova host adapter.
baud, which can be set from 300 to 1000000bps.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

getBaudRateUART(uartIndex)

This function gets the baudrate of the UART bridge.

Inputs:

This function takes one parameter:

uartIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with 'UART0' followed by 'BAUD' followed by the configured baudrate in bps.

Example Usage:

setDataBitsUART(uartIndex, databits)

This function sets the number of databits for the UART connection. The default databits setting is 8 bits.

Inputs:

This function takes two parameters:

uartIndex, which is always 0 on Binho Nova host adapter.
databits, which can be set from 5 to 8 bits.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

getDataBitsUART(uartIndex)

This function gets the number of databits for the UART connection.

Inputs:

This function takes one parameter:

uartIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with 'UART0' followed by 'DATABITS' followed by the configured number of bits.

Example Usage:

setParityUART(uartIndex, parity)

This function sets the Parity bit configuration for the UART connection. The default setting is None.

Inputs:

This function takes two parameters:

uartIndex, which is always 0 on Binho Nova host adapter.
parity, which can be set to NONE, ODD, or EVEN.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

getParityUART(uartIndex)

This function gets the Parity bit configuration for the UART connection.

Inputs:

This function takes one parameter:

uartIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with 'UART0' followed by 'PARITY' followed by the currently configured parity setting.

Example Usage:

setStopBitsUART(uartIndex, stopbits)

This function sets the Stop bit configuration for the UART connection. The default number of stop bits is 1.

Inputs:

This function takes two parameters:

uartIndex, which is always 0 on Binho Nova host adapter.
stopbits, which can be set to either 1 or 2.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

getStopBitsUART(uartIndex)

This function sets the Stop bit configuration for the UART connection.

Inputs:

This function takes one parameter:

uartIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with 'UART0' followed by 'STOPBITS' followed by the current number of stop bits.

Example Usage:

setEscapeSequenceUART(uartIndex, escape)

This function sets the escape sequence that can be used to break out of the UART bridge mode. The default escape sequence is +++UART0.

Inputs:

This function takes two parameters:

uartIndex, which is always 0 on Binho Nova host adapter.
escape, which must be a string of 6 to 16 characters.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

getEscapeSequenceUART(uartIndex)

This function gets the currently configured escape sequence which can be used to close the UART bridge once it's been opened.

Inputs:

This function takes one parameter:

uartIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with 'UART0' followed by 'ESC' followed by the currently configured escape sequence.

Example Usage:

beginBridgeUART(uartIndex)

This function opens up the UART bridge. Note that once the bridge is open, only reading and writing UART commands can be used until the UART bridge is closed.

Inputs:

This function takes one parameter:

uartIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

stopBridgeUART(sequence)

This function closes an opened UART bridge.

Inputs:

This function takes one parameter:

sequence, which is the 6 to 16 character long escape sequence.

Outputs:

The host adapter will respond with '-OK' upon successful execution of the command.

Example Usage:

writeBridgeUART(data)

This function is used to transmit data over an open UART bridge. Note that this command does not directly communicate with the Binho Nova host adapter. Instead, it's writing the data to a transmit buffer within the python library. The python library will then transmit the data placed in the buffer.

Inputs:

This function takes one parameter:

data, which is the data to be written to the UART bus.

Outputs:

This function does not return any data.

Example Usage:

readBridgeUART()

This function is used to read data over an open UART bridge. Note that this command does not directly communicate with the Binho Nova host adapter. Instead, it's reading from the received data buffer within the python library.

Inputs:

This function takes no parameters.

Outputs:

This function returns any data that has been received over the UART bridge.

Example Usage:

binhoUtilities

We highly encourage everyone to use our which is packed with features. This library is still supported, but is not recommended for new design.

The binhoUtilities class contains several functions which help with managing serial ports, discovering devices, and connecting to specific devices. This class can be included in your code as show below.

One of the key benefits of using these helper functions is that care has been taken to ensure they work well across the various operating systems, particularly in regards to how serial ports are named and accessed.

Examples

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

This section shows the Binho Multi-Protocol USB Host Adapter in use in a number of typical applications:

I2C EEPROM Reading And Writing I2C Peripheral Mode SPI FRAM Reading And Writing I2C FRAM Reading And Writing 1-Wire Communication SWI with Atmel Crypto ICs UART Bridge with I2C Using Binho with Pytest

Looking for an example in a particular use case or test environment? Reach out to us at [email protected] and we'll do our best to create and publish a relevant example.

User-Contributed Examples

Have you done something new, interesting, and/or clever with your Binho Multi-Protocol USB Host Adapter and want to gain some street cred by sharing it with others? Send a link to your example to us at [email protected] and we'll include it here!

I2C EEPROM Reading And Writing

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

The example below demonstrates how to read from and write to an I2C EEPROM. This particular demo uses the SparkX Qwiic 512Kbit EEPROM from Sparkfun.

I2C Peripheral Mode

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

This example demonstrates how to use Binho Nova as an I2C Peripheral device, with a device address of 0xA0 and operating in USEPTR mode of emulation.

SPI FRAM Reading And Writing

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

This example is a very brief demonstration of using SPI to read from and write to a SPI FRAM device. This particular examples uses the 64Kbit FRAM Breakout Board from Adafruit.

from binhoHostAdapter import binhoHostAdapter
from binhoHostAdapter import binhoUtilities

# Change this to match your COMPort
default_commport = "COM11"

print("SPI FRAM Example using Binho Host Adapter")
print("v1.0 -- Jonathan Georgino <[email protected]>")
print

utilities = binhoUtilities.binhoUtilities()
devices = utilities.listAvailableDevices()

if len(devices) == 1:
	COMPORT = devices[0]
	print("Found 1 attached adapter @ " + devices[0])
	print
else:
	COMPORT = default_commport
	print("Found more than 1 attached adapter, using default port " + COMPORT)
	print

print("Opening " + COMPORT + "...")
print

# create the binhoHostAdapter object
hostAdapter = binhoHostAdapter.binhoHostAdapter(COMPORT)

print(hostAdapter.setOperationMode(0, 'SPI'))
print(hostAdapter.setClockSPI(0, 1000000))
print(hostAdapter.setModeSPI(0, 0))
print(hostAdapter.setIOpinMode(0, 'DOUT'))
print(hostAdapter.setIOpinValue(0, 'HIGH'))

print(hostAdapter.beginSPI(0))
print(hostAdapter.setIOpinValue(0, 'LOW'))

print(hostAdapter.transferSPI(0, 0x9f))
print(hostAdapter.transferSPI(0, 0))
print(hostAdapter.transferSPI(0, 0))
print(hostAdapter.transferSPI(0, 0))
print(hostAdapter.transferSPI(0, 0))

print(hostAdapter.setIOpinValue(0, 'HIGH'))
print(hostAdapter.endSPI(0))


print(hostAdapter.clearBuffer(0))
print(hostAdapter.addByteToBuffer(0, 0x9f))

print(hostAdapter.beginSPI(0))
print(hostAdapter.setIOpinValue(0, 'LOW'))

print(hostAdapter.transferBufferSPI(0, 5))

print(hostAdapter.setIOpinValue(0, 'HIGH'))
print(hostAdapter.endSPI(0))

print(hostAdapter.readBuffer(0, 5))

I2C FRAM Reading And Writing

We highly encourage everyone to use our which is packed with features. This library is still supported, but is not recommended for new design.

The example below demonstrates how to read from and write to an I2C FRAM. Beyond that, it's also an excellent example of how to port an open-source Arduino library into a python script that can utilize the Binho Multi-Protocol USB Host Adapter.

This example is uses a 256Kbit I2C FRAM (MB85RC256V / Fujitsu) breakout board from our friends over at Adafruit. You can purchase it .

For comparison's sake, you can see the Adafruit Arduino library that this example was ported from

1-Wire Communication

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

The python script below demonstrates how to communicate with a DS2413, a dual-channel addressable switch IC. You can get one on an easy-to-use breakout board from our friends at Adafruit.

SWI with Atmel Crypto ICs

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

The following python script demonstrates how to use the SWI host Nova functionality of the Binho Multi-Protocol USB Host Adapter with the Atmel (now Microchip) ATSHA204A CryptoAuthentication IC. Communication with other devices from this family will be strikingly similar.

A special shout out to our friends at Sparkfun who produced a similar example above for their ATSHA204 Arduino Library many, many moons ago. This demo is built to match their example.

UART Bridge with I2C

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

The example below provides a basic demonstration of how to use the Binho Nova Multi-Protocol USB Host Adapter as both a UART bridge and an I2C controller to interact with the same DUT with both protocols.

from binhoHostAdapter import binhoHostAdapter
from binhoHostAdapter import binhoUtilities

binhoTesterCommPort = 'COM22'

# create the binhoHostAdapter object
binhoTester = binhoHostAdapter.binhoHostAdapter(binhoTesterCommPort)

print("Connecting to binho host adapter tester...")
print

print(binhoTester.setLEDColor('YELLOW'))

print(binhoTester.setOperationMode(0, 'UART'))

print(binhoTester.setBaudRateUART(0, 115200))
print(binhoTester.setDataBitsUART(0, 8))
print(binhoTester.setParityUART(0, 'NONE'))
print(binhoTester.setStopBitsUART(0, 1))

print(binhoTester.beginBridgeUART(0))

binhoTester.writeBridgeUART("Testing...")
binhoTester.writeBridgeUART("more more")

print(binhoTester.stopBridgeUART("+++UART0"))
print(binhoTester.ping())

binhoTester.setOperationMode(0, 'I2C')
binhoTester.setPullUpStateI2C(0, "EN")
binhoTester.setClockI2C(0, 400000)

print(binhoTester.startI2C(0, 100))
print(binhoTester.writeByteI2C(0, 15))
print(binhoTester.writeByteI2C(0, 25))
print(binhoTester.endI2C(0))

binhoTester.setOperationMode(0, 'UART')
print(binhoTester.beginBridgeUART(0))

binhoTester.writeBridgeUART("Second Burst")
binhoTester.writeBridgeUART("Same as the first")
binhoTester.writeBridgeUART("A whole lot louder")
binhoTester.writeBridgeUART("And a whole lot wurst")

print(binhoTester.stopBridgeUART("+++UART0"))
print(binhoTester.ping())

Using Binho with Pytest

We highly encourage everyone to use our which is packed with features. This library is still supported, but is not recommended for new design.

The Binho Nova Multi-Protocol USB Host Adapter pairs elegantly with to implement an incredibly robust and efficient hardware and firmware testing platform.

We'll leave discussion of the features of pytest for their own very-thorough documentation, and just hit on a few tips to make it fast and easy to get started using it with your host adatper.

In order for the serial connection with your Binho Nova to persist through the entire test plan, you'll want to use a fixture. This is as easy as creating a conftest.py file in the test directory. Additionally, allow it accept command line parameters for device IDs, as this makes it easy to use multiple adapters on the same host computer.

Replaying Logic Captures

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

The Binho Multi-Protocol USB Host Adapter paired with a Saleae Logic is the perfect combination for making hardware testing as simple as possible. Furthermore, Logic captures of UART, SPI, and I2C transactions can be exported and then replayed by Binho. This makes it very easy to recreate a test case or repeat a given stimuli that you've captured with Logic. Please see the samples below for each of the protocols.

Replay SPI Replay I2C Replay UART

Replay SPI

We highly encourage everyone to use our which is packed with features. This library is still supported, but is not recommended for new design.

The following script can be used to repeat SPI transactions captured and exported from Saleae Logic. After the capture is completed, export the SPI analyzer results as a csv file. You can follow to export the file. The exported data should be in HEX-- Note that the base/radix of the exported data will match the current setting for display in the software.

Simply modify the parameters in lines 9-17 in the script below and then everything is ready to play back the file from the Binho Multi-Protocol USB Host Adapter.

For easy testing, here's an example export file from Saleae Logic that works with this script:

Replay I2C

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

The following script can be used to repeat I2C transactions captured and exported from Saleae Logic. After the capture is completed, export the I2C analyzer results as a csv file. You can follow this guide to export the file. The exported data should be in HEX-- Note that the base/radix of the exported data will match the current setting for display in the software.

Simply modify the parameters in lines 9-15 in the script below and then everything is ready to play back the file from the Binho Nova Multi-Protocol USB Host Adapter.

For easy testing, here's an example export file from Saleae Logic that works with this script:

Replay UART

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

The following script can be used to repeat UART streams captured and exported from Saleae Logic. After the capture is completed, export the Async Serial analyzer results as a csv file. You can follow this guide to export the file. The exported data should be in HEX-- Note that the base/radix of the exported data will match the current setting for display in the software.

Simply modify the parameters in lines 9-18 in the script below and then everything is ready to play back the file from the Binho Multi-Protocol USB Host Adapter.

For easy testing, here's an example export file from Saleae Logic that works with this script:

I2C Functions

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

setClockI2C(i2cIndex, frequency)

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
frequency, which is an integer value in Hertz in the range of 100000 to 4000000. Note that the frequency value is truncated to 1kHz resolution. For example, a frequency value of will 200800 will result in an I2C clock frequency of 200kHz.

Outputs:

Example Usage:

getClockI2C(i2cIndex)

Inputs:

This function takes one parameter:

i2cIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with '-I2C0 CLK' followed by a space followed by the current I2C clock frequency in Hertz.

Example Usage:

setPullUpStateI2C(i2cIndex, state)

This function is used to engage / disengage the 2.2kOhm internal pull-up resistors on the SDA and SCL signals.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
state, which is the desired state of the pullup resistors, either 'EN' for enable or 'DIS' for disable. See the example below for additional acceptable values for convenience.

Outputs:

Example Usage:

getPullUpStateI2C(i2cIndex)

This function is used to get the status of the 2.2kOhm internal pull-up resistors on the SDA and SCL signals, as in whether they are currently engaged or disengaged.

Inputs:

This function takes one parameter:

i2cIndex, which is always 0 on Binho Nova host adapter.

Outputs:

The host adapter will respond with '-I2C0 PULL' followed by a space followed by the current state of the pull-up resistors, either 'ENABLED' or 'DISABLED'.

Example Usage:

scanAddrI2C(i2cIndex, address)

This function is used to scan a single address to determine if a slave device is present and responding.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
address, which is the address of the target peripheral device on the I2C bus.

Outputs:

The host adapter will respond with '-I2C0 SCAN' followed by a space followed by the address scanned, followed by the scan result, which will be either 'OK' or 'NG'.

Example Usage:

writeByteI2C(i2cIndex, data)

This function is used to write a single byte to a peripheral device on the I2C bus.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
data, which is the value to write to the target slave device.

Outputs:

Example Usage:

readByteI2C(i2cIndex, address)

This function is used to request a single byte from a peripheral device on the I2C bus.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
address, which is the address of the target peripheral device on the I2C bus.

Outputs:

The host adapter will respond with '-I2C0 RXD' followed by a space followed by the received byte. If no data is received or an error occurs during the read, the response will be 'NG'.

Example Usage:

readBytesI2C(i2cIndex, address, numBytes)

This function is used to request data from a peripheral device on the I2C bus. The maximum number of bytes in a single request is 256.

Inputs:

This function takes three parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
address, which is the address of the target peripheral device on the I2C bus.
numBytes, which is the number of bytes to request from the peripheral device.

Outputs:

The host adapter will respond with '-I2C0 RXD' followed by a space followed by the received bytes. If no data is received or an error occurs during the read, the response will be 'NG'.

Example Usage:

writeFromBufferI2C(i2cIndex, numBytes)

This function is used to send data to a peripheral device on the I2C bus from the internal buffer.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
numBytes, which is the number of bytes to send from the internal buffer. The data from the buffer is sent beginning with index 0 in the buffer.

Outputs:

Example Usage:

readToBufferI2C(i2cIndex, address, numBytes)

This function is used to request data from a peripheral device on the I2C bus and receive it into BUF0. The maximum number of bytes in a single request is 256.

Inputs:

This function takes three parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
address, which is the address of the target peripheral device on the I2C bus.
numBytes, which is the number of bytes to request from the peripheral device.

Outputs:

Example Usage:

startI2C(i2cIndex, address)

This function is used to start an I2C transmission to a target peripheral device on the I2C bus.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
address, which is the address of the target slave device on the I2C bus.

Outputs:

Example Usage:

endI2C(i2cIndex, repeat)

This function ends an I2C transmission. It can be used to send a stop bit or a repeated start bit.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
repeat, which shall be set to True to send a repeated start bit, otherwise the transmission will be terminated with a stop bit.

Outputs:

Example Usage:

writeToReadFromI2C(i2cIndex, addr, stop, numRBytes, numWBytes, data)

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
addr, which is the address of the target I2C peripheral device on the bus. Note the address must be formatted as 7bit address in hex, without the leading "0x".
stop, which is used to indicate a stop bit should be sent at the end of the transaction. 0 = no stop bit sent, 1 = terminate transaction with stop bit.

Outputs:

Example Usage:

setSlaveAddressI2C(i2cIndex, address)

This function configures Nova to behave as an I2C peripheral device assigned to the provided address.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
address, which can be any valid 8-bit I2C peripheral device address.

Outputs:

Example Usage:

getSlaveAddressI2C(i2cIndex)

This function returns the address assigned to Nova while operating in I2C peripheral mode.

Inputs:

This function takes one parameter:

i2cIndex, which is always 0 on Binho Nova host adapter.

Outputs:

Example Usage:

setSlaveModeI2C(i2cIndex, mode)

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
mode, which can be either USEPTR or STARTZERO.

Outputs:

Example Usage:

getSlaveModeI2C(i2cIndex)

Inputs:

This function takes one parameter:

i2cIndex, which is always 0 on Binho Nova host adapter.

Outputs:

Example Usage:

setSlaveRegisterCount(i2cIndex, registerCount)

This function configures the number of registers to emulate in the I2C peripheral device memory bank while operating in I2C peripheral mode.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
registerCount, which can be any integer value from 1 to 256.

Outputs:

Example Usage:

getSlaveRegisterCount(i2cIndex)

This function returns the number of registers being emulated in the I2C peripheral device memory bank while operating in I2C peripheral mode.

Inputs:

This function takes one parameter:

i2cIndex, which is always 0 on Binho Nova host adapter.

Outputs:

Example Usage:

setSlaveRegister(i2cIndex, register, value)

This function sets the value stored in a given register in the emulated I2C peripheral device to the provided value while operating in I2C peripheral mode.

Inputs:

This function takes three parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
register, which can be any integer value from 0 to the number of registers configured in the device.
value, which can be any integer value from 0 to 255

Outputs:

Example Usage:

getSlaveRegisterI2C(i2cIndex, register)

This function returns the value stored in a given register in the emulated I2C peripheral device while operating in I2C peripheral mode.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
register, which can be any integer value from 0 to the number of registers configured in the device.

Outputs:

Example Usage:

setSlaveWriteMaskI2C(i2cIndex, register, mask)

This function sets the value of any register's writemask which is used to determine which bits in a register can be written to by an I2C controller on the bus.

Inputs:

This function takes three parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
register, which can be any integer value from 0 to the number of registers configured in the device.
mask, which can be any integer value from 0 to 255, where a 1 corresponds to granting write access to the corresponding bit in the register.

Outputs:

Example Usage:

getSlaveWriteMaskI2C(i2cIndex, register)

This function returns the value of any register's writemask which is used to determine which bits in a register can be written to by an I2C controller on the bus.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
register, which can be any integer value from 0 to the number of registers configured in the device.

Outputs:

Example Usage:

setSlaveReadMaskI2C(i2cIndex, register, mask)

Inputs:

This function takes three parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
register, which can be any integer value from 0 to the number of registers configured in the device.
mask, which can be any integer value from 0 to 255, where a 1 corresponds to granting read access to the corresponding bit in the register.

Outputs:

Example Usage:

getSlaveReadMaskI2C(i2cIndex, register)

This function returns the value of any register's readmask which is used to determine which bits in a register can be read from by an I2C controller on the bus.

Inputs:

This function takes two parameters:

i2cIndex, which is always 0 on Binho Nova host adapter.
register, which can be any integer value from 0 to the number of registers configured in the device.

Outputs:

Example Usage:

SWI Functions

We highly encourage everyone to use our new Python package which is packed with features. This library is still supported, but is not recommended for new design.

beginSWI(swiIndex, pin, pullup)

The function starts the Atmel SWI host on the given IO pin. The SWI protocol can be used on any of the IO pins, however it is especially convenient to use it on IO0 and IO2 as the internal pull-up resistor can be used thus eliminating the need for an external pull-up resistor.

Inputs:

This function takes three parameters:

swiIndex, which is always 0 on the Binho Nova host adapter.
pin, which can be any of the IO pins 0 through 4.
pullup, which can be either True or

Outputs:

Example Usage:

sendTokenSWI(swiIndex, token)

This function is used to send either a WAKE, ONE, or ZERO token, as defined by the Atmel SWI protocol specification. Note that due to the timing constraints of the protocol, the delay between communication with the host adapter and the PC may prohibit the construction of full data packets by stringing together a series of ZERO and ONE tokens with this command. For actual data packet transmission, use the PACKET command.

Inputs:

This function takes two parameters:

swiIndex, which is always 0 on the Binho Nova host adapter.
token, which can be WAKE, ZERO, or ONE.

Outputs:

Example Usage:

sendFlagSWI(swiIndex, flag)

This function transmits a flag as defined by the Atmel SWI protocol. Note that this command is simply using the TX command below to send the predefined byte value of each of the four flags.

Inputs:

This function takes two parameters:

swiIndex, which is always 0 on the Binho Nova host adapter.
flag, which can be COMMAND, TRANSMIT, IDLE, or SLEEP.

Outputs:

Example Usage:

sendCommandFlagSWI(swiIndex)

This function transmits a COMMAND flag.

Inputs:

This function takes one parameter:

swiIndex, which is always 0 on the Binho Nova host adapter.

Outputs:

Example Usage:

sendTransmitFlagSWI(swiIndex)

This function transmits a TRANSMIT flag.

Inputs:

This function takes one parameter:

swiIndex, which is always 0 on the Binho Nova host adapter.

Outputs:

Example Usage:

sendIdleFlagSWI(swiIndex)

This function transmits an IDLE flag.

Inputs:

This function takes one parameter:

swiIndex, which is always 0 on the Binho Nova host adapter.

Outputs:

Example Usage:

sendSleepFlagSWI(swiIndex)

This function transmits a SLEEP flag.

Inputs:

This function takes one parameter:

swiIndex, which is always 0 on the Binho Nova host adapter.

Outputs:

Example Usage:

transmitByteSWI(swiIndex, data)

This function transmits a byte of data as defined by the Atmel SWI protocol.

Inputs:

This function takes two parameters:

swiIndex, which is always 0 on the Binho Nova host adapter.
data, which is the byte of data to be transmitted.

Outputs:

Example Usage:

receiveBytesSWI(swiIndex, count)

This function receives n bytes of data as defined by the Atmel SWI protocol.

Inputs:

This function takes two parameters:

swiIndex, which is always 0 on the Binho Nova host adapter.
data, which is the byte of data to be transmitted.

Outputs:

The host adapter will respond with 'SWI0' followed by 'RXD' followed by n bytes of received data.

Example Usage:

setPacketOpCodeSWI(swiIndex, opCode)

This function is used to set the opcode of an SWI packet.

Inputs:

This function takes two parameters:

swiIndex, which is always 0 on the Binho Nova host adapter.
opCode, which is the byte of data to be transmitted.

Outputs:

Example Usage:

setPacketParam1SWI(swiIndex, value)

This function is used to set the value of the Param1 byte of the SWI Packet.

Inputs:

This function takes two parameters:

swiIndex, which is always 0 on the Binho Nova host adapter.
value, which is the byte of data to be transmitted in the Param1 field of the packet.

Outputs:

Example Usage:

setPacketParam2SWI(swiIndex, value)

This function is used to set the 16bit value of the Param2 field of the SWI Packet.

Inputs:

This function takes two parameters:

swiIndex, which is always 0 on the Binho Nova host adapter.
data, which is the 16bit value to be transmitted in the Param2 field of the packet.

Outputs:

Example Usage:

setPacketDataSWI(swiIndex, index, value)

This function is used to set the bytes of the Data field one by one.

Inputs:

This function takes three parameters:

swiIndex, which is always 0 on the Binho Nova host adapter.
index, which is the byte index to load the value into the Data field.
value, which is the byte of data loaded into the given index of the Data field.

Outputs:

Example Usage:

setPacketDataFromBufferSWI(swiIndex, byteCount, bufferName)

This function is used to set the Data field of the SWI packet to the contents from a buffer.

Inputs:

This function takes three parameters:

swiIndex, which is always 0 on the Binho Nova host adapter.
byteCount, which is the number of bytes to load from the buffer.
bufferName, which is the name of the buffer to use, typically BUF0.

Outputs:

Example Usage:

sendPacketSWI(swiIndex)

This function sends the the constructed SWI packet.

Inputs:

This function takes one parameter:

swiIndex, which is always 0 on the Binho Nova host adapter.

Outputs:

Example Usage:

clearPacketSWI(swiIndex)

This function clears the OpCode, Param1, Param2, and Data fields of the SWI Packet.