int UARTGetNum(void)
{
unsigned char rxByte;
int sign = 1;
int value = 0;
rxByte = UARTGetc();
/* Accounting for negative numbers.*/
if('-' == rxByte)
{
UARTPutc('-');
sign = -1;
}
else
{
UARTPutc(rxByte);
value = value*10 + (rxByte - 0x30);
}
do
{
rxByte = UARTGetc();
/* Echoing the typed characters to the serial console.*/
UARTPutc(rxByte);
/*
** Checking if the entered character is a carriage return.
** Pressing the 'Enter' key on the keyboard executes a
** carriage return on the serial console.
*/
if('\r' == rxByte)
{
break;
}
/*
** Subtracting 0x30 to convert the representation of the digit
** from ASCII to hexadecimal.
*/
value = value*10 + (rxByte - 0x30);
}while(1);
/* Accounting for the sign of the number.*/
value = value * sign;
return value;
}
/*
** Main Function.
*/
int main(void)
{
unsigned char choice = 0;
/* Enable the clocks for McSPI0 module.*/
McSPI0ModuleClkConfig();
/* Perform Pin-Muxing for SPI0 Instance.*/
McSPIPinMuxSetup(0);
/* Perform Pin-Muxing for CS0 of SPI0 Instance.*/
McSPI0CSPinMuxSetup(MCSPI_CH_NUM);
/* Initialize the UART utility functions.*/
UARTStdioInit();
/* Enable IRQ in CPSR.*/
IntMasterIRQEnable();
UARTPuts("Here the McSPI controller on the SOC communicates with ",-1);
UARTPuts("the McSPI Flash.\r\n\r\n",-1);
/* Initialize the EDMA3 instance.*/
EDMA3Initialize();
/* Request EDMA3CC for Tx and Rx channels for SPI0. */
RequestEDMA3Channels();
/* Set up the McSPI instance.*/
McSPISetUp();
/* Enable the SPI Flash for writing to it. */
WriteEnable();
UARTPuts("Do you want to erase a sector of the flash before writing to it ?.", -1);
UARTPuts("\r\nInput y(Y)/n(N) to proceed.\r\n", -1);
choice = UARTGetc();
UARTPutc(choice);
if(('y' == choice) || ('Y' == choice))
{
/* Erasing the specified sector of SPI Flash. */
FlashSectorErase();
}
/* Enable the SPI Flash for writing to it. */
WriteEnable();
/* Write data of 1 page size into a page of Flash.*/
FlashPageProgram();
/* Read data of 1 page size from a page of flash.*/
ReadFromFlash();
/* Verify the data written to and read from Flash are same or not.*/
VerifyData();
while(1);
}
/**
* \brief This function builds an integer from teh data received
*
* \return The value received
*
* \note The numbers that this function can recieve should lie in the
* following range:
* [-2^(31)] to [2^(31) - 1] i.e.
* 0x80000000 to 0x7FFFFFFF
*
* This logic is meant only for Little Endian processors only.
*/
void UARTGetInt(int *val)
{
char* pCh = (char*)(val);
int size = 4;
do
{
*pCh = (char)UARTGetc();
pCh++;
} while(--size);
return;
}
int main(void)
{
unsigned int triggerValue = 0;
/* Setup the MMU and do necessary MMU configurations. */
MMUConfigAndEnable();
/* Enable all levels of CACHE. */
CacheEnable(CACHE_ALL);
/* Set up the UART2 peripheral */
UARTStdioInit();
/* Enable the WDT clocks */
WatchdogTimer1ModuleClkConfig();
/* Reset the Watchdog Timer */
WatchdogTimerReset(SOC_WDT_1_REGS);
/* Disable the Watchdog timer */
WatchdogTimerDisable(SOC_WDT_1_REGS);
/* Perform the initial settings for the Watchdog Timer */
WatchdogTimerSetUp();
/* Send the message to UART console */
UARTPuts("Program Reset!", -1);
UARTPuts("Input any key at least once in every 4 seconds to avoid a further reset.\n\r", -1);
/* Enable the Watchdog Timer */
WatchdogTimerEnable(SOC_WDT_1_REGS);
while(1)
{
/* Wait for an input through UART. If no input is given,
** the WDT will timeout and reset will occur.
*/
if(UARTGetc())
{
triggerValue += 1;
/* Write into the trigger register. This will load the value from the
** load register into the counter register and hence timer will start
** from the initial count.
*/
WatchdogTimerTriggerSet(SOC_WDT_1_REGS, triggerValue);
}
}
}
unsigned int UARTGets(char *pRxBuffer, int numBytesToRead)
{
unsigned int count = 0;
unsigned int flag = 0;
if(numBytesToRead < 0)
{
flag = 1;
}
do
{
*pRxBuffer = UARTGetc();
/*
** 0xD - ASCII value of Carriage Return.
** 0x1B - ASCII value of ESC character.
*/
if(0xD == *pRxBuffer || 0x1B == *pRxBuffer)
{
*pRxBuffer = '\0';
break;
}
/* Echoing the typed character back to the serial console. */
UARTPutc((unsigned char)*pRxBuffer);
pRxBuffer++;
count++;
if(0 == flag && (count == numBytesToRead))
{
break;
}
}while(1);
return count;
}
unsigned int UARTGetHexNum(void)
{
unsigned char rxByte;
unsigned int value = 0;
unsigned int loopIndex;
unsigned int byteCount = 0;
for(loopIndex = 0; loopIndex < 2; loopIndex++)
{
/* Receiving bytes from the host machine through serial console. */
rxByte = UARTGetc();
/*
** Checking if the entered character is a carriage return.
** Pressing the 'Enter' key on the keyboard executes a
** carriage return on the serial console.
*/
if('\r' == rxByte)
{
break;
}
/*
** Checking if the character entered is one among the alphanumeric
** character set A,B,C...F
*/
if(('A' <= rxByte) && (rxByte <= 'F'))
{
/* Echoing the typed characters to the serial console.*/
UARTPutc(rxByte);
value = value*16 + (rxByte - 0x37);
byteCount++;
}
/*
** Checking if the character entered is one among the alphanumeric
** character set a,b,c...f
*/
else if(('a' <= rxByte) && (rxByte <= 'f'))
{
UARTPutc(rxByte);
value = value*16 + (rxByte - 0x57);
byteCount++;
}
/*
** Checking if the character entered is one among the decimal
** number set 0,1,2,3,....9
*/
else if(('0' <= rxByte) && (rxByte <= '9'))
{
UARTPutc(rxByte);
value = value*16 + (rxByte - 0x30);
byteCount++;
}
/*
** Checking if the character is either a 'x'(lower-case) or an 'X'
** (upper-case).
*/
else if(('x' == rxByte) || ('X' == rxByte))
{
UARTPutc(rxByte);
value = 0;
break;
}
}
if(0 == value)
{
byteCount = 0;
}
do
{
rxByte = UARTGetc();
if('\r' == rxByte)
{
break;
}
/*
** Checking if the character entered is one among the alphanumeric
** character set A,B,C...F
*/
if(('A' <= rxByte) && (rxByte <= 'F'))
{
UARTPutc(rxByte);
value = value*16 + (rxByte - 0x37);
byteCount++;
}
/*
** Checking if the character entered is one among the alphanumeric
** character set a,b,c...f
*/
else if(('a' <= rxByte) && (rxByte <= 'f'))
{
UARTPutc(rxByte);
value = value*16 + (rxByte - 0x57);
byteCount++;
}
/*
** Checking if the character entered is one among the decimal
** number set 0,1,2,3,....9
*/
else if(('0' <= rxByte) && (rxByte <= '9'))
{
UARTPutc(rxByte);
value = value*16 + (rxByte - 0x30);
byteCount++;
}
/*
** Not receiving any other character other than the one belonging
** to the above three categories.
*/
else
{
/* Intentionally left empty. */
}
}while(byteCount < 8);
return value;
}
/*
** Main function.
*/
int main(void)
{
volatile char originalData[260] = {0};
volatile char readFlash[260] = {0};
unsigned int retVal = 0;
unsigned char choice;
/* Initializes the UART Instance for serial communication. */
UARTStdioInit();
UARTPuts("Welcome to SPI EDMA application.\r\n", -1);
UARTPuts("Here the SPI controller on the SoC communicates with", -1);
UARTPuts(" the SPI Flash present on the SoM.\r\n\r\n", -1);
/* Initializes the EDMA3 Instance. */
EDMA3Initialize();
/* Initializes the SPI1 Instance. */
SPIInitialize();
/* Request EDMA3CC for Tx and Rx channels for SPI1. */
RequestEDMA3Channels();
/* Enable SPI communication. */
SPIEnable(SOC_SPI_1_REGS);
/* Enable the SPI Flash for writing to it. */
WriteEnable();
UARTPuts("Do you want to erase a sector of the flash before writing to it ?.", -1);
UARTPuts("\r\nInput y(Y)/n(N) to proceed.\r\n", -1);
choice = UARTGetc();
UARTPutc(choice);
if(('y' == choice) || ('Y' == choice))
{
/* Erasing the specified sector of SPI Flash. */
FlashSectorErase();
}
WriteEnable();
/* Program a specified Page of the SPI Flash. */
FlashPageProgram(originalData);
/* Read the contents of the page that was previously written to. */
ReadFromFlash(readFlash);
/* Verify whether the written and the read contents are equal. */
retVal = verifyData(&originalData[4], &readFlash[4], 256);
if(TRUE == retVal)
{
UARTPuts("\r\nThe data in the Flash and the one written ", -1);
UARTPuts("to it are equal.\r\n", -1);
}
else
{
UARTPuts("\r\n\r\nThe data in the Flash and the one written to it", -1);
UARTPuts(" are not equal.\r\n", -1);
}
while(1);
}
/******************************************************************************
** INTERNAL FUNCTION DEFINITIONS
******************************************************************************/
int main(void)
{
volatile unsigned int count = 0x0FFFu;
unsigned int retVal = FALSE;
unsigned char choice = 0;
/* Enable the clocks for McSPI0 module.*/
McSPI0ModuleClkConfig();
/* Perform Pin-Muxing for SPI0 Instance */
McSPIPinMuxSetup(0);
/* Perform Pin-Muxing for CS0 of SPI0 Instance */
McSPI0CSPinMuxSetup(chNum);
/* Initialize the UART utility functions */
UARTStdioInit();
UARTPuts("Here the McSPI controller on the SoC communicates with", -1);
UARTPuts(" the SPI Flash.\r\n\r\n", -1);
/* Enable IRQ in CPSR.*/
IntMasterIRQEnable();
/* Map McSPI Interrupts to AINTC */
McSPI0AintcConfigure();
/* Do the necessary set up configurations for McSPI.*/
McSPISetUp();
/* Pass the write enable command to flash.*/
WriteEnable();
/* Wait until write enable command is successfully written to flash.*/
while(FALSE == retVal)
{
retVal = IsWriteSuccess();
}
retVal = FALSE;
UARTPuts("Do you want to erase a sector of the flash before ", -1);
UARTPuts("writing to it ?.", -1);
UARTPuts("\r\nInput y(Y)/n(N) to proceed.\r\n", -1);
choice = UARTGetc();
UARTPutc(choice);
if(('Y' == choice) || ('y' == choice))
{
/* Erase a sector of flash.*/
SectorErase();
}
/* Pass the write enable command to flash.*/
WriteEnable();
/* Wait until write enable command is successfully written to flash.*/
while(FALSE == retVal)
{
retVal = IsWriteSuccess();
}
/* Write data of 1 page size to flash.*/
WriteToFlash();
while(count--);
count = 0x0FFFu;
/* Read data of 1 page size from flash.*/
ReadFromFlash();
while(count--);
/* Verify the data written to and read from flash are same or not.*/
VerifyData();
while(1);
}
/*
** Main function. The application starts here.
*/
int main(void)
{
unsigned char rxByte;
unsigned int value = (unsigned int)E_FAIL;
#ifdef __TMS470__
/* Relocate the required section to internal RAM */
memcpy((void *)(&relocstart), (const void *)(&iram_start),
(unsigned int)(&iram_size));
#elif defined(__IAR_SYSTEMS_ICC__)
#pragma section = "CodeRelocOverlay"
#pragma section = "DataRelocOverlay"
#pragma section = "DataOverlayBlk"
#pragma section = "CodeOverlayBlk"
char* srcAddr = (__section_begin("CodeRelocOverlay"));
char* endAddr = (__section_end("DataRelocOverlay"));
memcpy((void *)(__section_begin("CodeRelocOverlay")),
(const void *)(__section_begin("CodeOverlayBlk")),
endAddr - srcAddr);
#else
memcpy((void *)&(relocstart), (const void *)&(iram_start),
(unsigned int)(((&(relocend)) -
(&(relocstart))) * (sizeof(unsigned int))));
#endif
MMUConfigAndEnable();
/* Enable Instruction Cache */
CacheEnable(CACHE_ALL);
PeripheralsSetUp();
/* Initialize the ARM Interrupt Controller */
IntAINTCInit();
/* Register the ISRs */
Timer2IntRegister();
Timer4IntRegister();
EnetIntRegister();
RtcIntRegister();
CM3IntRegister();
HSMMCSDIntRegister();
IntRegister(127, dummyIsr);
IntMasterIRQEnable();
pageIndex = 0;
prevAction = 0;
/* Enable system interrupts */
IntSystemEnable(SYS_INT_RTCINT);
IntPrioritySet(SYS_INT_RTCINT, 0, AINTC_HOSTINT_ROUTE_IRQ);
IntSystemEnable(SYS_INT_3PGSWTXINT0);
IntPrioritySet(SYS_INT_3PGSWTXINT0, 0, AINTC_HOSTINT_ROUTE_IRQ);
IntSystemEnable(SYS_INT_3PGSWRXINT0);
IntPrioritySet(SYS_INT_3PGSWRXINT0, 0, AINTC_HOSTINT_ROUTE_IRQ);
IntSystemEnable(SYS_INT_TINT2);
IntPrioritySet(SYS_INT_TINT2, 0, AINTC_HOSTINT_ROUTE_IRQ);
IntSystemEnable(SYS_INT_TINT4);
IntPrioritySet(SYS_INT_TINT4, 0, AINTC_HOSTINT_ROUTE_IRQ);
IntSystemEnable(SYS_INT_MMCSD0INT);
IntPrioritySet(SYS_INT_MMCSD0INT, 0, AINTC_HOSTINT_ROUTE_IRQ);
IntSystemEnable(SYS_INT_EDMACOMPINT);
IntPrioritySet(SYS_INT_EDMACOMPINT, 0, AINTC_HOSTINT_ROUTE_IRQ);
IntPrioritySet(SYS_INT_M3_TXEV, 0, AINTC_HOSTINT_ROUTE_IRQ );
IntSystemEnable(SYS_INT_M3_TXEV);
IntSystemEnable(127);
IntPrioritySet(127, 0, AINTC_HOSTINT_ROUTE_IRQ);
IntSystemEnable(SYS_INT_UART0INT);
IntPrioritySet(SYS_INT_UART0INT, 0, AINTC_HOSTINT_ROUTE_IRQ);
IntRegister(SYS_INT_UART0INT, uartIsr);
/* GPIO interrupts */
IntSystemEnable(SYS_INT_GPIOINT0A);
IntPrioritySet(SYS_INT_GPIOINT0A, 0, AINTC_HOSTINT_ROUTE_IRQ);
IntRegister(SYS_INT_GPIOINT0A, gpioIsr);
IntSystemEnable(SYS_INT_GPIOINT0B);
IntPrioritySet(SYS_INT_GPIOINT0B, 0, AINTC_HOSTINT_ROUTE_IRQ);
IntRegister(SYS_INT_GPIOINT0B, gpioIsr);
BoardInfoInit();
deviceVersion = DeviceVersionGet();
CM3EventsClear();
CM3LoadAndRun();
waitForM3Txevent();
/* Initialize console for communication with the Host Machine */
ConsoleUtilsInit();
/*
** Select the console type based on compile time check
** Note: This example is not fully complaint to semihosting. It is
** recommended to use Uart console interface only.
*/
ConsoleUtilsSetType(CONSOLE_UART);
/* Print Board and SoC information on console */
ConsoleUtilsPrintf("\n\r Board Name : %s", BoardNameGet());
ConsoleUtilsPrintf("\n\r Board Version : %s", BoardVersionGet());
ConsoleUtilsPrintf("\n\r SoC Version : %d", deviceVersion);
/* On CM3 init firmware version is loaded onto the IPC Message Reg */
ConsoleUtilsPrintf("\n CM3 Firmware Version: %d", readCM3FWVersion());
I2CIntRegister(I2C_0);
IntPrioritySet(SYS_INT_I2C0INT, 0, AINTC_HOSTINT_ROUTE_IRQ);
IntSystemEnable(SYS_INT_I2C0INT);
I2CInit(I2C_0);
IntSystemEnable(SYS_INT_TINT1_1MS);
IntPrioritySet(SYS_INT_TINT1_1MS, 0, AINTC_HOSTINT_ROUTE_IRQ);
IntRegister(SYS_INT_TINT1_1MS,clearTimerInt);
configVddOpVoltage();
RtcInit();
HSMMCSDContolInit();
DelayTimerSetup();
initializeTimer1();
ConsoleUtilsPrintf("\r\n After intializing timer");
Timer2Config();
Timer4Config();
LedIfConfig();
MailBoxInit();
Timer2IntEnable();
Timer4IntEnable();
RtcSecIntEnable();
Timer4Start();
while(FALSE == tmr4Flag);
tmr4Flag = FALSE;
Timer4Stop();
ConsoleUtilsPrintf("\n\r Configuring for maximum OPP");
mpuOpp = ConfigMaximumOPP();
mpuFreq = FrequencyGet(mpuOpp);
mpuVdd1 = VddVoltageGet(mpuOpp);
PrintConfigDVFS();
/* Create menu page */
pageIndex = MENU_IDX_MAIN;
ActionEnetInit();
/*
** Loop for ever. Necessary actions shall be taken
** after detecting the click.
*/
while(1)
{
/*
** Check for any any activity on Uart Console and process it.
*/
if (true == UARTCharsAvail(SOC_UART_0_REGS))
{
/* Receiving bytes from the host machine through serial console. */
rxByte = UARTGetc();
/*
** Checking if the entered character is a carriage return.
** Pressing the 'Enter' key on the keyboard executes a
** carriage return on the serial console.
*/
if('\r' == rxByte)
{
ConsoleUtilsPrintf("\n");
UartAction(value);
value = (unsigned int)E_FAIL;
rxByte = 0;
}
/*
** Checking if the character entered is one among the decimal
** number set 0,1,2,3,....9
*/
if(('0' <= rxByte) && (rxByte <= '9'))
{
ConsoleUtilsPrintf("%c", rxByte);
if((unsigned int)E_FAIL == value)
{
value = 0;
}
value = value*10 + (rxByte - 0x30);
}
}
/*
** Check if click is detected
*/
if(clickIdx != 0)
{
/*
** Take the Action for click
*/
ClickAction();
clickIdx = 0;
}
/*
** Check if the Timer Expired
*/
if(TRUE == tmrFlag)
{
/* Toggle the LED state */
LedToggle();
tmrFlag = FALSE;
}
/*
** Check if RTC Time is set
*/
if(TRUE == rtcSetFlag)
{
if(TRUE == rtcSecUpdate)
{
rtcSecUpdate = FALSE;
RtcTimeCalDisplay();
ConsoleUtilsPrintf(" --- Selected: ");
}
}
if(TRUE == tmr4Flag)
{
tmr4Flag = FALSE;
/* Make sure that interrupts are disabled and no lwIP functions
are executed while calling an lwIP exported API */
IntMasterIRQDisable();
etharp_tmr();
IntMasterIRQEnable();
}
}
}
