MicrochipSRAM.h

Go to the documentation of this file.

// clang-format off
// clang-format on
#include "Arduino.h"  // Arduino data type definitions
#include <SPI.h>      // SPI (Serial Peripheral Interface)
#ifndef MicrochipSRAM_h

#define MicrochipSRAM_h
/****************************************************************************************************
** Declare constants used in the class **
****************************************************************************************************/
const uint8_t  SRAM_WRITE_MODE_REG{0x01};  
const uint8_t  SRAM_READ_MODE_REG{0x05};   
const uint8_t  SRAM_BYTE_MODE{B00000000};  
const uint8_t  SRAM_PAGE_MODE{B10000000};  
const uint8_t  SRAM_SEQ_MODE{B11000000};   
const uint32_t SRAM_1024{131072};          
const uint32_t SRAM_512{65536};            
const uint32_t SRAM_256{32768};            
const uint32_t SRAM_128{16384};            
const uint32_t SRAM_64{8192};              
const uint8_t  SRAM_WRITE_CODE{2};         
const uint8_t  SRAM_READ_CODE{3};          

class MicrochipSRAM {
 public:
  MicrochipSRAM(const uint8_t SSPin);
  ~MicrochipSRAM();
  void clearMemory(const uint8_t clearValue = 0) const;
  /*************************************************************************************************
  ** Declare the get and put methods as template functions here in the header file. This allows   **
  ** any type of variable or structure to be used rather than having to make one function for     **
  ** each datatype used. Note that due to the sequential mode being active, reads and writes that **
  ** go past the last existing address will automatically wrap back to the beginning of memory.   **
  *************************************************************************************************/
  template <typename T>
  uint32_t &get(const uint32_t addr, T &value) const {
    static uint32_t returnAddress;
    uint8_t *       bytePtr = (uint8_t *)&value;               // Pointer to structure beginning
    returnAddress           = (addr + sizeof(T)) % SRAMBytes;  // compute the return address
    digitalWrite(_SSPin, LOW);                                 // Pull CS/SS low to select device
    SPI.transfer(SRAM_READ_CODE);                              // Send the command for READ mode
    if (SRAMBytes == SRAM_1024)
      SPI.transfer((uint8_t)(addr >> 16) & 0xFF);  // Send the MSB of the 24bit address
    SPI.transfer((uint8_t)(addr >> 8) & 0xFF);     // Send the 2nd byte of the address
    SPI.transfer((uint8_t)addr);                   // Send the LSB of the address
    for (uint32_t i = 0; i < sizeof(T); i++)
      *bytePtr++ = SPI.transfer(0x00);  // loop for each byte to be read
    digitalWrite(_SSPin, HIGH);         // Pull the SS/CS high to deselect
    return (returnAddress);             // Return the computed new address
  }                                     // of method "get()"
  template <typename T>
  uint32_t &put(const uint32_t addr, const T &value) const {
    static uint32_t returnAddress;
    const uint8_t * bytePtr = (const uint8_t *)&value;         // Pointer to structure beginning
    returnAddress           = (addr + sizeof(T)) % SRAMBytes;  // compute the return address
    digitalWrite(_SSPin, LOW);                                 // Pull CS/SS low to select device
    SPI.transfer(SRAM_WRITE_CODE);                             // Send the command for WRITE mode
    if (SRAMBytes == SRAM_1024)
      SPI.transfer((uint8_t)(addr >> 16) & 0xFF);  // Send the MSB of the 24bit address
    SPI.transfer((uint8_t)(addr >> 8) & 0xFF);     // Send the 2nd byte of the address
    SPI.transfer((uint8_t)addr);                   // Send the LSB of the address
    for (uint32_t i = 0; i < sizeof(T); i++)
      SPI.transfer(*bytePtr++);  // loop for each byte to be written
    digitalWrite(_SSPin, HIGH);  // Pull the SS/CS high to deselect
    return (returnAddress);      // Return the computed new address
  }                              // of method put()
  template <typename T>
  uint32_t &fillMemory(uint32_t addr, T &value) const {
    while (addr < (SRAMBytes - sizeof(T)))
      addr = put(addr, value);  // loop until we reach end of memory
    return (addr);
  }                        // of method fillMemory()
  uint32_t SRAMBytes = 0;  
 private:
  uint8_t _SSPin = 0;  
};                     // of MicrochipSRAM class definition
#endif