Welcome to our Getting Started Guide. The Binho Nova was designed for ultimate flexibility, as such, there are multiple ways to control and interact with it. First, follow the Hardware Setup Guide to quickly get your device connected to the host computer and your electronics:

Once everything is connected, follow the guides below to learn how to interact with the Binho Nova using our GUI Software, Python Libraries and a Serial Console.

Level #1 - GUI Guide

The easiest way to get familiar with your Binho Nova is by taking it for a test drive with our cross-platform desktop GUI software. Even if you intend to use it in automated environments and applications, the GUI is a great starting point before diving in to writing scripts.

Level #2 - Python Guide

When you're ready to start writing your own automated scripts, take a look at our guide for using our open-source python libraries.

Level #3 - ASCII Guide

And when you're ready to go to the deepest level of device interaction to learn how to control it from any language/platform capable of opening a serial port and sending ASCII text, have a look at the guide below. This guide is presented using CoolTerm due to it's elegant GUI and relatively identical performance across all the platforms supported by the Binho Nova.

If you're looking for the full in-depth explanation of all the features of the Binho Nova, then skip right ahead to the .

Welcome to our customer support site! You can browse the articles from the content links on the left, or locate specific information using the search bar in the upper-right corner of the page.

The best way to get familiar with the Binho Nova Multi-Protocol USB Host Adapter, whether you own one or not, is to have a read through our Getting Started guide:

There's also the complete product User Guide here which provides in-dept explanations on all of the devices functionality:

You may have noticed that our documentation is using some unfamiliar terms when discussing the roles and signals for a given protocol. We've dropped the use of legacy terms which may initially cause confusion, so we've put together a helpful resource here:

Finally, this portal contains a full set of documentation for the ASCII command set as well as the documentation of the Python library. This section includes a number of examples that demonstrate how to use the Binho Nova Multi-Protocol USB Host Adapter in many common use-cases such as reading/writing EEPROM, FLASH, and FRAM devices, interfacing I2C/SPI/1-WIRE sensors directly to your computer, and communicating with common CryptoAuth chips from Microchip (formerly Atmel).

If you're ready to purchase your own device and/or have some questions regarding doing business with Binho LLC, please check out the following pages:

Thanks again for visiting our support portal! If you have any unanswered questions, please reach out to [email protected] and we'll get right back to you as soon as possible.

The diagram below shows the pin assignments (in yellow) for the SCK, SDI, and SDO pins on the Binho Nova Multi-Protocol USB Host Adapter when it is in SPI mode.

Configuring the SPI Bus Settings

Once the SPI mode of operation has been activated by clicking the "Activate SPI Mode" button on the SPI tab, the SPI settings will be unlocked and ready for configuration.

The Binho Nova supports SPI bus clock frequencies from 500kHz to 12MHz, and all four SPI modes are supported. Data can be configured for MSB or LSB first bit orders and for 8 or 16 bits per transfer.

The diagram below shows the pin assignments (in green) for the TX and RX pins on the Binho Nova Multi-Protocol USB Host Adapter when it is in UART mode.

Configuring the UART Settings

Once the UART mode of operation has been activated by clicking the "Activate UART Mode" button on the UART tab, the UART settings will be unlocked and ready for configuration.

The Binho Nova supports UART baud rates from 300bps up to 1000000bps. The UART bus can be configured for 5, 6, 7, or 8 bit data packets; Even, Odd, or no Parity bit; and to use 1 or 2 stopbits.

Driver Installation

Great News! Most modern operating systems already have the device drivers needed for your Binho Nova Multi-Protocol USB Host Adapter to work properly installed. The Binho Nova utilizes the standardized USB Communications Device Class driver in order to achieve maximum compatibility with as many systems as possible. As such, there's no driver to download and install.

Windows 7 does not have the standard USB CDC driver mentioned above. Please see the troubleshooting article below.

If this is the first time connecting to a hardware device from your account on your Mac, you'll need to grant permission to your user account. Please see the following support article for instructions to perform this task:

If you're on Ubuntu or another Linux distribution and running into issues with your device, please perform the procedure in the following troubleshooting article:

Connection to the Computer

Use the provided USB Type-C (male) to USB Type-A (male) cable to connect the Binho Nova Multi-Protocol USB Host Adapter to your host PC. The device can be plugged into any available USB port - there is no requirement to plug it into a USB 3.0 port.

Upon power up, the Status LED on the Binho Nova will shine yellow while it is waiting for the COM port to be opened. When connected properly, the device should immediately enumerate and become available for use as a new COM port. Once a serial connection has been established between the device and the host computer, the Status LED will shine blue.

Connection to the Test Circuit

The Binho Nova Multi-Protocol USB Host Adapter features an integrated wire harness terminated with a 1.27mm pitch 2x5 IDC Connector. This harness contains the 5 signal pins, 1 x 3V3 power signal, 1 x VBUS power signal, and 3 x GND signals.

The figure below shows the connector pinout and channel functions:

Clear for Takeoff!

Now you're ready to begin interacting with the device. See the QuickStart Guides in this section to learn how to interact with the device via your preferred interface:

The diagram below shows the pin assignments (in purple) for the SCL and SDA pins on the Binho Nova Multi-Protocol USB Host Adapter when it is in I2C mode.

Configuring the I2C Bus Settings

Once the I2C mode of operation has been activated by clicking the "Activate I2C Mode" button on the I2C tab, the I2C settings will be unlocked and ready for configuration.

The Binho Nova supports I2C bus clock frequencies from 100kHz up to 3.4MHz, which covers all common operating modes (standard, full, fast, and high speed modes). Clock stretching and repeated starts are also supported. There are internal pull-up resistors which can be engaged or disabled as necessary.

Scanning for Devices

If you already know the address of your target I2C peripheral device, you can type it directly into the Address textbox (in either decimal or hex, preceded by "0x"). However, Binho makes it easy to discover devices on the I2C bus -- simply leave the "Address" textbox empty and click the "Scan Entire Bus..." button and the host adapter will check for devices on the bus. Any devices that are found will then be displayed in a listbox. Simply select the address of the device that you'd like to interact with from the list.

The remainder of the commands in this guide require that the "Target Address" has already been set, either by scanning the bus or via directly typing the peripheral I2C device address.

Reading Data

Reading data from the peripheral device is as simple as providing the number of bytes to read (in either decimal or hex, preceded by "0x") and clicking the "Read [n] Byte(s)" button.

Note that the results of this action are displayed in the transaction list at the bottom of the window.

Writing Data

Writing data to a peripheral device on the I2C bus can be done by entering the data into the "Write" textbox and clicking the "Write [n] Byte(s)" button. An option checkbox can be selected to immediately send a repeated start bit after writing the data. Data can be typed in binary, decimal, or hex formats. In the case of binary, the 8bit value should be preceded by a prefix of "0b", likewise a hex value should be preceded by "0x". Numbers without a prefix will be evaluated as a decimal number.

For clarity, here is an example of a valid data transfer displayed in each of the three supported bases:

Decimal: 222 173 190 239

Binary: 0b11011110 0b10101101 0b10111110 0b11101111

Hex: 0xDE 0xAD 0xBE 0xEF

Note that the results of this action are displayed in the transaction list at the bottom of the window.

Read Register

While not an official part of the I2C specification, a very common implementation across various I2C devices makes it convenient to have a Read Register function. Read Register is effectively a 1-byte Write command which contains the desired register address, followed immediately by a read command.

The Read Register command supports both 8bit and 16bit register addresses. When targeting a 16bit register on an I2C peripheral device, simply use the hex address padded with leading zeros as necessary.

For example, to address register 32 on a device which is expecting a 16-bit address, enter 0x0020 in the Register Address textbox.

Note that the results of this action are displayed in the transaction list at the bottom of the window.

Table of Contents

Step #1: Download and Install CoolTerm

CoolTerm is a very popular cross-platform serial console application developed by Roger Meier. It's got all the necessary features for communicating with hardware devices and an elegant user interface.

You can download the latest release directly from his website. Installation simply entails extracting the folder from it's compressed .zip archive and placing in a known location on your drive.

Step #2: Connect the Binho Multi-Protocol USB Host Adapter

Connect the Binho Nova to your PC using the provided USB cable. The status LED on the host adapter will shine yellow when it is powered and waiting for the host PC to open the connection to the device.

Step #3: Configure the Serial Connection

Configure the serial connection by clicking the "Options" button on the toolbar.

The connection parameters should be configured to the following:

• Baudrate: 1000000

• Databits: 8

• Parity: None

• Stop Bits: 1

Now let's adjust some CoolTerm settings to make it even easier to use.

1. Click the "Options" button again and select the "Terminal" Category from the list on the left.

2. Change the "Terminal Mode" setting from "Raw Mode" to "Line Mode"

3. Select the checkbox to enable "Local Echo" functionality.

Step #4: Open the Serial Connection

Now that the connection parameters have been configured correctly, it's time to connect to the Binho Nova. Click the "Connect" button on the toolbar to open the serial connection.

Once the serial connection has been established, the Status LED on the Binho Nova will shine blue. You can now begin sending commands to the host adapter.

Step #5: Send Commands

Sending commands to the device is as simple as typing a command and pressing Enter. Let's get the unique device ID of this host adapter by sending the device command +ID.

Note that the host adapter will respond to every command. If you do not receive a response from the command, then the serial connection may not be configured properly.

You're ready to hit the ground running. Check out the full User Guide to learn how to take advantage of the full set of supported protocols and features of your host adapter:

Our friends over at Sparkfun introduced us to Qwiic Connect System and we're loving it. This board makes it easy for you to interface your Binho host adapter with up to 4 strings of Qwiic devices, as well as breaking out all of the pins to a series of headers that make it very convenient to jump to other circuits, as well as hook up your Logic Analyzer to monitor everything while you develop and debug. This board is 25mm x 35mm and comes with the connectors pre-soldered. The headers are included but not installed.

This accessory is available for purchase in our online store here.

This board features a male 2x5 1.27mm connector and breaks it out to breadboard-friendly 2.54mm / 0.1in pitch headers. It's a quite easy way to interface your Binho host adapter with other circuits using standard jumper wires as well. The board measures 14mm x 18mm x 7mm and is black with white silkscreen labels for each of the pins. The SMT connector comes soldered to the board but you'll need to install the headers (included) yourself.

These are available for purchase on our website .

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.

This board makes it easy for you to interface your Binho Nova host adapter with any form-factor device. I2C, SPI, and UART interfaces are all wired up. By default, the 3V3 and 5V rails are connected so that the Binho Nova can power the sensors, but this can be easily disabled by cutting the exposed traces. Additionally, this interface board features a Qwiic connector to easily bridge the Feather and Qwiic ecosystems. The headers are included but not installed.

Note: We highly recommend the from Adafruit for use with this board.

This accessory is available for purchase in our online store .

This releases introduces the following enhancements:

• Added 1-WIRE WHR (Write Hex \ Read Hex) Command to increase 1-WIRE operational speed.

This release fixes the following bugs:

• No known bug fixes.

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

Legacy

This section addresses some common issues and how to resolve them. If you find yourself facing an issue not addressed here, please reach out to us at [email protected] and we'll help get to the bottom of it as quickly as possible.

Top Issues:

This release introduces the following enhancements:

• none

This release fixes the following bugs:

• Fixed I2C controller issue that can cause transfers of more than 256 bytes to fail.

This releases introduces the following features:

• Added CMD version keyword

• Added WHR command for improved I2C/SPI data transfer speed.

On MacOS, you'll need to ensure that your user account is added to the wheel group in order to grant it the permissions needed to access the hardware. This is only necessary once per user.

Simply run the following command:

Interested in trying out some of our newest features? This is the place for you! So, what does it mean to be an 'experimental feature'? Well, right now, these are features for which we are implementing proof-of-concept functional support in our products to gather feedback. These features have undergone a fair amount of internal testing already, but may lack strong supporting documentation.

The following features are currently available for public usage:

If you're using any of our experimental features, we want to hear from you! Please write in to [email protected] and let us know your thoughts and feedback so we can continue to improve them. Experimental features may eventually graduate and be assimilated into our standard feature set, or abandoned entirely.

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

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!

Key Features

• Support for SPI @ 12MHz max clock

• Support for I2C @ 3.4MHz max clock

• Support for UART @ 1000000 max baud

• Support for Dallas 1-Wire

• Support for Atmel Single-Wire Interface

• Provides 3v3 and VUSB power rails

• 1 x DAC Output, 5 x ADC Inputs

• GPIO / Interrupt / PWM Support

• Programmable RGB Status LED

• Field-Upgradeable Device Firmware

• Cross-platform Support for Windows, Mac, Linux

• Robust, low-profile Aluminum Enclosure

• USB Type-C Connector

Common Applications

• Firmware Development

• Proof of Concept Development

• System Debugging

• Automated Hardware Testing

Connector Pin Map

Device Description

The Binho Nova Multi-Protocol USB Host Adapter allows one to interface their computer directly to hardware circuits. This device is powered by the USB connection to the host PC and is also able to provide downstream power to test circuits.

The Binho Nova Multi-Protocol USB Host Adapter features 5 signal pins, 1 x 3v3 pin, 1 x VUSB pin, and 3 x GND pins on its 10pin wire harness. The wire harness terminates with a female 1.27mm 2x5 IDC connector. In IO Mode, the 5 signal pins can be used for varying functions such as Digital Input, Digital Output, PWM Output, Digital Interrupt (on rising edge, falling edge, or change), Analog Input, or Analog Output.

Additionally, the host adapter is able to utilize these pins to communicate on several digital buses: I2C, SPI, UART, (Dallas)1-Wire, and (Atmel) Single-Wire Interface. While in these modes of operation, remaining available pins can be assigned to other related or unrelated purposes such as gpio, interrupts, chip selects, PWM signals, or analog input or outputs.

The Binho Nova Multi-Protocol USB Host Adapter is ideal for manual testing during firmware development and debugging as well as a perfect way to automate hardware testing and validation. A common use-case of this product in production environments is for EEPROM/Flash Memory programming along with functional testing activities.

Included Components

The Binho Nova Multi-Protocol USB Host Adapter comes along with a helpful and with a 1 foot USB type C (male) to type A (male) cable in a soft-shell zippered case.

RoHS Certificate of Conformance

Download Binho RoHS Certificate of Conformance [pdf]

EU Declaration of Conformity

Download [pdf]

California Proposition 65 Warning

THIS PRODUCT CONTAINS CHEMICALS KNOWN TO THE STATE OF CALIFORNIA TO CAUSE CANCER AND BIRTH DEFECTS OR OTHER REPRODUCTIVE HARM.

Import / Export Compliance

Please see our International Shipping page for information regarding ECCN and HS Codes for Binho products:

Our cross-platform software is available for Windows, Mac, and Linux and provides an easy-to-use GUI interface for your Binho Nova Multi-Protocol USB Host Adapter.

Mission Control features support for SPI, I2C, and UART protocols, as well as IO functions.

You can download the latest version for your operating system here:

Take a look at the Getting Started section of our support portal for an introduction to using our GUI software:

Device Tab

IO Tab

SPI Tab

I2C Tab

UART Tab

Windows

We provide 32-bit and 64-bit builds of our application for Windows. The following versions are supported:

• Windows 10

• Windows 8.1

• Windows 7 SP1

Download

Download

Mac OS

Our MacOS build is a 64-bit application which runs on Apple computers with the following operating systems:

• macOS Mojave 10.14.x

• macOS High Sierra 10.13.x

• macOS Sierra 10.12.x

• OS X El Capitan 10.11.x

Download

Linux

We provide Linux builds for 32-bit and 64-bit system architectures. Our application runs on the following operating systems:

• Linux Mint 16 or later

• CentOS 7.0 or later

• Ubuntu 14.04 LTS or later

• Debian 6.0 or later

Download

Download

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.

As mentioned previously, every command sent to the host adapter will receive a response.

The Response Packets fall into one of three categories:

Windows

We provide 32-bit and 64-bit builds of our application for Windows. The following versions are supported:

• Windows 10

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.

In rare situations, there might be problems with the drivers on Windows 8 which require manual intervention in order to get the device working the first time that it's connected to the PC. These issues manifest themselves with the following 2 error codes displayed in Windows Device Manager.

Code 28 - The drivers for this device are not installed.

Driver Installation

Great News! Most modern operating systems already have the device drivers needed for your Binho Nova Multi-Protocol USB Host Adapter to work properly installed. The Binho Nova Mult-Protocol USB Host Adapter utilizes the standardized USB Communications Device Class driver in order to achieve maximum compatibility with as many systems as possible. As such, there's no driver to download and install.

Windows

We provide 32-bit and 64-bit builds of our application for Windows. The following versions are supported:

• Windows 10

Mission Control automatically detects the firmware version of a connected Binho Nova and checks if there's a newer version available. If a newer version of firmware is found, a prompt will be displayed asking if you'd like the device firmware to be updated. This process is shown below:

The five IO pins of the Binho Nova Multi-Protocol USB Host Adapter can be used in a variety of modes, and unassigned pins can be used for their IO functions even when other pins are used for SPI or I2C operation. The image below shows the pinout and functionality of each of the pins:

Digital Input

All 5 of the IO pins can be used as digital inputs. This can be achieved by selecting "DIN" from the pin assignment dropdown box. In this mode, the value of the input signal can be read by clicking the "Update" button. The value is displayed as either a logical 0 or 1.

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))

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.

V1.1.6 Release

1. Bugfix that was impacting the transmission of line endings in UART bridge mode

V1.1.4

1. Implements the new SPI CS pin control command, available in firmware version 0.2.7 and up, to have tighter timings on CS pin edges.

2. Fixed crash on old Nova FW on SPI tab when sending more than 256 bytes of data to old FW.

V1.1.3

1. Improved device discovery and connection management on Win, MacOS, and Linux.

V1.1.0

1. Improved I2C & SPI Data Transfer Performance

2. Added checking for Mission Control updates on application startup

3. Added firmware version detection & update prompt on device connection

4. Numerous Bug Fixes

V1.0.6

1. Improved I2C Addressing support with option for 7bit or 8bit addresses

2. Added support for UART Bridge mode of operation

3. Added device firmware update support

4. Added software check for update feature

V1.0.5 Alpha

1. Fixed bug in Reset and Reset to Bootloader functions

2. Fixed a variety of UI layout issues

3. Fixed errant unit labels

4. Enabled LiveScroll on PWM Frequency and Duty cycle sliders

V1.0.0 Alpha

Initial Release

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.

listAvailablePorts()

This function returns an array of currently available serial ports. The serial ports returned may or may not be a binho Multi-Protocol USB Host Adapter or some other device. See listAvailableDevices function below to get a list of serial ports related only to binho Multi-Protocol Host Adapters. Note that any serial ports which are currently opened will not be shown in the list.

Inputs:

This function takes no parameters.

Outputs:

This function returns an array of available serial ports as strings.

Example Usage:

listAvailableDevices()

This function returns an array of currently available serial ports that are associated with a binho Multi-Protocol USB Host Adapter. See listAvailablePorts function above to get a list of all available serial ports. Note that any serial ports which are currently opened will not be shown in the list.

Inputs:

This function takes no parameters.

Outputs:

This function returns an array of available serial ports as strings.

Example Usage:

getPortByDeviceID(deviceID)

This function returns an array which will either be either of length 0 (empty) or of length one, where the element will be a string containing the name of the serial port of the binho Multi-Protocol USB Host Adapter with the desired deviceID. This function is very useful when multiple host adapters are connected to the same computer.

Inputs:

This function takes 1 parameter, deviceID, as a string. It can either include or omit the "0x" prefix on the deviceID.

Outputs:

This function returns an array of serial ports as strings. Note that since the deviceIDs are globally unique, the returned array will have either zero or one element.

Example Usage:

Connection to the Computer

Use the provided USB Type-C (male) to USB Type-A (male) cable to connect the Binho Nova Multi-Protocol USB Host Adapter to your host PC. The device can be plugged into any available USB port - there is no requirement to plug it into a USB 3.0 port.

Upon power up, the Status LED on the Binho Nova Multi-Protocol USB Host adapter will shine yellow while it is waiting for the COM port to be opened. When connected properly, the device should immediately enumerate and become available for use as a new COM port. Once a serial connection has been established between the device and the host computer, the Status LED will shine blue.

Connection to the Test Circuit

The Binho Nova Multi-Protocol USB Host Adapter features an integrated wire harness terminated with a 1.27mm pitch 2x5 IDC Connector. This harness contains the 5 signal pins, 1 x 3V3 power signal, 1 x VBUS power signal, and 3 x GND signals.

The figure below shows the connector pinout and channel functions:

Use the link below to download a printable PDF version of this image for easy reference:

Clearly the most convenient method to connect the signals is by including a footprint for the 2x5 IDC connector on your circuit board, but this isn't always an option. As such, you can use the included Breadboard Adapter board to breakout the signals to 0.1in/2.54mm pitch headers which can easily be connected with jumper wires.

Furthermore, there are several accessories available that make it easy to connect directly to your test circuitry. You can learn all about them here:

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:

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.

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.

Before using your Binho Nova Multi-Protocol USB Host Adapter, let's review some basic safety information to keep in mind while working with electronics in order to avoid injury or damage.

Electrical Isolation

We're in the process of creating a streamlined way to install the device drivers. In the meantime, please follow the manual steps shown below to install the driver for your Binho Nova Multi-Protocol USB Host Adapter. Thank you very much for your patience while we work on improving the driver installation experience, and please feel free to reach out to us at [email protected] for any assistance related to driver installation issues.

The Binho Nova Multi-Protocol USB Host Adapter pairs elegantly with pytest 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.

Here's an example of a conftest.py file which creates two fixtures, one for each Binho Nova used in the testing:

In this fashion, the serial connections with the devices will be opened up at the beginning of the testing. Then, using these devices from within the test cases is simple, just pass them into each function that uses them as a parameter. Here's an example function to demonstrate this:

Writing automated hardware and firmware tests has never been easier!

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

What is it?

DAPLink mode allows a Binho Nova to be utilized as a programmer / debugger for ARM microcontrollers. By entering DAPLink mode, the Nova will enumerate as a CMSIS-DAP interface that can be discovered by OpenOCD, pyOCD, and even your favorite IDEs. As such, the Nova becomes a robust device which bridges the gap between expensive & powerful debuggers such as and cheap bare board tools or illegal knock-off devices.

Binho Nova's DAPLink mode supports the SWD interface (SWDIO, SWCLK, and RESET signals) as well as a UART bridge to a virtual COM port (using the same TX, RX signals as in normal Nova operation).

DAPLink is an open-source software project that is developed and maintained by ARM that enables programming and debugging of ARM Cortex CPUs. Please check out the official DAPLink website for more specific details:

The Binho Nova Multi-Protocol USB Host Adapter is designed for ease of use in every aspect, and that's especially true when it comes to updating the device firmware. In an effort to provide the greatest flexibility in accommodating our different customers' development and testing environments, we offer a variety of ways to update the Nova device firmware. Below we detail how to update the firmware through three main methods: using Mission Control, using our python library, and manually using a Serial Terminal.

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 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.

There are a number of accessories available that can make using a Binho Multi-Protocol USB Host Adapter even more convenient.

First in line is the breadboard breakout, making it easy to interface with 0.1" headers. This is such a common need that one of these is included with the host adapter, but it's good to know where to get more:

Qwiic is a fairly new open standard when it comes to hooking up I2C devices, brought to the world by Sparkfun Electronics and gaining adoption across the open-source hardware industry. We've made a board which makes it easy to interface the Binho Multi-Protocol USB Host Adapter with qwiic devices. This board is also a great way to breakout the header to a number of pins which can easily be jumped to other circuits or observed with your logic analyzer.

If you're working with a fixture or board that was designed for use with another common host adapter, but you'd like to find an easy way to get it hooked up to your Binho Multi-Protocol USB Host Adapter, then perhaps the Total Retrofitter is exactly what you're looking for:

If you have an idea for an accessory that would make your job easier, please feel to let us know at [email protected] and we'll see what we can do to help.

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.

The Binho Nova Multi-Protocol USB Host Adapter can serve as a SPI bus controller device which can be configured to meet the needs of nearly any SPI bus implementation. The SPI Clock can be set to a frequency between 500kHz and 12MHz, and all 4 SPI modes are supported. Transfers can be in 8-bit or 16-bit packets. The pin assignments for the SPI protocol are show in the graphic below, indicated in yellow:

The following table gives a brief overview of the available SPI commands.

Feel free to jump ahead to the ASCII Command Set reference to learn the specifics of each command, or continue below to see an example of how to use these commands to achieve communication on the SPI bus.

Setting Up the SPI Bus

The first step in using the Binho Nova Multi-Protocol USB Host adapter as a SPI Controller is to put the adapter into SPI mode using the command.

Now the host adapter is in SPI communication mode. The next step is to configure the SPI bus. Here are the default settings:

• SPI Clock Frequency = 2MHz

• SPI Mode = 0 (CPOL = 0, CPHA = 0)

• 8 Bit Packet Size (TXBITS)

• MSB-First bit ordering.

Let's change the bus configuration to a 5MHz clock:

And let's setup the IO0 pin to use as our chip-select signal. For this device, the chip-select signal is active low, so IO0 should be a digital output that is idle high.

The bus is now all setup and ready to go.

Sending and Receiving Data

Begin by putting the SPI signals (SCK, SDI, SDO) in their initial state simply by using the BEGIN command.

In order to begin transferring data over the SPI bus, one must first assert the chip-enable/chip-select signal of the peripheral device.

Now the chip-select signal is asserted and our target SPI peripheral device is ready to communicate.

Let's do a 5 byte transfer, which consists of sending a 1-byte command and then clocking out a 4-byte response.

Well that sure was tedious... and something seems strange. Looks like the peripheral device didn't return any data because we were too slow. It's fairly common for devices to have timing requirements regarding the duration of a transfer. Thankfully, for situations like this, we can use the buffer! Let's load up the buffer with our data:

Now let's perform the SPI transaction using BUF0 and send 5 bytes from BUF0, using IO0 as the ChipSelect pin (active-low):

Since we are using the buffer, the received data is also placed into the buffer. Let's read it out and see if the device responded as expected:

Awesome! The expected response was received. That's pretty much all it takes to use the Binho Nova Multi-Protocol USB Host Adapter to speak with SPI devices. Simply clear out the buffer and repeat the process to start another transfer.

Note that this example didn't cover using IO1, but it's not hard to imagine how this could be used as an interrupt pin, or to control the chip-select pin of a second peripheral device on the SPI bus.

Feel free to take a look in the examples section to see how to use the python library to use this in an automated way:

Otherwise, stick around here and move to the next page to see a similar tutorial on an I2C bus.

The Binho Nova Multi-Protocol USB Host Adapter can function as a Dallas 1-WIRE host device. This protocol can be configured to operate on any of the IO pins on the device, 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.

The following table gives a brief overview of the available 1WIRE commands.

Feel free to jump ahead to the ASCII Command Set reference to learn the specifics of each command, or continue below to see an example of how to use these commands to achieve communication on the 1-WIRE bus.

Setting Up the 1-WIRE Bus

The first step in using the Binho Nova Multi-Protocol USB Host Adapter as a 1-Wire host is to put the adapter into 1-WIRE mode using the command.

Now the host adapter is in 1-WIRE communication mode. The 1-Wire bus has no configurable settings, so all we need to do is decide which IO pin we want to use. Let's take advantage of the internal pull-up resistor on IO0:

And just like that, we're ready to start communicating with 1-Wire devices on the bus.

Selecting a Target Device

Let's get things started off right by first resetting all the devices on the bus:

With all the devices reset, it's now possible to begin the process of selecting the device that will be communicated with. Let's start a search for devices on the bus -- but before doing the search, let's make sure we start at the beginning of searching through the devices by reseting the search.

Alright, now let's begin the search:

Let's see what the search found. We'll query the address to see what device was found:

That's great - the exact device we were looking for! Now that we know the address of desired device is in the ADDR field, we can move ahead with sending and receiving data.

Sending and Receiving Data

Now let's get the device's attention and ready to interact with us. This is done by sending another RESET command:

Now let's select the device we'll be communicating with -- recall that it's address is already in memory from the result of our SEARCH command.

Finally let's do some reading and writing:

That's all there is to it! Of course getting the transaction complete before any timeouts occur can be challenging when manually interacting with the devices on the bus using these commands, however this isn't an issue when scripting the interactions. When it comes to manually interacting with 1-Wire devices, we highly recommend using the command. You can see how to do this in our video tutorial embedded below:

Check out the examples section to see how to use 1-Wire in an automated way:

1-Wire is just one of the common protocols which utilizes just one signal for bi-directional communication. On the next page we'll look at Atmel's Single-Wire Interface which is another similar protocol.

MODE

Gets/sets the current mode of a specific IO signal. Note that not all modes of operation are available on all pins. Please see the pin out diagram on the Using IO page for reference.

Set current mode value: IO[n] MODE [mode]

Get current mode value: IO[n] MODE ?

Parameters:

This function takes on parameter, mode:

• To set IO pin mode to Digital Input, use DIN

• To set IO pin mode to Digital Output, use DOUT

• To set IO pin mode to Analog Input, use AIN

Response:

Set: This function returns an if the command succeeds in setting the supplied mode of operation to the specified IO pin. If the command fails, the function will return a .

Get: This function returns -IO[n] followed by MODE followed by the current mode.

Example Usage:

INT

Gets/sets the interrupt configuration of a specific IO signal. Note that not all IO signals are capable of supporting hardware interrupts. Please see the pin out diagram on the page for reference.

Set Interrupt configuration: IO[n] INT [trigger]

Get Interrupt configuration: IO[n] INT ?

Parameters:

This function takes on parameter, trigger:

• To configure interrupt on rising edge, use RISE

• To configure interrupt on falling edge, use FALL

• To configure interrupt on either edge, use CHANGE

Response:

Set: This function returns an if the command succeeds in configuring the interrupt on the specified IO pin. If the command fails, the function will return a .

Get: This function returns -IO[n] followed by INT followed by the current interrupt configuration.

Example Usage:

VALUE

Gets/sets the current value of a specific IO signal. The meaning of the value is dependent on the current mode setting of the signal. The acceptable units for value depends on the current pin mode of operation.

Set value: IO[n] VALUE [val]

Get value: IO[n] VALUE ?

Parameters:

This function takes on parameter, val:

• When the pin is configured as a digital output:

  • val can be 0 or LOW to set the output low

  • val can be 1 or HIGH to set the output high

• When the pin is configured as an analog output:

Response:

Set: This function returns an if the command succeeds in configuring the output on the specified IO pin. If the command fails, the function will return a .

Get: This function returns -IO[n] followed by VALUE followed by the current value of the IO pin, which depends on the current operating mode of the pin.

• When the pin is configured as a digital input or output, returned value will be either 0 or 1

  • Example: IO[n] VALUE 0

• When the pin is configured as an analog input or output, returned value will be in counts and volts

Example Usage:

PWMFREQ

Gets/sets the current value of the PWM frequency of a specific IO signal. This is only applicable when in PWM Mode. Note that IO0 and IO2 share a PWM Frequency, and IO3 and IO4 share a PWM Frequency. The default PWM frequency is 10kHz.

Set Frequency: IO[n] PWMFREQ [frequency]

Get Frequency: IO[n] PWMFREQ ?

Parameters:

This function takes on parameter, frequency, which can be from 750Hz to 80000Hz.

Response:

Set: This function returns an if the command succeeds in configuring the PWM frequency on the specified IO pin. If the command fails, the function will return a .

Get: This function returns -IO[n] followed by PWMFREQ followed by the currently configured PWM frequency.

Example Usage:

The Binho Multi-Protocol USB Host Adapter also supports UART communication. This is slightly different than how other supported protocols are implemented as in UART mode, the Binho host adapter is just a pass-through bridge. However, this basic mode of operation affords several advantages versus using a separate USB to UART bridge IC. In particular, it's possible to use the DAC and the I2C bus along with UART since they are all on separate signals not overlapping with UART TX and UART RX signals, or use those 3 available IO pins as some combination of ADC inputs, PWM outputs, or GPIO.

Again for easy reference, here's the connector pinout with the UART signals shown in green:

Feel free to jump ahead to the ASCII Command Set reference to learn the specifics of each command, or continue below to see an example of how to use these commands to achieve communication using the UART bridge.

Configuring the Connection

The first step in using the Binho Multi-Protocol USB Host Adapter as a UART bridge is to put the adapter into UART mode using the command.

Now let's configure the desired parameters of the UART bridge to match the downstream UART device. Here are the default settings:

• 9600 Baud rate

• 8 Databits

• No Parity bit

• 1 Stop bit

Let's change the baudrate to match our desired communication speed:

The other settings are quite commonplace, so we'll leave those unchanged in this example. However, there is one important thing to discuss before starting the UART bridge: how to stop the UART bridge.

Let's do a quick exercise to solidify our understanding. The ESC command can be queried so that nothing needs to be memorized:

Okay, here we can see that the escape sequence is currently set to +++UART0, which is the default setting.

But wait, what if I actually need to send the same string over the UART bridge and I don't want it to stop the bridge. Glad you asked! The escape sequence can be user defined to something even more unique:

It's certainly a best practice to always read back the ESC value after writing to it to confirm that it's been set to the expected value.

Starting the UART Bridge

Now that we know the escape sequence, we can safely open up the UART bridge.

Once the -OK response is received, the UART bridge is open and all data will pass through the host adapter. The Binho Multi-Protocol USB Host Adapter will not respond to any commands until the UART bridge is closed.

Data can be simply passed through the host adapter as if it were a direct serial connection to the downstream device. Taking full advantage of the features available, one can easily jump out of the UART bridge to toggle pins, change the output voltage of the DAC, or otherwise stimulate the device, and then re-open the bridge.

Closing the UART Bridge

Now let's close the UART bridge and go back to command mode. Simply send the escape sequence that was defined before starting the bridge:

Feel free to take a look in the examples section to see how to use the python library to use this in an automated way:

That's it for guides through the various supported protocols. Congratulations on making it this far through the User Guide. The next and final chapter will show you how to perform a device firmware update so that you always have the latest and greatest features on your Binho Multi-Protocol USB Host Adapter.

The host adapter includes a 256-byte buffer which can be used to optimize multi-byte read and writes using any of the supported communication protocols.

clearBuffer(index)

This function clears the entire buffer, setting all bytes to 0.

Inputs:

This function one parameter, index. There is only one buffer, so this will always be 0.

Outputs:

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

Example Usage:

addByteToBuffer(index, val)

This function adds a single byte to the buffer. Note that the buffer automatically keeps track of / auto-increments the index as data is loaded.

Inputs:

This function takes two parameters:

• index, the index of the buffer. There is only one buffer, so this will always be zero.

• val, as 8-bit integer value.

Outputs:

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

Example Usage:

readBuffer(index, numBytes)

This function reads out a given number of bytes from the buffer. Note that the bytes are not cleared out of the buffer after the read. They will remain in the buffer until they are overwritten or when the buffer is cleared.

Inputs:

This function takes two parameters:

• index, the index of the buffer. There is only one buffer, so this will always be zero.

• numBytes, an 8-bit integer value of the number of bytes to read from the buffer.

Outputs:

The host adapter will respond with 'BUF0' followed by numBytes of bytes read from the buffer separated by spaces.

Example Usage:

writeToBuffer(index, startIndex, values)

This function writes up to 32 bytes into the buffer in a single transaction, beginning at the startIndex index in the buffer. This provides for a faster way to fill the buffer when the data is predetermined, such as when programming memory devices.

Inputs:

This function takes three parameters:

• index -- the index of the buffer. There is only one buffer, so this will always be zero.

• startIndex -- the position in the buffer that the first byte should be stored. The index will be incremented for each of the following bytes.

• values -- an array of up to 32 bytes of data to be loaded into the buffer beginning at the startIndex position.

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:

The Binho Socket Station provides the most convenient way to combine devices from your favorite form-factors and ecosystems in an elegant way. The board features sockets for a mikroBUS click and a Feather, as well as a Qwiic / StemmaQT connector to interface your favorite I2C devices. There are two ground loops soldered at the corners for easy signal probing with your scope or DMM. And of course, there's connectors to connect your Binho Nova to the SPI, I2C, and UART buses that interconnect these devices. The 3V3 and 5V power rails can be sourced by the attached Binho Nova, or can be isolated from the Nova via jumpers.

The silkscreen on the back of the PCB clearly shows the wiring between the Feather and mikroBUS click sockets for easy reference, and the board sits on 4 x bump-on feet to protect your desk. This board comes fully soldered and ready for action.

This accessory is available for purchase in our online store here.

This releases introduces the following features:

• PWM Frequency Control -- documentation can be found here and here.

This release fixes the following bugs:

• Added zero-padding to the device ID numbers so there are no blank spaces in the string

Download

The first set of commands covered in this guide are the "Device" commands. These commands are not related to any particular protocol or feature, rather they configure general functionality of the host adapter.

Functions related to the communication, setting the host adapter mode of operation, identifying the device, and resting the device can all be accomplished using the Device commands.

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

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 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.

Windows

We provide 32-bit and 64-bit builds of our application for Windows. The following versions are supported:

• Windows 10

This release introduces the following enhancements:

• no new features or enhancements

This release fixes the following bugs:

• Fixed ADC pin mappings for IO0, IO1, and IO2 that could be swapped in some cases

This page contains the firmware change log and binary files so that devices in the field can be updated to the latest version.

Please see the following guide to learn how to update the device firmware using Mission Control, our Python library, or even manually:

Releases

The ASCII Command Set provides an easy means to open up a serial port connection and interact with the device via a human-readable protocol. This is ideal for tasks such as debugging device drivers / performance issues, as well as device evaluation and proof of concept development.

The ASCII Commands are broken down into several categories.

This release introduces the following enhancements:

• I2C Peripheral mode of operation now supports BANK commands. Now the entire register bank can be read/written to with a single command to Nova. See the python library example .

• IO pins now have a Toggle() command which can instruct Nova to perform a toggle of a precise time duration (from 5microseconds to 265milliseconds). See the python library example .

The Binho Nova Multi-Protocol USB Host Adapter has been designed so that it can be compatible with as many systems as possible. By utilizing the USB Communications Device Class standard driver, it's possible to use your host adapter with any operating system which includes support for this type of USB device. This includes all modern versions of Windows (beginning with Windows Vista), Mac OS X, and Ubuntu. Additionally, it even works on Android-based mobile devices.

The only hardware-specific requirements is that your host PC has one available USB 2.0 port. The supplied USB cable features a Type-A male connector due to it's popularity, however another USB cable can be used to match the mating connector of the host device.

Given the above, it's easy to see that the Binho Nova Multi-Protocol USB Host Adapter can also be used with a variety of single-board computers such as the Raspberry Pi and others.