/**
* \brief usart-hard-handshaking Application entry point..
*
* Configures USART0 in hardware handshaking mode and
* Timer Counter 0 to generate an interrupt every second. Then, starts the first
* transfer on the USART and wait in an endless loop.
*
* \return Unused (ANSI-C compatibility).
* \callgraph
*/
extern int main( void )
{
/* Disable watchdog*/
WDT_Disable( WDT ) ;
/* Configure pins*/
PIO_Configure( pins, PIO_LISTSIZE( pins ) ) ;
/* Configure USART and display startup trace*/
_ConfigureUsart() ;
printf( "-- USART Hardware Handshaking Example %s --\n\r", SOFTPACK_VERSION ) ;
printf( "-- %s\n\r", BOARD_NAME ) ;
printf( "-- Compiled: %s %s --\n\r", __DATE__, __TIME__ ) ;
/* Configure TC0 to generate a 1s tick*/
_ConfigureTc0() ;
/* Start receiving data and start timer*/
USART_ReadBuffer( BOARD_USART_BASE, pBuffer, BUFFER_SIZE ) ;
BOARD_USART_BASE->US_IER = US_IER_RXBUFF ;
TC_Start( TC0, 0 ) ;
/* Infinite loop*/
while ( 1 ) ;
}
//------------------------------------------------------------------------------
/// Handles interrupts coming from Timer #0.
//------------------------------------------------------------------------------
static void ISR_Timer0()
{
unsigned char size;
unsigned int status = AT91C_BASE_TC0->TC_SR;
if ((status & AT91C_TC_CPCS) != 0) {
// Flush PDC buffer
size = DATABUFFERSIZE - AT91C_BASE_US0->US_RCR;
if (size == 0) {
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
return;
}
AT91C_BASE_US0->US_RCR = 0;
// Send current buffer through the USB
while (CDCDSerialDriver_Write(usartBuffers[usartCurrentBuffer],
size, 0, 0) != USBD_STATUS_SUCCESS);
// Restart read on buffer
USART_ReadBuffer(AT91C_BASE_US0,
usartBuffers[usartCurrentBuffer],
DATABUFFERSIZE);
usartCurrentBuffer = 1 - usartCurrentBuffer;
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
}
}
/**
* Handles interrupts coming from Timer #0.
*/
void TC0_IrqHandler(void)
{
Tc *pTc0 = TC0;
uint8_t size;
volatile uint32_t status = pTc0->TC_CHANNEL[0].TC_SR;
if ((status & TC_SR_CPCS) != 0) {
/* Serial Timer */
if (isSerialPortON) {
/* Flush PDC buffer */
size = DATABUFFERSIZE - BASE_USART->US_RCR;
if (size == 0) {
pTc0->TC_CHANNEL[0].TC_CCR = TC_CCR_CLKEN | TC_CCR_SWTRG;
return;
}
BASE_USART->US_RCR = 0;
/* Send current buffer through the USB */
CDCDSerial_Write(usartBuffers[usartCurrentBuffer],
size, 0, 0);
/* Restart read on buffer */
USART_ReadBuffer(BASE_USART,
usartBuffers[usartCurrentBuffer],
DATABUFFERSIZE);
usartCurrentBuffer = 1 - usartCurrentBuffer;
pTc0->TC_CHANNEL[0].TC_CCR = TC_CCR_CLKEN | TC_CCR_SWTRG;
}
}
}
/**
* \brief Interrupt handler for TC0.
*
* Displays the number of bytes received during the
* last second and the total number of bytes received, then restarts a read
* transfer on the USART if it was stopped.
*/
void TC0_IrqHandler( void )
{
uint32_t dwStatus ;
static uint32_t bytesTotal = 0 ;
/* Read TC0 status*/
dwStatus = TC0->TC_CHANNEL[0].TC_SR;
/* RC compare*/
if ( (dwStatus & TC_SR_CPCS) == TC_SR_CPCS )
{
/* Display info*/
bytesTotal += bytesReceived ;
sprintf( pString, "Bps: %4u; Tot: %6u\n\r", (unsigned int)bytesReceived, (unsigned int)bytesTotal ) ;
USART_WriteBuffer( BOARD_USART_BASE, pString, sizeof( pString ) ) ;
bytesReceived = 0 ;
/* Resume transfer if needed*/
if ( BOARD_USART_BASE->US_RCR == 0 )
{
USART_ReadBuffer( BOARD_USART_BASE, pBuffer, BUFFER_SIZE ) ;
BOARD_USART_BASE->US_IER = US_IER_RXBUFF ;
}
}
}
/**
* \brief Interrupt handler for USART.
*
* Increments the number of bytes received in the
* current second and starts another transfer if the desired bps has not been
* met yet.
*/
void USART1_IrqHandler(void)
{
uint32_t status;
/* Read USART status*/
status = BOARD_USART_BASE->US_CSR;
/* Receive buffer is full*/
if ((status & US_CSR_RXBUFF) == US_CSR_RXBUFF) {
bytesReceived += BUFFER_SIZE;
/* Restart transfer if BPS is not high enough*/
if (bytesReceived < MAX_BPS) {
USART_ReadBuffer(BOARD_USART_BASE, pBuffer, BUFFER_SIZE);
}
/* Otherwise disable interrupt*/
else {
BOARD_USART_BASE->US_IDR = US_IDR_RXBUFF;
}
}
}
//------------------------------------------------------------------------------
/// Initializes drivers and start the USB <-> Serial bridge.
//------------------------------------------------------------------------------
int main()
{
TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
TRACE_INFO("-- USB Device CDC Serial Project %s --\n\r", SOFTPACK_VERSION);
TRACE_INFO("-- %s\n\r", BOARD_NAME);
TRACE_INFO("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
// If they are present, configure Vbus & Wake-up pins
PIO_InitializeInterrupts(0);
// Configure USART
PIO_Configure(pins, PIO_LISTSIZE(pins));
AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_US0;
AT91C_BASE_US0->US_IDR = 0xFFFFFFFF;
USART_Configure(AT91C_BASE_US0,
USART_MODE_ASYNCHRONOUS,
115200,
BOARD_MCK);
USART_SetTransmitterEnabled(AT91C_BASE_US0, 1);
USART_SetReceiverEnabled(AT91C_BASE_US0, 1);
AIC_ConfigureIT(AT91C_ID_US0, 0, ISR_Usart0);
AIC_EnableIT(AT91C_ID_US0);
// Configure timer 0
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC0);
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKDIS;
AT91C_BASE_TC0->TC_IDR = 0xFFFFFFFF;
AT91C_BASE_TC0->TC_CMR = AT91C_TC_CLKS_TIMER_DIV5_CLOCK
| AT91C_TC_CPCSTOP
| AT91C_TC_CPCDIS
| AT91C_TC_WAVESEL_UP_AUTO
| AT91C_TC_WAVE;
AT91C_BASE_TC0->TC_RC = 0x00FF;
AT91C_BASE_TC0->TC_IER = AT91C_TC_CPCS;
AIC_ConfigureIT(AT91C_ID_TC0, 0, ISR_Timer0);
AIC_EnableIT(AT91C_ID_TC0);
// BOT driver initialization
CDCDSerialDriver_Initialize();
// connect if needed
VBus_Configure();
// Driver loop
while (1) {
// Device is not configured
if (USBD_GetState() < USBD_STATE_CONFIGURED) {
// Connect pull-up, wait for configuration
USBD_Connect();
while (USBD_GetState() < USBD_STATE_CONFIGURED);
// Start receiving data on the USART
usartCurrentBuffer = 0;
USART_ReadBuffer(AT91C_BASE_US0, usartBuffers[0], DATABUFFERSIZE);
USART_ReadBuffer(AT91C_BASE_US0, usartBuffers[1], DATABUFFERSIZE);
AT91C_BASE_US0->US_IER = AT91C_US_ENDRX
| AT91C_US_FRAME
| AT91C_US_OVER;
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
// Start receiving data on the USB
CDCDSerialDriver_Read(usbBuffer,
DATABUFFERSIZE,
(TransferCallback) UsbDataReceived,
0);
}
if( USBState == STATE_SUSPEND ) {
TRACE_DEBUG("suspend !\n\r");
LowPowerMode();
USBState = STATE_IDLE;
}
if( USBState == STATE_RESUME ) {
// Return in normal MODE
TRACE_DEBUG("resume !\n\r");
NormalPowerMode();
USBState = STATE_IDLE;
}
}
}
//------------------------------------------------------------------------------
/// Handles interrupts coming from USART #0.
//------------------------------------------------------------------------------
static void ISR_Usart0()
{
unsigned int status = AT91C_BASE_US0->US_CSR;
unsigned short serialState;
// If USB device is not configured, do nothing
if (USBD_GetState() != USBD_STATE_CONFIGURED) {
AT91C_BASE_US0->US_IDR = 0xFFFFFFFF;
return;
}
// Buffer has been read successfully
if ((status & AT91C_US_ENDRX) != 0) {
// Disable timer
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKDIS;
// Send buffer through the USB
while (CDCDSerialDriver_Write(usartBuffers[usartCurrentBuffer],
DATABUFFERSIZE, 0, 0) != USBD_STATUS_SUCCESS);
// Restart read on buffer
USART_ReadBuffer(AT91C_BASE_US0,
usartBuffers[usartCurrentBuffer],
DATABUFFERSIZE);
usartCurrentBuffer = 1 - usartCurrentBuffer;
// Restart timer
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
}
// Buffer has been sent
if ((status & AT91C_US_TXBUFE) != 0) {
// Restart USB read
CDCDSerialDriver_Read(usbBuffer,
DATABUFFERSIZE,
(TransferCallback) UsbDataReceived,
0);
AT91C_BASE_US0->US_IDR = AT91C_US_TXBUFE;
}
// Errors
serialState = CDCDSerialDriver_GetSerialState();
// Overrun
if ((status & AT91C_US_OVER) != 0) {
TRACE_WARNING( "ISR_Usart0: Overrun\n\r");
serialState |= CDCDSerialDriver_STATE_OVERRUN;
}
// Framing error
if ((status & AT91C_US_FRAME) != 0) {
TRACE_WARNING( "ISR_Usart0: Framing error\n\r");
serialState |= CDCDSerialDriver_STATE_FRAMING;
}
CDCDSerialDriver_SetSerialState(serialState);
}
/**
* \brief Application entry point.
*
* Configures USART1 in spi master/slave mode and SPI in slave/master mode,start
* a transmission between two peripherals.
* \return Unused.
*/
extern int main( void )
{
char c ;
char data = 0x0 ;
/* Disable watchdog */
WDT_Disable( WDT ) ;
/* Configure pins */
PIO_Configure( pins, PIO_LISTSIZE( pins ) ) ;
/* Example information log */
printf( "-- USART SPI Mode Example %s --\n\r", SOFTPACK_VERSION ) ;
printf( "-- %s\n\r", BOARD_NAME ) ;
printf( "-- Compiled: %s %s --\n\r", __DATE__, __TIME__ ) ;
/* display main menu*/
_DisplayMainmenu() ;
/* configure USART1 in Master and SPI in slave mode*/
_ConfigureUsart( STATE_UM_SS ) ;
_ConfigureSpi( STATE_UM_SS ) ;
printf( "-- USART1 as MASTER,SPI as SLAVE.--\n\r" ) ;
while ( 1 )
{
c = UART_GetChar() ;
switch ( c )
{
case 'w':
case 'W':
if ( glob_state == STATE_UM_SS )
{
data = SPI->SPI_RDR;
printf( "0x%x\n\r", data ) ;
/* slave in */
SPI_ReadBuffer( SPI, pRecvBufferSPI, BUFFER_SIZE ) ;
SPI_EnableIt( SPI, SPI_IER_RXBUFF ) ;
/* master out*/
USART_WriteBuffer( BOARD_USART_BASE, Buffer, BUFFER_SIZE ) ;
while ( !recvDone ) ;
if ( recvDone )
{
printf( "----USART1 MASTER WRITE----\n\r" ) ;
if ( strncmp( pRecvBufferSPI, Buffer, BUFFER_SIZE ) )
{
printf( " -F-: Failed!\n\r" ) ;
}
else
{
/* successfully received*/
_DumpInfo( pRecvBufferSPI, BUFFER_SIZE ) ;
}
printf( "----END of USART1 MASTER WRITE----\n\r" ) ;
memset( pRecvBufferSPI, 0, sizeof( pRecvBufferSPI ) ) ;
recvDone = false ;
}
}
else
{
data = USART1->US_RHR ;
printf( "US_RHR:0x%x\n\r", data ) ;
/* slave in */
USART_ReadBuffer( USART1, pRecvBufferUSART1, BUFFER_SIZE ) ;
USART_EnableIt( USART1, US_IER_RXBUFF ) ;
printf( "----SPI MASTER WRITE----\n\r" ) ;
/* master out*/
SPI_WriteBuffer( SPI, Buffer, BUFFER_SIZE ) ;
while ( !recvDone ) ;
if ( recvDone )
{
if ( strncmp( pRecvBufferUSART1, Buffer, BUFFER_SIZE ) )
{
printf( " -F-: Failed!\n\r" ) ;
}
else
{
/* successfully received*/
_DumpInfo( pRecvBufferUSART1, BUFFER_SIZE ) ;
}
printf( "----END of SPI MASTER WRITE----\n\r" ) ;
memset( pRecvBufferUSART1, 0, sizeof( pRecvBufferUSART1 ) ) ;
recvDone = false ;
}
}
break ;
case 'r':
case 'R':
if ( glob_state == STATE_UM_SS )
{
data = USART1->US_RHR ;
printf( "US_RHR:0x%x\n\r", data ) ;
/* slave out */
SPI_WriteBuffer( SPI, Buffer, BUFFER_SIZE ) ;
/* master read */
USART_ReadBuffer( USART1, pRecvBufferUSART1, BUFFER_SIZE ) ;
USART_EnableIt( USART1, US_IER_RXBUFF ) ;
/* start transmission */
USART_WriteBuffer( BOARD_USART_BASE, Buffer1, BUFFER_SIZE ) ;
printf( "----USART1 MASTER READ----\n\r" ) ;
while ( !recvDone ) ;
if ( recvDone )
{
if ( strncmp( pRecvBufferUSART1, Buffer, BUFFER_SIZE ) )
{
printf( " -F-: Failed!\n\r" ) ;
}
else
{
/* successfully received*/
_DumpInfo( pRecvBufferUSART1, BUFFER_SIZE ) ;
}
printf( "----END of USART1 MASTER READ----\n\r" ) ;
memset( pRecvBufferUSART1, 0, sizeof( pRecvBufferUSART1 ) ) ;
recvDone = false ;
}
}
else
{
data = SPI->SPI_RDR ;
printf( "SPI_RDR:0x%x\n\r", data ) ;
/* slave out */
USART_WriteBuffer( USART1, Buffer, BUFFER_SIZE ) ;
printf( "----SPI MASTER READ----\n\r" ) ;
/* master read */
SPI_ReadBuffer( SPI, pRecvBufferSPI, BUFFER_SIZE ) ;
SPI_EnableIt( SPI, SPI_IER_RXBUFF ) ;
/* start transmission */
SPI_WriteBuffer( SPI, Buffer1, BUFFER_SIZE ) ;
while ( !recvDone ) ;
if ( recvDone )
{
if ( strncmp( pRecvBufferSPI, Buffer, BUFFER_SIZE ) )
{
printf( " -F-: Failed!\n\r" ) ;
}
else
{
/* successfully received */
_DumpInfo( pRecvBufferSPI, BUFFER_SIZE ) ;
}
printf("----END of SPI MASTER READ----\n\r");
memset(pRecvBufferSPI,0,sizeof(pRecvBufferSPI));
recvDone = false;
}
}
break ;
case 's':
case 'S':
if ( glob_state == STATE_UM_SS )
{
glob_state = STATE_US_SM ;
_ConfigureUsart( glob_state ) ;
_ConfigureSpi( glob_state ) ;
printf( "-- USART1 as SLAVE,SPI as MASTER\n\r" ) ;
}
else
{
glob_state = STATE_UM_SS ;
_ConfigureUsart( glob_state ) ;
_ConfigureSpi( glob_state ) ;
printf( "-- USART1 as MASTER,SPI as SLAVE\n\r" ) ;
}
break ;
case 'm':
case 'M':
_DisplayMainmenu() ;
break ;
}
}
}
/* Usart receive task */
void vUsartRx_Task( void ) {
unsigned char pucFileName[30]; // File name
unsigned char ucReceived; // Received char
short i;
short sFlag = 0; // State flag
FIL Fil; // File object
FRESULT rc; // Result code
DIR dir; // Directory object
FILINFO fno; // File information object
UINT bw, br; // File counters
// Usart receive loop
for (;;) {
// Data is available
if (USART_IsDataAvailable(AT91C_BASE_US0)) {
USART_ReadBuffer(AT91C_BASE_US0, &ucReceived, 1);
// Stage 0: receive file name
if (sFlag == 0 && ucReceived == '\x01') {
i = 0;
memset(pucFileName, 0, 30);
sFlag = 1;
//debug_printf("\r\n--");
// Stage 1: receiving file name
} else if (sFlag == 1 && ucReceived != '\x02') {
//debug_printf("%c", ucReceived);
pucFileName[i] = ucReceived;
i++;
// Stage 1: end of file name
} else if (sFlag == 1 && ucReceived == '\x02') {
//debug_printf("\r\nRec file: %s\r\n", pucFileName);
sFlag = 2;
// Create the file
rc = f_open(&Fil, pucFileName, FA_CREATE_ALWAYS | FA_WRITE);
if (rc) {
sprintf(ucRemoteBuffer, "File creation failure.\r\n");
remote_printf(ucRemoteBuffer);
sFlag = 0;
}
// Stage 2: receive file
} else if (sFlag == 2 && ucReceived != '\x03') {
//debug_printf("%c", ucReceived);
f_write(&Fil, &ucReceived, 1, &bw);
// Stage 2: end of file
} else if (sFlag == 2 && ucReceived == '\x03') {
sFlag = 3;
// Stage 3: end of transmission
} else if (sFlag == 3 && ucReceived == '\x04') {
f_close(&Fil);
sprintf(ucRemoteBuffer, "\r\nReceived file: %s\r\n", pucFileName);
remote_printf(ucRemoteBuffer);
sFlag = 0;
}
} else {
vTaskDelay(5);
}
}
}
/**
* Initializes drivers and start the USB CDCHID device.
*/
int main(void)
{
uint8_t usbConnected = 0, serialON = 0;
/* Disable watchdog */
WDT_Disable( WDT );
printf("-- USB CDCHID Device Project %s --\n\r", SOFTPACK_VERSION);
printf("-- %s\n\r", BOARD_NAME);
printf("-- Compiled: %s %s --\n\r", __DATE__, __TIME__);
/* If they are present, configure Vbus & Wake-up pins */
PIO_InitializeInterrupts(0);
/* If there is on board power, switch it off */
/* Enable UPLL for USB */
ConfigureUsbClock();
/* Configure timer 0 */
ConfigureTc0();
/* ----- CDC Function Initialize */
/* Configure USART */
ConfigureUsart();
/* ----- HID Function Initialize */
/* Initialize key statuses and configure push buttons */
PIO_Configure(pinsPushButtons, PIO_LISTSIZE(pinsPushButtons));
memset(keyStatus, 1, NUM_KEYS);
/* Configure LEDs */
LED_Configure(LED_NUMLOCK);
/* USB CDCHID driver initialization */
CDCHIDDDriver_Initialize(&cdchiddDriverDescriptors);
/* connect if needed */
VBus_Configure();
/* Driver loop */
while (1) {
/* Device is not configured */
if (USBD_GetState() < USBD_STATE_CONFIGURED) {
if (usbConnected) {
printf("-I- USB Disconnect/Suspend\n\r");
usbConnected = 0;
/* Serial port closed */
isSerialPortON = 0;
}
}
else {
if (usbConnected == 0) {
printf("-I- USB Connect\n\r");
usbConnected = 1;
}
if (!serialON && isSerialPortON) {
printf("-I- SerialPort ON\n\r");
/* Start receiving data on the USART */
usartCurrentBuffer = 0;
USART_ReadBuffer(BASE_USART,
usartBuffers[0], DATABUFFERSIZE);
USART_ReadBuffer(BASE_USART,
usartBuffers[1], DATABUFFERSIZE);
BASE_USART->US_IER = US_CSR_ENDRX
| US_CSR_FRAME
| US_CSR_OVRE;
/* Start receiving data on the USB */
CDCDSerial_Read(usbSerialBuffer0,
DATABUFFERSIZE,
(TransferCallback) UsbDataReceived,
0);
serialON = 1;
}
else if (serialON && !isSerialPortON) {
printf("-I- SeriaoPort OFF\n\r");
serialON = 0;
}
HIDDKeyboardProcessKeys();
}
}
}
/*----------------------------------------------------------------------------
* Handles interrupts coming from USART
*----------------------------------------------------------------------------*/
void USART_Handler(void)
{
uint32_t status;
unsigned short serialState;
status = BASE_USART->US_CSR;
status &= BASE_USART->US_IMR;
/* If USB device is not configured, do nothing */
if (!isSerialPortON) {
BASE_USART->US_IDR = 0xFFFFFFFF;
return;
}
/* Buffer has been read successfully */
if ((status & US_CSR_ENDRX) != 0) {
/* Disable timer */
TC_Stop(TC0, 0);
/* Send buffer through the USB */
while (CDCDSerial_Write(usartBuffers[usartCurrentBuffer],
DATABUFFERSIZE, 0, 0) != USBD_STATUS_SUCCESS);
/* Restart read on buffer */
USART_ReadBuffer(BASE_USART,
usartBuffers[usartCurrentBuffer],
DATABUFFERSIZE);
usartCurrentBuffer = 1 - usartCurrentBuffer;
/* Restart timer */
TC_Start(TC0, 0);
}
/* Buffer has been sent */
if ((status & US_IER_TXBUFE) != 0) {
/* Restart USB read */
CDCDSerial_Read(usbSerialBuffer0,
DATABUFFERSIZE,
(TransferCallback) UsbDataReceived,
0);
BASE_USART->US_IDR = US_IER_TXBUFE;
}
/* Errors */
serialState = CDCDSerial_GetSerialState();
/* Overrun */
if ((status & US_CSR_OVRE) != 0) {
TRACE_WARNING( "USART1_IrqHandler: Overrun\n\r");
serialState |= CDCSerialState_OVERRUN;
}
/* Framing error */
if ((status & US_CSR_FRAME) != 0) {
TRACE_WARNING( "USART1_IrqHandler: Framing error\n\r");
serialState |= CDCSerialState_FRAMING;
}
CDCDSerial_SetSerialState(serialState);
}
