TM4C123FH6PM: USB host CDC function

Hello Oleg,

I have a USB Host CDC example that works for the TM4C1294NCPDT. The same should be able to be ported to the TM4C123x. Please see the following E2E post which has both the project and a detailed description of how to install it and how it works: https://e2e.ti.com/support/tools/code-composer-studio-group/ccs/f/code-composer-studio-forum/1017323/tm4c129x-and-bulk-transfer-and-device/3774058#3774058

We will look to create the same for the TM4C123x in the near future but do not have that available today.

Best Regards,

Ralph Jacobi

Looking on reality, the most common task is to communicate with some third-party devices and boards from Tiva-based one, because emploing linux boxes is not very good idea in most cases, as the task is usually rather simple - to convert protocols or concentrate several devices via some bus like CAN (like in my case - I have some set of devices, supported by third-party software, and I need to build simple solution for connecting them to PC with one cable, withoput making changes to devices and software).

Currently I'm writing the framework, it will have a structure like this:

usbhserial
 |
 +- usbhserialdriver
     |
     +- usbhserialcdc
     +- usbhserialcp210x
     +- ...

where usbhserial is a HAL layer, defining standart functions:

extern uint32_t USBHostSerialInit(tUSBCallback pfnCallback);

extern uint32_t USBHostSerialSetupInstance(tSerialInstance *psSerialInstance,
                                           tUSBCallback pfnCallback, void *pvRxBuffer);
extern void USBHostSerialClose(tSerialInstance *psSerialInstance);

extern uint32_t USBHostSerialReadData(tSerialInstance *psSerialInstance, uint8_t *pui8Data,
                                uint32_t ui32Size);
extern uint32_t USBHostSerialWriteData(tSerialInstance *psSerialInstance, uint8_t *pui8Data,
                                 uint32_t ui32Size);
extern void USBHostSerialScheduleWrite(tSerialInstance *psSerialInstance, uint8_t *pui8Data,
                                 uint32_t ui32Size);

extern uint32_t USBHostSerialInitNewDevice(tSerialInstance *psSerialInstance);

extern uint32_t USBHostSerialSetLineConfig(tSerialInstance *psSerialInstance, uint32_t ui32Baud, uint32_t ui32Coding);
extern uint32_t USBHostSerialGetBaud(tSerialInstance *psSerialInstance);
extern uint32_t USBHostSerialGetCoding(tSerialInstance *psSerialInstance);
extern uint32_t USBHostSerialSetControlLineState(tSerialInstance *psSerialInstance, uint32_t ui32Control);
extern uint32_t USBHostSerialGetControlLineState(tSerialInstance *psSerialInstance);
extern uint32_t USBHostSerialBreakSet(tSerialInstance *psSerialInstance);
extern uint32_t USBHostSerialBreakClear(tSerialInstance *psSerialInstance);

which can be called from application layer without knowing how the underlayer driver works,

usbhserialdriver defines interface to drivers, declaring driver definition structure:

//*****************************************************************************
//
//! This is the structure that holds all of the data for a given driver of
//! a serial device.
//
//*****************************************************************************
typedef struct {

    //
    //! The interface class that this device class driver supports.
    //
    uint32_t ui32InterfaceClass;

    //
    //! Vendor ID of device (0 - do not care)
    //
    uint16_t ui16VID;

    //
    //! Product ID of device (0 - do not care)
    //
    uint16_t ui16PID;

    //
    //! Polling mode flag
    //
    bool bPolling;

    //
    //! Polling interval
    //
    uint32_t ui32Interval;

    //
    //! Init function pointer
    //
    uint32_t (* pfnInit)(tSerialInstance *psSerialInstance);

    //
    //! Baud set function pointer
    //
    uint32_t (* pfnSetBaud)(tSerialInstance *psSerialInstance, uint32_t ui32Baud);

    //
    //! Baud get function pointer
    //
    uint32_t (* pfnGetBaud)(tSerialInstance *psSerialInstance);

    //
    //! Line coding set function pointer
    //
    uint32_t (* pfnSetBaud)(tSerialInstance *psSerialInstance, uint32_t ui32Coding);

    //
    //! Line coding get function pointer
    //
    uint32_t (* pfnGetCoding)(tSerialInstance *psSerialInstance);

    //
    //! Control line set function pointer
    //
    uint32_t (* pfnSetControlLineState)(tSerialInstance *psSerialInstance, uint32_t ui32Control);

    //
    //! Control line set function pointer
    //
    uint32_t (* pfnGetControlLineState)(tSerialInstance *psSerialInstance);

    //
    //! Break set function pointer
    //
    uint32_t (* pfnBreakSet)(tSerialInstance *psSerialInstance);

    //
    //! Break clear function pointer
    //
    uint32_t (* pfnBreakClear)(tSerialInstance *psSerialInstance);

} tUSBSerialDriver;

This approach will allow easy creation of additional drivers. Initially I'll supply two drivers with code: the CDC one and CP210x, as I have them and can implement and test.

One more note: provided example cannot work with more than one device or multichannel devices and I want to make it fully instance-based.

Finished draft framework and 2 drivers. Here is the library:

usbhserial @ google drive

And simple example main.c:

#include <stdint.h>
#include <stdbool.h>
#include <string.h>

#include <stdio.h>
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/debug.h"
#include "driverlib/gpio.h"
#include "driverlib/pin_map.h"
#include "driverlib/rom.h"
#include "driverlib/rom_map.h"
#include "driverlib/sysctl.h"
#include "driverlib/uart.h"
#include "driverlib/udma.h"
#include "usblib/usblib.h"
#include "usblib/usbcdc.h"
#include "usblib/host/usbhost.h"
#include "usbhserial.h"
#include "usbhserialdriver.h"
#include "usbhserialcdc.h"
#include "usbhserialcp210x.h"

//*****************************************************************************
//
// The number of SysTick ticks per second.
//
//*****************************************************************************
#define TICKS_PER_SECOND 100
#define MS_PER_SYSTICK (1000 / TICKS_PER_SECOND)

//*****************************************************************************
//
// Our running system tick counter and a global used to determine the time
// elapsed since last call to GetTickms().
//
//*****************************************************************************
uint32_t g_ui32SysTickCount;
uint32_t g_ui32LastTick;
uint8_t g_pUSBPipeBuffer[USB_TRANSFER_SIZE];

tUSBSerialDriver g_psDrivers[] =
{
 DECLARE_USB_SERIAL_CDC_DRIVER,
 DECLARE_USB_SERIAL_CP210X_DRIVER
};
uint8_t g_ui8NumDrivers = 2;

//*****************************************************************************
//
// This is the handler for this SysTick interrupt.
//
//*****************************************************************************
void
SysTickIntHandler(void)
{
    //
    // Update our tick counter.
    //
    g_ui32SysTickCount++;
}

//*****************************************************************************
//
// This function returns the number of ticks since the last time this function
// was called.
//
//*****************************************************************************
uint32_t
GetTickms(void)
{
    uint32_t ui32RetVal;
    uint32_t ui32Saved;

    ui32RetVal = g_ui32SysTickCount;
    ui32Saved = ui32RetVal;

    if(ui32Saved > g_ui32LastTick)
    {
        ui32RetVal = ui32Saved - g_ui32LastTick;
    }
    else
    {
        ui32RetVal = g_ui32LastTick - ui32Saved;
    }

    //
    // This could miss a few milliseconds but the timings here are on a
    // much larger scale.
    //
    g_ui32LastTick = ui32Saved;

    //
    // Return the number of milliseconds since the last time this was called.
    //
    return(ui32RetVal * MS_PER_SYSTICK);
}

uint32_t
CDCSerialCallback(void *pvCBData, uint32_t ui32Event,
                  uint32_t ui32MsgParam, void *pvMsgData)
{
    tSerialInstance *psInstance = (tSerialInstance *)pvCBData;
    uint32_t ui32Count;
    uint32_t ui16BytesReceived;

    switch(ui32Event)
    {
        //
        // Data was detected.
        //
        case USB_EVENT_RX_AVAILABLE:
        {
            ui16BytesReceived = USBHostSerialReadDataCount(psInstance);

            printf("Data received: ");
            for (ui32Count = 0; ui32Count < ui16BytesReceived; ui32Count++)
            {
                printf("%02X ", g_pUSBPipeBuffer[ui32Count]);
            }
            printf("\n");
            break;
        }
        case USB_EVENT_TX_COMPLETE:
        {
            break;
        }
    }
    return 0;
}

bool bConnected = false;
bool bSent = false;

tSerialInstance *psInstance = 0;

uint32_t
CDCSerialGlobalCallback(void *pvCBData, uint32_t ui32Event,
                  uint32_t ui32MsgParam, void *pvMsgData)
{
    if(ui32Event == USB_EVENT_CONNECTED)
    {
        psInstance = (tSerialInstance *)pvCBData;
        USBHostSerialSetupInstance(psInstance, CDCSerialCallback, g_pUSBPipeBuffer);
        USBHostSerialInitNewDevice(psInstance);
        USBHostSerialSetLineConfig(psInstance, 19200, USBHS_CONF_STOP_1 | USBHS_CONF_PAR_NONE | USBHS_CONF_DATA_8);

        printf("Connected serial device, driver = %d\n", (int)psInstance->ui8Driver);
        bConnected = true;
        return 0;
    }
    if(ui32Event == USB_EVENT_UNKNOWN_CONNECTED)
    {
        printf("Unknown device connected\n");
    }
}

#define HCD_MEMORY_SIZE         128
uint8_t g_pHCDPool[HCD_MEMORY_SIZE];

/**
 * main.c
 */
int main(void)
{
    SysCtlClockSet(SYSCTL_SYSDIV_2_5 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
                   SYSCTL_XTAL_16MHZ);
    uint32_t ui32SysClock = 80000000;
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
    GPIOPinTypeUSBAnalog(GPIO_PORTD_BASE, GPIO_PIN_5 | GPIO_PIN_4);

    //
    // Configure SysTick for a 100Hz interrupt.
    //
    SysTickPeriodSet(ui32SysClock / TICKS_PER_SECOND);
    SysTickEnable();
    SysTickIntEnable();

    //
    // Initialize the USB stack in host mode. No callback is needed at this
    // time.
    //
    USBStackModeSet(0, eUSBModeHost, 0);

    USBHostSerialInit(CDCSerialGlobalCallback);

    //
    // Initialize the power configuration.  This sets the power enable signal
    // to be active high and does not enable the power fault.
    //
    USBHCDPowerConfigInit(0, USBHCD_VBUS_AUTO_HIGH | USBHCD_VBUS_FILTER);
    USBHCDFeatureSet(0, USBLIB_FEATURE_CPUCLK, &ui32SysClock);

    //
    // Initialize the USB controller for host operation.
    //
    USBHCDInit(0, g_pHCDPool, HCD_MEMORY_SIZE);

    printf("USB host initialized\n");

    while(1)
    {
        //
        // Tell the OTG library code how much time has passed in
        // milliseconds since the last call.
        //
        USBOTGMain(GetTickms());
        if(bConnected && !bSent)
        {
            uint8_t Out[7] = {0x70, 0x01, 0, 0, 0, 0, 0x71};

            USBHostSerialScheduleWrite(psInstance,
                                 Out,
                                 7);
            bSent = true;
        }
    }

    return 0;
}

Example connects to device, determines it's cp210x, configures port, sends sample command and prints response.