USB IO Board PIC18F2455 / PIC18F2550

USB IO Board Controller

USB IO Board can be controlled with just about any serial port emulation program such as Hyper Terminal that comes with every Windows OS. The problem with Hyper Terminal is that you can't see the commands as you type them and that could be very annoying. With Hyper Terminal you also have to go through the wizard for setting up a serial port connection, and if the COM port changes you pretty much have to do it over and over again.

Luckily we have released our own little application called USB IO Board Controller that is so much easier and fun to use than Hyper Terminal. It only takes 25KB of space so it's very lightweight. USB IO Board Controller will also show you COM port of USB IO Board so that will save you the trip (and time) to Device Manager to find out USB IO Board COM port number.

To use USB IO Board Controller select the COM port from the drop down list, type the command and hit "Enter" key (or click on Send button). Each command returns "OK" message to acknowlege that the command was received and processed successfully.

Download USB IO Board Controller (Win 2K, XP, VISTA, Win7)

Note: If you try to execute USB IO Board Controller and it doesn't work you will need to download and install
Microsoft .NET Framework 3.5

Below you will find USB IO Board Controller source code written in C# and Visual Basic .NET using free Visual Studio 2008 Express IDE software. Use it as a foundation to get started on any projects of your choice. The code demonstrates how to list COM ports, connect to COM port, send commands and receive data from USB IO Board.

Download free copy of Visual C# 2008 Express or Visual Basic 2008 Express

USB IO Board Controller - C# Source Code

//============================================================================= // USB IO Board Controller v2.0 // Copyright www.Electronics-DIY.com � 2002-2012. All Rights Reserved. // THIS SOURCE CODE CAN ONLY BE USED FOR PERSONAL USE // DO NOT REPRODUCE WITHOUT PERMISSION //============================================================================= // Compiled with free Visual C# 2008 Express // http://www.microsoft.com/visualstudio/en-us/products/2008-editions/express //============================================================================= using System; using System.Windows.Forms; using System.IO.Ports; namespace USB_IO_Board_Controller { public partial class Form1 : Form { public SerialPort Port = new SerialPort("COM1", 57600, Parity.None, 8, StopBits.One); public Form1() { InitializeComponent(); } private void Form1_Load(object sender, EventArgs e) { ListCOMPorts(); } // List COM Ports private void ListCOMPorts() { foreach (string s in SerialPort.GetPortNames()) { cboCOMPorts.Items.Add(s); } cboCOMPorts.Sorted = true; } // Connect to COM Port private void cboCOMPorts_SelectedIndexChanged(object sender, EventArgs e) { try { Port.PortName = cboCOMPorts.Text; if (!Port.IsOpen) { StatusBar.Text = "Connected to " + Port.PortName; Port.Open(); } } catch (Exception ex) { MessageBox.Show(ex.Message); } } // Send Command to USB IO Board private void btnSend_Click(object sender, EventArgs e) { if (Port.IsOpen) { //Port.Write("C,0,0,0,0" + '\r'); //Example: Configure all ports as outputs Port.Write(cboCommandInput.Text + '\r'); System.Threading.Thread.Sleep(100); //ms ReceiveData(); } else { StatusBar.Text = "Select COM port"; } } // Receive Data from USB IO Board private void ReceiveData() { string output = null; byte[] Buffer = new byte[Port.BytesToRead]; Port.Read(Buffer, 0, Port.BytesToRead); for (int i = 0; i <= Buffer.Length - 1; i++) { output += Microsoft.VisualBasic.Strings.Chr(Buffer[i]); } txtOutput.Text = output + txtOutput.Text; } } }

Download USB IO Board Controller Project Files

USB IO Board Controller - VB.NET Source Code

'============================================================================= ' USB IO Board Controller v2.0 ' Copyright www.Electronics-DIY.com � 2002-2012. All Rights Reserved. ' THIS SOURCE CODE CAN ONLY BE USED FOR PERSONAL USE ' DO NOT REPRODUCE WITHOUT PERMISSION '============================================================================= ' Compiled with free Visual Basic 2008 Express ' http://www.microsoft.com/visualstudio/en-us/products/2008-editions/express '============================================================================= Imports System.IO.Ports Public Class Form1 Public WithEvents Port As SerialPort = New SerialPort("COM1", 57600, Parity.None, 8, StopBits.One) Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load ListCOMPorts() End Sub ' List COM Ports Private Sub ListCOMPorts() For Each s As String In SerialPort.GetPortNames() cboCOMPorts.Items.Add(s) Next cboCOMPorts.Sorted = True End Sub ' Connect to COM Port Private Sub cbo_SelectedIndexChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles cboCOMPorts.SelectedIndexChanged Try Port.PortName = cboCOMPorts.SelectedItem If Not Port.IsOpen Then StatusBar.Text = "Connected to " & Port.PortName Port.Open() End If Catch ex As Exception MsgBox(ex.Message) End Try End Sub ' Send Command to USB IO Board Private Sub btnSendCommand_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnSendCommand.Click If Port.IsOpen Then 'Port.Write("C,0,0,0,0" & vbCr) 'Example: Configure all ports as outputs Port.Write(cboCommandInput.Text & vbCr) System.Threading.Thread.Sleep(100) 'ms ReceiveData() Else StatusBar.Text = "Select COM port" End If End Sub ' Receive Data from USB IO Board Private Sub ReceiveData() Dim output As String Dim Buffer(Port.BytesToRead - 1) As Byte Port.Read(Buffer, 0, Port.BytesToRead) For i As Integer = 0 To Buffer.Length - 1 output &= Chr(Buffer(i)) Next txtOutput.Text = output & txtOutput.Text End Sub End Class

Download USB IO Board Controller Project Files

Testing USB IO Board

Lets run some sample commands to see how easy it is to turn LED ON/OFF.
Connect LED to microcontroller; longer leg to PIN28 (RB7), shorter leg to ground (GND) via 470 Ohm resistor. Now, to turn LED ON and OFF type these commands using USB IO Board Controller. Remember to hit "Enter" key after each command is entered.

Configure Port A, B and C as outputs:
C,0,0,0,0

Turn LED ON (+5V):
PO,B,7,1

Turn LED OFF (0V):
PO,B,7,0

Here's an example on how we can measure voltage on PIN2 (AN0) and still be able to use other ports as outputs. Maximum input voltage of PIC18F2455 / PIC18F2550 microcontroller is limited to 5V but with a simple two resistor voltage divider we can easily measure up to any voltage we want. Use 1K resistor connected to PIN2 and GND and 100K resistor connected to PIN2 and input to measure up to 500V. Please see USB Voltmeter page for more information.

Configure Port A - PIN2 as analog input, B and C as outputs:
C,1,0,0,1

Sample input voltage on PIN2:
A

USB IO Board will return digital representation of voltage and display it on the computer.

Turn LED ON on PIN28 (+5V):
PO,B,7,1

Turn LED OFF on PIN28 (0V):
PO,B,7,0

Please read more about "C" command below on how to configure more analog inputs.

Notes for ALL commands:

You end a command by sending a <CR> or <LF> or some combination of the two. This is how all commands must be terminated to be considered valid.
The total number of bytes of each command, counting from the very first byte of the command name up to and including the <CR> at the end of the command must be 64 bytes or less. If it is longer than 64 bytes, the command will be ignored, and other bad things may or may not happen. This limitation will hopefully be removed in future FW D versions.
You can string together as many commands as you want into one string, and then send that string all at once to the USB IO Board. As long as each individual command is not more than 64 bytes, this will work well. By putting many commands together (each with their own terminating <CR>) and sending it all to the USB IO Board at once, you make the most efficient use of the USB bandwidth.
After successful reception of a command, the USB IO Board will always send back an OK packet, which will consist of "OK<CR><LF>". For just testing things out with a terminal emulator, this is very useful because it tells you that the USB IO Board understood your command. However, it does add extra communications overhead that may not be appreciated in a higher speed application. Starting with this version (1.4.0) you can use the CU command to turn off the sending of "OK" packets. Errors will still be sent, but not any "OK" packets.
Currently, the backspace key does not work. For example, if you are typing a command to the USB IO Board from a terminal emulator and you make a mistake and try to backspace to correct your mistake, the USB IO Board will not recognize the backspace and will generate an error. This will hopefully be correct in a future FW D version.
All command names ("C", "BC", etc.) are case insensitive.
All port names ("A", "B", "C") are case insensitive

"C" Command:

The "C" command stands for 'Configure' and allows you to set the state of the port direction registers for ports A, B and C, as well as enable analog inputs. This allows you to turn each pin into an input or an output on a pin by pin basis, or enable one or more of the pins to be analog inputs.
Format: "C,<DirA>,<DirB>,<DirC>,<AnalogEnableCount><CR>" where <DirX> is a value between 0 and 255 that indicates the direction bits for that port. A 1 is an input, a 0 is an output.

<AnalogEnableCount> If this value is sent as a zero, then all analog inputs are turned off and all of the pins behave as just digital inputs or outputs.
If <AnalogEnableCount> is sent as a value from 1 to 12, then one or more of the analog inputs (see below) are enabled and will start sampling every millisecond. Any value over 12 is an error. Use the "A" command to retrieve the values of the enabled analog inputs.

Example: "C,4,245,52,0"
Warning on Analog Inputs: It is very important that if you enable an analog input on a pin, that you set that pin as an input (set the proper <DirX> bit). If you have a pin set as an output in the <DirX> bit but have it enabled as an analog input, your analog reading will simply convert the current digital output voltage on the pin (which may be what you want, but probably not). Also, if you have a pin set as a digital output with the <DirX> bit, but DON'T enable it as an analog input and then apply analog input levels to the pin, that pin may draw excessive power because it may float around between a High (5V) and Low (0V). PICs are very robust, but be careful.
Analog Input Matrix:

If one or more of the analog inputs are enabled, then use this chart to see which number for <AnanlogEnableCount> enables which pins as analog inputs. The PIC core that all of the USB PICs are built on has 13 analog input channels. However, on the 28 pin parts (which are currently used in USB IO Board designs) three of those analog inputs (AN5,AN6 and AN7) do not come out as pins. They still exist, and as far as Firmware D v1.2 is concerned, are treated exactly as all of the other analog input pins, so the show up in the "A" packet. Also, AN12 (the 13th analog input) is not available for Firmware D v1.2 use because enabling all 13 would create a USB packet greater than 64 bytes, which is not allowed.

<AnalogEnableCount>
value

AN11
RB4

AN10
RB1

AN9
RB3

AN8
RB2

AN7
N.A.

AN6
N.A.

AN5
N.A.

AN4
RA5

AN3
RA3

AN2
RA2

AN1
RA1

AN0
RA0

Return Packet: "OK"

"O" Command:

The "O" command stands for 'Output state' and will take the values you give it and write them to the port A, B and C data registers. This allows you to set the state of all pins that are outputs.
Format: "O,<PortA>,<PortB>,<PortC><CR>" where <PortX> is a value between 0 and 255 that indicates the value of the port pins for that register.
Example: "O,0,255,22"
Return Packet: "OK"

"I" Command

The "I" Command stands for 'Input state' and when you send the USB IO Board an "I" command, it will respond with an "I" packet back that will hold the value of each bit in each of the three ports A, B and C. It reads the state of the pin, no matter if the pin is an input or an output. If the pin is configured as an analog input, the bit will always read low (0) in the "I" packet.
Format: "I<CR>"
Example: "I"
Return Packet: "I,<StatusA>,<StatusB>,<StatusC><CR>" where <StatusX> is a number from 0 to 255 that indicates the current value of the pins on that port. Note that <StatusX> will always be 3 characters long, which means that leading zeros will be added so that the return packet is always the same length regardless of the data values.
Example Return Packet: "I,001,045,205"

"V" Command

The "V" Command stands for 'Version' and when you send the USB IO Board an "V" command, it will respond with a text string that looks something like this: "USB IO Board FW D Version 1.4.0"
Format: "V"
Return Packet: "USB IO Board FW D Version 1.4.0"

"R" Command

The "R" Command stands for 'Reset to default state' and when you send the USB IO Board an "R" command it will initialize all pins to digital inputs and stop any running timers.
Format: "R"
Return Packet: "OK"

"T" Command

The "T" Command stands for 'Timer read inputs' and when you send the USB IO Board an "T" command, it will set the delay for one of two timers. When the timer times out, it will cause an "I" packet or "A" packet response to get sent to the PC.
Format: "T,<TimeBetweenPacketsInMilliseconds>,<Mode><CR>"
<TimeBetweenPacketsInMilliseconds>: The time between response packets is determined by the <TimeBetweenPacketsInMilliseconds> value, and is expressed as a number between (and including) 1 and 30000 . If you send a 10 for <TimeBetweenPacketsInMilliseonds> then a new packet response would be sent every 10ms. If you sent a value of 30000, then it would send a packet response every 30 seconds. If you want to turn off either timer so that no more packets are sent, send a <TimeBetweenPacketsInMilliseconds> of zero. You have to send a time of zero for both "I" and "A" timers if you want them both to turn off. Note : just because the UWB can kick out I and A packets every 1ms (at its fastest) doesn't mean that your PC app can read them in that fast. Some terminal emulators are not able to keep up with this data rate coming back from the USB IO Board, and what happens is that the USB IO Board's internal buffers overflow. This will generate error messages being sent back from the USB IO Board. If you write your own custom application to receive data from the USB IO Board, make sure to not read in one byte at a time from the serial port - always ask for large amounts (10K or more) and then internally parse the contents of the data coming in. (Realizing that the last packet may not be complete.) Note 2 : It has been discovered that if an attempt is made to have all 13 channels of analog be reported any faster than every 4ms, then an internal USB IO Board buffer overflow occurs. Be careful with the speed you choose for A packets. The maximum speed is based upon how many analog channels are being sent back.
<Mode>: If <Mode> is "0" then the "I" packet timer (digital input packet) is set and will generate "I" packets back to the PC. If <Mode> is "1" then the "A" packet timer (analog input packet) is set and will generate "A" packets back to the PC. Both timers can be active and sending back their respective packets at different (or the same) rates.
Note : The USB IO Board is actually sampling the digital input pins at an extremely precise time interval of whatever you sent in the T command. The values of the pins are stored in a buffer, and then packet responses are generated whenever there is 'free time' on the USB back to the PC. So you can count the I packet responses between rising or falling edges of pin values and know the time between those events to the precision of the value of <TimeBetweenPacketsInMilliseconds>. This is true for <Mode>=0. For <Mode>=1, the analog inputs are sampled every 1ms. Each time the "A" timer times out, the latest set of analog values is used to create a new "A" packet and that is then sent out.
Example: "T,100,0" - this would send back 10 "I" packets per second, sampled every 100ms.
Example: "T,14,1" - this would sample all enabled analog inputs and send back an "A" packet every 14ms.
Return Packet: "OK". Note however, the "I" packet or "A" packet responses will start flowing at regular intervals after the T command is received by the UWB.
Note: If the "I" or "A" packet responses stop coming back after you've done a "T" command, and you didn't stop them yourself (with a "T,0,0" or "T,0,1") then what's happened is that the internal buffer in the USB IO Board for I or A packet data has been filled up. (There is room for 3 I packets and 3 A packets.) This means that the USB system is too busy to get the packet responses back to the PC fast enough. You need to have less USB traffic (from other devices) or increase the time between packet responses.

"A" Command

The "A" Command stands for 'Sample Analog Inputs'. When you send the "A" packet to the USB IO Board, it will send back the last sampled set of analog inputs. All enabled analog inputs are sampled every 1ms, and stored. Whenever an "A" packet is received, the latest stored value for the analog inputs is sent back in a returning "A" packet.
Format: "A<CR>"
Example: "A"
Return Packet: "A,0145,1004,0000,0045" (The return packet would look like this if there were 4 analog inputs enabled with the "C" command). There can be up to 12 analog input enabled, and thus there might 12 numbers between 0 and 1023 after the "A,". See the chart in the "C" command above for information on which analog inputs correspond to which pins. The numbers represent the analog voltage on each enabled analog input from 0V (0000) to 5V (1023). The first number after the "A," is for AN0, and the last number is for the highest analog input channel (ANx) that is currently enabled.

"MR" Command

The "MR" Command stands for 'Memory Read'.
Format: "MR,<Address><CR>"
<Address>: This is a number between and including 0 to 4095. It is the address in the USB IO Board's RAM that you wish to read.
Example: "MR,3968" (asks the USB IO Board to read the value in the PORTA register)
Return Packet: "MR,<Value>"
<Value>: This is a number between and including 0 to 255. It is the result of reading <Address>.
Example Return Packet: "MR,28"

"MW" Command

The "MW" Command stands for 'Memory Write'.
Format: "MR,<Address>,<Value><CR>"
<Address>: This is a number between and including 0 to 4095. It is the address in the USB IO Board's RAM that you wish to write into.
<Value>: This is a number between and including 0 to 255. It is the value you wish to write into <Address>.
Example: "MW,3968,56" (asks the USB IO Board to write the value 56 into the PORTA register)
Return Packet: "OK"
NOTE: This command can be extremely dangerous unless you read the PIC datasheet and understand what you are doing. With this command you have the ability to write over all of the current RAM in the USB IO Board - including all variables that the firmware is using, and all of the Special Function Registers in the PIC. It can be a very handy thing, but use it with caution.

"PD" Command

The "PD" command stands for "Pin Direction". It allows you to set the direction on just one pin at a time. (Input or Output)
Format: "PD,<Port>,<Pin>,<Direction><CR>"
<Port>: This is the character "A", "B", or "C" depending upon which port you want to change.
<Pin>: This is a number between and including 0 to 7. It indicates which pin in the port you want to change the direction on.
<Direction>: This is either "0" or "1", for Output (0) or Input (1).
Example: "PD,B,2,1" - This would change Port B, pin 2 to an input.
Return Packet: "OK"

"PI" Command

The "PI" command stands for "Pin Input". It allows you to read the state of just one pin at a time. (High or Low)
Format: "PI,<Port>,<Pin><CR>"
<Port>: This is the character "A", "B", or "C" depending upon which port you want to change.
<Pin>: This is a number between and including 0 to 7. It indicates which pin in the port you want to change the direction on.
Example: "PI,C,6" - This would read the state of Port C pin 6.
Return Packet: "PI,<Value>"
<Value>: This is either a High (1) or a Low (0) depending upon the voltage on the pin at the time it was read.
Example Return Packet: "PI,1" (Means that the pin was high.)

"PO" Command

The "PO" command stands for "Pin Output". It allows you to set the output value (if it is currently set to be an output) on just one pin at a time. (High or Low)
Format: "PO,<Port>,<Pin>,<Value><CR>"
<Port>: This is the character "A", "B", or "C" depending upon which port you want to set.
<Pin>: This is a number between and including 0 to 7. It indicates which pin in the port for which you want to set the state.
<Value>: This is either "0" or "1", for Low (0) or High (1).
Example: "PD,A,3,0" - This would make Port A pin 3 low.
Return Packet: "OK"

"CU" Command

The "CU" command stands for "Configure USB IO Board". It is designed to be a generic command for setting things that affect the general operation of the USB IO Board.
Format: "CU,<Parameter>,<Value><CR>"
<Parameter>: This is an unsigned 8 bit value, representing the parameter number you wish to change. (See table below)
<Value>: This is a value who's meaning depends upon the <Parameter> number chosen.
Example: "CU,1,0" - This would turn off the sending of the "OK" packets after each command.
Return Packet: "OK"

<Parameter>	<Value>	<Value> meaning
1	0 or 1	0 = Turn off "OK" packets 1 = Turn on "OK" packets (default)

"RC" Command

The "RC" command stands for "RC Servo Output". It will turn any pin into an RC servo output, if that pin is already configured as a digital output.
Format: "RC,<Port>,<Pin>,<Value><CR>"
<Port>: This is the character "A", "B", or "C" depending upon which port you want to set.
<Pin>: This is a number between and including 0 to 7. It indicates which pin in the port for which you want to set the state. Note that some pins do not come out of the chip (RA6, RA7, RC3, RC4 and RC5), and some pins are not accessible via headers on IO Board (RC0, RC1, RC2). You can still set RC outputs on those pins, but the non-existent ones will just be skipped by the RC code, and if you set RC outputs on RC0, RC1 or RC2, you may see interesting results (since RC0 and RC1 have LEDs on them).
<Value>: This is a value between 0 and 11890.

A <Value> of 0 (zero) will turn the RC output (for that pin) completely off. A <Value> of 1 will cause a 1ms high pulse on the pin. A <Value> of 11890 will cause a 2ms high pulse on the pin. Any <Value> inbetween 1 and 11890 will cause a high pulse whose duration is proportionally between 1ms and 2ms. These pulses repeat every 19ms.

Example: "RC,B,3,5945" - If PortB pin 3 was already an output, then there would be a 1.5ms (which is 'center' to an RC servo) high pulse coming out of PortB pin 3 every 19ms.
Return Packet: "OK"
Note: This command allows you to have up to 16 independant RC servo outputs.

Binary Output Commands
The "BC", "BO" and "BS" commands all work together to allow for high speed parallel output to a hardware device like an LCD panel or other latched 8-bit parallel interface. The basic idea is to take a byte, write it out to PortB, set a strobe bit on PortA, wait a bit, then clear the strobe bit on PortA, then wait for a busy bit to go high (or low) on PortA, then wait for the busy bit to go low (or high) on PortA and then repeat for as many bytes as there are to send out PortB. So PortB is used as the output to the parallel bus and two bits on PortA are used as a strobe bit (output) and a busy bit (input).
The BC command sets up all of the parameters, and then the BO or BS commands stream the data out PortB. Before this scheme will be very successful, make sure to set the direction bits on PortB and PortA properly.

"BC" Command

The "BC" command stands for "Bulk Configure". It allows you to configure the options for the BO and BS commands.
Format: "BC,<Init>,<WaitMask>,<WaitDelay>,<StrobeMask>,<StrobeDelay>,<CR>"
<Init>: This is the inital value written to PortA.
<WaitMask>: Each bit that is set in this mask indicates a 'busy' bit coming back from the LCD (or other hardware). This value is only used if <WaitDelay> is not zero.
<WaitDelay>: The <WaitDelay> is the maximum amount of time to wait for the busy bit to become asserted, and then to become de-asserted. If <WaitDelay> expires, then the next byte is just sent out. <WaitDelay> is in units of about 400ns.
<StrobeMask>: Each bit that is set in this mask indicates the strobe bits that are to be inverted after the byte is written to PortB. When <StrobeDelay> is over, the initial value (<Init>) is written back to PortA.
<StrobeDelay>: The length of time that the strobe bits (from <StrobeMask>) are inverted from their intial values. <StrobeDelay> is in units of about 830ns.
Example: "BC,1,1,1,1,1"
Return Packet: "OK"

"BO" Command

The "BO" command stands for "Bulk Output". It uses the settings from the BC command and outputs bytes to PortB. PortA bits are used as control bits, with at least one used as a strobe output (indicating that a new byte is present on PortB) and an optional second PortA bit used as a 'busy' input to prevent the next byte from being sent out before the receiver is able to process it.
Format: "BO,<ASCII_HEX_Bytes><CR>"
<ASCII_HEX_Bytes>: This group of characters are the hexadecimal representation of the bytes that you whish to send out PortB. For example, if you wanted to send 3 bytes, of values 0x55, 0xA7 and 0x21, you would use "BO,55A721" as your command. The total length of this command must not be more than 63 bytes, so at most you can pack 30 bytes worth of ASCII hex characters into this command.
The way that the bytes get sent out PortB is by using the WaitMask, WaitDelay, StrobeMask, StrobeDelay and Init values from the BC command above. When the BC command is accepted, PortA will be initalized to the value in the <Init> parameter. Note that you must have already set up PortB as outputs and have the direction of each bit in PortA set up according to what you need. When it is time to output a byte (with the BO or BS commands), the chain of events is as follows:

The byte is output on PortB.
The bits that are high in the <StrobeMask> are inverted on PortA.
A delay is executed for <StrobeDelay> units (each unit is about 830ns)
The PortA is then returned to the <Init> value.
If <WaitDelay> is greater than zero,

Wait (up to <WaitDelay> units) for the busy bit to become the state it is in <Init>
Wait (up to <WaitDelay> units) for the busy bit to become the inverse of what it is in <Init>

Repeat

Example: "BO,55A721"
Return Packet: "OK"

"BS" Command
NOTE: (09/18/08) Greg Corson has pointed out a serious bug in this command in Firmware D 1.4.3. If you send any <CR> or <LF> bytes in the binary data section of them command, they get eaten by the command processing fuctions, and don't make it out to the I/O pins! This will get fixed in a future version.

The "BS" command stands for "Bulk Stream". It uses the settings from the BC command and streams raw binary bytes to PortB, just like the "BO" command does.
Format: "BC,<ByteCount>,<BinaryStreamOfBytes><CR>"
<ByteCount>: This is the number of bytes in <BinaryStreamOfBytes>. It must be an exact number, because this his how the USB IO Board knows when the end of <BinaryStreamOfBytes> is and when to begin looking for the <CR>. The range of acceptable values for <ByteCount> are from 1 to 56 inclusive.
<BinaryStreamOfBytes>: Must be exactly <BinaryStreamOfBytes> bytes long. This stream is the _binary_ (NOT ASCII) bytes that you want to send out PortB. In other words, if you wanted to send three bytes who's values are 0x23, 0x49 and 0x6A then the three bytes in <BinaryStreamOfBytes> would be "#Ij" and <ByteCount> would be 3. Note that since this is pure binary, it does not suffer from the lower bandwidth utilization that the "BO" command has (where each byte to be output is represented by two ASCII HEX bytes in the command string). But it is also more difficult to use because many of the characters inside the binary stream are not printable, and/or are difficult to generate with a terminal emulator.
Example: "BS,3,#Ij"
Return Packet: "OK"

Related Links