Revision 0:bdd299c0e8e6, committed 2012-07-14

Comitter:

bborredon

Date:

Sat Jul 14 08:23:30 2012 +0000

Commit message:

[mbed] converted /SramSpi/sram23x

Changed in this revision

diff -r 000000000000 -r bdd299c0e8e6 sram23x.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sram23x.cpp	Sat Jul 14 08:23:30 2012 +0000
@@ -0,0 +1,371 @@
+/***********************************************************
+Author: Bernard Borredon
+Date: 27 december 2011
+Version: 1.0
+************************************************************/
+#include "sram23x.h"
+
+#define HIGH(x) (x >> 8)
+#define LOW(x) (x & 0xff)
+
+SRAM23X::SRAM23X(PinName mosi, PinName miso, PinName sclk, PinName cs, TypeSram type) : _spi(mosi, miso, sclk) 
+{
+  
+  _errnum = SRAM23X_NoError;
+  _type = type;
+  _cs = new DigitalOut(cs);
+  if(_cs == NULL)
+    _errnum = SRAM23X_CsError;
+    
+  // Don't select chip
+  deselect();
+  
+    // Size in bytes
+  _size = _type;
+  
+  // Set SPI frequency
+  _spi.frequency(10000000);
+  
+  // Set format
+  _spi.format(8,0);
+  
+  // Mode sequential
+  select();
+  writeStatus(SRAM23X_SEQ);
+  deselect();
+}
+
+// Initialization
+uint8_t SRAM23X::init(uint16_t address, uint16_t size, uint8_t mode)
+{
+  
+  // Check error
+  if(_errnum) 
+    return(_errnum);
+    
+  // Check address
+  if(!checkAddress(address)) {
+    _errnum = SRAM23X_OutOfRange;
+    return(_errnum);
+  }
+  
+  // Check address
+  if(!checkAddress(address + size - 1)) {
+    _errnum = SRAM23X_OutOfRange;
+    return(_errnum);
+  }
+  
+  // No error
+  _errnum = SRAM23X_NoError;
+
+  select();
+  // Acces instruction
+  _spi.write(mode);
+  
+  // High address part
+  _spi.write(HIGH(address));
+  
+  // Low address part
+  _spi.write(LOW(address));
+  
+  return(_errnum);
+}
+
+// Sequential read bytes
+void SRAM23X::read(uint16_t address, int8_t *data, uint16_t size)
+{
+  uint8_t ret;
+  uint16_t i;
+  
+  ret = init(address,size,SRAM23X_READ);
+  if(ret != 0) {
+    // Deselect chip
+    deselect();
+    return;
+  }
+  
+  // Datas
+  for(i = 0;i < size;i++) {
+    data[i] = _spi.write(0);
+  }
+  
+  // Deselect chip
+  deselect();
+  
+}
+
+// Sequential read anything
+void SRAM23X::read(uint16_t address, void *data, uint16_t size)
+{
+  int8_t *cmd = NULL;
+  
+  cmd = (int8_t *)malloc(size);
+  if(cmd == NULL) {
+    _errnum = SRAM23X_MallocError;
+    return;
+  }
+  
+  read(address,cmd,size);
+  
+  memcpy(data,cmd,size);
+  
+  free(cmd);
+}
+
+// Sequential read int16
+void SRAM23X::read(uint16_t address, int16_t *data, uint16_t size)
+{
+  uint16_t i,j;
+  uint8_t cmd[2];
+  uint8_t ret;
+  
+  ret = init(address,size,SRAM23X_READ);
+  if(ret != 0) {
+    // Deselect chip
+    deselect();
+    return;
+  }
+  
+  // Datas
+  for(i = 0;i < size / 2;i = i + 2) {
+     for(j = 0;j < 2;j++)
+        cmd[j] = _spi.write(0);
+     memcpy(&data[i],cmd,2);
+  }
+  
+  // Deselect chip
+  deselect();
+
+}
+
+// Sequential read int32
+void SRAM23X::read(uint16_t address, int32_t *data, uint16_t size)
+{
+  uint16_t i,j;
+  uint8_t cmd[4];
+  uint8_t ret;
+  
+  ret = init(address,size,SRAM23X_READ);
+  if(ret != 0) {
+    // Deselect chip
+    deselect();
+    return;
+  }
+  
+  // Datas
+  for(i = 0;i < size / 4;i = i + 4) {
+     for(j = 0;j < 4;j++)
+        cmd[j] = _spi.write(0);
+     memcpy(&data[i],cmd,4);
+  }
+  
+  // Deselect chip
+  deselect();
+
+}
+
+// Sequential read float
+void SRAM23X::read(uint16_t address, float *data, uint16_t size)
+{
+  uint16_t i,j;
+  uint8_t cmd[4];
+  uint8_t ret;
+  
+  ret = init(address,size,SRAM23X_READ);
+  if(ret != 0) {
+    // Deselect chip
+    deselect();
+    return;
+  }
+  
+  // Datas
+  for(i = 0;i < size / 4;i = i + 4) {
+     for(j = 0;j < 4;j++)
+        cmd[j] = _spi.write(0);
+     memcpy(&data[i],cmd,4);
+  }
+  
+  // Deselect chip
+  deselect();
+
+}
+
+// Sequential write bytes
+void SRAM23X::write(uint16_t address, int8_t *data, uint16_t size)
+{
+  uint16_t i;
+  uint8_t ret;
+  
+  ret = init(address,size,SRAM23X_WRITE);
+  if(ret != 0) {
+    // Deselect chip
+    deselect();
+    return;
+  }
+  
+  // Datas
+  for(i = 0;i < size;i++) {
+    _spi.write(data[i]);
+  }
+  
+  // Deselect chip
+  deselect();
+  
+}
+
+// Sequential write anything
+void SRAM23X::write(uint16_t address, void *data, uint16_t size)
+{
+  int8_t *cmd = NULL;
+  
+  cmd = (int8_t *)malloc(size);
+  if(cmd == NULL) {
+    _errnum = SRAM23X_MallocError;
+    return;
+  }
+  
+  memcpy(cmd,data,size);
+  
+  write(address,cmd,size);
+  
+  free(cmd);
+}
+
+// Sequential write int16
+void SRAM23X::write(uint16_t address, int16_t *data, uint16_t size)
+{
+  uint16_t i,j;
+  uint8_t ret;
+  uint8_t cmd[2];
+  
+  ret = init(address,size,SRAM23X_WRITE);
+  if(ret != 0) {
+    // Deselect chip
+    deselect();
+    return;
+  }
+  
+  // Datas
+  for(i = 0;i < size / 2;i = i + 2) {
+     memcpy(cmd,&data[i],2);
+     for(j = 0;j < 2;j++)
+        _spi.write(cmd[j]);
+  }
+  
+  // Deselect chip
+  deselect();
+  
+}
+
+// Sequential write int32
+void SRAM23X::write(uint16_t address, int32_t *data, uint16_t size)
+{
+  uint16_t i,j;
+  uint8_t ret;
+  uint8_t cmd[4];
+  
+  ret = init(address,size,SRAM23X_WRITE);
+  if(ret != 0) {
+    // Deselect chip
+    deselect();
+    return;
+  }
+  
+  // Datas
+  for(i = 0;i < size / 4;i = i + 4) {
+     memcpy(cmd,&data[i],4);
+     for(j = 0;j < 4;j++)
+        _spi.write(cmd[j]);
+  }
+  
+  // Deselect chip
+  deselect();
+  
+}
+
+// Sequential write float
+void SRAM23X::write(uint16_t address, float *data, uint16_t size)
+{
+  uint16_t i,j;
+  uint8_t ret;
+  uint8_t cmd[4];
+  
+  ret = init(address,size,SRAM23X_WRITE);
+  if(ret != 0) {
+    // Deselect chip
+    deselect();
+    return;
+  }
+  
+  // Datas
+  for(i = 0;i < size / 4;i = i + 4) {
+     memcpy(cmd,&data[i],4);
+     for(j = 0;j < 4;j++)
+        _spi.write(cmd[j]);
+  }
+  
+  // Deselect chip
+  deselect();
+  
+}
+
+// Get SRAM size in bytes
+uint16_t SRAM23X::getSize(void)
+{
+  return(_size);
+}
+
+// Select chip
+void SRAM23X::select(void)
+{
+  _cs->write(0);
+  wait_us(10.0);
+}
+
+// Deselect chip
+void SRAM23X::deselect(void)
+{
+
+  wait_us(10.0);
+  _cs->write(1);
+}
+
+// Read status register
+uint8_t SRAM23X::readStatus(void)
+{
+  uint8_t ret;
+  
+  select();
+  _spi.write(SRAM23X_RDSR);
+  ret = _spi.write(0);
+  deselect();
+  
+  return(ret);
+}
+
+// Write status register
+void SRAM23X::writeStatus(uint8_t status)
+{
+  
+  select();
+  _spi.write(SRAM23X_WRSR);
+  _spi.write(status);
+  deselect();
+}
+
+// Check address
+bool SRAM23X::checkAddress(uint16_t address)
+{
+  bool ret = true;
+  
+  if(address >= _type)
+    ret = false;
+  
+  return(ret);
+}  
+
+// Get current error number
+uint8_t SRAM23X::getError(void)
+{ 
+  return(_errnum);
+}
\ No newline at end of file

diff -r 000000000000 -r bdd299c0e8e6 sram23x.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sram23x.h	Sat Jul 14 08:23:30 2012 +0000
@@ -0,0 +1,211 @@
+#ifndef __SRAM23X__H_
+#define __SRAM23X__H_
+
+// Includes
+#include <string> 
+
+#include "mbed.h"
+
+// Example
+/*
+*/
+
+// Defines
+#define SRAM23X_READ        0x03
+#define SRAM23X_WRITE       0x02
+#define SRAM23X_RDSR        0x05
+#define SRAM23X_WRSR        0x01
+#define SRAM23X_SEQ         0x40
+
+#define SRAM23X_NoError     0x00
+#define SRAM23X_OutOfRange  0x01
+#define SRAM23X_CsError     0x02
+#define SRAM23X_MallocError 0x03
+
+#define SRAM23X_MaxError       4
+
+static std::string _ErrorMessageSRAM23X[SRAM23X_MaxError] = {
+                                                          "",
+                                                          "Data address out of range"
+                                                          "Chip select error",
+                                                          "Memory allocation error"       
+                                                        };
+
+// Class
+class SRAM23X {
+public:
+    enum TypeSram {S23X640=8192,S23X256=32768} Type;
+    
+    /*
+     * Constructor, initialize the sram on spi interface.
+     * @param mosi : mosi spi pin (PinName)
+     * @param miso : miso spi pin (PinName)
+     * @param sclk : sclk spi pin (PinName)
+     * @param cs   : chip select pin (PinName)
+     * @param type : sram type (TypeSram) 
+     * @return none
+    */
+    SRAM23X(PinName mosi, PinName miso, PinName sclk, PinName cs, TypeSram type);
+    
+   /*
+     * Sequential read bytes
+     * @param address : start address (uint16_t)
+     * @param data : bytes array to read (int8_t *)
+     * @param size : number of bytes to read (uint16_t)
+     * @return none
+    */
+    void read(uint16_t address, int8_t *data, uint16_t size);
+    
+    /*
+     * Sequential read anything
+     * @param address : start address (uint16_t)
+     * @param data : data array to read (void *)
+     * @param size : number of bytes to read (uint16_t)
+     * @return none
+    */
+    void read(uint16_t address, void *data, uint16_t size);
+    
+    /*
+     * Sequential read int16
+     * @param address : start address (uint16_t)
+     * @param data : short array to read (int16_t *)
+     * @param size : number of bytes to read (uint16_t)
+     * @return none
+    */
+    void read(uint16_t address, int16_t *data, uint16_t size);
+    
+    /*
+     * Sequential read int32
+     * @param address : start address (uint16_t)
+     * @param data : int array to read (int32_t *)
+     * @param size : number of bytes to read (uint16_t)
+     * @return none
+    */
+    void read(uint16_t address, int32_t *data, uint16_t size);
+    
+    /*
+     * Sequential read float
+     * @param address : start address (uint16_t)
+     * @param data : float array to read (float *)
+     * @param size : number of bytes to read (uint16_t)
+     * @return none
+    */
+    void read(uint16_t address, float *data, uint16_t size);
+    
+    /*
+     * Sequential write bytes
+     * @param address : start address(uint16_t)
+     * @param data : bytes array to write (int8_t *)
+     * @param size : number of bytes to write (uint16_t)
+     * @return none
+    */
+    void write(uint16_t address, int8_t *data, uint16_t size);
+    
+    /*
+     * Sequential write anything
+     * @param address : start address (uint16_t)
+     * @param data : data array to write (void *)
+     * @param size : number of bytes to write (uint16_t)
+     * @return none
+    */
+    void write(uint16_t address, void *data, uint16_t size);
+    
+    /*
+     * Sequential write int16
+     * @param address : start address (uint16_t)
+     * @param data : short array to write  (int8_t *)
+     * @param size : number of bytes to write (uint16_t)
+     * @return none
+    */
+    void write(uint16_t address, int16_t *data, uint16_t size);
+    
+    /*
+     * Sequential write int32
+     * @param address : address to write (uint16_t)
+     * @param data : int array to write (int32_t *)
+     * @param size : number of bytes to write (uint16_t)
+     * @return none
+    */
+    void write(uint16_t address, int32_t *data, uint16_t size);
+    
+    /*
+     * Sequential write float
+     * @param address : address to write (uint16_t)
+     * @param data : float array to write (float *)
+     * @param size : number of bytes to write (uint16_t)
+     * @return none
+    */
+    void write(uint16_t address, float *data, uint16_t size);
+    
+    /*
+     * Get sram size in bytes
+     * @param : none
+     * @return size in bytes (uint16_t)
+    */
+    uint16_t getSize(void);
+    
+    /*
+     * Select chip
+     * @param : none
+     * @return none
+    */
+    void select(void);
+    
+    /*
+     * Deselect chip
+     * @param : none
+     * @return none
+    */
+    void deselect(void);
+    
+    /*
+     * Read status register
+     * @param : none
+     * @return status register  value (uint8_t)
+    */
+    uint8_t readStatus(void);
+    
+    /*
+     * Write status register
+     * @param : status value (uint8_t)
+     * @return none
+    */
+    void writeStatus(uint8_t status);
+    
+    /*
+     * Get current error message
+     * @param  : none
+     * @return current error message(std::string)
+    */
+    std::string getErrorMessage(void)
+    { 
+      return(_ErrorMessageSRAM23X[_errnum]);
+    }
+    
+    /*
+     * Get the current error number (SRAM23X_NoError if no error)
+     * @param  : none
+     * @return current error number (uint8_t)
+    */
+    uint8_t getError(void);
+    
+//---------- local variables ----------
+private:
+    SPI _spi;             // Local spi communication interface instance
+    DigitalOut *_cs;      // Chip select
+    uint8_t _errnum;      // Error number
+    TypeSram _type;       // SRAM type
+    uint16_t _size;       // Size in bytes
+    bool checkAddress(uint16_t address); // Check address range
+//-------------------------------------
+
+    /*
+     * Initialization
+     * @param address : address to write (uint16_t)
+     * @param size : size to write in bytes (uint16_t)
+     * @param mode : read or write (uint8_t)
+     * @return error code, 0 if no error
+    */
+    uint8_t init(uint16_t address, uint16_t size, uint8_t mode);
+};
+#endif
\ No newline at end of file