/*
** ===================================================================
** Method : CLS1_ReadAndParseWithCommandTable (component Shell)
** Description :
** Reads characters from the default input channel and appends
** it to the buffer. Once a new line has been detected, the
** line will be parsed using the handlers in the table.
** Parameters :
** NAME - DESCRIPTION
** * cmdBuf - Pointer to buffer provided by the
** caller where to store the command to read
** in. Characters will be appended, so make
** sure string buffer is initialized with a
** zero byte at the beginning.
** cmdBufSize - Size of buffer
** * io - Pointer to I/O channels to be used
** * parseCallback - Pointer to callback
** table provided by the user application to
** parse commands. The table has a NULL
** sentinel.
** Returns :
** --- - Error code
** ===================================================================
*/
uint8_t CLS1_ReadAndParseWithCommandTable(uint8_t *cmdBuf, size_t cmdBufSize, CLS1_ConstStdIOType *io, CLS1_ConstParseCommandCallback *parseCallback)
{
uint8_t res = ERR_OK;
size_t len;
/* IMPORTANT NOTE: this function *appends* to the buffer, so the buffer needs to be initialized first! */
len = UTIL1_strlen((const char*)cmdBuf);
if (CLS1_ReadLine(cmdBuf, cmdBuf+len, cmdBufSize-len, io)) {
len = UTIL1_strlen((const char*)cmdBuf); /* length of buffer string */
if (len==0) { /* error case */
return ERR_FAILED;
} else if (len==1 && (cmdBuf[0]=='\n' || cmdBuf[0]=='\r')) { /* eat preceding newline characters */
cmdBuf[0] = '\0';
}
if (len>=cmdBufSize-1) { /* buffer overflow? Parse what we have, will be likely return an error */
(void)CLS1_ParseWithCommandTable(cmdBuf, io, parseCallback);
cmdBuf[0] = '\0'; /* start again */
res = ERR_OVERFLOW;
} else if (cmdBuf[len-1]=='\n' || cmdBuf[len-1]=='\r') { /* line end: parse command */
cmdBuf[len-1] = '\0'; /* remove line end character for parser */
res = CLS1_ParseWithCommandTable(cmdBuf, io, parseCallback);
cmdBuf[0] = '\0'; /* start again */
} else {
/* continue to append to buffer */
}
}
return res;
}
void I2C_StoreCmd(void) {
#if PL_HAS_UI
unsigned char buf[32];
uint8_t strSize;
#if PL_HAS_RUNNER
buf[0] = '@';
buf[1] = '\0';
RUNNER_GetCmdString(buf, sizeof(buf));
#elif PL_HAS_SLIDER
SLIDER_GetCmdString(buf, sizeof(buf));
#else
buf[0] = '\0';
#endif
if (buf[0]!='\0') {
uint8_t cnt=3;
while(cnt>0 && memDevice.u.data.cmdLength!=0) { /* poll cmdLength: this will be set to zero by the master if it is ok to place the string */
FRTOS1_vTaskDelay(50/portTICK_RATE_MS); /* give master some time to clear the flasg */
cnt--;
}
if (cnt==0) { /* timeout. Will loose that command. Not ideal, but simple :-) */
return; /* get out here */
}
strSize = (uint8_t)(UTIL1_strlen(buf)+1); /* size of string including zero byte */
if (strSize>sizeof(memDevice.u.data.cmd)) {
strSize = sizeof(memDevice.u.data.cmd);
}
EnterCritical();
memDevice.u.data.cmdLength = strSize;
UTIL1_strcpy(memDevice.u.data.cmd, sizeof(memDevice.u.data.cmd), buf);
ExitCritical();
}
#endif /* PL_HAS_UI */
}
/*!
\brief A simple state machine iterating through different transceiver states
*/
static void RADIO_HandleState(void) {
tTxPacket ackTxPacket; /* SMAC structure for TX packets */
static uint8_t ackTxDataBuffer[SMAC1_RADIO_BUF_SIZE]; /*Data buffer to hold TX data */
switch (RADIO_AppStatus) {
case RADIO_INITIAL_STATE:
RADIO_AppStatus = RADIO_RECEIVER_ALWAYS_ON;
break;
case RADIO_RECEIVER_ALWAYS_ON:
RADIO_AppStatus = RADIO_READY_FOR_TX_RX_DATA;
(void)SMAC1_MLMERXEnableRequest(0); /* Zero means wait forever with RX ON. */
break;
case RADIO_READY_FOR_TX_RX_DATA: /* we are ready to receive/send data data */
break;
case RADIO_TRANSMIT_DATA:
if (SMAC1_MLMERXDisableRequest() != SMAC1_SUCCESS) { /* Turn off the RX forever mode. */
RADIO_AppStatus = RADIO_TRANSMIT_DATA; /* retry */
break;
}
LED1_Neg();
if ((SMAC1_MCPSDataRequest(&RADIO_TxPacket) == SMAC1_SUCCESS)) { /* transmit data */
RADIO_AppStatus = RADIO_WAITING_FOR_ACK;
(void)SMAC1_MLMERXEnableRequest(RADIO_TIMEOUT_COUNT);
} else {
RADIO_AppStatus = RADIO_RECEIVER_ALWAYS_ON; /* what should we otherwise do? */
}
break;
case RADIO_TRANSMIT_ACK:
/*Initialize the packet.*/
/*! \todo RADIO: Below we send back the acknowledge message:
* check that your RADIO_ACK_STR is what you want and need.
* Notice the implicit string concatenation for efficiency and reduced code size. */
UTIL1_strcpy(ackTxDataBuffer, sizeof(ackTxDataBuffer), (unsigned char*)RADIO_PREFIX_STR RADIO_ACK_STR);
ackTxPacket.pu8Data = &ackTxDataBuffer[0]; /* Load the address of our txbuffer into the tx structure*/
ackTxPacket.u8DataLength = (byte)(UTIL1_strlen((char*)ackTxDataBuffer)+1); /* set the size of the packet */
(void)SMAC1_MCPSDataRequest(&ackTxPacket); /* transmit data */
RADIO_AppStatus = RADIO_RECEIVER_ALWAYS_ON;
break;
case RADIO_RESET_STATE:
/* MC13192 Reset, reinitialize and return to default state. */
SMAC1_RadioInit();
RADIO_AppStatus = RADIO_INITIAL_STATE;
break;
case RADIO_WAITING_FOR_ACK:
/* At this point only two things happen, 1-we receive the ack packet or 2-timeout.
* Either way the TX will leave this state and continue. Low power mode could be placed here
* because both 1 and 2 are interrupt driven, in this case we keep it simple
*/
break;
default:
break;
}
}
uint8_t ESP_SendATCommand(uint8_t *cmd, uint8_t *rxBuf, size_t rxBufSize, uint8_t *expectedTailStr)
{
uint16_t snt;
if (AS2_SendBlock(cmd, (uint16_t)UTIL1_strlen((char*)cmd), &snt) != ERR_OK) {
return ERR_FAILED;
}
return RxResponse(rxBuf, rxBufSize, ESP_TIMOUT_MS, expectedTailStr);
}
uint8_t RNETA_ParseCommand(const unsigned char *cmd, bool *handled, const CLS1_StdIOType *io) {
uint8_t res = ERR_OK;
const uint8_t *p;
uint16_t val16;
if (UTIL1_strcmp((char*)cmd, (char*)CLS1_CMD_HELP)==0 || UTIL1_strcmp((char*)cmd, (char*)"app help")==0) {
PrintHelp(io);
*handled = TRUE;
} else if (UTIL1_strcmp((char*)cmd, (char*)CLS1_CMD_STATUS)==0 || UTIL1_strcmp((char*)cmd, (char*)"app status")==0) {
*handled = TRUE;
return PrintStatus(io);
} else if (UTIL1_strncmp((char*)cmd, (char*)"app saddr", sizeof("app saddr")-1)==0) {
p = cmd + sizeof("app saddr")-1;
*handled = TRUE;
if (UTIL1_ScanHex16uNumber(&p, &val16)==ERR_OK) {
(void)RNWK_SetThisNodeAddr((RNWK_ShortAddrType)val16);
} else {
CLS1_SendStr((unsigned char*)"ERR: wrong address\r\n", io->stdErr);
return ERR_FAILED;
}
} else if (UTIL1_strncmp((char*)cmd, (char*)"app daddr", sizeof("app daddr")-1)==0) {
p = cmd + sizeof("app daddr")-1;
*handled = TRUE;
if (UTIL1_ScanHex16uNumber(&p, &val16)==ERR_OK) {
APP_dstAddr = val16;
} else {
CLS1_SendStr((unsigned char*)"ERR: wrong address\r\n", io->stdErr);
return ERR_FAILED;
}
#if PL_HAS_RSTDIO
} else if (UTIL1_strncmp((char*)cmd, (char*)"app send", sizeof("app send")-1)==0) {
unsigned char buf[32];
RSTDIO_QueueType queue;
if (UTIL1_strncmp((char*)cmd, (char*)"app send in", sizeof("app send in")-1)==0) {
queue = RSTDIO_QUEUE_TX_IN;
cmd += sizeof("app send in");
} else if (UTIL1_strncmp((char*)cmd, (char*)"app send out", sizeof("app send out")-1)==0) {
queue = RSTDIO_QUEUE_TX_OUT;
cmd += sizeof("app send out");
} else if (UTIL1_strncmp((char*)cmd, (char*)"app send err", sizeof("app send err")-1)==0) {
queue = RSTDIO_QUEUE_TX_ERR;
cmd += sizeof("app send err");
} else {
return ERR_OK; /* not handled */
}
UTIL1_strcpy(buf, sizeof(buf), cmd);
UTIL1_chcat(buf, sizeof(buf), '\n');
buf[sizeof(buf)-2] = '\n'; /* have a '\n' in any case */
if (RSTDIO_SendToTxStdio(queue, buf, UTIL1_strlen((char*)buf))!=ERR_OK) {
CLS1_SendStr((unsigned char*)"failed!\r\n", io->stdErr);
}
*handled = TRUE;
#endif
}
return res;
}
int strindex(char *s, char *t) {
uint16_t i,n;
n=UTIL1_strlen(t);
for(i=0;*(s+i); i++) {
if (UTIL1_strncmp(s+i,t,n) == 0)
return i;
}
return -1;
}
static uint8_t Test(CLS1_ConstStdIOTypePtr io) {
static FIL fp;
UINT bw;
uint8_t read_buf[16];
uint8_t write_buf[10];
uint8_t i;
if (FAT1_isWriteProtected()) {
CLS1_SendStr((unsigned char*)"disk is write protected!\r\n", io->stdErr);
return ERR_FAILED;
}
/* write file */
CLS1_SendStr((const unsigned char*)"Creating test.txt...\r\n", io->stdOut);
if (FAT1_open(&fp, "./test.txt", FA_CREATE_ALWAYS|FA_WRITE)!=FR_OK) {
CLS1_SendStr((const unsigned char*)"*** Failed creating file!\r\n", io->stdErr);
return ERR_FAILED;
}
/* write text */
if (FAT1_write(&fp, "Hello world ", sizeof("Hello world ")-1, &bw)!=FR_OK) {
CLS1_SendStr((const unsigned char*)"*** Failed writing string!\r\n", io->stdErr);
(void)FAT1_close(&fp);
return ERR_FAILED;
}
write_buf[0] = '\0';
for(i=0;i<4;i++) {
UTIL1_strcatNum8u(write_buf, sizeof(write_buf), i);
UTIL1_chcat(write_buf, sizeof(write_buf), ' ');
}
if (FAT1_write(&fp, write_buf, UTIL1_strlen((char*)write_buf), &bw)!=FR_OK) {
CLS1_SendStr((const unsigned char*)"*** Failed writing string!\r\n", io->stdErr);
(void)FAT1_close(&fp);
return ERR_FAILED;
}
/* closing file */
(void)FAT1_close(&fp);
/* read from file */
CLS1_SendStr((const unsigned char*)"Read from file...\r\n", io->stdOut);
if (FAT1_open(&fp, "./test.txt", FA_READ)!=FR_OK) {
CLS1_SendStr((const unsigned char*)"*** Failed opening file!\r\n", io->stdErr);
return ERR_FAILED;
}
if (FAT1_read(&fp, &read_buf[0], sizeof(read_buf)-2, &bw)!=FR_OK) {
CLS1_SendStr((const unsigned char*)"*** Failed reading file!\r\n", io->stdErr);
(void)FAT1_close(&fp);
return ERR_FAILED;
}
read_buf[sizeof(read_buf)-2] = '\0'; /* terminate string */
UTIL1_strcat(read_buf, sizeof(read_buf), (unsigned char*)"\r\n");
CLS1_SendStr(read_buf, io->stdOut);
CLS1_SendStr((const unsigned char*)"\r\n", io->stdOut);
/* close file */
(void)FAT1_close(&fp);
return ERR_OK;
}
void LogToFile(DataBuffer* myBuf,char annotation, char* fileName) {
int16_t currentBuf = myBuf->currentReadBuffer;
//uint8_t write_buf[48];
UINT bw;
/* open file */
if (FAT1_open(&fp, fileName, FA_OPEN_ALWAYS|FA_WRITE)!=FR_OK) {
Err(/*OPEN_FILE_ERROR*/);
}
/* move to the end of the file */
if (FAT1_lseek(&fp, fp.fsize) != FR_OK || fp.fptr != fp.fsize) {
Err(/*END_OF_FILE_ERROR*/);
}
/* write data */
write_buf[0] = '\0';
//time_t run_time;
for(int cur_buf_index=0;cur_buf_index<BUFFER_SIZE;++cur_buf_index)
{
/** Time Components */
UTIL1_strcatNum8u(write_buf, sizeof(write_buf), myBuf->dataBuffer[currentBuf][cur_buf_index].time.hour);
UTIL1_chcat(write_buf, sizeof(write_buf), ':');
UTIL1_strcatNum8u(write_buf, sizeof(write_buf), myBuf->dataBuffer[currentBuf][cur_buf_index].time.minute);
UTIL1_chcat(write_buf, sizeof(write_buf), ':');
UTIL1_strcatNum8u(write_buf, sizeof(write_buf), myBuf->dataBuffer[currentBuf][cur_buf_index].time.second);
UTIL1_chcat(write_buf, sizeof(write_buf), ':');
UTIL1_strcatNum8u(write_buf, sizeof(write_buf), myBuf->dataBuffer[currentBuf][cur_buf_index].time.milliBig);
UTIL1_strcatNum8u(write_buf, sizeof(write_buf), myBuf->dataBuffer[currentBuf][cur_buf_index].time.milliSmall);
UTIL1_chcat(write_buf, sizeof(write_buf), ',');
;
/** Accelerometer Components */
UTIL1_strcatNum16s(write_buf, sizeof(write_buf), myBuf->dataBuffer[currentBuf][cur_buf_index].x);
UTIL1_chcat(write_buf, sizeof(write_buf), ',');
UTIL1_strcatNum16s(write_buf, sizeof(write_buf), myBuf->dataBuffer[currentBuf][cur_buf_index].y);
UTIL1_chcat(write_buf, sizeof(write_buf), ',');
UTIL1_strcatNum16s(write_buf, sizeof(write_buf), myBuf->dataBuffer[currentBuf][cur_buf_index].z);
UTIL1_chcat(write_buf, sizeof(write_buf), ',');
/** Annotation mode **/
UTIL1_chcat(write_buf, sizeof(write_buf), annotation);
UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)"\n");
/** Write to file **/
if (FAT1_write(&fp, write_buf, UTIL1_strlen((char*)write_buf), &bw)!=FR_OK) {
(void)FAT1_close(&fp);
Err(/*WRITE_ERROR*/);
}
memset(write_buf,'\0',48);
}
if(myBuf->currentReadBuffer == currentBuf)
myBuf->currentReadBuffer=-1;
/* closing file */
(void)FAT1_close(&fp);
}
void RADIO_SendString(const char *data) {
if (!RADIO_isOn) {
return;
}
while (RADIO_AppStatus != RADIO_READY_FOR_TX_RX_DATA) { /* we are not ready yet! */
RADIO_HandleState(); /* advance state machine */
}
UTIL1_strcpy((char*)RADIO_TxDataBuffer, sizeof(RADIO_TxDataBuffer), RADIO_PREFIX_STR);
UTIL1_strcat((char*)RADIO_TxDataBuffer, sizeof(RADIO_TxDataBuffer), data);
RADIO_TxPacket.pu8Data = &RADIO_TxDataBuffer[0]; /* Load the address of our txbuffer into tx structure.*/
RADIO_TxPacket.u8DataLength = (byte)(UTIL1_strlen((char*)RADIO_TxDataBuffer)+1); /* Set the data length of the packet */
RADIO_AppStatus = RADIO_TRANSMIT_DATA;
RADIO_HandleState(); /* advance state machine */
}
void SQUEUE_SendString(const unsigned char *str) {
/*! \todo Implement function */
#if PL_CONFIG_HAS_SQUEUE_SINGLE_CHAR
while(*str!='\0') {
if (FRTOS1_xQueueSendToBack(SQUEUE_Queue, str, 100/portTICK_RATE_MS)!=pdPASS) {
/*for(;;){}*/ /* ups? */ /* loosing character */
}
str++;
}
#else
unsigned char *ptr;
size_t bufSize;
bufSize = UTIL1_strlen(str)+1;
ptr = FRTOS1_pvPortMalloc(bufSize);
UTIL1_strcpy(ptr, bufSize, str);
if (FRTOS1_xQueueSendToBack(SQUEUE_Queue, &ptr, portMAX_DELAY)!=pdPASS) {
for(;;){} /* ups? */
}
#endif
}
static void LogToFile(int16_t x, int16_t y, int16_t z) {
uint8_t write_buf[48];
UINT bw;
TIMEREC time;
/* open file */
if (FAT1_open(&fp, "./log.txt", FA_OPEN_ALWAYS|FA_WRITE)!=FR_OK) {
Err();
}
/* move to the end of the file */
if (FAT1_lseek(&fp, fp.fsize) != FR_OK || fp.fptr != fp.fsize) {
Err();
}
/* get time */
if (TmDt1_GetTime(&time)!=ERR_OK) {
Err();
}
/* write data */
write_buf[0] = '\0';
UTIL1_strcatNum8u(write_buf, sizeof(write_buf), time.Hour);
UTIL1_chcat(write_buf, sizeof(write_buf), ':');
UTIL1_strcatNum8u(write_buf, sizeof(write_buf), time.Min);
UTIL1_chcat(write_buf, sizeof(write_buf), ':');
UTIL1_strcatNum8u(write_buf, sizeof(write_buf), time.Sec);
UTIL1_chcat(write_buf, sizeof(write_buf), '\t');
UTIL1_strcatNum16s(write_buf, sizeof(write_buf), x);
UTIL1_chcat(write_buf, sizeof(write_buf), '\t');
UTIL1_strcatNum16s(write_buf, sizeof(write_buf), y);
UTIL1_chcat(write_buf, sizeof(write_buf), '\t');
UTIL1_strcatNum16s(write_buf, sizeof(write_buf), z);
UTIL1_strcat(write_buf, sizeof(write_buf), (unsigned char*)"\r\n");
if (FAT1_write(&fp, write_buf, UTIL1_strlen((char*)write_buf), &bw)!=FR_OK) {
(void)FAT1_close(&fp);
Err();
}
/* closing file */
(void)FAT1_close(&fp);
}
uint8_t ESP_SendATCommand(uint8_t *cmd, uint8_t *rxBuf, size_t rxBufSize, uint8_t *expectedTailStr, uint16_t msTimeout, const CLS1_StdIOType *io) {
uint16_t snt;
uint8_t res;
if (rxBuf!=NULL) {
rxBuf[0] = '\0';
}
if (io!=NULL) {
CLS1_SendStr("sending>>:\r\n", io->stdOut);
CLS1_SendStr(cmd, io->stdOut);
}
if (AS2_SendBlock(cmd, (uint16_t)UTIL1_strlen((char*)cmd), &snt) != ERR_OK) {
return ERR_FAILED;
}
if (rxBuf!=NULL) {
res = RxResponse(rxBuf, rxBufSize, expectedTailStr, msTimeout);
if (io!=NULL) {
CLS1_SendStr("received<<:\r\n", io->stdOut);
CLS1_SendStr(rxBuf, io->stdOut);
}
}
return res;
}
/*
** ===================================================================
** Method : CLS1_ReadLine (component Shell)
** Description :
** Reads a line from stdIn and returns TRUE if we have a line,
** FALSE otherwise.
** Parameters :
** NAME - DESCRIPTION
** * bufStart - Pointer to start of buffer
** * buf - Pointer to buffer where to read in the
** information
** bufSize - size of buffer
** * io - Pointer to I/O callbacks
** Returns :
** --- - TRUE if something has been read, FALSE
** otherwise
** ===================================================================
*/
bool CLS1_ReadLine(uint8_t *bufStart, uint8_t *buf, size_t bufSize, CLS1_ConstStdIOType *io)
{
uint8_t c;
bool isBackwardHistory;
if (io->keyPressed()) {
for(;;) { /* while not '\r' or '\n' */
c = '\0'; /* initialize character */
io->stdIn(&c); /* read character */
if (c=='\0') { /* nothing in rx buffer? Something is wrong... */
break; /* get out of loop */
}
if (c=='\b' || c=='\177') { /* check for backspace */
if (buf > bufStart) { /* Avoid buffer underflow */
#if CLS1_ECHO_ENABLED
io->stdOut('\b'); /* delete character on terminal */
io->stdOut(' ');
io->stdOut('\b');
#endif
buf--; /* delete last character in buffer */
*buf = '\0';
bufSize++;
}
} else if (CLS1_IsHistoryCharacter(c, bufStart, buf-bufStart, &isBackwardHistory)) {
#if CLS1_HISTORY_ENABLED
uint8_t cBuf[3]={'\0','\0','\0'}, cBufIdx = 0;
bool prevInHistory;
#endif
while (c!='\0') { /* empty the rx buffer (escape sequence) */
#if CLS1_HISTORY_ENABLED
cBuf[cBufIdx] = c;
cBufIdx++;
if (cBufIdx==sizeof(cBuf)) {
cBufIdx = 0; /* ring buffer */
}
#endif
c = '\0'; /* initialize character */
io->stdIn(&c); /* read character */
}
#if CLS1_HISTORY_ENABLED
/* if not an alphanumeric switch to history */
prevInHistory = cBufIdx==0 && cBuf[0]==0x1b && cBuf[1]==0x5b && (cBuf[2]==0x41 /*up*/ || cBuf[2]==0x44 /*left*/);
/* up: 0x27 0x5b 0x41
* down: 0x27 0x5b 0x42
* right: 0x27 0x5b 0x43
* left: 0x27 0x5b 0x44
*/
if (prevInHistory) {
UTIL1_strcpy(bufStart, CLS1_HIST_LEN, CLS1_history[CLS1_history_index]);
CLS1_history_index++; /* update the index */
if (CLS1_history_index==CLS1_NOF_HISTORY) {
CLS1_history_index = 0;
}
} else {
if (CLS1_history_index==0) {
CLS1_history_index = (CLS1_NOF_HISTORY-1);
} else {
CLS1_history_index--;
}
UTIL1_strcpy(bufStart, CLS1_HIST_LEN, CLS1_history[CLS1_history_index]);
}
bufSize = bufSize + buf - bufStart - UTIL1_strlen(bufStart); /* update the buffer */
buf = bufStart + UTIL1_strlen(bufStart);
#endif
#if CLS1_ECHO_ENABLED
CLS1_SendStr((unsigned char*)"\r\n", io->stdOut);
CLS1_PrintPrompt(io);
CLS1_SendStr(bufStart, io->stdOut);
#endif
} else {
#if CLS1_ECHO_ENABLED
io->stdOut(c); /* echo character */
#endif
*buf = (uint8_t)c; /* append character to the string */
buf++;
bufSize--;
if ((c=='\r') || (c=='\n')) {
#if CLS1_ECHO_ENABLED
CLS1_SendStr((unsigned char*)"\n", io->stdOut);
#endif
#if CLS1_HISTORY_ENABLED
if ((bufStart[0] != '\0') && (bufStart[0] != '\r') && (bufStart[0] != '\n')) {
int i;
for(i=CLS1_NOF_HISTORY-1; i>0;i--) {
UTIL1_strcpy(CLS1_history[i], CLS1_HIST_LEN, CLS1_history[i-1]); /* move previous commands */
}
CLS1_history_index = 0; /* update the history with the current command */
UTIL1_strcpy(CLS1_history[0], CLS1_HIST_LEN, bufStart); /* add the current command to the history */
if (buf-bufStart <= CLS1_HIST_LEN) { /* size check */
CLS1_history[0][buf-bufStart-1] = '\0';
} else {
CLS1_history[0][CLS1_HIST_LEN-1] = '\0';
}
}
#endif
break;
}
if (bufSize <= 1) { /* buffer full */
break;
}
}
} /* for */
*buf = '\0'; /* zero terminate string */
return TRUE;
} else {
return FALSE;
}
}
uint8_t RNETA_ParseCommand(const unsigned char *cmd, bool *handled, const CLS1_StdIOType *io) {
uint8_t res = ERR_OK;
const uint8_t *p;
uint16_t val16;
uint8_t val8;
if (UTIL1_strcmp((char*)cmd, (char*)CLS1_CMD_HELP)==0 || UTIL1_strcmp((char*)cmd, (char*)"rapp help")==0) {
PrintHelp(io);
*handled = TRUE;
} else if (UTIL1_strcmp((char*)cmd, (char*)CLS1_CMD_STATUS)==0 || UTIL1_strcmp((char*)cmd, (char*)"rapp status")==0) {
*handled = TRUE;
return PrintStatus(io);
} else if (UTIL1_strncmp((char*)cmd, (char*)"rapp saddr", sizeof("rapp saddr")-1)==0) {
p = cmd + sizeof("rapp saddr")-1;
*handled = TRUE;
if (UTIL1_ScanHex16uNumber(&p, &val16)==ERR_OK) {
(void)RNWK_SetThisNodeAddr((RNWK_ShortAddrType)val16);
} else {
CLS1_SendStr((unsigned char*)"ERR: wrong address\r\n", io->stdErr);
return ERR_FAILED;
}
} else if (UTIL1_strncmp((char*)cmd, (char*)"rapp send val", sizeof("rapp send val")-1)==0) {
p = cmd + sizeof("rapp send val")-1;
*handled = TRUE;
if (UTIL1_ScanDecimal8uNumber(&p, &val8)==ERR_OK) {
(void)RAPP_SendPayloadDataBlock(&val8, sizeof(val8), (uint8_t)RAPP_MSG_TYPE_DATA, APP_dstAddr, RPHY_PACKET_FLAGS_NONE); /* only send low byte */
} else {
CLS1_SendStr((unsigned char*)"ERR: wrong number format\r\n", io->stdErr);
return ERR_FAILED;
}
} else if (UTIL1_strncmp((char*)cmd, (char*)"rapp daddr", sizeof("rapp daddr")-1)==0) {
p = cmd + sizeof("rapp daddr")-1;
*handled = TRUE;
if (UTIL1_ScanHex16uNumber(&p, &val16)==ERR_OK) {
APP_dstAddr = val16;
} else {
CLS1_SendStr((unsigned char*)"ERR: wrong address\r\n", io->stdErr);
return ERR_FAILED;
}
#if RNET_CONFIG_REMOTE_STDIO
} else if (UTIL1_strncmp((char*)cmd, (char*)"rapp send", sizeof("rapp send")-1)==0) {
unsigned char buf[32];
RSTDIO_QueueType queue;
if (UTIL1_strncmp((char*)cmd, (char*)"rapp send in", sizeof("rapp send in")-1)==0) {
queue = RSTDIO_QUEUE_TX_IN;
cmd += sizeof("rapp send in");
} else if (UTIL1_strncmp((char*)cmd, (char*)"rapp send out", sizeof("rapp send out")-1)==0) {
queue = RSTDIO_QUEUE_TX_OUT;
cmd += sizeof("rapp send out");
} else if (UTIL1_strncmp((char*)cmd, (char*)"rapp send err", sizeof("rapp send err")-1)==0) {
queue = RSTDIO_QUEUE_TX_ERR;
cmd += sizeof("rapp send err");
} else {
return ERR_OK; /* not handled */
}
UTIL1_strcpy(buf, sizeof(buf), cmd);
UTIL1_chcat(buf, sizeof(buf), '\n');
buf[sizeof(buf)-2] = '\n'; /* have a '\n' in any case */
if (RSTDIO_SendToTxStdio(queue, buf, UTIL1_strlen((char*)buf))!=ERR_OK) {
CLS1_SendStr((unsigned char*)"failed!\r\n", io->stdErr);
}
*handled = TRUE;
#endif
}
return res;
}
