diff options
| author | Yuval Adam <yuv.adm@gmail.com> | 2014-06-29 12:34:32 +0300 |
|---|---|---|
| committer | Yuval Adam <yuv.adm@gmail.com> | 2014-06-29 12:34:32 +0300 |
| commit | c3e4c9a25c2910d2d66d52215b3406b13d5b23d5 (patch) | |
| tree | added370d1e356901f8579f076e3263fb0464db7 /boards/dk-tm4c129x/usb_dev_serial/usb_dev_serial.c | |
| parent | 990090a4cc9070837d31e66b58d40f0c3d038741 (diff) | |
Add more board models
Diffstat (limited to 'boards/dk-tm4c129x/usb_dev_serial/usb_dev_serial.c')
| -rw-r--r-- | boards/dk-tm4c129x/usb_dev_serial/usb_dev_serial.c | 1455 |
1 files changed, 1455 insertions, 0 deletions
diff --git a/boards/dk-tm4c129x/usb_dev_serial/usb_dev_serial.c b/boards/dk-tm4c129x/usb_dev_serial/usb_dev_serial.c new file mode 100644 index 0000000..a31e163 --- /dev/null +++ b/boards/dk-tm4c129x/usb_dev_serial/usb_dev_serial.c @@ -0,0 +1,1455 @@ +//*****************************************************************************
+//
+// usb_dev_serial.c - Main routines for the USB CDC serial example.
+//
+// Copyright (c) 2013-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 DK-TM4C129X Firmware Package.
+//
+//*****************************************************************************
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "inc/hw_ints.h"
+#include "inc/hw_memmap.h"
+#include "inc/hw_types.h"
+#include "inc/hw_uart.h"
+#include "driverlib/debug.h"
+#include "driverlib/gpio.h"
+#include "driverlib/interrupt.h"
+#include "driverlib/sysctl.h"
+#include "driverlib/systick.h"
+#include "driverlib/timer.h"
+#include "driverlib/uart.h"
+#include "driverlib/usb.h"
+#include "driverlib/rom.h"
+#include "driverlib/rom_map.h"
+#include "grlib/grlib.h"
+#include "usblib/usblib.h"
+#include "usblib/usbcdc.h"
+#include "usblib/usb-ids.h"
+#include "usblib/device/usbdevice.h"
+#include "usblib/device/usbdcdc.h"
+#include "utils/ustdlib.h"
+#include "drivers/frame.h"
+#include "drivers/kentec320x240x16_ssd2119.h"
+#include "drivers/pinout.h"
+#include "usb_serial_structs.h"
+
+//*****************************************************************************
+//
+//! \addtogroup example_list
+//! <h1>USB Serial Device (usb_dev_serial)</h1>
+//!
+//! This example application turns the development kit into a virtual serial
+//! port when connected to the USB host system. The application supports the
+//! USB Communication Device Class, Abstract Control Model to redirect UART0
+//! traffic to and from the USB host system.
+//!
+//! The application can be recompiled to run using and external USB phy to
+//! implement a high speed device using an external USB phy. To use the
+//! external phy the application must be built with \b USE_ULPI defined. This
+//! disables the internal phy and the connector on the DK-TM4C129X board and
+//! enables the connections to the external ULPI phy pins on the DK-TM4C129X
+//! board.
+//!
+//! Assuming you installed TivaWare in the default directory, a
+//! driver information (INF) file for use with Windows XP, Windows Vista and
+//! Windows7 can be found in C:/ti/TivaWare-for-C-Series/windows_drivers.
+//! For Windows 2000, the required INF file is in
+//! C:/ti/TivaWare-for-C-Series/windows_drivers/win2K.
+//
+//*****************************************************************************
+
+//*****************************************************************************
+//
+// Note:
+//
+// This example is intended to run on Tiva C Series evaluation kit hardware
+// where the UARTs are wired solely for TX and RX, and do not have GPIOs
+// connected to act as handshake signals. As a result, this example mimics
+// the case where communication is always possible. It reports DSR, DCD
+// and CTS as high to ensure that the USB host recognizes that data can be
+// sent and merely ignores the host's requested DTR and RTS states. "TODO"
+// comments in the code indicate where code would be required to add support
+// for real handshakes.
+//
+//*****************************************************************************
+
+
+//*****************************************************************************
+//
+// Configuration and tuning parameters.
+//
+//*****************************************************************************
+
+//*****************************************************************************
+//
+// The system tick rate expressed both as ticks per second and a millisecond
+// period.
+//
+//*****************************************************************************
+#define TICKS_PER_SECOND 100
+
+//*****************************************************************************
+//
+// The UART peripheral clock rate.
+//
+//*****************************************************************************
+#define UART_CLOCK 16000000
+
+//*****************************************************************************
+//
+// Variables tracking transmit and receive counts.
+//
+//*****************************************************************************
+static volatile uint32_t g_ui32UARTTxCount;
+static volatile uint32_t g_ui32UARTRxCount;
+#ifdef DEBUG
+uint32_t g_ui32UARTRxErrors;
+#endif
+
+//*****************************************************************************
+//
+// The base address, peripheral ID and interrupt ID of the UART that is to
+// be redirected.
+//
+//*****************************************************************************
+
+//*****************************************************************************
+//
+// Default line coding settings for the redirected UART.
+//
+//*****************************************************************************
+#define DEFAULT_BIT_RATE 115200
+#define DEFAULT_UART_CONFIG (UART_CONFIG_WLEN_8 | UART_CONFIG_PAR_NONE | \
+ UART_CONFIG_STOP_ONE)
+
+//*****************************************************************************
+//
+// Global system tick counter
+//
+//*****************************************************************************
+static volatile uint32_t g_ui32SysTickCount = 0;
+
+//*****************************************************************************
+//
+// Graphics context used to show text on the color STN display.
+//
+//*****************************************************************************
+static tContext g_sContext;
+#define TEXT_FONT g_psFontCmss22b
+#define TEXT_HEIGHT (GrFontHeightGet(TEXT_FONT))
+#define BUFFER_METER_HEIGHT TEXT_HEIGHT
+#define BUFFER_METER_WIDTH 150
+
+//*****************************************************************************
+//
+// Flags used to pass commands from interrupt context to the main loop.
+//
+//*****************************************************************************
+#define FLAG_STATUS_UPDATE 0
+#define FLAG_USB_CONFIGURED 1
+#define FLAG_SENDING_BREAK 2
+static volatile uint32_t g_ui32Flags;
+
+//*****************************************************************************
+//
+// Global pointer to the current status string.
+//
+//*****************************************************************************
+static char *g_pcStatus;
+
+//*****************************************************************************
+//
+// Internal function prototypes.
+//
+//*****************************************************************************
+static void USBUARTPrimeTransmit(uint32_t ui32Base);
+static void CheckForSerialStateChange(const tUSBDCDCDevice *psDevice,
+ uint32_t ui32Errors);
+static void SetControlLineState(uint16_t ui16State);
+static bool SetLineCoding(tLineCoding *psLineCoding, uint32_t ui32UARTClock);
+static void GetLineCoding(tLineCoding *psLineCoding, uint32_t ui32UARTClock);
+static void SendBreak(bool bSend);
+
+//*****************************************************************************
+//
+// The error routine that is called if the driver library encounters an error.
+//
+//*****************************************************************************
+#ifdef DEBUG
+void
+__error__(char *pcFilename, uint32_t ui32Line)
+{
+ while(1)
+ {
+ }
+}
+#endif
+
+//*****************************************************************************
+//
+// This function is called whenever serial data is received from the UART.
+// It is passed the accumulated error flags from each character received in
+// this interrupt and determines from them whether or not an interrupt
+// notification to the host is required.
+//
+// If a notification is required and the control interrupt endpoint is idle,
+// we send the notification immediately. If the endpoint is not idle, we
+// accumulate the errors in a global variable which will be checked on
+// completion of the previous notification and used to send a second one
+// if necessary.
+//
+//*****************************************************************************
+static void
+CheckForSerialStateChange(const tUSBDCDCDevice *psDevice, uint32_t ui32Errors)
+{
+ uint16_t ui16SerialState;
+
+ //
+ // Clear our USB serial state. Since we are faking the handshakes, always
+ // set the TXCARRIER (DSR) and RXCARRIER (DCD) bits.
+ //
+ ui16SerialState = USB_CDC_SERIAL_STATE_TXCARRIER |
+ USB_CDC_SERIAL_STATE_RXCARRIER;
+
+ //
+ // Are any error bits set?
+ //
+ if(ui32Errors)
+ {
+ //
+ // At least one error is being notified so translate from our hardware
+ // error bits into the correct state markers for the USB notification.
+ //
+ if(ui32Errors & UART_DR_OE)
+ {
+ ui16SerialState |= USB_CDC_SERIAL_STATE_OVERRUN;
+ }
+
+ if(ui32Errors & UART_DR_PE)
+ {
+ ui16SerialState |= USB_CDC_SERIAL_STATE_PARITY;
+ }
+
+ if(ui32Errors & UART_DR_FE)
+ {
+ ui16SerialState |= USB_CDC_SERIAL_STATE_FRAMING;
+ }
+
+ if(ui32Errors & UART_DR_BE)
+ {
+ ui16SerialState |= USB_CDC_SERIAL_STATE_BREAK;
+ }
+
+ //
+ // Call the CDC driver to notify the state change.
+ //
+ USBDCDCSerialStateChange((void *)psDevice, ui16SerialState);
+ }
+}
+
+//*****************************************************************************
+//
+// Read as many characters from the UART FIFO as we can and move them into
+// the CDC transmit buffer.
+//
+// \return Returns UART error flags read during data reception.
+//
+//*****************************************************************************
+static uint32_t
+ReadUARTData(void)
+{
+ int32_t i32Char;
+ int8_t ui8Char;
+ uint32_t ui32Space, ui32Errors;
+
+ //
+ // Clear our error indicator.
+ //
+ ui32Errors = 0;
+
+ //
+ // How much space do we have in the buffer?
+ //
+ ui32Space = USBBufferSpaceAvailable((tUSBBuffer *)&g_sTxBuffer);
+
+ //
+ // Read data from the UART FIFO until there is none left or we run
+ // out of space in our receive buffer.
+ //
+ while(ui32Space && UARTCharsAvail(UART0_BASE))
+ {
+ //
+ // Read a character from the UART FIFO into the ring buffer if no
+ // errors are reported.
+ //
+ i32Char = UARTCharGetNonBlocking(UART0_BASE);
+
+ //
+ // If the character did not contain any error notifications,
+ // copy it to the output buffer.
+ //
+ if(!(i32Char & ~0xFF))
+ {
+ ui8Char = (unsigned char)(i32Char & 0xFF);
+ USBBufferWrite((tUSBBuffer *)&g_sTxBuffer,
+ (unsigned char *)&ui8Char, 1);
+
+ //
+ // Decrement the number of bytes we know the buffer can accept.
+ //
+ ui32Space--;
+ }
+ else
+ {
+#ifdef DEBUG
+ //
+ // Increment our receive error counter.
+ //
+ g_ui32UARTRxErrors++;
+#endif
+ //
+ // Update our error accumulator.
+ //
+ ui32Errors |= i32Char;
+ }
+
+ //
+ // Update our count of bytes received via the UART.
+ //
+ g_ui32UARTRxCount++;
+ }
+
+ //
+ // Pass back the accumulated error indicators.
+ //
+ return(ui32Errors);
+}
+
+//*****************************************************************************
+//
+// Take as many bytes from the transmit buffer as we have space for and move
+// them into the USB UART's transmit FIFO.
+//
+//*****************************************************************************
+static void
+USBUARTPrimeTransmit(uint32_t ui32Base)
+{
+ uint32_t ui32Read;
+ uint8_t ui8Char;
+
+ //
+ // If we are currently sending a break condition, don't receive any
+ // more data. We will resume transmission once the break is turned off.
+ //
+ if(HWREGBITW(&g_ui32Flags, FLAG_SENDING_BREAK))
+ {
+ return;
+ }
+
+ //
+ // If there is space in the UART FIFO, try to read some characters
+ // from the receive buffer to fill it again.
+ //
+ while(UARTSpaceAvail(ui32Base))
+ {
+ //
+ // Get a character from the buffer.
+ //
+ ui32Read = USBBufferRead((tUSBBuffer *)&g_sRxBuffer, &ui8Char, 1);
+
+ //
+ // Did we get a character?
+ //
+ if(ui32Read)
+ {
+ //
+ // Place the character in the UART transmit FIFO.
+ //
+ ROM_UARTCharPutNonBlocking(ui32Base, ui8Char);
+
+ //
+ // Update our count of bytes transmitted via the UART.
+ //
+ g_ui32UARTTxCount++;
+ }
+ else
+ {
+ //
+ // We ran out of characters so exit the function.
+ //
+ return;
+ }
+ }
+}
+
+//*****************************************************************************
+//
+// Interrupt handler for the system tick counter.
+//
+//*****************************************************************************
+void
+SysTickHandler(void)
+{
+ //
+ // Update our system time.
+ //
+ g_ui32SysTickCount++;
+}
+
+//*****************************************************************************
+//
+// Interrupt handler for the UART which we are redirecting via USB.
+//
+//*****************************************************************************
+void
+USBUARTIntHandler(void)
+{
+ uint32_t ui32Ints, ui32Errors;
+
+ //
+ // Get and clear the current interrupt source(s)
+ //
+ ui32Ints = ROM_UARTIntStatus(UART0_BASE, true);
+ ROM_UARTIntClear(UART0_BASE, ui32Ints);
+
+ //
+ // Are we being interrupted because the TX FIFO has space available?
+ //
+ if(ui32Ints & UART_INT_TX)
+ {
+ //
+ // Move as many bytes as we can into the transmit FIFO.
+ //
+ USBUARTPrimeTransmit(UART0_BASE);
+
+ //
+ // If the output buffer is empty, turn off the transmit interrupt.
+ //
+ if(!USBBufferDataAvailable(&g_sRxBuffer))
+ {
+ ROM_UARTIntDisable(UART0_BASE, UART_INT_TX);
+ }
+ }
+
+ //
+ // Handle receive interrupts.
+ //
+ if(ui32Ints & (UART_INT_RX | UART_INT_RT))
+ {
+ //
+ // Read the UART's characters into the buffer.
+ //
+ ui32Errors = ReadUARTData();
+
+ //
+ // Check to see if we need to notify the host of any errors we just
+ // detected.
+ //
+ CheckForSerialStateChange(&g_sCDCDevice, ui32Errors);
+ }
+}
+
+//*****************************************************************************
+//
+// Set the state of the RS232 RTS and DTR signals.
+//
+//*****************************************************************************
+static void
+SetControlLineState(uint16_t ui16State)
+{
+ //
+ // TODO: If configured with GPIOs controlling the handshake lines,
+ // set them appropriately depending upon the flags passed in the wValue
+ // field of the request structure passed.
+ //
+}
+
+//*****************************************************************************
+//
+// Set the communication parameters to use on the UART.
+//
+//*****************************************************************************
+static bool
+SetLineCoding(tLineCoding *psLineCoding, uint32_t ui32UARTClock)
+{
+ uint32_t ui32Config;
+ bool bRetcode;
+
+ //
+ // Assume everything is OK until we detect any problem.
+ //
+ bRetcode = true;
+
+ //
+ // Word length. For invalid values, the default is to set 8 bits per
+ // character and return an error.
+ //
+ switch(psLineCoding->ui8Databits)
+ {
+ case 5:
+ {
+ ui32Config = UART_CONFIG_WLEN_5;
+ break;
+ }
+
+ case 6:
+ {
+ ui32Config = UART_CONFIG_WLEN_6;
+ break;
+ }
+
+ case 7:
+ {
+ ui32Config = UART_CONFIG_WLEN_7;
+ break;
+ }
+
+ case 8:
+ {
+ ui32Config = UART_CONFIG_WLEN_8;
+ break;
+ }
+
+ default:
+ {
+ ui32Config = UART_CONFIG_WLEN_8;
+ bRetcode = false;
+ break;
+ }
+ }
+
+ //
+ // Parity. For any invalid values, we set no parity and return an error.
+ //
+ switch(psLineCoding->ui8Parity)
+ {
+ case USB_CDC_PARITY_NONE:
+ {
+ ui32Config |= UART_CONFIG_PAR_NONE;
+ break;
+ }
+
+ case USB_CDC_PARITY_ODD:
+ {
+ ui32Config |= UART_CONFIG_PAR_ODD;
+ break;
+ }
+
+ case USB_CDC_PARITY_EVEN:
+ {
+ ui32Config |= UART_CONFIG_PAR_EVEN;
+ break;
+ }
+
+ case USB_CDC_PARITY_MARK:
+ {
+ ui32Config |= UART_CONFIG_PAR_ONE;
+ break;
+ }
+
+ case USB_CDC_PARITY_SPACE:
+ {
+ ui32Config |= UART_CONFIG_PAR_ZERO;
+ break;
+ }
+
+ default:
+ {
+ ui32Config |= UART_CONFIG_PAR_NONE;
+ bRetcode = false;
+ break;
+ }
+ }
+
+ //
+ // Stop bits. Our hardware only supports 1 or 2 stop bits whereas CDC
+ // allows the host to select 1.5 stop bits. If passed 1.5 (or any other
+ // invalid or unsupported value of ucStop, we set up for 1 stop bit but
+ // return an error in case the caller needs to Stall or otherwise report
+ // this back to the host.
+ //
+ switch(psLineCoding->ui8Stop)
+ {
+ //
+ // One stop bit requested.
+ //
+ case USB_CDC_STOP_BITS_1:
+ {
+ ui32Config |= UART_CONFIG_STOP_ONE;
+ break;
+ }
+
+ //
+ // Two stop bits requested.
+ //
+ case USB_CDC_STOP_BITS_2:
+ {
+ ui32Config |= UART_CONFIG_STOP_TWO;
+ break;
+ }
+
+ //
+ // Other cases are either invalid values of ucStop or values that we
+ // cannot support so set 1 stop bit but return an error.
+ //
+ default:
+ {
+ ui32Config = UART_CONFIG_STOP_ONE;
+ bRetcode |= false;
+ break;
+ }
+ }
+
+ //
+ // Set the UART mode appropriately.
+ //
+ ROM_UARTConfigSetExpClk(UART0_BASE, ui32UARTClock,
+ psLineCoding->ui32Rate, ui32Config);
+
+ //
+ // Let the caller know if we had a problem or not.
+ //
+ return(bRetcode);
+}
+
+//*****************************************************************************
+//
+// Get the communication parameters in use on the UART.
+//
+//*****************************************************************************
+static void
+GetLineCoding(tLineCoding *psLineCoding, uint32_t ui32UARTClock)
+{
+ uint32_t ui32Config, ui32Rate;
+
+ //
+ // Get the current line coding set in the UART.
+ //
+ ROM_UARTConfigGetExpClk(UART0_BASE, ui32UARTClock, &ui32Rate,
+ &ui32Config);
+ psLineCoding->ui32Rate = ui32Rate;
+
+ //
+ // Translate the configuration word length field into the format expected
+ // by the host.
+ //
+ switch(ui32Config & UART_CONFIG_WLEN_MASK)
+ {
+ case UART_CONFIG_WLEN_8:
+ {
+ psLineCoding->ui8Databits = 8;
+ break;
+ }
+
+ case UART_CONFIG_WLEN_7:
+ {
+ psLineCoding->ui8Databits = 7;
+ break;
+ }
+
+ case UART_CONFIG_WLEN_6:
+ {
+ psLineCoding->ui8Databits = 6;
+ break;
+ }
+
+ case UART_CONFIG_WLEN_5:
+ {
+ psLineCoding->ui8Databits = 5;
+ break;
+ }
+ }
+
+ //
+ // Translate the configuration parity field into the format expected
+ // by the host.
+ //
+ switch(ui32Config & UART_CONFIG_PAR_MASK)
+ {
+ case UART_CONFIG_PAR_NONE:
+ {
+ psLineCoding->ui8Parity = USB_CDC_PARITY_NONE;
+ break;
+ }
+
+ case UART_CONFIG_PAR_ODD:
+ {
+ psLineCoding->ui8Parity = USB_CDC_PARITY_ODD;
+ break;
+ }
+
+ case UART_CONFIG_PAR_EVEN:
+ {
+ psLineCoding->ui8Parity = USB_CDC_PARITY_EVEN;
+ break;
+ }
+
+ case UART_CONFIG_PAR_ONE:
+ {
+ psLineCoding->ui8Parity = USB_CDC_PARITY_MARK;
+ break;
+ }
+
+ case UART_CONFIG_PAR_ZERO:
+ {
+ psLineCoding->ui8Parity = USB_CDC_PARITY_SPACE;
+ break;
+ }
+ }
+
+ //
+ // Translate the configuration stop bits field into the format expected
+ // by the host.
+ //
+ switch(ui32Config & UART_CONFIG_STOP_MASK)
+ {
+ case UART_CONFIG_STOP_ONE:
+ {
+ psLineCoding->ui8Stop = USB_CDC_STOP_BITS_1;
+ break;
+ }
+
+ case UART_CONFIG_STOP_TWO:
+ {
+ psLineCoding->ui8Stop = USB_CDC_STOP_BITS_2;
+ break;
+ }
+ }
+}
+
+//*****************************************************************************
+//
+// This function sets or clears a break condition on the redirected UART RX
+// line. A break is started when the function is called with \e bSend set to
+// \b true and persists until the function is called again with \e bSend set
+// to \b false.
+//
+//*****************************************************************************
+static void
+SendBreak(bool bSend)
+{
+ //
+ // Are we being asked to start or stop the break condition?
+ //
+ if(!bSend)
+ {
+ //
+ // Remove the break condition on the line.
+ //
+ ROM_UARTBreakCtl(UART0_BASE, false);
+ HWREGBITW(&g_ui32Flags, FLAG_SENDING_BREAK) = 0;
+ }
+ else
+ {
+ //
+ // Start sending a break condition on the line.
+ //
+ ROM_UARTBreakCtl(UART0_BASE, true);
+ HWREGBITW(&g_ui32Flags, FLAG_SENDING_BREAK) = 1;
+ }
+}
+
+//*****************************************************************************
+//
+// Shows the status string on the color STN display.
+//
+// \param psContext is a pointer to the graphics context representing the
+// display.
+// \param pcStatus is a pointer to the string to be shown.
+//
+//*****************************************************************************
+void
+DisplayStatus(tContext *psContext, char *pcStatus)
+{
+ tRectangle rectLine;
+ int32_t i32Y;
+
+ //
+ // Calculate the Y coordinate of the top left of the character cell
+ // for our line of text.
+ //
+ i32Y = (GrContextDpyHeightGet(psContext) / 4) -
+ (GrFontHeightGet(TEXT_FONT) / 2);
+
+ //
+ // Determine the bounding rectangle for this line of text. We add 4 pixels
+ // to the height just to ensure that we clear a couple of pixels above and
+ // below the line of text.
+ //
+ rectLine.i16XMin = 0;
+ rectLine.i16XMax = GrContextDpyWidthGet(psContext) - 1;
+ rectLine.i16YMin = i32Y;
+ rectLine.i16YMax = i32Y + GrFontHeightGet(TEXT_FONT) + 3;
+
+ //
+ // Clear the line with black.
+ //
+ GrContextForegroundSet(&g_sContext, ClrBlack);
+ GrRectFill(psContext, &rectLine);
+
+ //
+ // Draw the new status string
+ //
+ GrContextForegroundSet(&g_sContext, ClrWhite);
+ GrStringDrawCentered(psContext, pcStatus, -1,
+ GrContextDpyWidthGet(psContext) / 2,
+ GrContextDpyHeightGet(psContext) / 4 , false);
+}
+
+//*****************************************************************************
+//
+// Draw a horizontal meter at a given position on the display and fill it
+// with green.
+//
+//*****************************************************************************
+void
+DrawBufferMeter(tContext *psContext, int32_t i32X, int32_t i32Y)
+{
+ tRectangle sRect;
+ int32_t i32CorrectedY;
+
+ //
+ // Correct the Y coordinate so that the meter is centered on the same line
+ // as the text caption to its left.
+ //
+ i32CorrectedY = i32Y - ((BUFFER_METER_HEIGHT - TEXT_HEIGHT) / 2);
+
+ //
+ // Determine the bounding rectangle of the meter.
+ //
+ sRect.i16XMin = i32X;
+ sRect.i16XMax = i32X + BUFFER_METER_WIDTH - 1;
+ sRect.i16YMin = i32CorrectedY;
+ sRect.i16YMax = i32CorrectedY + BUFFER_METER_HEIGHT - 1;
+
+ //
+ // Fill the meter with green to indicate empty
+ //
+ GrContextForegroundSet(psContext, ClrGreen);
+ GrRectFill(psContext, &sRect);
+
+ //
+ // Put a white box around the meter.
+ //
+ GrContextForegroundSet(psContext, ClrWhite);
+ GrRectDraw(psContext, &sRect);
+}
+
+//*****************************************************************************
+//
+// Draw green and red blocks within a graphical meter on the display to
+// indicate percentage fullness of some quantity (transmit and receive buffers
+// in this case).
+//
+//*****************************************************************************
+void
+UpdateBufferMeter(tContext *psContext, uint32_t ui32FullPercent, int32_t i32X,
+ int32_t i32Y)
+{
+ tRectangle sRect;
+ int32_t i32CorrectedY, i32XBreak;
+
+ //
+ // Correct the Y coordinate so that the meter is centered on the same line
+ // as the text caption to its left and so that we avoid the meter's 1 pixel
+ // white border.
+ //
+ i32CorrectedY = i32Y - ((BUFFER_METER_HEIGHT - TEXT_HEIGHT) / 2) + 1;
+
+ //
+ // Determine where the break point between full (red) and empty (green)
+ // sections occurs.
+ //
+ i32XBreak = (i32X + 1) + (ui32FullPercent * (BUFFER_METER_WIDTH - 2)) /
+ 100;
+
+ //
+ // Determine the bounding rectangle of the full section.
+ //
+ sRect.i16XMin = i32X + 1;
+ sRect.i16XMax = i32XBreak;
+ sRect.i16YMin = i32CorrectedY;
+ sRect.i16YMax = i32CorrectedY + BUFFER_METER_HEIGHT - 3;
+
+ //
+ // Fill the full section with red (if there is anything to draw)
+ //
+ if(ui32FullPercent)
+ {
+ GrContextForegroundSet(psContext, ClrRed);
+ GrRectFill(psContext, &sRect);
+ }
+
+ //
+ // Fill the empty section with green.
+ //
+ sRect.i16XMin = i32XBreak;
+ sRect.i16XMax = i32X + BUFFER_METER_WIDTH - 2;
+ if(sRect.i16XMax > sRect.i16XMin)
+ {
+ GrContextForegroundSet(psContext, ClrGreen);
+ GrRectFill(psContext, &sRect);
+ }
+
+ //
+ // Revert to white for text drawing which may occur later.
+ //
+ GrContextForegroundSet(psContext, ClrWhite);
+
+}
+
+//*****************************************************************************
+//
+// Handles CDC driver notifications related to control and setup of the device.
+//
+// \param pvCBData is the client-supplied callback pointer for this channel.
+// \param ulEvent identifies the event we are being notified about.
+// \param ulMsgValue is an event-specific value.
+// \param pvMsgData is an event-specific pointer.
+//
+// This function is called by the CDC driver to perform control-related
+// operations on behalf of the USB host. These functions include setting
+// and querying the serial communication parameters, setting handshake line
+// states and sending break conditions.
+//
+// \return The return value is event-specific.
+//
+//*****************************************************************************
+uint32_t
+ControlHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue,
+ void *pvMsgData)
+{
+ //
+ // Which event are we being asked to process?
+ //
+ switch(ui32Event)
+ {
+ //
+ // We are connected to a host and communication is now possible.
+ //
+ case USB_EVENT_CONNECTED:
+ {
+ //
+ // Now connected and ready for normal operation.
+ //
+ HWREGBITW(&g_ui32Flags, FLAG_USB_CONFIGURED) = 1;
+
+ //
+ // Flush our buffers.
+ //
+ USBBufferFlush(&g_sTxBuffer);
+ USBBufferFlush(&g_sRxBuffer);
+
+ //
+ // Tell the main loop to update the display.
+ //
+ g_pcStatus = "Host connected.";
+
+ //
+ // Set the command status update flag.
+ //
+ HWREGBITW(&g_ui32Flags, FLAG_STATUS_UPDATE) = 1;
+
+ break;
+ }
+
+ //
+ // The host has disconnected.
+ //
+ case USB_EVENT_DISCONNECTED:
+ {
+ //
+ // No longer connected.
+ //
+ HWREGBITW(&g_ui32Flags, FLAG_USB_CONFIGURED) = 0;
+
+ g_pcStatus = "Host disconnected.";
+
+ //
+ // Set the command status update flag.
+ //
+ HWREGBITW(&g_ui32Flags, FLAG_STATUS_UPDATE) = 1;
+
+ break;
+ }
+
+ //
+ // Return the current serial communication parameters.
+ //
+ case USBD_CDC_EVENT_GET_LINE_CODING:
+ {
+ GetLineCoding(pvMsgData, UART_CLOCK);
+ break;
+ }
+
+ //
+ // Set the current serial communication parameters.
+ //
+ case USBD_CDC_EVENT_SET_LINE_CODING:
+ {
+ SetLineCoding(pvMsgData, UART_CLOCK);
+ break;
+ }
+
+ //
+ // Set the current serial communication parameters.
+ //
+ case USBD_CDC_EVENT_SET_CONTROL_LINE_STATE:
+ {
+ SetControlLineState((uint16_t)ui32MsgValue);
+ break;
+ }
+
+ //
+ // Send a break condition on the serial line.
+ //
+ case USBD_CDC_EVENT_SEND_BREAK:
+ {
+ SendBreak(true);
+ break;
+ }
+
+ //
+ // Clear the break condition on the serial line.
+ //
+ case USBD_CDC_EVENT_CLEAR_BREAK:
+ {
+ SendBreak(false);
+ break;
+ }
+
+ //
+ // Ignore SUSPEND and RESUME for now.
+ //
+ case USB_EVENT_SUSPEND:
+ case USB_EVENT_RESUME:
+ {
+ break;
+ }
+
+ //
+ // We don't expect to receive any other events. Ignore any that show
+ // up in a release build or hang in a debug build.
+ //
+ default:
+ {
+#ifdef DEBUG
+ while(1);
+#else
+ break;
+#endif
+ }
+
+ }
+
+ return(0);
+}
+
+//*****************************************************************************
+//
+// Handles CDC 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 CDC 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_t
+TxHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue,
+ void *pvMsgData)
+{
+ //
+ // Which event have we been sent?
+ //
+ switch(ui32Event)
+ {
+ case USB_EVENT_TX_COMPLETE:
+ {
+ //
+ // Since we are using the USBBuffer, we don't need to do anything
+ // here.
+ //
+ break;
+ }
+
+ //
+ // We don't expect to receive any other events. Ignore any that show
+ // up in a release build or hang in a debug build.
+ //
+ default:
+ {
+#ifdef DEBUG
+ while(1);
+#else
+ break;
+#endif
+ }
+ }
+ return(0);
+}
+
+//*****************************************************************************
+//
+// Handles CDC driver notifications related to the receive channel (data from
+// the USB host).
+//
+// \param pvCBData is the client-supplied callback data value 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 CDC 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_t
+RxHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue,
+ void *pvMsgData)
+{
+ uint32_t ui32Count;
+
+ //
+ // Which event are we being sent?
+ //
+ switch(ui32Event)
+ {
+ //
+ // A new packet has been received.
+ //
+ case USB_EVENT_RX_AVAILABLE:
+ {
+ //
+ // Feed some characters into the UART TX FIFO and enable the
+ // interrupt so we are told when there is more space.
+ //
+ USBUARTPrimeTransmit(UART0_BASE);
+ ROM_UARTIntEnable(UART0_BASE, UART_INT_TX);
+ break;
+ }
+
+ //
+ // We are being asked how much unprocessed data we have still to
+ // process. We return 0 if the UART is currently idle or 1 if it is
+ // in the process of transmitting something. The actual number of
+ // bytes in the UART FIFO is not important here, merely whether or
+ // not everything previously sent to us has been transmitted.
+ //
+ case USB_EVENT_DATA_REMAINING:
+ {
+ //
+ // Get the number of bytes in the buffer and add 1 if some data
+ // still has to clear the transmitter.
+ //
+ ui32Count = UARTBusy(UART0_BASE) ? 1 : 0;
+ return(ui32Count);
+ }
+
+ //
+ // We are being asked to provide a buffer into which the next packet
+ // can be read. We do not support this mode of receiving data so let
+ // the driver know by returning 0. The CDC driver should not be sending
+ // this message but this is included just for illustration and
+ // completeness.
+ //
+ case USB_EVENT_REQUEST_BUFFER:
+ {
+ return(0);
+ }
+
+ //
+ // We don't expect to receive any other events. Ignore any that show
+ // up in a release build or hang in a debug build.
+ //
+ default:
+#ifdef DEBUG
+ while(1);
+#else
+ break;
+#endif
+ }
+
+ return(0);
+}
+
+//*****************************************************************************
+//
+// This is the main application entry function.
+//
+//*****************************************************************************
+int
+main(void)
+{
+ uint32_t ui32TxCount, ui32RxCount, ui32Fullness, ui32SysClock, ui32PLLRate;
+ tRectangle sRect;
+ char pcBuffer[16];
+#ifdef USE_ULPI
+ uint32_t ui32Setting;
+#endif
+
+ //
+ // Set the system clock to run at 120MHz from the PLL.
+ //
+ ui32SysClock = MAP_SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
+ SYSCTL_OSC_MAIN | SYSCTL_USE_PLL |
+ SYSCTL_CFG_VCO_480), 120000000);
+
+ //
+ // Configure the device pins.
+ //
+ PinoutSet();
+
+#ifdef USE_ULPI
+ //
+ // Switch the USB ULPI Pins over.
+ //
+ USBULPIPinoutSet();
+
+ //
+ // Enable USB ULPI with high speed support.
+ //
+ ui32Setting = USBLIB_FEATURE_ULPI_HS;
+ USBOTGFeatureSet(0, USBLIB_FEATURE_USBULPI, &ui32Setting);
+
+ //
+ // Setting the PLL frequency to zero tells the USB library to use the
+ // external USB clock.
+ //
+ ui32PLLRate = 0;
+#else
+ //
+ // Save the PLL rate used by this application.
+ //
+ ui32PLLRate = 480000000;
+#endif
+
+ //
+ // Enable the system tick.
+ //
+ ROM_SysTickPeriodSet(ui32SysClock / TICKS_PER_SECOND);
+ ROM_SysTickIntEnable();
+ ROM_SysTickEnable();
+
+ //
+ // Not configured initially.
+ //
+ g_ui32Flags = 0;
+
+ //
+ // Initialize the display driver.
+ //
+ Kentec320x240x16_SSD2119Init(ui32SysClock);
+
+ //
+ // Initialize the graphics context.
+ //
+ GrContextInit(&g_sContext, &g_sKentec320x240x16_SSD2119);
+
+ //
+ // Draw the application frame.
+ //
+ FrameDraw(&g_sContext, "usb-dev-serial");
+
+ //
+ // Fill the top 15 rows of the screen with blue to create the banner.
+ //
+ sRect.i16XMin = 0;
+ sRect.i16YMin = 0;
+ sRect.i16XMax = GrContextDpyWidthGet(&g_sContext) - 1;
+ sRect.i16YMax = 23;
+ GrContextForegroundSet(&g_sContext, ClrDarkBlue);
+ GrRectFill(&g_sContext, &sRect);
+
+ //
+ // Put a white box around the banner.
+ //
+ GrContextForegroundSet(&g_sContext, ClrWhite);
+ GrRectDraw(&g_sContext, &sRect);
+
+ //
+ // Show the various static text elements on the color STN display.
+ //
+ GrContextFontSet(&g_sContext, TEXT_FONT);
+ GrStringDraw(&g_sContext, "Tx bytes:", -1, 8, 80, false);
+ GrStringDraw(&g_sContext, "Tx buffer:", -1, 8, 105, false);
+ GrStringDraw(&g_sContext, "Rx bytes:", -1, 8, 160, false);
+ GrStringDraw(&g_sContext, "Rx buffer:", -1, 8, 185, false);
+ DrawBufferMeter(&g_sContext, 150, 105);
+ DrawBufferMeter(&g_sContext, 150, 185);
+
+ //
+ // Enable the UART that we will be redirecting.
+ //
+ ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
+
+ //
+ // Change the UART clock to the 16 MHz PIOSC.
+ //
+ UARTClockSourceSet(UART0_BASE, UART_CLOCK_PIOSC);
+
+ //
+ // Set the default UART configuration.
+ //
+ ROM_UARTConfigSetExpClk(UART0_BASE, UART_CLOCK,
+ DEFAULT_BIT_RATE, DEFAULT_UART_CONFIG);
+ ROM_UARTFIFOLevelSet(UART0_BASE, UART_FIFO_TX4_8, UART_FIFO_RX4_8);
+
+ //
+ // Configure and enable UART interrupts.
+ //
+ ROM_UARTIntClear(UART0_BASE, ROM_UARTIntStatus(UART0_BASE, false));
+ ROM_UARTIntEnable(UART0_BASE, (UART_INT_OE | UART_INT_BE | UART_INT_PE |
+ UART_INT_FE | UART_INT_RT | UART_INT_TX | UART_INT_RX));
+
+ //
+ // Tell the user what we are up to.
+ //
+ DisplayStatus(&g_sContext, " Configuring USB... ");
+
+ //
+ // 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, eUSBModeDevice, 0);
+
+ //
+ // Tell the USB library the CPU clock and the PLL frequency. This is a
+ // new requirement for TM4C129 devices.
+ //
+ USBDCDFeatureSet(0, USBLIB_FEATURE_CPUCLK, &ui32SysClock);
+ USBDCDFeatureSet(0, USBLIB_FEATURE_USBPLL, &ui32PLLRate);
+
+ //
+ // Pass our device information to the USB library and place the device
+ // on the bus.
+ //
+ USBDCDCInit(0, (tUSBDCDCDevice *)&g_sCDCDevice);
+
+ //
+ // Wait for initial configuration to complete.
+ //
+ DisplayStatus(&g_sContext, " Waiting for host... ");
+
+ //
+ // Clear our local byte counters.
+ //
+ ui32RxCount = 0;
+ ui32TxCount = 0;
+ g_ui32UARTTxCount = 0;
+ g_ui32UARTRxCount = 0;
+#ifdef DEBUG
+ g_ui32UARTRxErrors = 0;
+#endif
+
+ //
+ // Enable interrupts now that the application is ready to start.
+ //
+ ROM_IntEnable(INT_UART0);
+
+ //
+ // Main application loop.
+ //
+ while(1)
+ {
+ //
+ // Have we been asked to update the status display?
+ //
+ if(HWREGBITW(&g_ui32Flags, FLAG_STATUS_UPDATE))
+ {
+ //
+ // Clear the command flag
+ //
+ HWREGBITW(&g_ui32Flags, FLAG_STATUS_UPDATE) = 0;
+
+ DisplayStatus(&g_sContext, g_pcStatus);
+ }
+
+ //
+ // Has there been any transmit traffic since we last checked?
+ //
+ if(ui32TxCount != g_ui32UARTTxCount)
+ {
+ //
+ // Take a snapshot of the latest transmit count.
+ //
+ ui32TxCount = g_ui32UARTTxCount;
+
+ //
+ // Update the display of bytes transmitted by the UART.
+ //
+ usnprintf(pcBuffer, 16, "%d ", ui32TxCount);
+ GrStringDraw(&g_sContext, pcBuffer, -1, 150, 80, true);
+
+ //
+ // Update the RX buffer fullness. Remember that the buffers are
+ // named relative to the USB whereas the status display is from
+ // the UART's perspective. The USB's receive buffer is the UART's
+ // transmit buffer.
+ //
+ ui32Fullness = ((USBBufferDataAvailable(&g_sRxBuffer) * 100) /
+ UART_BUFFER_SIZE);
+
+ UpdateBufferMeter(&g_sContext, ui32Fullness, 150, 105);
+ }
+
+ //
+ // Has there been any receive traffic since we last checked?
+ //
+ if(ui32RxCount != g_ui32UARTRxCount)
+ {
+ //
+ // Take a snapshot of the latest receive count.
+ //
+ ui32RxCount = g_ui32UARTRxCount;
+
+ //
+ // Update the display of bytes received by the UART.
+ //
+ usnprintf(pcBuffer, 16, "%d ", ui32RxCount);
+ GrStringDraw(&g_sContext, pcBuffer, -1, 150, 160, true);
+
+ //
+ // Update the TX buffer fullness. Remember that the buffers are
+ // named relative to the USB whereas the status display is from
+ // the UART's perspective. The USB's transmit buffer is the UART's
+ // receive buffer.
+ //
+ ui32Fullness = ((USBBufferDataAvailable(&g_sTxBuffer) * 100) /
+ UART_BUFFER_SIZE);
+
+ UpdateBufferMeter(&g_sContext, ui32Fullness, 150, 185);
+ }
+ }
+}
|