int send_command(int instance, char * command_ptr, int byteCountBuff, int wait_time,char * response,int recieve_size){
PRINTF("\r\nInside send command\r\n");
int i =0, x;
for(x=0;x<200;x++)
response[x]=0;
UART_DRV_SendDataBlocking(instance, command_ptr, byteCountBuff, wait_time);
printf("Sent\r\n");
printf("Size of response1 %d\r\n",sizeof(response));
returnValue = UART_DRV_ReceiveDataBlocking (instance,response,recieve_size,wait_time);//Buffer size in bytes to accept all of the me
printf("Size of response2 %d\r\n",sizeof(response));
if(returnValue == kStatus_UART_Success){
PRINTF("Fn Recieved:\r\n");
while(response[i] != '\0')
{
PRINTF("%c",response[i]);
i++;
}
PRINTF("\r\n");
if(strstr(*response,"OK") || strstr(*response,">") || strstr(*response,"+CMSG:") == 0){
printf("Response matches\r\n");
return 0;
}
//return -2;
}
}
/*!
* @brief get input charater.
*
*/
char getInput()
{
char ch;
/* We use GETCHAR() for BM and UART Blocking technic for other RTOS. */
#if (defined FSL_RTOS_BM) || ((defined FSL_RTOS_MQX)&&(MQX_COMMON_CONFIG != MQX_LITE_CONFIG))
ch = GETCHAR();
#else
UART_DRV_ReceiveDataBlocking(BOARD_DEBUG_UART_INSTANCE, (uint8_t*)(&ch), 1, OSA_WAIT_FOREVER);
#endif // FSL_RTOS_BM
return ch;
}
static int nio_serial_read(void *dev_context, void *fp_context, void *buf, size_t nbytes)
{
NIO_SERIAL_DEV_CONTEXT_STRUCT *serial_dev_context = (NIO_SERIAL_DEV_CONTEXT_STRUCT *)dev_context;
#if PLATFORM_LPUART_ENABLED
if (kStatus_UART_Success != LPUART_DRV_ReceiveDataBlocking(serial_dev_context->instance, buf, nbytes, OSA_WAIT_FOREVER))
#else
if (kStatus_UART_Success != UART_DRV_ReceiveDataBlocking(serial_dev_context->instance, buf, nbytes, OSA_WAIT_FOREVER))
#endif
{
errno = EIO;
}
return (nbytes - serial_dev_context->uart_state.rxSize);
}
int main(void)
{
uart_state_t uartState; // user provides memory for the driver state structure
uart_user_config_t uartConfig;
long int x;
char AT[] = "\nAT";
char rxBuff[10];
uint32_t byteCountBuff = 0;
//Initialise the FRDM-KL26Z Board
hardware_init();
configure_uart_pins(0); //instance 0 is UART1???
// Call OSA_Init to setup LP Timer for timeout
OSA_Init();
uartConfig.baudRate = 9600;
uartConfig.bitCountPerChar = kUart8BitsPerChar;
uartConfig.parityMode = kUartParityDisabled;
uartConfig.stopBitCount = kUartOneStopBit;
UART_DRV_Init(1, &uartState,&uartConfig);
//Print message to serial terminal
PRINTF("First Embedded Systems Lab_Aonghus\r\n");
PRINTF("Type a character and it will be echoed back\r\n\n");
int i = 0;
byteCountBuff = sizeof(AT);
while(1) {
//UART_DRV_SendDataBlocking(1, AT, byteCountBuff, 16000u);
while(UART_DRV_ReceiveDataBlocking ( 1, rxBuff, sizeof(rxBuff),16000u) == kStatus_UART_Success )
{
for(i=0;i<sizeof(rxBuff);i++)
PRINTF("%c",rxBuff[i]);
}
// if(UART_DRV_GetTransmitStatus (1,sizeof(rxBuff)) == kStatus_UART_Success ){
// }
for(x=0;x<10000000;x++);
}
/* Never leave main */
return 0;
}
static OSStatus platform_uart_receive_bytes( mico_uart_t uart, void* data, uint32_t size, uint32_t timeout )
{
uart_status_t retVal = kStatus_UART_Success;
uart = MICO_UART_1; //test
/* Reset DMA transmission result. The result is assigned in interrupt handler */
#if ADD_OS_CODE
uart_interfaces[uart].rx_dma_result = kGeneralErr;
#endif
#ifdef UART_IRQ_APP
retVal = UART_DRV_ReceiveDataBlocking(BOARD_APP_UART_INSTANCE, data, size, timeout);
// if(UART_DRV_ReceiveData(BOARD_APP_UART_INSTANCE, data,size )==kStatus_UART_Success){
#else
// if(UART_DRV_EdmaReceiveData(BOARD_DEBUG_UART_INSTANCE, data, size)==kStatus_UART_Success){
retVal = UART_DRV_EdmaReceiveDataBlocking(BOARD_APP_UART_INSTANCE, data, size, timeout);//
#endif
if(retVal == kStatus_UART_Success) {
#if ADD_OS_CODE
#ifndef NO_MICO_RTOS
mico_rtos_set_semaphore( &uart_interfaces[uart].rx_complete );
#else
uart_interfaces[uart ].rx_complete = true;
#endif
#endif
return kNoErr;
}
if ( timeout > 0 )
{
#if ADD_OS_CODE
#ifndef NO_MICO_RTOS
mico_rtos_get_semaphore( &uart_interfaces[uart].rx_complete, timeout );
#else
uart_interfaces[uart].rx_complete = false;
int delay_start = mico_get_time_no_os();
while(uart_interfaces[uart].rx_complete == false){
if(mico_get_time_no_os() >= delay_start + timeout && timeout != MICO_NEVER_TIMEOUT){
break;
}
}
#endif
return uart_interfaces[uart].rx_dma_result;
#endif
}
return kGeneralErr; // kNoErr;
}
int main (void)
{
/***************************************************************************
* RX buffers
**************************************************************************/
/*! @param receiveBuff Buffer used to hold received data */
uint8_t receiveBuff[19] = {0};
/* Initialize standard SDK demo application pins */
hardware_init();
/* Configure the UART TX/RX pins */
configure_uart_pins(BOARD_DEBUG_UART_INSTANCE);
#ifdef USE_STDIO_FUNCTIONS
/* Call this function to initialize the console UART. This function
enables the use of STDIO functions (printf, scanf, etc.) */
dbg_uart_init();
/* Print the initial banner */
printf("\r\nHello World!\n\n\r");
while(1)
{
/********************************************
* Main routine that simply echoes received
* characters forever
*********************************************/
/* First, get character. */
receiveBuff[0] = getchar();
/* Now echo the received character */
putchar(receiveBuff[0]);
}
#else
/***************************************************************************
* UART configuration and state structures
**************************************************************************/
/*! @param uartConfig UART configuration structure */
/*! @param uartState UARt state structure which is used internally by the*/
/*! by the UART driver to keep track of the UART states */
uart_user_config_t uartConfig;
uart_state_t uartState;
/***************************************************************************
* TX buffers
**************************************************************************/
/*! @param sourceBuff Buffer used to hold the string to be transmitted */
uint8_t sourceBuff[19] = {"\r\nHello World!\n\n\r"};
/* Configure the UART for 115200, 8 data bits, No parity, and one stop bit*/
uartConfig.baudRate = 115200;
uartConfig.bitCountPerChar = kUart8BitsPerChar;
uartConfig.parityMode = kUartParityDisabled;
uartConfig.stopBitCount = kUartOneStopBit;
/* Must call the OSA Init function to use Communication drivers */
OSA_Init();
/* Initialize the UART module */
UART_DRV_Init(BOARD_DEBUG_UART_INSTANCE, &uartState, &uartConfig);
/* Print the initial banner */
UART_DRV_SendDataBlocking(BOARD_DEBUG_UART_INSTANCE, sourceBuff, 17, 200);
while(1)
{
/********************************************
* Main routine that simply echoes received
* characters forever
*********************************************/
/* First, get character. */
UART_DRV_ReceiveDataBlocking(BOARD_DEBUG_UART_INSTANCE, receiveBuff, 1,
OSA_WAIT_FOREVER);
/* Now, stuff the buffer for the TX side and send the character*/
sourceBuff[0] = receiveBuff[0];
/* Now echo the received character */
UART_DRV_SendDataBlocking(BOARD_DEBUG_UART_INSTANCE, sourceBuff, 1,
200);
}
#endif
}
