BG96_at_driver.c File Reference

BG96 AT-command driver functionality. More...

#include <stdint.h>
#include <stdbool.h>
#include "em_cmu.h"
#include "em_device.h"
#include "em_gpio.h"
#include "BG96_at_driver.h"
#include "debug_dbprint.h"
#include "delay.h"
#include "util_string.h"
#include "datatypes.h"
#include "credentials.h"
#include "pin_mapping.h"

Go to the source code of this file.

Macros
#define	PRINT_ID_TOKEN   0 /* 0 = don't print ID & Token, 1 = print ID & Token */

Functions
static bool	transmissionBegin (bool continueCode)
	Code for the start of a NB-IoT transmission. More...
static bool	transmissionEnd (bool continueCode)
	Code for the end of a NB-IoT transmission. More...
void	initBG96 (void)
	Initialize the GPIO pins and UART0 module necessary to communicate with the BG96 module. More...
void	sendMeasurements (MeasurementData_t *data)
	Send measurements to the cloud using NB-IoT. More...
void	sendStatus (int8_t status)
	Send status to the cloud using NB-IoT. More...
void	sendPulse (uint8_t number, uint8_t pulse)
	Send current pulses to the cloud using NB-IoT. More...
void	powerBG96 (void)
	Method to enable the power key for 100ms to enable/disable the module. More...
void	disableEcho (void)
	Disable echo. More...
void	sendCMD (char *message)
	Print a string (char array) to USARTx. More...
void	readResponse (char *buf)
	Read a string (char array) from USARTx. More...
bool	waitForResponse (char *response, uint8_t timeout)
	Wait for the correct response using sleep/timeout functionality. More...

Variables
char	DEVICE_ID_hex [2 *(sizeof(DEVICE_ID) -1)+1]
char	DEVICE_TOKEN_hex [2 *(sizeof(DEVICE_TOKEN) -1)+1]

Detailed Description

BG96 AT-command driver functionality.

Version

1.0

Author

Brecht Van Eeckhoudt

---

Versions

• v1.0: Basic functionality to send measurements to the cloud using NB-IoT without timeout functionality.

---

License

Copyright (C) 2020 - Brecht Van Eeckhoudt

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

A copy of the GNU General Public License can be found in the LICENSE file along with this source code.

Some methods use code obtained from examples from Silicon Labs' GitHub. These sections are licensed under the Silabs License Agreement. See the file "Silabs_License_Agreement.txt" for details. Before using this software for any purpose, you must agree to the terms of that agreement.

Definition in file BG96_at_driver.c.

Macro Definition Documentation

PRINT_ID_TOKEN

#define PRINT_ID_TOKEN   0 /* 0 = don't print ID & Token, 1 = print ID & Token */

Definition at line 59 of file BG96_at_driver.c.

Function Documentation

disableEcho()

void disableEcho

(

void

)

Disable echo.

Definition at line 592 of file BG96_at_driver.c.

{

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
    dbinfo("Sending Disable Echo command...");
#endif /* DEBUG_DBPRINT */

    bool continueCode = true;

    sendCMD("ATE0\r");

    while (!continueCode) // TODO: update this code with timeout functionality?
    {
        sleep(2);
        sendCMD("ATE0\r");
        continueCode = waitForResponse("OK", 5); /* Wait for the correct response */
    }
}

initBG96()

void initBG96

(

void

)

Initialize the GPIO pins and UART0 module necessary to communicate with the BG96 module.

Definition at line 82 of file BG96_at_driver.c.

{
    /* Convert ID & Token */
    charASCII_to_charHex(DEVICE_ID, DEVICE_ID_hex);
    charASCII_to_charHex(DEVICE_TOKEN, DEVICE_TOKEN_hex);

#if PRINT_ID_TOKEN == 1 /* PRINT_ID_TOKEN */
#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbprint("INFO: DEVICE_ID = ");
        dbprintln(DEVICE_ID);
        dbprint("INFO: DEVICE_ID_hex = ");
        dbprintln(DEVICE_ID_hex);
        dbprintln("");
        dbprint("INFO: DEVICE_TOKEN = ");
        dbprintln(DEVICE_TOKEN);
        dbprint("INFO: DEVICE_TOKEN_hex = ");
        dbprintln(DEVICE_TOKEN_hex);
        dbprintln("");
#endif /* DEBUG_DBPRINT */
#endif /* PRINT_ID_TOKEN */

    /* Enable oscillator to GPIO*/
    CMU_ClockEnable(cmuClock_GPIO, true);

    /* Initialize GPIO pin for PWR key */
    /* In the case of gpioModePushPull, the last argument directly sets the pin state */
    GPIO_PinModeSet(BG96_PWRKEY_PORT, BG96_PWRKEY_PIN, gpioModePushPull, 0);

    /*
     * USART_INITASYNC_DEFAULT:
     *   config.enable = usartEnable       // Specifies whether TX and/or RX is enabled when initialization is completed
     *                                     // (Enable RX/TX when initialization is complete).
     *   config.refFreq = 0                // USART/UART reference clock assumed when configuring baud rate setup
     *                                     // (0 = Use current configured reference clock for configuring baud rate).
     *   config.baudrate = 115200          // Desired baudrate (115200 bits/s).
     *   config.oversampling = usartOVS16  // Oversampling used (16x oversampling).
     *   config.databits = usartDatabits8  // Number of data bits in frame (8 data bits).
     *   config.parity = usartNoParity     // Parity mode to use (no parity).
     *   config.stopbits = usartStopbits1  // Number of stop bits to use (1 stop bit).
     *   config.mvdis = false              // Majority Vote Disable for 16x, 8x and 6x oversampling modes (Do not disable majority vote).
     *   config.prsRxEnable = false        // Enable USART Rx via PRS (Not USART PRS input mode).
     *   config.prsRxCh = 0                // Select PRS channel for USART Rx. (Only valid if prsRxEnable is true - PRS channel 0).
     *   config.autoCsEnable = false       // Auto CS enabling (Auto CS functionality enable/disable switch - disabled).
     */

    USART_InitAsync_TypeDef config = USART_INITASYNC_DEFAULT;

    /* Enable oscillator to USARTx modules */
    if (BG96_UART == USART0) CMU_ClockEnable(cmuClock_USART0, true);
    else if (BG96_UART == USART1) CMU_ClockEnable(cmuClock_USART1, true);

    /* Set pin modes for UART TX and RX pins */
    if (BG96_UART == USART0)
    {
        switch (BG96_UART_LOC)
        {
            case 0:
                GPIO_PinModeSet(gpioPortE, 11, gpioModeInput, 0);    /* RX */
                GPIO_PinModeSet(gpioPortE, 10, gpioModePushPull, 1); /* TX */
                break;
            case 2:
                GPIO_PinModeSet(gpioPortC, 10, gpioModeInput, 0);    /* RX */
                /* No TX pin in this mode */
                break;
            case 3:
                GPIO_PinModeSet(gpioPortE, 12, gpioModeInput, 0);    /* RX */
                GPIO_PinModeSet(gpioPortE, 13, gpioModePushPull, 1); /* TX */
                break;
            case 4:
                GPIO_PinModeSet(gpioPortB, 8, gpioModeInput, 0);     /* RX */
                GPIO_PinModeSet(gpioPortB, 7, gpioModePushPull, 1);  /* TX */
                break;
            case 5:
            case 6:
                GPIO_PinModeSet(gpioPortC, 1, gpioModeInput, 0);     /* RX */
                GPIO_PinModeSet(gpioPortC, 0, gpioModePushPull, 1);  /* TX */
                break;
            /* default: */
                /* No default */
        }
    }
    else if (BG96_UART == USART1)
    {
        switch (BG96_UART_LOC)
        {
            case 0:
                GPIO_PinModeSet(gpioPortC, 1, gpioModeInput, 0);     /* RX */
                GPIO_PinModeSet(gpioPortC, 0, gpioModePushPull, 1);  /* TX */
                break;
            case 2:
            case 3:
                GPIO_PinModeSet(gpioPortD, 6, gpioModeInput, 0);     /* RX */
                GPIO_PinModeSet(gpioPortD, 7, gpioModePushPull, 1);  /* TX */
                break;
            case 4:
                GPIO_PinModeSet(gpioPortA, 0, gpioModeInput, 0);     /* RX */
                GPIO_PinModeSet(gpioPortF, 2, gpioModePushPull, 1);  /* TX */
                break;
            case 5:
                GPIO_PinModeSet(gpioPortC, 2, gpioModeInput, 0);     /* RX */
                GPIO_PinModeSet(gpioPortC, 1, gpioModePushPull, 1);  /* TX */
                break;
            /* default: */
                /* No default */
        }
    }

    /* Initialize USART asynchronous mode */
    USART_InitAsync(BG96_UART, &config);

    /* Route pins */
    switch (BG96_UART_LOC)
    {
        case 0:
            BG96_UART->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_LOC0;
            break;
        case 1:
            BG96_UART->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_LOC1;
            break;
        case 2:
            BG96_UART->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_LOC2;
            break;
        case 3:
            BG96_UART->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_LOC3;
            break;
        case 4:
            BG96_UART->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_LOC4;
            break;
        case 5:
            BG96_UART->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_LOC5;
            break;
        case 6:
            BG96_UART->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_LOC6;
            break;
        default:
            BG96_UART->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_DEFAULT;
    }

}

powerBG96()

void powerBG96

(

void

)

Method to enable the power key for 100ms to enable/disable the module.

Definition at line 579 of file BG96_at_driver.c.

{
    /* Set PWK high for 100ms */
    GPIO_PinOutSet(BG96_PWRKEY_PORT, BG96_PWRKEY_PIN);
    delay(100);
    GPIO_PinOutClear(BG96_PWRKEY_PORT, BG96_PWRKEY_PIN);
}

readResponse()

void readResponse

(

char *

buf

)

Read a string (char array) from USARTx.

Note

The reading stops when a "LF" (Line Feed) character is received or the maximum length (UART_BUFFER_SIZE) is reached.

Parameters

[in]

buf

The buffer to put the resulting string in. This needs to have a length of UART_BUFFER_SIZE for the function to work properly: char buf[UART_BUFFER_SIZE];!

Definition at line 647 of file BG96_at_driver.c.

{
    for (uint32_t i = 0; i < UART_BUFFER_SIZE - 1 ; i++ )
    {
        char localBuffer = USART_Rx(BG96_UART);

        /* Check if a LF character is received */
        if (localBuffer == '\n')
        {
            /* End with a null termination character */
            buf[i] = '\0';
            break;
        }
        else
        {
            buf[i] = localBuffer;
        }
    }
}

sendCMD()

void sendCMD

(

char *

message

)

Print a string (char array) to USARTx.

Note

If the input is not a string (ex.: "Hello world!") but a char array, the input message (array) needs to end with NULL ("\0")!

Parameters

[in]

message

The string to print to USARTx.

Definition at line 623 of file BG96_at_driver.c.

{
    /* "message[i] != 0" makes "uint32_t length = strlen(message)"
     * not necessary (given string MUST be terminated by NULL for this to work) */
    for (uint32_t i = 0; message[i] != 0; i++)
    {
        USART_Tx(BG96_UART, message[i]);
    }
}

sendMeasurements()

void sendMeasurements

(

MeasurementData_t *

data

)

Send measurements to the cloud using NB-IoT.

Parameters

[in]

data

The measurements to send

Definition at line 230 of file BG96_at_driver.c.

{
    /* Begin transmission */
    bool continueCode = transmissionBegin(true);

    if (continueCode)
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbprintln("INFO: Sending the following values to the cloud:");
        dbprint("      t1 = ");
        dbprintInt(data->t1);
        dbprint(", t2 = ");
        dbprintInt(data->t2);
        dbprint(", p = ");
        dbprintInt(data->p);
        dbprint(", n1 = ");
        dbprintInt(data->n1);
        dbprint(", n2 = ");
        dbprintInt(data->n2);
        dbprint(", r = ");
        dbprintInt(data->r);
        dbprint(", c = ");
        dbprintlnInt(data->c);
#endif /* DEBUG_DBPRINT */

        /* Convert values */
        char t1_hex[9]; // TODO: Use less chars here because we use uint16_t (check if values aren't bigger than 0xFFFF)
        uint32_to_charHex(data->t1, t1_hex); // TODO: Make sure we can send negative values!
        char t2_hex[9];
        uint32_to_charHex(data->t2, t2_hex); // TODO: Make sure we can send negative values!
        char p_hex[9];
        uint32_to_charHex(data->p, p_hex);
        char n1_hex[9];
        uint32_to_charHex(data->n1, n1_hex);
        char n2_hex[9];
        uint32_to_charHex(data->n2, n2_hex);
        char r_hex[9];
        uint32_to_charHex(data->r, r_hex);
        char c_hex[9];
        uint32_to_charHex(data->c, c_hex);

        /*
         * http://cbor.me/
         *
         * Diagnostic:
         * {
         *   "t1": 2345,
         *   "t2": 2345,
         *   "p":  2345,
         *   "n1": 2345,
         *   "n2": 2345,
         *   "r":  2345,
         *   "c":  2345
         * }
         *
         * CBOR:
         * A7         # map(7)
         *    62      # text(2)
         *       7431 # "t1"
         *    19 0929 # unsigned(2345) (19 ~ uint16_t)
         *    62      # text(2)
         *       7432 # "t2"
         *    19 0929 # unsigned(2345)
         *    61      # text(1)
         *       70   # "p"
         *    19 0929 # unsigned(2345)
         *    62      # text(2)
         *       6E31 # "n1"
         *    19 0929 # unsigned(2345)
         *    62      # text(2)
         *       6E32 # "n2"
         *    19 0929 # unsigned(2345)
         *    61      # text(1)
         *       72   # "r"
         *    19 0929 # unsigned(2345)
         *    61      # text(1)
         *       63   # "c"
         *    19 0929 # unsigned(2345)
         */

        /* Send commands */
        sendCMD("AT+QISENDEX=0,\"");
        sendCMD(DEVICE_ID_hex);
        sendCMD("0a"); /* \n */
        sendCMD(DEVICE_TOKEN_hex);
        sendCMD("0a"); /* \n */
        sendCMD("a762743119"); /* 0xa6 = map(7), 0x62 = text(2), 0x7431 = "t1", 0x19 = uint16_t */
        sendCMD(t1_hex);
        sendCMD("62743219"); /* 0x62 = text(2), 0x7432 = "t2", 0x19 = uint16_t */
        sendCMD(t2_hex);
        sendCMD("617019"); /* 0x61 = text(1), 0x70 = "p", 0x19 = uint16_t */
        sendCMD(p_hex);
        sendCMD("626e3119"); /* 0x62 = text(2), 0x6e31 = "n1", 0x19 = uint16_t */
        sendCMD(n1_hex);
        sendCMD("626e3219"); /* 0x62 = text(2), 0x6e32 = "n2", 0x19 = uint16_t */
        sendCMD(n2_hex);
        sendCMD("617219"); /* 0x61 = text(1), 0x72 = "r", 0x19 = uint16_t */
        sendCMD(r_hex);
        sendCMD("616319"); /* 0x61 = text(1), 0x63 = "c", 0x19 = uint16_t */
        sendCMD(c_hex);
        sendCMD("\"\n\r");

        /* Wait for the correct response */
        continueCode = waitForResponse("SEND OK", 5);
    }

    /* End transmission */
    continueCode = transmissionEnd(continueCode);
}

sendPulse()

void sendPulse	(	uint8_t	number,
		uint8_t	pulse
	)

Send current pulses to the cloud using NB-IoT.

Parameters

[in]	number	0 - PULSE0 selected. 1 - PULSE0 selected.
[in]	pulse	The pulse value to send

Definition at line 412 of file BG96_at_driver.c.

{
    /* Begin transmission */
    bool continueCode = transmissionBegin(true);

    if (continueCode)
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbprintln("INFO: Sending pulse(s) [");
        dbprintInt(pulse);
        dbprintln("] to the cloud.");
#endif /* DEBUG_DBPRINT */

        /* Convert values */
        char pulse_hex[9]; // TODO: Use less chars here because we use uint16_t (check if values aren't bigger than 0xFFFF)
        uint32_to_charHex(pulse, pulse_hex);

        /*
         * http://cbor.me/
         *
         * Diagnostic:
         * {
         *   "p1": 2345
         * }
         *
         * CBOR:
         * A1         # map(1)
         *    62      # text(2)
         *       7031 # "p1"
         *    19 0929 # unsigned(2345) (19 ~ uint16_t)
         */

        /* Send commands */
        sendCMD("AT+QISENDEX=0,\"");
        sendCMD(DEVICE_ID_hex);
        sendCMD("0a"); /* \n */
        sendCMD(DEVICE_TOKEN_hex);
        sendCMD("0a"); /* \n */
        if (number == 0) sendCMD("a162703119"); /* 0xa1 = map(1), 0x62 = text(2), 0x7031 = "p1", 0x19 = uint16_t */
        else if (number == 1) sendCMD("a162703219"); /* 0xa1 = map(1), 0x62 = text(2), 0x7032 = "p2", 0x19 = uint16_t */
        sendCMD(pulse_hex);
        sendCMD("\"\n\r");

        /* Wait for the correct response */
        continueCode = waitForResponse("SEND OK", 5);
    }

    /* End transmission */
    continueCode = transmissionEnd(continueCode);
}

sendStatus()

void sendStatus

(

int8_t

status

)

Send status to the cloud using NB-IoT.

Parameters

[in]

status

The status value to send

Definition at line 349 of file BG96_at_driver.c.

{
    /* Begin transmission */
    bool continueCode = transmissionBegin(true);

    if (continueCode)
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbprintln("INFO: Sending status ");
        dbprintInt(status);
        dbprintln(" to the cloud.");
#endif /* DEBUG_DBPRINT */

        /* Convert values */
        char s_hex[9]; // TODO: Use less chars here because we use uint16_t (check if values aren't bigger than 0xFFFF)
        uint32_to_charHex(status, s_hex); // TODO: Make sure we can send negative values!

        /*
         * http://cbor.me/
         *
         * Diagnostic:
         * {
         *   "s": 2345
         * }
         *
         * CBOR:
         * A1         # map(1)
         *    61      # text(1)
         *       73   # "s"
         *    19 0929 # unsigned(2345) (19 ~ uint16_t)
         */

        /* Send commands */
        sendCMD("AT+QISENDEX=0,\"");
        sendCMD(DEVICE_ID_hex);
        sendCMD("0a"); /* \n */
        sendCMD(DEVICE_TOKEN_hex);
        sendCMD("0a"); /* \n */
        sendCMD("a1617319"); /* 0xa1 = map(1), 0x61 = text(1), 0x73 = "s", 0x19 = uint16_t */
        sendCMD(s_hex);
        sendCMD("\"\n\r");

        /* Wait for the correct response */
        continueCode = waitForResponse("SEND OK", 5);
    }

    /* End transmission */
    continueCode = transmissionEnd(continueCode);
}

transmissionBegin()

static bool transmissionBegin ( bool  continueCode )

static

Code for the start of a NB-IoT transmission.

Note

This is a static method because it's only internally used in this file and called by other methods if necessary.

Parameters

[in]

continueCode

Functionality to skip code if previous code failed.

Returns

If the code finished okay/failed.

Definition at line 479 of file BG96_at_driver.c.

{
#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
    dbinfo("Powering on BG96");
#endif /* DEBUG_DBPRINT */

    powerBG96(); /* Power up BG96 */
    continueCode = waitForResponse("APP RDY", 5); /* Wait for the correct response */

    sleep(8); // TODO: Wait some time before activating PDP?

    if (continueCode)
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbinfo("Sending Activate PDP command...");
#endif /* DEBUG_DBPRINT */

        sendCMD("AT+QIACT=1\r");
        continueCode = waitForResponse("OK", 5); /* Wait for the correct response */

        while (!continueCode) // TODO: update timeout functionality
        {
            sleep(2); /* Sleep for 2s */
            sendCMD("AT+QIACT=1\r");
            continueCode = waitForResponse("OK", 5); /* Wait for the correct response */
        }
    }


    if (continueCode)
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbinfo("Sending Create UDP command...");
#endif /* DEBUG_DBPRINT */

        sendCMD("AT+QIOPEN=1,0,\"UDP\",\"40.68.172.187\",8891\r"); // BEFORE: api.allthingstalk.io
        continueCode = waitForResponse("OK", 5); /* Wait for the correct response */
        continueCode = waitForResponse("+QIOPEN: 0,0", 5); /* Wait for the correct response */
    }

    return (continueCode);
}

transmissionEnd()

static bool transmissionEnd ( bool  continueCode )

static

Code for the end of a NB-IoT transmission.

Note

This is a static method because it's only internally used in this file and called by other methods if necessary.

Parameters

[in]

continueCode

Functionality to skip code if previous code failed.

Returns

If the code finished okay/failed.

Definition at line 539 of file BG96_at_driver.c.

{
#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
    dbinfo("Sending Deactivate PDP command...");
#endif /* DEBUG_DBPRINT */

    sendCMD("AT+QIDEACT=1\r");
    continueCode = waitForResponse("OK", 5); /* Wait for the correct response */

    if (continueCode)
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbinfo("Sending Power down command...");
#endif /* DEBUG_DBPRINT */

        sendCMD("AT+QPOWD\r");
        continueCode = waitForResponse("OK", 5); /* Wait for the correct response */
        continueCode = waitForResponse("POWERED DOWN", 5); /* Wait for the correct response */
    }
    else
    {

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
        dbwarn("Powering down BG96 using hardware...");
#endif /* DEBUG_DBPRINT */

        powerBG96();
    }

    sleep(2); // TODO: Wait less

    return (continueCode);
}

waitForResponse()

bool waitForResponse	(	char *	response,
		uint8_t	timeout
	)

Wait for the correct response using sleep/timeout functionality.

Parameters

[in]	response	The correct response to look for.
[in]	timeout	The timeout value.

Returns

• true - Module responded correctly before timeout.
• false - The module timed out or gave only incorrect responses.

Definition at line 682 of file BG96_at_driver.c.

{
    uint8_t i = 0;

    char rxBuf[UART_BUFFER_SIZE];

    while (i < timeout) // TODO: update timeout functionality
    {
        readResponse(rxBuf);

        if (stringStartsWith((char *)rxBuf, response))
        {

            // Printing breaks timing!
//#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
//          dbprint("INFO: > ");
//          dbprint(response);
//          dbprintln("");
//#endif /* DEBUG_DBPRINT */

            return(true);
        }
        else if (stringStartsWith((char *)rxBuf, "ERROR"))
        {

            // Printing breaks timing!
//#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
//          dbcrit(" > ERROR");
//#endif /* DEBUG_DBPRINT */

            return(false);
        }

        i++;
    }

#if DEBUG_DBPRINT == 1 /* DEBUG_DBPRINT */
    dbprint_color("CRIT: Timeout reached while waiting on ", RED);
    dbprint(response);
    dbprint_color(" command", RED);
    dbprintln("");
#endif /* DEBUG_DBPRINT */

    return(false);
}

Variable Documentation

DEVICE_ID_hex

char DEVICE_ID_hex[2 *(sizeof(DEVICE_ID) -1)+1]

Definition at line 68 of file BG96_at_driver.c.

DEVICE_TOKEN_hex

char DEVICE_TOKEN_hex[2 *(sizeof(DEVICE_TOKEN) -1)+1]

Definition at line 69 of file BG96_at_driver.c.