How to send sensor data using AT commands to a device using Uart in segger embedded studio

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Rajbir Singh — Fri, 28 May 2021 16:10:15 GMT

Here is my code

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "app_uart.h"
#include "app_error.h"
#include "nrf_delay.h"
#include "nrf.h"
#include "bsp.h"
#include "nrf_uart.h"
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"

#define ENABLE_SWO

//#define DTM_RX_PIN NRF_GPIO_PIN_MAP(0, 11) // p0.11
//#define DTM_TX_PIN NRF_GPIO_PIN_MAP(1, 8) // p1.08


#define UART_TX_BUFF_SIZE 256
#define UART_RX_BUFF_SIZE 256

#define UART_HWFC APP_UART_FLOW_CONTROL_DISABLED


void uart_err_handle(app_uart_evt_type_t * p)
{
  

}


///**@brief Function for UART initialization.
// */
//static void uart_init(void)
//{   
//    uint32_t err_code;
//    const app_uart_comm_params_t comm_params =
//      {
//          DTM_RX_PIN,
//          DTM_TX_PIN,
//          RTS_PIN_NUMBER,
//          CTS_PIN_NUMBER,
//          APP_UART_FLOW_CONTROL_DISABLED,
//          false,
//          NRF_UART_BAUDRATE_115200
//          //DTM_BITRATE
//      };

int main(void)
{

  APP_ERROR_CHECK(NRF_LOG_INIT(NULL));
  NRF_LOG_DEFAULT_BACKENDS_INIT();
  
  NRF_LOG_INFO("AT/n");
  uint32_t err_code;

  bsp_board_init(BSP_INIT_LEDS);
  
  const app_uart_comm_params_t com_params = 
   {
    RX_PIN_NUMBER, 
    TX_PIN_NUMBER, 
    RTS_PIN_NUMBER,
    CTS_PIN_NUMBER,
    UART_HWFC,     //APP_UART_FLOW_CONTROL_DISABLED
    false,
    NRF_UART_BAUDRATE_115200
    };


  APP_UART_FIFO_INIT(&com_params, 
                      UART_RX_BUFF_SIZE, 
                      UART_TX_BUFF_SIZE, 
                      uart_err_handle, 
                      APP_IRQ_PRIORITY_LOWEST, 
                      err_code);

  APP_ERROR_CHECK(err_code);
  NRF_LOG_INFO("AT/n");
  nrf_delay_ms(1000);
  //printf("Hello PC from Nordic");
  
  while(true)
  {
    uint8_t cr;
    NRF_LOG_INFO("AT/n");
    printf("\r\nAT\r\n");
    nrf_delay_ms(2000);
    while(app_uart_get(&cr) != NRF_SUCCESS);//wait here for the character from pc
    if(cr == 'OK')
    {
      bsp_board_leds_on();
      NRF_LOG_INFO("OK");
      
    }
    if(cr == 'ERROR')
    {
      bsp_board_leds_off();
      NRF_LOG_INFO("ERROR");
    }
  }
}

Please correct me where i am wrong?

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Rajbir Singh — Fri, 28 May 2021 16:09:16 GMT

where id debug terminal in this

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Rajbir Singh — Fri, 28 May 2021 15:54:06 GMT

Please tell me where in segger I can check the output of the command

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

awneil — Fri, 28 May 2021 15:11:42 GMT

see the link I provided.

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Rajbir Singh — Fri, 28 May 2021 15:05:44 GMT

[quote userid="6462" url="~/f/nordic-q-a/75447/how-to-send-sensor-data-using-at-commands-to-a-device-using-uart-in-segger-embedded-studio/312403#312403"]As with any other microcontroller, you would need to connect some sort of monitor onto the wires connecting the nRF to the modem[/quote]

means another device, I don't understand what actually you are saying.

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Rajbir Singh — Fri, 28 May 2021 14:27:47 GMT

[quote userid="98377" url="~/f/nordic-q-a/75447/how-to-send-sensor-data-using-at-commands-to-a-device-using-uart-in-segger-embedded-studio/312393#312393"]is used to send data through UART.[/quote]

this?

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Rajbir Singh — Fri, 28 May 2021 14:25:07 GMT

[quote userid="6462" url="~/f/nordic-q-a/75447/how-to-send-sensor-data-using-at-commands-to-a-device-using-uart-in-segger-embedded-studio/312403#312403"]Do you have any experience with ant other microcontroller(s) and/or any other IDE(s) ?[/quote]

yes, i have experience in Arduino programming, python programming for raspberry pi but don't have any in Avr microcontrollers.

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

awneil — Fri, 28 May 2021 13:30:33 GMT

[quote userid="98377" url="~/f/nordic-q-a/75447/how-to-send-sensor-data-using-at-commands-to-a-device-using-uart-in-segger-embedded-studio/312394#312394"]

awneil said:
don't really understand what you meant by Software UART

it is like SoftwareSerial lib in Arduino, by using this we can make any I/O pins as Rx and Tx

[/quote]

That was Hung Bui - not me.

The Arduino SoftwareSerial is, indeed, bit-banged:

www.arduino.cc/.../softwareSerial

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

awneil — Fri, 28 May 2021 13:27:46 GMT

[quote userid="98377" url="~/f/nordic-q-a/75447/how-to-send-sensor-data-using-at-commands-to-a-device-using-uart-in-segger-embedded-studio/312393#312393"]

Some are saying P0.05 to P0.08 is used by J-Link.

[/quote]

That would refer to a Nordic Dev Kit - you could easily check this in the User Manual and/or schematics for that Dev Kit.

In that case you would, indeed, need to choose different pins - or use the other UART.

[quote userid="98377" url="~/f/nordic-q-a/75447/how-to-send-sensor-data-using-at-commands-to-a-device-using-uart-in-segger-embedded-studio/312393#312393"]which pins should I use [/quote]

As stated earlier, with just a few restrictions, you are free to choose any pins you like.

[quote userid="98377" url="~/f/nordic-q-a/75447/how-to-send-sensor-data-using-at-commands-to-a-device-using-uart-in-segger-embedded-studio/312393#312393"]how to change the pins in the code[/quote]

Using the macro definitions shown above.

[quote userid="98377" url="~/f/nordic-q-a/75447/how-to-send-sensor-data-using-at-commands-to-a-device-using-uart-in-segger-embedded-studio/312393#312393"] I am new to nrf and segger [/quote]

Do you have any experience with ant other microcontroller(s) and/or any other IDE(s) ?

[quote userid="98377" url="~/f/nordic-q-a/75447/how-to-send-sensor-data-using-at-commands-to-a-device-using-uart-in-segger-embedded-studio/312393#312393"]how can I check the data in the output console[/quote]

As with any other microcontroller, you would need to connect some sort of monitor onto the wires connecting the nRF to the modem

See:

https://www.avrfreaks.net/comment/2336161#comment-2336161

https://www.avrfreaks.net/comment/2306116#comment-2306116

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Rajbir Singh — Fri, 28 May 2021 13:12:42 GMT

[quote userid="6462" url="~/f/nordic-q-a/75447/how-to-send-sensor-data-using-at-commands-to-a-device-using-uart-in-segger-embedded-studio/312383#312383"]don't really understand what you meant by Software UART[/quote]

it is like SoftwareSerial lib in Arduino, by using this we can make any I/O pins as Rx and Tx.

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Rajbir Singh — Fri, 28 May 2021 13:10:46 GMT

basically, I want to send AT commands to an LTE Module using nrf52840, so I used the UART example in the example folder of nrf sdk 17.0.2.

But I have read its response back to see what I get.

Si I have read m Q&A on devzone.nordicsemi.com.

Some are saying P0.05 to P0.08 is used by J-Link.

So I am confused, so which pins should I use to communicate and how to change the pins in the code.

Actually I am new to nrf and segger so i have some basic questions also

And

printf("AT\n")

is used to send data through UART.

But how can I check the data in the output console, means which command is used to print data in the output console

is it

NRF_LOG_INFO("AT/n");

app_uart_put()

Please help

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

awneil — Fri, 28 May 2021 12:57:18 GMT

[quote userid="2121" url="~/f/nordic-q-a/75447/how-to-send-sensor-data-using-at-commands-to-a-device-using-uart-in-segger-embedded-studio/312382#312382"] don't really understand what you meant by Software UART[/quote]

I presume he means bit-banging it in software?

Doesn't seem much point in doing that when the nRF52840 has 2 "real" (ie, hardware) UARTS?

[quote userid="2121" url="~/f/nordic-q-a/75447/how-to-send-sensor-data-using-at-commands-to-a-device-using-uart-in-segger-embedded-studio/312382#312382"]RX pin to pin P0.27 on the chip. TX pin to P0.26[/quote]

How does it work for P1.xx pins ?

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Hung Bui — Fri, 28 May 2021 12:53:28 GMT

Hi,

What's the exact issue you are having ?
Can you develop your app based on the uart example in the SDK or the example that you found working above ?

I don't really understand what you meant by Software UART ?

What did you mean by "hardware UART is used by debugger" ?
Calling this:

#define RX_PIN_NUMBER 27 //8
#define TX_PIN_NUMBER 26 //6
#define CTS_PIN_NUMBER 12 //7
#define RTS_PIN_NUMBER 11 //5

Will degine the RX pin to pin P0.27 on the chip. TX pin to P0.26 on the chip, and so on.

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Rajbir Singh — Wed, 26 May 2021 09:03:23 GMT

Please help i have some issues.

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Rajbir Singh — Tue, 25 May 2021 11:17:41 GMT

Hi awneil by using the above code, I am not able to send anything.

But I tried the following code to send data to Arduino and I am able to send the data.


#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "app_uart.h"
#include "app_error.h"
#include "nrf_delay.h"
#include "nrf.h"
#include "bsp.h"
#include "nrf_uart.h"

//#define RX_PIN_NUMBER 27 //8
//#define TX_PIN_NUMBER 26 //6
//#define CTS_PIN_NUMBER 12 //7
//#define RTS_PIN_NUMBER 11 //5


#define UART_TX_BUFF_SIZE 256
#define UART_RX_BUFF_SIZE 256

#define UART_HWFC APP_UART_FLOW_CONTROL_DISABLED

void uart_err_handle(app_uart_evt_type_t * p)
{
  

}

int main(void)
{
  uint32_t err_code;

  bsp_board_init(BSP_INIT_LEDS);
  
  const app_uart_comm_params_t com_params = 
   {
    RX_PIN_NUMBER,
    TX_PIN_NUMBER,
    RTS_PIN_NUMBER,
    CTS_PIN_NUMBER,
    UART_HWFC,
    false,
    NRF_UART_BAUDRATE_115200
    };

  APP_UART_FIFO_INIT(&com_params, UART_RX_BUFF_SIZE, UART_TX_BUFF_SIZE, uart_err_handle, APP_IRQ_PRIORITY_LOWEST, err_code);

  APP_ERROR_CHECK(err_code);
  
  printf("Hello PC from Nordic\r\n");
  
  while(true)
  {
    uint8_t cr;

    while(app_uart_get(&cr) != NRF_SUCCESS);//wait here for the character from pc
    if(cr == 'OK')
    {
      bsp_board_leds_on();
      printf("Leds are ON\r\n");
    }
    if(cr == 'ERROR')
    {
      bsp_board_leds_off();
      printf("Leds are OFF\r\n");
    }
  }
}

Also, I am confused that by changing these pins

#define RX_PIN_NUMBER 27 //8
#define TX_PIN_NUMBER 26 //6
#define CTS_PIN_NUMBER 12 //7
#define RTS_PIN_NUMBER 11 //5

Could I able to change the hardware UART to Software UART

Because Hardware UART is used by Debugger

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Rajbir Singh — Mon, 24 May 2021 15:56:06 GMT

I am using hardware pins,but i am able to make communication with device.

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Rajbir Singh — Mon, 24 May 2021 15:54:27 GMT

Is this correct

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "app_uart.h"
#include "app_error.h"
#include "nrf_delay.h"
#include "nrf.h"
#include "bsp.h"
#include "nrf_uart.h"
#include <string.h>

#define RX_PIN_NUMBER 27 //8
#define TX_PIN_NUMBER 26 //6
#define CTS_PIN_NUMBER 12 //7
#define RTS_PIN_NUMBER 11 //5


#define UART_TX_BUF_SIZE 256                         /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE 256                         /**< UART RX buffer size. */

/* When UART is used for communication with the host do not use flow control.*/
#define UART_HWFC APP_UART_FLOW_CONTROL_DISABLED

void uart_error_handle(app_uart_evt_t * p_event)
{
    if (p_event->evt_type == APP_UART_COMMUNICATION_ERROR)
    {
        APP_ERROR_HANDLER(p_event->data.error_communication);
    }
    else if (p_event->evt_type == APP_UART_FIFO_ERROR)
    {
        APP_ERROR_HANDLER(p_event->data.error_code);
    }
}

void uart_putstring(const uint8_t *str) 
{
       uint32_t err_code;

       while( str ) 
       {
            err_code = app_uart_put(( uint8_t*) str++ );

            APP_ERROR_CHECK(err_code);
       }
}
 


/***

static void uart_loopback_test()
{
    uint8_t * tx_data = (uint8_t *)("\r\nLOOPBACK_TEST\r\n");
    uint8_t   rx_data;

    // Start sending one byte and see if you get the same
    for (uint32_t i = 0; i < MAX_TEST_DATA_BYTES; i++)
    {
        uint32_t err_code;
        while (app_uart_put(tx_data[i]) != NRF_SUCCESS);

        nrf_delay_ms(10);
        err_code = app_uart_get(&rx_data);

        if ((rx_data != tx_data[i]) || (err_code != NRF_SUCCESS))
        {
            show_error();
        }
    }
    return;
}

***/

char* uart_getstring(char* rx_data) 
{
       uint32_t err_code;
       err_code = app_uart_get(rx_data);
       APP_ERROR_CHECK(err_code);
       return rx_data;
}


/**
 * @brief Function for main application entry.
 */
int main(void)
{
    uint32_t err_code;

    const app_uart_comm_params_t comm_params =
      {
          RX_PIN_NUMBER,
          TX_PIN_NUMBER,
          RTS_PIN_NUMBER,
          CTS_PIN_NUMBER,
          UART_HWFC,
          false,

          NRF_UART_BAUDRATE_115200

      };

    APP_UART_FIFO_INIT(&comm_params,
                         UART_RX_BUF_SIZE,
                         UART_TX_BUF_SIZE,
                         uart_error_handle,
                         APP_IRQ_PRIORITY_LOWEST,
                         err_code);

    APP_ERROR_CHECK(err_code);

 //Commands to send data to murata_1sc

    uart_putstring((const char*)"AT\r\n"); //variaible iterate - array iterate
    nrf_delay_ms(100);
     char* output;
    output = uart_getstring(output);
    printf(output);
    
    uart_putstring((const char*)"AT%AWSIOTCMD=\"PUBLISH\",\"tracker/location\",\"{\"message\":\"Hello from Murata 1SC\"}\"\r\n"); //variaible iterate - array iterate
    nrf_delay_ms(100);
     char* output;
    output = uart_getstring(output);
    printf(output);
 
}








/***
 
 //array of commands declare
 char arrr[12][150]  = { " AT\r\n ",
                         " ",
                         " ",
                         " AT%CERTCMD=\"DIR\"%CERTCMD:murata_1sc_cert.pem,cert.pem,privatekey.pem,murata_private.key\r\n ",
                         " AT%CERTCFG=\"ADD\",1,,\"~\",\"murata_1sc_cert.pem\",\"murata_1sc_private.key\"\r\n ",
                         " AT%AWSIOTCFG=\"PROTOCOL\",1200,0\r\n ",
                         " AT%AWSIOTEV=\"ALL\",1\r\n ",
                         " AT%AWSIOTCMD=\"CONNECT\"\r\n ",
                         " AT%AWSIOTCMD=\"PUBLISH\",\"tracker/location\",\"{\"message\":\"Hello from Murata 1SC\"}\"\r\n ",
                         " AT%AWSIOTCMD=\"SUBSCRIBE\",\"tracker/location\"\r\n ",
                         " AT%AWSIOTCMD=\"SUBSCRIBE\",\"$aws/things/murata_1sc/shadow/update\"\r\n ",
                         " AT%AWSIOTCMD=\"PUBLISH\",\"$aws/things/murata_1sc/shadow/update\",\" { \"state\": {\"desired\": { \"color\": \"yellow\" } } }\"\r\n "
                       };
 //char outttt[12][100];    
 //loopstart

 int i = 0;
 for(i=0;i<13;i++)
 {
    uart_putstring((const char*)arrr[i]); //variaible iterate - array iterate
    nrf_delay_ms(100);
    char* output;
    while( true )
        {
          // wait for timeout or reply complete
          output = uart_getstring(output);
          if (output == "ERROR")
          {
           printf("ERROR");
          }
}

//print
//loop end
}
}

***/

From where to check the GPIO pin in nrf

P1.02

P1.03

P1.04

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

awneil — Mon, 24 May 2021 14:57:29 GMT

See the Product Specification: the nRF52 have flexible pin mapping - with just a couple of restrictions, the UART (and other peripherals) can be routed to any pins.

The nRF52840 has two hardware UARTs

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Rajbir Singh — Mon, 24 May 2021 14:36:43 GMT

Yes, I am just testing the timeout with different commands.

Could me please tell me, how can I make other pins as UART

Because P0.05 to P0.08 are Hardware UART pins

how can i make other GPIO pins work as UART like software serial in Arduino

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

awneil — Mon, 24 May 2021 13:48:14 GMT

This should really be documented by the module manufacturer - you need to contact them for details.

Remember that you have to consider worst case conditions.

But if your application is OK to wait a whole 4s for a command which should complete "immediately" - then that's fine.

It's your application - only you can answer that.

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Rajbir Singh — Mon, 24 May 2021 11:48:10 GMT

I have sent AT every commands to the module using TeraTerm software, so some commands took almost 3 to 4 seconds to respond.

So 4 seconds timout will be fine for this?

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

awneil — Mon, 24 May 2021 09:35:16 GMT

What, exactly, is your confusion?

Another on ignoring responses when sending commands - only this morning:

www.avrfreaks.net/.../3144271

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Rajbir Singh — Sun, 23 May 2021 14:13:49 GMT

i have made this code

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "app_uart.h"
#include "app_error.h"
#include "nrf_delay.h"
#include "nrf.h"
#include "bsp.h"
#include "nrf_uart.h"
#include <string.h>


#define UART_TX_BUF_SIZE 256                         /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE 256                         /**< UART RX buffer size. */

/* When UART is used for communication with the host do not use flow control.*/
#define UART_HWFC APP_UART_FLOW_CONTROL_DISABLED

void uart_error_handle(app_uart_evt_t * p_event)
{
    if (p_event->evt_type == APP_UART_COMMUNICATION_ERROR)
    {
        APP_ERROR_HANDLER(p_event->data.error_communication);
    }
    else if (p_event->evt_type == APP_UART_FIFO_ERROR)
    {
        APP_ERROR_HANDLER(p_event->data.error_code);
    }
}

void uart_putstring(const uint8_t *str) 
{
       uint32_t err_code;

       while( str ) 
       {
            err_code = app_uart_put(( uint8_t*) str++ );

            APP_ERROR_CHECK(err_code);
       }
}
 
char* uart_getstring(char* rx_data) 
{
       uint32_t err_code;
       err_code = app_uart_get(rx_data);
       return rx_data;
}


/**
 * @brief Function for main application entry.
 */
int main(void)
{
    uint32_t err_code;

    const app_uart_comm_params_t comm_params =
      {
          RX_PIN_NUMBER,
          TX_PIN_NUMBER,
          RTS_PIN_NUMBER,
          CTS_PIN_NUMBER,
          UART_HWFC,
          false,

          NRF_UART_BAUDRATE_115200

      };

    APP_UART_FIFO_INIT(&comm_params,
                         UART_RX_BUF_SIZE,
                         UART_TX_BUF_SIZE,
                         uart_error_handle,
                         APP_IRQ_PRIORITY_LOWEST,
                         err_code);

    APP_ERROR_CHECK(err_code);

 //Commands to send data to murata_1sc

//    uart_putstring((const char*)"AT\r\n"); //variaible iterate - array iterate
  //   char* output;
    //output = uart_getstring(output);
     //printf("Hello PC from Nordic Device!!!\r\n");


 
 //array of commands declare
 char arrr[12][150]  = { " AT\r\n ",
                         " ",
                         " ",
                         " AT%CERTCMD=\"DIR\"%CERTCMD:murata_1sc_cert.pem,cert.pem,privatekey.pem,murata_private.key\r\n ",
                         " AT%CERTCFG=\"ADD\",1,,\"~\",\"murata_1sc_cert.pem\",\"murata_1sc_private.key\"\r\n ",
                         " AT%AWSIOTCFG=\"PROTOCOL\",1200,0\r\n ",
                         " AT%AWSIOTEV=\"ALL\",1\r\n ",
                         " AT%AWSIOTCMD=\"CONNECT\"\r\n ",
                         " AT%AWSIOTCMD=\"PUBLISH\",\"tracker/location\",\"{\"message\":\"Hello from Murata 1SC\"}\"\r\n ",
                         " AT%AWSIOTCMD=\"SUBSCRIBE\",\"tracker/location\"\r\n ",
                         " AT%AWSIOTCMD=\"SUBSCRIBE\",\"$aws/things/murata_1sc/shadow/update\"\r\n ",
                         " AT%AWSIOTCMD=\"PUBLISH\",\"$aws/things/murata_1sc/shadow/update\",\" { \"state\": {\"desired\": { \"color\": \"yellow\" } } }\"\r\n "
                       };
 //char outttt[12][100];    
 //loopstart

 int i = 0;
 for(i=0;i<13;i++)
 {
    uart_putstring((const char*)arrr[i]); //variaible iterate - array iterate
    char* output;
   
      while( !timeout && !reply_complete )
        {
          // wait for timeout or reply complete
          output = uart_getstring(output);
          if (output == "ERROR")
          {
           printf("ERROR");
          }
}

//print
//loop end
}
}

I am still confused about time out

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

Rajbir Singh — Sat, 22 May 2021 12:19:05 GMT

ok thank you so much, I'll try that

RE: How to send sensor data using AT commands to a device using Uart in segger embedded studio

awneil — Sat, 22 May 2021 11:40:13 GMT

I wouldn't recommend this:

send_AT_Command();

timeout();

if (received_srting == actual_string)
{
    print(received_srting);
}
else
{
    print("ERROR",received_srting);
}

because that means you always wait for the maximum time - irrespective of how quickly the modem responds.

also note that replies will generally include variable data - so you can't just test for an "expected string"

instead, maybe something like this:

send_AT_Command();

while( !timeout && !reply_complete )
{
    // wait for timeout or reply complete
}

// handle reply or timeout ...