jfet_commandLine.c

Go to the documentation of this file.

/*!
 * \file jfet_commandLine.c
 *
 * \brief Command Line Interface (CLI) functions and commands
 *
 * \copyright  J Factor Embedded Technologies LLC. 2026
 * \copyright  TJM Embedded Software LLC. 2026
 * \author  T. J. Mulrooney
 */
/*
 * All Rights Reserved
 * UNPUBLISHED, LICENSED SOFTWARE.
 *
 * CONFIDENTIAL AND PROPRIETARY INFORMATION
 * WHICH IS THE PROPERTY OF J-Factor Embedded Technologies.
 *
 */
#define __USE_MINGW_ANSI_STDIO 1
 
// #include <event_manager.h>
// #include <drivers/uart.h>
#include "jfet_files/common.h"
#include "jfet_files/w25q64jv_Driver.h"
#include <zephyr/drivers/i2c.h>
// #include "cloud/cloud_codec/cloud_codec.h"
#include "HDC2080.h"
#include "ncs_version.h"
#include <bluetooth/services/nus.h>
#include <zephyr/drivers/uart.h>
#include <zephyr/pm/device.h>
 
////#include <net/aws_iot.h>
// #include "time.h"
// #include <date_time.h>
//
///* prottypes */
// uint8_t getLine(void);
void executeCmd(char *line);
int8_t getCLICmd(char *line);
void cliADC();
void cliBatMon();
void cliBME688();
void cliBME688CS();
void cliDeviceID();
void cliDeviceInfo();
void cliCustomer();
void cliDateTime();
void cliDutyCycle();
void cliFlashErase();
void cliFlashEraseSector();
void cliFlashFillPage();
void cliFlashID();
void cliFlashNSS();
void cliFlashReadPage();
void cliFlashStatus();
void cliFlashWritePage();
void cliGroup();
void cliHelp();
void cliHumidity();
void cliNouart0(void);
void cliI2CRead();
void cliI2CWrite();
void cliIgnoreBME688();
void cliLocation();
void cliManualTrigger(void);
void cliPublishNow();
void cliReset();
void cliResetCause();
void cliSaved();
void cliSensorID();
void cliSensorName();
void cliSensors();
void cliSilent();
void cliTemperature();
void cliVersion();
void displayHelp(char c);
int uart_init(void);
 
// void displayTouchHandler(unsigned char *ptrBuf, int cnt);
////int aws_iot_disconnect(void);
// int time_NTP_server_get(void);
//
///* external */
////extern struct cloud_data_cfg current_cfg;
// extern struct time_aux {
//  int64_t date_time_utc;
//  int64_t last_date_time_update;
// } time_aux;
//
////#include <strings.h>
// enum at_cmd_state cmd_state;     //!<state of AT command executed from command line
//
///* globals */
// uint8_t escapeSeen = 0;      //!<escape sequence seen
 
/* enums */
enum COMMANDS //!< vaild command indexes
{
  ADCX,
  //    ALARMSENABLED,
  BATMON,
  BME688,
  BME688CS,
  DATETIME,
  DEVICEID,
  DEVICEINFO,
  CUSTOMER,
  //    DISTRIBUTOR,
  DUTYCYCLE,
  FLASHERASE,
  FLASHERASESECTOR,
  FLASHFILLPAGE,
  FLASHID,
  FLASHNSS,
  FLASHREADPAGE,
  FLASHSTATUS,
  FLASHWRITEPAGE,
  FLASHPARAMETERS,
  GROUP,
  HELP,
  HUMIDITY,
  I2CREAD,
  I2CWRITE,
  IGNOREBME688,
  LOCATION,
  MANUALTRIGGER,
  NOUART0,
  PUBLISHNOW,
  RESCAN,
  RESETX,
  RESETCAUSE,
  SAVED,
  SENSORID,
  SENSORNAME,
  SILENT,
  SENSORS,
  TEMP,
  VERSIONX,
};
 
#define LINE_SIZE 90 //!< maximum number of characters on a CLI line
#define NUM_LINES 10 //!< maximum number of lines in saved history
 
/* Prototypes */
 
/* externs */
// extern UART_HandleTypeDef UartHandle;
 
/* Locals */
// static char line[LINE_SIZE];                           //!< character array read
////char lineDownlink[200];                   //!< character array downlink
////char downlinkIMEI[30];                          //<! character array fro downlink IMEI
static char lineTmp[LINE_SIZE]; //!< tempory line saved
// static char lastLine[NUM_LINES][LINE_SIZE];            //!< array of previous command lines
// static int8_t indexNextLineIn = 0;                     //!< index of next position to save current command line
// static int8_t indexNextLineOut = 0;                    //!< index of next position to read out saved command lines
// static int8_t linesInBuffer = 0;                       //!< number of lines in  command line buffer
// static int8_t charCount;                               //!< number of characters in the current command line
// static int8_t cursorPosition;                          //!< current cursor position in the current command line
//
//
/* sensor types and state (present = 1) */
 
char *sensorTypeNames[] = //!< sensor types and state (present = 1)
    {
        "HDC2080 - temperature/Humidty Sensor(I2C 0x40)",
        "W25Q64JV - 64MB Flash memory(SPI CS1)",
        "BME688 - Gas/Pressure/temperature/Humidty Sensor(SPI CS2)",
        "Unknown",
};
 
char const *validCLICmds[] = //!< array of valid commands - case insensitive
    {
        "adc",
        //  "alarmsenabled",
        "batmon",
        "bme688",
        "bme688cs",
        "datetime",
        "deviceid",
        "deviceinfo",
        "customer",
        //  "distributor",
        "dutycycle",
        "flasherase",
        "flasherasesector",
        "flashfillpage",
        "flashid",
        "flashnss",
        "flashreadpage",
        "flashstatus",
        "flashwritepage",
        "flashparameters",
        "group",
        "help",
        "humidity",
        "i2cread",
        "i2cwrite",
        "ignorebme688",
        "location",
        "manualtrigger",
        "nouart0",
        "publishnow",
        "rescan",
        "reset",
        "resetcause",
        "saved",
        "sensorid",
        "sensorname",
        "silent",
        "sensors",
        "temp",
        "version",
};
 
char const *helpMessages[] = {
    "adc - display Battery voltage AIN0",
    //    "alarmsenabled [0/1/t/T/f/F]- display/set alarms enabled",
    "batmon - <0 | 1> enable or disable Battery monitor",
    "bme688 <n> - read n sample from BME688",
    "bme688cs <0 | 1> - display/set BME688 CS",
    "datetime save data/time from gateway"
    "deviceid - display Device ID",
    "deviceinfo - display device information",
    "customer [X]- display/set customer",
    //    "distributor [X]- display/set distributor",
    "dutycycle [0 <minutes> | 1-7] - 0=minutes,1=2min,2=1min,3=10secs,4=5secs,5=1secs,6=.5secs,7=.2secs",
    "flasherase -  erase entire memory",
    "flasherasesector - [sector] erase 256K Byte sector X (default 0) range ( 0 -> 31)",
    "flashfillpage [page data length] - fill length pages with data starting at page",
    "flashid - display serial flash ID",
    "flashnss <0 | 1> - set SPI NSS",
    "flashparameters - list the saved flash parameters",
    "flashreadpage [page length] - read length pages starting at page",
    "flashstatus - display serial flash status registers",
    "flashwritepage page address data - write data to address in page",
    ////    "gps - display cirrent GPS location",
    ////    "gpsenable - [0/1] enable or disable gps",
    ////    "gpsfixcheck - [n] display/set GPS fix check time",
    ////    "gpsexternal - [0/1] external or internal gps",
    "group [X]- display/set group",
    "help [c] - display list of valid commands starting with c",
    "humidity- display humidity",
    "i2cread [add reg length] - read length bytes from I2C address starting at r",
    "i2cwrite add reg data length - write byte to I2C address at reg",
    "ignorebme688 [0 | 1] - display set ignore BME688 flag",
    "location [X]- display/set location",
    "manualtrigger [0 | 1] - display set manual trigger flag",
    "nouart0 [0/1] - display/set No UART0",
    "publishnow- publish a BLE payload now",
    "rescan - rescan for connected devices",
    "reset [x]- reset the board any paramter causes a WDT reset",
    "resetCause - display reason for last reset ",
    "saved [clear | n] [count]- display count saved flash JSON packets or clear all saved packets",
    "sensorid [X]- display/set sensor ID",
    "sensorname - display/set sensor name",
    "sensors - display available sensors",
    "silent [0 | 1]- display/set silent flag",
    "temp- display sensor temperatures ",
    "version - display version information",
    "END",
}; //!< array of help messages
 
/*!
 * \fn void executeCmd(char *line)
 *
 * \brief executes the command in line array.
 *
 */
void executeCmd(char *line) {
  int8_t cmd;
  //    uint32_t i;
  //    int ret;
  //    uint32_t length;
  //    char str[80];
  ////    uint32_t pageAddress;
  //    uint8_t write_buffer[DATA_LENGTH];
  ////    struct tm time;
  //    int j;
  //    int k;
  ////    int l,m;
  //    float temp, tempMin, tempMax;
  //    float tempHum;
  //    //float uva,uvb,uvi;
  //    double testd = 1.23;
  //    enum at_cmd_state state;
  //    char *ceregState[] =
  //    {
  //      "Not registered. User Equipment (UE) is not currently searching for an operator to register to",
  //      "Registered, home network",
  //      "Not registered, but UE is currently trying to attach or searching an operator to register to",
  //      "Registration denied",
  //      "Unknown (e.g. out of E-UTRAN coverage)",
  //      "Registered, roaming",
  //      "Not registered due to Universal Integrated Circuit Card (UICC) failure",
  //    };
  strcpy(lineTmp, line); /* save command line */
  cmd = getCLICmd(line);
  myPrintk("\r\n");
  //    myPrintk("cmd: %d numParameters: %d\r\n",cmd,numParameters);
 
  /* execute command */
  switch (cmd) {
  case ADCX:
    cliADC();
    break; /* read and display ADC voltage */
  case BATMON:
    cliBatMon();
    break; /* set Battery Monitor GPIO */
  case BME688:
    cliBME688();
    break; /* set BME688 read */
  case BME688CS:
    cliBME688CS();
    break; /* set BME688 CS GPIO */
  case CUSTOMER:
    cliCustomer();
    break; /* display Customer ID   */
  case DATETIME:
    cliDateTime();
    break; /* display Device ID*/
  case DEVICEID:
    cliDeviceID();
    break; /* display Device ID*/
  case DEVICEINFO:
    cliDeviceInfo();
    break; /* display Device Information */
  case DUTYCYCLE:
    cliDutyCycle();
    break; /* display Device ID*/
  case FLASHERASE:
    cliFlashErase();
    break; /* erase Flash entire device */
  case FLASHERASESECTOR:
    cliFlashEraseSector();
    break; /* erase Flash sector */
  case FLASHFILLPAGE:
    cliFlashFillPage();
    break; /* fill flash page */
  case FLASHID:
    cliFlashID();
    break; /* display Flash ID */
  case FLASHNSS:
    cliFlashNSS();
    break; /* set/clear Flash NSS */
  case FLASHPARAMETERS:
    displayFlashxParameters();
    break; /* display all Flash Parameters */
  case FLASHREADPAGE:
    cliFlashReadPage();
    break; /* read n pages of Flash */
  case FLASHSTATUS:
    cliFlashStatus();
    break; /* display Flash Status Info */
  case FLASHWRITEPAGE:
    cliFlashWritePage();
    break; /* write a byte to a page */
  case GROUP:
    cliGroup();
    break; /* display group information */
  case HELP:
    cliHelp();
    break; /* display help message */
  case HUMIDITY:
    cliHumidity();
    break; /* display Humidity */
  case I2CREAD:
    cliI2CRead();
    break; /* I2C read */
  case I2CWRITE:
    cliI2CWrite();
    break; /* I2C Write */
  case NOUART0:
    cliNouart0();
    break; /* set/display nouart0 */
  case IGNOREBME688:
    cliIgnoreBME688();
    break; /* display/set ignore BME688 flag */
  case LOCATION:
    cliLocation();
    break; /* display/set location */
  case MANUALTRIGGER:
    cliManualTrigger();
    break; /* display/set manual trigger */
  case PUBLISHNOW:
    cliPublishNow();
    break; /* Publish BLE data immediately */
  case RESCAN:
    rescan();
    break; /* rescan for connected devices */
  case RESETX:
    cliReset();
    break; /* software reset processor */
  case RESETCAUSE:
    cliResetCause();
    break; /* processor reset cause */
  case SAVED:
    cliSaved();
    break; /* display connected sensors */
  case SENSORID:
    cliSensorID();
    break; /* display/set sensor ID */
  case SENSORNAME:
    cliSensorName();
    break; /* display/set sensor name */
  case SENSORS:
    cliSensors();
    break; /* display connected sensors */
  case SILENT:
    cliSilent();
    break; /* display connected sensors */
  case TEMP:
    cliTemperature();
    break; /* display temperature */
  case VERSIONX:
    cliVersion();
    break; /* display Version Info */
 
  default:
    if (((line[0] == 'a') || (line[0] == 'A')) && ((line[1] == 't') || (line[1] == 'T')))
      break;
    if (strlen(line) != 0) {
      myPrintk("Unknown cmd: %s\r\nType help for list of valid commands\r\n", line);
      //                linesInBuffer--;
      //                indexNextLineIn--;
      //                if(linesInBuffer == NUM_LINES)
      //                    indexNextLineIn = NUM_LINES -1;
    }
    break;
  }
}
 
/*!
 * \fn int8_t getCLICmd(char *line)
 *
 * \brief parses command line to find position of command in validCLICmds array.
 *
 * goes through line array separated by spaces. cmdLineParameter[numParameters]\n
 * is an array of pointers to the various parameters in the line until the end of line then\n
 * searches cmd array for a match in validCLICmds array.
 *
 * \return int8 - position of command in command array if found. -1 if not found\n
 */
int8_t getCLICmd(char *line) {
  uint8_t i;
  int len = strlen(line);
 
  /* parse all parameters on the command line into cmdLineparameter array */
  numParameters = 0; /* no parameters seen yet */
 
  cmdLineParameter[numParameters++] = &line[0];
  for (i = 0; i < len; i++) {
    //    printk("%d %c\r\n", i, line[i]);
    if (line[i] == ' ') {
      line[i] = '\0';
      cmdLineParameter[numParameters++] = &line[i + 1];
    }
    //    printk("%d %s\r\n", i, cmdLineParameter[i - 1]);
  }
  line[i] = '\0';
 
#if 0
  for(i=0;i<len+1;i++)
  {
      myPrintk("%d %c %02X\r\n",i,line[i],line[i]);
  }
  for(i=0;i<numParameters;i++)
  {
      myPrintk("i: %d Param: %s\r\n",i,cmdLineParameter[i]);
  }
#endif
 
  for (i = 0; i < sizeof(validCLICmds) / sizeof(validCLICmds[0]); i++) {
    if (strcmp(validCLICmds[i], cmdLineParameter[0]) == 0) {
      return i;
    }
  }
  return -1;
}
 
/*!
 * \fn void displayHelp(char c)
 *
 * \brief displays a list of all available CLI commands
 *
 * \param c check for only help messages beginning with c
 *
 */
void displayHelp(char c) {
// #ifndef MEMORYSAVE
#if 1
  int i;
 
  myPrintk("Valid Commands (%c)\r\n", c);
  for (i = 0; 1; i++) {
    if (strstr(helpMessages[i], "END") != NULL) {
      break;
    }
    if ((helpMessages[i][0] == c) || (c == 'z')) {
      myPrintk("%s\r\n", helpMessages[i]);
    }
  }
#endif
}
//
/////*!
//// * \fn char * replace_char(char* str, char find, char replace)
//// *
//// * \brief replace characters in a string
//// *
//// * \param str pointer to string to search
//// * \param find character to look for
//// * \param replace character to replace found character with
//// *
//// * \return char * pointer to new string with replaced characters
//// */
////char * replace_char(char* str, char find, char replace)
////{
////    char *current_pos = strchr(str,find);
////    while (current_pos)
////    {
////        *current_pos = replace;
////        current_pos = strchr(current_pos,find);
////    }
////    return str;
////}
 
/**
 * \fn void cliADC(void)
 *
 * \brief CLI command to sample and display the ADC voltage.
 *
 * This function triggers an ADC sampling process and prints the resulting
 * voltage from the primary channel to the console.
 */
void cliADC(void) {
  int err;
 
  /* Perform an ADC sample to read the current voltage from hardware */
  err = adc_sample();
  if (err) {
    myPrintk("Error in adc sampling: %d\n", err);
  }
 
  /* Display the sampled voltage from the first channel (index 0) */
  myPrintk("ADC: %3.2f\r\n", (double)adc_voltage[0]);
  return;
}
 
/**
 * \fn void cliBatMon(void)
 *
 * @brief CLI command to enable or disable the battery monitor hardware.
 *
 * This function parses the command line parameter to set the state of the
 * battery enable (BATEN) GPIO pin.
 */
void cliBatMon(void) {
  int i;
 
  i = 0;
  /* Check if exactly one argument (0 or 1) is provided */
  if (numParameters != 2) {
    myPrintk("format batmon <0 | 1>\r\n");
    return;
  }
  /* Convert parameter string to integer and update GPIO state */
  i = atoi(cmdLineParameter[1]);
  gpio_pin_set(baten.port, baten.pin, i);
  /* Provide feedback to the user via console */
  myPrintk("Battery Monitor: %s\r\n", i ? "Enabled" : "Disabled");
  return;
}
 
/**
 * \fn void cliBME688(void)
 *
 * @brief CLI command to read and display data from the BME688 sensor
 */
void cliBME688(void) {
  int count = 1; // Default to 1 sample if no argument provided
  int i;
 
  /* Check if user provided a specific number of samples */
  if (numParameters == 1) {
    count = 1;
  }
  if (numParameters == 2) {
    count = atoi(cmdLineParameter[1]);
  }
 
  /* Print header for the sensor data table */
  myPrintk("Sample\tTemperature(deg C)\tPressure(Pa)\tHumidity(%%)\tGas resistance(ohm)\tStatus\n");
  for (i = 0; i < count; i++) {
    /* Fetch data from the sensor */
    getBME688Data(1, TRUE);
    myPrintk("%u\t%.2f", i, (double)BME688Data.temperature);
    myPrintk(" \t\t\t%.2f", (double)BME688Data.pressure);
    myPrintk(" \t%.2f", (double)BME688Data.humidity);
    /* Display gas resistance and status bits */
    myPrintk(" \t\t%.2f", (double)BME688Data.gas_resistance);
    myPrintk(" \t\t0x%02X\r\n", BME688Data.status);
  }
  return;
}
 
/**
 * \fn void cliBME688CS(void)
 * \brief CLI command to manually control the BME688 SPI Chip Select (CS) pin.
 */
void cliBME688CS(void) {
  int i;
  int bme688cs = 0;
  ;
 
  /* Validate that exactly one argument (0 or 1) is provided */
  if (numParameters != 2) {
    myPrintk("format bme688cs 0/1\r\n");
    return;
  }
  if (numParameters == 2) {
    i = atoi(cmdLineParameter[1]);
    if (i == 0) {
      /* Set GPIO high to de-assert the active-low Chip Select */
      gpio_pin_set(spics2n.port, spics2n.pin, 1);
      bme688cs = 0;
    } else {
      /* Set GPIO low to assert the active-low Chip Select */
      gpio_pin_set(spics2n.port, spics2n.pin, 0);
      bme688cs = 1;
    }
  }
  myPrintk("BME688CS: %d\r\n", bme688cs);
  return;
}
 
/**
 * \fn void cliCustomer(void)
 * \brief CLI command to set or display the customer name in flash parameters.
 */
void cliCustomer() {
  /* If arguments are provided, update the customer name */
  if (numParameters > 1) {
    /* Clear existing buffer */
    for (int i = 0; i < sizeof(flashParameters.customer); i++)
      flashParameters.customer[i] = '\0';
 
    /* Copy new customer name from the raw command line (offset 9 for "customer ") */
    strncpy(flashParameters.customer, &lineTmp[9], 39);
    setFlashxParameters(false);
  }
  myPrintk("Customer: %s\r\n", flashParameters.customer);
}
 
/**
 * \fn void int64_to_string(int64_t num, char *str)
 *
 * @brief Converts a 64-bit signed integer to a null-terminated string.
 *
 * @param num The 64-bit integer to convert.
 * @param str Pointer to the destination buffer (must be large enough to hold the result).
 */
void int64_to_string(int64_t num, char *str) {
  /* Handle negative numbers */
  if (num < 0) {
    *str++ = '-';
    num = -num;
  }
 
  char buffer[20]; /* Temporary buffer to hold digits in reverse order (max 19 digits + sign) */
  int i = 0;
  /* Extract digits one by one */
  do {
    buffer[i++] = num % 10 + '0';
    num /= 10;
  } while (num != 0);
 
  /* Reverse the digits into the output string */
  while (i > 0) {
    *str++ = buffer[--i];
  }
  *str = '\0';
}
 
/*!
 * \fn void cliDateTime()
 * \brief CLI command to set or display the gateway epoch timestamp.
 */
void cliDateTime() {
  char str[20]; // Buffer to hold the string representation of the epoch
 
  /* Check if a new epoch timestamp was provided as an argument */
  if (numParameters == 2) {
    //    printk("cmdLineParameter[1] %s\r\n", cmdLineParameter[1]);
    /* Convert the string parameter to a 64-bit integer */
    gatewayDateTime = atoll(cmdLineParameter[1]);
    //    int64_to_string(gatewayDateTime, gatewayEpoch);
    //    sprintf(myStr, "%s\t%s t1 %3.2f h1 %3.2f", gatewayEpoch, devIDStr, (double)hdcTemp, (double)hdcHumidity);
    //    bt_nus_send(NULL, myStr, strlen(myStr));
    //    myPrintkW("%s\r\n", myStr);
  }
  /* Convert the current gatewayDateTime back to a string for display */
  int64_to_string(gatewayDateTime, str);
  //  printk("gateway Date/Time (epoch) %s\r\n", str);
 
  /* if manual trigger set send indication to waiting loop */
  if (flashParameters.manualTrigger) {
    triggerMeasurement();
    k_sem_give(&hdc_rdy_seen); /* indicate HDC2080 RDY seen */
  }
}
 
/** \fn void cliDeviceID(void)
 *
 * \brief Display the unique device identifier string
 */
void cliDeviceID(void) { myPrintkS("Device ID: %s\r\n", devIDStr); }
 
/**
 * \fn void cliDeviceInfo(void)
 *
 * \brief Transmit comprehensive device information over BLE NUS service.
 *
 * This function iterates through various device parameters (ID, Name, Customer, etc.)
 * and sends them both to the local console and over the Bluetooth NUS service.
 */
void cliDeviceInfo(void) {
  char myStr[256];
  char str1[128];
 
  myPrintkS("Device Information \r\n");
  /* Set flag to indicate the system is currently transmitting device metadata */
  sendingDeviceInfo = true;
 
  /* send sensor ID*/
  myPrintkS("Sensor ID: %s\r\n", flashParameters.sensorID);
  sprintf(myStr, "%0d\t%s id %s", bleIndex, devIDStr, flashParameters.sensorID);
  myPrintkS("%s\r\n", myStr);
  bt_nus_send(NULL, myStr, strlen(myStr));
  k_sleep(K_SECONDS(2)); /* Delay to prevent flooding the BLE link */
 
  myPrintkS("Sensor Name: %s\r\n", flashParameters.sensorName);
  sprintf(myStr, "%0d\t%s sn %s", bleIndex, devIDStr, flashParameters.sensorName);
  myPrintkS("%s\r\n", myStr);
  bt_nus_send(NULL, myStr, strlen(myStr));
  k_sleep(K_SECONDS(2));
 
  myPrintkS("Customer: %s\r\n", flashParameters.customer);
  sprintf(myStr, "%0d\t%s cu %s", bleIndex, devIDStr, flashParameters.customer);
  myPrintkS("%s\r\n", myStr);
  bt_nus_send(NULL, myStr, strlen(myStr));
  k_sleep(K_SECONDS(2));
 
  myPrintkS("Group: %s\r\n", flashParameters.group);
  sprintf(myStr, "%0d\t%s gr %s", bleIndex, devIDStr, flashParameters.group);
  myPrintkS("%s\r\n", myStr);
  bt_nus_send(NULL, myStr, strlen(myStr));
  k_sleep(K_SECONDS(2));
 
  myPrintkS("Location: %s\r\n", flashParameters.location);
  sprintf(myStr, "%0d\t%s lo %s", bleIndex, devIDStr, flashParameters.location);
  myPrintkS("%s\r\n", myStr);
  bt_nus_send(NULL, myStr, strlen(myStr));
  k_sleep(K_SECONDS(2));
 
  //   sprintf(str1, "%s%sV %d.%02d %s%s", BOARD_NAME, BOARD_NAME_EXT, VERSION_MAJOR, VERSION_MINOR, VERSION_DATE, VERSION_DATE_EXT);
  if (flashParameters.nouart0 == false) {
    sprintf(str1, "V %d.%02d %s%s", VERSION_MAJOR, VERSION_MINOR, VERSION_DATE, VERSION_DATE_EXT1);
  } else {
    sprintf(str1, "V %d.%02d %s%s", VERSION_MAJOR, VERSION_MINOR, VERSION_DATE, VERSION_DATE_EXT2);
  }
#ifndef CONFIG_SERIAL
  sprintf(str1, "V %d.%02d %s%s", VERSION_MAJOR, VERSION_MINOR, VERSION_DATE, VERSION_DATE_EXT3);
#endif
 
  myPrintkS("Version: %s\r\n", str1);
  sprintf(myStr, "%0d\t%s ve %s", bleIndex, devIDStr, str1);
  myPrintkS("%s\r\n", myStr);
  bt_nus_send(NULL, myStr, strlen(myStr));
  k_sleep(K_SECONDS(2));
 
  sprintf(str1, "nRF52832");
  myPrintkS("Board Version: %s\r\n", str1);
  sprintf(myStr, "%0d\t%s brdV %s", bleIndex, devIDStr, str1);
  myPrintkS("%s\r\n", myStr);
  bt_nus_send(NULL, myStr, strlen(myStr));
  k_sleep(K_SECONDS(2));
 
  sprintf(str1, "%s%s", BOARD_NAME, BOARD_NAME_EXT);
  myPrintkS("Hardware Version: %s\r\n", str1);
  sprintf(myStr, "%0d\t%s hwV %s", bleIndex, devIDStr, str1);
  myPrintkS("%s\r\n", myStr);
  bt_nus_send(NULL, myStr, strlen(myStr));
  k_sleep(K_SECONDS(2));
 
  sprintf(str1, "nRF52832");
  myPrintkS("Chip version: %s\r\n", str1);
  sprintf(myStr, "%0d\t%s hwC %s", bleIndex, devIDStr, str1);
  myPrintkS("%s\r\n", myStr);
  bt_nus_send(NULL, myStr, strlen(myStr));
  k_sleep(K_SECONDS(2));
 
  /* Reset flag to resume normal sensor data transmission */
  sendingDeviceInfo = false;
 
  if (flashParameters.manualTrigger) {
    myPrintkW("Manual trigger Enabled. Waiting for datetime command from gateway.\r\n");
    disableInterrupt();
  }
}
 
/**
 * \fn void cliDutyCycle(void)
 *
 * \brief CLI command to configure the sensor data sampling interval.
 */
void cliDutyCycle(void) {
  int hdcCode;  //!< HDC2080 specific rate code
  char *end;    //!< Pointer for strtoul parsing
  char str[20]; //!< String representation of the duty cycle
 
  /* Handle case where only the HDC2080 rate code is provided */
  if (numParameters == 2) {
    hdcCode = strtoul(cmdLineParameter[1], &end, 10);
    if ((hdcCode > 0) && (hdcCode <= 7)) {
      flashParameters.dutyCycle = hdcCode;
      /* Apply the hardware conversion rate to the sensor */
      setRate(hdcCode); /* set auto conversion rate */
      setFlashxParameters(false);
    } else {
      myPrintk("format dutycycle [HDC2080 Setting 1-7] [minutes > 2 if setting == 0]");
      return;
    }
  }
  /* Handle case where manual minutes are provided (code must be 0) */
  if (numParameters == 3) {
    hdcCode = strtoul(cmdLineParameter[1], &end, 10);
    hdcMinutes = strtoul(cmdLineParameter[2], &end, 10);
    if ((hdcCode == 0) && (hdcMinutes > 2)) {
      flashParameters.dutyCycle = hdcMinutes + 7;
      /* Default to 1 minute hardware rate for long duty cycles */
      setRate(ONE_MINS); /* set auto conversion rate */
      setFlashxParameters(false);
    } else {
      myPrintk("format dutycycle [HDC2080 Setting 1-7] [minutes > 2 if setting == 0]");
      return;
    }
  }
  /* Display the current duty cycle status to the user */
  if (flashParameters.dutyCycle < 7) {
    switch (flashParameters.dutyCycle) {
    case 1:
      strcpy(str, "2 Minutes");
      break;
 
    case 2:
      strcpy(str, "1 Minute");
      break;
 
    case 3:
      strcpy(str, "10 Seconds");
      break;
 
    case 4:
      strcpy(str, "5 Seconds");
      break;
 
    case 5:
      strcpy(str, "1 Second");
      break;
 
    case 6:
      strcpy(str, ".5 Seconds");
      break;
 
    case 7:
      strcpy(str, ".2 Seconds");
      break;
    }
    myPrintk("Duty Cycle: %d Setting %s\r\n", flashParameters.dutyCycle, str);
  } else {
    /* Calculate minutes from the offset dutyCycle value */
    myPrintk("Duty Cycle: %d Minutes\r\n", flashParameters.dutyCycle - 7);
  }
  return;
}
 
/** \fn  void cliFlashErase(void)
 *
 *  \brief CLI command to erase the entire external flash memory.
 */
void cliFlashErase(void) {
  /* Perform a full chip erase of the external flash memory */
  flashxErase();
 
  /* Notify user of completion */
  myPrintk("Flash Erase complete\r\n");
 
  /* Reset the local flash parameters structure to default values
   * to ensure the RAM state matches the cleared flash state.
   */
  flashxClearParameters();
  return;
}
 
/**
 * \fn void cliFlashEraseSector(void)
 *
 * \brief CLI command to erase a specific 4KB sector of the external flash.
 *
 * If no parameter is provided, it defaults to erasing the parameter storage sector.
 * Erasing the parameter sector also triggers a reset of the local parameter structure.
 */
void cliFlashEraseSector(void) {
  uint32_t address;
  char *end;
 
  if (numParameters == 1) {
    /* Default to the start of the parameter storage if no sector specified */
    address = FLASHPARAMETERSTART;
  } else if (numParameters == 2) {
    address = strtoul(cmdLineParameter[1], &end, 16);
  } else {
    myPrintk("format flasherasesector [sector]");
    return;
  }
  if (address >= 32) {
    /* Limit check based on the expected memory map/device size */
    myPrintk("Sector address %d >= 32\r\n", address);
    return;
  }
  /* Execute the hardware-level sector erase */
  flashxEraseSector(address);
  myPrintk("Flash Sector %d Erase complete\r\n", address);
  if (address == FLASHPARAMETERSTART) {
    /* Clear local RAM copy of parameters if the primary flash sector was wiped */
    flashxClearParameters();
  }
}
 
/**
 * \fn void cliFlashFillPage(void)
 *
 * \brief CLI command to fill one or more flash pages with a specific 32-bit data pattern.
 */
void cliFlashFillPage(void) {
  int address = 0;
  int length = 1;
  int32_t data;
  int i;
  char *end;
 
  address = 0;
  data = 0;
  length = 1;
  /* Parse arguments: [address] [data] [length] */
  if (numParameters == 2) {
    address = strtoul(cmdLineParameter[1], &end, 16);
  } else if (numParameters == 3) {
    address = strtoul(cmdLineParameter[1], &end, 16);
    data = strtoul(cmdLineParameter[2], &end, 16);
  } else if (numParameters == 4) {
    address = strtoul(cmdLineParameter[1], &end, 16);
    data = strtoul(cmdLineParameter[2], &end, 16);
    length = atoi(cmdLineParameter[3]);
  } else if (numParameters > 4) {
    myPrintk("format flashFill [address][data] [length]");
    return;
  }
  /* Validate page address range */
  if (address >= 32768) {
    myPrintk("Page address %d >= 32768\r\n", address);
    return;
  }
  /* Iterate through the specified number of pages and write the pattern */
  for (i = 0; i < length; i++, address++) {
    myPrintk("flashFill page: 0x%X data: 0x%02X\r\n", address, data);
    flashxFillPage(address, data);
    myPrintk("flashFill complete\r\n");
  }
  return;
  ;
}
 
/**
 * \fn void cliFlashID(void)
 *
 * \brief CLI command to read and display the unique Flash memory ID.
 *
 * This function retrieves the manufacturer and device identification
 * from the external SPI flash and prints it to the console.
 */
void cliFlashID(void) {
  uint8_t flashIDIn[5];
 
  readNVFlashxID(flashIDIn);
  myPrintk("Flash ID: 0x%02X 0x%02X 0x%02X\r\n", flashIDIn[0], flashIDIn[1], flashIDIn[2]);
}
 
/**
 * \fn void cliFlashNSS(void)
 *
 * \brief CLI command to manually toggle the SPI Chip Select (NSS) for the Flash memory.
 *
 * This is used for hardware debugging to verify the SPI CS1 line state.
 */
void cliFlashNSS(void) {
  int i;
  int flashNSS = 0;
  ;
 
  if (numParameters != 2) {
    myPrintk("format flashnss 0/1\r\n");
    return;
  }
  if (numParameters == 2) {
    i = atoi(cmdLineParameter[1]);
    if (i == 0) {
      gpio_pin_set(spics1n.port, spics1n.pin, 1); /* active low so turn on */
      flashNSS = 0;
    } else {
      gpio_pin_set(spics1n.port, spics1n.pin, 0); /* active low so turn off */
      flashNSS = 1;
    }
  }
  myPrintk("flashnss: %d\r\n", flashNSS);
  return;
}
 
/**
 * \fn void cliFlashReadPage(void)
 *
 * \brief CLI command to read and display the contents of external flash pages.
 *
 * This function reads 256-byte pages from the SPI flash and displays them
 * in a hex-dump format with corresponding ASCII representation.
 */
void cliFlashReadPage(void) {
  int address = 0;
  int length = 1;
  int i, j, k;
  char *end;
  char ascii[17];
  char str[80];
 
  /* Parse page address and optional number of pages to read */
  if (numParameters == 2) {
    address = strtoul(cmdLineParameter[1], &end, 16);
  } else if (numParameters == 3) {
    address = strtoul(cmdLineParameter[1], &end, 16);
    length = atoi(cmdLineParameter[2]);
  }
  if (address >= 32768) {
    myPrintk("Page address %d >= 32768\r\n", address);
    return;
  }
 
  /* Iterate through and read the requested number of pages */
  for (k = 0; k < length; k++, address++) {
    flashxReadPage(address, flashReadIn);
    myPrintk("Read Page 0x%X\r\n", address);
    ascii[0x10] = '\0';
    /* Process 256 bytes per page */
    for (i = 0; i < 256; i++) {
      if ((i % 0x10) == 0) {
        if (i == 0) {
          sprintf(str, "0x%06X ", (unsigned int)(address * 256) + i);
        } else {
          /* Print the ASCII column and start a new line */
          myPrintk(str, " %s\r\n0x%06X ", ascii, (unsigned int)(address * 256) + i);
          for (j = 0; j < sizeof(ascii); j++) {
            ascii[j] = '\0';
          }
        }
        myPrintk("%s", str);
      }
      /* Filter non-printable characters for the ASCII display */
      if ((flashReadIn[i] < 0x20) || (flashReadIn[i] > 0x7E)) {
        ascii[i % 0x10] = '.';
      } else {
        ascii[i % 0x10] = flashReadIn[i];
      }
      /* Print the hex value of the byte */
      myPrintk("%02X ", flashReadIn[i]);
    }
    myPrintk(" %s\r\n", ascii);
  }
  return;
}
 
/**
 * \fn void cliFlashStatus(void)
 *
 * \brief CLI command to read and display the status registers of the external flash.
 *
 * This function reads the three status registers from the SPI flash and decodes
 * individual bits such as Busy, Write Enable, and Protection settings.
 */
void cliFlashStatus(void) {
  uint8_t flashStatusIn[3];
 
  readNVFlashxStatus(flashStatusIn);
  myPrintk("Flash Status 0x%02X 0x%02X 0x%02X\r\n", flashStatusIn[0], flashStatusIn[1], flashStatusIn[2]);
  myPrintk("Status register 1\r\n");
  myPrintk("%sBusy\r\n", flashStatusIn[0] & 0x01 ? "" : "Not ");
  myPrintk("Write %sabled\r\n", flashStatusIn[0] & 0x02 ? "en" : "dis");
  myPrintk("Block Protect %d\r\n", (flashStatusIn[0] & 0x1C) >> 2);
  myPrintk("%s Protect\r\n", flashStatusIn[0] & 0x20 ? "Bottom" : "Top");
  myPrintk("%sK Blocks\r\n", flashStatusIn[0] & 0x40 ? "4" : "64");
  myPrintk("Status Register%s Protected\r\n", flashStatusIn[0] & 0x80 ? "" : " Not");
  myPrintk("\r\nStatus register 2\r\n");
  myPrintk("Status Register %sLocked\r\n", flashStatusIn[1] & 0x01 ? "" : "Not ");
  myPrintk("QSPI %sEnabled\r\n", flashStatusIn[1] & 0x02 ? "" : "Not ");
  myPrintk("Lock Bits %d\r\n", (flashStatusIn[1] & 0x38) >> 3);
  myPrintk("Complement Protect %d\r\n", flashStatusIn[1] & 0x40);
  myPrintk("Suspend Status %d\r\n", flashStatusIn[1] & 0x80);
  myPrintk("\r\nStatus register 3\r\n");
  myPrintk("Write protect Selection %d\r\n", flashStatusIn[2] & 0x04);
  myPrintk("Drive Stength %d\r\n", (flashStatusIn[2] & 0x60) >> 5);
}
 
/**
 * \fn void cliFlashWritePage(void)
 *
 * \brief CLI command to write a single byte of data to a specific address within a flash page.
 *
 * This function parses the page index, the byte offset within that page, and the data byte
 * to be written. It validates the ranges before calling the flash driver.
 */
void cliFlashWritePage(void) {
  uint32_t page;
  int32_t data;
  int address = 0;
  char *end;
  uint8_t dataArray[2];
 
  /* Ensure all required arguments are present: page, address, and data */
  if (numParameters != 4) {
    myPrintk("format flashWrite page address data\r\n");
    return;
  }
 
  /* Convert hex string parameters to integers */
  page = strtoul(cmdLineParameter[1], &end, 16);
  address = strtoul(cmdLineParameter[2], &end, 16);
  data = strtoul(cmdLineParameter[3], &end, 16);
 
  /* Check bounds: 32768 pages total, 256 bytes per page */
  if (page >= 32768) {
    myPrintk("Page %d >= 32768\r\n", page);
    return;
  }
  if (address >= 256) {
    myPrintk("Address %d >= 256\r\n", address);
    return;
  }
 
  dataArray[0] = data;
  myPrintk("flashwrite page: 0x%X address: 0x%02X data: 0x%02X\r\n", page, address, dataArray[0]);
 
  /* Execute the write operation via SPI */
  flashxWritePage(page, address, dataArray, 1);
  myPrintk("flashwrite complete\r\n");
  return;
}
 
/**
 * \fn void cliGroup(void)
 *
 * \brief CLI command to set or display the sensor group name.
 *
 * If a parameter is provided, it updates the group name in the flash parameters.
 */
void cliGroup(void) {
  if (numParameters > 1) {
    /* Clear the existing group name buffer */
    for (int i = 0; i < sizeof(flashParameters.group); i++)
      flashParameters.group[i] = '\0';
    /* Copy the new group name from the command line starting after "group " */
    strncpy(flashParameters.group, &lineTmp[6], 39);
    setFlashxParameters(false);
  }
  myPrintk("Group: %s\r\n", flashParameters.group);
}
 
/**
 * \fn void cliHelp(void)
 *
 * \brief CLI command to display help information for available commands.
 */
void cliHelp(void) {
  /* If a specific character is provided, show commands starting with that letter,
   * otherwise show all commands ('z' is the internal flag for all). */
  if (numParameters != 1) {
    displayHelp(cmdLineParameter[1][0]);
  } else {
    displayHelp('z');
  }
  return;
}
 
/**
 * \fn void cliHumidity(void)
 *
 * \brief CLI command to display humidity data from connected sensors.
 */
void cliHumidity(void) {
  int i;
 
  i = 0;
  /* Print table header for humidity data */
  myPrintk("Humidity (%%)\r\nDevice\tCurrent\tLow\tHigh\r\n");
 
  /* Check if HDC2080 sensor is detected on the I2C bus */
  if ((sensorTypePresentAll & (1 << SENSORTYPEHDC2080))) {
    i++;
    /* Read current humidity and display along with configured thresholds */
    hdcHumidity = readHumidity();
    myPrintk("HDC2080\t%3.2f\t%3.2f\t%3.2f\r\n", (double)hdcHumidity, (double)readLowHumidityThreshold(),
             (double)readHighHumidityThreshold());
  }
 
  /* Inform user if no compatible sensors were found */
  if (i == 0)
    myPrintk("No Humidity sensor connected\r\n");
  return;
}
 
/**
 * \fn void cliI2CRead(void)
 *
 * \brief CLI command to read data from an I2C device.
 *
 * Parses the command line for I2C address, register, and length,
 * then performs the read operation and prints the results in hex.
 */
void cliI2CRead(void) {
  int i2cAddress, i2cRegister, length, i;
  char *end;
  uint8_t datas[DATA_LENGTH];
 
  i2cAddress = 0x00;
  i2cRegister = 0x00;
  length = 1; /* Default values if parameters are missing */
 
  if (numParameters == 2) {
    i2cAddress = strtoul(cmdLineParameter[1], &end, 16);
  } else if (numParameters == 3) {
    i2cAddress = strtoul(cmdLineParameter[1], &end, 16);
    i2cRegister = strtoul(cmdLineParameter[2], &end, 16);
  } else if (numParameters == 4) {
    i2cAddress = strtoul(cmdLineParameter[1], &end, 16);
    i2cRegister = strtoul(cmdLineParameter[2], &end, 16);
    length = atoi(cmdLineParameter[3]);
  }
 
  /* Set the register pointer first */
  datas[0] = i2cRegister;
  i2c_write(i2c_dev, datas, 1, i2cAddress);
 
  /* Read the requested number of bytes */
  i2c_read(i2c_dev, datas, length, 0x40);
  myPrintk("I2C Read Address: 0x%02X Reg: 0x%02X Length: %d\r\n", (unsigned int)i2cAddress, (int)i2cRegister, (int)length);
  for (i = 0; i < length; i++) {
    myPrintk("0x%02X 0x%02X\r\n", (unsigned int)(i2cRegister + i), datas[i]);
  }
  return;
}
 
/**
 * \fn void cliI2CWrite(void)
 *
 * \brief CLI command to write data to a specific I2C device register.
 *
 * This function parses the I2C slave address, the target register, and the data byte
 * from the command line, then executes the I2C write transaction.
 */
void cliI2CWrite(void) {
  int i2cAddress, i2cRegister, data;
  char *end;
  uint8_t dataArray[4];
  /* Default values if parameters are missing */
 
  i2cAddress = 0x00;
  i2cRegister = 0x00;
  data = 1; /* set to default address and data */
  if (numParameters == 2) {
    i2cAddress = strtoul(cmdLineParameter[1], &end, 16);
  } else if (numParameters == 3) {
    i2cAddress = strtoul(cmdLineParameter[1], &end, 16);
    i2cRegister = strtoul(cmdLineParameter[2], &end, 16);
  } else if (numParameters == 4) {
    i2cAddress = strtoul(cmdLineParameter[1], &end, 16);
    i2cRegister = strtoul(cmdLineParameter[2], &end, 16);
    data = strtoul(cmdLineParameter[3], &end, 16);
  }
  /* Prepare the data buffer: [Register Address, Data Byte] */
  dataArray[0] = i2cRegister;
  dataArray[1] = data;
  /* Execute the I2C write operation */
  i2c_write(i2c_dev, dataArray, 2, i2cAddress);
  myPrintk("I2C write Address: 0x%02X Reg: 0x%02X data: 0x%02X\r\n", (unsigned int)i2cAddress, (int)i2cRegister, (int)data);
  return;
}
 
#if 1
/*!
 * \fn void nouart0(void)
 *
 * \brief set display nouart0
 *
 */
void cliNouart0(void) {
#if CONFIG_SERIAL
  int i;
  int err;
 
  if (numParameters > 2) {
    printk("format nouart0 [0/1]\n");
    return;
  }
  if (numParameters == 2) {
    i = atoi(cmdLineParameter[1]);
    if (i == 1) {
      flashParameters.nouart0 = true;
      myPrintkW("UART0 Disable\r\n");
#if 1
      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 {
        myPrintkW("UART0 RX Disable Failed: %d\r\n", err);
        return;
      }
      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
    } else {
      flashParameters.nouart0 = false;
      err = pm_device_action_run(uart0_dev, PM_DEVICE_ACTION_RESUME);
// #if CONFIG_SERIAL
#if 0
      err = uart_init(); /* initialize UART */
      if (err) {
        myPrintkE("UART device is not ready\r\n");
        error();
      }
      myPrintkI("UART device is ready\r\n");
#endif
      k_sleep(K_SECONDS(5));
      myPrintkW("UART0 Enabled\n");
      myPrintkW("UART0 RESUME: %d\r\n", err);
    }
    setFlashxParameters(true);
  }
  myPrintk("nouart0: %d\n", flashParameters.nouart0);
#endif
 
  return;
}
#endif
 
/**
 * \fn void cliIgnoreBME688(void)
 *
 * \brief CLI command to set or display the ignore BME688 flag.
 */
void cliIgnoreBME688(void) {
  int i;
 
  i = 0;
  /* If a parameter is provided, update the manual triugger mode setting */
  if (numParameters == 2) {
    i = atoi(cmdLineParameter[1]);
    if (i > 1)
      i = 1;
    flashParameters.ignoreBME688 = i; /* set ignore BME688 flash parameter */
    setFlashxParameters(false);
    myPrintk("Ignore BME688: %s\r\n", i ? "Enabled" : "Disabled");
    return;
  }
  /* If no parameter, display the current state */
  else if (numParameters == 1) {
    myPrintk("Ignore BME688: %s\r\n", flashParameters.ignoreBME688 ? "Enabled" : "Disabled");
    return;
  } else { /* Invalid number of arguments */
    myPrintk("format ignorebme688 [0 | 1]\r\n");
    return;
  }
}
 
/**
 * \fn void cliLocation(void)
 *
 * \brief CLI command to set or display the sensor's physical location.
 *
 * If a location string is provided, it updates the flash parameters.
 */
void cliLocation(void) {
  if (numParameters > 1) {
    /* Clear existing location buffer */
    for (int i = 0; i < sizeof(flashParameters.location); i++)
      flashParameters.location[i] = '\0';
    /* Copy new location from command line (offset 9 for "location ") */
    strncpy(flashParameters.location, &lineTmp[9], 39);
    setFlashxParameters(false);
  }
  myPrintk("Location: %s\r\n", flashParameters.location);
}
 
/**
 * \fn void cliManualTrigger(void)
 *
 * \brief CLI command to set or display the manual trigger mode flag.
 */
void cliManualTrigger(void) {
  int i;
 
  i = 0;
  /* If a parameter is provided, update the manual triugger mode setting */
  if (numParameters == 2) {
    i = atoi(cmdLineParameter[1]);
    if (i > 1)
      i = 1;
    flashParameters.manualTrigger = i; /* set manual trigger flash parameter */
    setFlashxParameters(false);
    myPrintk("Manual Trigger: %s\r\n", i ? "Enabled" : "Disabled");
    return;
  }
  /* If no parameter, display the current state */
  else if (numParameters == 1) {
    myPrintk("Manual Trigger: %s\r\n", flashParameters.manualTrigger ? "Enabled" : "Disabled");
    return;
  } else { /* Invalid number of arguments */
    myPrintk("format manualtrigger [0 | 1]\r\n");
    return;
  }
}
 
/**
 * \fn void cliPublishNow(void)
 *
 * \brief CLI command to trigger an immediate sensor data publication.
 *
 * This function releases the hdc_rdy_seen semaphore to bypass the normal
 * duty cycle timer and force a sensor read/BLE transmission.
 */
void cliPublishNow(void) {
  myPrintk("Send BLE data immediately\r\n");
  /* show RX received */
  k_sem_give(&hdc_rdy_seen); /* indicate HDC2080 RDY seen */
  return;
}
 
/**
 * \fn void cliReset(void)
 *
 * \brief CLI command to reset the processor.
 *
 * If called without parameters, it performs a clean system reset.
 * If called with any parameter, it stops the watchdog feeder to force a WDT reset.
 */
void cliReset(void) {
  if (numParameters == 1) {
    myPrintk("Software Reset the board\r\n");
#if defined(CONFIG_REBOOT)
    //              sys_reboot(SYS_REBOOT_COLD);
    NVIC_SystemReset();
#endif
  } else {
    myPrintk("Forced WDT reset of the processor. WDT feed Stopped!\r\n");
    stopWDTFeed = 1;
  }
  return;
}
 
/**
 * \fn void cliResetCause(void)
 *
 * \brief CLI command to display the reason for the last processor reset.
 */
void cliResetCause(void) {
  myPrintk("resetCause: %s\r\n", resetCause);
  return;
}
 
/**
 * \fn void cliSaved(void)
 *
 * \brief CLI command to manage and display JSON packets saved in external flash.
 *
 * This function allows the user to clear all saved packets, read a specific packet,
 * or display a range of packets stored in the flash memory.
 */
void cliSaved(void) {
#if 1
  int sectorCount;
  int data;
  int i, j;
 
  /* Validate argument count */
  if (numParameters > 3) {
    myPrintk("format saved [clear/n] [len]\r\n");
    return;
  } else if (numParameters == 2) {
    /* Handle 'clear' command to wipe saved data */
    if ((cmdLineParameter[1][0] == 'c') || (cmdLineParameter[1][0] == 'C')) {
      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 */
      }
      return;
    } else {
      /* Read and display a single specific packet index */
      data = atoi(cmdLineParameter[1]); /* get packet to read */
      if (data < flashParameters.savedCount) {
        flashxReadPage(data + FLASHBLESTART, flashReadIn);
        myPrintkI("Page: 0x%04X %s", data + FLASHBLESTART, flashReadIn);
        myPrintk("\r\n");
      } else {
        myPrintkW("%d >= %d packets saved\r\n", data, flashParameters.savedCount);
      }
      return;
    }
  } else if (numParameters == 3) {
    /* Read and display a range of packets starting from an index */
    data = atoi(cmdLineParameter[1]); /* get starting packet */
    if (data >= flashParameters.savedCount) {
      myPrintkW("%d >= %d packets saved\r\n", data, flashParameters.savedCount);
      return;
    }
    j = atoi(cmdLineParameter[2]); /* get number of packets to display*/
    for (i = 0; i < j; i++) {
      if ((data + i) >= flashParameters.savedCount) {
        myPrintkW("%d >= %d packets saved\r\n", (data + i), flashParameters.savedCount);
        return;
      }
      flashxReadPage(data + i + FLASHBLESTART, flashReadIn);
      myPrintkI("Page: 0x%04X %s", data + FLASHBLESTART + i, flashReadIn);
      myPrintk("\r\n");
    }
  } else if (numParameters == 1) {
    /* Display summary of saved packet statistics */
    myPrintk("Saved BLE Packets: %d Next Read: %d Next Write: %d Max: %d\r\n", flashParameters.savedCount, flashParameters.nextSavedRead,
             flashParameters.nextSavedWrite, MAX_NUMBER_BLE_PACKETS);
  }
#endif
  return;
}
 
/**
 * \fn void cliSensorID(void)
 *
 * \brief CLI command to set or display the unique sensor ID.
 *
 * If a parameter is provided, it updates the sensorID in flash memory.
 */
void cliSensorID(void) {
  if (numParameters > 1) {
    /* Clear existing ID buffer */
    for (int i = 0; i < sizeof(flashParameters.sensorID); i++)
      flashParameters.sensorID[i] = '\0';
    /* Copy new ID from command line (offset 9 for "sensorid ") */
    strncpy(flashParameters.sensorID, &lineTmp[9], 6);
    setFlashxParameters(false);
  }
  myPrintk("Sensor ID: %s\r\n", flashParameters.sensorID);
}
 
/**
 * \fn void cliSensorName(void)
 *
 * \brief CLI command to set or display the human-readable sensor name.
 *
 * Updates the sensorName in flash parameters if a new name is provided.
 */
void cliSensorName(void) {
  if (numParameters > 1) {
    /* Clear existing name buffer */
    for (int i = 0; i < sizeof(flashParameters.sensorName); i++)
      flashParameters.sensorName[i] = '\0';
    /* Copy new name from command line (offset 11 for "sensorname ") */
    strncpy(flashParameters.sensorName, &lineTmp[11], 39);
    setFlashxParameters(false);
  }
  myPrintk("Sensor Name: %s\r\n", flashParameters.sensorName);
}
 
/**
 * \fn void cliSensors(void)
 *
 * \brief CLI command to list all supported sensors and their detection status.
 *
 * Checks the sensorTypePresentAll bitmask against the known sensor list.
 */
void cliSensors(void) {
  int i;
 
  myPrintk("sensorTypePresentAll %08X\r\n", sensorTypePresentAll);
  for (i = 0; 1; i++) {
    /* Formatting: new line every 4 entries */
    if ((i & 0x3) == 0)
      myPrintk("\r\n");
    if (strcmp(sensorTypeNames[i], "Unknown") == 0)
      break;
    /* Check if the bit corresponding to the sensor type is set */
    if ((sensorTypePresentAll & (1 << i)) == 0) {
      myPrintkW("%s %s\r\n", sensorTypeNames[i], "Not Present");
    } else {
      myPrintkI("%s %s\r\n", sensorTypeNames[i], "Present");
    }
  }
  return;
}
 
/**
 * \fn void cliSilent(void)
 *
 * \brief CLI command to set or display the silent mode flag.
 */
void cliSilent(void) {
  int i;
 
  i = 0;
  /* If a parameter is provided, update the silent mode setting */
  if (numParameters == 2) {
    i = atoi(cmdLineParameter[1]);
    if (i > 1)
      i = 1;
    flashParameters.silent = i; /* set silent flash parameter */
    setFlashxParameters(false);
    myPrintk("Silent: %s\r\n", i ? "Enabled" : "Disabled");
    return;
  }
  /* If no parameter, display the current state */
  else if (numParameters == 1) {
    myPrintk("Silent: %s\r\n", flashParameters.silent ? "Enabled" : "Disabled");
    return;
  } else { /* Invalid number of arguments */
    myPrintk("format silent [0 | 1]\r\n");
    return;
  }
}
 
/**
 * \fn void cliTemperature(void)
 *
 * \brief CLI command to display temperature data from connected sensors.
 *
 * Reads the current temperature from the HDC2080 and displays it alongside
 * the configured low and high alarm thresholds.
 */
void cliTemperature(void) {
  int i;
 
  i = 0;
  myPrintk("Temperature (deg C)\r\nDevice\tCurrent\tLow\tHigh\r\n");
 
  /* Check if HDC2080 sensor is present on the I2C bus */
  if ((sensorTypePresentAll & (1 << SENSORTYPEHDC2080))) {
    i++;
    hdcTemp = readTemp();
    ;
    myPrintk("HDC2080\t%3.2f\t%3.2f\t%3.2f\r\n", (double)hdcTemp, (double)readLowTempThreshold(), (double)readHighTempThreshold());
  }
  /* Notify user if no temperature sensors were detected */
  if (i == 0)
    myPrintk("No Temperature sensor connected\r\n");
  return;
}
 
/**
 * \fn void cliVersion(void)
 * \brief CLI command to display firmware, hardware, and SDK version information.
 */
void cliVersion(void) {
  /* display version and build information */
  if (flashParameters.nouart0 == false) {
    myPrintk("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 {
    myPrintk("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
  myPrintk("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
 
  myPrintk("SDK Version: %s\r\n", EXPAND_AND_STR(NCS_BUILD_VERSION));
  myPrintk("Built:%s %s\r\n", __DATE__, __TIME__);
  if (IS_ENABLED(CONFIG_LTE_NETWORK_MODE_LTE_M)) {
    myPrintk("GPS not available!\r\n");
  }
  if (IS_ENABLED(CONFIG_LTE_NETWORK_MODE_LTE_M_GPS)) {
    myPrintk("GPS available!\r\n");
  }
  return;
}