Mech - User contributions [en]

NScopeOld

2015-04-11T21:20:20Z

DavidMeyer: moved NScopeOld to NScope over redirect

#REDIRECT [[NScope]]

NScope

2015-04-11T21:20:20Z

DavidMeyer: moved NScopeOld to NScope over redirect

[[Image:nscope.jpg|[www.nscope.org | nscope.org]]

MATLAB DAQ and Pong files: [[Media:nScope_MATLAB_2014.zip | nScope_MATLAB_2014.zip]]

nScope info may be found at [http://nscope.org nscope.org]

NScope

2015-04-11T21:20:07Z

DavidMeyer: moved NScope to NScopeOld

[[Image:nscope.jpg|[www.nscope.org | nscope.org]]

MATLAB DAQ and Pong files: [[Media:nScope_MATLAB_2014.zip | nScope_MATLAB_2014.zip]]

nScope info may be found at [http://nscope.org nscope.org]

Main Page

2015-04-11T21:19:08Z

DavidMeyer:

[[Image:mechlab.jpg|right|thumb|[http://mechatronics.mech.northwestern.edu/ Northwestern Mechatronics Design Lab]]]

The Northwestern University mechatronics design wiki provides reference material on the theory and applications of electronics, sensors, actuators, etc., for use in mechatronics-related research and projects. Practical applications often refer to equipment and supplies available in the [http://mechatronics.mech.northwestern.edu/ Northwestern Mechatronics Design Lab].

The mechatronics wiki was initiated by undergraduate Ben Stephens in 2006, under the supervision of Profs. Kevin Lynch and Michael Peshkin. Since then, many students have contributed content.

Important: Please be sure to read the [http://mechatronics.mech.northwestern.edu/mech-rules.pdf Rules for Using the Mechatronics Design Lab].

(Here you can find the [[Old Index Page]] of the mechatronics wiki, as of May 2, 2009. That page is now obsolete, and new material should be indexed on the pages below. New pages may be indexed in multiple places.)

* [[Editing the mechatronics wiki]] (or visit [[The sandbox]] to practice your wiki skills)
* [[Electronics basics]]
* [[Sensors]]
* [[Actuators]]
* [[Communication]]
* Control computers and software
**[[Robot Club]]
**[[nScope]]
** [[Microchip PICs]]
** [[PC/104 stacks and Matlab xPC]]
** [[QNX]]
** [[Robot Operating System]]
** [[Processing]]
** [[Node.js]]
** [[Eagle]]
** [[KiCad]]
** [[C Compilers]]
* Courses
** [[DTC]]
** [[EDI Bootcamp]]
** [[ME 224 Experimental Engineering]]
** [[ME 333 Introduction to Mechatronics]]
*** [[ME 333 Readings, Videos, and Sample Code]]
*** [[ME 333 final projects]] (2010 and earlier)
** [http://www.mech.northwestern.edu/courses/descriptions/433-advanced-mechatronics.html ME 433 Advanced Mechatronics]
** [[Northwestern Design Competition]]
** [[ME 449 Robotic Manipulation]]
* [[Tools in the lab and shop]] (software, hardware, supplies, etc.)
* [[Vendors and Useful Links]]
* [[Projects and miscellaneous]] (projects, research, and other mechatronics-related info)

USB Communication Board

2012-10-01T18:52:05Z

DavidMeyer: /* Micro-controller Side */

''' ***Under Construction*** '''

= Overview =

The NU USB Communication Board is a universal communication board which serves as an interface between PCs and embedded systems. Using a PIC32MX250 chip, the board translates between USB HID communication and low-level microcontroller communication protocols, including RS232, I2C, and SPI. This board is useful in circumstances when fast, reliable communication is desired between a microcontroller and PC, but resources are not available on the microcontroller to run a full USB stack. The schematic and images of the copper traces are shown below.

{|
|-
| [[image:USB_Board_Schematic.png|thumb|400px|Board Schematic|none]]
| [[image:USB_Board_Top.png|thumb|160px|Top Copper|none]]
| [[image:USB_Board_Bottom.png|thumb|160px|Bottom Copper|none]]
|}

<br clear=all>

= Using the USB Communication Board =

The USB protocol used on this board operates in the HID class. This is beneficial because no drivers are required for any operating system, and low latency is guaranteed. The USB in operation on this board delivers 64 byte packets every millisecond in both directions. For this reason, all streaming data coming from the embedded side will be "packetized" by the board into 63 byte packets, using the first byte as a descriptor.

== Micro-controller Side ==

The board operates in one of four modes: RS232, RS232 with Hardware Flow Control, SPI, or I2C. This mode is selected upon board power-up by the CommSelect jumpers on board. The selection criteria are shown below

* No Jumpers - RS232
* CS1 Jumped - RS232 w/ Hardware Flow Control
* CS2 Jumped - SPI
* Both Jumped - I2C

=== RS232 ===

In RS232 mode, the communication board will read in any characters over the RS232 U1RX line and send them in 63 byte packets to the computer via USB. The zeroth byte of the USB 64-byte packet describes the length (N) of the data packet being sent to the computer, and has a maximum value of 63. Bytes 1 through N are filled with the pertinent data being sent to the computer. Bytes N+1 through 63 are meaningless. Each one of these packets is sent out every millisecond, for a maximum throughput of 63 kB/s.

Any packets received from the computer will be fed out the U1TX line. Again, the zeroth byte of the packet from the computer should contain the number of relevant bytes, as to not bog down the U1TX line with meaningless data.

=== RS232 w/ Hardware Flow Control ===

This mode operates under the same principle, but uses the U1RTS and U1CTS lines for flow control. This allows for higher baud-rates, and possibly higher-speed communication.

=== SPI ===

In development

=== I2C ===

In development

== PC Side ==

=== Processing ===

To send and receive USB packets in Processing on the computer, we use a Java Native Interface library which uses C libraries to communicate via USB. We have included the library in an example processing sketch for you, but if you're interested in using the Java library for something else, documentation and downloads for this library can be found [http://code.google.com/p/javahidapi/ here]. This is the template [[Media:USB_Processing_Template.zip|Processing sketch]] which simply listens for characters and prints them out in the text pane, and sends them back to the device. The code directory contains the .jar file containing the Java library. These files need to be here, but do not require editing.

In the sketch itself, the '''USBListener''' file defines a Thread which listens to the USB port. The function pic.read() will wait until the USB buffer is not empty, and then place the first-in data into the specified variable. This thread is also a good place to update all state variables and send out data to the PIC using pic.write(). The '''HIDManager''' file contains the code to connect and set up the USB communication with the PIC device. The NU USB Communication Board has product ID: 0, so the proper function call to open the pic is openPic(0);

Here is the API [[Media:Hidapi-1.1-javadoc.zip|documentation]], which explains what each function does.

=== Matlab ===

In development

== Source Code ==

9/4/2012 - [[Media:USB_COMM.X.zip|Source Project]]

File:USB Board Schematic.png

2012-09-09T16:56:23Z

DavidMeyer: uploaded a new version of "File:USB Board Schematic.png"

USB Communication Board

2012-09-09T16:49:43Z

DavidMeyer: /* Overview */

''' ***Under Construction*** '''

= Overview =

The NU USB Communication Board is a universal communication board which serves as an interface between PCs and embedded systems. Using a PIC32MX250 chip, the board translates between USB HID communication and low-level microcontroller communication protocols, including RS232, I2C, and SPI. This board is useful in circumstances when fast, reliable communication is desired between a microcontroller and PC, but resources are not available on the microcontroller to run a full USB stack. The schematic and images of the copper traces are shown below.

{|
|-
| [[image:USB_Board_Schematic.png|thumb|400px|Board Schematic|none]]
| [[image:USB_Board_Top.png|thumb|160px|Top Copper|none]]
| [[image:USB_Board_Bottom.png|thumb|160px|Bottom Copper|none]]
|}

<br clear=all>

= Using the USB Communication Board =

The USB protocol used on this board operates in the HID class. This is beneficial because no drivers are required for any operating system, and low latency is guaranteed. The USB in operation on this board delivers 64 byte packets every millisecond in both directions. For this reason, all streaming data coming from the embedded side will be "packetized" by the board into 63 byte packets, using the first byte as a descriptor.

== Micro-controller Side ==

The board operates in one of four modes: RS232, RS232 with Hardware Flow Control, SPI, or I2C. This mode is selected upon board power-up by the CommSelect jumpers on board. The selection criteria are shown below

* No Jumpers - RS232
* CS1 Jumped - RS232 w/ Hardware Flow Control
* CS2 Jumped - SPI
* Both Jumped - I2C

=== RS232 ===

In RS232 mode, the communication board will read in any characters over the RS232 U1RX line and send them in 63 byte packets to the computer via USB. The zeroth byte of the USB 64-byte packet describes the length (N) of the data packet being sent to the computer, and has a maximum value of 63. Bytes 1 through N are filled with the pertinent data being sent to the computer. Bytes N+1 through 63 are meaningless. Each one of these packets is sent out every millisecond, for a maximum throughput of 63 kB/s.

Any packets received from the computer will be fed out the U1TX line. Again, the zeroth byte of the packet from the computer should contain the number of relevant bytes, as to not bog down the U1TX line with meaningless data.

=== RS232 w/ Hardware Flow Control ===

This mode operates under the same principle, but uses the U1RTS and U1CTS lines for flow control. This allows for higher baud-rates, and possibly higher-speed communication.

=== SPI ===

Not yet implemented

=== I2C ===

Not yet implemented

== PC Side ==

=== Processing ===

To send and receive USB packets in Processing on the computer, we use a Java Native Interface library which uses C libraries to communicate via USB. We have included the library in an example processing sketch for you, but if you're interested in using the Java library for something else, documentation and downloads for this library can be found [http://code.google.com/p/javahidapi/ here]. This is the template [[Media:USB_Processing_Template.zip|Processing sketch]] which simply listens for characters and prints them out in the text pane, and sends them back to the device. The code directory contains the .jar file containing the Java library. These files need to be here, but do not require editing.

In the sketch itself, the '''USBListener''' file defines a Thread which listens to the USB port. The function pic.read() will wait until the USB buffer is not empty, and then place the first-in data into the specified variable. This thread is also a good place to update all state variables and send out data to the PIC using pic.write(). The '''HIDManager''' file contains the code to connect and set up the USB communication with the PIC device. The NU USB Communication Board has product ID: 0, so the proper function call to open the pic is openPic(0);

Here is the API [[Media:Hidapi-1.1-javadoc.zip|documentation]], which explains what each function does.

=== Matlab ===

In development

== Source Code ==

9/4/2012 - [[Media:USB_COMM.X.zip|Source Project]]

File:USB Board Bottom.png

2012-09-09T16:47:09Z

DavidMeyer:

File:USB Board Top.png

2012-09-09T16:40:50Z

DavidMeyer:

File:USB Board Schematic.png

2012-09-09T16:33:15Z

DavidMeyer:

USB Communication Board

2012-09-09T16:31:24Z

DavidMeyer:

''' ***Under Construction*** '''

= Overview =

The NU USB Communication Board is a universal communication board which serves as an interface between PCs and embedded systems. Using a PIC32MX250 chip, the board translates between USB HID communication and low-level microcontroller communication protocols, including RS232, I2C, and SPI. This board is useful in circumstances when fast, reliable communication is desired between a microcontroller and PC, but resources are not available on the microcontroller to run a full USB stack.

[[image:All-actuators-captions-small.jpg|thumb|300px|Available Actuators|right]]

= Using the USB Communication Board =

The USB protocol used on this board operates in the HID class. This is beneficial because no drivers are required for any operating system, and low latency is guaranteed. The USB in operation on this board delivers 64 byte packets every millisecond in both directions. For this reason, all streaming data coming from the embedded side will be "packetized" by the board into 63 byte packets, using the first byte as a descriptor.

== Micro-controller Side ==

The board operates in one of four modes: RS232, RS232 with Hardware Flow Control, SPI, or I2C. This mode is selected upon board power-up by the CommSelect jumpers on board. The selection criteria are shown below

* No Jumpers - RS232
* CS1 Jumped - RS232 w/ Hardware Flow Control
* CS2 Jumped - SPI
* Both Jumped - I2C

=== RS232 ===

In RS232 mode, the communication board will read in any characters over the RS232 U1RX line and send them in 63 byte packets to the computer via USB. The zeroth byte of the USB 64-byte packet describes the length (N) of the data packet being sent to the computer, and has a maximum value of 63. Bytes 1 through N are filled with the pertinent data being sent to the computer. Bytes N+1 through 63 are meaningless. Each one of these packets is sent out every millisecond, for a maximum throughput of 63 kB/s.

Any packets received from the computer will be fed out the U1TX line. Again, the zeroth byte of the packet from the computer should contain the number of relevant bytes, as to not bog down the U1TX line with meaningless data.

=== RS232 w/ Hardware Flow Control ===

This mode operates under the same principle, but uses the U1RTS and U1CTS lines for flow control. This allows for higher baud-rates, and possibly higher-speed communication.

=== SPI ===

Not yet implemented

=== I2C ===

Not yet implemented

== PC Side ==

=== Processing ===

To send and receive USB packets in Processing on the computer, we use a Java Native Interface library which uses C libraries to communicate via USB. We have included the library in an example processing sketch for you, but if you're interested in using the Java library for something else, documentation and downloads for this library can be found [http://code.google.com/p/javahidapi/ here]. This is the template [[Media:USB_Processing_Template.zip|Processing sketch]] which simply listens for characters and prints them out in the text pane, and sends them back to the device. The code directory contains the .jar file containing the Java library. These files need to be here, but do not require editing.

In the sketch itself, the '''USBListener''' file defines a Thread which listens to the USB port. The function pic.read() will wait until the USB buffer is not empty, and then place the first-in data into the specified variable. This thread is also a good place to update all state variables and send out data to the PIC using pic.write(). The '''HIDManager''' file contains the code to connect and set up the USB communication with the PIC device. The NU USB Communication Board has product ID: 0, so the proper function call to open the pic is openPic(0);

Here is the API [[Media:Hidapi-1.1-javadoc.zip|documentation]], which explains what each function does.

=== Matlab ===

In development

== Source Code ==

9/4/2012 - [[Media:USB_COMM.X.zip|Source Project]]

USB Communication Board

2012-09-07T20:11:31Z

DavidMeyer: /* Processing */

''' ***Under Construction*** '''

= Overview =

The NU USB Communication Board is a universal communication board which serves as an interface between PCs and embedded systems. Using a PIC32MX250 chip, the board translates between USB HID communication and low-level microcontroller communication protocols, including RS232, I2C, and SPI. This board is useful in circumstances when fast, reliable communication is desired between a microcontroller and PC, but resources are not available on the microcontroller to run a full USB stack.

= Using the USB Communication Board =

The USB protocol used on this board operates in the HID class. This is beneficial because no drivers are required for any operating system, and low latency is guaranteed. The USB in operation on this board delivers 64 byte packets every millisecond in both directions. For this reason, all streaming data coming from the embedded side will be "packetized" by the board into 63 byte packets, using the first byte as a descriptor.

== Micro-controller Side ==

The board operates in one of four modes: RS232, RS232 with Hardware Flow Control, SPI, or I2C. This mode is selected upon board power-up by the CommSelect jumpers on board. The selection criteria are shown below

* No Jumpers - RS232
* CS1 Jumped - RS232 w/ Hardware Flow Control
* CS2 Jumped - SPI
* Both Jumped - I2C

=== RS232 ===

In RS232 mode, the communication board will read in any characters over the RS232 U1RX line and send them in 63 byte packets to the computer via USB. The zeroth byte of the USB 64-byte packet describes the length (N) of the data packet being sent to the computer, and has a maximum value of 63. Bytes 1 through N are filled with the pertinent data being sent to the computer. Bytes N+1 through 63 are meaningless. Each one of these packets is sent out every millisecond, for a maximum throughput of 63 kB/s.

Any packets received from the computer will be fed out the U1TX line. Again, the zeroth byte of the packet from the computer should contain the number of relevant bytes, as to not bog down the U1TX line with meaningless data.

=== RS232 w/ Hardware Flow Control ===

This mode operates under the same principle, but uses the U1RTS and U1CTS lines for flow control. This allows for higher baud-rates, and possibly higher-speed communication.

=== SPI ===

Not yet implemented

=== I2C ===

Not yet implemented

== PC Side ==

=== Processing ===

To send and receive USB packets in Processing on the computer, we use a Java Native Interface library which uses C libraries to communicate via USB. We have included the library in an example processing sketch for you, but if you're interested in using the Java library for something else, documentation and downloads for this library can be found [http://code.google.com/p/javahidapi/ here]. This is the template [[Media:USB_Processing_Template.zip|Processing sketch]] which simply listens for characters and prints them out in the text pane, and sends them back to the device. The code directory contains the .jar file containing the Java library. These files need to be here, but do not require editing.

In the sketch itself, the '''USBListener''' file defines a Thread which listens to the USB port. The function pic.read() will wait until the USB buffer is not empty, and then place the first-in data into the specified variable. This thread is also a good place to update all state variables and send out data to the PIC using pic.write(). The '''HIDManager''' file contains the code to connect and set up the USB communication with the PIC device. The NU USB Communication Board has product ID: 0, so the proper function call to open the pic is openPic(0);

Here is the API [[Media:Hidapi-1.1-javadoc.zip|documentation]], which explains what each function does.

=== Matlab ===

In development

== Source Code ==

9/4/2012 - [[Media:USB_COMM.X.zip|Source Project]]

USB Communication Board

2012-09-07T20:10:41Z

DavidMeyer: /* Processing */

''' ***Under Construction*** '''

= Overview =

The NU USB Communication Board is a universal communication board which serves as an interface between PCs and embedded systems. Using a PIC32MX250 chip, the board translates between USB HID communication and low-level microcontroller communication protocols, including RS232, I2C, and SPI. This board is useful in circumstances when fast, reliable communication is desired between a microcontroller and PC, but resources are not available on the microcontroller to run a full USB stack.

= Using the USB Communication Board =

The USB protocol used on this board operates in the HID class. This is beneficial because no drivers are required for any operating system, and low latency is guaranteed. The USB in operation on this board delivers 64 byte packets every millisecond in both directions. For this reason, all streaming data coming from the embedded side will be "packetized" by the board into 63 byte packets, using the first byte as a descriptor.

== Micro-controller Side ==

The board operates in one of four modes: RS232, RS232 with Hardware Flow Control, SPI, or I2C. This mode is selected upon board power-up by the CommSelect jumpers on board. The selection criteria are shown below

* No Jumpers - RS232
* CS1 Jumped - RS232 w/ Hardware Flow Control
* CS2 Jumped - SPI
* Both Jumped - I2C

=== RS232 ===

In RS232 mode, the communication board will read in any characters over the RS232 U1RX line and send them in 63 byte packets to the computer via USB. The zeroth byte of the USB 64-byte packet describes the length (N) of the data packet being sent to the computer, and has a maximum value of 63. Bytes 1 through N are filled with the pertinent data being sent to the computer. Bytes N+1 through 63 are meaningless. Each one of these packets is sent out every millisecond, for a maximum throughput of 63 kB/s.

Any packets received from the computer will be fed out the U1TX line. Again, the zeroth byte of the packet from the computer should contain the number of relevant bytes, as to not bog down the U1TX line with meaningless data.

=== RS232 w/ Hardware Flow Control ===

This mode operates under the same principle, but uses the U1RTS and U1CTS lines for flow control. This allows for higher baud-rates, and possibly higher-speed communication.

=== SPI ===

Not yet implemented

=== I2C ===

Not yet implemented

== PC Side ==

=== Processing ===

To send and receive USB packets in Processing on the computer, we use a Java Native Interface library which uses C libraries to communicate via USB. We have included the library in an example processing sketch for you, but if you're interested in using the Java library for something else, documentation and downloads for this library can be found [http://code.google.com/p/javahidapi/ here]. This is the template [[Media:USB_Processing_Template.zip|Processing sketch]] which simply listens for characters and prints them out in the text pane, and sends them back to the device. The code directory contains the .jar file containing the Java library. These files need to be here, but do not require editing.

In the sketch itself, the '''USBListener''' file defines a Thread which listens to the USB port. The function pic.read() will wait until the USB buffer is not empty, and then place the first-in data into the specified variable. This thread is also a good place to update all state variables and send out data to the PIC using pic.write(). The '''HIDManager''' file contains the code to connect and set up the . This class defines callback functions which are called whenever a device is added or removed.

Here is the API [[Media:Hidapi-1.1-javadoc.zip|documentation]], which explains what each function does.

=== Matlab ===

In development

== Source Code ==

9/4/2012 - [[Media:USB_COMM.X.zip|Source Project]]

File:Hidapi-1.1-javadoc.zip

2012-09-07T20:05:17Z

DavidMeyer: Java Documentation for the HID API library. Version 1.1

Java Documentation for the HID API library. Version 1.1

USB Communication Board

2012-09-07T20:03:39Z

DavidMeyer: /* Processing */

''' ***Under Construction*** '''

= Overview =

The NU USB Communication Board is a universal communication board which serves as an interface between PCs and embedded systems. Using a PIC32MX250 chip, the board translates between USB HID communication and low-level microcontroller communication protocols, including RS232, I2C, and SPI. This board is useful in circumstances when fast, reliable communication is desired between a microcontroller and PC, but resources are not available on the microcontroller to run a full USB stack.

= Using the USB Communication Board =

The USB protocol used on this board operates in the HID class. This is beneficial because no drivers are required for any operating system, and low latency is guaranteed. The USB in operation on this board delivers 64 byte packets every millisecond in both directions. For this reason, all streaming data coming from the embedded side will be "packetized" by the board into 63 byte packets, using the first byte as a descriptor.

== Micro-controller Side ==

The board operates in one of four modes: RS232, RS232 with Hardware Flow Control, SPI, or I2C. This mode is selected upon board power-up by the CommSelect jumpers on board. The selection criteria are shown below

* No Jumpers - RS232
* CS1 Jumped - RS232 w/ Hardware Flow Control
* CS2 Jumped - SPI
* Both Jumped - I2C

=== RS232 ===

In RS232 mode, the communication board will read in any characters over the RS232 U1RX line and send them in 63 byte packets to the computer via USB. The zeroth byte of the USB 64-byte packet describes the length (N) of the data packet being sent to the computer, and has a maximum value of 63. Bytes 1 through N are filled with the pertinent data being sent to the computer. Bytes N+1 through 63 are meaningless. Each one of these packets is sent out every millisecond, for a maximum throughput of 63 kB/s.

Any packets received from the computer will be fed out the U1TX line. Again, the zeroth byte of the packet from the computer should contain the number of relevant bytes, as to not bog down the U1TX line with meaningless data.

=== RS232 w/ Hardware Flow Control ===

This mode operates under the same principle, but uses the U1RTS and U1CTS lines for flow control. This allows for higher baud-rates, and possibly higher-speed communication.

=== SPI ===

Not yet implemented

=== I2C ===

Not yet implemented

== PC Side ==

=== Processing ===

To send and receive USB packets in Processing on the computer, we use a Java Native Interface library which uses C libraries to communicate via USB. We have included the library in an example processing sketch for you, but if you're interested in using the Java library for something else, documentation and downloads for this library can be found [http://code.google.com/p/javahidapi/ here]. This is the template [[Media:USB_Processing_Template.zip|Processing sketch]] which simply listens for characters and prints them out in the text pane, and sends them back to the device. The code directory contains the .jar file containing the Java library. These files need to be here, but do not require editing.

In the sketch itself, the '''USBListener''' file defines a Thread which listens to the USB port. The function pic.read() will wait until the USB buffer is not empty, and then place the first-in data into the specified variable. This thread is also a good place to update all state variables and send out data to the PIC using pic.write(). The '''HIDManager''' file contains the code to connect and set up the . This class defines callback functions which are called whenever a device is added or removed.

Here is the API [[Nope|documentation]], which explains what each function does.

=== Matlab ===

In development

== Source Code ==

9/4/2012 - [[Media:USB_COMM.X.zip|Source Project]]

File:USB Processing Template.zip

2012-09-07T20:03:01Z

DavidMeyer: Template for developing USB communication code in Processing

Template for developing USB communication code in Processing

USB Communication Board

2012-09-07T20:01:41Z

DavidMeyer: /* Processing */

''' ***Under Construction*** '''

= Overview =

The NU USB Communication Board is a universal communication board which serves as an interface between PCs and embedded systems. Using a PIC32MX250 chip, the board translates between USB HID communication and low-level microcontroller communication protocols, including RS232, I2C, and SPI. This board is useful in circumstances when fast, reliable communication is desired between a microcontroller and PC, but resources are not available on the microcontroller to run a full USB stack.

= Using the USB Communication Board =

The USB protocol used on this board operates in the HID class. This is beneficial because no drivers are required for any operating system, and low latency is guaranteed. The USB in operation on this board delivers 64 byte packets every millisecond in both directions. For this reason, all streaming data coming from the embedded side will be "packetized" by the board into 63 byte packets, using the first byte as a descriptor.

== Micro-controller Side ==

The board operates in one of four modes: RS232, RS232 with Hardware Flow Control, SPI, or I2C. This mode is selected upon board power-up by the CommSelect jumpers on board. The selection criteria are shown below

* No Jumpers - RS232
* CS1 Jumped - RS232 w/ Hardware Flow Control
* CS2 Jumped - SPI
* Both Jumped - I2C

=== RS232 ===

In RS232 mode, the communication board will read in any characters over the RS232 U1RX line and send them in 63 byte packets to the computer via USB. The zeroth byte of the USB 64-byte packet describes the length (N) of the data packet being sent to the computer, and has a maximum value of 63. Bytes 1 through N are filled with the pertinent data being sent to the computer. Bytes N+1 through 63 are meaningless. Each one of these packets is sent out every millisecond, for a maximum throughput of 63 kB/s.

Any packets received from the computer will be fed out the U1TX line. Again, the zeroth byte of the packet from the computer should contain the number of relevant bytes, as to not bog down the U1TX line with meaningless data.

=== RS232 w/ Hardware Flow Control ===

This mode operates under the same principle, but uses the U1RTS and U1CTS lines for flow control. This allows for higher baud-rates, and possibly higher-speed communication.

=== SPI ===

Not yet implemented

=== I2C ===

Not yet implemented

== PC Side ==

=== Processing ===

To send and receive USB packets in Processing on the computer, we use a Java Native Interface library which uses C libraries to communicate via USB. We have included the library in an example processing sketch for you, but if you're interested in using the Java library for something else, documentation and downloads for this library can be found [http://code.google.com/p/javahidapi/ here]. This is the template [[Nope|Processing sketch]] which simply listens for characters and prints them out in the text pane, and sends them back to the device. The code directory contains the .jar file containing the Java library. These files need to be here, but do not require editing.

In the sketch itself, the '''USBListener''' file defines a Thread which listens to the USB port. The function pic.read() will wait until the USB buffer is not empty, and then place the first-in data into the specified variable. This thread is also a good place to update all state variables and send out data to the PIC using pic.write(). The '''HIDManager''' file contains the code to connect and set up the . This class defines callback functions which are called whenever a device is added or removed.

Here is the API [[Nope|documentation]], which explains what each function does.

=== Matlab ===

In development

== Source Code ==

9/4/2012 - [[Media:USB_COMM.X.zip|Source Project]]

USB Communication Board

2012-09-07T19:54:32Z

DavidMeyer:

''' ***Under Construction*** '''

= Overview =

The NU USB Communication Board is a universal communication board which serves as an interface between PCs and embedded systems. Using a PIC32MX250 chip, the board translates between USB HID communication and low-level microcontroller communication protocols, including RS232, I2C, and SPI. This board is useful in circumstances when fast, reliable communication is desired between a microcontroller and PC, but resources are not available on the microcontroller to run a full USB stack.

= Using the USB Communication Board =

The USB protocol used on this board operates in the HID class. This is beneficial because no drivers are required for any operating system, and low latency is guaranteed. The USB in operation on this board delivers 64 byte packets every millisecond in both directions. For this reason, all streaming data coming from the embedded side will be "packetized" by the board into 63 byte packets, using the first byte as a descriptor.

== Micro-controller Side ==

The board operates in one of four modes: RS232, RS232 with Hardware Flow Control, SPI, or I2C. This mode is selected upon board power-up by the CommSelect jumpers on board. The selection criteria are shown below

* No Jumpers - RS232
* CS1 Jumped - RS232 w/ Hardware Flow Control
* CS2 Jumped - SPI
* Both Jumped - I2C

=== RS232 ===

In RS232 mode, the communication board will read in any characters over the RS232 U1RX line and send them in 63 byte packets to the computer via USB. The zeroth byte of the USB 64-byte packet describes the length (N) of the data packet being sent to the computer, and has a maximum value of 63. Bytes 1 through N are filled with the pertinent data being sent to the computer. Bytes N+1 through 63 are meaningless. Each one of these packets is sent out every millisecond, for a maximum throughput of 63 kB/s.

Any packets received from the computer will be fed out the U1TX line. Again, the zeroth byte of the packet from the computer should contain the number of relevant bytes, as to not bog down the U1TX line with meaningless data.

=== RS232 w/ Hardware Flow Control ===

This mode operates under the same principle, but uses the U1RTS and U1CTS lines for flow control. This allows for higher baud-rates, and possibly higher-speed communication.

=== SPI ===

Not yet implemented

=== I2C ===

Not yet implemented

== PC Side ==

=== Processing ===

To send and receive USB packets in Processing on the computer, we use a Java Native Interface library which uses C libraries to communicate via USB. We have included the library in the processing sketch for you, but if you're interested in using the Java library for something else, documentation and downloads for this library can be found [http://code.google.com/p/javahidapi/ here]. This is the template [[Nope|Processing sketch]] which simply listens for characters and prints them out in the text pane. Any character that is typed into the box will be sent to over USB to the connected device. The code directory contains the .jar file containing the Java library. These files need to be here, but do not require editing.

In the sketch itself, the '''USBListener''' file defines a Thread which listens to the USB port. The function pic.read() will wait until the USB buffer is not empty, and then place the first-in data into the specified variable. This thread is also a good place to update all state variables and send out data to the PIC using pic.write(). The '''HIDManager''' file contains the code to connect and set up the . This class defines callback functions which are called whenever a device is added or removed.

Here is the API [[Nope|documentation]], which explains what each function does.

=== Matlab ===

In development

== Source Code ==

9/4/2012 - [[Media:USB_COMM.X.zip|Source Project]]

USB Communication Board

2012-09-04T22:55:03Z

DavidMeyer: /* Source Code */

''' ***Under Construction*** '''

== Overview ==

The NU USB Communication Board is a universal communication board which serves as an interface between PCs and embedded systems. Using a PIC32MX250 chip, the board translates between USB HID communication and low-level microcontroller communication protocols, including RS232, I2C, and SPI. This board is useful in circumstances when fast, reliable communication is desired between a microcontroller and PC, but resources are not available on the microcontroller to run a full USB stack.

== Using the USB Communication Board ==

The board operates in one of four modes: RS232, RS232 with Hardware Flow Control, SPI, or I2C. This mode is selected upon board power-up by the CommSelect jumpers on board. The selection criteria are shown below

* No Jumpers - RS232
* CS1 Jumped - RS232 w/ Hardware Flow Control
* CS2 Jumped - SPI
* Both Jumped - I2C

=== RS232 ===

In RS232 mode, the communication board will read in any characters over the RS232 U1RX line and send them in 63 byte packets to the computer via USB. The zeroth byte of the USB 64-byte packet describes the length (N) of the data packet being sent to the computer, and has a maximum value of 63. Bytes 1 through N are filled with the pertinent data being sent to the computer. Bytes N+1 through 63 are meaningless. Each one of these packets is sent out every millisecond, for a maximum throughput of 63 kB/s.

Any packets received from the computer will be fed out the U1TX line. Again, the zeroth byte of the packet from the computer should contain the number of relevant bytes, as to not bog down the U1TX line with meaningless data.

=== RS232 w/ Hardware Flow Control ===

This mode operates under the same principle, but uses the U1RTS and U1CTS lines for flow control. This allows for higher baud-rates, and possibly higher-speed communication.

=== SPI ===

Not yet implemented

=== I2C ===

Not yet implemented

== Source Code ==

9/4/2012 - [[Media:USB_COMM.X.zip|Source Project]]

File:USB COMM.X.zip

2012-09-04T22:49:33Z

DavidMeyer: Source code for the USB Communication Board - 9/4/2012

Source code for the USB Communication Board - 9/4/2012

USB Communication Board

2012-09-04T22:45:25Z

DavidMeyer:

USB Communication Board

2012-09-04T22:25:59Z

DavidMeyer:

USB Communication Board

2012-09-04T22:14:39Z

DavidMeyer:

=== ***Under Construction*** ===

The NU USB Communication Board is a universal communication board which serves as an interface between PCs and embedded systems.

== Using the USB Communication Board ==

USB Communication Board

2012-09-04T22:08:30Z

DavidMeyer: Created page with "'''Under Construction'''"

'''Under Construction'''

USB Communication using PIC microcontrollers

2012-09-04T21:57:48Z

DavidMeyer:

==USB Overview==

Universal Serial Bus, or USB, is a very common method of communication between electronic devices. USB is universal, meaning that it's standard across all electronic devices, serial, meaning that data is transmitted on only one data line one bit at a time, and is a bus, meaning that all devices are connected through the same parallel electronic wires and therefore require addresses. A simple USB connection requires a host and a device. The host initiates all communication, assigns device addresses, and controls the flow of the data line in the connection. For our purposes, the USB host will be the PC and the USB device will be a PIC chip.

There are many different speeds associated with USB. USB 1.0 introduced data rates of 1.5 Mbits/s ('''Low-Speed''') and 12 Mbits/s ('''Full-Speed'''). With USB 2.0 and 3.0, data rates of 480 Mbits/s ('''Hi-Speed''') and 5 Gbits/s ('''Super-Speed'''), were added respectively. PIC chips have hardware capable of full speed USB.

===Hardware===

A USB cable has 4 wires: power (red), ground (black), D+ (green), and D- (white). You may notice that many USB plugs and receptacles have 5 pins. This fifth pin is called ID, and is often not connected, but has been added to the specifications for use with USB-OTG, or On-The-Go. OTG allows devices to also act as a host. Many PIC chips are compatible with USB-OTG communication, but we will not discuss this topic any further at this point.

The two data lines, D+ and D-, provide information about the state of the USB link.

*Detached State, or SE0 - device is unplugged, both data lines are low, pulled down by 15 kOhm resistors within the host hardware.
*Attached State, Idle State, or J State - the device pulls up the D+ line (for a high-speed device) when it is attached.
*K State - opposite polarity from J State. To communicate, the host or device alternates the device between the J and K states in specific patterns.
*Illegal State, or SE1 - both data lines are high. If this happens, there is a hardware problem with the USB link.

===Protocol===

Useful Links
[http://www.usb.org/developers/devclass_docs/HID1_11.pdf HID Specification]
[http://www.usbmadesimple.co.uk/index.html USB Made Simple]

==Microchip USB Stack==

Microchip has provided almost all of the code and examples to run USB code on PIC chips. This code is called the USB stack, and we will use this as the main library for communicating to PCs. Unfortunately, there are a few bugs for certain PIC chips and some quirks to getting the libraries setup in MPLAB. This section will document the steps necessary to install the USB stack and setup a proper programming environment in MPLAB.

===Installation===

====Download====

We'll begin with the assumption that the reader knows how to setup a project for a PIC chip in MPLAB and program their chip with some basic C code. The Microchip USB stack is a part of the Microchip Application Libraries, which are available at the Microchip website [http://www.microchip.com/MAL/ here].

You must download and install the entire Application Libraries package, which will place all the libraries in your C drive on a Windows machine and some other place ('''**FIND OUT WHERE**''') on a Mac. The name of the root directory should be something like "Microchip Solutions v2012...", but from here on out, we'll refer to the root directory of that installation as <MAL>.

====Include Libraries and Driver in Project====

Once the installer has finished running, the actual USB stack is located at <MAL>/Microchip/USB. <MAL>/USB is not the stack, and only contains demos of the firmware for learning purposes. We will not be using any of those files for our purposes. After starting a project in MPLAB for your PIC chip, you must complete the following steps:

*Include the USB libraries in your project
**In MPLAB X, right-click on your project and select properties. In the left-sidebar, click on your compiler (pic32-gcc for PIC32 chips). In the main window, find the field called "Include Directories" and click the button with "..." Add the directories <MAL>/Microchip/USB, <MAL>/Microchip/Include, and '''importantly''' your ''current project directory''. This last one is important because the stack references a Hardware Profile which we will include in our own project directory.
*Add the HID device drivers to your project
**In MPLAB X, right-click on your project source files and select "add existing..." Browse to <MAL>/Microchip/USB and add '''usb_device.c''' and '''./HID Device Driver/usb_function_hid.c'''. These files do not need to be moved to your project directory, they just need to be added into your project via MPLAB.

====Add Application-Specific USB files====

Two additional header files and two additional source files specific to each application are required for the microcontroller to be fully USB functional.

*usb_config.h - provides configuration details for the mode of USB operation
*HardwareProfile.h - gives information about the specific microcontroller we're using
*usb_descriptors.c - defines all the descriptors used to tell the Host PC what kind of USB device we're connecting
*usb_callbacks.c - defines all callback functions executed when the driver detects certain conditions in the connection

The file attached below is a zip containing examples of these four files. This example provides generic USB HID operation under Microchip's VendorID (1240) and a ProductID of 0, operating in USB_INTERRUPT mode (described below).

[[Media:PIC32_USB_Files.zip|PIC32_USB_Files]]

=== Microchip Stack Bug Notes ===

For the pic32mx2xx series, the usb interrupts are not configured correctly in the Microchip stack, so the following changes need to be made.

'''In <MAL>/Microchip/Include/usb_hal_pic32.h (Line 365):'''

This section normally sets the bits to configure IPC11, the USB interrupt location, but on the pic32mx2xx series, the USB interrupt bits are located at IPC7, as detailed in the Interrupt Controller chapter of the PIC datasheet. We've added a precompiler if statement to detect if a specific chip is being used. It's simple to change this for your specific chip though.

#if defined(USB_INTERRUPT)
// This is edited for use with the PIC32MX250F128B
#ifdef __32MX250F128B__
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC7CLR=0x00FF0000;IPC7SET=0x00100000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#else
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC11CLR=0x0000FF00;IPC11SET=0x00001000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#endif
#else
#define USBEnableInterrupts()
#endif

'''In <MAL>/Microchip/USB/usb_device.c (Line 673)'''
The Microchip stack assumes that the USB interrupt vector is 45 but this has changed to 30 for the pic32mx2xx series.

The line:
void __attribute__((interrupt(),vector(45))) _USB1Interrupt( void )

Should be:
void __attribute__((interrupt(),vector(_USB_1_VECTOR))) _USB1Interrupt( void )

=== USB Hardware Notes ===

It is important to use an external clock or oscillator in order to use the USB module. A 48 MHz clock is required for proper operation. The clock configuration can be seen in the data sheet, but for the pic32mx2xx series a 4 Mhz clock is required before the USB PLL. Since I am using a 20MHz external clock, we use these lines to set DEVCFG2 to proper values.
#pragma config UPLLEN = ON // USB PLL Enable
#pragma config UPLLIDIV = DIV_5 // USB PLL Divider
// 20MHz / 5 * 24 / 2 = 48MHz

=== USB Stack Operation ===

A function called USBDeviceTasks() defined in usb_device.c handles USB events, host requests, and enumeration. This function must be called every ~1.8ms during enumeration, and at specific intervals during other operation. This timing can be faster than the minimum with no hitch, but slower causes failure in communication. The stack may operate in two modes, USB_POLLING, or USB_INTERRUPT as defined in usb_config.h.

USB_POLLING requires the developer to call USBDeviceTasks() manually faster than the minimum rate, whereas USB_INTERRUPT handles all timing automatically. In the demo, we use USB_INTERRUPT to handle this timing.

Below is some sample code in the while loop of a main function of PIC communicating via USB.
while(1){
if((USBGetDeviceState() < CONFIGURED_STATE) ||
(USBIsDeviceSuspended() == TRUE))
{
//Either the device is not configured or we are suspended,
// so we don't want to execute any USB related application code
continue; //go back to the top of the while loop
}
if(!HIDRxHandleBusy(USBOutHandle)) //Check if data was received from the host.
{
//Do something with the data
ToSendDataBuffer[0] = ReceivedDataBuffer[0];
//Re-arm the OUT endpoint for the next packet
USBOutHandle = HIDRxPacket(HID_EP,(BYTE*)&ReceivedDataBuffer,64);
}
if(!HIDTxHandleBusy(USBInHandle)){
// Send out new data
USBInHandle = HIDTxPacket(HID_EP,(BYTE*)&ToSendDataBuffer[0],64);
}
}

===Demo===

This [[Media:USBExample.zip|MPLABX Project Directory]] is an example project written for the PIC32MX250F128B.

This demo communicated with the processing demo explained below, using the 28-DIP package for the pic32 and the following pinout.

*Pin01 - MCLR
*Pin03 - Configured for OC2, connected to an LED
*Pin04 - PGED1
*Pin05 - PGEC1
*Pin07 - Configured for AN5, reads analog voltage from potentiometer
*Pin08 - Vss
*Pin09 - External Clock, running at 20MHz
*Pin12 - Configured for digital in, reads switch state
*Pin13 - Vdd
*Pin15 - Vbus, connected to USB 5 Volt line
*Pin16 - Configured for digital out, connected to an LED
*Pin18 - Configured for OC3, connected to an LED
*Pin19 - Vss
*Pin20 - Vcap, 10nF capacitor to Vss
*Pin21 - USB, D+
*Pin22 - USB, D-
*Pin23 - Vusb, 3.3V
*Pin27 - AVss, 10nF capacitor to AVdd
*Pin28 - AVdd, 3.3V

==Processing and the HID API==

To send and receive USB packets in Processing on the computer, we use a Java Native Interface library which uses C libraries to communicate via USB. Documentation and downloads for this library can be found [http://code.google.com/p/javahidapi/ here]. This is the [[Media:Processing_USBExample.zip|Processing sketch]] used to interface with the demo board described above.

The code directory contains both the .jar file containing the Java library, and the .dll, .jnilib, and .so files containing the native USB libraries. These files need to be here, but do not require editing.

In the sketch itself, the '''USBListener''' file defines a Thread which listens to the USB port. The function pic.read() will wait until the USB buffer is not empty, and then place the first-in data into the specified variable. This thread is also a good place to update all state variables and send out data to the PIC using pic.write(). The '''HIDManager''' extends the HIDManager class defined in the API. This class defines callback functions which are called whenever a device is added or removed.

The main file includes the typical functions, setup() and draw(), as well as an openPic() function used to search the computer for a connected PIC microcontroller and open it for communication.

Here is the API [[Media:HIDAPI.zip|documentation]], which explains what each function does.

==Matlab and the HID API==

USB Communication using PIC microcontrollers

2012-07-09T18:17:53Z

DavidMeyer:

'''***Under Construction***'''

==USB Overview==

Universal Serial Bus, or USB, is a very common method of communication between electronic devices. USB is universal, meaning that it's standard across all electronic devices, serial, meaning that data is transmitted on only one data line one bit at a time, and is a bus, meaning that all devices are connected through the same parallel electronic wires and therefore require addresses. A simple USB connection requires a host and a device. The host initiates all communication, assigns device addresses, and controls the flow of the data line in the connection. For our purposes, the USB host will be the PC and the USB device will be a PIC chip.

There are many different speeds associated with USB. USB 1.0 introduced data rates of 1.5 Mbits/s ('''Low-Speed''') and 12 Mbits/s ('''Full-Speed'''). With USB 2.0 and 3.0, data rates of 480 Mbits/s ('''Hi-Speed''') and 5 Gbits/s ('''Super-Speed'''), were added respectively. PIC chips have hardware capable of full speed USB.

===Hardware===

A USB cable has 4 wires: power (red), ground (black), D+ (green), and D- (white). You may notice that many USB plugs and receptacles have 5 pins. This fifth pin is called ID, and is often not connected, but has been added to the specifications for use with USB-OTG, or On-The-Go. OTG allows devices to also act as a host. Many PIC chips are compatible with USB-OTG communication, but we will not discuss this topic any further at this point.

The two data lines, D+ and D-, provide information about the state of the USB link.

*Detached State, or SE0 - device is unplugged, both data lines are low, pulled down by 15 kOhm resistors within the host hardware.
*Attached State, Idle State, or J State - the device pulls up the D+ line (for a high-speed device) when it is attached.
*K State - opposite polarity from J State. To communicate, the host or device alternates the device between the J and K states in specific patterns.
*Illegal State, or SE1 - both data lines are high. If this happens, there is a hardware problem with the USB link.

===Protocol===

Useful Links
[http://www.usb.org/developers/devclass_docs/HID1_11.pdf HID Specification]
[http://www.usbmadesimple.co.uk/index.html USB Made Simple]

==Microchip USB Stack==

Microchip has provided almost all of the code and examples to run USB code on PIC chips. This code is called the USB stack, and we will use this as the main library for communicating to PCs. Unfortunately, there are a few bugs for certain PIC chips and some quirks to getting the libraries setup in MPLAB. This section will document the steps necessary to install the USB stack and setup a proper programming environment in MPLAB.

===Installation===

====Download====

We'll begin with the assumption that the reader knows how to setup a project for a PIC chip in MPLAB and program their chip with some basic C code. The Microchip USB stack is a part of the Microchip Application Libraries, which are available at the Microchip website [http://www.microchip.com/MAL/ here].

You must download and install the entire Application Libraries package, which will place all the libraries in your C drive on a Windows machine and some other place ('''**FIND OUT WHERE**''') on a Mac. The name of the root directory should be something like "Microchip Solutions v2012...", but from here on out, we'll refer to the root directory of that installation as <MAL>.

====Include Libraries and Driver in Project====

Once the installer has finished running, the actual USB stack is located at <MAL>/Microchip/USB. <MAL>/USB is not the stack, and only contains demos of the firmware for learning purposes. We will not be using any of those files for our purposes. After starting a project in MPLAB for your PIC chip, you must complete the following steps:

*Include the USB libraries in your project
**In MPLAB X, right-click on your project and select properties. In the left-sidebar, click on your compiler (pic32-gcc for PIC32 chips). In the main window, find the field called "Include Directories" and click the button with "..." Add the directories <MAL>/Microchip/USB, <MAL>/Microchip/Include, and '''importantly''' your ''current project directory''. This last one is important because the stack references a Hardware Profile which we will include in our own project directory.
*Add the HID device drivers to your project
**In MPLAB X, right-click on your project source files and select "add existing..." Browse to <MAL>/Microchip/USB and add '''usb_device.c''' and '''./HID Device Driver/usb_function_hid.c'''. These files do not need to be moved to your project directory, they just need to be added into your project via MPLAB.

====Add Application-Specific USB files====

Two additional header files and two additional source files specific to each application are required for the microcontroller to be fully USB functional.

*usb_config.h - provides configuration details for the mode of USB operation
*HardwareProfile.h - gives information about the specific microcontroller we're using
*usb_descriptors.c - defines all the descriptors used to tell the Host PC what kind of USB device we're connecting
*usb_callbacks.c - defines all callback functions executed when the driver detects certain conditions in the connection

The file attached below is a zip containing examples of these four files. This example provides generic USB HID operation under Microchip's VendorID (1240) and a ProductID of 0, operating in USB_INTERRUPT mode (described below).

[[Media:PIC32_USB_Files.zip|PIC32_USB_Files]]

=== Microchip Stack Bug Notes ===

For the pic32mx2xx series, the usb interrupts are not configured correctly in the Microchip stack, so the following changes need to be made.

'''In <MAL>/Microchip/Include/usb_hal_pic32.h (Line 365):'''

This section normally sets the bits to configure IPC11, the USB interrupt location, but on the pic32mx2xx series, the USB interrupt bits are located at IPC7, as detailed in the Interrupt Controller chapter of the PIC datasheet. We've added a precompiler if statement to detect if a specific chip is being used. It's simple to change this for your specific chip though.

#if defined(USB_INTERRUPT)
// This is edited for use with the PIC32MX250F128B
#ifdef __32MX250F128B__
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC7CLR=0x00FF0000;IPC7SET=0x00100000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#else
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC11CLR=0x0000FF00;IPC11SET=0x00001000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#endif
#else
#define USBEnableInterrupts()
#endif

'''In <MAL>/Microchip/USB/usb_device.c (Line 673)'''
The Microchip stack assumes that the USB interrupt vector is 45 but this has changed to 30 for the pic32mx2xx series.

The line:
void __attribute__((interrupt(),vector(45))) _USB1Interrupt( void )

Should be:
void __attribute__((interrupt(),vector(_USB_1_VECTOR))) _USB1Interrupt( void )

=== USB Hardware Notes ===

It is important to use an external clock or oscillator in order to use the USB module. A 48 MHz clock is required for proper operation. The clock configuration can be seen in the data sheet, but for the pic32mx2xx series a 4 Mhz clock is required before the USB PLL. Since I am using a 20MHz external clock, we use these lines to set DEVCFG2 to proper values.
#pragma config UPLLEN = ON // USB PLL Enable
#pragma config UPLLIDIV = DIV_5 // USB PLL Divider
// 20MHz / 5 * 24 / 2 = 48MHz

=== USB Stack Operation ===

A function called USBDeviceTasks() defined in usb_device.c handles USB events, host requests, and enumeration. This function must be called every ~1.8ms during enumeration, and at specific intervals during other operation. This timing can be faster than the minimum with no hitch, but slower causes failure in communication. The stack may operate in two modes, USB_POLLING, or USB_INTERRUPT as defined in usb_config.h.

USB_POLLING requires the developer to call USBDeviceTasks() manually faster than the minimum rate, whereas USB_INTERRUPT handles all timing automatically. In the demo, we use USB_INTERRUPT to handle this timing.

Below is some sample code in the while loop of a main function of PIC communicating via USB.
while(1){
if((USBGetDeviceState() < CONFIGURED_STATE) ||
(USBIsDeviceSuspended() == TRUE))
{
//Either the device is not configured or we are suspended,
// so we don't want to execute any USB related application code
continue; //go back to the top of the while loop
}
if(!HIDRxHandleBusy(USBOutHandle)) //Check if data was received from the host.
{
//Do something with the data
ToSendDataBuffer[0] = ReceivedDataBuffer[0];
//Re-arm the OUT endpoint for the next packet
USBOutHandle = HIDRxPacket(HID_EP,(BYTE*)&ReceivedDataBuffer,64);
}
if(!HIDTxHandleBusy(USBInHandle)){
// Send out new data
USBInHandle = HIDTxPacket(HID_EP,(BYTE*)&ToSendDataBuffer[0],64);
}
}

===Demo===

This [[Media:USBExample.zip|MPLABX Project Directory]] is an example project written for the PIC32MX250F128B.

This demo communicated with the processing demo explained below, using the 28-DIP package for the pic32 and the following pinout.

*Pin01 - MCLR
*Pin03 - Configured for OC2, connected to an LED
*Pin04 - PGED1
*Pin05 - PGEC1
*Pin07 - Configured for AN5, reads analog voltage from potentiometer
*Pin08 - Vss
*Pin09 - External Clock, running at 20MHz
*Pin12 - Configured for digital in, reads switch state
*Pin13 - Vdd
*Pin15 - Vbus, connected to USB 5 Volt line
*Pin16 - Configured for digital out, connected to an LED
*Pin18 - Configured for OC3, connected to an LED
*Pin19 - Vss
*Pin20 - Vcap, 10nF capacitor to Vss
*Pin21 - USB, D+
*Pin22 - USB, D-
*Pin23 - Vusb, 3.3V
*Pin27 - AVss, 10nF capacitor to AVdd
*Pin28 - AVdd, 3.3V

==Processing and the HID API==

To send and receive USB packets in Processing on the computer, we use a Java Native Interface library which uses C libraries to communicate via USB. Documentation and downloads for this library can be found [http://code.google.com/p/javahidapi/ here]. This is the [[Media:Processing_USBExample.zip|Processing sketch]] used to interface with the demo board described above.

The code directory contains both the .jar file containing the Java library, and the .dll, .jnilib, and .so files containing the native USB libraries. These files need to be here, but do not require editing.

In the sketch itself, the '''USBListener''' file defines a Thread which listens to the USB port. The function pic.read() will wait until the USB buffer is not empty, and then place the first-in data into the specified variable. This thread is also a good place to update all state variables and send out data to the PIC using pic.write(). The '''HIDManager''' extends the HIDManager class defined in the API. This class defines callback functions which are called whenever a device is added or removed.

The main file includes the typical functions, setup() and draw(), as well as an openPic() function used to search the computer for a connected PIC microcontroller and open it for communication.

Here is the API [[Media:HIDAPI.zip|documentation]], which explains what each function does.

==Matlab and the HID API==

USB Communication using PIC microcontrollers

2012-07-09T18:17:06Z

DavidMeyer: /* Processing and the HID API */

File:HIDAPI.zip

2012-07-09T18:14:02Z

DavidMeyer: HID API Documentation

HID API Documentation

USB Communication using PIC microcontrollers

2012-07-09T17:27:51Z

DavidMeyer: /* Processing and the HID API */

USB Communication using PIC microcontrollers

2012-07-09T17:20:06Z

DavidMeyer: /* Demo */

'''***Under Construction***'''

==USB Overview==

Universal Serial Bus, or USB, is a very common method of communication between electronic devices. USB is universal, meaning that it's standard across all electronic devices, serial, meaning that data is transmitted on only one data line one bit at a time, and is a bus, meaning that all devices are connected through the same parallel electronic wires and therefore require addresses. A simple USB connection requires a host and a device. The host initiates all communication, assigns device addresses, and controls the flow of the data line in the connection. For our purposes, the USB host will be the PC and the USB device will be a PIC chip.

There are many different speeds associated with USB. USB 1.0 introduced data rates of 1.5 Mbits/s ('''Low-Speed''') and 12 Mbits/s ('''Full-Speed'''). With USB 2.0 and 3.0, data rates of 480 Mbits/s ('''Hi-Speed''') and 5 Gbits/s ('''Super-Speed'''), were added respectively. PIC chips have hardware capable of full speed USB.

===Hardware===

A USB cable has 4 wires: power (red), ground (black), D+ (green), and D- (white). You may notice that many USB plugs and receptacles have 5 pins. This fifth pin is called ID, and is often not connected, but has been added to the specifications for use with USB-OTG, or On-The-Go. OTG allows devices to also act as a host. Many PIC chips are compatible with USB-OTG communication, but we will not discuss this topic any further at this point.

The two data lines, D+ and D-, provide information about the state of the USB link.

*Detached State, or SE0 - device is unplugged, both data lines are low, pulled down by 15 kOhm resistors within the host hardware.
*Attached State, Idle State, or J State - the device pulls up the D+ line (for a high-speed device) when it is attached.
*K State - opposite polarity from J State. To communicate, the host or device alternates the device between the J and K states in specific patterns.
*Illegal State, or SE1 - both data lines are high. If this happens, there is a hardware problem with the USB link.

===Protocol===

Useful Links
[http://www.usb.org/developers/devclass_docs/HID1_11.pdf HID Specification]
[http://www.usbmadesimple.co.uk/index.html USB Made Simple]

==Microchip USB Stack==

Microchip has provided almost all of the code and examples to run USB code on PIC chips. This code is called the USB stack, and we will use this as the main library for communicating to PCs. Unfortunately, there are a few bugs for certain PIC chips and some quirks to getting the libraries setup in MPLAB. This section will document the steps necessary to install the USB stack and setup a proper programming environment in MPLAB.

===Installation===

====Download====

We'll begin with the assumption that the reader knows how to setup a project for a PIC chip in MPLAB and program their chip with some basic C code. The Microchip USB stack is a part of the Microchip Application Libraries, which are available at the Microchip website [http://www.microchip.com/MAL/ here].

You must download and install the entire Application Libraries package, which will place all the libraries in your C drive on a Windows machine and some other place ('''**FIND OUT WHERE**''') on a Mac. The name of the root directory should be something like "Microchip Solutions v2012...", but from here on out, we'll refer to the root directory of that installation as <MAL>.

====Include Libraries and Driver in Project====

Once the installer has finished running, the actual USB stack is located at <MAL>/Microchip/USB. <MAL>/USB is not the stack, and only contains demos of the firmware for learning purposes. We will not be using any of those files for our purposes. After starting a project in MPLAB for your PIC chip, you must complete the following steps:

*Include the USB libraries in your project
**In MPLAB X, right-click on your project and select properties. In the left-sidebar, click on your compiler (pic32-gcc for PIC32 chips). In the main window, find the field called "Include Directories" and click the button with "..." Add the directories <MAL>/Microchip/USB, <MAL>/Microchip/Include, and '''importantly''' your ''current project directory''. This last one is important because the stack references a Hardware Profile which we will include in our own project directory.
*Add the HID device drivers to your project
**In MPLAB X, right-click on your project source files and select "add existing..." Browse to <MAL>/Microchip/USB and add '''usb_device.c''' and '''./HID Device Driver/usb_function_hid.c'''. These files do not need to be moved to your project directory, they just need to be added into your project via MPLAB.

====Add Application-Specific USB files====

Two additional header files and two additional source files specific to each application are required for the microcontroller to be fully USB functional.

*usb_config.h - provides configuration details for the mode of USB operation
*HardwareProfile.h - gives information about the specific microcontroller we're using
*usb_descriptors.c - defines all the descriptors used to tell the Host PC what kind of USB device we're connecting
*usb_callbacks.c - defines all callback functions executed when the driver detects certain conditions in the connection

The file attached below is a zip containing examples of these four files. This example provides generic USB HID operation under Microchip's VendorID (1240) and a ProductID of 0, operating in USB_INTERRUPT mode (described below).

[[Media:PIC32_USB_Files.zip|PIC32_USB_Files]]

=== Microchip Stack Bug Notes ===

For the pic32mx2xx series, the usb interrupts are not configured correctly in the Microchip stack, so the following changes need to be made.

'''In <MAL>/Microchip/Include/usb_hal_pic32.h (Line 365):'''

This section normally sets the bits to configure IPC11, the USB interrupt location, but on the pic32mx2xx series, the USB interrupt bits are located at IPC7, as detailed in the Interrupt Controller chapter of the PIC datasheet. We've added a precompiler if statement to detect if a specific chip is being used. It's simple to change this for your specific chip though.

#if defined(USB_INTERRUPT)
// This is edited for use with the PIC32MX250F128B
#ifdef __32MX250F128B__
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC7CLR=0x00FF0000;IPC7SET=0x00100000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#else
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC11CLR=0x0000FF00;IPC11SET=0x00001000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#endif
#else
#define USBEnableInterrupts()
#endif

'''In <MAL>/Microchip/USB/usb_device.c (Line 673)'''
The Microchip stack assumes that the USB interrupt vector is 45 but this has changed to 30 for the pic32mx2xx series.

The line:
void __attribute__((interrupt(),vector(45))) _USB1Interrupt( void )

Should be:
void __attribute__((interrupt(),vector(_USB_1_VECTOR))) _USB1Interrupt( void )

=== USB Hardware Notes ===

It is important to use an external clock or oscillator in order to use the USB module. A 48 MHz clock is required for proper operation. The clock configuration can be seen in the data sheet, but for the pic32mx2xx series a 4 Mhz clock is required before the USB PLL. Since I am using a 20MHz external clock, we use these lines to set DEVCFG2 to proper values.
#pragma config UPLLEN = ON // USB PLL Enable
#pragma config UPLLIDIV = DIV_5 // USB PLL Divider
// 20MHz / 5 * 24 / 2 = 48MHz

=== USB Stack Operation ===

A function called USBDeviceTasks() defined in usb_device.c handles USB events, host requests, and enumeration. This function must be called every ~1.8ms during enumeration, and at specific intervals during other operation. This timing can be faster than the minimum with no hitch, but slower causes failure in communication. The stack may operate in two modes, USB_POLLING, or USB_INTERRUPT as defined in usb_config.h.

USB_POLLING requires the developer to call USBDeviceTasks() manually faster than the minimum rate, whereas USB_INTERRUPT handles all timing automatically. In the demo, we use USB_INTERRUPT to handle this timing.

Below is some sample code in the while loop of a main function of PIC communicating via USB.
while(1){
if((USBGetDeviceState() < CONFIGURED_STATE) ||
(USBIsDeviceSuspended() == TRUE))
{
//Either the device is not configured or we are suspended,
// so we don't want to execute any USB related application code
continue; //go back to the top of the while loop
}
if(!HIDRxHandleBusy(USBOutHandle)) //Check if data was received from the host.
{
//Do something with the data
ToSendDataBuffer[0] = ReceivedDataBuffer[0];
//Re-arm the OUT endpoint for the next packet
USBOutHandle = HIDRxPacket(HID_EP,(BYTE*)&ReceivedDataBuffer,64);
}
if(!HIDTxHandleBusy(USBInHandle)){
// Send out new data
USBInHandle = HIDTxPacket(HID_EP,(BYTE*)&ToSendDataBuffer[0],64);
}
}

===Demo===

This [[Media:USBExample.zip|MPLABX Project Directory]] is an example project written for the PIC32MX250F128B.

This demo communicated with the processing demo explained below, using the 28-DIP package for the pic32 and the following pinout.

*Pin01 - MCLR
*Pin03 - Configured for OC2, connected to an LED
*Pin04 - PGED1
*Pin05 - PGEC1
*Pin07 - Configured for AN5, reads analog voltage from potentiometer
*Pin08 - Vss
*Pin09 - External Clock, running at 20MHz
*Pin12 - Configured for digital in, reads switch state
*Pin13 - Vdd
*Pin15 - Vbus, connected to USB 5 Volt line
*Pin16 - Configured for digital out, connected to an LED
*Pin18 - Configured for OC3, connected to an LED
*Pin19 - Vss
*Pin20 - Vcap, 10nF capacitor to Vss
*Pin21 - USB, D+
*Pin22 - USB, D-
*Pin23 - Vusb, 3.3V
*Pin27 - AVss, 10nF capacitor to AVdd
*Pin28 - AVdd, 3.3V

==Processing and the HID API==

To send and receive USB packets in Processing on the computer, we use a Java Native Interface library which uses C libraries to communicate via USB. Documentation and downloads for this library can be found [http://code.google.com/p/javahidapi/ here]. Attached is the Processing sketch used to interface with the demo board described above.

USB Communication using PIC microcontrollers

2012-07-09T17:19:01Z

DavidMeyer: /* Add Application-Specific USB files */

'''***Under Construction***'''

==USB Overview==

Universal Serial Bus, or USB, is a very common method of communication between electronic devices. USB is universal, meaning that it's standard across all electronic devices, serial, meaning that data is transmitted on only one data line one bit at a time, and is a bus, meaning that all devices are connected through the same parallel electronic wires and therefore require addresses. A simple USB connection requires a host and a device. The host initiates all communication, assigns device addresses, and controls the flow of the data line in the connection. For our purposes, the USB host will be the PC and the USB device will be a PIC chip.

There are many different speeds associated with USB. USB 1.0 introduced data rates of 1.5 Mbits/s ('''Low-Speed''') and 12 Mbits/s ('''Full-Speed'''). With USB 2.0 and 3.0, data rates of 480 Mbits/s ('''Hi-Speed''') and 5 Gbits/s ('''Super-Speed'''), were added respectively. PIC chips have hardware capable of full speed USB.

===Hardware===

A USB cable has 4 wires: power (red), ground (black), D+ (green), and D- (white). You may notice that many USB plugs and receptacles have 5 pins. This fifth pin is called ID, and is often not connected, but has been added to the specifications for use with USB-OTG, or On-The-Go. OTG allows devices to also act as a host. Many PIC chips are compatible with USB-OTG communication, but we will not discuss this topic any further at this point.

The two data lines, D+ and D-, provide information about the state of the USB link.

*Detached State, or SE0 - device is unplugged, both data lines are low, pulled down by 15 kOhm resistors within the host hardware.
*Attached State, Idle State, or J State - the device pulls up the D+ line (for a high-speed device) when it is attached.
*K State - opposite polarity from J State. To communicate, the host or device alternates the device between the J and K states in specific patterns.
*Illegal State, or SE1 - both data lines are high. If this happens, there is a hardware problem with the USB link.

===Protocol===

Useful Links
[http://www.usb.org/developers/devclass_docs/HID1_11.pdf HID Specification]
[http://www.usbmadesimple.co.uk/index.html USB Made Simple]

==Microchip USB Stack==

Microchip has provided almost all of the code and examples to run USB code on PIC chips. This code is called the USB stack, and we will use this as the main library for communicating to PCs. Unfortunately, there are a few bugs for certain PIC chips and some quirks to getting the libraries setup in MPLAB. This section will document the steps necessary to install the USB stack and setup a proper programming environment in MPLAB.

===Installation===

====Download====

We'll begin with the assumption that the reader knows how to setup a project for a PIC chip in MPLAB and program their chip with some basic C code. The Microchip USB stack is a part of the Microchip Application Libraries, which are available at the Microchip website [http://www.microchip.com/MAL/ here].

You must download and install the entire Application Libraries package, which will place all the libraries in your C drive on a Windows machine and some other place ('''**FIND OUT WHERE**''') on a Mac. The name of the root directory should be something like "Microchip Solutions v2012...", but from here on out, we'll refer to the root directory of that installation as <MAL>.

====Include Libraries and Driver in Project====

Once the installer has finished running, the actual USB stack is located at <MAL>/Microchip/USB. <MAL>/USB is not the stack, and only contains demos of the firmware for learning purposes. We will not be using any of those files for our purposes. After starting a project in MPLAB for your PIC chip, you must complete the following steps:

*Include the USB libraries in your project
**In MPLAB X, right-click on your project and select properties. In the left-sidebar, click on your compiler (pic32-gcc for PIC32 chips). In the main window, find the field called "Include Directories" and click the button with "..." Add the directories <MAL>/Microchip/USB, <MAL>/Microchip/Include, and '''importantly''' your ''current project directory''. This last one is important because the stack references a Hardware Profile which we will include in our own project directory.
*Add the HID device drivers to your project
**In MPLAB X, right-click on your project source files and select "add existing..." Browse to <MAL>/Microchip/USB and add '''usb_device.c''' and '''./HID Device Driver/usb_function_hid.c'''. These files do not need to be moved to your project directory, they just need to be added into your project via MPLAB.

====Add Application-Specific USB files====

Two additional header files and two additional source files specific to each application are required for the microcontroller to be fully USB functional.

*usb_config.h - provides configuration details for the mode of USB operation
*HardwareProfile.h - gives information about the specific microcontroller we're using
*usb_descriptors.c - defines all the descriptors used to tell the Host PC what kind of USB device we're connecting
*usb_callbacks.c - defines all callback functions executed when the driver detects certain conditions in the connection

The file attached below is a zip containing examples of these four files. This example provides generic USB HID operation under Microchip's VendorID (1240) and a ProductID of 0, operating in USB_INTERRUPT mode (described below).

[[Media:PIC32_USB_Files.zip|PIC32_USB_Files]]

=== Microchip Stack Bug Notes ===

For the pic32mx2xx series, the usb interrupts are not configured correctly in the Microchip stack, so the following changes need to be made.

'''In <MAL>/Microchip/Include/usb_hal_pic32.h (Line 365):'''

This section normally sets the bits to configure IPC11, the USB interrupt location, but on the pic32mx2xx series, the USB interrupt bits are located at IPC7, as detailed in the Interrupt Controller chapter of the PIC datasheet. We've added a precompiler if statement to detect if a specific chip is being used. It's simple to change this for your specific chip though.

#if defined(USB_INTERRUPT)
// This is edited for use with the PIC32MX250F128B
#ifdef __32MX250F128B__
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC7CLR=0x00FF0000;IPC7SET=0x00100000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#else
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC11CLR=0x0000FF00;IPC11SET=0x00001000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#endif
#else
#define USBEnableInterrupts()
#endif

'''In <MAL>/Microchip/USB/usb_device.c (Line 673)'''
The Microchip stack assumes that the USB interrupt vector is 45 but this has changed to 30 for the pic32mx2xx series.

The line:
void __attribute__((interrupt(),vector(45))) _USB1Interrupt( void )

Should be:
void __attribute__((interrupt(),vector(_USB_1_VECTOR))) _USB1Interrupt( void )

=== USB Hardware Notes ===

It is important to use an external clock or oscillator in order to use the USB module. A 48 MHz clock is required for proper operation. The clock configuration can be seen in the data sheet, but for the pic32mx2xx series a 4 Mhz clock is required before the USB PLL. Since I am using a 20MHz external clock, we use these lines to set DEVCFG2 to proper values.
#pragma config UPLLEN = ON // USB PLL Enable
#pragma config UPLLIDIV = DIV_5 // USB PLL Divider
// 20MHz / 5 * 24 / 2 = 48MHz

=== USB Stack Operation ===

A function called USBDeviceTasks() defined in usb_device.c handles USB events, host requests, and enumeration. This function must be called every ~1.8ms during enumeration, and at specific intervals during other operation. This timing can be faster than the minimum with no hitch, but slower causes failure in communication. The stack may operate in two modes, USB_POLLING, or USB_INTERRUPT as defined in usb_config.h.

USB_POLLING requires the developer to call USBDeviceTasks() manually faster than the minimum rate, whereas USB_INTERRUPT handles all timing automatically. In the demo, we use USB_INTERRUPT to handle this timing.

Below is some sample code in the while loop of a main function of PIC communicating via USB.
while(1){
if((USBGetDeviceState() < CONFIGURED_STATE) ||
(USBIsDeviceSuspended() == TRUE))
{
//Either the device is not configured or we are suspended,
// so we don't want to execute any USB related application code
continue; //go back to the top of the while loop
}
if(!HIDRxHandleBusy(USBOutHandle)) //Check if data was received from the host.
{
//Do something with the data
ToSendDataBuffer[0] = ReceivedDataBuffer[0];
//Re-arm the OUT endpoint for the next packet
USBOutHandle = HIDRxPacket(HID_EP,(BYTE*)&ReceivedDataBuffer,64);
}
if(!HIDTxHandleBusy(USBInHandle)){
// Send out new data
USBInHandle = HIDTxPacket(HID_EP,(BYTE*)&ToSendDataBuffer[0],64);
}
}

===Demo===

Attached here is an example project for the PIC32MX250F128B. [[Media:USBExample.zip]]

This demo communicated with the processing demo explained below, using the 28-DIP package for the pic32 and the following pinout.

*Pin01 - MCLR
*Pin03 - Configured for OC2, connected to an LED
*Pin04 - PGED1
*Pin05 - PGEC1
*Pin07 - Configured for AN5, reads analog voltage from potentiometer
*Pin08 - Vss
*Pin09 - External Clock, running at 20MHz
*Pin12 - Configured for digital in, reads switch state
*Pin13 - Vdd
*Pin15 - Vbus, connected to USB 5 Volt line
*Pin16 - Configured for digital out, connected to an LED
*Pin18 - Configured for OC3, connected to an LED
*Pin19 - Vss
*Pin20 - Vcap, 10nF capacitor to Vss
*Pin21 - USB, D+
*Pin22 - USB, D-
*Pin23 - Vusb, 3.3V
*Pin27 - AVss, 10nF capacitor to AVdd
*Pin28 - AVdd, 3.3V

==Processing and the HID API==

To send and receive USB packets in Processing on the computer, we use a Java Native Interface library which uses C libraries to communicate via USB. Documentation and downloads for this library can be found [http://code.google.com/p/javahidapi/ here]. Attached is the Processing sketch used to interface with the demo board described above.

File:Processing USBExample.zip

2012-07-09T17:16:49Z

DavidMeyer: Example Processing sketch for communicating via native USB

Example Processing sketch for communicating via native USB

USB Communication using PIC microcontrollers

2012-07-09T17:00:18Z

DavidMeyer:

'''***Under Construction***'''

==USB Overview==

Universal Serial Bus, or USB, is a very common method of communication between electronic devices. USB is universal, meaning that it's standard across all electronic devices, serial, meaning that data is transmitted on only one data line one bit at a time, and is a bus, meaning that all devices are connected through the same parallel electronic wires and therefore require addresses. A simple USB connection requires a host and a device. The host initiates all communication, assigns device addresses, and controls the flow of the data line in the connection. For our purposes, the USB host will be the PC and the USB device will be a PIC chip.

There are many different speeds associated with USB. USB 1.0 introduced data rates of 1.5 Mbits/s ('''Low-Speed''') and 12 Mbits/s ('''Full-Speed'''). With USB 2.0 and 3.0, data rates of 480 Mbits/s ('''Hi-Speed''') and 5 Gbits/s ('''Super-Speed'''), were added respectively. PIC chips have hardware capable of full speed USB.

===Hardware===

A USB cable has 4 wires: power (red), ground (black), D+ (green), and D- (white). You may notice that many USB plugs and receptacles have 5 pins. This fifth pin is called ID, and is often not connected, but has been added to the specifications for use with USB-OTG, or On-The-Go. OTG allows devices to also act as a host. Many PIC chips are compatible with USB-OTG communication, but we will not discuss this topic any further at this point.

The two data lines, D+ and D-, provide information about the state of the USB link.

*Detached State, or SE0 - device is unplugged, both data lines are low, pulled down by 15 kOhm resistors within the host hardware.
*Attached State, Idle State, or J State - the device pulls up the D+ line (for a high-speed device) when it is attached.
*K State - opposite polarity from J State. To communicate, the host or device alternates the device between the J and K states in specific patterns.
*Illegal State, or SE1 - both data lines are high. If this happens, there is a hardware problem with the USB link.

===Protocol===

Useful Links
[http://www.usb.org/developers/devclass_docs/HID1_11.pdf HID Specification]
[http://www.usbmadesimple.co.uk/index.html USB Made Simple]

==Microchip USB Stack==

Microchip has provided almost all of the code and examples to run USB code on PIC chips. This code is called the USB stack, and we will use this as the main library for communicating to PCs. Unfortunately, there are a few bugs for certain PIC chips and some quirks to getting the libraries setup in MPLAB. This section will document the steps necessary to install the USB stack and setup a proper programming environment in MPLAB.

===Installation===

====Download====

We'll begin with the assumption that the reader knows how to setup a project for a PIC chip in MPLAB and program their chip with some basic C code. The Microchip USB stack is a part of the Microchip Application Libraries, which are available at the Microchip website [http://www.microchip.com/MAL/ here].

You must download and install the entire Application Libraries package, which will place all the libraries in your C drive on a Windows machine and some other place ('''**FIND OUT WHERE**''') on a Mac. The name of the root directory should be something like "Microchip Solutions v2012...", but from here on out, we'll refer to the root directory of that installation as <MAL>.

====Include Libraries and Driver in Project====

Once the installer has finished running, the actual USB stack is located at <MAL>/Microchip/USB. <MAL>/USB is not the stack, and only contains demos of the firmware for learning purposes. We will not be using any of those files for our purposes. After starting a project in MPLAB for your PIC chip, you must complete the following steps:

*Include the USB libraries in your project
**In MPLAB X, right-click on your project and select properties. In the left-sidebar, click on your compiler (pic32-gcc for PIC32 chips). In the main window, find the field called "Include Directories" and click the button with "..." Add the directories <MAL>/Microchip/USB, <MAL>/Microchip/Include, and '''importantly''' your ''current project directory''. This last one is important because the stack references a Hardware Profile which we will include in our own project directory.
*Add the HID device drivers to your project
**In MPLAB X, right-click on your project source files and select "add existing..." Browse to <MAL>/Microchip/USB and add '''usb_device.c''' and '''./HID Device Driver/usb_function_hid.c'''. These files do not need to be moved to your project directory, they just need to be added into your project via MPLAB.

====Add Application-Specific USB files====

Two additional header files and two additional source files specific to each application are required for the microcontroller to be fully USB functional.

*usb_config.h - provides configuration details for the mode of USB operation
*HardwareProfile.h - gives information about the specific microcontroller we're using
*usb_descriptors.c - defines all the descriptors used to tell the Host PC what kind of USB device we're connecting
*usb_callbacks.c - defines all callback functions executed when the driver detects certain conditions in the connection

The file attached below is a zip containing examples of these four files. This example provides generic USB HID operation under Microchip's VendorID (1240) and a ProductID of 0, operating in USB_INTERRUPT mode (described below).

[[Media:PIC32_USB_Files.zip]]

=== Microchip Stack Bug Notes ===

For the pic32mx2xx series, the usb interrupts are not configured correctly in the Microchip stack, so the following changes need to be made.

'''In <MAL>/Microchip/Include/usb_hal_pic32.h (Line 365):'''

This section normally sets the bits to configure IPC11, the USB interrupt location, but on the pic32mx2xx series, the USB interrupt bits are located at IPC7, as detailed in the Interrupt Controller chapter of the PIC datasheet. We've added a precompiler if statement to detect if a specific chip is being used. It's simple to change this for your specific chip though.

#if defined(USB_INTERRUPT)
// This is edited for use with the PIC32MX250F128B
#ifdef __32MX250F128B__
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC7CLR=0x00FF0000;IPC7SET=0x00100000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#else
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC11CLR=0x0000FF00;IPC11SET=0x00001000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#endif
#else
#define USBEnableInterrupts()
#endif

'''In <MAL>/Microchip/USB/usb_device.c (Line 673)'''
The Microchip stack assumes that the USB interrupt vector is 45 but this has changed to 30 for the pic32mx2xx series.

The line:
void __attribute__((interrupt(),vector(45))) _USB1Interrupt( void )

Should be:
void __attribute__((interrupt(),vector(_USB_1_VECTOR))) _USB1Interrupt( void )

=== USB Hardware Notes ===

It is important to use an external clock or oscillator in order to use the USB module. A 48 MHz clock is required for proper operation. The clock configuration can be seen in the data sheet, but for the pic32mx2xx series a 4 Mhz clock is required before the USB PLL. Since I am using a 20MHz external clock, we use these lines to set DEVCFG2 to proper values.
#pragma config UPLLEN = ON // USB PLL Enable
#pragma config UPLLIDIV = DIV_5 // USB PLL Divider
// 20MHz / 5 * 24 / 2 = 48MHz

=== USB Stack Operation ===

A function called USBDeviceTasks() defined in usb_device.c handles USB events, host requests, and enumeration. This function must be called every ~1.8ms during enumeration, and at specific intervals during other operation. This timing can be faster than the minimum with no hitch, but slower causes failure in communication. The stack may operate in two modes, USB_POLLING, or USB_INTERRUPT as defined in usb_config.h.

USB_POLLING requires the developer to call USBDeviceTasks() manually faster than the minimum rate, whereas USB_INTERRUPT handles all timing automatically. In the demo, we use USB_INTERRUPT to handle this timing.

Below is some sample code in the while loop of a main function of PIC communicating via USB.
while(1){
if((USBGetDeviceState() < CONFIGURED_STATE) ||
(USBIsDeviceSuspended() == TRUE))
{
//Either the device is not configured or we are suspended,
// so we don't want to execute any USB related application code
continue; //go back to the top of the while loop
}
if(!HIDRxHandleBusy(USBOutHandle)) //Check if data was received from the host.
{
//Do something with the data
ToSendDataBuffer[0] = ReceivedDataBuffer[0];
//Re-arm the OUT endpoint for the next packet
USBOutHandle = HIDRxPacket(HID_EP,(BYTE*)&ReceivedDataBuffer,64);
}
if(!HIDTxHandleBusy(USBInHandle)){
// Send out new data
USBInHandle = HIDTxPacket(HID_EP,(BYTE*)&ToSendDataBuffer[0],64);
}
}

===Demo===

Attached here is an example project for the PIC32MX250F128B. [[Media:USBExample.zip]]

This demo communicated with the processing demo explained below, using the 28-DIP package for the pic32 and the following pinout.

*Pin01 - MCLR
*Pin03 - Configured for OC2, connected to an LED
*Pin04 - PGED1
*Pin05 - PGEC1
*Pin07 - Configured for AN5, reads analog voltage from potentiometer
*Pin08 - Vss
*Pin09 - External Clock, running at 20MHz
*Pin12 - Configured for digital in, reads switch state
*Pin13 - Vdd
*Pin15 - Vbus, connected to USB 5 Volt line
*Pin16 - Configured for digital out, connected to an LED
*Pin18 - Configured for OC3, connected to an LED
*Pin19 - Vss
*Pin20 - Vcap, 10nF capacitor to Vss
*Pin21 - USB, D+
*Pin22 - USB, D-
*Pin23 - Vusb, 3.3V
*Pin27 - AVss, 10nF capacitor to AVdd
*Pin28 - AVdd, 3.3V

==Processing and the HID API==

To send and receive USB packets in Processing on the computer, we use a Java Native Interface library which uses C libraries to communicate via USB. Documentation and downloads for this library can be found [http://code.google.com/p/javahidapi/ here]. Attached is the Processing sketch used to interface with the demo board described above.

USB Communication using PIC microcontrollers

2012-07-09T16:41:33Z

DavidMeyer:

'''***Under Construction***'''

==USB Overview==

Universal Serial Bus, or USB, is a very common method of communication between electronic devices. USB is universal, meaning that it's standard across all electronic devices, serial, meaning that data is transmitted on only one data line one bit at a time, and is a bus, meaning that all devices are connected through the same parallel electronic wires and therefore require addresses. A simple USB connection requires a host and a device. The host initiates all communication, assigns device addresses, and controls the flow of the data line in the connection. For our purposes, the USB host will be the PC and the USB device will be a PIC chip.

There are many different speeds associated with USB. USB 1.0 introduced data rates of 1.5 Mbits/s ('''Low-Speed''') and 12 Mbits/s ('''Full-Speed'''). With USB 2.0 and 3.0, data rates of 480 Mbits/s ('''Hi-Speed''') and 5 Gbits/s ('''Super-Speed'''), were added respectively. PIC chips have hardware capable of full speed USB.

===Hardware===

A USB cable has 4 wires: power (red), ground (black), D+ (green), and D- (white). You may notice that many USB plugs and receptacles have 5 pins. This fifth pin is called ID, and is often not connected, but has been added to the specifications for use with USB-OTG, or On-The-Go. OTG allows devices to also act as a host. Many PIC chips are compatible with USB-OTG communication, but we will not discuss this topic any further at this point.

The two data lines, D+ and D-, provide information about the state of the USB link.

*Detached State, or SE0 - device is unplugged, both data lines are low, pulled down by 15 kOhm resistors within the host hardware.
*Attached State, Idle State, or J State - the device pulls up the D+ line (for a high-speed device) when it is attached.
*K State - opposite polarity from J State. To communicate, the host or device alternates the device between the J and K states in specific patterns.
*Illegal State, or SE1 - both data lines are high. If this happens, there is a hardware problem with the USB link.

===Protocol===

Useful Links
[http://www.usb.org/developers/devclass_docs/HID1_11.pdf HID Specification]
[http://www.usbmadesimple.co.uk/index.html USB Made Simple]

==Microchip USB Stack==

Microchip has provided almost all of the code and examples to run USB code on PIC chips. This code is called the USB stack, and we will use this as the main library for communicating to PCs. Unfortunately, there are a few bugs for certain PIC chips and some quirks to getting the libraries setup in MPLAB. This section will document the steps necessary to install the USB stack and setup a proper programming environment in MPLAB.

===Installation===

====Download====

We'll begin with the assumption that the reader knows how to setup a project for a PIC chip in MPLAB and program their chip with some basic C code. The Microchip USB stack is a part of the Microchip Application Libraries, which are available at the Microchip website [http://www.microchip.com/MAL/ here].

You must download and install the entire Application Libraries package, which will place all the libraries in your C drive on a Windows machine and some other place ('''**FIND OUT WHERE**''') on a Mac. The name of the root directory should be something like "Microchip Solutions v2012...", but from here on out, we'll refer to the root directory of that installation as <MAL>.

====Include Libraries and Driver in Project====

Once the installer has finished running, the actual USB stack is located at <MAL>/Microchip/USB. <MAL>/USB is not the stack, and only contains demos of the firmware for learning purposes. We will not be using any of those files for our purposes. After starting a project in MPLAB for your PIC chip, you must complete the following steps:

*Include the USB libraries in your project
**In MPLAB X, right-click on your project and select properties. In the left-sidebar, click on your compiler (pic32-gcc for PIC32 chips). In the main window, find the field called "Include Directories" and click the button with "..." Add the directories <MAL>/Microchip/USB, <MAL>/Microchip/Include, and '''importantly''' your ''current project directory''. This last one is important because the stack references a Hardware Profile which we will include in our own project directory.
*Add the HID device drivers to your project
**In MPLAB X, right-click on your project source files and select "add existing..." Browse to <MAL>/Microchip/USB and add '''usb_device.c''' and '''./HID Device Driver/usb_function_hid.c'''. These files do not need to be moved to your project directory, they just need to be added into your project via MPLAB.

====Add Application-Specific USB files====

Two additional header files and two additional source files specific to each application are required for the microcontroller to be fully USB functional.

*usb_config.h - provides configuration details for the mode of USB operation
*HardwareProfile.h - gives information about the specific microcontroller we're using
*usb_descriptors.c - defines all the descriptors used to tell the Host PC what kind of USB device we're connecting
*usb_callbacks.c - defines all callback functions executed when the driver detects certain conditions in the connection

The file attached below is a zip containing examples of these four files. This example provides generic USB HID operation under Microchip's VendorID (1240) and a ProductID of 0, operating in USB_INTERRUPT mode (described below).

[[Media:PIC32_USB_Files.zip]]

=== Microchip Stack Bug Notes ===

For the pic32mx2xx series, the usb interrupts are not configured correctly in the Microchip stack, so the following changes need to be made.

'''In <MAL>/Microchip/Include/usb_hal_pic32.h (Line 365):'''

This section normally sets the bits to configure IPC11, the USB interrupt location, but on the pic32mx2xx series, the USB interrupt bits are located at IPC7, as detailed in the Interrupt Controller chapter of the PIC datasheet. We've added a precompiler if statement to detect if a specific chip is being used. It's simple to change this for your specific chip though.

#if defined(USB_INTERRUPT)
// This is edited for use with the PIC32MX250F128B
#ifdef __32MX250F128B__
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC7CLR=0x00FF0000;IPC7SET=0x00100000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#else
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC11CLR=0x0000FF00;IPC11SET=0x00001000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#endif
#else
#define USBEnableInterrupts()
#endif

'''In <MAL>/Microchip/USB/usb_device.c (Line 673)'''
The Microchip stack assumes that the USB interrupt vector is 45 but this has changed to 30 for the pic32mx2xx series.

The line:
void __attribute__((interrupt(),vector(45))) _USB1Interrupt( void )

Should be:
void __attribute__((interrupt(),vector(_USB_1_VECTOR))) _USB1Interrupt( void )

=== USB Hardware Notes ===

It is important to use an external clock or oscillator in order to use the USB module. A 48 MHz clock is required for proper operation. The clock configuration can be seen in the data sheet, but for the pic32mx2xx series a 4 Mhz clock is required before the USB PLL. Since I am using a 20MHz external clock, we use these lines to set DEVCFG2 to proper values.
#pragma config UPLLEN = ON // USB PLL Enable
#pragma config UPLLIDIV = DIV_5 // USB PLL Divider
// 20MHz / 5 * 24 / 2 = 48MHz

=== USB Stack Operation ===

A function called USBDeviceTasks() defined in usb_device.c handles USB events, host requests, and enumeration. This function must be called every ~1.8ms during enumeration, and at specific intervals during other operation. This timing can be faster than the minimum with no hitch, but slower causes failure in communication. The stack may operate in two modes, USB_POLLING, or USB_INTERRUPT as defined in usb_config.h.

USB_POLLING requires the developer to call USBDeviceTasks() manually faster than the minimum rate, whereas USB_INTERRUPT handles all timing automatically. In the demo, we use USB_INTERRUPT to handle this timing.

Below is some sample code in the while loop of a main function of PIC communicating via USB.
while(1){
if((USBGetDeviceState() < CONFIGURED_STATE) ||
(USBIsDeviceSuspended() == TRUE))
{
//Either the device is not configured or we are suspended,
// so we don't want to execute any USB related application code
continue; //go back to the top of the while loop
}
if(!HIDRxHandleBusy(USBOutHandle)) //Check if data was received from the host.
{
//Do something with the data
ToSendDataBuffer[0] = ReceivedDataBuffer[0];
//Re-arm the OUT endpoint for the next packet
USBOutHandle = HIDRxPacket(HID_EP,(BYTE*)&ReceivedDataBuffer,64);
}
if(!HIDTxHandleBusy(USBInHandle)){
// Send out new data
USBInHandle = HIDTxPacket(HID_EP,(BYTE*)&ToSendDataBuffer[0],64);
}
}

===Demo===

Attached here is an example project for the PIC32MX250F128B. [[Media:USBExample.zip]]

This demo communicated with the processing demo explained below, using the 28-DIP package for the pic32 and the following pinout.

*Pin01 - MCLR
*Pin03 - Configured for OC2, connected to an LED
*Pin04 - PGED1
*Pin05 - PGEC1
*Pin07 - Configured for AN5, reads analog voltage from potentiometer
*Pin08 - Vss
*Pin09 - External Clock, running at 20MHz
*Pin12 - Configured for digital in, reads switch state
*Pin13 - Vdd
*Pin15 - Vbus, connected to USB 5 Volt line
*Pin16 - Configured for digital out, connected to an LED
*Pin18 - Configured for OC3, connected to an LED
*Pin19 - Vss
*Pin20 - Vcap, 10nF capacitor to Vss
*Pin21 - USB, D+
*Pin22 - USB, D-
*Pin23 - Vusb, 3.3V
*Pin27 - AVss, 10nF capacitor to AVdd
*Pin28 - AVdd, 3.3V

==Processing and the HID API==

File:USBExample.zip

2012-07-09T16:23:39Z

DavidMeyer: Example project for USB communication with PIC32MX250F128B

Example project for USB communication with PIC32MX250F128B

USB Communication using PIC microcontrollers

2012-07-09T15:17:42Z

DavidMeyer:

'''***Under Construction***'''

==USB Overview==

Universal Serial Bus, or USB, is a very common method of communication between electronic devices. USB is universal, meaning that it's standard across all electronic devices, serial, meaning that data is transmitted on only one data line one bit at a time, and is a bus, meaning that all devices are connected through the same parallel electronic wires and therefore require addresses. A simple USB connection requires a host and a device. The host initiates all communication, assigns device addresses, and controls the flow of the data line in the connection. For our purposes, the USB host will be the PC and the USB device will be a PIC chip.

There are many different speeds associated with USB. USB 1.0 introduced data rates of 1.5 Mbits/s ('''Low-Speed''') and 12 Mbits/s ('''Full-Speed'''). With USB 2.0 and 3.0, data rates of 480 Mbits/s ('''Hi-Speed''') and 5 Gbits/s ('''Super-Speed'''), were added respectively. PIC chips have hardware capable of full speed USB.

===Hardware===

A USB cable has 4 wires: power (red), ground (black), D+ (green), and D- (white). You may notice that many USB plugs and receptacles have 5 pins. This fifth pin is called ID, and is often not connected, but has been added to the specifications for use with USB-OTG, or On-The-Go. OTG allows devices to also act as a host. Many PIC chips are compatible with USB-OTG communication, but we will not discuss this topic any further at this point.

The two data lines, D+ and D-, provide information about the state of the USB link.

*Detached State, or SE0 - device is unplugged, both data lines are low, pulled down by 15 kOhm resistors within the host hardware.
*Attached State, Idle State, or J State - the device pulls up the D+ line (for a high-speed device) when it is attached.
*K State - opposite polarity from J State. To communicate, the host or device alternates the device between the J and K states in specific patterns.
*Illegal State, or SE1 - both data lines are high. If this happens, there is a hardware problem with the USB link.

===Protocol===

Useful Links
[http://www.usb.org/developers/devclass_docs/HID1_11.pdf HID Specification]
[http://www.usbmadesimple.co.uk/index.html USB Made Simple]

==Microchip USB Stack==

Microchip has provided almost all of the code and examples to run USB code on PIC chips. This code is called the USB stack, and we will use this as the main library for communicating to PCs. Unfortunately, there are a few bugs for certain PIC chips and some quirks to getting the libraries setup in MPLAB. This section will document the steps necessary to install the USB stack and setup a proper programming environment in MPLAB.

===Installation===

====Download====

We'll begin with the assumption that the reader knows how to setup a project for a PIC chip in MPLAB and program their chip with some basic C code. The Microchip USB stack is a part of the Microchip Application Libraries, which are available at the Microchip website [http://www.microchip.com/MAL/ here].

You must download and install the entire Application Libraries package, which will place all the libraries in your C drive on a Windows machine and some other place ('''**FIND OUT WHERE**''') on a Mac. The name of the root directory should be something like "Microchip Solutions v2012...", but from here on out, we'll refer to the root directory of that installation as <MAL>.

====Include Libraries and Driver in Project====

Once the installer has finished running, the actual USB stack is located at <MAL>/Microchip/USB. <MAL>/USB is not the stack, and only contains demos of the firmware for learning purposes. We will not be using any of those files for our purposes. After starting a project in MPLAB for your PIC chip, you must complete the following steps:

*Include the USB libraries in your project
**In MPLAB X, right-click on your project and select properties. In the left-sidebar, click on your compiler (pic32-gcc for PIC32 chips). In the main window, find the field called "Include Directories" and click the button with "..." Add the directories <MAL>/Microchip/USB, <MAL>/Microchip/Include, and '''importantly''' your ''current project directory''. This last one is important because the stack references a Hardware Profile which we will include in our own project directory.
*Add the HID device drivers to your project
**In MPLAB X, right-click on your project source files and select "add existing..." Browse to <MAL>/Microchip/USB and add '''usb_device.c''' and '''./HID Device Driver/usb_function_hid.c'''. These files do not need to be moved to your project directory, they just need to be added into your project via MPLAB.

====Add Application-Specific USB files====

Two additional header files and two additional source files specific to each application are required for the microcontroller to be fully USB functional.

*usb_config.h - provides configuration details for the mode of USB operation
*HardwareProfile.h - gives information about the specific microcontroller we're using
*usb_descriptors.c - defines all the descriptors used to tell the Host PC what kind of USB device we're connecting
*usb_callbacks.c - defines all callback functions executed when the driver detects certain conditions in the connection

The file attached below is a zip containing examples of these four files. This example provides generic USB HID operation under Microchip's VendorID (1240) and a ProductID of 0, operating in USB_INTERRUPT mode (described below).

[[Media:PIC32_USB_Files.zip]]

=== Microchip Stack Bug Notes ===

For the pic32mx2xx series, the usb interrupts are not configured correctly in the Microchip stack, so the following changes need to be made.

'''In <MAL>/Microchip/Include/usb_hal_pic32.h (Line 365):'''

This section normally sets the bits to configure IPC11, the USB interrupt location, but on the pic32mx2xx series, the USB interrupt bits are located at IPC7, as detailed in the Interrupt Controller chapter of the PIC datasheet. We've added a precompiler if statement to detect if a specific chip is being used. It's simple to change this for your specific chip though.

#if defined(USB_INTERRUPT)
// This is edited for use with the PIC32MX250F128B
#ifdef __32MX250F128B__
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC7CLR=0x00FF0000;IPC7SET=0x00100000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#else
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC11CLR=0x0000FF00;IPC11SET=0x00001000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#endif
#else
#define USBEnableInterrupts()
#endif

'''In <MAL>/Microchip/USB/usb_device.c (Line 673)'''
The Microchip stack assumes that the USB interrupt vector is 45 but this has changed to 30 for the pic32mx2xx series.

The line:
void __attribute__((interrupt(),vector(45))) _USB1Interrupt( void )

Should be:
void __attribute__((interrupt(),vector(_USB_1_VECTOR))) _USB1Interrupt( void )

=== USB Hardware Notes ===

It is important to use an external clock or oscillator in order to use the USB module. A 48 MHz clock is required for proper operation. The clock configuration can be seen in the data sheet, but for the pic32mx2xx series a 4 Mhz clock is required before the USB PLL. Since I am using a 20MHz external clock, we use these lines to set DEVCFG2 to proper values.
#pragma config UPLLEN = ON // USB PLL Enable
#pragma config UPLLIDIV = DIV_5 // USB PLL Divider
// 20MHz / 5 * 24 / 2 = 48MHz

=== USB Stack Operation ===

A function called USBDeviceTasks() defined in usb_device.c handles USB events, host requests, and enumeration. This function must be called every ~1.8ms during enumeration, and at specific intervals during other operation. This timing can be faster than the minimum with no hitch, but slower causes failure in communication. The stack may operate in two modes, USB_POLLING, or USB_INTERRUPT as defined in usb_config.h.

USB_POLLING requires the developer to call USBDeviceTasks() manually faster than the minimum rate, whereas USB_INTERRUPT handles all timing automatically. In the demo, we use USB_INTERRUPT to handle this timing.

Below is some sample code in the while loop of a main function of PIC communicating via USB.
while(1){
if((USBGetDeviceState() < CONFIGURED_STATE) ||
(USBIsDeviceSuspended() == TRUE))
{
//Either the device is not configured or we are suspended,
// so we don't want to execute any USB related application code
continue; //go back to the top of the while loop
}
if(!HIDRxHandleBusy(USBOutHandle)) //Check if data was received from the host.
{
//Do something with the data
ToSendDataBuffer[0] = ReceivedDataBuffer[0];
//Re-arm the OUT endpoint for the next packet
USBOutHandle = HIDRxPacket(HID_EP,(BYTE*)&ReceivedDataBuffer,64);
}
if(!HIDTxHandleBusy(USBInHandle)){
// Send out new data
USBInHandle = HIDTxPacket(HID_EP,(BYTE*)&ToSendDataBuffer[0],64);
}
}

==Processing and the HID API==

USB Communication using PIC microcontrollers

2012-07-03T23:11:25Z

DavidMeyer: /* Add Application-Specific USB files */

'''***Under Construction***'''

==USB Overview==

Universal Serial Bus, or USB, is a very common method of communication between electronic devices. USB is universal, meaning that it's standard across all electronic devices, serial, meaning that data is transmitted on only one data line one bit at a time, and is a bus, meaning that all devices are connected through the same parallel electronic wires and therefore require addresses. A simple USB connection requires a host and a device. The host initiates all communication, assigns device addresses, and controls the flow of the data line in the connection. For our purposes, the USB host will be the PC and the USB device will be a PIC chip.

There are many different speeds associated with USB. USB 1.0 introduced data rates of 1.5 Mbits/s ('''Low-Speed''') and 12 Mbits/s ('''Full-Speed'''). With USB 2.0 and 3.0, data rates of 480 Mbits/s ('''Hi-Speed''') and 5 Gbits/s ('''Super-Speed'''), were added respectively. PIC chips have hardware capable of full speed USB.

===Hardware===

A USB cable has 4 wires: power (red), ground (black), D+ (green), and D- (white). You may notice that many USB plugs and receptacles have 5 pins. This fifth pin is called ID, and is often not connected, but has been added to the specifications for use with USB-OTG, or On-The-Go. OTG allows devices to also act as a host. Many PIC chips are compatible with USB-OTG communication, but we will not discuss this topic any further at this point.

The two data lines, D+ and D-, provide information about the state of the USB link.

*Detached State, or SE0 - device is unplugged, both data lines are low, pulled down by 15 kOhm resistors within the host hardware.
*Attached State, Idle State, or J State - the device pulls up the D+ line (for a high-speed device) when it is attached.
*K State - opposite polarity from J State. To communicate, the host or device alternates the device between the J and K states in specific patterns.
*Illegal State, or SE1 - both data lines are high. If this happens, there is a hardware problem with the USB link.

===Protocol===

Useful Links
[http://www.usb.org/developers/devclass_docs/HID1_11.pdf HID Specification]
[http://www.usbmadesimple.co.uk/index.html USB Made Simple]

==Microchip USB Stack==

Microchip has provided almost all of the code and examples to run USB code on PIC chips. This code is called the USB stack, and we will use this as the main library for communicating to PCs. Unfortunately, there are a few bugs for certain PIC chips and some quirks to getting the libraries setup in MPLAB. This section will document the steps necessary to install the USB stack and setup a proper programming environment in MPLAB.

===Installation===

====Download====

We'll begin with the assumption that the reader knows how to setup a project for a PIC chip in MPLAB and program their chip with some basic C code. The Microchip USB stack is a part of the Microchip Application Libraries, which are available at the Microchip website [http://www.microchip.com/MAL/ here].

You must download and install the entire Application Libraries package, which will place all the libraries in your C drive on a Windows machine and some other place ('''**FIND OUT WHERE**''') on a Mac. The name of the root directory should be something like "Microchip Solutions v2012...", but from here on out, we'll refer to the root directory of that installation as <MAL>.

====Include Libraries and Driver in Project====

Once the installer has finished running, the actual USB stack is located at <MAL>/Microchip/USB. <MAL>/USB is not the stack, and only contains demos of the firmware for learning purposes. We will not be using any of those files for our purposes. After starting a project in MPLAB for your PIC chip, you must complete the following steps:

*Include the USB libraries in your project
**In MPLAB X, right-click on your project and select properties. In the left-sidebar, click on your compiler (pic32-gcc for PIC32 chips). In the main window, find the field called "Include Directories" and click the button with "..." Add the directories <MAL>/Microchip/USB, <MAL>/Microchip/Include, and '''importantly''' your ''current project directory''. This last one is important because the stack references a Hardware Profile which we will include in our own project directory.
*Add the HID device drivers to your project
**In MPLAB X, right-click on your project source files and select "add existing..." Browse to <MAL>/Microchip/USB and add '''usb_device.c''' and '''./HID Device Driver/usb_function_hid.c'''. These files do not need to be moved to your project directory, they just need to be added into your project via MPLAB.

====Add Application-Specific USB files====

Two additional header files and two additional source files specific to each application are required for the microcontroller to be fully USB functional.

*usb_config.h - provides configuration details for the mode of USB operation
*HardwareProfile.h - gives information about the specific microcontroller we're using
*usb_descriptors.c - defines all the descriptors used to tell the Host PC what kind of USB device we're connecting
*usb_callbacks.c - defines all callback functions executed when the driver detects certain conditions in the connection

The file attached below is a zip containing examples of these four files. This example provides generic USB HID operation under Microchip's VendorID (1240) and a ProductID of 0, operating in USB_INTERRUPT mode (described below).

[[Media:PIC32_USB_Files.zip]]

=== Microchip Stack Bug Notes ===

For the pic32mx2xx series, the usb interrupts are not configured correctly in the Microchip stack, so the following changes need to be made.

'''In <MAL>/Microchip/Include/usb_hal_pic32.h (Line 365):'''

This section normally sets the bits to configure IPC11, the USB interrupt location, but on the pic32mx2xx series, the USB interrupt bits are located at IPC7, as detailed in the Interrupt Controller chapter of the PIC datasheet. We've added a precompiler if statement to detect if a specific chip is being used. It's simple to change this for your specific chip though.

#if defined(USB_INTERRUPT)
// This is edited for use with the PIC32MX250F128B
#ifdef __32MX250F128B__
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC7CLR=0x00FF0000;IPC7SET=0x00100000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#else
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC11CLR=0x0000FF00;IPC11SET=0x00001000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#endif
#else
#define USBEnableInterrupts()
#endif

'''In <MAL>/Microchip/USB/usb_device.c (Line 673)'''
The Microchip stack assumes that the USB interrupt vector is 45 but this has changed to 30 for the pic32mx2xx series.

The line:
void __attribute__((interrupt(),vector(45))) _USB1Interrupt( void )

Should be:
void __attribute__((interrupt(),vector(_USB_1_VECTOR))) _USB1Interrupt( void )

=== USB Hardware Notes ===

It is important to use an external clock or oscillator in order to use the USB module. A 48 MHz clock is required for proper operation. The clock configuration can be seen in the data sheet, but for the pic32mx2xx series a 4 Mhz clock is required before the USB PLL. Since I am using a 20MHz external clock, we use these lines to set DEVCFG2 to proper values.
#pragma config UPLLEN = ON // USB PLL Enable
#pragma config UPLLIDIV = DIV_5 // USB PLL Divider
// 20MHz / 5 * 24 / 2 = 48MHz

=== USB Stack Operation ===

A function called USBDeviceTasks() defined in usb_device.c handles USB events, host requests, and enumeration. This function must be called every ~1.8ms during enumeration, and at specific intervals during other operation. This timing can be faster than the minimum with no hitch, but slower causes failure in communication. The stack may operate in two modes, USB_POLLING, or USB_INTERRUPT as defined in usb_config.h.

USB_POLLING requires the developer to call USBDeviceTasks() manually faster than the minimum rate, whereas USB_INTERRUPT handles all timing automatically. In the demo, we use USB_INTERRUPT to handle this timing.

==Processing and the HID API==

USB Communication using PIC microcontrollers

2012-07-03T22:46:47Z

DavidMeyer: /* Microchip USB Stack */

'''***Under Construction***'''

==USB Overview==

Universal Serial Bus, or USB, is a very common method of communication between electronic devices. USB is universal, meaning that it's standard across all electronic devices, serial, meaning that data is transmitted on only one data line one bit at a time, and is a bus, meaning that all devices are connected through the same parallel electronic wires and therefore require addresses. A simple USB connection requires a host and a device. The host initiates all communication, assigns device addresses, and controls the flow of the data line in the connection. For our purposes, the USB host will be the PC and the USB device will be a PIC chip.

There are many different speeds associated with USB. USB 1.0 introduced data rates of 1.5 Mbits/s ('''Low-Speed''') and 12 Mbits/s ('''Full-Speed'''). With USB 2.0 and 3.0, data rates of 480 Mbits/s ('''Hi-Speed''') and 5 Gbits/s ('''Super-Speed'''), were added respectively. PIC chips have hardware capable of full speed USB.

===Hardware===

A USB cable has 4 wires: power (red), ground (black), D+ (green), and D- (white). You may notice that many USB plugs and receptacles have 5 pins. This fifth pin is called ID, and is often not connected, but has been added to the specifications for use with USB-OTG, or On-The-Go. OTG allows devices to also act as a host. Many PIC chips are compatible with USB-OTG communication, but we will not discuss this topic any further at this point.

The two data lines, D+ and D-, provide information about the state of the USB link.

*Detached State, or SE0 - device is unplugged, both data lines are low, pulled down by 15 kOhm resistors within the host hardware.
*Attached State, Idle State, or J State - the device pulls up the D+ line (for a high-speed device) when it is attached.
*K State - opposite polarity from J State. To communicate, the host or device alternates the device between the J and K states in specific patterns.
*Illegal State, or SE1 - both data lines are high. If this happens, there is a hardware problem with the USB link.

===Protocol===

Useful Links
[http://www.usb.org/developers/devclass_docs/HID1_11.pdf HID Specification]
[http://www.usbmadesimple.co.uk/index.html USB Made Simple]

==Microchip USB Stack==

Microchip has provided almost all of the code and examples to run USB code on PIC chips. This code is called the USB stack, and we will use this as the main library for communicating to PCs. Unfortunately, there are a few bugs for certain PIC chips and some quirks to getting the libraries setup in MPLAB. This section will document the steps necessary to install the USB stack and setup a proper programming environment in MPLAB.

===Installation===

====Download====

We'll begin with the assumption that the reader knows how to setup a project for a PIC chip in MPLAB and program their chip with some basic C code. The Microchip USB stack is a part of the Microchip Application Libraries, which are available at the Microchip website [http://www.microchip.com/MAL/ here].

You must download and install the entire Application Libraries package, which will place all the libraries in your C drive on a Windows machine and some other place ('''**FIND OUT WHERE**''') on a Mac. The name of the root directory should be something like "Microchip Solutions v2012...", but from here on out, we'll refer to the root directory of that installation as <MAL>.

====Include Libraries and Driver in Project====

Once the installer has finished running, the actual USB stack is located at <MAL>/Microchip/USB. <MAL>/USB is not the stack, and only contains demos of the firmware for learning purposes. We will not be using any of those files for our purposes. After starting a project in MPLAB for your PIC chip, you must complete the following steps:

*Include the USB libraries in your project
**In MPLAB X, right-click on your project and select properties. In the left-sidebar, click on your compiler (pic32-gcc for PIC32 chips). In the main window, find the field called "Include Directories" and click the button with "..." Add the directories <MAL>/Microchip/USB, <MAL>/Microchip/Include, and '''importantly''' your ''current project directory''. This last one is important because the stack references a Hardware Profile which we will include in our own project directory.
*Add the HID device drivers to your project
**In MPLAB X, right-click on your project source files and select "add existing..." Browse to <MAL>/Microchip/USB and add '''usb_device.c''' and '''./HID Device Driver/usb_function_hid.c'''. These files do not need to be moved to your project directory, they just need to be added into your project via MPLAB.

====Add Application-Specific USB files====

Two additional header files and two additional source files specific to each application are required for the microcontroller to be fully USB functional.

*usb_config.h - provides configuration details for the mode of USB operation
*HardwareProfile.h - gives information about the specific microcontroller we're using
*usb_descriptors.c - defines all the descriptors used to tell the Host PC what kind of USB device we're connecting
*usb_callbacks.c - defines all callback functions executed when the driver detects certain conditions in the connection

The file attached below is a zip containing examples of these four files. This example provides generic USB HID operation under Microchip's VendorID (1240) and a ProductID of 0, operating in USB_INTERRUPT mode (described below).

[[File:PIC32_USB_Files.zip]]

=== Microchip Stack Bug Notes ===

For the pic32mx2xx series, the usb interrupts are not configured correctly in the Microchip stack, so the following changes need to be made.

'''In <MAL>/Microchip/Include/usb_hal_pic32.h (Line 365):'''

This section normally sets the bits to configure IPC11, the USB interrupt location, but on the pic32mx2xx series, the USB interrupt bits are located at IPC7, as detailed in the Interrupt Controller chapter of the PIC datasheet. We've added a precompiler if statement to detect if a specific chip is being used. It's simple to change this for your specific chip though.

#if defined(USB_INTERRUPT)
// This is edited for use with the PIC32MX250F128B
#ifdef __32MX250F128B__
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC7CLR=0x00FF0000;IPC7SET=0x00100000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#else
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC11CLR=0x0000FF00;IPC11SET=0x00001000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#endif
#else
#define USBEnableInterrupts()
#endif

'''In <MAL>/Microchip/USB/usb_device.c (Line 673)'''
The Microchip stack assumes that the USB interrupt vector is 45 but this has changed to 30 for the pic32mx2xx series.

The line:
void __attribute__((interrupt(),vector(45))) _USB1Interrupt( void )

Should be:
void __attribute__((interrupt(),vector(_USB_1_VECTOR))) _USB1Interrupt( void )

=== USB Hardware Notes ===

It is important to use an external clock or oscillator in order to use the USB module. A 48 MHz clock is required for proper operation. The clock configuration can be seen in the data sheet, but for the pic32mx2xx series a 4 Mhz clock is required before the USB PLL. Since I am using a 20MHz external clock, we use these lines to set DEVCFG2 to proper values.
#pragma config UPLLEN = ON // USB PLL Enable
#pragma config UPLLIDIV = DIV_5 // USB PLL Divider
// 20MHz / 5 * 24 / 2 = 48MHz

=== USB Stack Operation ===

A function called USBDeviceTasks() defined in usb_device.c handles USB events, host requests, and enumeration. This function must be called every ~1.8ms during enumeration, and at specific intervals during other operation. This timing can be faster than the minimum with no hitch, but slower causes failure in communication. The stack may operate in two modes, USB_POLLING, or USB_INTERRUPT as defined in usb_config.h.

USB_POLLING requires the developer to call USBDeviceTasks() manually faster than the minimum rate, whereas USB_INTERRUPT handles all timing automatically. In the demo, we use USB_INTERRUPT to handle this timing.

==Processing and the HID API==

USB Communication using PIC microcontrollers

2012-07-03T22:45:36Z

DavidMeyer:

'''***Under Construction***'''

==USB Overview==

Universal Serial Bus, or USB, is a very common method of communication between electronic devices. USB is universal, meaning that it's standard across all electronic devices, serial, meaning that data is transmitted on only one data line one bit at a time, and is a bus, meaning that all devices are connected through the same parallel electronic wires and therefore require addresses. A simple USB connection requires a host and a device. The host initiates all communication, assigns device addresses, and controls the flow of the data line in the connection. For our purposes, the USB host will be the PC and the USB device will be a PIC chip.

There are many different speeds associated with USB. USB 1.0 introduced data rates of 1.5 Mbits/s ('''Low-Speed''') and 12 Mbits/s ('''Full-Speed'''). With USB 2.0 and 3.0, data rates of 480 Mbits/s ('''Hi-Speed''') and 5 Gbits/s ('''Super-Speed'''), were added respectively. PIC chips have hardware capable of full speed USB.

===Hardware===

A USB cable has 4 wires: power (red), ground (black), D+ (green), and D- (white). You may notice that many USB plugs and receptacles have 5 pins. This fifth pin is called ID, and is often not connected, but has been added to the specifications for use with USB-OTG, or On-The-Go. OTG allows devices to also act as a host. Many PIC chips are compatible with USB-OTG communication, but we will not discuss this topic any further at this point.

The two data lines, D+ and D-, provide information about the state of the USB link.

*Detached State, or SE0 - device is unplugged, both data lines are low, pulled down by 15 kOhm resistors within the host hardware.
*Attached State, Idle State, or J State - the device pulls up the D+ line (for a high-speed device) when it is attached.
*K State - opposite polarity from J State. To communicate, the host or device alternates the device between the J and K states in specific patterns.
*Illegal State, or SE1 - both data lines are high. If this happens, there is a hardware problem with the USB link.

===Protocol===

Useful Links
[http://www.usb.org/developers/devclass_docs/HID1_11.pdf HID Specification]
[http://www.usbmadesimple.co.uk/index.html USB Made Simple]

==Microchip USB Stack==

Microchip has provided almost all of the code and examples to run USB code on PIC chips. This code is called the USB stack, and we will use this as the main library for communicating to PCs. Unfortunately, there are a few bugs for certain PIC chips and some quirks to getting the libraries setup in MPLAB. This section will document the steps necessary to install the USB stack and setup a proper programming environment in MPLAB.

===Download===

We'll begin with the assumption that the reader knows how to setup a project for a PIC chip in MPLAB and program their chip with some basic C code. The Microchip USB stack is a part of the Microchip Application Libraries, which are available at the Microchip website [http://www.microchip.com/MAL/ here].

You must download and install the entire Application Libraries package, which will place all the libraries in your C drive on a Windows machine and some other place ('''**FIND OUT WHERE**''') on a Mac. The name of the root directory should be something like "Microchip Solutions v2012...", but from here on out, we'll refer to the root directory of that installation as <MAL>.

===Include Libraries and Driver in Project===

Once the installer has finished running, the actual USB stack is located at <MAL>/Microchip/USB. <MAL>/USB is not the stack, and only contains demos of the firmware for learning purposes. We will not be using any of those files for our purposes. After starting a project in MPLAB for your PIC chip, you must complete the following steps:

*Include the USB libraries in your project
**In MPLAB X, right-click on your project and select properties. In the left-sidebar, click on your compiler (pic32-gcc for PIC32 chips). In the main window, find the field called "Include Directories" and click the button with "..." Add the directories <MAL>/Microchip/USB, <MAL>/Microchip/Include, and '''importantly''' your ''current project directory''. This last one is important because the stack references a Hardware Profile which we will include in our own project directory.
*Add the HID device drivers to your project
**In MPLAB X, right-click on your project source files and select "add existing..." Browse to <MAL>/Microchip/USB and add '''usb_device.c''' and '''./HID Device Driver/usb_function_hid.c'''. These files do not need to be moved to your project directory, they just need to be added into your project via MPLAB.

===Add Application-Specific USB files===

Two additional header files and two additional source files specific to each application are required for the microcontroller to be fully USB functional.

*usb_config.h - provides configuration details for the mode of USB operation
*HardwareProfile.h - gives information about the specific microcontroller we're using
*usb_descriptors.c - defines all the descriptors used to tell the Host PC what kind of USB device we're connecting
*usb_callbacks.c - defines all callback functions executed when the driver detects certain conditions in the connection

The file attached below is a zip containing examples of these four files. This example provides generic USB HID operation under Microchip's VendorID (1240) and a ProductID of 0, operating in USB_INTERRUPT mode (described below).

[[File:PIC32_USB_Files.zip]]

=== Microchip Stack Bug Notes ===

For the pic32mx2xx series, the usb interrupts are not configured correctly in the Microchip stack, so the following changes need to be made.

'''In <MAL>/Microchip/Include/usb_hal_pic32.h (Line 365):'''

This section normally sets the bits to configure IPC11, the USB interrupt location, but on the pic32mx2xx series, the USB interrupt bits are located at IPC7, as detailed in the Interrupt Controller chapter of the PIC datasheet. We've added a precompiler if statement to detect if a specific chip is being used. It's simple to change this for your specific chip though.

#if defined(USB_INTERRUPT)
// This is edited for use with the PIC32MX250F128B
#ifdef __32MX250F128B__
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC7CLR=0x00FF0000;IPC7SET=0x00100000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#else
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC11CLR=0x0000FF00;IPC11SET=0x00001000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#endif
#else
#define USBEnableInterrupts()
#endif

'''In <MAL>/Microchip/USB/usb_device.c (Line 673)'''
The Microchip stack assumes that the USB interrupt vector is 45 but this has changed to 30 for the pic32mx2xx series.

The line:
void __attribute__((interrupt(),vector(45))) _USB1Interrupt( void )

Should be:
void __attribute__((interrupt(),vector(_USB_1_VECTOR))) _USB1Interrupt( void )

=== USB Hardware Notes ===

It is important to use an external clock or oscillator in order to use the USB module. A 48 MHz clock is required for proper operation. The clock configuration can be seen in the data sheet, but for the pic32mx2xx series a 4 Mhz clock is required before the USB PLL. Since I am using a 20MHz external clock, we use these lines to set DEVCFG2 to proper values.
#pragma config UPLLEN = ON // USB PLL Enable
#pragma config UPLLIDIV = DIV_5 // USB PLL Divider
// 20MHz / 5 * 24 / 2 = 48MHz

=== USB Stack Operation ===

A function called USBDeviceTasks() defined in usb_device.c handles USB events, host requests, and enumeration. This function must be called every ~1.8ms during enumeration, and at specific intervals during other operation. This timing can be faster than the minimum with no hitch, but slower causes failure in communication. The stack may operate in two modes, USB_POLLING, or USB_INTERRUPT as defined in usb_config.h.

USB_POLLING requires the developer to call USBDeviceTasks() manually faster than the minimum rate, whereas USB_INTERRUPT handles all timing automatically. In the demo, we use USB_INTERRUPT to handle this timing.

==Processing and the HID API==

File:PIC32 USB Files.zip

2012-07-03T22:40:42Z

DavidMeyer: Application specific files for using the Microchip USB Stack

Application specific files for using the Microchip USB Stack

USB Communication using PIC microcontrollers

2012-07-03T22:28:31Z

DavidMeyer: /* USB Hardware Notes */

'''***Under Construction***'''

==USB Overview==

Universal Serial Bus, or USB, is a very common method of communication between electronic devices. USB is universal, meaning that it's standard across all electronic devices, serial, meaning that data is transmitted on only one data line one bit at a time, and is a bus, meaning that all devices are connected through the same parallel electronic wires and therefore require addresses. A simple USB connection requires a host and a device. The host initiates all communication, assigns device addresses, and controls the flow of the data line in the connection. For our purposes, the USB host will be the PC and the USB device will be a PIC chip.

There are many different speeds associated with USB. USB 1.0 introduced data rates of 1.5 Mbits/s ('''Low-Speed''') and 12 Mbits/s ('''Full-Speed'''). With USB 2.0 and 3.0, data rates of 480 Mbits/s ('''Hi-Speed''') and 5 Gbits/s ('''Super-Speed'''), were added respectively. PIC chips have hardware capable of full speed USB.

===Hardware===

A USB cable has 4 wires: power (red), ground (black), D+ (green), and D- (white). You may notice that many USB plugs and receptacles have 5 pins. This fifth pin is called ID, and is often not connected, but has been added to the specifications for use with USB-OTG, or On-The-Go. OTG allows devices to also act as a host. Many PIC chips are compatible with USB-OTG communication, but we will not discuss this topic any further at this point.

The two data lines, D+ and D-, provide information about the state of the USB link.

*Detached State, or SE0 - device is unplugged, both data lines are low, pulled down by 15 kOhm resistors within the host hardware.
*Attached State, Idle State, or J State - the device pulls up the D+ line (for a high-speed device) when it is attached.
*K State - opposite polarity from J State. To communicate, the host or device alternates the device between the J and K states in specific patterns.
*Illegal State, or SE1 - both data lines are high. If this happens, there is a hardware problem with the USB link.

===Protocol===

Useful Links
[http://www.usb.org/developers/devclass_docs/HID1_11.pdf HID Specification]
[http://www.usbmadesimple.co.uk/index.html USB Made Simple]

==Microchip USB Stack==

Microchip has provided almost all of the code and examples to run USB code on PIC chips. This code is called the USB stack, and we will use this as the main library for communicating to PCs. Unfortunately, there are a few bugs for certain PIC chips and some quirks to getting the libraries setup in MPLAB. This section will document the steps necessary to install the USB stack and setup a proper programming environment in MPLAB.

===Download===

We'll begin with the assumption that the reader knows how to setup a project for a PIC chip in MPLAB and program their chip with some basic C code. The Microchip USB stack is a part of the Microchip Application Libraries, which are available at the Microchip website [http://www.microchip.com/MAL/ here].

You must download and install the entire Application Libraries package, which will place all the libraries in your C drive on a Windows machine and some other place ('''**FIND OUT WHERE**''') on a Mac. The name of the root directory should be something like "Microchip Solutions v2012...", but from here on out, we'll refer to the root directory of that installation as <MAL>.

===Include Libraries and Driver in Project===

Once the installer has finished running, the actual USB stack is located at <MAL>/Microchip/USB. <MAL>/USB is not the stack, and only contains demos of the firmware for learning purposes. We will not be using any of those files for our purposes. After starting a project in MPLAB for your PIC chip, you must complete the following steps:

*Include the USB libraries in your project
**In MPLAB X, right-click on your project and select properties. In the left-sidebar, click on your compiler (pic32-gcc for PIC32 chips). In the main window, find the field called "Include Directories" and click the button with "..." Add the directories <MAL>/Microchip/USB, <MAL>/Microchip/Include, and '''importantly''' your ''current project directory''. This last one is important because the stack references a Hardware Profile which we will include in our own project directory.
*Add the HID device drivers to your project
**In MPLAB X, right-click on your project source files and select "add existing..." Browse to <MAL>/Microchip/USB and add '''usb_device.c''' and '''./HID Device Driver/usb_function_hid.c'''. These files do not need to be moved to your project directory, they just need to be added into your project via MPLAB.

===Add Application-Specific USB files===

Two additional header files and two additional source files specific to each application are required for the microcontroller to be fully USB functional.

*usb_config.h - provides configuration details for the mode of USB operation
*HardwareProfile.h - gives information about the specific microcontroller we're using
*usb_descriptors.c - defines all the descriptors used to tell the Host PC what kind of USB device we're connecting
*usb_callbacks.c - defines all callback functions executed when the driver detects certain conditions in the connection

=== Microchip Stack Bug Notes ===

For the pic32mx2xx series, the usb interrupts are not configured correctly in the Microchip stack, so the following changes need to be made.

'''In <MAL>/Microchip/Include/usb_hal_pic32.h (Line 365):'''

This section normally sets the bits to configure IPC11, the USB interrupt location, but on the pic32mx2xx series, the USB interrupt bits are located at IPC7, as detailed in the Interrupt Controller chapter of the PIC datasheet. We've added a precompiler if statement to detect if a specific chip is being used. It's simple to change this for your specific chip though.

#if defined(USB_INTERRUPT)
// This is edited for use with the PIC32MX250F128B
#ifdef __32MX250F128B__
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC7CLR=0x00FF0000;IPC7SET=0x00100000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#else
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC11CLR=0x0000FF00;IPC11SET=0x00001000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#endif
#else
#define USBEnableInterrupts()
#endif

'''In <MAL>/Microchip/USB/usb_device.c (Line 673)'''
The Microchip stack assumes that the USB interrupt vector is 45 but this has changed to 30 for the pic32mx2xx series.

The line:
void __attribute__((interrupt(),vector(45))) _USB1Interrupt( void )

Should be:
void __attribute__((interrupt(),vector(_USB_1_VECTOR))) _USB1Interrupt( void )

=== USB Hardware Notes ===

It is important to use an external clock or oscillator in order to use the USB module. A 48 MHz clock is required for proper operation. The clock configuration can be seen in the data sheet, but for the pic32mx2xx series a 4 Mhz clock is required before the USB PLL. Since I am using a 20MHz external clock, we use these lines to set DEVCFG2 to proper values.
#pragma config UPLLEN = ON // USB PLL Enable
#pragma config UPLLIDIV = DIV_5 // USB PLL Divider
// 20MHz / 5 * 24 / 2 = 48MHz

=== USB Stack Operation ===

A function called USBDeviceTasks() defined in usb_device.c handles USB events, host requests, and enumeration. This function must be called every ~1.8ms during enumeration, and at specific intervals during other operation. This timing can be faster than the minimum with no hitch, but slower causes failure in communication. The stack may operate in two modes, USB_POLLING, or USB_INTERRUPT as defined in usb_config.h.

USB_POLLING requires the developer to call USBDeviceTasks() manually faster than the minimum rate, whereas USB_INTERRUPT handles all timing automatically. In the demo, we use USB_INTERRUPT to handle this timing.

==Processing and the HID API==

USB Communication using PIC microcontrollers

2012-07-03T22:18:50Z

DavidMeyer: /* Protocol */

'''***Under Construction***'''

==USB Overview==

Universal Serial Bus, or USB, is a very common method of communication between electronic devices. USB is universal, meaning that it's standard across all electronic devices, serial, meaning that data is transmitted on only one data line one bit at a time, and is a bus, meaning that all devices are connected through the same parallel electronic wires and therefore require addresses. A simple USB connection requires a host and a device. The host initiates all communication, assigns device addresses, and controls the flow of the data line in the connection. For our purposes, the USB host will be the PC and the USB device will be a PIC chip.

There are many different speeds associated with USB. USB 1.0 introduced data rates of 1.5 Mbits/s ('''Low-Speed''') and 12 Mbits/s ('''Full-Speed'''). With USB 2.0 and 3.0, data rates of 480 Mbits/s ('''Hi-Speed''') and 5 Gbits/s ('''Super-Speed'''), were added respectively. PIC chips have hardware capable of full speed USB.

===Hardware===

A USB cable has 4 wires: power (red), ground (black), D+ (green), and D- (white). You may notice that many USB plugs and receptacles have 5 pins. This fifth pin is called ID, and is often not connected, but has been added to the specifications for use with USB-OTG, or On-The-Go. OTG allows devices to also act as a host. Many PIC chips are compatible with USB-OTG communication, but we will not discuss this topic any further at this point.

The two data lines, D+ and D-, provide information about the state of the USB link.

*Detached State, or SE0 - device is unplugged, both data lines are low, pulled down by 15 kOhm resistors within the host hardware.
*Attached State, Idle State, or J State - the device pulls up the D+ line (for a high-speed device) when it is attached.
*K State - opposite polarity from J State. To communicate, the host or device alternates the device between the J and K states in specific patterns.
*Illegal State, or SE1 - both data lines are high. If this happens, there is a hardware problem with the USB link.

===Protocol===

Useful Links
[http://www.usb.org/developers/devclass_docs/HID1_11.pdf HID Specification]
[http://www.usbmadesimple.co.uk/index.html USB Made Simple]

==Microchip USB Stack==

Microchip has provided almost all of the code and examples to run USB code on PIC chips. This code is called the USB stack, and we will use this as the main library for communicating to PCs. Unfortunately, there are a few bugs for certain PIC chips and some quirks to getting the libraries setup in MPLAB. This section will document the steps necessary to install the USB stack and setup a proper programming environment in MPLAB.

===Download===

We'll begin with the assumption that the reader knows how to setup a project for a PIC chip in MPLAB and program their chip with some basic C code. The Microchip USB stack is a part of the Microchip Application Libraries, which are available at the Microchip website [http://www.microchip.com/MAL/ here].

You must download and install the entire Application Libraries package, which will place all the libraries in your C drive on a Windows machine and some other place ('''**FIND OUT WHERE**''') on a Mac. The name of the root directory should be something like "Microchip Solutions v2012...", but from here on out, we'll refer to the root directory of that installation as <MAL>.

===Include Libraries and Driver in Project===

Once the installer has finished running, the actual USB stack is located at <MAL>/Microchip/USB. <MAL>/USB is not the stack, and only contains demos of the firmware for learning purposes. We will not be using any of those files for our purposes. After starting a project in MPLAB for your PIC chip, you must complete the following steps:

*Include the USB libraries in your project
**In MPLAB X, right-click on your project and select properties. In the left-sidebar, click on your compiler (pic32-gcc for PIC32 chips). In the main window, find the field called "Include Directories" and click the button with "..." Add the directories <MAL>/Microchip/USB, <MAL>/Microchip/Include, and '''importantly''' your ''current project directory''. This last one is important because the stack references a Hardware Profile which we will include in our own project directory.
*Add the HID device drivers to your project
**In MPLAB X, right-click on your project source files and select "add existing..." Browse to <MAL>/Microchip/USB and add '''usb_device.c''' and '''./HID Device Driver/usb_function_hid.c'''. These files do not need to be moved to your project directory, they just need to be added into your project via MPLAB.

===Add Application-Specific USB files===

Two additional header files and two additional source files specific to each application are required for the microcontroller to be fully USB functional.

*usb_config.h - provides configuration details for the mode of USB operation
*HardwareProfile.h - gives information about the specific microcontroller we're using
*usb_descriptors.c - defines all the descriptors used to tell the Host PC what kind of USB device we're connecting
*usb_callbacks.c - defines all callback functions executed when the driver detects certain conditions in the connection

=== Microchip Stack Bug Notes ===

For the pic32mx2xx series, the usb interrupts are not configured correctly in the Microchip stack, so the following changes need to be made.

'''In <MAL>/Microchip/Include/usb_hal_pic32.h (Line 365):'''

This section normally sets the bits to configure IPC11, the USB interrupt location, but on the pic32mx2xx series, the USB interrupt bits are located at IPC7, as detailed in the Interrupt Controller chapter of the PIC datasheet. We've added a precompiler if statement to detect if a specific chip is being used. It's simple to change this for your specific chip though.

#if defined(USB_INTERRUPT)
// This is edited for use with the PIC32MX250F128B
#ifdef __32MX250F128B__
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC7CLR=0x00FF0000;IPC7SET=0x00100000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#else
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC11CLR=0x0000FF00;IPC11SET=0x00001000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#endif
#else
#define USBEnableInterrupts()
#endif

'''In <MAL>/Microchip/USB/usb_device.c (Line 673)'''
The Microchip stack assumes that the USB interrupt vector is 45 but this has changed to 30 for the pic32mx2xx series.

The line:
void __attribute__((interrupt(),vector(45))) _USB1Interrupt( void )

Should be:
void __attribute__((interrupt(),vector(_USB_1_VECTOR))) _USB1Interrupt( void )

=== USB Hardware Notes ===

It is rather important to use an external clock or oscillator in order to use the USB module. A 48 MHz clock is required for proper operation. The clock configuration can be seen in the data sheet, but for the pic32mx2xx series a 4 Mhz clock is required before the USB PLL. Since I am using a 20MHz external clock, we use these lines to set DEVCFG2 to proper values.
#pragma config UPLLEN = ON // USB PLL Enable
#pragma config UPLLIDIV = DIV_5 // USB PLL Divider
// 20MHz / 5 * 24 / 2 = 48MHz

=== USB Stack Operation ===

A function called USBDeviceTasks() defined in usb_device.c handles USB events, host requests, and enumeration. This function must be called every ~1.8ms during enumeration, and at specific intervals during other operation. This timing can be faster than the minimum with no hitch, but slower causes failure in communication. The stack may operate in two modes, USB_POLLING, or USB_INTERRUPT as defined in usb_config.h.

USB_POLLING requires the developer to call USBDeviceTasks() manually faster than the minimum rate, whereas USB_INTERRUPT handles all timing automatically. In the demo, we use USB_INTERRUPT to handle this timing.

==Processing and the HID API==

USB Communication using PIC microcontrollers

2012-07-03T22:13:19Z

DavidMeyer: /* USB Stack Operation */

'''***Under Construction***'''

==USB Overview==

Universal Serial Bus, or USB, is a very common method of communication between electronic devices. USB is universal, meaning that it's standard across all electronic devices, serial, meaning that data is transmitted on only one data line one bit at a time, and is a bus, meaning that all devices are connected through the same parallel electronic wires and therefore require addresses. A simple USB connection requires a host and a device. The host initiates all communication, assigns device addresses, and controls the flow of the data line in the connection. For our purposes, the USB host will be the PC and the USB device will be a PIC chip.

There are many different speeds associated with USB. USB 1.0 introduced data rates of 1.5 Mbits/s ('''Low-Speed''') and 12 Mbits/s ('''Full-Speed'''). With USB 2.0 and 3.0, data rates of 480 Mbits/s ('''Hi-Speed''') and 5 Gbits/s ('''Super-Speed'''), were added respectively. PIC chips have hardware capable of full speed USB.

===Hardware===

A USB cable has 4 wires: power (red), ground (black), D+ (green), and D- (white). You may notice that many USB plugs and receptacles have 5 pins. This fifth pin is called ID, and is often not connected, but has been added to the specifications for use with USB-OTG, or On-The-Go. OTG allows devices to also act as a host. Many PIC chips are compatible with USB-OTG communication, but we will not discuss this topic any further at this point.

The two data lines, D+ and D-, provide information about the state of the USB link.

*Detached State, or SE0 - device is unplugged, both data lines are low, pulled down by 15 kOhm resistors within the host hardware.
*Attached State, Idle State, or J State - the device pulls up the D+ line (for a high-speed device) when it is attached.
*K State - opposite polarity from J State. To communicate, the host or device alternates the device between the J and K states in specific patterns.
*Illegal State, or SE1 - both data lines are high. If this happens, there is a hardware problem with the USB link.

===Protocol===

Useful Links [http://www.usb.org/developers/devclass_docs/HID1_11.pdf HID Specification]

All of these details are handled by the USB modules themselves, and the developer seldom needs to know these things. However, they are useful to those who are debugging hardware issues. More information about USB can be found at the [http://www.usbmadesimple.co.uk/index.html USB Made Simple] site.

==Microchip USB Stack==

Microchip has provided almost all of the code and examples to run USB code on PIC chips. This code is called the USB stack, and we will use this as the main library for communicating to PCs. Unfortunately, there are a few bugs for certain PIC chips and some quirks to getting the libraries setup in MPLAB. This section will document the steps necessary to install the USB stack and setup a proper programming environment in MPLAB.

===Download===

We'll begin with the assumption that the reader knows how to setup a project for a PIC chip in MPLAB and program their chip with some basic C code. The Microchip USB stack is a part of the Microchip Application Libraries, which are available at the Microchip website [http://www.microchip.com/MAL/ here].

You must download and install the entire Application Libraries package, which will place all the libraries in your C drive on a Windows machine and some other place ('''**FIND OUT WHERE**''') on a Mac. The name of the root directory should be something like "Microchip Solutions v2012...", but from here on out, we'll refer to the root directory of that installation as <MAL>.

===Include Libraries and Driver in Project===

Once the installer has finished running, the actual USB stack is located at <MAL>/Microchip/USB. <MAL>/USB is not the stack, and only contains demos of the firmware for learning purposes. We will not be using any of those files for our purposes. After starting a project in MPLAB for your PIC chip, you must complete the following steps:

*Include the USB libraries in your project
**In MPLAB X, right-click on your project and select properties. In the left-sidebar, click on your compiler (pic32-gcc for PIC32 chips). In the main window, find the field called "Include Directories" and click the button with "..." Add the directories <MAL>/Microchip/USB, <MAL>/Microchip/Include, and '''importantly''' your ''current project directory''. This last one is important because the stack references a Hardware Profile which we will include in our own project directory.
*Add the HID device drivers to your project
**In MPLAB X, right-click on your project source files and select "add existing..." Browse to <MAL>/Microchip/USB and add '''usb_device.c''' and '''./HID Device Driver/usb_function_hid.c'''. These files do not need to be moved to your project directory, they just need to be added into your project via MPLAB.

===Add Application-Specific USB files===

Two additional header files and two additional source files specific to each application are required for the microcontroller to be fully USB functional.

*usb_config.h - provides configuration details for the mode of USB operation
*HardwareProfile.h - gives information about the specific microcontroller we're using
*usb_descriptors.c - defines all the descriptors used to tell the Host PC what kind of USB device we're connecting
*usb_callbacks.c - defines all callback functions executed when the driver detects certain conditions in the connection

=== Microchip Stack Bug Notes ===

For the pic32mx2xx series, the usb interrupts are not configured correctly in the Microchip stack, so the following changes need to be made.

'''In <MAL>/Microchip/Include/usb_hal_pic32.h (Line 365):'''

This section normally sets the bits to configure IPC11, the USB interrupt location, but on the pic32mx2xx series, the USB interrupt bits are located at IPC7, as detailed in the Interrupt Controller chapter of the PIC datasheet. We've added a precompiler if statement to detect if a specific chip is being used. It's simple to change this for your specific chip though.

#if defined(USB_INTERRUPT)
// This is edited for use with the PIC32MX250F128B
#ifdef __32MX250F128B__
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC7CLR=0x00FF0000;IPC7SET=0x00100000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#else
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC11CLR=0x0000FF00;IPC11SET=0x00001000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#endif
#else
#define USBEnableInterrupts()
#endif

'''In <MAL>/Microchip/USB/usb_device.c (Line 673)'''
The Microchip stack assumes that the USB interrupt vector is 45 but this has changed to 30 for the pic32mx2xx series.

The line:
void __attribute__((interrupt(),vector(45))) _USB1Interrupt( void )

Should be:
void __attribute__((interrupt(),vector(_USB_1_VECTOR))) _USB1Interrupt( void )

=== USB Hardware Notes ===

It is rather important to use an external clock or oscillator in order to use the USB module. A 48 MHz clock is required for proper operation. The clock configuration can be seen in the data sheet, but for the pic32mx2xx series a 4 Mhz clock is required before the USB PLL. Since I am using a 20MHz external clock, we use these lines to set DEVCFG2 to proper values.
#pragma config UPLLEN = ON // USB PLL Enable
#pragma config UPLLIDIV = DIV_5 // USB PLL Divider
// 20MHz / 5 * 24 / 2 = 48MHz

=== USB Stack Operation ===

A function called USBDeviceTasks() defined in usb_device.c handles USB events, host requests, and enumeration. This function must be called every ~1.8ms during enumeration, and at specific intervals during other operation. This timing can be faster than the minimum with no hitch, but slower causes failure in communication. The stack may operate in two modes, USB_POLLING, or USB_INTERRUPT as defined in usb_config.h.

USB_POLLING requires the developer to call USBDeviceTasks() manually faster than the minimum rate, whereas USB_INTERRUPT handles all timing automatically. In the demo, we use USB_INTERRUPT to handle this timing.

==Processing and the HID API==

USB Communication using PIC microcontrollers

2012-07-03T22:12:18Z

DavidMeyer:

'''***Under Construction***'''

==USB Overview==

Universal Serial Bus, or USB, is a very common method of communication between electronic devices. USB is universal, meaning that it's standard across all electronic devices, serial, meaning that data is transmitted on only one data line one bit at a time, and is a bus, meaning that all devices are connected through the same parallel electronic wires and therefore require addresses. A simple USB connection requires a host and a device. The host initiates all communication, assigns device addresses, and controls the flow of the data line in the connection. For our purposes, the USB host will be the PC and the USB device will be a PIC chip.

There are many different speeds associated with USB. USB 1.0 introduced data rates of 1.5 Mbits/s ('''Low-Speed''') and 12 Mbits/s ('''Full-Speed'''). With USB 2.0 and 3.0, data rates of 480 Mbits/s ('''Hi-Speed''') and 5 Gbits/s ('''Super-Speed'''), were added respectively. PIC chips have hardware capable of full speed USB.

===Hardware===

A USB cable has 4 wires: power (red), ground (black), D+ (green), and D- (white). You may notice that many USB plugs and receptacles have 5 pins. This fifth pin is called ID, and is often not connected, but has been added to the specifications for use with USB-OTG, or On-The-Go. OTG allows devices to also act as a host. Many PIC chips are compatible with USB-OTG communication, but we will not discuss this topic any further at this point.

The two data lines, D+ and D-, provide information about the state of the USB link.

*Detached State, or SE0 - device is unplugged, both data lines are low, pulled down by 15 kOhm resistors within the host hardware.
*Attached State, Idle State, or J State - the device pulls up the D+ line (for a high-speed device) when it is attached.
*K State - opposite polarity from J State. To communicate, the host or device alternates the device between the J and K states in specific patterns.
*Illegal State, or SE1 - both data lines are high. If this happens, there is a hardware problem with the USB link.

===Protocol===

Useful Links [http://www.usb.org/developers/devclass_docs/HID1_11.pdf HID Specification]

All of these details are handled by the USB modules themselves, and the developer seldom needs to know these things. However, they are useful to those who are debugging hardware issues. More information about USB can be found at the [http://www.usbmadesimple.co.uk/index.html USB Made Simple] site.

==Microchip USB Stack==

Microchip has provided almost all of the code and examples to run USB code on PIC chips. This code is called the USB stack, and we will use this as the main library for communicating to PCs. Unfortunately, there are a few bugs for certain PIC chips and some quirks to getting the libraries setup in MPLAB. This section will document the steps necessary to install the USB stack and setup a proper programming environment in MPLAB.

===Download===

We'll begin with the assumption that the reader knows how to setup a project for a PIC chip in MPLAB and program their chip with some basic C code. The Microchip USB stack is a part of the Microchip Application Libraries, which are available at the Microchip website [http://www.microchip.com/MAL/ here].

You must download and install the entire Application Libraries package, which will place all the libraries in your C drive on a Windows machine and some other place ('''**FIND OUT WHERE**''') on a Mac. The name of the root directory should be something like "Microchip Solutions v2012...", but from here on out, we'll refer to the root directory of that installation as <MAL>.

===Include Libraries and Driver in Project===

Once the installer has finished running, the actual USB stack is located at <MAL>/Microchip/USB. <MAL>/USB is not the stack, and only contains demos of the firmware for learning purposes. We will not be using any of those files for our purposes. After starting a project in MPLAB for your PIC chip, you must complete the following steps:

*Include the USB libraries in your project
**In MPLAB X, right-click on your project and select properties. In the left-sidebar, click on your compiler (pic32-gcc for PIC32 chips). In the main window, find the field called "Include Directories" and click the button with "..." Add the directories <MAL>/Microchip/USB, <MAL>/Microchip/Include, and '''importantly''' your ''current project directory''. This last one is important because the stack references a Hardware Profile which we will include in our own project directory.
*Add the HID device drivers to your project
**In MPLAB X, right-click on your project source files and select "add existing..." Browse to <MAL>/Microchip/USB and add '''usb_device.c''' and '''./HID Device Driver/usb_function_hid.c'''. These files do not need to be moved to your project directory, they just need to be added into your project via MPLAB.

===Add Application-Specific USB files===

Two additional header files and two additional source files specific to each application are required for the microcontroller to be fully USB functional.

*usb_config.h - provides configuration details for the mode of USB operation
*HardwareProfile.h - gives information about the specific microcontroller we're using
*usb_descriptors.c - defines all the descriptors used to tell the Host PC what kind of USB device we're connecting
*usb_callbacks.c - defines all callback functions executed when the driver detects certain conditions in the connection

=== Microchip Stack Bug Notes ===

For the pic32mx2xx series, the usb interrupts are not configured correctly in the Microchip stack, so the following changes need to be made.

'''In <MAL>/Microchip/Include/usb_hal_pic32.h (Line 365):'''

This section normally sets the bits to configure IPC11, the USB interrupt location, but on the pic32mx2xx series, the USB interrupt bits are located at IPC7, as detailed in the Interrupt Controller chapter of the PIC datasheet. We've added a precompiler if statement to detect if a specific chip is being used. It's simple to change this for your specific chip though.

#if defined(USB_INTERRUPT)
// This is edited for use with the PIC32MX250F128B
#ifdef __32MX250F128B__
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC7CLR=0x00FF0000;IPC7SET=0x00100000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#else
#define USBEnableInterrupts() {IEC1bits.USBIE = 1; IPC11CLR=0x0000FF00;IPC11SET=0x00001000; INTEnableSystemMultiVectoredInt(); INTEnableInterrupts();}
#endif
#else
#define USBEnableInterrupts()
#endif

'''In <MAL>/Microchip/USB/usb_device.c (Line 673)'''
The Microchip stack assumes that the USB interrupt vector is 45 but this has changed to 30 for the pic32mx2xx series.

The line:
void __attribute__((interrupt(),vector(45))) _USB1Interrupt( void )

Should be:
void __attribute__((interrupt(),vector(_USB_1_VECTOR))) _USB1Interrupt( void )

=== USB Hardware Notes ===

It is rather important to use an external clock or oscillator in order to use the USB module. A 48 MHz clock is required for proper operation. The clock configuration can be seen in the data sheet, but for the pic32mx2xx series a 4 Mhz clock is required before the USB PLL. Since I am using a 20MHz external clock, we use these lines to set DEVCFG2 to proper values.
#pragma config UPLLEN = ON // USB PLL Enable
#pragma config UPLLIDIV = DIV_5 // USB PLL Divider
// 20MHz / 5 * 24 / 2 = 48MHz

=== USB Stack Operation ===

A function called USBDeviceTasks() defined in usb_device.c handles enumeration and detection with the PC. This function must be called every ~1.8ms during enumeration, and at specific intervals during other operation. This timing can be faster than the minimum with no hitch, but slower causes failure in communication. The stack may operate in two modes, USB_POLLING, or USB_INTERRUPT as defined in usb_config.h.

USB_POLLING requires the developer to call USBDeviceTasks() manually faster than the minimum rate, whereas USB_INTERRUPT handles all timing automatically. In the demo, we use USB_INTERRUPT to handle this timing.

==Processing and the HID API==

USB Communication using PIC microcontrollers

2012-07-03T21:31:01Z

DavidMeyer: /* Add Application-Specific USB files */

USB Communication using PIC microcontrollers

2012-06-29T15:13:33Z

DavidMeyer:

USB Communication using PIC microcontrollers

2012-06-28T05:09:11Z

DavidMeyer:

USB Communication using PIC microcontrollers

2012-06-28T04:45:35Z

DavidMeyer: /* Add Application-Specific USB files */

USB Communication using PIC microcontrollers

2012-06-27T16:10:34Z

DavidMeyer:

USB Communication using PIC microcontrollers

2012-06-22T19:28:42Z

DavidMeyer: /* Microchip USB Stack */