源代码程序如下所示：//*****************************************************************************//// u***_dev_bulk.c - Main routines for the generic bulk device example.//// Copyright (c) 2012-2014 Texas Instruments Incorporated.  All rights reserved.// Software License Agreement// // Texas Instruments (TI) is supplying this software for use solely and// exclusively on TI's microcontroller products. The software is owned by// TI and/or its suppliers, and is protected under applicable copyright// laws. You may not combine this software with "viral" open-source// software in order to form a larger program.// // THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL// DAMAGES, FOR ANY REASON WHATSOEVER.// // This is part of revision 2.1.0.12573 of the EK-TM4C123GXL Firmware Package.////*****************************************************************************#include #include #include "inc/hw_ints.h"#include "inc/hw_memmap.h"#include "inc/hw_types.h"#include "driverlib/debug.h"#include "driverlib/fpu.h"#include "driverlib/gpio.h"#include "driverlib/interrupt.h"#include "driverlib/pin_map.h"#include "driverlib/sysctl.h"#include "driverlib/systick.h"#include "driverlib/timer.h"#include "driverlib/uart.h"#include "driverlib/rom.h"#include "u***lib/u***lib.h"#include "u***lib/u***-ids.h"#include "u***lib/device/u***device.h"#include "u***lib/device/u***dbulk.h"#include "utils/uartstdio.h"#include "utils/ustdlib.h"#include "u***_bulk_structs.h"//*****************************************************************************////! addtogroup example_list//!

USB Generic Bulk Device (u***_dev_bulk)

//!//! This example provides a generic USB device offering simple bulk data//! transfer to and from the host.  The device uses a vendor-specific class ID//! and supports a single bulk IN endpoint and a single bulk OUT endpoint.//! Data received from the host is assumed to be ASCII text and it is//! echoed back with the case of all alphabetic characters swapped.//!//! A Windows INF file for the device is provided on the installation CD and//! in the C:/ti/TivaWare-for-C-Series/windows_drivers directory of TivaWare C//! series releases.  This INF contains information required to install the//! WinUSB subsystem on Windowi16XP and Vista PCs.  WinUSB is a Windows//! subsystem allowing user mode applications to access the USB device without//! the need for a vendor-specific kernel mode driver.//!//! A sample Windows command-line application, u***_bulk_example, illustrating//! how to connect to and communicate with the bulk device is also provided.//! The application binary is installed as part of the ''Windows-side examples//! for USB kits'' package (SW-USB-win) on the installation CD or via download//! from http://www.ti.com/tivaware .  Project files are included to allow//! the examples to be built using Microsoft VisualStudio 2008.  Source code//! for this application can be found in directory//! TivaWare-for-C-Series/tools/u***_bulk_example.////*****************************************************************************//*****************************************************************************//// The system tick rate expressed both as ticks per second and a millisecond// period.////*****************************************************************************#define SYSTICKS_PER_SECOND     100#define SYSTICK_PERIOD_MS       (1000 / SYSTICKS_PER_SECOND)//*****************************************************************************//// The global system tick counter.////*****************************************************************************volatile uint32_t g_ui32SysTickCount = 0;//*****************************************************************************//// Variables tracking transmit and receive counts.////*****************************************************************************volatile uint32_t g_ui32TxCount = 0;volatile uint32_t g_ui32RxCount = 0;#ifdef DEBUGuint32_t g_ui32UARTRxErrors = 0;#endif//*****************************************************************************//// Debug-related definitions and declarations.//// Debug output is available via UART0 if DEBUG is defined during build.////*****************************************************************************#ifdef DEBUG//*****************************************************************************//// Map all debug print calls to UARTprintf in debug builds.////*****************************************************************************#define DEBUG_PRINT UARTprintf#else//*****************************************************************************//// Compile out all debug print calls in release builds.////*****************************************************************************#define DEBUG_PRINT while(0) ((int (*)(char *, ...))0)#endif//*****************************************************************************//// Flags used to pass commands from interrupt context to the main loop.////*****************************************************************************#define COMMAND_PACKET_RECEIVED 0x00000001#define COMMAND_STATUS_UPDATE   0x00000002volatile uint32_t g_ui32Flags = 0;//*****************************************************************************//// Global flag indicating that a USB configuration has been set.////*****************************************************************************static volatile bool g_bUSBConfigured = false;//*****************************************************************************//// The error routine that is called if the driver library encounters an error.////*****************************************************************************#ifdef DEBUGvoid__error__(char *pcFilename, uint32_t ui32Line)[    UARTprintf("Error at line %d of %sn", ui32Line, pcFilename);    while(1)    [    ]]#endif//*****************************************************************************//// Interrupt handler for the system tick counter.////*****************************************************************************voidSysTickIntHandler(void)[    //    // Update our system tick counter.    //    g_ui32SysTickCount++;]//*****************************************************************************//// Receive new data and echo it back to the host.//// param psDevice points to the instance data for the device whose data is to// be processed.// param pui8Data points to the newly received data in the USB receive buffer.// param ui32NumBytes is the number of bytes of data available to be processed.//// This function is called whenever we receive a notification that data is// available from the host. We read the data, byte-by-byte and swap the case// of any alphabetical characters found then write it back out to be// transmitted back to the host.//// return Returns the number of bytes of data processed.////*****************************************************************************static uint32_tEchoNewDataToHost(tUSBDBulkDevice *psDevice, uint8_t *pui8Data,                  uint32_t ui32NumBytes)[    uint32_t ui32Loop, ui32Space, ui32Count;    uint32_t ui32ReadIndex;    uint32_t ui32WriteIndex;    tUSBRingBufObject sTxRing;    //    // Get the current buffer information to allow us to write directly to    // the transmit buffer (we already have enough information from the    // parameters to access the receive buffer directly).    //    USBBufferInfoGet(&g_sTxBuffer, &sTxRing);    //    // How much space is there in the transmit buffer?    //    ui32Space = USBBufferSpaceAvailable(&g_sTxBuffer);    //    // How many characters can we process this time round?    //    ui32Loop = (ui32Space < ui32NumBytes) ? ui32Space : ui32NumBytes;    ui32Count = ui32Loop;    //    // Update our receive counter.    //    g_ui32RxCount += ui32NumBytes;    //    // Dump a debug message.    //    DEBUG_PRINT("Received %d bytesn", ui32NumBytes);    //    // Set up to process the characters by directly accessing the USB buffers.    //    ui32ReadIndex = (uint32_t)(pui8Data - g_pui8USBRxBuffer);    ui32WriteIndex = sTxRing.ui32WriteIndex;    while(ui32Loop)    [        //        // Copy from the receive buffer to the transmit buffer converting        // character case on the way.        //        //        // Is this a lower case character?        //        if((g_pui8USBRxBuffer[ui32ReadIndex] >= 'a') &&           (g_pui8USBRxBuffer[ui32ReadIndex] <= 'z'))        [            //            // Convert to upper case and write to the transmit buffer.            //            g_pui8USBTxBuffer[ui32WriteIndex] =                (g_pui8USBRxBuffer[ui32ReadIndex] - 'a') + 'A';        ]        else        [            //            // Is this an upper case character?            //            if((g_pui8USBRxBuffer[ui32ReadIndex] >= 'A') &&               (g_pui8USBRxBuffer[ui32ReadIndex] <= 'Z'))            [                //                // Convert to lower case and write to the transmit buffer.                //                g_pui8USBTxBuffer[ui32WriteIndex] =                    (g_pui8USBRxBuffer[ui32ReadIndex] - 'Z') + 'z';            ]            else            [                //                // Copy the received character to the transmit buffer.                //                g_pui8USBTxBuffer[ui32WriteIndex] =                        g_pui8USBRxBuffer[ui32ReadIndex];            ]        ]        //        // Move to the next character taking care to adjust the pointer for        // the buffer wrap if necessary.        //        ui32WriteIndex++;        ui32WriteIndex = (ui32WriteIndex == BULK_BUFFER_SIZE) ?                         0 : ui32WriteIndex;        ui32ReadIndex++;        ui32ReadIndex = (ui32ReadIndex == BULK_BUFFER_SIZE) ?                        0 : ui32ReadIndex;        ui32Loop--;    ]    //    // We've processed the data in place so now send the processed data    // back to the host.    //    USBBufferDataWritten(&g_sTxBuffer, ui32Count);    DEBUG_PRINT("Wrote %d bytesn", ui32Count);    //    // We processed as much data as we can directly from the receive buffer so    // we need to return the number of bytes to allow the lower layer to    // update its read pointer appropriately.    //    return(ui32Count);]//*****************************************************************************//// Handles bulk driver notifications related to the transmit channel (data to// the USB host).//// param pvCBData is the client-supplied callback pointer for this channel.// param ui32Event identifies the event we are being notified about.// param ui32MsgValue is an event-specific value.// param pvMsgData is an event-specific pointer.//// This function is called by the bulk driver to notify us of any events// related to operation of the transmit data channel (the IN channel carrying// data to the USB host).//// return The return value is event-specific.////*****************************************************************************uint32_tTxHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue,          void *pvMsgData)[    //    // We are not required to do anything in response to any transmit event    // in this example. All we do is update our transmit counter.    //    if(ui32Event == USB_EVENT_TX_COMPLETE)    [        g_ui32TxCount += ui32MsgValue;    ]    //    // Dump a debug message.    //    DEBUG_PRINT("TX complete %dn", ui32MsgValue);    return(0);]//*****************************************************************************//// Handles bulk driver notifications related to the receive channel (data from// the USB host).//// param pvCBData is the client-supplied callback pointer for this channel.// param ui32Event identifies the event we are being notified about.// param ui32MsgValue is an event-specific value.// param pvMsgData is an event-specific pointer.//// This function is called by the bulk driver to notify us of any events// related to operation of the receive data channel (the OUT channel carrying// data from the USB host).//// return The return value is event-specific.////*****************************************************************************uint32_tRxHandler(void *pvCBData, uint32_t ui32Event,               uint32_t ui32MsgValue, void *pvMsgData)[    //    // Which event are we being sent?    //    switch(ui32Event)    [        //        // We are connected to a host and communication is now possible.        //        case USB_EVENT_CONNECTED:        [            g_bUSBConfigured = true;            UARTprintf("Host connected.n");            //            // Flush our buffers.            //            USBBufferFlush(&g_sTxBuffer);            USBBufferFlush(&g_sRxBuffer);            break;        ]        //        // The host has disconnected.        //        case USB_EVENT_DISCONNECTED:        [            g_bUSBConfigured = false;            UARTprintf("Host disconnected.n");            break;        ]        //        // A new packet has been received.        //        case USB_EVENT_RX_AVAILABLE:        [            tUSBDBulkDevice *psDevice;            //            // Get a pointer to our instance data from the callback data            // parameter.            //            psDevice = (tUSBDBulkDevice *)pvCBData;            //            // Read the new packet and echo it back to the host.            //            return(EchoNewDataToHost(psDevice, pvMsgData, ui32MsgValue));        ]        //        // Ignore SUSPEND and RESUME for now.        //        case USB_EVENT_SUSPEND:        case USB_EVENT_RESUME:        [            break;        ]        //        // Ignore all other events and return 0.        //        default:        [            break;        ]    ]    return(0);]//*****************************************************************************//// Configure the UART and its pins.  This must be called before UARTprintf().////*****************************************************************************voidConfigureUART(void)[    //    // Enable the GPIO Peripheral used by the UART.    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);    //    // Enable UART0    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);    //    // Configure GPIO Pins for UART mode.    //    ROM_GPIOPinConfigure(GPIO_PA0_U0RX);    ROM_GPIOPinConfigure(GPIO_PA1_U0TX);    ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);    //    // Use the internal 16MHz oscillator as the UART clock source.    //    UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);    //    // Initialize the UART for console I/O.    //    UARTStdioConfig(0, 115200, 16000000);]//*****************************************************************************//// This is the main application entry function.////*****************************************************************************intmain(void)[    volatile uint32_t ui32Loop;    uint32_t ui32TxCount;    uint32_t ui32RxCount;    //    // Enable lazy stacking for interrupt handlers.  This allows floating-point    // instructions to be used within interrupt handlers, but at the expense of    // extra stack usage.    //    ROM_FPULazyStackingEnable();    //    // Set the clocking to run from the PLL at 50MHz    //    ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |                       SYSCTL_XTAL_16MHZ);    //    // Enable the GPIO port that is used for the on-board LED.    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);    //    // Enable the GPIO pins for the LED (PF2 & PF3).    //    ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_3 | GPIO_PIN_2);    //    // Open UART0 and show the application name on the UART.    //    ConfigureUART();    UARTprintf("33[2JTiva C Series USB bulk device examplen");    UARTprintf("---------------------------------nn");    //    // Not configured initially.    //    g_bUSBConfigured = false;    //    // Enable the GPIO peripheral used for USB, and configure the USB    // pins.    //    ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);    ROM_GPIOPinTypeUSBAnalog(GPIO_PORTD_BASE, GPIO_PIN_4 | GPIO_PIN_5);    //    // Enable the system tick.    //    ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / SYSTICKS_PER_SECOND);    ROM_SysTickIntEnable();    ROM_SysTickEnable();    //    // Tell the user what we are up to.    //    UARTprintf("Configuring USBn");    //    // Initialize the transmit and receive buffers.    //    USBBufferInit(&g_sTxBuffer);    USBBufferInit(&g_sRxBuffer);    //    // Set the USB stack mode to Device mode with VBUS monitoring.    //    USBStackModeSet(0, eUSBModeForceDevice, 0);    //    // Pass our device information to the USB library and place the device    // on the bus.    //    USBDBulkInit(0, &g_sBulkDevice);    //    // Wait for initial configuration to complete.    //    UARTprintf("Waiting for host...n");    //    // Clear our local byte counters.    //    ui32RxCount = 0;    ui32TxCount = 0;    //    // Main application loop.    //    while(1)    [        //        // See if any data has been transferred.        //        if((ui32TxCount != g_ui32TxCount) || (ui32RxCount != g_ui32RxCount))        [            //            // Has there been any transmit traffic since we last checked?            //            if(ui32TxCount != g_ui32TxCount)            [                //                // Turn on the Green LED.                //                GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, GPIO_PIN_3);                //                // Delay for a bit.                //                for(ui32Loop = 0; ui32Loop < 150000; ui32Loop++)                [                ]                //                // Turn off the Green LED.                //                GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_3, 0);                //                // Take a snapshot of the latest transmit count.                //                ui32TxCount = g_ui32TxCount;            ]            //            // Has there been any receive traffic since we last checked?            //            if(ui32RxCount != g_ui32RxCount)            [                //                // Turn on the Blue LED.                //                GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, GPIO_PIN_2);                //                // Delay for a bit.                //                for(ui32Loop = 0; ui32Loop < 150000; ui32Loop++)                [                ]                //                // Turn off the Blue LED.                //                GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_2, 0);                //                // Take a snapshot of the latest receive count.                //                ui32RxCount = g_ui32RxCount;            ]            //            // Update the display of bytes transferred.            //            UARTprintf("rTx: %d  Rx: %d", ui32TxCount, ui32RxCount);        ]    ]]