w25q64jv.c

Go to the documentation of this file.

/*!
 * \file w25q64jv.c
 *
 * \brief W25Q64JW Mb Flash Memory (I2C) functions
 *
 * \copyright  J Factor Embedded Technologies LLC. 2020
 * \copyright  TJM Embedded Software LLC. 2020
 * \author  T. J. Mulrooney
 *
 * \sa
 *  <a href="https://www.adestotech.com/wp-content/uploads/DS-45DB641E-027.pdf">W25Q64JW Datasheet</a>
 *
 */
/*
 * All Rights Reserved
 * UNPUBLISHED, LICENSED SOFTWARE.
 *
 * CONFIDENTIAL AND PROPRIETARY INFORMATION
 * WHICH IS THE PROPERTY OF J-Factor Embedded Technologies.
 *
 */
 
#include "jfet_files/w25q64jv_Driver.h"
#include <stdio.h>
 
/*!
 * \fn void readNVFlashxID(uint8_t *flashId)
 *
 * \brief reads the NV Flash ID over the SPI bus.
 *
 * \param flashId pointer to the buffer to receive the Flash ID bytes
 *
 */
void readNVFlashxID(uint8_t *flashId) {
  uint8_t i = 0;
  int ret;
 
  /* zero buffer and load the command */
  for (i = 0; i < 4; i++)
    buffer_tx[i] = 0;
  buffer_tx[0] = 0x9F;
  tx_bufs[0].len = 4;
  rx_bufs[0].len = 4;
 
  /* enable CS and send command  */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* shift bytes back to caller byte 0 is not valid data */
  for (i = 0; i < 3; i++)
    flashId[i] = buffer_rx[i + 1];
}
 
/*!
 * \fn void readNVFlashxStatus(uint8_t *flashStatus)
 *
 * \brief reads the 3 NV Flash status registers over the SPI bus.
 *
 * \param flashStatus pointer to the buffer to receive the Flash Status bytes
 *
 */
void readNVFlashxStatus(uint8_t *flashStatus) {
  uint8_t i;
  uint8_t status[3];
  int ret;
 
  for (i = 0; i < 3; i++)
    status[i] = 0;
 
  /* zero buffer and load the command */
  for (i = 0; i < 2; i++)
    buffer_tx[i] = 0;
 
  /*  get status register 1 */
  buffer_tx[0] = 0x05;
  tx_bufs[0].len = 2;
  rx_bufs[0].len = 2;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* get requested status register */
  status[0] = buffer_rx[1];
 
  /* zero buffer and load the command */
  for (i = 0; i < 2; i++)
    buffer_tx[i] = 0;
 
  /*  get status register 2 */
  buffer_tx[0] = 0x35;
  tx_bufs[0].len = 2;
  rx_bufs[0].len = 2;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* get requested status register */
  status[1] = buffer_rx[1];
 
  /* zero buffer and load the command */
  for (i = 0; i < 2; i++)
    buffer_tx[i] = 0;
 
  /*  get status register 2 */
  buffer_tx[0] = 0x15;
  tx_bufs[0].len = 2;
  rx_bufs[0].len = 2;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* get requested status register */
  status[2] = buffer_rx[1];
 
  /* send back status registers */
  for (i = 0; i < 3; i++)
    flashStatus[i] = status[i];
}
 
#if 1
/*!
 * \fn void writeNVFlashxStatus(void)
 *
 * \brief writes NV Flash status register2 over the SPI bus.
 *
 * clears teh QSPI bit
 */
void writeNVFlashxStatus(void) {
  uint8_t i;
  int ret;
  uint8_t flashStatus[3];
 
  /* zero buffer and load the command */
  for (i = 0; i < 2; i++)
    buffer_tx[i] = 0;
 
  buffer_tx[0] = 0x06; /* non-volatile write enable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /*  set status register 1 */
  //    buffer_tx[0] = 0x01;
  //    buffer_tx[1] = 0x00;    /* SRP = 1 */
  //    tx_bufs[0].len = 2;
  //    rx_bufs[0].len = 2;
 
  /* enable CS and send command */
  //    ret = spi_transceive(spi, &spi_cfg, &tx, &rx);
 
  /*  set status register 2 */
  buffer_tx[0] = 0x31;
  buffer_tx[1] = 0x00; /* QE = 0 */
  tx_bufs[0].len = 2;
  rx_bufs[0].len = 2;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  readNVFlashxStatus(flashStatus);
 
  buffer_tx[0] = 0x04; /* write disable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
}
#endif
 
/*!
 * \fn void flashxErasePage(uint32_t address)
 *
 * \brief erases a 256 byte page over the SPI bus.
 *
 * \param address address of the page to be erased
 *
 */
void flashxErasePage(uint32_t address) {
  uint8_t flashStatusIn[3];
  uint32_t address32 = address << 11;
  int ret;
 
  buffer_tx[0] = 0x06; /* write enable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  buffer_tx[0] = 0x20; /* block 1 erase */
  buffer_tx[1] = (address32 >> 16) & 0xFF;
  buffer_tx[2] = (address32 >> 8) & 0xFF;
  buffer_tx[3] = (address32 >> 0) & 0xFF;
  tx_bufs[0].len = 4;
  rx_bufs[0].len = 4;
 
  /* enable CS and send command to read ID into buffer */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  printf("Erasing sector (16 pages) %d. Please wait ...\r\n", address);
 
  while (1) /* wait until flag goes away */
  {
    readNVFlashxStatus(flashStatusIn);
    //        printf("Flash Status: 0x%02X 0x%02X\r\n",flashStatusIn[0],flashStatusIn[1]);
    if ((flashStatusIn[0] & 0x01) == 0x00) {
      break;
    }
    k_sleep(K_MSEC(1));
  }
 
  buffer_tx[0] = 0x04; /* write disable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
}
 
/*!
 * \fn void flashxEraseBlock1(uint32_t address)
 *
 * \brief erases a 2K block page over the SPI bus.
 *
 * \param address address of the block to be erased
 *
 */
void flashxEraseBlock1(uint32_t address) {
  uint8_t flashStatusIn[3];
  uint32_t address32 = address << 7;
  int ret;
 
  buffer_tx[0] = 0x06; /* write enable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  buffer_tx[0] = 0x52; /* block 1 erase */
  buffer_tx[1] = (address32 >> 16) & 0xFF;
  buffer_tx[2] = (address32 >> 8) & 0xFF;
  buffer_tx[3] = (address32 >> 0) & 0xFF;
  tx_bufs[0].len = 4;
  rx_bufs[0].len = 4;
 
  /* enable CS and send command to read ID into buffer */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  printf("Erasing Block %d. Please wait ...\r\n", address);
 
  while (1) /* wait until flag goes away */
  {
    readNVFlashxStatus(flashStatusIn);
    //        printf("Flash Status: 0x%02X 0x%02X\r\n",flashStatusIn[0],flashStatusIn[1]);
    if ((flashStatusIn[0] & 0x01) == 0x00) {
      break;
    }
    k_sleep(K_MSEC(1));
  }
 
  buffer_tx[0] = 0x04; /* write disable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
}
 
/*!
 * \fn void flashxEraseBlock1(uint32_t address)
 *
 * \brief erases a 2K block page over the SPI bus.
 *
 * \param address address of the block to be erased
 *
 */
void flashxEraseBlock2(uint32_t address) {
  uint8_t flashStatusIn[3];
  uint32_t address32 = address << 4;
  int ret;
 
  buffer_tx[0] = 0x06; /* write enable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  buffer_tx[0] = 0xD8; /* block 1 erase */
  buffer_tx[1] = (address32 >> 16) & 0xFF;
  buffer_tx[2] = (address32 >> 8) & 0xFF;
  buffer_tx[3] = (address32 >> 0) & 0xFF;
  tx_bufs[0].len = 4;
  rx_bufs[0].len = 4;
 
  /* enable CS and send command to read ID into buffer */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  printf("Erasing Block %d. Please wait ...\r\n", address);
 
  while (1) /* wait until flag goes away */
  {
    readNVFlashxStatus(flashStatusIn);
    //        printf("Flash Status: 0x%02X 0x%02X\r\n",flashStatusIn[0],flashStatusIn[1]);
    if ((flashStatusIn[0] & 0x01) == 0x00) {
      break;
    }
    k_sleep(K_MSEC(1));
  }
 
  buffer_tx[0] = 0x04; /* write disable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
}
 
/*!
 * \fn void flashxEraseSector(uint32_t address)
 *
 * \brief erases a 256K byte sector over the SPI bus.
 *
 * \param address address of the sector to be erased
 *
 */
void flashxEraseSector(uint32_t address) {
  uint8_t flashStatusIn[3];
  uint32_t address32 = address << 12;
  int ret;
 
  buffer_tx[0] = 0x06; /* write enable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  buffer_tx[0] = 0x20; /* 4K sector erase */
  buffer_tx[1] = (address32 >> 16) & 0xFF;
  buffer_tx[2] = (address32 >> 8) & 0xFF;
  buffer_tx[3] = (address32 >> 0) & 0xFF;
  tx_bufs[0].len = 4;
  rx_bufs[0].len = 4;
 
  /* enable CS and send command to read ID into buffer */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  printf("Erasing Sector %d. Please wait ...\r\n", address);
 
  while (1) /* wait until flag goes away */
  {
    readNVFlashxStatus(flashStatusIn);
    //        printf("Flash Status: 0x%02X 0x%02X\r\n",flashStatusIn[0],flashStatusIn[1]);
    if ((flashStatusIn[0] & 0x01) == 0x00) {
      break;
    }
    k_sleep(K_MSEC(1));
  }
 
  buffer_tx[0] = 0x04; /* write disable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
  printf("Erasing Sector %d. Finished ...\r\n", address);
}
 
/*!
 * \fn void flashxErase(void)
 *
 * \brief erases the entire 8 Mb over the SPI bus.
 *
 */
void flashxErase(void) {
  uint8_t flashStatusIn[3];
  int ret;
 
  buffer_tx[0] = 0x06; /* write enable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  buffer_tx[0] = 0xC7; /* write enable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command to read ID into buffer */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  printf("Erasing entire device. Please wait ...\r\n");
 
  while (1) /* wait until flag goes away */
  {
    readNVFlashxStatus(flashStatusIn);
    //       printf("Flash Status: 0x%02X 0x%02X %d\r\n",flashStatusIn[0],flashStatusIn[1],(flashStatusIn[0] & 0x80));
    if ((flashStatusIn[0] & 0x01) == 0x00) {
      break;
    }
    k_sleep(K_MSEC(1));
  }
  printf("Entire device erased\r\n");
 
  buffer_tx[0] = 0x04; /* write disable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
}
 
/*!
 * \fn void flashxReadPage(uint32_t address,  uint8_t *flashRead)
 *
 * \brief reads a 256 byte page over the SPI bus.
 *
 * \param address 24 bit memory address of page to read
 * \param flashRead - address of data array to received bytes from NV memory
 *
 */
void flashxReadPage(uint32_t address, uint8_t *flashRead) {
  uint16_t i;
  uint32_t address32;
  int ret;
  uint8_t readBuffer[256];
 
  /* start first 64 byte read from page */
  /* zero buffer and load the command */
  address32 = (address << 8) + 0; /* set first address */
  for (i = 0; i < 64 + 4; i++)
    buffer_tx[i] = 0;
  buffer_tx[0] = 0x03;
  buffer_tx[1] = (address32 >> 16) & 0xFF;
  buffer_tx[2] = (address32 >> 8) & 0xFF;
  buffer_tx[3] = (address32 >> 0) & 0xFF;
  tx_bufs[0].len = 64 + 4;
  rx_bufs[0].len = 64 + 4;
 
  //    printf("Flash Page Read: 0x%08X\r\n",address);
  //    printf("%02X %02X %02X %02X\r\n",flashReadCmd[0],flashReadCmd[1],flashReadCmd[2],flashReadCmd[3]);
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* put bytes in buffer ignore first 4 bytes */
  for (i = 0; i < 64; i++)
    readBuffer[i] = buffer_rx[i + 4];
  /* end first 64 byte read from page */
 
  /* start second 64 byte read from page */
  /* zero buffer and load the command */
  address32 = (address << 8) + 64; /* set first address */
  for (i = 0; i < 64 + 4; i++)
    buffer_tx[i] = 0;
  buffer_tx[0] = 0x03;
  buffer_tx[1] = (address32 >> 16) & 0xFF;
  buffer_tx[2] = (address32 >> 8) & 0xFF;
  buffer_tx[3] = (address32 >> 0) & 0xFF;
  tx_bufs[0].len = 64 + 4;
  rx_bufs[0].len = 64 + 4;
 
  //    printf("Flash Page Read: 0x%08X\r\n",address);
  //    printf("%02X %02X %02X %02X\r\n",flashReadCmd[0],flashReadCmd[1],fsheadCmd[2],flashReadCmd[3]);
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* put bytes in buffer ignore first 4 bytes */
  for (i = 0; i < 64; i++)
    readBuffer[i + 64] = buffer_rx[i + 4];
  /* end second 64 byte read from page */
 
  /* start third 64 byte read from page */
  /* zero buffer and load the command */
  address32 = (address << 8) + 128; /* set first address */
  for (i = 0; i < 64 + 4; i++)
    buffer_tx[i] = 0;
  buffer_tx[0] = 0x03;
  buffer_tx[1] = (address32 >> 16) & 0xFF;
  buffer_tx[2] = (address32 >> 8) & 0xFF;
  buffer_tx[3] = (address32 >> 0) & 0xFF;
  tx_bufs[0].len = 64 + 4;
  rx_bufs[0].len = 64 + 4;
 
  //    printf("Flash Page Read: 0x%08X\r\n",address);
  //    printf("%02X %02X %02X %02X\r\n",flashReadCmd[0],flashReadCmd[1],flashReadCmd[2],flashReadCmd[3]);
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* put bytes in buffer ignore first 4 bytes */
  for (i = 0; i < 64; i++)
    readBuffer[i + 128] = buffer_rx[i + 4];
  /* end third 64 byte read from page */
 
  /* start fourth 64 byte read from page */
  /* zero buffer and load the command */
  address32 = (address << 8) + 192; /* set first address */
  for (i = 0; i < 64 + 4; i++)
    buffer_tx[i] = 0;
  buffer_tx[0] = 0x03;
  buffer_tx[1] = (address32 >> 16) & 0xFF;
  buffer_tx[2] = (address32 >> 8) & 0xFF;
  buffer_tx[3] = (address32 >> 0) & 0xFF;
  tx_bufs[0].len = 64 + 4;
  rx_bufs[0].len = 64 + 4;
 
  //    printf("Flash Page Read: 0x%08X\r\n",address);
  //    printf("%02X %02X %02X %02X\r\n",flashReadCmd[0],flashReadCmd[1],flashReadCmd[2],flashReadCmd[3]);
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* put bytes in buffer ignore first 4 bytes */
  for (i = 0; i < 64; i++)
    readBuffer[i + 192] = buffer_rx[i + 4];
  /* end fourth 64 byte read from page */
 
  /* shift bytes back to caller byte 0 is not valid data */
  for (i = 0; i < 256; i++) {
    flashRead[i] = readBuffer[i];
  }
}
 
/**
 * \fn void flashxWritePage(uint32_t page, uint32_t address, uint8_t *data, uint16_t count)
 *
 * \brief writes data to address in serial flash over the SPI bus.
 *
 * \param page 24 bit memory address of page to write
 * \param address address within page to begin writing
 * \param data address of data array to get bytes to store bytes in NV memory
 * \param count number of bytes to write
 *
 */
void flashxWritePage(uint32_t page, uint32_t address, uint8_t *data, uint16_t count) {
  int i;
  uint8_t flashStatusIn[2];
  //    uint8_t flashIn[256+4];
  uint32_t address32 = page << 8;
  uint8_t dataPage[256 + 4];
  int ret;
 
#if 0
    printf("flashxWritePage page: %d length: %d\r\n",page,count);
    for(i=0;i<count;i++)
    {
      if( (i & 0xf) == 0)
        printf("\r\n %02X",i);
      printf(" 0x%02X",data[i]);
    }
#endif
 
#if 1
  buffer_tx[0] = 0x06; /* write enable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  //    printf("page: %d address: %d data: %02X count: %d\r\n",page,address,data[0],count);
  flashxReadPage(page, dataPage); /* read in page data */
 
  //    for(i=0;i<256;i++)
  //    printf("i: %d data: %02X\r\n",i,dataPage[i]);
  for (i = 0; i < count; i++) /* move in new data */
    dataPage[i + address] = data[i];
  //    for(i=0;i<256;i++)
  //        printf("i: %d data: %02X\r\n",i,dataPage[i]);
 
  /* write first 64 byte write */
  address32 = (page << 8) + 0;
  buffer_tx[0] = 0x02; /* chip program */
  buffer_tx[1] = (address32 >> 16) & 0xFF;
  buffer_tx[2] = (address32 >> 8) & 0xFF;
  buffer_tx[3] = (address32 >> 0) & 0xFF;
  for (i = 0; i < 64; i++)
    buffer_tx[i + 4] = dataPage[i];
  tx_bufs[0].len = 64 + 4;
  rx_bufs[0].len = 64 + 4;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  while (1) /* wait until flag goes away */
  {
    readNVFlashxStatus(flashStatusIn);
    //        PRINTF("Flash Status: 0x%02X 0x%02X\r\n",flashStatusIn[0],flashStatusIn[1]);
    if ((flashStatusIn[0] & 0x01) == 0x00) {
      break;
    }
    k_sleep(K_MSEC(1));
  }
 
  buffer_tx[0] = 0x04; /* write disable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* end of first 64 byte write */
//    myPrintkI("first 64 bytes written\r\n");
#endif
 
#if 1
  buffer_tx[0] = 0x06; /* write enable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* write second 64 byte write */
  address32 = (page << 8) + 64;
  buffer_tx[0] = 0x02; /* chip program */
  buffer_tx[1] = (address32 >> 16) & 0xFF;
  buffer_tx[2] = (address32 >> 8) & 0xFF;
  buffer_tx[3] = (address32 >> 0) & 0xFF;
  for (i = 0; i < 64; i++)
    buffer_tx[i + 4] = dataPage[i + 64];
  tx_bufs[0].len = 64 + 4;
  rx_bufs[0].len = 64 + 4;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  while (1) /* wait until flag goes away */
  {
    readNVFlashxStatus(flashStatusIn);
    //        PRINTF("Flash Status: 0x%02X 0x%02X\r\n",flashStatusIn[0],flashStatusIn[1]);
    if ((flashStatusIn[0] & 0x01) == 0x00) {
      break;
    }
    k_sleep(K_MSEC(1));
  }
 
  buffer_tx[0] = 0x04; /* write disable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* end of second 64 byte write */
//    myPrintkI("second 64 bytes written\r\n");
#endif
 
#if 1
  buffer_tx[0] = 0x06; /* write enable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* write third 64 byte write */
  address32 = (page << 8) + 128;
  buffer_tx[0] = 0x02; /* chip program */
  buffer_tx[1] = (address32 >> 16) & 0xFF;
  buffer_tx[2] = (address32 >> 8) & 0xFF;
  buffer_tx[3] = (address32 >> 0) & 0xFF;
  for (i = 0; i < 64; i++)
    buffer_tx[i + 4] = dataPage[i + 128];
  tx_bufs[0].len = 64 + 4;
  rx_bufs[0].len = 64 + 4;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  while (1) /* wait until flag goes away */
  {
    readNVFlashxStatus(flashStatusIn);
    //        PRINTF("Flash Status: 0x%02X 0x%02X\r\n",flashStatusIn[0],flashStatusIn[1]);
    if ((flashStatusIn[0] & 0x01) == 0x00) {
      break;
    }
    k_sleep(K_MSEC(1));
  }
 
  buffer_tx[0] = 0x04; /* write disable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* end of third 64 byte write */
//    myPrintkI("third 64 bytes written\r\n");
#endif
 
#if 1
  buffer_tx[0] = 0x06; /* write enable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* write fourth 64 byte write */
  address32 = (page << 8) + 192;
  buffer_tx[0] = 0x02; /* chip program */
  buffer_tx[1] = (address32 >> 16) & 0xFF;
  buffer_tx[2] = (address32 >> 8) & 0xFF;
  buffer_tx[3] = (address32 >> 0) & 0xFF;
  for (i = 0; i < 64; i++)
    buffer_tx[i + 4] = dataPage[i + 192];
  tx_bufs[0].len = 64 + 4;
  rx_bufs[0].len = 64 + 4;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  while (1) /* wait until flag goes away */
  {
    readNVFlashxStatus(flashStatusIn);
    //        PRINTF("Flash Status: 0x%02X 0x%02X\r\n",flashStatusIn[0],flashStatusIn[1]);
    if ((flashStatusIn[0] & 0x01) == 0x00) {
      break;
    }
    k_sleep(K_MSEC(1));
  }
 
  buffer_tx[0] = 0x04; /* write disable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* end of fourth 64 byte write */
//    myPrintkI("fourth 64 bytes written\r\n");
#endif
}
 
/*!
 * \fn void flashxFillPage(uint32_t address, uint16_t data)
 *
 * \brief fills a 256 byte page with data over the SPI bus.
 *
 * \param address 24 bit memory address of page to write
 * \param data byte to fill in page in NV memory
 *
 */
void flashxFillPage(uint32_t address, uint16_t data) {
  int i;
  uint8_t flashStatusIn[2];
  uint32_t address32 = address << 8;
  int ret;
 
#if 1
  buffer_tx[0] = 0x06; /* write enable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* fill first 64 bytes */
  address32 = (address << 8) + 0;
  buffer_tx[0] = 0x02; /* chip program */
  buffer_tx[1] = (address32 >> 16) & 0xFF;
  buffer_tx[2] = (address32 >> 8) & 0xFF;
  buffer_tx[3] = (address32 >> 0) & 0xFF;
  for (i = 0; i < 64; i++)
    buffer_tx[i + 4] = data;
  tx_bufs[0].len = 64 + 4;
  rx_bufs[0].len = 64 + 4;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  while (1) /* wait until flag goes away */
  {
    readNVFlashxStatus(flashStatusIn);
    //               printf("Flash Status: 0x%02X 0x%02X\r\n",flashStatusIn[0],flashStatusIn[1]);
    if ((flashStatusIn[0] & 0x01) == 0x00) {
      break;
    }
    //                    k_sleep(K_MSEC(1));
  }
  // myPrintkI("first 64 bytes written\r\n");
 
  buffer_tx[0] = 0x04; /* write disable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* end fill first 64 bytes */
#endif
 
#if 1
  buffer_tx[0] = 0x06; /* write enable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* fill second 64 bytes */
  address32 = (address << 8) + 64;
  buffer_tx[0] = 0x02; /* chip program */
  buffer_tx[1] = (address32 >> 16) & 0xFF;
  buffer_tx[2] = (address32 >> 8) & 0xFF;
  buffer_tx[3] = (address32 >> 0) & 0xFF;
  for (i = 0; i < 64; i++)
    buffer_tx[i + 4] = data;
  tx_bufs[0].len = 64 + 4;
  rx_bufs[0].len = 64 + 4;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  while (1) /* wait until flag goes away */
  {
    readNVFlashxStatus(flashStatusIn);
    //           printf("Flash Status: 0x%02X 0x%02X\r\n",flashStatusIn[0],flashStatusIn[1]);
    if ((flashStatusIn[0] & 0x01) == 0x00) {
      break;
    }
    //                k_sleep(K_MSEC(1));
  }
  // myPrintkI("second 64 bytes written\r\n");
 
  buffer_tx[0] = 0x04; /* write disable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* end fill second 64 bytes */
#endif
 
#if 1
  buffer_tx[0] = 0x06; /* write enable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* fill third 64 bytes */
  address32 = (address << 8) + 128;
  buffer_tx[0] = 0x02; /* chip program */
  buffer_tx[1] = (address32 >> 16) & 0xFF;
  buffer_tx[2] = (address32 >> 8) & 0xFF;
  buffer_tx[3] = (address32 >> 0) & 0xFF;
  for (i = 0; i < 64; i++)
    buffer_tx[i + 4] = data;
  tx_bufs[0].len = 64 + 4;
  rx_bufs[0].len = 64 + 4;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  while (1) /* wait until flag goes away */
  {
    readNVFlashxStatus(flashStatusIn);
    //       printf("Flash Status: 0x%02X 0x%02X\r\n",flashStatusIn[0],flashStatusIn[1]);
    if ((flashStatusIn[0] & 0x01) == 0x00) {
      break;
    }
    //            delay_ms(1);
  }
  // myPrintkI("third 64 bytes written\r\n");
 
  buffer_tx[0] = 0x04; /* write disable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* end fill second 64 bytes */
#endif
 
#if 1
  buffer_tx[0] = 0x06; /* write enable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  /* fill fourth 64 bytes */
  address32 = (address << 8) + 192;
  buffer_tx[0] = 0x02; /* chip program */
  buffer_tx[1] = (address32 >> 16) & 0xFF;
  buffer_tx[2] = (address32 >> 8) & 0xFF;
  buffer_tx[3] = (address32 >> 0) & 0xFF;
  for (i = 0; i < 64; i++)
    buffer_tx[i + 4] = data;
  tx_bufs[0].len = 64 + 4;
  rx_bufs[0].len = 64 + 4;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
 
  while (1) /* wait until flag goes away */
  {
    readNVFlashxStatus(flashStatusIn);
    //       printf("Flash Status: 0x%02X 0x%02X\r\n",flashStatusIn[0],flashStatusIn[1]);
    if ((flashStatusIn[0] & 0x01) == 0x00) {
      break;
    }
    //            delay_ms(1);
  }
  /* end fill fourth 64 bytes */
  // myPrintkI("fourth 64 bytes written\r\n");
 
  buffer_tx[0] = 0x04; /* write disable */
  tx_bufs[0].len = 1;
  rx_bufs[0].len = 1;
 
  /* enable CS and send command */
  ret = spi_transceive(spi_dev, &spi_cfg1, &tx, &rx);
#endif
}
 
/*!
 * \fn void flashxClearParameters(void)
 *
 * \brief clears/initializes the flash parameters in RAM
 *
 *  This is called on power up reset after the NV flash parameters have been erased \n
 * from Page 0 1nd 1. only called if the Key is not set in the NV Flash Parameters.
 *
 */
void flashxClearParameters(void) {
 
  //    flashParameters.tempUnitsCentigrade = true;
  //    flashParameters.dateSet = false;
  //    flashParameters.timeZone = DEFAULT_TIMEZONE;
  //    flashParameters.alarmsEnabled = false;
  //    flashParameters.gpio09Mode = 1;
  //    flashParameters.lowPower = 0;
  //    flashParameters.gpsEnable = false;
  //    flashParameters.gpsExternal = false;
  //    jfet_dk_set_led(GPSENB,flashParameters.gpsEnable?1:0);
  //    flashParameters.modenPMEnable = false;
  //    jfet_dk_set_led(GPSENB,flashParameters.modenPMEnable?1:0);
  //    flashParameters.offsetAM2315 = 0;
  //    flashParameters.offsetAM2315Humidity = 0;
  //    flashParameters.offsetMSPPressure = 0;
  //    flashParameters.offsetRTD = 0;
  //    flashParameters.offsetThermistor = 0;
  //    flashParameters.sw1 = false;
  //    flashParameters.sw2 = false;
  flashParameters.silent = false;
  flashParameters.manualTrigger = true;
  flashParameters.nouart0 = false;
  flashParameters.ignoreBME688 = true;
  flashParameters.dutyCycle = DEFAULT_DUTYCYCLE;
  strcpy(flashParameters.sensorID, "No ID");
  strcpy(flashParameters.sensorName, "No Sensor Name");
  strcpy(flashParameters.customer, "No Customer Name");
  strcpy(flashParameters.location, "No Location Name");
  strcpy(flashParameters.group, "No Group Name");
  //    strcpy(flashParameters.distributor,"No Distributor Name");
  //    strcpy(flashParameters.clientID,"x");
  ////    strcpy(flashParameters.edrx_param,CONFIG_LTE_EDRX_REQ_VALUE);
  ////    strcpy(flashParameters.ptw_param,CONFIG_LTE_PTW_VALUE);
  //    strcpy(flashParameters.ptw_param,"");
  //    strcpy(flashParameters.psm_param_rat,CONFIG_LTE_PSM_REQ_RAT);
  //    strcpy(flashParameters.psm_param_rptau,CONFIG_LTE_PSM_REQ_RPTAU);
  //    memset(&flashParameters.tempAlarms[0],0,sizeof(tempAlarmStruct) * MAX_NUMBER_TEMPERATURE_SENSORS);
  //    flashParameters.tempAlarmValid = DEFAULT_TEMPALARMVALID;
  //    flashParameters.tempAlarmCheck = DEFAULT_TEMPALARMCHECK;
  //    memset(&flashParameters.humidityAlarms[0],0,sizeof(humidityAlarmStruct) * MAX_NUMBER_HUMIDITY_SENSORS);
  //    flashParameters.humidityAlarmValid = DEFAULT_HUMIDITYALARMVALID;
  //    flashParameters.humidityAlarmCheck = DEFAULT_HUMIDITYALARMCHECK;
  //    memset(&flashParameters.pressureAlarms[0],0,sizeof(pressureAlarmStruct) * MAX_NUMBER_PRESSURE_SENSORS);
  //    flashParameters.pressureAlarmValid = DEFAULT_PRESSUREALARMVALID;
  //    flashParameters.pressureAlarmCheck = DEFAULT_PRESSUREALARMCHECK;
  //    memset(&flashParameters.ezoecAlarms[0],0,sizeof(ezoecAlarmStruct) * MAX_NUMBER_EZOEC_SENSORS);
  //    flashParameters.ezoecAlarmValid = DEFAULT_EZOECALARMVALID;
  //    flashParameters.ezoecAlarmCheck = DEFAULT_EZOECALARMCHECK;
  //    memset(&flashParameters.powerAlarms[0],0,sizeof(powerAlarmStruct) * MAX_NUMBER_POWER_SENSORS);
  //    flashParameters.powerAlarmValid = DEFAULT_POWERALARMVALID;
  //    flashParameters.powerAlarmCheck = DEFAULT_POWERALARMCHECK;
  flashParameters.savedCount = 0;
  flashParameters.nextSavedRead = 0;
  flashParameters.nextSavedWrite = 0;
  // #if 0
  //    flashParameters.tempAlarms[1].tempAlarm = 0xF;
  //    flashParameters.tempAlarms[1].lowTempCheck = (int16_t)(20.0 * 100);
  //    flashParameters.tempAlarms[1].lowTempAlarmValue = (int16_t)(13.67 * 100);
  //    flashParameters.tempAlarms[1].highTempCheck = (int16_t)(30.0 * 100);
  //    flashParameters.tempAlarms[1].highTempAlarmValue = (int16_t)(33.67 * 100);
  //    struct tm  time;
  //    time_t curTime;
  //    getRTCTime(&time);
  //    curTime = mktime(&time);
  //    flashParameters.tempAlarms[1].lowTempTime = curTime;
  //    flashParameters.tempAlarms[1].lowTempTime = curTime;
  //    flashParameters.tempAlarms[1].highTempTime = curTime;
  //    flashParameters.tempAlarms[1].highTempTime = curTime;
  // #endif
  myPrintkI("Flash parameters reset to defaults\r\n");
}
 
/*!
 * \fn void void displayFlashxParameters(void)
 *
 * \brief displays the NV flash parameters.
 *
 * This also first loads the RAM flash parameters from the NV Flash Parameters\n
 * so it reloads the RAM flash parameters.
 *
 */
void displayFlashxParameters(void) {
  printf("FLASH Parameters\r\n");
#if 1
  uint8_t data0[256 + 8];
  int i;
  uint8_t *pFlashParameters = (uint8_t *)&flashParameters;
 
  //    if (flashParameters.silent)
  //        return;
  printf("Flash Parameters Size: %d\r\n", sizeof(flashParametersStruct));
  if (sizeof(flashParametersStruct) <= 256) {
    flashxReadPage(FLASHPARAMETERSTART, data0);
    for (i = 0; i < sizeof(flashParametersStruct); i++)
      pFlashParameters[i] = data0[i];
  } else if (sizeof(flashParametersStruct) <= 512) {
    flashxReadPage(FLASHPARAMETERSTART, data0);
    for (i = 0; i < 256; i++)
      pFlashParameters[i] = data0[i];
    flashxReadPage(FLASHPARAMETERSTART + 1, data0);
    for (i = 0; i < sizeof(flashParametersStruct) - 256; i++)
      pFlashParameters[i + 256] = data0[i];
  } else if (sizeof(flashParametersStruct) <= 768) {
    flashxReadPage(FLASHPARAMETERSTART, data0);
    for (i = 0; i < 256; i++)
      pFlashParameters[i] = data0[i];
    flashxReadPage(FLASHPARAMETERSTART + 1, data0);
    for (i = 0; i < 256; i++)
      pFlashParameters[i + 256] = data0[i];
    flashxReadPage(FLASHPARAMETERSTART + 2, data0);
    for (i = 0; i < sizeof(flashParametersStruct) - 512; i++)
      pFlashParameters[i + 512] = data0[i];
  } else {
    flashxReadPage(FLASHPARAMETERSTART, data0);
    for (i = 0; i < 256; i++)
      pFlashParameters[i] = data0[i];
    flashxReadPage(FLASHPARAMETERSTART + 1, data0);
    for (i = 0; i < 256; i++)
      pFlashParameters[i + 256] = data0[i];
    flashxReadPage(FLASHPARAMETERSTART + 2, data0);
    for (i = 0; i < 256; i++)
      pFlashParameters[i + 512] = data0[i];
    flashxReadPage(FLASHPARAMETERSTART + 3, data0);
    for (i = 0; i < sizeof(flashParametersStruct) - 768; i++)
      pFlashParameters[i + 768] = data0[i];
  }
  if (flashParameters.key == FLASHPARAMETERKEY) {
    printf("    Key: 0x%08X\r\n", (unsigned int)flashParameters.key);
    //        printf("    Date Set: %s\r\n",flashParameters.dateSet?"True":"False");
    //        printf("    Time Zone: %d\r\n",flashParameters.timeZone);
    if (flashParameters.dutyCycle < 7) {
      printf("    Duty Cycle: %d Setting\r\n", flashParameters.dutyCycle);
    } else {
      printf("    Duty Cycle: %d Minutes\r\n", flashParameters.dutyCycle - 7);
    }
    //        printf("    SW1: %s\r\n",flashParameters.sw1?"True":"False");
    //        printf("    SW2: %s\r\n",flashParameters.sw2?"True":"False");
    //        printf("    GPIO09 Mode: %s\r\n",flashParameters.gpio09Mode?"Input":"Output");
    //        if(flashParameters.lowPower > 2)
    //            flashParameters.lowPower = 0;
    ////        printf("    Low Power: %s\r\n",powerModes[flashParameters.lowPower]);
    ////        printf("    Mode_nPM Enable: %s\r\n",flashParameters.modenPMEnable?"True":"False");
    ////        printf("    GPS Enable: %s\r\n",flashParameters.gpsEnable?"True":"False");
    ////        printf("    GPS External: %s\r\n",flashParameters.gpsExternal?"External":"Internal");
    ////        printf("    GPS Fix Check: %ld seconds\r\n",(long int)flashParameters.gpsFixCheck);
    //        printf("    Offset Am2315: %3.3f C\r\n",flashParameters.offsetAM2315 / 1000.0);
    //        printf("    Offset Am2315 Humidity: %3.3f %%\r\n",flashParameters.offsetAM2315Humidity / 1000.0);
    //        printf("    Offset MSP300 Pressure: %3.3f PSI\r\n",flashParameters.offsetMSPPressure / 1000.0);
    //        printf("    Offset RTD: %3.3f C\r\n",flashParameters.offsetRTD / 1000.0);
    //        printf("    Offset Thermistor: %3.3f C\r\n",flashParameters.offsetThermistor / 1000.0);
    printf("    Silent: %s\r\n", flashParameters.silent ? "True" : "False");
    printf("    Manual Trigger: %s\r\n", flashParameters.manualTrigger ? "True" : "False");
    printf("    Ignore BME688: %s\r\n", flashParameters.ignoreBME688 ? "True" : "False");
    printf("    No UART0: %s\r\n", flashParameters.nouart0 ? "True" : "False");
    printf("    Sensor ID: %s\r\n", flashParameters.sensorID);
    printf("    Sensor Name: %s\r\n", flashParameters.sensorName);
    printf("    Customer: %s\r\n", flashParameters.customer);
    printf("    Location: %s\r\n", flashParameters.location);
    printf("    Group: %s\r\n", flashParameters.group);
    //        printf("    Distributor: %s\r\n",flashParameters.distributor);
    //        printf("    Client ID: %s\r\n",flashParameters.clientID);
    //        printf("    EDRX Parameter: %s\r\n",flashParameters.edrx_param);
    ////        printf("    EDRX PTW: %s\r\n",flashParameters.ptw_param);
    //        printf("    PSM Tau: %s\r\n",flashParameters.psm_param_rptau);
    //        printf("    PSM AT: %s\r\n",flashParameters.psm_param_rat);
    printf("    BLE Packets Saved: %d\r\n", flashParameters.savedCount);
    printf("    Next Saved BLE Packet Read: %d 0x%X\r\n", flashParameters.nextSavedRead, flashParameters.nextSavedRead);
    printf("    Next Saved BLE Packet Write: %d 0x%X\r\n", flashParameters.nextSavedWrite, flashParameters.nextSavedWrite);
  } else {
    printf("Flash Parameter Key: 0x%08X Not Set\r\n", flashParameters.key);
  }
#endif
}
 
/*!
 * \fn void setFlashxParameters(uint8_t display)
 *
 * \brief loads the NV Flash parameters from teh RAM flash parameters
 *
 * \param display true to display parameters after the write, false to not display after a write
 *
 */
void setFlashxParameters(uint8_t display) {
  //   int i;
  uint16_t address = FLASHPARAMETERSTART;
  uint8_t *pFlashParameters = (uint8_t *)&flashParameters;
 
  myPrintkI("Setting Flash Parameters\r\n");
  /* erase page */
  flashxEraseSector(FLASHPARAMETERSTART);
  k_sleep(K_MSEC(200));
 
  flashParameters.key = FLASHPARAMETERKEY;
  if (sizeof(flashParametersStruct) <= 256) {
    myPrintkI("Flash Parameters Size: %d\r\n", sizeof(flashParametersStruct));
    memcpy(tmpData, pFlashParameters, sizeof(flashParametersStruct));
    flashxWritePage(FLASHPARAMETERSTART, address, tmpData, sizeof(flashParametersStruct));
    myPrintkI("Flash Parameters Written\r\n");
  } else if (sizeof(flashParametersStruct) <= 512) {
    memcpy(tmpData, pFlashParameters, 256);
    flashxWritePage(FLASHPARAMETERSTART, address, tmpData, 256);
    memcpy(tmpData, pFlashParameters + 256, sizeof(flashParametersStruct) - 256);
    flashxWritePage(FLASHPARAMETERSTART + 1, address, tmpData, (uint16_t)(sizeof(flashParametersStruct) - 256));
  } else if (sizeof(flashParametersStruct) <= 768) {
    memcpy(tmpData, pFlashParameters, 256);
    flashxWritePage(FLASHPARAMETERSTART, address, tmpData, 256);
    memcpy(tmpData, pFlashParameters + 256, 256);
    flashxWritePage(FLASHPARAMETERSTART + 1, address, tmpData, 256);
    memcpy(tmpData, pFlashParameters + 512, sizeof(flashParametersStruct) - 512);
    flashxWritePage(FLASHPARAMETERSTART + 2, address, tmpData, (uint16_t)(sizeof(flashParametersStruct) - 512));
  } else {
    memcpy(tmpData, pFlashParameters, 256);
    flashxWritePage(FLASHPARAMETERSTART, address, tmpData, 256);
    memcpy(tmpData, pFlashParameters + 256, 256);
    flashxWritePage(FLASHPARAMETERSTART + 1, address, tmpData, 256);
    memcpy(tmpData, pFlashParameters + 512, 256);
    flashxWritePage(FLASHPARAMETERSTART + 2, address, tmpData, 256);
    memcpy(tmpData, pFlashParameters + 768, sizeof(flashParametersStruct) - 768);
    flashxWritePage(FLASHPARAMETERSTART + 3, address, tmpData, (uint16_t)(sizeof(flashParametersStruct) - 512));
  }
  //    for(i=0; i < sizeof(flashParametersStruct); i++)
  //        PRINTF("%02X %02X\r\n",tmp[i],pFlashParameters[i]);
  //        for(i=0; i < sizeof(flashParametersStruct); i++,address++)
  //    {
  //        PRINTF("i: %d %02X %02X\r\n",i,address,tmp[i]);
  //    flashxWritePage(FLASHPARAMETERSTART, address,tmp,256);
  //    }
  if (!flashParameters.silent)
    printf("Flash Parameters Set\r\n");
  //    if (display)
  //    {
  //        displayFlashxParameters();
  //    }
  //    //  publishSensor = true;
}
 
/** \fn void getFlashparameters(void)
 * \brief Read the stored flash parameter block from serial flash.
 *
 * The flash parameter structure is stored in consecutive 256-byte pages.
 * This function reads only the number of pages needed for the current
 * sizeof(flashParametersStruct).
 */
void getFlashparameters(void) {
  uint8_t data0[256 + 8];
  uint8_t *pFlashParameters = (uint8_t *)&flashParameters;
  int i;
 
  /* Read the flash parameter pages based on the current structure size. */
  if (sizeof(flashParametersStruct) <= 256) {
    flashxReadPage(FLASHPARAMETERSTART, data0);
    for (i = 0; i < sizeof(flashParametersStruct); i++)
      pFlashParameters[i] = data0[i];
  } else if (sizeof(flashParametersStruct) <= 512) {
    flashxReadPage(FLASHPARAMETERSTART, data0);
    for (i = 0; i < 256; i++)
      pFlashParameters[i] = data0[i];
    flashxReadPage(FLASHPARAMETERSTART + 1, data0);
    for (i = 0; i < sizeof(flashParametersStruct) - 256; i++)
      pFlashParameters[i + 256] = data0[i];
  } else if (sizeof(flashParametersStruct) <= 768) {
    flashxReadPage(FLASHPARAMETERSTART, data0);
    for (i = 0; i < 256; i++)
      pFlashParameters[i] = data0[i];
    flashxReadPage(FLASHPARAMETERSTART + 1, data0);
    for (i = 0; i < 256; i++)
      pFlashParameters[i + 256] = data0[i];
    flashxReadPage(FLASHPARAMETERSTART + 2, data0);
    for (i = 0; i < sizeof(flashParametersStruct) - 512; i++)
      pFlashParameters[i + 512] = data0[i];
  } else if (sizeof(flashParametersStruct) <= 1024) {
    flashxReadPage(FLASHPARAMETERSTART, data0);
    for (i = 0; i < 256; i++)
      pFlashParameters[i] = data0[i];
    flashxReadPage(FLASHPARAMETERSTART + 1, data0);
    for (i = 0; i < 256; i++)
      pFlashParameters[i + 256] = data0[i];
    flashxReadPage(FLASHPARAMETERSTART + 2, data0);
    for (i = 0; i < 256; i++)
      pFlashParameters[i + 512] = data0[i];
    flashxReadPage(FLASHPARAMETERSTART + 3, data0);
    for (i = 0; i < sizeof(flashParametersStruct) - 768; i++)
      pFlashParameters[i + 768] = data0[i];
  } else {
    /* For parameter structures larger than 1024 bytes, read the next pages sequentially. */
    flashxReadPage(FLASHPARAMETERSTART, data0);
    for (i = 0; i < 256; i++)
      pFlashParameters[i] = data0[i];
    flashxReadPage(FLASHPARAMETERSTART + 1, data0);
    for (i = 0; i < 256; i++)
      pFlashParameters[i + 256] = data0[i];
    flashxReadPage(FLASHPARAMETERSTART + 2, data0);
    for (i = 0; i < 256; i++)
      pFlashParameters[i + 512] = data0[i];
    flashxReadPage(FLASHPARAMETERSTART + 3, data0);
    for (i = 0; i < 256; i++)
      pFlashParameters[i + 768] = data0[i];
    flashxReadPage(FLASHPARAMETERSTART + 4, data0);
    for (i = 0; i < sizeof(flashParametersStruct) - 1024; i++)
      pFlashParameters[i + 1024] = data0[i];
  }
}
 
/*!
 * \fn int initW25Q64JV( void)
 *
 * \brief Initiailizes the W25Q64JW.
 *
 *  This will read the WHO_AM_I value to determine if a W25Q64JW is connected.\n
 *  It will set SENSORTYPEW25Q64JW if a W25Q64JW is available.
 *
 *
 * \return TRUE if W25Q64JW connected, FALSE if W25Q64JW not connected.
 */
int initW25Q64JV(void) {
  uint8_t flashIDIn[5];
 
  readNVFlashxID(flashIDIn);
  if ((flashIDIn[0] == W25Q64JW_WHO_AM_I_REG0) && (flashIDIn[1] == W25Q64JW_WHO_AM_I_REG1) && (flashIDIn[2] == W25Q64JW_WHO_AM_I_REG2)) {
    sensorTypePresentAll |= (1 << SENSORTYPEW25Q64JV);
    myPrintkI("W25Q64JV 64MB Flash Memory - Present\r\n");
    return TRUE;
  } else {
    myPrintkW("W25Q64JV 64MB Flash Memory - Not Present\r\n");
    return FALSE;
  }
}