main.c

Go to the documentation of this file.

/** \file main.c
 *  \brief Nordic UART Bridge Service (NUS) sample
 *
 * \copyright (c) 2018 Nordic Semiconductor ASA
 *
 * \note SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#if CONFIG_SERIAL
#include "uart_async_adapter.h"
#include <zephyr/drivers/uart.h>
#endif
 
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <zephyr/usb/usb_device.h>
 
#include <soc.h>
#include <zephyr/device.h>
#include <zephyr/devicetree.h>
 
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/gatt.h>
#include <zephyr/bluetooth/hci.h>
#include <zephyr/bluetooth/uuid.h>
 
#include <bluetooth/services/nus.h>
 
#include <dk_buttons_and_leds.h>
 
#include <zephyr/settings/settings.h>
 
#include <stdio.h>
#include <zephyr/drivers/gpio.h>
 
#include "jfet_files/jfet_common.h"
#include "mainpage.h"
#include "watchdog/watchdog_app.h"
#include <zephyr/logging/log.h>
 
#include "jfet_files/HDC2080.h"
#include "ncs_version.h"
// #include <date_time.h>
#include <stdlib.h>
#include <time.h>
#include <zephyr/drivers/i2c.h>
 
// #define NO_UART0 //!< define to disable UART0 for lower power consumption
//  #ifdef NO_UART0
#include <zephyr/pm/device.h>
// #endif
 
// #define LOG_MODULE_NAME BLE_Prototype
// LOG_MODULE_REGISTER(LOG_MODULE_NAME);
// LOG_MODULE_REGISTER(BLE_Prototype, LOG_LEVEL_DBG);
LOG_MODULE_REGISTER(main, LOG_LEVEL_DBG);
 
#include <zephyr/drivers/gpio.h>
 
#define STACKSIZE CONFIG_BT_NUS_THREAD_STACK_SIZE //!< stack size for main thread
#define PRIORITY 7                                //!< priority for main thread
 
#define DEVICE_NAME CONFIG_BT_DEVICE_NAME         //!< device name defined in prj.conf
#define DEVICE_NAME_LEN (sizeof(DEVICE_NAME) - 1) //!< length of device name
 
#define RUN_STATUS_LED DK_LED1      //!< LED to indicate the application is running
#define RUN_LED_BLINK_INTERVAL 1000 //!< interval for blinking the run status LED in milliseconds
 
#define CON_STATUS_LED DK_LED2 //!< LED to indicate the BLE connection status
 
#define KEY_PASSKEY_ACCEPT DK_BTN1_MSK //!< Button used to accept a pairing passkey
#define KEY_PASSKEY_REJECT DK_BTN2_MSK //!< Button used to reject a pairing passkey
 
#define UART_BUF_SIZE CONFIG_BT_NUS_UART_BUFFER_SIZE //!< size of the buffer for UART data
#define UART_WAIT_FOR_BUF_DELAY K_MSEC(50)           //!< delay to wait for UART buffer availability in milliseconds
#define UART_WAIT_FOR_RX CONFIG_BT_NUS_UART_RX_WAIT_TIME
 
/* start I2C test */
#if 1
#if DT_NODE_HAS_STATUS(DT_ALIAS(i2c_0), okay)   //!< check if i2c_0 alias is okay in devicetree
#define I2C_DEV_NODE DT_ALIAS(i2c_0)            //!< if i2c_0 alias is okay, set I2C_DEV_NODE to i2c_0 alias
#elif DT_NODE_HAS_STATUS(DT_ALIAS(i2c_1), okay) //!< check if i2c_1 alias is okay in devicetree
#define I2C_DEV_NODE DT_ALIAS(i2c_1)
#elif DT_NODE_HAS_STATUS(DT_ALIAS(i2c_2), okay) //!< check if i2c_2 alias is okay in devicetree
#define I2C_DEV_NODE DT_ALIAS(i2c_2)
#else
#error "Please set the correct I2C device"
#endif
#endif
 
#if CONFIG_SERIAL
#if 1
#if DT_NODE_HAS_STATUS(DT_ALIAS(uart0), okay)
#define UART0_DEV_NODE DT_ALIAS(uart0)
#else
// #error "Please set the correct UART0 device"
#warning "UART0 not available"
#endif
const struct device *const uart0_dev = DEVICE_DT_GET(UART0_DEV_NODE); //!< pointer to UART0 (CLI) device
#endif
#endif
 
/* prototypes */
void hdc2080RdyHandler(void);
 
const struct device *const i2c_dev = DEVICE_DT_GET(I2C_DEV_NODE); //!< get the device structure for the I2C device defined by I2C_DEV_NODE
/* end I2C test */
 
static K_SEM_DEFINE(ble_init_ok, 0,
                    1);           //!< semaphore to indicate when BLE initialization is complete and the system is ready for BLE operations
K_SEM_DEFINE(hdc_rdy_seen, 0, 1); //!< semaphore to indicate when the HDC2080 sensor ready signal has been seen
K_SEM_DEFINE(sw2_rdy_seen, 0, 1); //!< semaphore to indicate when the SW2 button press has been seen
K_SEM_DEFINE(cli_cmd_seen, 0, 1); //!< semaphore to indicate when a CLI command has been received and is ready for processing
K_SEM_DEFINE(uart_rx_disabled_sem, 0, 1); //!< semaphore to indicate UART RX is disabled
 
static struct bt_conn *current_conn; //!< pointer to the current BLE connection structure, used to keep track of the active BLE connection
                                     //!< for sending data and managing connection state
static struct bt_conn *auth_conn; //!< pointer to the BLE connection structure that is currently undergoing authentication, used to manage
                                  //!< pairing and security procedures separately from the active connection used for data transfer
static struct k_work
    adv_work; //!< work item for handling BLE advertising operations, used to schedule advertising tasks in the system workqueue
 
/* start dummy timer setup */
/* commentthis line to yse GDC hardware - uncomment if using simuated interrupt */
// #define SIMULATED_INTERRUPT
#ifdef SIMULATED_INTERRUPT
struct k_timer simulated_interrupt_timer; //!< timer to simulate HDC2080 interrupt
 
/*!
 * \fn void simulated_interrupt_handler(struct k_work *work)
 *
 * \brief work function GDC2080 simulated interrupt handler
 *
 * simulates a HDC2080 interrupt for testing
 *
 * \param work ptr to work funtion
 *
 *
 */
void simulated_interrupt_handler(struct k_work *work) {
  char str[80];
  static int count = 0;
 
  sprintf(str, "count: %d", count++);
  myPrintkI("HDC Interrupt %s\r\n", str);
  if (bt_nus_send(NULL, str, strlen(str))) {
    myPrintkE("Failed to send data over BLE connection\r\n");
  }
}
 
K_WORK_DEFINE(simulated_interrupt_work, simulated_interrupt_handler);
 
/*!
 * \fn void simulated_interrupt_handler(struct k_timer *dummy)
 *
 * \brief simulated interrupt handler
 *
 * timer handler jsimulated interrupt
 *
 * \param dummy pointer to a timer sturcture
 *
 *
 */
void simulated_interrupt_timer_handler(struct k_timer *dummy) { k_work_submit(&simulated_interrupt_work); }
#endif
/* end dummy timer setup */
 
/* start GPIO test */
 
#if 1
#define BATEN_NODE DT_ALIAS(baten)        //!< check if baten alias is okay in devicetree and set BATEN_NODE to baten alias
#if !DT_NODE_HAS_STATUS(BATEN_NODE, okay) //!< check if BATEN_NODE is okay in devicetree
#error "BATEN alias is not defined"
#endif
const struct gpio_dt_spec baten =
    GPIO_DT_SPEC_GET_OR(BATEN_NODE, gpios, {0}); //!< get the GPIO specification for the BATEN pin defined by BATEN_NODE
#endif
 
#if 1
#define HDC2080RDY_NODE                                                                                                                    \
  DT_ALIAS(hdc2080rdy) //!< check if hdc2080rdy alias is okay in devicetree and set HDC2080RDY_NODE to hdc2080rdy alias
#if !DT_NODE_HAS_STATUS(HDC2080RDY_NODE, okay) //!< check if HDC2080RDY_NODE is okay in devicetree
#error "HDC2080 alias is not defined"
#endif
static const struct gpio_dt_spec hdc2080 =
    GPIO_DT_SPEC_GET_OR(HDC2080RDY_NODE, gpios, {0}); //!< get the GPIO specification for the HDC2080 ready pin defined by HDC2080RDY_NODE
static struct gpio_callback hdc2080_cb_data;          //!< GPIO callback structure for handling HDC2080 ready pin interrupts
#endif
 
#if 1
#define SW2_NODE DT_ALIAS(sw2input)     //!< check if sw2input alias is okay in devicetree and set SW2_NODE to sw2input alias
#if !DT_NODE_HAS_STATUS(SW2_NODE, okay) //!< check if SW2_NODE is okay in devicetree
#error "SW2 alias is not defined"
#endif
static const struct gpio_dt_spec sw2 =
    GPIO_DT_SPEC_GET_OR(SW2_NODE, gpios, {0}); //!< get the GPIO specification for the SW2 button pin defined by SW2_NODE
static struct gpio_callback sw2_cb_data;       //!< GPIO callback structure for handling SW2 button pin interrupts
#endif
 
/* end GPIO test */
 
/* start SPI test */
#include <zephyr/drivers/spi.h>
 
/* end SPI test */
 
/* start ADC test */
#include <math.h>
#include <nrfx_saadc.h>
#include <zephyr/drivers/adc.h>
#define ADC_BUFFER_SIZE 1 //!< number of ADC channels to read
 
#if DT_NODE_HAS_STATUS(DT_ALIAS(adc), okay) //!< check if adc alias is okay in devicetree and set ADC_DEV_NODE to adc alias
#define ADC_DEV_NODE DT_ALIAS(adc)          //!< if adc alias is okay, set ADC_DEV_NODE to adc alias
#else
#error "Please set the correct ADC device"
#endif
 
////#define ADC_DEVICE_NAME DT_ADC_0_NAME
#define ADC_RESOLUTION 10 //!< resolution for ADC readings in bits (e.g., 10 bits for values from 0 to 1023)
#define ADC_GAIN                                                                                                                           \
  ADC_GAIN_1_6 //!< gain setting for ADC readings, set to 1/6 to allow for a wider input voltage range (e.g., up to 3.6V with a 3.3V
               //!< reference)
#define ADC_REFERENCE                                                                                                                      \
  ADC_REF_INTERNAL //!< reference voltage for ADC readings, set to internal reference for stable and consistent measurements
#define ADC_ACQUISITION_TIME                                                                                                               \
  ADC_ACQ_TIME(ADC_ACQ_TIME_MICROSECONDS, 10) //!< acquisition time for ADC readings, set to 10 microseconds to allow for accurate sampling
                                              //!< of the input signal while minimizing noise and power consumption
#define ADC_1ST_CHANNEL_ID 0 //!< channel ID for the first ADC channel to read, set to 0 for the first channel (e.g., AIN0 on nRF52832)
#define ADC_1ST_CHANNEL_INPUT                                                                                                              \
  NRF_SAADC_INPUT_AIN0 //!< input selection for the first ADC channel, set to AIN0 for the first analog input on nRF52832 (e.g., connected
                       //!< to a sensor output or battery voltage)
#define ADC_2ND_CHANNEL_ID 1 //!< channel ID for the second ADC channel to read, set to 1 for the second channel (e.g., AIN1 on nRF52832)
#define ADC_2ND_CHANNEL_INPUT                                                                                                              \
  NRF_SAADC_INPUT_AIN1 //!< input selection for the second ADC channel, set to AIN1 for the second analog input on nRF52832 (e.g., connected
                       //!< to a different sensor output or reference voltage)
#define ADC_3RD_CHANNEL_ID 2 //!< channel ID for the third ADC channel to read, set to 2 for the third channel (e.g., AIN2 on nRF52832)
#define ADC_3RD_CHANNEL_INPUT                                                                                                              \
  NRF_SAADC_INPUT_AIN2 //!< input selection for the third ADC channel, set to AIN2 for the third analog input on nRF52832 (e.g., connected
                       //!< to a different sensor output or reference voltage)
#define ADC_4TH_CHANNEL_ID 3 //!< channel ID for the fourth ADC channel to read, set to 3 for the fourth channel (e.g., AIN3 on nRF52832)
#define ADC_4TH_CHANNEL_INPUT                                                                                                              \
  NRF_SAADC_INPUT_AIN3 //!< input selection for the fourth ADC channel, set to AIN3 for the fourth analog input on nRF52832 (e.g., connected
                       //!< to a different sensor output or reference voltage)
#define ADC_5TH_CHANNEL_ID 4 //!< channel ID for the fifth ADC channel to read, set to 4 for the fifth channel (e.g., AIN4 on nRF52832)
#define ADC_5TH_CHANNEL_INPUT                                                                                                              \
  NRF_SAADC_INPUT_AIN4 //!< input selection for the fifth ADC channel, set to AIN4 for the fifth analog input on nRF52832 (e.g., connected
                       //!< to a different sensor output or reference voltage)
#define ADC_6ST_CHANNEL_ID 5 //!< channel ID for the sixth ADC channel to read, set to 5 for the sixth channel (e.g., AIN5 on nRF52832)
#define ADC_6ST_CHANNEL_INPUT                                                                                                              \
  NRF_SAADC_INPUT_AIN5 //!< input selection for the sixth ADC channel, set to AIN5 for the sixth analog input on nRF52832 (e.g., connected
                       //!< to a different sensor output or reference voltage)
 
const struct device *const adc_dev = DEVICE_DT_GET(ADC_DEV_NODE); //!< get the device structure for the ADC device defined by ADC_DEV_NODE
 
#if 0
static const struct adc_channel_cfg m_4th_channel_cfg =   //!< ADC config for ADC input
{
    .gain = ADC_GAIN,
    .reference = ADC_REFERENCE,
    .acquisition_time = ADC_ACQUISITION_TIME,
    .channel_id = ADC_4TH_CHANNEL_ID,
#if defined(CONFIG_ADC_CONFIGURABLE_INPUTS)
    .input_positive = ADC_4TH_CHANNEL_INPUT,
#endif
};
#endif
 
#if 0
static const struct adc_channel_cfg m_3rd_channel_cfg = 
{
    .gain = ADC_GAIN,
    .reference = ADC_REFERENCE,
    .acquisition_time = ADC_ACQUISITION_TIME,
    .channel_id = ADC_3RD_CHANNEL_ID,
#if defined(CONFIG_ADC_CONFIGURABLE_INPUTS)
    .input_positive = ADC_3RD_CHANNEL_INPUT,
#endif
};
#endif
 
#if 0
static const struct adc_channel_cfg m_2nd_channel_cfg =   //!< ADC config for Battery input
{
    .gain = ADC_GAIN,
    .reference = ADC_REFERENCE,
    .acquisition_time = ADC_ACQUISITION_TIME,
    .channel_id = ADC_2ND_CHANNEL_ID,
#if defined(CONFIG_ADC_CONFIGURABLE_INPUTS)
    .input_positive = ADC_2ND_CHANNEL_INPUT,
#endif
};
#endif
 
#if 1
/*!
 * \brief ADC configuration for the first channel
 * This structure defines the configuration for the first ADC channel, including gain, reference voltage, acquisition time, channel ID, and
 * input selection. It is used to set up the ADC for reading from the specified channel with the desired settings.
 */
static const struct adc_channel_cfg m_1st_channel_cfg = {
    .gain = ADC_GAIN,
    .reference = ADC_REFERENCE,
    .acquisition_time = ADC_ACQUISITION_TIME,
    .channel_id = ADC_1ST_CHANNEL_ID,
#if defined(CONFIG_ADC_CONFIGURABLE_INPUTS)
    .input_positive = ADC_1ST_CHANNEL_INPUT,
#endif
};
#endif
 
static int16_t m_sample_buffer[ADC_BUFFER_SIZE]; //!< buffer to receive ADC data from configured channels
 
#define ADC_REF_MV 3600U
#define ADC_DIV_MV 1000U
#define ADC_MAX_VAL ((1U << ADC_RESOLUTION) - 1U)
 
static const float adc_volts_per_step = (float)ADC_REF_MV / ((float)ADC_MAX_VAL * (float)ADC_DIV_MV);
 
/** \fn static inline float adc_raw_to_voltage(uint16_t raw)
 *
 * \brief Convert raw ADC reading to voltage in volts.
 *
 * \param raw Raw ADC sample value (integer from 0..ADC_MAX_VAL)
 * \return Voltage corresponding to the raw ADC value in volts (float)
 *
 * Uses the precomputed adc_volts_per_step factor which incorporates the
 * reference voltage (ADC_REF_MV), ADC resolution and any divider (ADC_DIV_MV).
 */
static inline float adc_raw_to_voltage(uint16_t raw) { return (float)raw * adc_volts_per_step; }
 
/*!
 * \fn int adc_sample(void)
 *
 * \brief get a single reading from ADC channel
 *
 * will read ADC_1ST_CHANNEL_ID\n
 * resoultion set to ADC_RESOLUTION in millivolts\n
 * will printout floating point value based on 3.6V max\n
 *
 * \return ADC_RESOLUTION value on ADC_1ST_CHANNEL_ID if pass or -1 if failed\n
 */
int adc_sample(void) {
  int ret;
  const struct adc_sequence sequence = {
      .channels = BIT(ADC_1ST_CHANNEL_ID),
      .buffer = m_sample_buffer,
      .buffer_size = sizeof(m_sample_buffer),
      .resolution = ADC_RESOLUTION,
  };
 
  if (!adc_dev) {
    return -ENODEV;
  }
 
  ret = adc_read(adc_dev, &sequence);
  if (ret != 0) {
    myPrintkE("ADC read err: %d\n", ret);
    return ret;
  }
 
  for (int i = 0; i < ADC_BUFFER_SIZE; i++) {
    adc_voltage[i] = adc_raw_to_voltage(m_sample_buffer[i]);
  }
 
  return 0;
}
 
/* end ADC test */
 
char device_name[40];    //!< buffer to hold the device name string, used for BLE advertising and identification
uint8_t device_name_len; //!< length of the device name string, used to ensure proper formatting and transmission in BLE advertising packets
 
/* enums */
/*!
 * \brief Valid command indexes
 */
enum COMMANDS {
  CR,
  NONE,
};
 
char const *validCmds[] = //!< array of valid commands - case insensitive
    {
        "cr",
        "END",
};
 
#if CONFIG_SERIAL
static const struct device *uart =
    DEVICE_DT_GET(DT_CHOSEN(nordic_nus_uart)); //!< get the device structure for the UART device defined by the nordic_nus_uart alias in
                                               //!< devicetree, used for UART communication with the Nordic UART Service (NUS)
static struct k_work_delayable
    uart_work; //!< delayable work item for handling UART operations, used to schedule UART tasks in the system workqueue with a delay when
               //!< necessary (e.g., waiting for buffer availability or processing received data)
#endif
 
struct uart_data_t {
  void *fifo_reserved;
  uint8_t data[UART_BUF_SIZE];
  uint16_t len;
}; //!< structure to hold UART data and metadata, including a reserved field for FIFO management, a data buffer for UART communication, and
   //!< a length field to track the amount of valid data in the buffer
 
static K_FIFO_DEFINE(fifo_uart_tx_data); //!< FIFO queue for UART data to be transmitted, used to manage outgoing UART data and ensure
                                         //!< proper sequencing and flow control
static K_FIFO_DEFINE(fifo_uart_rx_data); //!< FIFO queue for UART data that has been received, used to manage incoming UART data and ensure
                                         //!< proper processing and flow control
 
// static const struct bt_data ad[] =
//{
//  BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
//  BT_DATA(BT_DATA_NAME_COMPLETE, DEVICE_NAME, DEVICE_NAME_LEN),
// };
 
static struct bt_data ad[2] = {
    BT_DATA_BYTES(BT_DATA_FLAGS, (BT_LE_AD_GENERAL | BT_LE_AD_NO_BREDR)),
    BT_DATA(BT_DATA_NAME_COMPLETE, DEVICE_NAME, DEVICE_NAME_LEN),
};
 
static const struct bt_data sd[] = {
    BT_DATA_BYTES(BT_DATA_UUID128_ALL, BT_UUID_NUS_VAL),
};
 
#if CONFIG_SERIAL
#if CONFIG_BT_NUS_UART_ASYNC_ADAPTER
UART_ASYNC_ADAPTER_INST_DEFINE(async_adapter);
#else
static const struct device *const async_adapter;
#endif
 
/*! \fn static void uart_cb(const struct device *dev, struct uart_event *evt, void *user_data)
 *
 * \brief UART callback function to handle UART events
 *
 * This function is called by the UART driver when specific UART events occur, such as data transmission completion, data reception, or
 * errors. It processes the events and manages the UART data buffers accordingly.
 *
 * \param dev pointer to the UART device structure that triggered the event
 * \param evt pointer to the uart_event structure containing details about the event
 * \param user_data pointer to user-defined data (not used in this implementation)
 *
 * The function handles various UART events, including:
 * - UART_TX_DONE: Indicates that a UART transmission has completed. The function retrieves the transmitted buffer, frees it, and checks for
 * any pending data to transmit.
 * - UART_RX_RDY: Indicates that received data is ready for processing. The function updates the length of received data and checks for
 * newline characters to determine if reception should be disabled.
 * - UART_RX_DISABLED: Indicates that reception has been disabled. The function allocates a new buffer for receiving data and re-enables
 * reception.
 * - UART_RX_BUF_REQUEST: Indicates that the driver requests a new buffer for continuous reception. The function allocates a new buffer and
 * provides it to the driver.
 * - UART_RX_BUF_RELEASED: Indicates that a buffer is no longer used by the driver. The function checks if there is valid data in the buffer
 * and either queues it for processing or frees it.
 * - UART_TX_ABORTED: Indicates that a transmission was aborted due to timeout or flow control issues. The function manages the aborted
 * buffer and attempts to retransmit any remaining data.
 */
static void uart_cb(const struct device *dev, struct uart_event *evt, void *user_data) {
  ARG_UNUSED(dev);
 
  static size_t aborted_len;
  struct uart_data_t *buf;
  static uint8_t *aborted_buf;
  static bool disable_req;
 
  switch (evt->type) {
  case UART_TX_DONE:
    //    myPrintkW("UART_TX_DONE\r\n");
    if ((evt->data.tx.len == 0) || (!evt->data.tx.buf)) {
      return;
    }
 
    if (aborted_buf) {
      buf = CONTAINER_OF(aborted_buf, struct uart_data_t, data[0]);
      aborted_buf = NULL;
      aborted_len = 0;
    } else {
      buf = CONTAINER_OF(evt->data.tx.buf, struct uart_data_t, data[0]);
    }
 
    k_free(buf);
 
    buf = k_fifo_get(&fifo_uart_tx_data, K_NO_WAIT);
    if (!buf) {
      return;
    }
 
    if (uart_tx(uart, buf->data, buf->len, SYS_FOREVER_MS)) {
      myPrintkW("Failed to send data over UART\r\n");
    }
 
    break;
 
  case UART_RX_RDY:
    //    myPrintkW("UART_RX_RDY\r\n");
    buf = CONTAINER_OF(evt->data.rx.buf, struct uart_data_t, data[0]);
    buf->len += evt->data.rx.len;
 
    if (disable_req) {
      return;
    }
 
    if ((evt->data.rx.buf[buf->len - 1] == '\n') || (evt->data.rx.buf[buf->len - 1] == '\r')) {
      disable_req = true;
      uart_rx_disable(uart);
    }
 
    break;
 
  case UART_RX_DISABLED:
    //   myPrintkW("UART_RX_DISABLED\r\n");
    disable_req = false;
 
    buf = k_malloc(sizeof(*buf));
    if (buf) {
      buf->len = 0;
    } else {
      myPrintkW("Not able to allocate UART receive buffer\r\n");
      k_work_reschedule(&uart_work, UART_WAIT_FOR_BUF_DELAY);
      return;
    }
 
    /* check if UART0 is disabled */
    // #ifdef NO_UART0
    if (flashParameters.nouart0) {
      /* signal that it is safe to suspend */
      k_sem_give(&uart_rx_disabled_sem);
      // #else
    } else {
      uart_rx_enable(uart, buf->data, sizeof(buf->data), UART_WAIT_FOR_RX);
    }
    // #endif
    break;
 
  case UART_RX_BUF_REQUEST:
    //    myPrintkW("UART_RX_BUF_REQUEST\r\n");
    buf = k_malloc(sizeof(*buf));
    if (buf) {
      buf->len = 0;
      uart_rx_buf_rsp(uart, buf->data, sizeof(buf->data));
    } else {
      myPrintkW("Not able to allocate UART receive buffer\r\n");
    }
 
    break;
 
  case UART_RX_BUF_RELEASED:
    //    myPrintkW("UART_RX_BUF_RELEASED\r\n");
    buf = CONTAINER_OF(evt->data.rx_buf.buf, struct uart_data_t, data[0]);
 
    if (buf->len > 0) {
      k_fifo_put(&fifo_uart_rx_data, buf);
    } else {
      k_free(buf);
    }
 
    break;
 
  case UART_TX_ABORTED:
    myPrintkW("UART_TX_ABORTED\r\n");
    if (!aborted_buf) {
      aborted_buf = (uint8_t *)evt->data.tx.buf;
    }
 
    aborted_len += evt->data.tx.len;
    buf = CONTAINER_OF((void *)aborted_buf, struct uart_data_t, data);
 
    uart_tx(uart, &buf->data[aborted_len], buf->len - aborted_len, SYS_FOREVER_MS);
 
    break;
 
  default:
    break;
  }
}
#endif
 
#if CONFIG_SERIAL
/*!
  * \fn static void uart_work_handler(struct k_work *item)
  *
  * \brief UART callback function to handle UART events
  *
  * This function is called by the UART driver when specific UART events occur, such as data transmission completion, data reception, or
  * errors. It processes the events and manages the UART data buffers accordingly.
  *
  * \param dev pointer to the UART device structure that triggered the event
  * \param evt pointer to the uart_event structure containing details about the event
  * \param user_data pointer to user-defined data (not used in this implementation)
  *
  * The function handles various UART events, including:
  * - UART_TX_DONE: Indicates that a UART transmission has completed. The function retrieves the transmitted buffer, frees it, and checks
for
  * any pending data to transmit.
  * - UART_RX_RDY: Indicates that received data is ready for processing. The function updates the length of received data and checks for
  * newline characters to determine if reception should be disabled.
  * - UART_RX_DISABLED: Indicates that reception has been disabled. The function allocates a new buffer for receiving data and re-enables
  * reception.
  * - UART_RX_BUF_REQUEST: Indicates that the driver requests a new buffer for continuous reception. The function allocates a new buffer and
  * provides it to the driver.
  * - UART_RX_BUF_RELEASED: Indicates that a buffer is no longer used by the driver. The function checks if there is valid data in the
buffer
  * and either queues it for processing or frees it.
  * - UART_TX_ABORTED: Indicates that a transmission was aborted due to timeout or flow control issues. The function manages the aborted
  * buffer and attempts to retransmit any remaining data.
*/
static void uart_work_handler(struct k_work *item) {
  struct uart_data_t *buf;
 
  buf = k_malloc(sizeof(*buf));
  if (buf) {
    buf->len = 0;
  } else {
    myPrintkW("Not able to allocate UART receive buffer\r\n");
    k_work_reschedule(&uart_work, UART_WAIT_FOR_BUF_DELAY);
    return;
  }
 
  uart_rx_enable(uart, buf->data, sizeof(buf->data), UART_WAIT_FOR_RX);
}
#endif
 
#if CONFIG_SERIAL
/*!
 * \fn static bool uart_test_async_api(const struct device *dev)
 * \brief Test if the UART device supports asynchronous API
 * \param dev pointer to the UART device structure
 * \return true if the device supports asynchronous API, false otherwise
 */
static bool uart_test_async_api(const struct device *dev) {
  const struct uart_driver_api *api = (const struct uart_driver_api *)dev->api;
 
  return (api->callback_set != NULL);
}
#endif
 
#if CONFIG_SERIAL
/*!
 * \fn static int uart_init(void)
 * \brief Initialize the UART device
 * \return 0 on success, negative error code on failure
 */
// static int uart_init(void) {
int uart_init(void) {
  int err;
  int pos;
  struct uart_data_t *rx;
  struct uart_data_t *tx;
 
  if (!device_is_ready(uart)) {
    return -ENODEV;
  }
 
  if (IS_ENABLED(CONFIG_USB_DEVICE_STACK)) {
    err = usb_enable(NULL);
    if (err && (err != -EALREADY)) {
      myPrintkE("Failed to enable USB\r\n");
      return err;
    }
  }
 
  rx = k_malloc(sizeof(*rx));
  if (rx) {
    rx->len = 0;
  } else {
    return -ENOMEM;
  }
 
  k_work_init_delayable(&uart_work, uart_work_handler);
 
  if (IS_ENABLED(CONFIG_BT_NUS_UART_ASYNC_ADAPTER) && !uart_test_async_api(uart)) {
    /* Implement API adapter */
    uart_async_adapter_init(async_adapter, uart);
    uart = async_adapter;
  }
 
  err = uart_callback_set(uart, uart_cb, NULL);
  if (err) {
    k_free(rx);
    myPrintkE("Cannot initialize UART callback\r\n");
    return err;
  }
 
  if (IS_ENABLED(CONFIG_UART_LINE_CTRL)) {
    myPrintkI("Wait for DTR\r\n");
    while (true) {
      uint32_t dtr = 0;
 
      uart_line_ctrl_get(uart, UART_LINE_CTRL_DTR, &dtr);
      if (dtr) {
        break;
      }
      /* Give CPU resources to low priority threads. */
      k_sleep(K_MSEC(100));
    }
    myPrintkI("DTR set\r\n");
    err = uart_line_ctrl_set(uart, UART_LINE_CTRL_DCD, 1);
    if (err) {
      myPrintkW("Failed to set DCD, ret code %d\r\n", err);
    }
    err = uart_line_ctrl_set(uart, UART_LINE_CTRL_DSR, 1);
    if (err) {
      myPrintkW("Failed to set DSR, ret code %d\r\n", err);
    }
  }
 
  tx = k_malloc(sizeof(*tx));
 
  if (tx) {
    pos = snprintf(tx->data, sizeof(tx->data), "Starting BLE Prototype (nRF52832)\r\n");
 
    if ((pos < 0) || (pos >= sizeof(tx->data))) {
      k_free(rx);
      k_free(tx);
      myPrintkE("snprintf returned %d\r\n", pos);
      return -ENOMEM;
    }
 
    tx->len = pos;
  } else {
    k_free(rx);
    return -ENOMEM;
  }
 
  err = uart_tx(uart, tx->data, tx->len, SYS_FOREVER_MS);
  if (err) {
    k_free(rx);
    k_free(tx);
    myPrintkE("Cannot display welcome message (err: %d)\r\n", err);
    return err;
  }
 
  err = uart_rx_enable(uart, rx->data, sizeof(rx->data), 50);
  if (err) {
    myPrintkE("Cannot enable uart reception (err: %d)\r\n", err);
    /* Free the rx buffer only because the tx buffer will be handled in the callback */
    k_free(rx);
  }
 
  return err;
}
#endif
 
/*!
 * \fn static void adv_work_handler(struct k_work *work)
 * \brief Handler for the advertising work item
 * \param work pointer to the work item
 */
static void adv_work_handler(struct k_work *work) {
  int err = bt_le_adv_start(BT_LE_ADV_CONN_FAST_2, ad, ARRAY_SIZE(ad), sd, ARRAY_SIZE(sd));
 
  if (err) {
    myPrintkE("Advertising failed to start (err %d)\r\n", err);
    return;
  }
 
  myPrintkI("Advertising successfully started\r\n");
}
 
/*!
 * \fn static void advertising_start(void)
 * \brief Start the advertising process
 *
 */
static void advertising_start(void) { k_work_submit(&adv_work); }
 
/*!
 * \fn static void connected(struct bt_conn *conn, uint8_t err)
 * \brief Callback function for when a Bluetooth connection is established
 * \param conn pointer to the Bluetooth connection structure
 * \param err error code indicating the result of the connection attempt
 * This function is called when a Bluetooth connection is established. It checks for any errors during the connection process and logs the
 * result. If the connection is successful, it stores a reference to the current connection and updates the connection status LED to
 * indicate that a device is connected.
 *
 */
static void connected(struct bt_conn *conn, uint8_t err) {
  char addr[BT_ADDR_LE_STR_LEN];
 
  if (err) {
    myPrintkE("Connection failed (err %u)\r\n", err);
    return;
  }
 
  bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
  myPrintkI("Connected %s\r\n", addr);
 
  current_conn = bt_conn_ref(conn);
 
  dk_set_led_on(CON_STATUS_LED);
}
 
/*!
 * \fn static void disconnected(struct bt_conn *conn, uint8_t reason)
 * \brief Callback function for when a Bluetooth connection is lost
 * \param conn pointer to the Bluetooth connection structure
 * \param reason reason for the disconnection
 * This function is called when a Bluetooth connection is lost. It logs the address of the disconnected device and the reason for the
 * disconnection. It also checks if there are any active connections or authentication processes and cleans up the connection references
 * accordingly. Finally, it updates the connection status LED to indicate that no device is currently connected.
 */
static void disconnected(struct bt_conn *conn, uint8_t reason) {
  char addr[BT_ADDR_LE_STR_LEN];
 
  bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
 
  myPrintkI("Disconnected: %s (reason %u)\r\n", addr, reason);
 
  if (auth_conn) {
    bt_conn_unref(auth_conn);
    auth_conn = NULL;
  }
 
  if (current_conn) {
    bt_conn_unref(current_conn);
    current_conn = NULL;
    dk_set_led_off(CON_STATUS_LED);
  }
}
 
/*!
 * \fn static void recycled_cb(void)
 * \brief Callback function for when a Bluetooth connection object is recycled
 *
 * This function is called when a Bluetooth connection object is recycled, which typically occurs after a disconnection has been fully
 * processed and the connection resources have been released. It logs a message indicating that the connection object is now available for
 * reuse and starts the advertising process again to allow new devices to connect.
 *
 */
static void recycled_cb(void) {
  myPrintkI("Connection object available from previous conn. Disconnect is complete!\r\n");
  advertising_start();
}
 
#ifdef CONFIG_BT_NUS_SECURITY_ENABLED
/*!
 * \fn static void security_changed(struct bt_conn *conn, bt_security_t level, enum bt_security_err err)
 * \brief Callback function for when the security level of a Bluetooth connection changes
 * \param conn pointer to the Bluetooth connection structure
 * \param level new security level
 * \param err error code indicating the result of the security change attempt
 * This function is called when the security level of a Bluetooth connection changes. It logs the address of the device and the new security
 * level if the change was successful, or logs a warning with the error code if the change failed. This is important for managing the
 * security state of the connection and ensuring that the appropriate security measures are
 */
static void security_changed(struct bt_conn *conn, bt_security_t level, enum bt_security_err err) {
  char addr[BT_ADDR_LE_STR_LEN];
 
  bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
 
  if (!err) {
    myPrintkI("Security changed: %s level %u\r\n", addr, level);
  } else {
    myPrintkW("Security failed: %s level %u err %d\r\n", addr, level, err);
  }
}
#endif
 
/**
 * \brief Bluetooth connection callbacks
 */
BT_CONN_CB_DEFINE(conn_callbacks) = {
    .connected = connected,
    .disconnected = disconnected,
    .recycled = recycled_cb,
#ifdef CONFIG_BT_NUS_SECURITY_ENABLED
    .security_changed = security_changed,
#endif
};
 
#if defined(CONFIG_BT_NUS_SECURITY_ENABLED)
/*!
 * \fn static void auth_passkey_display(struct bt_conn *conn, unsigned int passkey)
 * \brief Callback function for when a passkey is displayed during authentication
 * \param conn pointer to the Bluetooth connection structure
 * \param passkey the passkey to be displayed
 * This function is called when a passkey needs to be displayed during the authentication process. It logs the address of the device and the
 * passkey.
 */
static void auth_passkey_display(struct bt_conn *conn, unsigned int passkey) {
  char addr[BT_ADDR_LE_STR_LEN];
 
  bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
 
  myPrintkI("Passkey for %s: %06u\r\n", addr, passkey);
}
 
/*!
 * \fn static void auth_passkey_confirm(struct bt_conn *conn, unsigned int passkey)
 * \brief Callback function for when a passkey is confirmed during authentication
 * \param conn pointer to the Bluetooth connection structure
 * \param passkey the passkey to be confirmed
 * This function is called when a passkey needs to be confirmed during the authentication process. It logs the address of the device and the
 * passkey.
 */
static void auth_passkey_confirm(struct bt_conn *conn, unsigned int passkey) {
  char addr[BT_ADDR_LE_STR_LEN];
 
  auth_conn = bt_conn_ref(conn);
 
  bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
 
  myPrintkI("Passkey for %s: %06u\r\n", addr, passkey);
  myPrintkI("Press Button 1 to confirm, Button 2 to reject.\r\n");
}
 
/*!
 * \fn static void auth_cancel(struct bt_conn *conn)
 * \brief Callback function for when pairing is cancelled
 * \param conn pointer to the Bluetooth connection structure
 * This function is called when pairing is cancelled. It logs the address of the device.
 */
static void auth_cancel(struct bt_conn *conn) {
  char addr[BT_ADDR_LE_STR_LEN];
 
  bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
 
  myPrintkI("Pairing cancelled: %s\r\n", addr);
}
 
/*!
 * \fn static void pairing_complete(struct bt_conn *conn, bool bonded)
 * \brief Callback function for when pairing is completed
 * \param conn pointer to the Bluetooth connection structure
 * \param bonded indicates whether the device is bonded after pairing
 * This function is called when pairing is completed. It logs the address of the device and whether it is bonded.
 */
static void pairing_complete(struct bt_conn *conn, bool bonded) {
  char addr[BT_ADDR_LE_STR_LEN];
 
  bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
 
  myPrintkI("Pairing completed: %s, bonded: %d\r\n", addr, bonded);
}
 
/*!
 * \fn static void pairing_failed(struct bt_conn *conn, enum bt_security_err reason)
 * \brief Callback function for when pairing fails
 * \param conn pointer to the Bluetooth connection structure
 * \param reason the reason for the pairing failure
 * This function is called when pairing fails. It logs the address of the device and the reason for the failure.
 */
static void pairing_failed(struct bt_conn *conn, enum bt_security_err reason) {
  char addr[BT_ADDR_LE_STR_LEN];
 
  bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
 
  myPrintkI("Pairing failed conn: %s, reason %d %s\r\n", addr, reason, bt_security_err_to_str(reason));
}
 
/*!
 * \brief Bluetooth connection authentication callbacks
 * This structure defines the callbacks for Bluetooth connection authentication events, including passkey display, passkey confirmation, and
 * cancellation of pairing. It is used to manage the authentication process during Bluetooth pairing and ensure that the appropriate actions
 * are taken based on user input and authentication events.
 */
static struct bt_conn_auth_cb conn_auth_callbacks = {
    .passkey_display = auth_passkey_display,
    .passkey_confirm = auth_passkey_confirm,
    .cancel = auth_cancel,
};
 
/*!
* \brief Bluetooth connection authentication information callbacks
* This structure defines the callbacks for Bluetooth connection authentication information events, including pairing completion and pairing
failure. It is used to manage the authentication process during Bluetooth pairing and ensure that the appropriate actions are taken based on
the outcome of the pairing process, such as logging the results and handling any necessary cleanup or user notifications.
 
*/
static struct bt_conn_auth_info_cb conn_auth_info_callbacks = {.pairing_complete = pairing_complete, .pairing_failed = pairing_failed};
#else
static struct bt_conn_auth_cb conn_auth_callbacks;
static struct bt_conn_auth_info_cb conn_auth_info_callbacks;
#endif
 
/*!
 * \fn static void bt_receive_cb(struct bt_conn *conn, const uint8_t *const data, uint16_t len)
 * \brief Callback function for receiving data over Bluetooth
 * \param conn pointer to the Bluetooth connection structure
 * \param data pointer to the received data
 * \param len length of the received data
 */
static void bt_receive_cb(struct bt_conn *conn, const uint8_t *const data, uint16_t len) {
  int err;
  char addr[BT_ADDR_LE_STR_LEN] = {0};
 
  bt_addr_le_to_str(bt_conn_get_dst(conn), addr, ARRAY_SIZE(addr));
 
#if 0
  /* for testing */
  sprintf(myStr, "%s B", devIDStr);
  myPrintkS("%s\r\n", myStr);
  bt_nus_send(NULL, myStr, strlen(myStr));
  k_sleep(K_SECONDS(2));
#endif
 
  myPrintkI("Received data from: %s\r\n", addr);
 
#if CONFIG_SERIAL
  for (uint16_t pos = 0; pos != len;) {
    struct uart_data_t *tx = k_malloc(sizeof(*tx));
 
    if (!tx) {
#if 0
      sprintf(myStr, "%s C", devIDStr);
      myPrintkS("%s\r\n", myStr);
      bt_nus_send(NULL, myStr, strlen(myStr));
      k_sleep(K_SECONDS(2));
#endif
      myPrintkW("Not able to allocate UART send data buffer\r\n");
      return;
    }
 
    /* Keep the last byte of TX buffer for potential LF char. */
    size_t tx_data_size = sizeof(tx->data) - 1;
 
    if ((len - pos) > tx_data_size) {
      tx->len = tx_data_size;
    } else {
      tx->len = (len - pos);
    }
 
    memcpy(tx->data, &data[pos], tx->len);
 
    pos += tx->len;
 
    /* Append the LF character when the CR character triggered
     * transmission from the peer.
     */
    if ((pos == len) && (data[len - 1] == '\r')) {
      tx->data[tx->len] = '\n';
      tx->len++;
    }
 
#if 0
    sprintf(myStr, "%s D", devIDStr);
    myPrintkS("%s\r\n", myStr);
    bt_nus_send(NULL, myStr, strlen(myStr));
    k_sleep(K_SECONDS(2));
#endif
 
    err = uart_tx(uart, tx->data, tx->len, SYS_FOREVER_MS);
    if (err) {
      k_fifo_put(&fifo_uart_tx_data, tx);
    }
 
    /* show TX sent */
    tx->data[tx->len] = '\0';
    err = bleCommand(tx->data);
  }
#else
  char bleStr[80];
  int lentemp;
 
  for (uint16_t pos = 0; pos != len;) {
 
    /* Keep the last byte of TX buffer for potential LF char. */
    size_t tx_data_size = sizeof(bleStr) - 1;
 
    if ((len - pos) > tx_data_size) {
      lentemp = tx_data_size;
    } else {
      lentemp = (len - pos);
    }
 
    memcpy(bleStr, &data[pos], lentemp);
 
    pos += lentemp;
 
    /* Append the LF character when the CR character triggered
     * transmission from the peer.
     */
    if ((pos == len) && (data[len - 1] == '\r')) {
      bleStr[lentemp] = '\n';
      lentemp++;
    }
 
    /* show TX sent */
    bleStr[lentemp] = '\0';
 
#if 0
    sprintf(myStr, "%s DD %s", devIDStr, bleStr);
    bt_nus_send(NULL, myStr, strlen(myStr));
    k_sleep(K_SECONDS(2));
#endif
 
    err = bleCommand(bleStr);
  }
#endif
}
 
/*!
 * \brief Bluetooth NUS callbacks
 * This structure defines the callbacks for Bluetooth NUS events, including data reception.
 */
static struct bt_nus_cb nus_cb = {
    .received = bt_receive_cb,
};
 
/*!
 * \fn void error(void)
 * \brief Function to handle fatal errors
 * This function is called when a fatal error occurs in the system. It turns off all LEDs to indicate an error state and enters an infinite
 * loop to halt the system. This is a common error handling approach in embedded systems to prevent further damage or undefined behavior
 * after a critical failure. The function also includes a commented-out print statement that could be used to log the error message before
 * halting the system, but it is currently disabled to avoid potential issues with logging in an error state.
 */
void error(void) {
  dk_set_leds_state(DK_ALL_LEDS_MSK, DK_NO_LEDS_MSK);
 
  // myprintkE("Fatal Error!!\r\n");
  while (true) {
    /* Spin for ever */
    k_sleep(K_MSEC(1000));
  }
}
 
#ifdef CONFIG_BT_NUS_SECURITY_ENABLED
/*!
 * \fn static void num_comp_reply(bool accept)
 * \brief Callback function for handling numeric comparison replies
 * \param accept boolean indicating whether the numeric comparison was accepted
 * This function is called to handle the user's response to a numeric comparison during Bluetooth authentication. If the user accepts the
 * comparison, the function confirms the passkey for the current authentication connection. If the user rejects the comparison, the function
 * cancels the authentication process. After handling the user's response, the function releases the
 */
static void num_comp_reply(bool accept) {
  if (accept) {
    bt_conn_auth_passkey_confirm(auth_conn);
    myPrintkI("Numeric Match, conn %p\r\n", (void *)auth_conn);
  } else {
    bt_conn_auth_cancel(auth_conn);
    myPrintkI("Numeric Reject, conn %p\r\n", (void *)auth_conn);
  }
 
  bt_conn_unref(auth_conn);
  auth_conn = NULL;
}
 
/*!
 * \fn void button_changed(uint32_t button_state, uint32_t has_changed)
 * \brief Callback function for handling button changes
 * \param button_state current state of the buttons
 * \param has_changed bitmask indicating which buttons have changed
 * This function is called when the state of the buttons changes. It checks if there is an active authentication connection and if any of
 * the buttons that have changed are the ones used for accepting or rejecting the numeric comparison during authentication. If the accept
 * button is pressed, it calls the num_comp_reply function with true to confirm the pass key. If the reject button is pressed, it calls the
 * num_comp_reply function with false to cancel the authentication. This allows the user to interact with the authentication process using
 * physical buttons on the device.
 *
 */
void button_changed(uint32_t button_state, uint32_t has_changed) {
  uint32_t buttons = button_state & has_changed;
 
  if (auth_conn) {
    if (buttons & KEY_PASSKEY_ACCEPT) {
      num_comp_reply(true);
    }
 
    if (buttons & KEY_PASSKEY_REJECT) {
      num_comp_reply(false);
    }
  }
}
#endif /* CONFIG_BT_NUS_SECURITY_ENABLED */
 
static void configure_gpio(void) {
  int err;
 
#ifdef CONFIG_BT_NUS_SECURITY_ENABLED
  err = dk_buttons_init(button_changed);
  if (err) {
    myPrintkE("Cannot init buttons (err: %d)\r\n", err);
  }
#endif /* CONFIG_BT_NUS_SECURITY_ENABLED */
 
  err = dk_leds_init();
  if (err) {
    myPrintkE("Cannot init LEDs (err: %d)\r\n", err);
  }
}
 
int bleLoopCount = 0;
 
/*!
 * \fn int main(void)
 
 * \brief Nordic UART Bridge Service (NUS) sample (BLE_Prototype) starting point
 
 * This is the main function of the program, which serves as the entry point for execution. It performs initial setup and configuration,
 * including determining the cause of the last reset, configuring GPIOs for buttons and LEDs, and setting up interrupts for the HDC2080
 * sensor and SW2 button. It also initializes the Bluetooth functionality and starts advertising for connections. The function includes
 * error handling to ensure that any issues during initialization are logged and that the system enters a safe state if critical errors
 * occur. Overall, this function orchestrates the initialization and main loop of the application, ensuring that all components are properly
 * set up and ready for operation.
 
 * \return TRUE if passed, FALSE if failed
 *
 */
int main(void) {
  //    int blink_status = 0;
  int err = 0;
 
  /* find the reason that we started the program */
  ret = NRF_POWER->RESETREAS;
  if (ret == 0)
    sprintf(resetCause, "Power applied reset, ");
  if (ret & 0x1)
    strcat(resetCause, "Pin reset, ");
  if (ret & 0x2)
    strcat(resetCause, "Global Watchdog reset, ");
  if (ret & 0x4)
    strcat(resetCause, "Wakeup from system off detect from GPIO reset, ");
  if (ret & 0x10)
    strcat(resetCause, "Wakeup from system off debug interface mode reset, ");
  if (ret & 0x10000)
    strcat(resetCause, "AIRCR.SYSRESETREQ reset, ");
  if (ret & 0x20000)
    strcat(resetCause, "CPU lockup reset, ");
  if (ret & 0x40000)
    strcat(resetCause, "CTRL_AP reset, ");
  if (strlen(resetCause) > 90)
    resetCause[90] = '\0';
  resetCause[strlen(resetCause) - 2] = '\0';
  NRF_POWER->RESETREAS = ret;
  myPrintkS("resetCause: %s\r\n", resetCause);
 
  bleIndex = 1; /* reset BLE index counter */
 
  configure_gpio(); /* configure buttons and LEDS */
 
  /* start GPIO test */
  myPrintk("*** GPIO Init ***\r\n");
 
  /* check if hdc2080 (GPIO Inoput) ready */
  if (!gpio_is_ready_dt(&hdc2080)) {
    myPrintkE("Error: HDC2080 GPIO %s is not ready\n", hdc2080.port->name);
    error();
  }
  myPrintkI("HDC2080 GPIO %s is ready\n", hdc2080.port->name);
 
  /* configure hdc2080 GPIO as input */
  err = gpio_pin_configure_dt(&hdc2080, GPIO_INPUT);
  if (err) {
    myPrintkE("Error %d: failed to configure %s pin %d\n", err, hdc2080.port->name, hdc2080.pin);
    error();
  }
  myPrintkI("HDC2080 passed configure %s pin %d\n", hdc2080.port->name, hdc2080.pin);
 
  /* configure HDC2080 GPIO interrupt */
  //    ret = gpio_pin_interrupt_configure_dt(&hdc2080   GPIO_INT_EDGE_TO_ACTIVE);
  err = gpio_pin_interrupt_configure_dt(&hdc2080, GPIO_INT_EDGE_FALLING);
  //    ret = gpio_pin_interrupt_configure_dt(&hdc2080,   GPIO_INT_EDGE_RISING);
  //    ret = gpio_pin_interrupt_configure_dt(&hdc2080,   GPIO_INT_EDGE_BOTH);
  if (err != 0) {
    myPrintkE("Error %d: failed to configure interrupt on %s pin %d\n", err, hdc2080.port->name, hdc2080.pin);
    error();
  }
  myPrintkI("HDC2080 passed configure interrupt on %s pin %d\n", hdc2080.port->name, hdc2080.pin);
 
  /* set up HDC2080 GPIO interrupt callback */
  gpio_init_callback(&hdc2080_cb_data, hdc2080_rdy_seen, BIT(hdc2080.pin));
  gpio_add_callback(hdc2080.port, &hdc2080_cb_data);
  myPrintkI("Set up HDC2080 at %s pin %d\n", hdc2080.port->name, hdc2080.pin);
 
  /* check if SW2 (GPIO Inoput) ready */
  if (!gpio_is_ready_dt(&sw2)) {
    myPrintkE("Error: SW2 GPIO %s is not ready\n", sw2.port->name);
    error();
  }
  myPrintkI("SW2 GPIO %s is ready\n", sw2.port->name);
 
  /* configure SW2 GPIO as input */
  err = gpio_pin_configure_dt(&sw2, GPIO_INPUT);
  if (err) {
    myPrintkE("Error %d: failed to configure %s pin %d\n", err, sw2.port->name, sw2.pin);
    error();
  }
  myPrintkI("SW2 passed configure %s pin %d\n", sw2.port->name, sw2.pin);
 
#if 1
  /* configure sw2 GPIO interrupt */
  //    ret = gpio_pin_interrupt_configure_dt(&sw2   GPIO_INT_EDGE_TO_ACTIVE);
  err = gpio_pin_interrupt_configure_dt(&sw2, GPIO_INT_EDGE_FALLING);
  //    ret = gpio_pin_interrupt_configure_dt(&sw2,   GPIO_INT_EDGE_RISING);
  //    ret = gpio_pin_interrupt_configure_dt(&sw2,   GPIO_INT_EDGE_BOTH);
  if (err != 0) {
    myPrintkE("Error %d: failed to configure interrupt on %s pin %d\n", err, sw2.port->name, sw2.pin);
    error();
  }
  myPrintkI("SW2 passed configure interrupt on %s pin %d\n", sw2.port->name, sw2.pin);
 
  /* set up SW2 GPIO interrupt callback */
  gpio_init_callback(&sw2_cb_data, sw2_seen, BIT(sw2.pin));
  gpio_add_callback(sw2.port, &sw2_cb_data);
  myPrintkI("Set up SW2 at %s pin %d\n", sw2.port->name, sw2.pin);
#endif
 
  /* set up SPI CS1N as output/pullup */
  if (!gpio_is_ready_dt(&spics1n)) {
    myPrintkE("SPI CS1N device is not ready\r\n");
  } else
    myPrintkI("SPI CS1N device is ready\r\n");
  gpio_pin_configure_dt(&spics1n, GPIO_OUTPUT | GPIO_PULL_UP | GPIO_ACTIVE_LOW);
  gpio_pin_set(spics1n.port, spics1n.pin, 0);
 
  /* set up SPI CS2N as output/pullup */
  if (!gpio_is_ready_dt(&spics2n)) {
    myPrintkE("SPI CS2N device is not ready\r\n");
  } else
    myPrintkI("SPI CS2N device is ready\r\n");
  gpio_pin_configure_dt(&spics2n, GPIO_OUTPUT | GPIO_PULL_UP | GPIO_ACTIVE_LOW);
  gpio_pin_set(spics2n.port, spics2n.pin, 0);
 
  /* set up BATEN as output/pullup */
  if (!gpio_is_ready_dt(&baten)) {
    myPrintkE("BATEN device is not ready\r\n");
  } else
    myPrintkI("BATEN device is ready\r\n");
  gpio_pin_configure_dt(&baten, GPIO_OUTPUT | GPIO_PULL_UP);
 
#if 0
/* SW2 switch push test */
    int test = 0;
    while(1)
    {
            test = gpio_pin_get(sw2.port, sw2.pin);
            myPrintk("SW@: %d\r\n",test);
            k_sleep(K_SECONDS(1));
    }
#endif
 
#if 0
    /* SW2 switch interrupt test */
    while (1)
    {
        if (k_sem_take(&sw2_rdy_seen, K_MSEC(100)) == 0 )
        {
            myPrintk("SW2: %d\r\n", gpio_pin_get(sw2.port, sw2.pin));
        }
    }
#endif
 
#if 0
    int test = 0;
    while(1)
    {
        /* toggle test */
//      gpio_pin_toggle(spics1n.port, spics1n.pin);
//      k_sleep(K_MSEC(10));
 
        /* set/clear test */
        if(test++ & 0x01)
        {
//          printf("set\r\n");
            gpio_pin_set(spics1n.port, spics1n.pin, 1);
            k_sleep(K_MSEC(10));
        }
        else
        {
//          printf("clear\r\n");
            gpio_pin_set(spics1n.port, spics1n.pin, 0);
            k_sleep(K_MSEC(20));
        }
    }
#endif
 
#if 0
    int test = 0;
    while(1)
    {
        /* toggle test */
//      gpio_pin_toggle(spics2n.port, spics2n.pin);
//      k_sleep(K_MSEC(10));
 
        /* set/clear test */
        if(test++ & 0x01)
        {
//          printf("set\r\n");
            gpio_pin_set(spics2n.port, spics2n.pin, 1);
        }
        else
        {
//          printf("clear\r\n");
            gpio_pin_set(spics2n.port, spics2n.pin, 0);
        }
        k_sleep(K_MSEC(20));
    }
#endif
 
#if 0
    int test = 0;
    while(1)
    {
        /* toggle test */
//      gpio_pin_toggle(baten.port, baten.pin);
//      k_sleep(K_MSEC(10));
 
        /* set/clear test */
        if(test++ & 0x01)
        {
//          printf("set\r\n");
            gpio_pin_set(baten.port, baten.pin, 1);
        }
        else
        {
//          printf("clear\r\n");
            gpio_pin_set(baten.port, baten.pin, 0);
        }
        k_sleep(K_MSEC(20));
    }
#endif
 
  /* end GPIO test */
 
#if CONFIG_SERIAL
  err = uart_init(); /* initialize UART */
  if (err) {
    // myprintkE("UART device is not ready\r\n");
    error();
  }
  // myprintkI("UART device is ready\r\n");
#endif
 
  err = init_i2c(); /* initialize I2C peripheral returns TRUE if passed */
  if (err == FALSE) {
    // myprintkE("I2C interface is not ready\r\n");
    error();
  }
  // myprintkI("I2C interface is ready\r\n");
 
/* start I2C test */
#if 0
    unsigned char datas[6];
    while(1)
    {
        /* 4. verify i2c_read() from HDC2080 */
        datas[0] = 0xFC;
        i2c_write(i2c_dev, datas, 1, 0x40);
 
        i2c_read(i2c_dev, datas, 2, 0x40);
        printf("I2C 0x%02X 0x%02X\r\n",datas[0],datas[1]);
        k_sleep(K_MSEC(1000));
    }
#endif
 
  /* end I2C test */
  /* start SPI test */
 
  myPrintk("*** SPI Init ***\r\n");
 
  if (!device_is_ready(spi_dev)) {
    myPrintkE("SPI device is not ready\r\n");
  } else
    myPrintkI("SPI device is ready\r\n");
 
#if 0
 
    printf("SPI Test Running\r\n");
    while(1)
    {
        /* zero buffer and load the command */
        for(int i=0;i<4;i++)
            buffer_tx[i] = 0;
        buffer_tx[0] = 0x9F;
        tx_bufs[0].len = 4;
        rx_bufs[0].len = 4;
 
    /* enable CS1 and send command  */
        ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
        k_sleep(K_MSEC(10));
 
    /* enable CS2 and send command  */
        ret = spi_transceive(spi_dev, &spi_cfg2, &tx, &rx);
        k_sleep(K_MSEC(10));
    }
#endif
 
/* end SPi test */
 
/* start Flash test */
#if 0
    uint8_t readBuffer[10];
//uint8_t flashRead[256];
//uint8_t data[3];
 
    printf("Flash Test Running\r\n");
    while(1)
    {
//      ret = initW25Q64JV();
        readNVFlashxStatus(readBuffer);
//      flashxErasePage(1);
//      flashxEraseBlock1(1);
//      flashxEraseBlock2(1);
//      flashxEraseSector(1);
//      flashxErase();
//      flashxReadPage(1, flashRead);
//      data[0] = 0xAB;
//      flashxWritePage(1, 3, data, 1);
//      flashxFillPage(1, 0xCD);
//      flashxClearParameters();
//      setFlashxParameters(TRUE);
 
 
        k_sleep(K_MSEC(100));
    }
#endif
 
  /* end Flash test */
 
  /* start ADC test */
 
  myPrintk("*** ADC Init ***\r\n");
 
  if (!device_is_ready(adc_dev)) /* check if ADC peripheral ready */
  {
    myPrintkE("ADC device is not ready\n");
    return FALSE;
  }
  myPrintkI("ADC device is ready\n");
 
  err = adc_channel_setup(adc_dev, &m_1st_channel_cfg);
  if (err) {
    myPrintkE("Error in adc AIN0 setup: %d\n", err);
  }
  myPrintkI("ADC AIN0 is ready\n");
 
#if 0
 
    printf("ADC Test Running\r\n");
    while(1)
    {
        err = adc_sample();
        printf("ADC: %3.2f\r\n",adc_voltage[0]);
        k_sleep(K_MSEC(5000));
    }
#endif
 
  /* end ADC test */
 
  /* get Nordic unique device ID */
  // sprintf(devIDStr, "%08X_%08X", NRF_FICR->DEVICEID[0], NRF_FICR->DEVICEID[1]);
  sprintf(devIDStr, "%08X", NRF_FICR->DEVICEID[0]);
  //    sprintf(devIDStr, "%s", "x");
  myPrintkS("Device ID: %s\r\n", devIDStr);
  if (flashParameters.nouart0 == false) {
    myPrintkS("Board: %s%s\r\nFW VERSION: V %d.%02d %s%s\r\n", BOARD_NAME, BOARD_NAME_EXT, VERSION_MAJOR, VERSION_MINOR, VERSION_DATE,
              VERSION_DATE_EXT1);
  } else {
    myPrintkS("Board: %s%s\r\nFW VERSION: V %d.%02d %s%s\r\n", BOARD_NAME, BOARD_NAME_EXT, VERSION_MAJOR, VERSION_MINOR, VERSION_DATE,
              VERSION_DATE_EXT2);
  }
#ifndef CONFIG_SERIAL
  myPrintkS("Board: %s%s\r\nFW VERSION: V %d.%02d %s%s\r\n", BOARD_NAME, BOARD_NAME_EXT, VERSION_MAJOR, VERSION_MINOR, VERSION_DATE,
            VERSION_DATE_EXT3);
#endif
  myPrintkS("SDK Version: %s\r\n", EXPAND_AND_STR(NCS_BUILD_VERSION));
  myPrintkS("Built:%s %s\r\n", __DATE__, __TIME__);
 
  /* chacek and load flashparameters */
  myPrintkS("Read Flash Parameters size: %d\r\n", sizeof(flashParametersStruct));
  getFlashparameters(); /* first read to set flash in correct state */
  getFlashparameters();
 
  if (flashParameters.key == 0) {
    myPrintkW("Flash key not found, try again\r\n");
    getFlashparameters(); /* try one more time to read flash parameters */
  }
  myPrintk("key: 0x%08X\r\n", flashParameters.key);
 
#if 1
  /* check if any flash parameters have been written */
  if (flashParameters.key == FLASHPARAMETERKEY) {
    k_sleep(K_SECONDS(1));
    displayFlashxParameters();
  } else {
    myPrintkW("Flash Parameter Key: %08X Not Set\r\n", flashParameters.key);
    flashxClearParameters();
    setFlashxParameters(true);
  }
#endif
 
#ifdef SIMULATED_INTERRUPT
  /* start simulated interrupt timerr */
  k_timer_init(&simulated_interrupt_timer, simulated_interrupt_timer_handler, NULL);
  k_timer_start(&simulated_interrupt_timer, K_SECONDS(5), K_SECONDS(5));
  k_sleep(K_SECONDS(2));
#endif
 
#if 1
  err = watchdog_init_and_start();
 
  if (err) {
    myPrintkE("watchdog_init_and_start, error: %d\n", err);
  } else {
    myPrintkI("watchdog_init_and_start Passed\n");
  }
#endif
 
  /* is BLE security UART enabled */
  if (IS_ENABLED(CONFIG_BT_NUS_SECURITY_ENABLED)) {
    err = bt_conn_auth_cb_register(&conn_auth_callbacks); /* register authorization callbacks */
    if (err) {
      myPrintkE("Failed to register BLE authorization callbacks.\n");
      error();
    }
    myPrintkI("Passed register BLE authorization callbacks.\n");
 
    err = bt_conn_auth_info_cb_register(&conn_auth_info_callbacks); /* register authorization info callbacks */
    if (err) {
      myPrintkE("Failed to register BLE authorization info callbacks.\n");
      error();
    }
    myPrintkI("passed register BLE authorization info callbacks.\n");
  }
 
  err = bt_enable(NULL); /* enable Bluetooth */
  if (err) {
    myPrintkE("Failed to enable BLE. %d\n", err);
    error();
  }
  myPrintkI("Bluetooth Enabled\r\n");
 
  k_sem_give(&ble_init_ok); /* set semaphore to indicate BLE OK */
 
  if (IS_ENABLED(CONFIG_SETTINGS)) {
    err = settings_load();
  }
 
  err = bt_nus_init(&nus_cb); /* initialize Nordic UART Service */
  if (err) {
    // sprintfstr, "Failed to initialize UART service (err: %d)", err);
    // myprintkE(str);
    error();
  }
  // myprintkI("initialized BLE UART service\r\n");
 
  /* create unique BLE advertizer name */
  strcpy(device_name, DEVICE_NAME);
  strcat(device_name, devIDStr);
  device_name_len = strlen(device_name);
  myPrintkS("BLE Advertizing name: %s\r\n", device_name);
  ad[1].type = BT_DATA_NAME_COMPLETE;
  ad[1].data_len = device_name_len;
  ad[1].data = device_name;
 
#ifndef SW2STARTSADVERTISING
 
  k_work_init(&adv_work, adv_work_handler);
  advertising_start();
  //    err = bt_le_adv_start(BT_LE_ADV_CONN, ad, ARRAY_SIZE(ad), sd, ARRAY_SIZE(sd)); /* start BLE advertising */
  //    if (err)
  //    {
  //        myPrintkE("Advertising failed to start (err %d)", err);
  //        error();
  //    }
  myPrintkI("Advertising started (name %s)\r\n", device_name);
#endif
 
  rescan(); /* scans for all I2C and SPI devices */
 
  /* set HDC2080 interrupt rate */
  if (flashParameters.manualTrigger == true) {
    setRate(MANUAL); /* set manual trigger */
  } else if (flashParameters.dutyCycle > 7) {
    setRate(ONE_MINS); /* set auto conversion rate */
    hdcMinutes = flashParameters.dutyCycle - 7;
  } else {
    setRate(flashParameters.dutyCycle); /* set auto conversion rate */
  }
 
#if 0
    for (;;)
    {
        dk_set_led(RUN_STATUS_LED, (++blink_status) % 2);
        k_sleep(K_MSEC(RUN_LED_BLINK_INTERVAL));
    }
#else
 
#if CONFIG_SERIAL
  // #ifdef NO_UART0
  if (flashParameters.nouart0) {
    myPrintkW("UART0 Disable\r\n");
    k_sleep(K_SECONDS(3));
    // 1. Disable RX first
    err = uart_rx_disable(uart0_dev);
    //      __ASSERT(err == 0, "Failed to disable uart rx");
    if (err == 0) {
      myPrintkW("UART0 RX Disabled\r\n");
    } else {
      myPrintkE("UART0 RX Disable Failed: %d\r\n", err);
    }
    myPrintkW("UART0 SUSPEND: %d\r\n", err);
 
    // 2. Wait for UART_RX_DISABLED event in your UART callback
    //    (use a semaphore or flag set in the callback)
    k_sem_take(&uart_rx_disabled_sem, K_FOREVER); // Wait for the semaphore to be given in the callback
    // 3. Only then suspend the device
    err = pm_device_action_run(uart0_dev, PM_DEVICE_ACTION_SUSPEND);
  }
//  #endif
#endif
 
  for (;;) {
 
    /* check for CLI commands */
    //    if (k_sem_take(&cli_cmd_seen, K_MSEC(100)) == 0) {
    if (k_sem_take(&cli_cmd_seen, K_NO_WAIT) == 0) {
      myPrintk("cli CMD: %s\r\n", cliCMD);
      executeCmd(cliCMD);
    }
 
    /*check for SW2 press */
    //    if (k_sem_take(&sw2_rdy_seen, K_MSEC(100)) == 0) {
    if (k_sem_take(&sw2_rdy_seen, K_NO_WAIT) == 0) {
      myPrintk("SW2: %d\r\n", gpio_pin_get(sw2.port, sw2.pin));
 
      // #ifdef SW2STARTSADVERTISING
      //            /* SW2 seen so start advertising  */
      //            err = bt_le_adv_start(BT_LE_ADV_CONN, ad, ARRAY_SIZE(ad), sd, ARRAY_SIZE(sd)); /* start BLE advertising */
      //            if (err)
      //            {
      //                myPrintkE("Advertising failed to start (err %d)", err);
      //                error();
      //            }
      //            myPrintkS("Advertising started (name %s)\r\n", device_name);
      // #endif
    }
 
    /* Don't go any further until HDC2080 RDY seen */
    //      k_sem_take(&hdc_rdy_seen, K_FOREVER);
 
    /* check for HDC2080 RDY */
    //    if (k_sem_take(&hdc_rdy_seen, K_MSEC(100)) == 0) {
    if (k_sem_take(&hdc_rdy_seen, K_NO_WAIT) == 0) {
      hdc2080RdyHandler(); /* call the HDC2080 RDY handler directly */
    } /* end of sem take*/
    k_sleep(K_MSEC(100)); /* sleep for 100 ms */
  }
#endif
}
 
void hdc2080RdyHandler(void) {
  int err = 0;
  uint8_t status;
  uint8_t byte[2];
  uint8_t tempStatus;
  uint8_t humidityStatus;
  uint8_t intEnables;
  //  int sectorCount;
  myPrintkW("hdc2080RdyHandler called\r\n");
 
  //
  //  bleLoopCount++; /* update loop count */
 
  int64_to_string(gatewayDateTime, gatewayEpoch);
 
  //            if (flashParameters.silent == false)
  {
    myPrintkI("\r\nHDC2080 Rdy Seen. Loop Count: %d\r\n", bleLoopCount);
 
    //              myPrintkI("meas config: 0x%02X\r\n", byte[0]);
    //              myPrintkI("Low T: %3.2f High T: %3.2f \r\n", readLowTempThreshold(), readHighTempThreshold());
    //              myPrintkI("Low H: %3.2f High H: %3.2f \r\n", readLowHumidityThreshold(),
    // readHighHumidityThreshold());
  }
 
  if (flashParameters.ignoreBME688 == false) {
    /* get BME688 data*/
    getBME688Data(1, TRUE);
    if (flashParameters.silent == false) {
      myPrintkI("BME688 Data Read\r\n");
    }
  }
 
  //            int64_t time_ms = k_uptime_get();
  //            myPrintkW("uptime: %d\r\n", time_ms);
  readReg(MEASUREMENT_CONFIG, byte, 1);
 
  status = readInterruptStatus();            /* get current interupt status */
  readReg(INTERRUPT_CONFIG, &intEnables, 1); /* get current interup enables */
 
  hdcTemp = readTemp();
  hdcHumidity = readHumidity();
  if (flashParameters.silent == false) {
    myPrintkI("HDC2080 Data Read\r\n");
  }
  // snprintf(str1, "%3.2f", sizeof(str1), hdcTemp);
  //       sprintf(str2, "%3.2f", hdcHumidity);
  if (flashParameters.silent == false) {
    //        myPrintkI("Index: %d Temp: %3.2f Humidity: %3.2f 0x%02X\r\n", bleIndex, (double)hdcTemp, (double)hdcHumidity, status);
    myPrintkI("gateway Epoch: %s Temp: %d Humidity: %d 0x%02X\r\n", gatewayEpoch, (int)(hdcTemp * 100), (int)(hdcHumidity * 100), status);
  }
 
  if (sendingDeviceInfo == true) {
    myPrintkW("In the middle of sending device info, skip sending data\r\n");
    return; /* skip sending data if we are in the middle of sending device info */
  }
 
  /* get interupt state for temp and humidity */
  tempStatus = 0;
  humidityStatus = 0;
  /* set up temp status */
  if (status & TL_STATUS) {
    tempStatus |= LOWTEMPACTIVE;
  }
  if (status & TH_STATUS) {
    tempStatus |= HIGHTEMPACTIVE;
  }
  if (intEnables & TL_ENABLE) {
    tempStatus |= LOWTEMPENABLE;
  }
  if (intEnables & TH_ENABLE) {
    tempStatus |= HIGHTEMPENABLE;
  }
 
  /* set up humidity status */
  if (status & HL_STATUS) {
    humidityStatus |= LOWHUMIDITYACTIVE;
  }
  if (status & HH_STATUS) {
    humidityStatus |= HIGHHUMIDITYACTIVE;
  }
  if (intEnables & HL_ENABLE) {
    humidityStatus |= LOWHUMIDITYENABLE;
  }
  if (intEnables & HH_ENABLE) {
    humidityStatus |= HIGHHUMIDITYENABLE;
  }
 
  if (flashParameters.manualTrigger) { /* if manual trigger sned all */
    myPrintkW("Manual Trigger\r\n");
 
    /* send HDC data */
    if ((byte[0] & 0x6) == 0x0) /*both temperature and humidity read */
    {
      // sprintf(myStr,
      //                                sprintf(myStr, "Index: %0d ID: %s t_hdc %3.2f %02X h_hdc %3.2f
      //%02X\r\n", bleIndex, devIDStr, hdcTemp, tempStatus, hdcHumidity, humidityStatus);
      // sprintf(myStr, "I: %0d ID: %s t %3.2f %02X h %3.2f %02X\r\n", bleIndex, devIDStr, hdcTemp, tempStatus, hdcHumidity,
      // humidityStatus);
      //          sprintf(myStr, "%0d\t%s t1 %3.2f h1 %3.2f", bleIndex, devIDStr, (double)hdcTemp, (double)hdcHumidity);
 
      sprintf(myStr, "%s\t%s t1 %d h1 %d", gatewayEpoch, devIDStr, (int)(hdcTemp * 100), (int)(hdcHumidity * 100));
      //                sprintf(myStr, "%0d I: %s t %3.2f %02X h %3.2f %d", bleIndex, devIDStr, hdcTemp, tempStatus,
      // hdcHumidity, 123456789);
      // sprintf(myStr,"0123456789012345678901234567890123456789");
    } else if ((byte[0] & 0x6) == 0x2) /* temperature only read */
    {
      //          sprintf(myStr, "I: %0d ID: %s t1 %3.2f\r\n", bleIndex, devIDStr, (double)hdcTemp);
      sprintf(myStr, "I: %s ID: %s t1 %d\r\n", gatewayEpoch, devIDStr, (int)(hdcTemp * 100));
    } else if ((byte[0] & 0x6) == 0x4) /* humidity only read */
    {
      //          sprintf(myStr, "I: %0d ID: %s h1 %3.2f\r\n", bleIndex, devIDStr, (double)hdcHumidity);
      sprintf(myStr, "I: %s ID: %s h1 %d\r\n", gatewayEpoch, devIDStr, (int)(hdcHumidity * 100));
    }
    if (flashParameters.silent == false) {
      myPrintkI("%s\r\n", myStr);
    }
    bt_nus_send(NULL, myStr, strlen(myStr));
    k_sleep(K_SECONDS(2));
 
    if (flashParameters.ignoreBME688 == false) {
      /* send BME688 data  */
      //            sprintf(myStr, "%0d %s t %3.2f h %3.2f p %3.2f r %3.2f", bleIndex, devIDStr,  BME688Data.temperature,
      // BME688Data.humidity, BME688Data.pressure, BME688Data.gas_resistance);
      //        sprintf(myStr, "%0d\t%s t2 %3.2f h %3.2f", bleIndex, devIDStr, (double)BME688Data.temperature,
      //        (double)BME688Data.humidity);
      sprintf(myStr, "%s\t%s t2 %d h %d", gatewayEpoch, devIDStr, (int)(BME688Data.temperature * 100), (int)(BME688Data.humidity * 100));
      // sprintf(myStr, "%0d %s  p %3.2f r %3.2f", bleIndex, devIDStr, BME688Data.pressure, BME688Data.gas_resistance);
      if (flashParameters.silent == false) {
        myPrintkI("%s\r\n", myStr);
      }
      bt_nus_send(NULL, myStr, strlen(myStr));
      k_sleep(K_SECONDS(2));
 
      /* send BME688 data  */
      // sprintf(myStr, "%0d\t%s p2 %3.2f", bleIndex, devIDStr, BME688Data.pressure);
      //        sprintf(myStr, "%0d\t%s p2 %d", bleIndex, devIDStr, (int)BME688Data.pressure);
      sprintf(myStr, "%s\t%s p2 %d", gatewayEpoch, devIDStr, (int)BME688Data.pressure);
      if (flashParameters.silent == false) {
        myPrintkI("%s\r\n", myStr);
      }
      bt_nus_send(NULL, myStr, strlen(myStr));
      k_sleep(K_SECONDS(2));
 
      /* send BME688 data  */
      // sprintf(myStr, "%0d\t%s r2 %3.2f", bleIndex, devIDStr, BME688Data.gas_resistance);
      //        sprintf(myStr, "%0d\t%s r2 %d", bleIndex, devIDStr, (int)BME688Data.gas_resistance);
      sprintf(myStr, "%s\t%s r2 %d", gatewayEpoch, devIDStr, (int)BME688Data.gas_resistance);
      if (flashParameters.silent == false) {
        myPrintkI("%s\r\n", myStr);
      }
      bt_nus_send(NULL, myStr, strlen(myStr));
      k_sleep(K_SECONDS(2));
    }
    /* send battery data  */
    err = adc_sample();
    //        sprintf(myStr, "%0d\t%s bat %d", bleIndex, devIDStr,
    sprintf(myStr, "%s\t%s bat %d", gatewayEpoch, devIDStr,
            (int)(adc_voltage[0] * 100)); /* since no battery ADC data just send a dummy value */
    if (flashParameters.silent == false) {
      myPrintkI("%s\r\n", myStr);
    }
    bleLoopCount = -1; /* reset loop count */
    bt_nus_send(NULL, myStr, strlen(myStr));
    k_sleep(K_SECONDS(2));
 
  } else {
    //    switch ((bleLoopCount & 0x7)) {
    //    case 0:                       /* send HDC data */
    //      if ((byte[0] & 0x6) == 0x0) /*both temperature and humidity read */
    //      {
    //        // sprintf(myStr,
    //        //                                sprintf(myStr, "Index: %0d ID: %s t_hdc %3.2f %02X h_hdc
    //        %3.2f
    //        //%02X\r\n", bleIndex, devIDStr, hdcTemp, tempStatus, hdcHumidity, humidityStatus);
    //        // sprintf(myStr, "I: %0d ID: %s t %3.2f %02X h %3.2f %02X\r\n", bleIndex, devIDStr, hdcTemp, tempStatus, hdcHumidity,
    //        // humidityStatus);
    //        //          sprintf(myStr, "%0d\t%s t1 %3.2f h1 %3.2f", bleIndex, devIDStr, (double)hdcTemp, (double)hdcHumidity);
    //        sprintf(myStr, "%s\t%s t1 %3.2f h1 %3.2f", gatewayEpoch, devIDStr, (double)hdcTemp, (double)hdcHumidity);
    //        //                sprintf(myStr, "%0d I: %s t %3.2f %02X h %3.2f %d", bleIndex, devIDStr, hdcTemp, tempStatus,
    //        // hdcHumidity, 123456789);
    //        // sprintf(myStr,"0123456789012345678901234567890123456789");
    //      } else if ((byte[0] & 0x6) == 0x2) /* temperature only read */
    //      {
    //        //          sprintf(myStr, "I: %0d ID: %s t1 %3.2f\r\n", bleIndex, devIDStr, (double)hdcTemp);
    //        sprintf(myStr, "I: %s ID: %s t1 %3.2f\r\n", gatewayEpoch, devIDStr, (double)hdcTemp);
    //      } else if ((byte[0] & 0x6) == 0x4) /* humidity only read */
    //      {
    //        //          sprintf(myStr, "I: %0d ID: %s h1 %3.2f\r\n", bleIndex, devIDStr, (double)hdcHumidity);
    //        sprintf(myStr, "I: %s ID: %s h1 %3.2f\r\n", gatewayEpoch, devIDStr, (double)hdcHumidity);
    //      }
    //      break;
    //
    //    case 1: /* send BME688 data  */
    //      //          sprintf(myStr, "%0d %s t %3.2f h %3.2f p %3.2f r %3.2f", bleIndex, devIDStr,  BME688Data.temperature,
    //      // BME688Data.humidity, BME688Data.pressure, BME688Data.gas_resistance);
    //      //        sprintf(myStr, "%0d\t%s t2 %3.2f h %3.2f", bleIndex, devIDStr, (double)BME688Data.temperature,
    //      //        (double)BME688Data.humidity);
    //      sprintf(myStr, "%s\t%s t2 %3.2f h %3.2f", gatewayEpoch, devIDStr, (double)BME688Data.temperature, (double)BME688Data.humidity);
    //      // sprintf(myStr, "%0d %s  p %3.2f r %3.2f", bleIndex, devIDStr, BME688Data.pressure, BME688Data.gas_resistance);
    //      if (flashParameters.silent == false) {
    //        myPrintkI("%s\r\n", myStr);
    //      }
    //      break;
    //
    //    case 2: /* send BME688 data  */
    //      // sprintf(myStr, "%0d\t%s p2 %3.2f", bleIndex, devIDStr, BME688Data.pressure);
    //      //        sprintf(myStr, "%0d\t%s p2 %d", bleIndex, devIDStr, (int)BME688Data.pressure);
    //      sprintf(myStr, "%s\t%s p2 %d", gatewayEpoch, devIDStr, (int)BME688Data.pressure);
    //      if (flashParameters.silent == false) {
    //        myPrintkI("%s\r\n", myStr);
    //      }
    //      break;
    //
    //    case 3: /* send BME688 data  */
    //            // sprintf(myStr, "%0d\t%s r2 %3.2f", bleIndex, devIDStr, BME688Data.gas_resistance);
    //            //        sprintf(myStr, "%0d\t%s r2 %d", bleIndex, devIDStr, (int)BME688Data.gas_resistance);
    //      sprintf(myStr, "%s\t%s r2 %d", gatewayEpoch, devIDStr, (int)BME688Data.gas_resistance);
    //      if (flashParameters.silent == false) {
    //        myPrintkI("%s\r\n", myStr);
    //      }
    //      break;
    //
    //    case 4: /* send battery data  */
    //      err = adc_sample();
    //      //        sprintf(myStr, "%0d\t%s bat %d", bleIndex, devIDStr,
    //      sprintf(myStr, "%s\t%s bat %d", gatewayEpoch, devIDStr,
    //              (int)(adc_voltage[0] * 100)); /* since no battery ADC data just send a dummy value */
    //      if (flashParameters.silent == false) {
    //        myPrintkI("%s\r\n", myStr);
    //      }
    //      bleLoopCount = -1; /* reset loop count */
    //      break;
    //    } /* end of switch statement */
    //
    //    if (flashParameters.silent == false) {
    //      //              if (status & DRDY_STATUS)
    //      //                  myPrintkI("DRDY Set\r\n");
    //      if (status & TH_STATUS)
    //        myPrintkI("Temp High Set\r\n");
    //      if (status & TL_STATUS)
    //        myPrintkI("Temp Low Set\r\n");
    //      if (status & HH_STATUS)
    //        myPrintkI("Humidity High Set\r\n");
    //      if (status & HL_STATUS)
    //        myPrintkI("Humidity Low Set\r\n");
    //    }
    //
    //    if (flashParameters.dutyCycle > 7) {
    //      hdcMinutes--;
    //      if (hdcMinutes != 0) {
    //        return; /* minutes timer not expired */
    //      } else {
    //        hdcMinutes = flashParameters.dutyCycle - 7;
    //      }
    //    }
    // #if 1
    //    //            if ((bleLoopCount & 0x3) == 0)
    //    {
    //      bleIndex++; /* update the BLE index counter */
    //      if (bt_nus_send(NULL, myStr, strlen(myStr))) {
    //        /* save BLE packet if failed to send */
    //        if (flashParameters.savedCount < MAX_NUMBER_BLE_PACKETS) {
    //          memset(tmpData, 0, 256);
    //          strcpy(tmpData, myStr); /* copy string that did not get sent to empty buffer*/
    //          flashxWritePage(FLASHBLESTART + flashParameters.nextSavedWrite, 0, tmpData, 256); /* save in flash and update write
    //          address*/ flashParameters.savedCount++; flashParameters.nextSavedWrite++; setFlashxParameters(false); myPrintkW("BLE packet
    //          saved to Flash Memory %d of %d\r\n", flashParameters.savedCount, MAX_NUMBER_BLE_PACKETS);
    //        } else {
    //          myPrintkW("BLE packet saved Flash Memory full\r\n");
    //        }
    //        if (flashParameters.silent == false) {
    //          myPrintkW("Failed to send data over BLE connection: %d %s\r\n", strlen(myStr), myStr);
    //        }
    //      } else {
    //        /* packet sent correctly */
    //        if (flashParameters.silent == false) {
    //          if (flashParameters.savedCount > 0) {
    //            while (flashParameters.savedCount > 0) {
    //
    //              //                          k_sleep(K_SECONDS(1)); /* send next saved packet since connection is
    //              // valid again */
    //              flashxReadPage(flashParameters.nextSavedRead + FLASHBLESTART, flashReadIn);
    //              strcpy(myStr, flashReadIn);
    //              flashParameters.savedCount--;
    //              flashParameters.nextSavedRead++;
    //              setFlashxParameters(false);
    //              bt_nus_send(NULL, myStr, strlen(myStr)); /* send saved packet*/
    //              myPrintkS("Sent saved data over BLE connection: %s\r\n", myStr);
    //            }
    //
    //            /* all saved packets have been sent so clear BLE saved packet memory */
    //            flashParameters.nextSavedRead = 0;
    //            flashParameters.nextSavedWrite = 0;
    //            flashParameters.savedCount = 0;
    //            myPrintkI("Saved JSON Packets Cleared\r\n");
    //            setFlashxParameters(false);
    //            sectorCount = (MAX_NUMBER_BLE_PACKETS / 0x10) + 1; /* get number of sectors needed for number of BLE packets*/
    //            for (int i = 0; i < sectorCount; i++) {
    //              flashxEraseSector((FLASHBLESTART / 0x10) + i); /* erase the next sector */
    //            }
    //          }
    //          myPrintkS("Sent data over BLE connection: %d %s\r\n", strlen(myStr), myStr);
    //        }
    //      }
    //    }
    // #endif
  }
}
 
void ble_write_thread(void) {
#if 0
    /* Don't go any further until BLE is initialized */
    k_sem_take(&ble_init_ok, K_FOREVER);
    struct uart_data_t nus_data = {
        .len = 0,
    };
 
    for (;;)
    {
        /* Wait indefinitely for data to be sent over bluetooth */
        struct uart_data_t *buf = k_fifo_get(&fifo_uart_rx_data,
                                             K_FOREVER);
 
        int plen = MIN(sizeof(nus_data.data) - nus_data.len, buf->len);
        int loc = 0;
 
        while (plen > 0)
        {
            memcpy(&nus_data.data[nus_data.len], &buf->data[loc], plen);
            nus_data.len += plen;
            loc += plen;
 
            if (nus_data.len >= sizeof(nus_data.data) ||
                (nus_data.data[nus_data.len - 1] == '\n') ||
                (nus_data.data[nus_data.len - 1] == '\r'))
            {
                if (bt_nus_send(NULL, nus_data.data, nus_data.len))
                {
                    LOG_WRN("Failed to send data over BLE connection");
                }
                nus_data.len = 0;
            }
 
            plen = MIN(sizeof(nus_data.data), buf->len - loc);
        }
 
        k_free(buf);
    }
#else
  uint8_t myBuff[128];
  //    uint8_t status;
  int i;
  //    uint8_t str[120];
 
  /* Don't go any further until BLE is initialized */
  k_sem_take(&ble_init_ok, K_FOREVER);
  struct uart_data_t nus_data = {
      .len = 0,
  };
 
  for (;;) {
    /* Wait indefinitely for data to be sent over bluetooth */
    struct uart_data_t *buf = k_fifo_get(&fifo_uart_rx_data, K_FOREVER); /* get uart data */
 
    int plen = MIN(sizeof(nus_data.data) - nus_data.len, buf->len);
    int loc = 0;
 
    memset(myBuff, 0, sizeof(myBuff)); /* clear UART recved buffer */
    while (plen > 0) {
      memcpy(&nus_data.data[nus_data.len], &buf->data[loc], plen);
      nus_data.len += plen;
      loc += plen;
 
      /* wait for CR or LF */
      if (nus_data.len >= sizeof(nus_data.data) || (nus_data.data[nus_data.len - 1] == '\n') || (nus_data.data[nus_data.len - 1] == '\r')) {
        nus_data.data[nus_data.len - 1] = '\0';
        nus_data.len--;
        //              printf("RX buf len: %d %s\r\n", nus_data.len, nus_data.data);
        strncpy(myBuff, nus_data.data, nus_data.len);
        for (i = 0; i < strlen(myBuff); i++) {
          if ((myBuff[i] == '\r') || (myBuff[i] == '\n'))
            myBuff[i] = '\0';
          //            printf("i: %d 0x%02X %c\r\n",i,myBuff[i],myBuff[i]);
        }
        //              int len = strlen(myBuff);
        strcpy(cliCMD, myBuff);
        //              executeCmd(myBuff);
        k_sem_give(&cli_cmd_seen); /* indicate HDC2080 RDY seen */
        //          if (bt_nus_send(NULL, nus_data.data, nus_data.len))
        //              {
        //                  LOG_WRN("Failed to send data over BLE connection");
        //              }
        nus_data.len = 0;
      }
 
      plen = MIN(sizeof(nus_data.data), buf->len - loc);
    }
 
    k_free(buf);
  }
#endif
}
 
/* TJM added functions */
/*!
 * \fn int init_i2c()
 * \brief Initializes the I2C interface
 * \return TRUE if successful, FALSE otherwise
 * This function initializes the I2C interface by configuring the I2C peripheral with the specified speed and mode. It checks if the I2C
 device is ready and then configures it. If any step fails, it returns FALSE; otherwise, it returns TRUE to indicate successful
 initialization.
 *
 * Note: The I2C speed is set to fast mode, and the device is configured as a controller. The function also includes debug print statements
 to indicate the status of the initialization process.
 
 *
 */
int init_i2c() {
  uint32_t i2c_cfg = I2C_SPEED_SET(I2C_SPEED_FAST) | I2C_MODE_CONTROLLER;
 
  myPrintk("*** I2C Init ***\r\n");
  myPrintkS("Initializing I2C device\r\n");
 
  if (!device_is_ready(i2c_dev)) /* check if I2C peripheral ready */
  {
    myPrintkE("I2C device is not ready\n");
    return FALSE;
  }
  myPrintkI("I2C device is ready\n");
 
  /* 1. verify i2c_configure() */
  if (i2c_configure(i2c_dev, i2c_cfg)) /* configure I2C peripheral */
  {
    myPrintkE("I2C config failed\n");
    return FALSE;
  }
  myPrintkI("I2C config passed %08X\n", i2c_cfg);
  return TRUE;
}
 
/*!
 * \fn void hdc2080_rdy_seen(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
 * \brief Callback function for HDC2080 RDY pin
 * \param dev Pointer to the device structure
 * \param cb Pointer to the GPIO callback structure
 * \param pins GPIO pin mask
 * This function is a callback that is triggered when the HDC2080 RDY pin is activated. It checks if the specific pin associated with the
 * HDC2080 is part of the pins that triggered the callback. If it is, it gives a semaphore to indicate that the HDC2080 RDY signal has been
 * seen, allowing other parts of the program to proceed with reading data from the sensor or performing other actions that depend on the RDY
 * signal. The function includes commented-out code for debugging purposes, which can be used to print the state of the pin and the pins
 * that triggered the callback.
 *
 */
void hdc2080_rdy_seen(const struct device *dev, struct gpio_callback *cb, uint32_t pins) {
  //    int pinx,piny;
 
  if (BIT(hdc2080.pin) & pins) {
    //      pinx = gpio_pin_get_raw(hdc2080.port,hdc2080.pin);
    //      piny = gpio_pin_get(hdc2080.port,hdc2080.pin);
    //      printf("Button %d %d %08X pressed at %" PRIu32 "\n",pinx, piny, pins, k_cycle_get_32());
    /* show RX received */
    k_sem_give(&hdc_rdy_seen); /* indicate HDC2080 RDY seen */
  }
}
 
/*!
 * \fn void sw2_seen(const struct device *dev, struct gpio_callback *cb, uint32_t pins)
 * \brief Callback function for SW2 button
 * \param dev Pointer to the device structure
 * \param cb Pointer to the GPIO callback structure
 * \param pins GPIO pin mask
 * This function is a callback that is triggered when the SW2 button is pressed. It checks if the specific pin associated with the SW2
 * button is part of the pins that triggered the callback. If it is, it gives a semaphore to indicate that the SW2 button has been seen,
 * allowing other parts of the program to proceed with actions that depend on the SW2 button press. The function includes commented-out code
 * for debugging purposes, which can be used to print the state of the pin and the pins that triggered the callback.
 */
void sw2_seen(const struct device *dev, struct gpio_callback *cb, uint32_t pins) {
  //    int pinx,piny;
 
  if (BIT(sw2.pin) & pins) {
    k_sem_give(&sw2_rdy_seen); /* indicate HDC2080 RDY seen */
  }
}
 
/**
 * \fn uint8_t bleCommand(uint8_t *data)
 * \brief Executes a BLE command
 * \param data Pointer to the command data
 * \return TRUE if the command is executed successfully, FALSE otherwise
 * This function takes a pointer to the command data received over BLE, processes it, and executes the corresponding command. It includes
 * debug print statements to indicate the received command and its length. The function can be expanded to include specific command parsing
 * and execution logic based on the content of the data. In the provided code, there is a placeholder for command execution, and the actual
 * implementation can be added as needed. The function currently returns TRUE to indicate that the command has been processed, but this can
 * be modified to return FALSE if the command is invalid or if there is an error during execution.
 *
 */
uint8_t bleCommand(uint8_t *data) {
//  myPrintkI("\r\n BLE Command: %s Len %d\r\n", data, strlen(data));
#if 0
    int cmd;
 
    cmd = getCmd(data);
    myPrintkI("cmd: %d numParameters: %d ", cmd, numParameters);
    //  for(int i=0;i< numParameters;i++)
    //  {
    //      printf("i: %d %s\r\n",i,cmdLineParameter[i]);
    //  }
 
    /* execute BLE command */
    switch (cmd)
    {
    case CR:
        myPrintkI("Conv Rate %d\r\n", atoi(cmdLineParameter[1]));
        setRate(atoi(cmdLineParameter[1])); /* set auto conversion rate */
        break;
 
    default:
        myPrintkW("unknown BLE command %s\r\n", data);
    }
#else
  myPrintkS("BLE Command: %s Len %d\r\n", data, strlen(data));
  data[strlen(data) - 2] = '\0';
  executeCmd(data);
#endif
  return TRUE;
}
 
/*!
 * \fn void rescan(void)
 * \brief rescan all I2C and SPI devices
 *
 * This function rescans all I2C and SPI devices by calling the initialization functions for each device. It checks if the HDC2080,
 * W25Q64JV, and BME688 devices are available and properly initialized. If any of the initialization functions fail, it can be modified to
 * handle the error accordingly. The function includes calls to the initialization functions for each device and can be expanded to include
 * additional devices as needed. The current implementation assumes that the initialization functions will handle any necessary error
 * reporting and that the rescan function will simply call them in sequence.
 *
 */
void rescan(void) {
  int err;
 
  err = initHDC2080(); /* check if HDC2080 available */
 
  err = initW25Q64JV(); /* check if W25Q64JV available */
 
  if (flashParameters.ignoreBME688 == false) {
    err = initBME688(); /* check if BME688 available */
  }
  return;
}
 
/**
 * \fn void myPrintk(char *str)
 *
 * \brief prints a string to the UART
 *
 * @param str ASCII string to print
 *
 * \return HAL_OK if passed<p>
 *
 */
// void myPrintk(char *str)
//{
//  printk("%s", str);
//  return;
// }
 
int myPrintk(char *restrict fmt, ...) {
  int n = 0;
#if CONFIG_SERIAL
  va_list ap;
 
  va_start(ap, fmt);
  n = vprintf(fmt, ap);
  va_end(ap);
#endif
  return n;
}
 
/*
 * Black \033[0;30m.
 * Red \033[0;31m.
 * Green \033[0;32m.
 * Yellow \033[0;33m.
 * Blue \033[0;34m.
 * Purple \033[0;35m.
 * Cyan \033[0;36m.
 * White \033[0;37m.
 */
 
/* yellow (Warning)*/
// void myPrintkW(char *str)
//{
//  printk("%s", "\33[1;33m");
//  printk("%s", str);
//  // printk("%s", myStr);
//  printk("%s", "\33[0m");
//  return;
// }
 
/*!
 * \fn int myPrintkW(char *restrict fmt, ...)
 * \brief prints a warning message to the UART
 * \param fmt format string
 * \return number of characters printed
 * This function prints a warning message to the UART in yellow color. It takes a format string and additional arguments, similar to printf,
 * and formats the message accordingly. The function uses ANSI escape codes to set the text color to yellow before printing the message and
 * resets it back to default afterward. The number of characters printed is returned as an integer.
 *
 */
int myPrintkW(char *restrict fmt, ...) {
  int n = 0;
#if CONFIG_SERIAL
  va_list ap;
 
  printk("\33[1;33m");
  va_start(ap, fmt);
  vprintk(fmt, ap);
  va_end(ap);
  printk("\33[0m");
#endif
  return n;
}
 
/* Green (Information)*/
// void myPrintkI(char *str)
//{
//  printk("%s", "\33[1;32m");
//  printk("%s", str);
//  printk("%s", "\33[0m");
//  return;
// }
 
/*!
 * \fn int myPrintkI(char *restrict fmt, ...)
 * \brief prints an information message to the UART
 * \param fmt format string
 * \return number of characters printed
 * This function prints an information message to the UART in green color. It takes a format string and additional arguments, similar to
 * printf, and formats the message accordingly. The function uses ANSI escape codes to set the text color to green before printing the
 * message and resets it back to default afterward. The number of characters printed is returned as an integer.
 *
 */
int myPrintkI(char *restrict fmt, ...) {
  int n = 0;
#if CONFIG_SERIAL
  va_list ap;
 
  printk("\33[1;32m");
  va_start(ap, fmt);
  vprintk(fmt, ap);
  va_end(ap);
  printk("\33[0m");
#endif
  return n;
}
 
/* CYAN (Status)*/
// void myPrintkS(char *str)
//{
//  printk("%s", "\33[1;36m");
//  printk("%s", str);
//  printk("%s", "\33[0m");
//  return;
// }
 
/*!
 * \fn int myPrintkS(char *restrict fmt, ...)
 * \brief prints a status message to the UART
 * \param fmt format string
 * \return number of characters printed
 * This function prints a status message to the UART in cyan color. It takes a format string and additional arguments, similar to printf,
 * and formats the message accordingly. The function uses ANSI escape codes to set the text color to cyan before printing the message and
 * resets it back to default afterward. The number of characters printed is returned as an integer.
 *
 */
int myPrintkS(char *restrict fmt, ...) {
  int n = 0;
#if CONFIG_SERIAL
  va_list ap;
 
  printk("\33[1;36m");
  va_start(ap, fmt);
  vprintk(fmt, ap);
  va_end(ap);
  printk("\33[0m");
#endif
  return n;
}
 
/* Red (Error)*/
// void myPrintkE(char *str)
//{
//  printk("%s", "\33[1;31m");
//  printk("%s", str);
//  printk("%s", "\33[0m");
//  return;
// }
 
/*!
 * \fn int myPrintkE(char *restrict fmt, ...)
 * \brief prints an error message to the UART
 * \param fmt format string
 * \return number of characters printed
 * This function prints an error message to the UART in red color. It takes a format string and additional arguments, similar to printf,
 * and formats the message accordingly. The function uses ANSI escape codes to set the text color to red before printing the message and
 * resets it back to default afterward. The number of characters printed is returned as an integer.
 *
 */
int myPrintkE(char *restrict fmt, ...) {
  int n = 0;
#if CONFIG_SERIAL
  va_list ap;
 
  printk("\33[1;31m");
  va_start(ap, fmt);
  vprintk(fmt, ap);
  va_end(ap);
  printk("\33[0m");
#endif
  return n;
}
 
K_THREAD_DEFINE(ble_write_thread_id, STACKSIZE, ble_write_thread, NULL, NULL, NULL, PRIORITY, 0, 0);