void Uart0::isr() {
uint32_t Status;
char data;
Uart0 *object;
// Process UARTA0
if (g_uart0_object != NULL) {
Status = MAP_UARTIntStatus(UARTA0_BASE, true);
MAP_UARTIntClear(UARTA0_BASE, Status);
object = g_uart0_object;
if (Status & UART_INT_RX) {
data = MAP_UARTCharGet(UARTA0_BASE);
if (object->echo)
MAP_UARTCharPut(UARTA0_BASE, data);
object->in_buffer()->push_front_isr(data);
}
if (!object->out_buffer()->is_empty()) {
data = object->out_buffer()->pop_isr();
MAP_UARTCharPut(UARTA0_BASE, data);
}
}
}
//****************************************************************************
//
//! Get Ssid name form the user over UART
//!
//! \param pcSsidName is a pointer to the array which will contain the ssid name
//!
//! This function
//! 1. gets the ssid name string over uart
//!
//! \return iStringLength is the length of the ssid(user input).
//
//****************************************************************************
int GetSsidName(char *pcSsidName, unsigned int uiMaxLen)
{
char cCharacter;
int iStringLength = 0;
while(1)
{
//
// Fetching the input from the terminal.
//
cCharacter = MAP_UARTCharGet(CONSOLE);
if(cCharacter == '\r' || cCharacter == '\n' ||
(iStringLength >= uiMaxLen-1))
{
if(iStringLength >= uiMaxLen-1)
{
MAP_UARTCharPut(CONSOLE, cCharacter);
pcSsidName[iStringLength] = cCharacter;
iStringLength++;
}
MAP_UARTCharPut(CONSOLE, '\n');
MAP_UARTCharPut(CONSOLE, '\r');
pcSsidName[iStringLength] = '\0';
break;
}
else
{
MAP_UARTCharPut(CONSOLE, cCharacter);
pcSsidName[iStringLength] = cCharacter;
iStringLength++;
}
}
return(iStringLength);
}
//*****************************************************************************
//
//! GETChar
//!
//! \param ucBuffer to which Command will be populated
//!
//! \return Success or Failure
//!
//! \brief Get the char string from UART
//
//*****************************************************************************
unsigned int GETChar(unsigned char *ucBuffer)
{
int i = 0;
char c;
uiUartline = 0;
//
// Wait to receive a character over UART
//
while (MAP_UARTCharsAvail(CONSOLE) == false)
{
osi_Sleep(1);
}
c = MAP_UARTCharGetNonBlocking(CONSOLE);
MAP_UARTCharPut(CONSOLE, c);
ilength = 0;
//
// Checking the end of line
//
while (c != '\r' && c != '\n')
{
uiUartline = 1;
//
// Copying Data from UART into a buffer
//
if (c != '\b')
{
ilength++;
*(ucBuffer + i) = c;
i++;
}
//
// Deleting last character when you hit backspace
//
if (c == '\b')
{
i--;
ilength--;
}
while (MAP_UARTCharsAvail(CONSOLE) == false)
{
osi_Sleep(1);
}
c = MAP_UARTCharGetNonBlocking(CONSOLE);
MAP_UARTCharPut(CONSOLE, c);
}
strncpy((char*)g_ucUARTBuffer, (char *)ucBuffer, ilength);
memset(g_ucUARTRecvBuffer, 0, sizeof(g_ucUARTRecvBuffer));
return uiUartline;
}
ssize_t _write(int fd, const void *buf, size_t count) {
if (fd != 1 && fd != 2) {
_not_implemented("_write to files");
}
for (size_t i = 0; i < count; i++) {
const char c = ((const char *) buf)[i];
if (c == '\n') MAP_UARTCharPut(CONSOLE_UART, '\r');
MAP_UARTCharPut(CONSOLE_UART, c);
}
return count;
}
int _write(int file, char *ptr, unsigned int len)
{
unsigned int i;
for(i = 0; i < len; i++){
if( ptr[i] == '\n' && ( i > 0 && ptr[i-1] != '\r' ) )
{
MAP_UARTCharPut(UART0_BASE, '\r');
}
MAP_UARTCharPut(UART0_BASE, ptr[i]);
}
return i;
}
//****************************************************************************
//
//! Confgiures the mode in which the device will work
//!
//! \param iMode is the current mode of the device
//!
//! This function
//! 1. prompt user for desired configuration and accordingly configure the
//! networking mode(STA or AP).
//! 2. also give the user the option to configure the ssid name in case of
//! AP mode.
//!
//! \return 0: success, -ve: failure.
//
//****************************************************************************
long ConfigureMode(int iMode)
{
char cCharacter = 'a';
char pcSsidName[33];
unsigned short len;
long lRetVal = -1;
while(cCharacter != '1' && cCharacter != '2' && cCharacter != '3')
{
UART_PRINT("Do you Want to Switch Mode\n\r1. STA mode\n\r2. AP Mode\n\r"
"3. P2P Mode :");
cCharacter = MAP_UARTCharGet(CONSOLE);
MAP_UARTCharPut(CONSOLE,cCharacter);
MAP_UARTCharPut(CONSOLE,'\n');
MAP_UARTCharPut(CONSOLE,'\r');
}
if(cCharacter == '1')
{
lRetVal = sl_WlanSetMode(ROLE_STA);
ASSERT_ON_ERROR(lRetVal);
UART_PRINT("mode configured\n\r");
}
else if(cCharacter == '2')
{
UART_PRINT("Enter the SSID name: ");
GetSsidName(pcSsidName,33);
_SlNonOsMainLoopTask();
lRetVal = sl_WlanSetMode(ROLE_AP);
ASSERT_ON_ERROR(lRetVal);
len = strlen(pcSsidName);
lRetVal = sl_WlanSet(SL_WLAN_CFG_AP_ID, WLAN_AP_OPT_SSID, len,
(unsigned char*) pcSsidName);
ASSERT_ON_ERROR(lRetVal);
UART_PRINT("mode configured\n\r");
}
else if(cCharacter == '3')
{
lRetVal = sl_WlanSetMode(ROLE_P2P);
ASSERT_ON_ERROR(lRetVal);
UART_PRINT("mode configured\n\r");
}
else
{
UART_PRINT("Wrong input\n\r");
}
return 0;
}
static void cc32xx_int_handler(struct mgos_uart_state *us) {
if (us == NULL) return;
struct cc32xx_uart_state *ds = (struct cc32xx_uart_state *) us->dev_data;
uint32_t int_st = MAP_UARTIntStatus(ds->base, true /* masked */);
us->stats.ints++;
uint32_t int_dis = UART_TX_INTS;
if (int_st & UART_INT_OE) {
us->stats.rx_overflows++;
HWREG(ds->base + UART_O_ECR) = 0xff;
}
if (int_st & (UART_RX_INTS | UART_TX_INTS)) {
if (int_st & UART_RX_INTS) {
us->stats.rx_ints++;
struct cs_rbuf *irxb = &ds->isr_rx_buf;
cc32xx_uart_rx_bytes(ds->base, irxb);
if (us->cfg.rx_fc_type == MGOS_UART_FC_SW &&
irxb->used >= CC32xx_UART_ISR_RX_BUF_FC_THRESH && !us->xoff_sent) {
MAP_UARTCharPut(ds->base, MGOS_UART_XOFF_CHAR);
us->xoff_sent = true;
}
/* Do not disable RX ints if we have space in the ISR buffer. */
if (irxb->avail == 0) int_dis |= UART_RX_INTS;
}
if (int_st & UART_TX_INTS) us->stats.tx_ints++;
mgos_uart_schedule_dispatcher(us->uart_no, true /* from_isr */);
}
MAP_UARTIntDisable(ds->base, int_dis);
MAP_UARTIntClear(ds->base, int_st);
}
void dbg_putc(char c) {
#ifndef NO_DEBUG
MAP_UARTCharPut(DEBUG_UART_BASE, c);
#else
(void) c;
#endif
}
void cc3200_console_putc(int fd, char c) {
MAP_UARTCharPut(CONSOLE_UART, c);
#ifdef SJ_ENABLE_CLUBBY
if (fd == 1 && get_cfg()->console.send_to_cloud) cc3200_console_cloud_putc(c);
#endif
(void) fd;
}
int _write(int file, char *ptr, unsigned int len)
{
unsigned int i;
for(i = 0; i < len; i++){
MAP_UARTCharPut(UART0_BASE, ptr[i]);
}
return i;
}
void platform_s_uart_send( unsigned id, u8 data )
{
#ifdef BUILD_USB_CDC
if( id == CDC_UART_ID )
USBBufferWrite( &g_sTxBuffer, &data, 1 );
else
#endif
MAP_UARTCharPut( uart_base[ id ], data );
}
static void logger_writer(struct LOGGER_APPENDER *appender, int level, const char *buf, int len)
{
const char *p = buf;
if (p != NULL)
{
while(*p != '\0')
{
MAP_UARTCharPut(CONSOLE, *p++);
}
}
}
//*****************************************************************************
//
//! Outputs a character string to the console
//!
//! \param str is the pointer to the string to be printed
//!
//! This function
//! 1. prints the input string character by character on to the console.
//!
//! \return none
//
//*****************************************************************************
void
Message(const char *str)
{
#ifndef NOTERM
if(str != NULL)
{
while(*str!='\0')
{
MAP_UARTCharPut(CONSOLE,*str++);
}
}
#endif
}
//*****************************************************************************
//
// Send a string to the UART. This function sends a string of characters to a
// particular UART module.
//
//*****************************************************************************
void
UARTSend(uint32_t ui32UARTBase, const uint8_t *pui8Buffer, uint32_t ui32Count)
{
//
// Loop while there are more characters to send.
//
while(ui32Count--)
{
//
// Write the next character to the UART.
//
MAP_UARTCharPut(ui32UARTBase, *pui8Buffer++);
}
}
//*****************************************************************************
//
//! GetKey - Gets the Key from User
//!
//! \param uiKeySize - Key Size Used
//! \param pucKeyBuff - Key Buffer into which Key will be populated
//!
//! \return Success or Failure
//!
//*****************************************************************************
bool
GetKey(unsigned int uiKeySize,char *pucKeyBuff)
{
char cChar;
unsigned int uiMsgLen;
UART_PRINT("\n\r Do you want to use Pre-Defined Key ???(y/n) \n\r");
//
// Get the option
//
cChar = MAP_UARTCharGet(UARTA0_BASE);
//
// Echo the received character
//
MAP_UARTCharPut(UARTA0_BASE, cChar);
UART_PRINT("\n\r");
if(cChar=='y' || cChar=='Y' )
{
//
// Fetch the key
//
if(uiKeySize==8)
{
UART_PRINT("\n\r Press 1 for Key - %s\n\r Press 2 for Key - %s "
"\n\r Press 3 for Key - %s\n\r",DESKey1,DESKey2,DESKey3);
cChar = MAP_UARTCharGet(UARTA0_BASE);
//
// Echo the received character
//
MAP_UARTCharPut(UARTA0_BASE, cChar);
UART_PRINT("\n\r");
if(cChar=='1' )
memcpy(&uiDESKey,DESKey1,8);
else if(cChar=='2')
memcpy(&uiDESKey,DESKey2,8);
else if(cChar=='3')
memcpy(&uiDESKey,DESKey3,8);
else
{
UART_PRINT("\n\r Invalid Input \n\r");
return false;
}
}
else if(uiKeySize==24)
{
UART_PRINT("\n\r Press 1 for Key - %s\n\r Press 2 for Key - %s "
"\n\r Press 3 for Key - %s\n\r",TDESKey1,TDESKey2,TDESKey3);
cChar = MAP_UARTCharGet(UARTA0_BASE);
//
// Echo the received character
//
MAP_UARTCharPut(UARTA0_BASE, cChar);
UART_PRINT("\n\r");
if(cChar=='1' )
memcpy(&uiTDESKey,TDESKey1,24);
else if(cChar=='2')
memcpy(&uiTDESKey,TDESKey2,24);
else if(cChar=='3')
memcpy(&uiTDESKey,TDESKey3,24);
else
{
UART_PRINT("\n\r Invalid Input \n\r");
return false;
}
}
}
else if(cChar=='n' || cChar=='N')
{
//
// Ask for the Key
//
UART_PRINT("\n\rEnter the Key \n\r");
uiMsgLen=GetCmd(pucKeyBuff,BUFFER_LEN);
if(uiMsgLen!=uiKeySize)
{
UART_PRINT("\n\r Enter Valid Key of length %d\n\r",uiKeySize);
return false;
}
}
else
{
UART_PRINT("\n\r Invalid Input \n\r");
return false;
}
return true;
}
//*****************************************************************************
//
//! CRCParser
//!
//! \param ucCMDBuffer - Buffer which contains command from UART
//! \param uiConfig - Sets Configuration Value
//!
//! \return none
//!
//*****************************************************************************
bool
CRCParser( char *ucCMDBuffer,unsigned int *uiConfig)
{
char *ucInpString,cChar;
ucInpString = strtok(ucCMDBuffer, " ");
//
// Check Whether Command is valid
//
if((ucInpString != NULL) && ((!strcmp(ucInpString,"crc"))))
{
//
// Get which Algorithm you are using
//
ucInpString = strtok(NULL, " ");
//
// Get Key Length
//
if(ucInpString != NULL && ((!strcmp(ucInpString,"P8005")) || \
(!strcmp(ucInpString,"p8005"))))
*uiConfig=CRC_CFG_TYPE_P8005;
else if (ucInpString != NULL && (!strcmp(ucInpString,"P1021") || \
(!strcmp(ucInpString,"p1021"))))
*uiConfig=CRC_CFG_TYPE_P1021;
else if (ucInpString != NULL && (!strcmp(ucInpString,"P4C11DB7") || \
!strcmp(ucInpString,"p4c11db7")))
*uiConfig=CRC_CFG_TYPE_P4C11DB7;
else if (ucInpString != NULL && (!strcmp(ucInpString,"P1EDC6F41") || \
!strcmp(ucInpString,"p1edc6f41") ))
*uiConfig=CRC_CFG_TYPE_P1EDC6F41;
else if (ucInpString != NULL && (!strcmp(ucInpString,"TCPCHKSUM") || \
!strcmp(ucInpString,"tcpchksum")))
*uiConfig=CRC_CFG_TYPE_TCPCHKSUM;
else
{
UART_PRINT("\n\r Invalid CRC type \n\r");
return false;
}
UART_PRINT("\n\rPress 1 to Initialize Seed\n\rPress 2 to Initialize to"
"all 0's\n\rPress 3 to Initialize to all 1's \n\r");
//
// Get the option
//
cChar = MAP_UARTCharGet(UARTA0_BASE);
//
// Echo the received character
//
MAP_UARTCharPut(UARTA0_BASE, cChar);
UART_PRINT("\n\r");
if(cChar=='1' )
{
*uiConfig|=CRC_CFG_INIT_SEED;
}
else if(cChar=='2')
{
*uiConfig|=CRC_CFG_INIT_0;
}
else if(cChar=='3')
{
*uiConfig|=CRC_CFG_INIT_1;
}
else
{
UART_PRINT("\n\r Invalid Input \n\r");
return false;
}
UART_PRINT("\n\rPress 1 for byte write\n\rPress 2 for word write \n\r");
//
// Get the option
//
cChar = MAP_UARTCharGet(UARTA0_BASE);
//
// Echo the received character
//
MAP_UARTCharPut(UARTA0_BASE, cChar);
UART_PRINT("\n\r");
if(cChar=='1' )
{
*uiConfig|=CRC_CFG_SIZE_8BIT;
}
else if(cChar=='2')
{
*uiConfig|=CRC_CFG_SIZE_32BIT;
}
else
{
UART_PRINT("\n\r Invalid Input \n\r");
return false;
}
#if 0
UART_PRINT("\n\rPress 1 for Result Inverse\n\rPress 2 for Output "
"Inverse \n\r");
//
// Get the option
//
cChar = MAP_UARTCharGet(UARTA0_BASE);
//
// Echo the received character
//
MAP_UARTCharPut(UARTA0_BASE, cChar);
UART_PRINT("\n\r");
if(cChar=='1' )
{
*uiConfig|=CRC_CFG_RESINV;
}
else if(cChar=='2')
{
*uiConfig|=CRC_CFG_OBR;
}
else
{
UART_PRINT("\n\r Invalid Input \n\r");
return false;
}
#endif
}
else
{
return false;
}
return true;
}
void uart_write_char(char c){
MAP_UARTCharPut(UART0_BASE, c);
}
//*****************************************************************************
//
//! Get Key Function
//!
//! This function
//! 1. Gets the Key from the User
//! \param uiKeySize - Key Size used
//! \out pucKeyBuff - KeyBuffer in which Key is stored
//!
//! \return Success or Failure
//
//*****************************************************************************
bool
GetKey(unsigned int uiKeySize, char *pucKeyBuff)
{
char cChar;
unsigned int uiMsgLen;
UART_PRINT("\n\r Do you want to use Pre-Defined Key ???(y/n) \n\r");
//
// Get the option
//
cChar = MAP_UARTCharGet(UARTA0_BASE);
//
// Echo the received character
//
MAP_UARTCharPut(UARTA0_BASE, cChar);
UART_PRINT("\n\r");
if(cChar=='y' || cChar=='Y' )
{
//
// Fetch the key
//
if(uiKeySize==AES_CFG_KEY_SIZE_128BIT)
{
UART_PRINT("\n\r Press 1 for Key - %s\n\r Press 2 for Key - %s \n\r "
"Press 3 for Key - %s\n\r",AES128Key1,AES128Key2,AES128Key3);
cChar = MAP_UARTCharGet(UARTA0_BASE);
//
// Echo the received character
//
MAP_UARTCharPut(UARTA0_BASE, cChar);
UART_PRINT("\n\r");
if(cChar=='1' )
memcpy(&uiKey128,AES128Key1,16);
else if(cChar=='2')
memcpy(&uiKey128,AES128Key2,16);
else if(cChar=='3')
memcpy(&uiKey128,AES128Key3,16);
else
{
UART_PRINT("\n\r Invalid Input \n\r");
return false;
}
}
else if(uiKeySize==AES_CFG_KEY_SIZE_192BIT)
{
UART_PRINT("\n\r Press 1 for Key - %s\n\r Press 2 for Key - %s \n\r "
"Press 3 for Key - %s\n\r",AES192Key1,AES192Key2,AES192Key3);
cChar = MAP_UARTCharGet(UARTA0_BASE);
//
// Echo the received character
//
MAP_UARTCharPut(UARTA0_BASE, cChar);
UART_PRINT("\n\r");
if(cChar=='1' )
memcpy(&uiKey192,AES192Key1,24);
else if(cChar=='2')
memcpy(&uiKey192,AES192Key2,24);
else if(cChar=='3')
memcpy(&uiKey192,AES192Key3,24);
else
{
UART_PRINT("\n\r Invalid Input \n\r");
return false;
}
}
else if(uiKeySize==AES_CFG_KEY_SIZE_256BIT)
{
UART_PRINT("\n\r Press 1 for Key - %s\n\r Press 2 for Key - %s \n\r"
" Press 3 for Key - %s\n\r",AES256Key1,AES256Key2,AES256Key3);
cChar = MAP_UARTCharGet(UARTA0_BASE);
//
// Echo the received character
//
MAP_UARTCharPut(UARTA0_BASE, cChar);
UART_PRINT("\n\r");
if(cChar=='1' )
memcpy(&uiKey256,AES256Key1,32);
else if(cChar=='2')
memcpy(&uiKey256,AES256Key2,32);
else if(cChar=='3')
memcpy(&uiKey256,AES256Key3,32);
else
{
UART_PRINT("\n\r Invalid Input \n\r");
return false;
}
}
}
else if(cChar=='n' || cChar=='N')
{
//
// Ask for the Key
//
UART_PRINT("\n\rEnter the Key \n\r");
uiMsgLen=GetCmd(pucKeyBuff,520);
if(uiMsgLen!=uiKeySize)
{
UART_PRINT("\n\r Enter Valid Key of length %d\n\r",uiKeySize);
return false;
}
}
else
{
UART_PRINT("\n\r Invalid Input \n\r");
return false;
}
return true;
}
int main()
{
UserIn User;
int iFlag = 1;
long lRetVal = -1;
char cChar;
unsigned char policyVal;
//
// Initialize Board configuration
//
BoardInit();
//
//
//Pin muxing
//
PinMuxConfig();
// Configuring UART
//
InitTerm();
DisplayBanner(APPLICATION_NAME);
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
UART_PRINT("Failed to configure the device in its default state \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device is configured in default state \n\r");
CLR_STATUS_BIT_ALL(g_ulStatus);
//
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(0, 0, 0);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device started as STATION \n\r");
//
// reset all network policies
//
lRetVal = sl_WlanPolicySet( SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(0,0,0,0,0),
&policyVal,
1 /*PolicyValLen*/);
if (lRetVal < 0)
{
UART_PRINT("Failed to set policy \n\r");
LOOP_FOREVER();
}
while (iFlag)
{
User = UserInput();
switch(User.choice)
{
case(1):
/*******An example of Tx continuous on user selected channel, rate 11,
* user selected number of packets, minimal delay between packets*******/
lRetVal = Tx_continuous(User.channel,User.rate,User.packets, \
User.Txpower,0);
if(lRetVal < 0)
{
UART_PRINT("Error during transmission of raw data\n\r");
LOOP_FOREVER();
}
break;
case(2):
/******An example of Rx statistics using user selected channel *******/
lRetVal = RxStatisticsCollect();
if(lRetVal < 0)
{
UART_PRINT("Error while collecting statistics data\n\r");
LOOP_FOREVER();
}
break;
}
UART_PRINT("\n\rEnter \"1\" to restart or \"0\" to quit: ");
//
// Wait to receive a character over UART
//
cChar = MAP_UARTCharGet(CONSOLE);
//
// Echo the received character
//
MAP_UARTCharPut(CONSOLE, cChar);
UART_PRINT("\n\r");
iFlag = atoi(&cChar);
}
UART_PRINT("\r\nEnding the application....");
//
// power off network processor
//
lRetVal = sl_Stop(SL_STOP_TIMEOUT);
LOOP_FOREVER();
}
void platform_s_uart_send( unsigned id, u8 data )
{
MAP_UARTCharPut( uart_base[ id ], data );
}
void uart_write_str(char *str) {
while (*str)
{
MAP_UARTCharPut(UART0_BASE, *str++);
}
}
void fprint_str(FILE *fp, const char *str) {
while (*str != '\0') {
if (*str == '\n') MAP_UARTCharPut(CONSOLE_UART, '\r');
MAP_UARTCharPut(CONSOLE_UART, *str++);
}
}
//*****************************************************************************
//
//! Get Key - Gets the Key into the Buffer from User
//!
//! \param pucKeyBuff is the Key buffer to which Key will be populated
//!
//! \return Success or Failure
//!
//*****************************************************************************
bool
GetKey(char *pucKeyBuff)
{
char cChar;
unsigned int uiMsgLen;
if(uiHMAC)
{
UART_PRINT("\n\rDo you want to use Pre-Defined Key or not (y/n) ? \n\r");
//
// Get the option
//
cChar = MAP_UARTCharGet(UARTA0_BASE);
//
// Echo the received character
//
MAP_UARTCharPut(UARTA0_BASE, cChar);
UART_PRINT("\n\r");
if(cChar=='y' || cChar=='Y' )
{
//
// Fetch the key
//
UART_PRINT("\n\r Press 1 for Key - %s\n\r Press 2 for Key - %s \n\r"
" Press 3 for Key - %s\n\r",HMACKey1,HMACKey2,HMACKey3);
cChar = MAP_UARTCharGet(UARTA0_BASE);
//
// Echo the received character
//
MAP_UARTCharPut(UARTA0_BASE, cChar);
UART_PRINT("\n\r");
if(cChar=='1' )
memcpy(&uiHMACKey,HMACKey1,64);
else if(cChar=='2')
memcpy(&uiHMACKey,HMACKey2,64);
else if(cChar=='3')
memcpy(&uiHMACKey,HMACKey3,64);
else
{
UART_PRINT("\n\r Wrong Key \n\r");
return false;
}
}
else if(cChar=='n' || cChar=='N')
{
//
// Ask for the Key
//
UART_PRINT("Enter the Key \n\r");
uiMsgLen=GetCmd(pucKeyBuff,520);
if(uiMsgLen!=64)
{
UART_PRINT("\n\r Enter Valid Key of length 64\n\r");
return false;
}
}
else
{
UART_PRINT("\n\r Invalid Input \n\r");
return false;
}
}
return true;
}
//*****************************************************************************
//
//! Get the Command string from UART
//!
//! \param pucBuffer is the command store to which command will be populated
//! \param ucBufLen is the length of buffer store available
//!
//! \return Length of the bytes received. -1 if buffer length exceeded.
//!
//*****************************************************************************
int
GetCmd(char *pcBuffer, unsigned int uiBufLen)
{
char cChar;
int iLen = 0;
//
// Wait to receive a character over UART
//
while(MAP_UARTCharsAvail(CONSOLE) == false)
{
#if defined(USE_FREERTOS) || defined(USE_TI_RTOS)
osi_Sleep(1);
#endif
}
cChar = MAP_UARTCharGetNonBlocking(CONSOLE);
//
// Echo the received character
//
MAP_UARTCharPut(CONSOLE, cChar);
iLen = 0;
//
// Checking the end of Command
//
while((cChar != '\r') && (cChar !='\n') )
{
//
// Handling overflow of buffer
//
if(iLen >= uiBufLen)
{
return -1;
}
//
// Copying Data from UART into a buffer
//
if(cChar != '\b')
{
*(pcBuffer + iLen) = cChar;
iLen++;
}
else
{
//
// Deleting last character when you hit backspace
//
if(iLen)
{
iLen--;
}
}
//
// Wait to receive a character over UART
//
while(MAP_UARTCharsAvail(CONSOLE) == false)
{
#if defined(USE_FREERTOS) || defined(USE_TI_RTOS)
osi_Sleep(1);
#endif
}
cChar = MAP_UARTCharGetNonBlocking(CONSOLE);
//
// Echo the received character
//
MAP_UARTCharPut(CONSOLE, cChar);
}
*(pcBuffer + iLen) = '\0';
Report("\n\r");
return iLen;
}
