SPI SRAM 23X library
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
sram23x.cpp | Show annotated file Show diff for this revision Revisions of this file |
sram23x.h | Show annotated file Show diff for this revision Revisions of this file |
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