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

[Rajbir Singh]

Hi, I am new to NRF and segger embedded studio.

So I want to send temperature sensor data connected with nrf52840 DK to the Murata1_SC  device using UART.

The data will be sent using AT Commands.

So how to send AT Commands in Segger embedded studio.

Thank you for the help in advance.

[Rajbir Singh]

#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 UART_TX_BUFF_SIZE 128
#define UART_RX_BUFF_SIZE 128

#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 Device!!!\r\n");
  
  while(true)
  {
    uint8_t cr;

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

[Rajbir Singh]

I have seen this code

uart_putstring((uint8_t*)"AT\r");
nrf_delay_ms(2000);
uart_putstring((uint8_t*)"AT+CMGF=1\r");
       nrf_delay_ms(2000);
uart_putstring((uint8_t*)"AT+CMGS=\"8919242248\"\r");
   nrf_delay_ms(2000);
   uart_putstring((uint8_t*)"test\r");
          nrf_delay_ms(2000);
          app_uart_put((char)0x1A);   ///used (uint8_t) 26 also but no response..
                 nrf_delay_ms(1000);

in this link, where someone is saying to wait for the response, so how can i do that.

[awneil]

Rajbir Singh said:

how much timeout should I keep for waiting for the response

That will depend on the command - you will have to study the module documentation and/or contact the manufacturer for support on that.

Things that require interaction over the network will obviously take longer than things which simply report local status.

Pay attention to commands which can give one (or more) intermediate response(s) before a final response.

Again, study the module documentation for details.

This is where experimenting by sending commands manually helps ...

 

please remember how to properly post source code:

[awneil]

Sorry - I accidentally hit the 'Report as abusive button' - and can't see any way to cancel it.

[Rajbir Singh]

ok, thank you so much for your help,

[awneil]

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 ...

[Rajbir Singh]

ok thank you so much, I'll try that

[Rajbir Singh]

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

[awneil]

What, exactly, is your confusion?

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

www.avrfreaks.net/.../3144271

[Rajbir Singh]

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?

[awneil]

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.

[Rajbir Singh]

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