TMS320F28374D: how can I data 256 bytes of data at a time in 50 usec over USB?

Hello Akash,

Have you verified that the timer ISR is executing properly each time that the data is sent via the ISR? Is it a consistent issue regarding what data/how much data is not sent properly, or is it random every time?

Best regards,

Omer Amir

Hello Omer Amir,

Thanks for reply,

I verified Timer ISR executing properly, with the help of Scope.

yes, I try to send data in timer ISR, main while loop also I was tried.

it is constant number of bytes (256 bytes)

but I'm using USBCDC communications virtual com Port. 

I can only be able to send 32 bytes at time. and I will get 32 bytes I'm application as well in sequence in 50 usec.

if I increased number of bytes to 256 then it will start sending packet size 4096 data it is ok, but data is missing.

My question is it possible to send 256 bytes I single packet in 50 usec. if yes please suggest me where i need to modify.

Thanks,

Hi,

The USB CDC is based on bulk transfer endpoints, so the maximum packet size of full speed USB CDC is 64 bytes.  You will have to send multiple packets for 256 bytes.  Are you able to send the data but it's not within the specified time? 

Can you share the snippet of code where you are transferring the data?

Best Regards

Siddharth

//###########################################################################
//
// FILE: usb_dev_serial.c
//
// TITLE: Main routines for the USB CDC serial example.
//
//###########################################################################
// $TI Release: F2837xD Support Library v210 $
// $Release Date: Tue Nov 1 14:46:15 CDT 2016 $
// $Copyright: Copyright (C) 2013-2016 Texas Instruments Incorporated -
// http://www.ti.com/ ALL RIGHTS RESERVED $
//###########################################################################

//
// Included Files
//
#include "F28x_Project.h"
#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/interrupt.h"
#include "driverlib/sysctl.h"
#include "driverlib/systick.h"
#include "driverlib/uart.h"
#include "driverlib/usb.h"
#include "driverlib/usb_hal.h"
#include "driverlib/rom.h"
#include "usblib/usblib.h"
#include "usblib/usbcdc.h"
#include "usblib/usb-ids.h"
#include "usblib/usblibpriv.h"
#include "usblib/device/usbdevice.h"
#include "usblib/device/usbdcdc.h"
#include "utils/ustdlib.h"
#include "usb_serial_structs.h"
//#include "USBDMA.h"

__interrupt void cpu_timer0_isr(void);
//*****************************************************************************
//
//! \addtogroup cpu01_example_list
//! <h1>USB Serial Device (usb_dev_serial)</h1>
//!
//! This example application turns the evaluation 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.
//!
//! Connect USB cables from your PC to both the mini and microUSB connectors on
//! the controlCARD.Figure out what COM ports your controlCARD is enumerating
//! (typically done using Device Manager in Windows) and open a serial terminal
//! to each of with the settings 115200 Baud 8-N-1. Characters typed in one
//! terminal should be echoed in the other and vice versa.
//!
//! A driver information (INF) file for use with Windows XP and
//! Windows 7 can be found in the windows_drivers directory.
//
//*****************************************************************************
//*****************************************************************************
//
// Configuration and tuning parameters.
//
//*****************************************************************************

//*****************************************************************************
//
// 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)

//*****************************************************************************
//
// Variables tracking transmit and receive counts.
//
//*****************************************************************************
volatile uint32_t g_ui32UARTTxCount = 0;
volatile uint32_t g_ui32UARTRxCount = 0;

uint32_t tx_flag = 0;

#ifdef DEBUG
uint32_t g_ui32UARTRxErrors = 0;
#endif

//*****************************************************************************
//
// The base address, peripheral ID and interrupt ID of the UART that is to
// be redirected.
//
//*****************************************************************************

//*****************************************************************************
//
// Defines required to redirect UART0 via USB.
//
//*****************************************************************************
#define USB_UART_BASE UARTA_BASE
#define USB_UART_PERIPH SYSCTL_PERIPH_SCI1
#define USB_UART_INT INT_SCIRXINTA

//*****************************************************************************
//
// 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)

//*****************************************************************************
//
// Flag indicating whether or not we are currently sending a Break condition.
//
//*****************************************************************************
static bool g_bSendingBreak = false;

//*****************************************************************************
//
// Global system tick counter
//
//*****************************************************************************
volatile uint32_t g_ui32SysTickCount = 0;

//*****************************************************************************
//
// Flags used to pass commands from interrupt context to the main loop.
//
//*****************************************************************************
#define COMMAND_PACKET_RECEIVED 0x00000001
#define COMMAND_STATUS_UPDATE 0x00000002

volatile uint32_t g_ui32Flags = 0;
char *g_pcStatus;

//*****************************************************************************
//
// Global flag indicating that a USB configuration has been set.
//
//*****************************************************************************
static volatile bool g_bUSBConfigured = false;

//****************************************************************************
//
// Rx and Tx buffer for handling data from the applications end
//
//****************************************************************************

uint8_t USBRxBuffer[100];
uint8_t USBTxBuffer[256] =
{

0xAA,0x55
,0x00,1,0x00,2,0x00,3,0x00,4,0x00,5
,0x00,6,0x00,7,0x00,8,0x00,9,0x00,10
,0x00,11,0x00,12,0x00,13,0x00,14,0x00,15
// ,0x00,16,0x00,17,0x00,18,0x00,19,0x00,20
// ,0x00,21,0x00,22,0x00,23,0x00,24,0x00,25,0x00,26,
/*0x01,0x02,0x03,0x04,0x05,0x06,0x07,
0x00,0x01,0x00,0x02,0x00,0x03,0x00,0x04,0x00*/

};

uint8_t peranum = 32;
uint8_t peranum1= 64;

uint8_t USB_remain_data = 0;
//***************************************************************************
//
//Additional variables below
//
//******************************************************************************

void sciaRxFifoIsr();
void Load_Rx_Paremeters();

//*****************************************************************************
//
// Internal function prototypes.
//
//*****************************************************************************

static void SetControlLineState(uint16_t ui16State);
static bool SetLineCoding(tLineCoding *psLineCoding);
static void GetLineCoding(tLineCoding *psLineCoding);
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
//*****************************************************************************
//
// Interrupt handler for the system tick counter.
//
//*****************************************************************************

__interrupt void
SysTickIntHandler(void)
{
//
// Update our system time.
//
g_ui32SysTickCount++;
PieCtrlRegs.PIEACK.all |= 1;
}

//*****************************************************************************
//
// 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 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 ui8Stop, 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 ui8Stop 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.
//
UARTConfigSetExpClk(USB_UART_BASE, SysCtlLowSpeedClockGet(SYSTEM_CLOCK_SPEED),
readusb32_t(&(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 ui32Config;
uint32_t ui32Rate;

//
// Get the current line coding set in the UART.
//
UARTConfigGetExpClk(USB_UART_BASE, SysCtlLowSpeedClockGet(SYSTEM_CLOCK_SPEED),
&ui32Rate, &ui32Config);
writeusb32_t(&(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;
}
}

//
// 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)
{
//
//C28x SCI cannot send break conditions
//
return;
}

//*****************************************************************************
//
// Handles CDC driver notifications related to control and setup of the device.
//
// \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 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.
//
//*****************************************************************************

// call

uint32_t
ControlHandler(void *pvCBData, uint32_t ui32Event,
uint32_t ui32MsgValue, void *pvMsgData)
{
uint32_t ui32IntsOff;

//
// 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:
g_bUSBConfigured = true;

//
// Flush our buffers.
//
USBBufferFlush(&g_sTxBuffer);
USBBufferFlush(&g_sRxBuffer);

//
// Tell the main loop to update the display.
//
ui32IntsOff = IntMasterDisable();
g_pcStatus = "Connected";
g_ui32Flags |= COMMAND_STATUS_UPDATE;
if(!ui32IntsOff)
{
IntMasterEnable();
}
break;

//
// The host has disconnected.
//
case USB_EVENT_DISCONNECTED:
g_bUSBConfigured = false;
ui32IntsOff = IntMasterDisable();
g_pcStatus = "Disconnected";
g_ui32Flags |= COMMAND_STATUS_UPDATE;
if(!ui32IntsOff)
{
IntMasterEnable();
}
break;

//
// Return the current serial communication parameters.
//
case USBD_CDC_EVENT_GET_LINE_CODING:
GetLineCoding(pvMsgData);
break;

//
// Set the current serial communication parameters.
//
case USBD_CDC_EVENT_SET_LINE_CODING:
SetLineCoding(pvMsgData);
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.
//
tx_flag = 0;
GpioDataRegs.GPATOGGLE.bit.GPIO31 = 1;

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.
//
//*****************************************************************************

//call

uint32_t
RxHandler(void *pvCBData, uint32_t ui32Event, uint32_t ui32MsgValue,
void *pvMsgData)
{
uint32_t ui32Count;
uint32_t ui32Read;
uint8_t ui8Char;

//
// 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.
//
// 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(g_bSendingBreak)
{
return(0);
}

//
// If there is space in the UART FIFO, try to read some characters
// from the receive buffer to fill it again.
//
while(UARTSpaceAvail(USB_UART_BASE))
{
//
// Get a character from the buffer.
//
ui32Read = USBBufferRead((tUSBBuffer *)&g_sRxBuffer, &ui8Char, 1);

//
// Did we get a character?
//
if(ui32Read)
{

//
// Update our count of bytes transmitted via the UART.
//
USBRxBuffer [g_ui32UARTTxCount] = ui8Char;
g_ui32UARTTxCount++;

if(g_ui32UARTTxCount > 99)
g_ui32UARTTxCount=0;
}
else
{
//
// We ran out of characters so exit the function.
//
return(0);
}
}

// USBUARTPrimeTransmit(USB_UART_BASE);
UARTIntEnable(USB_UART_BASE, UART_INT_TXRDY); //call
// USBBufferDataWritten(&g_sTxBuffer, 215);
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(USB_UART_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.
//
//*****************************************************************************

uint16_t tmr_inex= 0;
uint32_t datleght = 32;

__interrupt void cpu_timer0_isr(void)
{
//CpuTimer0.InterruptCount++;
//GpioDataRegs.GPBSET.bit.GPIO34 = 1;
DELAY_US(35);

tmr_inex++;
USBTxBuffer[8] = tmr_inex >> 8;
USBTxBuffer[9] = tmr_inex;

//if (tx_flag == 1)

USBBufferWrite((tUSBBuffer *)&g_sTxBuffer,(uint8_t *)&USBTxBuffer[0], peranum);

//GpioDataRegs.GPBCLEAR.bit.GPIO34 = 1;
PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
}

int
main(void)
{

uint32_t ui32RxCount;
volatile uint32_t ui32Fullness;

InitSysCtrl();
DINT;
InitPieCtrl();
IER = 0x0000;
IFR = 0x0000;

#ifdef _FLASH
// Copy time critical code and Flash setup code to RAM
// This includes the following functions: InitFlash();
// The RamfuncsLoadStart, RamfuncsLoadSize, and RamfuncsRunStart
// symbols are created by the linker. Refer to the device .cmd file.
memcpy(&RamfuncsRunStart, &RamfuncsLoadStart, (size_t)&RamfuncsLoadSize);
#endif

//
// Set the clocking to run from the PLL at 50MHz
//
SysCtlClockSet(SYSCTL_OSCSRC_XTAL | SYSCTL_PLL_ENABLE | SYSCTL_IMULT(20) |
SYSCTL_SYSDIV(2));
SysCtlAuxClockSet(SYSCTL_OSCSRC_XTAL | SYSCTL_PLL_ENABLE |
SYSCTL_IMULT(12) | SYSCTL_SYSDIV(4));

#ifdef _FLASH
// Call Flash Initialization to setup flash waitstates
// This function must reside in RAM
InitFlash();
#endif

//
// Initialize interrupt controller and vector table
//
InitPieVectTable();

EALLOW;
GpioCtrlRegs.GPBMUX1.bit.GPIO34 = 0;
GpioCtrlRegs.GPBDIR.bit.GPIO34 = 1;
GpioCtrlRegs.GPAMUX2.bit.GPIO31 = 0;
GpioCtrlRegs.GPADIR.bit.GPIO31 = 1;
EDIS;

//
// Not configured initially.
//
g_bUSBConfigured = false;

//
// Configure the required pins for USB operation.
//
USBGPIOEnable();
USBIntRegister(USB0_BASE, f28x_USB0DeviceIntHandler);
//
// Enable the UART that we will be redirecting.
//
SysCtlPeripheralEnable(USB_UART_PERIPH);

//
// Configure GPIO Pins for UART mode.
//
EALLOW;
GpioCtrlRegs.GPAMUX2.bit.GPIO28 = 1;
GpioCtrlRegs.GPAPUD.bit.GPIO28 = 0;
GpioCtrlRegs.GPAQSEL2.bit.GPIO28 = 3;
GpioCtrlRegs.GPADIR.bit.GPIO28 = 0;

GpioCtrlRegs.GPAMUX2.bit.GPIO29 = 1;
GpioCtrlRegs.GPAPUD.bit.GPIO29 = 0;
GpioCtrlRegs.GPADIR.bit.GPIO29 = 1;
EDIS;

//
// TODO: Add code to configure handshake GPIOs if required.
//

//
// Set the default UART configuration.
//
/*UARTConfigSetExpClk(USB_UART_BASE, SysCtlLowSpeedClockGet(SYSTEM_CLOCK_SPEED),
DEFAULT_BIT_RATE, DEFAULT_UART_CONFIG);
UARTFIFOIntLevelSet(USB_UART_BASE, UART_FIFO_TX4_8, UART_FIFO_RX4_8);*/

//
// Configure and enable UART interrupts.
//
/*UARTIntClear(USB_UART_BASE, UARTIntStatus(USB_UART_BASE, false));
UARTIntEnable(USB_UART_BASE, (UART_INT_RXERR | UART_INT_RXRDY_BRKDT |
UART_INT_TXRDY ));*/
//
// Enable the system tick.
//
/* SysTickInit();
SysTickPeriodSet(SysCtlClockGet(SYSTEM_CLOCK_SPEED) / SYSTICKS_PER_SECOND);
SysTickIntRegister(SysTickIntHandler);
SysTickIntEnable();
SysTickEnable();
*/
//
// 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.
//
USBDCDCInit(0, &g_sCDCDevice);

//
// Clear our local byte counters.
//
ui32RxCount = 0; //
// Enable interrupts now that the application is ready to start.
//
IntEnable(USB_UART_INT);
IntMasterEnable();

EALLOW; // This is needed to write to EALLOW protected registers
PieVectTable.TIMER0_INT = &cpu_timer0_isr;
InitCpuTimers();
ConfigCpuTimer(&CpuTimer0, 200, 50);
CpuTimer0Regs.TCR.all = 0x4001;
IER |= M_INT1;
PieCtrlRegs.PIEIER1.bit.INTx7 = 1;
CpuTimer0Regs.TCR.bit.FREE = 1;
CpuTimer0Regs.TCR.bit.TSS = 0;

EDIS;
EINT; // Enable Global __interrupt INTM
ERTM;

/*************************************************************************/
// DMA init
/***********************************************************************/
//tUSBDMAInstance *psUSBDMAInst = USBLibDMAInit (USB0_BASE);
USBFIFOConfigSet(USB0_BASE,USB_EP_2,0x00000028,USB_FIFO_SZ_32_DB,USB_EP_DEV_IN);
//USBDevEndpointConfigSet (USB0_BASE,USB_EP_2,USB_FIFO_SZ_32_DB,USB_EP_SPEED_FULL);
// USBEndpointDMAConfigSet(USB0_BASE, USB_EP_1,USB_EP_AUTO_SET);
// USBEndpointDMAEnable(USB0_BASE, USB_EP_1, USB_EP_DEV_IN);

/***********************************************************************/

//
// Main application loop.
//
while(1)
{

/*if(g_ui32Flags & COMMAND_STATUS_UPDATE)
{
//
// Clear the command flag
//
IntMasterDisable();
g_ui32Flags &= ~COMMAND_STATUS_UPDATE;
IntMasterEnable();
}

//
// Has there been any receive traffic since we last checked?
//

if(ui32RxCount != g_ui32UARTRxCount)
//if(1)
{
//
// Take a snapshot of the latest receive count.
//
ui32RxCount = g_ui32UARTRxCount;
//
// Update the TX buffer fullness. Remember that the buffers ar
// 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);
}
*/
//
// Has there been any Transmit traffic since we last checked?
//

/*
if (tx_flag == 1)
{
//USBBufferDataWritten(&USBTxBuffer[0], 8);
//USBTxBuffer[8] = tmr_inex >> 8;
//USBTxBuffer[9] = tmr_inex;
tx_flag = 0;
USBBufferWrite((tUSBBuffer *)&g_sTxBuffer,(uint8_t *)&USBTxBuffer[0], peranum1);

// USBBufferDataWritten ((tUSBBuffer *)&g_sTxBuffer,peranum);

//USBEndpointDataPut(USB0_BASE,USB_EP_2, &USBTxBuffer[0], USB_FIFO_SZ_256_DB);
//USBEndpointDataSend (USB0_BASE,USB_EP_2,USB_TRANS_OUT);
}*/
}
}
//
// End of file
//

HI Siddharth,

This is my main file full code, any length of data i send on PC application is missing data.

my requirement is to send 256bytes of data in 50usec.

please suggest any solution.

Thanks in advance.

Akash, 

I am out of office today, will take a look at the code that you shared and get back by early next week.

Best Regards

Siddharth

Hi Siddharth,

Thanks for response.

please get back to me my next week.

Thank you for your time,

Hi Siddharth,

if there is any solution for my problem, please give us.

we are waiting for your response.

Thank You

Hi, 

Are you seeing all the data in the USB ring buffer? 

Is it getting overwritten due to which the data is missing?

Best Regards

Siddharth

Hi Siddharth,

can you please clarify name of ring buffer.

if I increase size of ring buffer my problem will resolve or is there any solution to avoid it.

Thank you

Hi Akash,

"g_pi8USBTxBuffer" and "g_pi8USBRxBuffer" are the ring buffers that are used in the example.

Best Regards

Siddharth

Hi Siddharth,

For data transmission1 bit is taking 84ns, and 54 bytes of data with frame it become 81 bytes. so, it is taking around 54usec.

now my question is there any option to reduce this time duration.

Thank you.

Akash, 

How are you measuring the time? Can check using the profiling clock in CCS (count CPU cycles).? 

If you have a USB analyzer you can see if the host is requesting the data fast enough to get the throughput you need.We have been able to achieve 7-8 Mbps using a Visual Studio project on a Windows PC and the usb bulk example.

Best Regards

Siddharth