SPI SRAM 23X library

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers sram23x.cpp Source File

sram23x.cpp

00001 /***********************************************************
00002 Author: Bernard Borredon
00003 Date: 27 december 2011
00004 Version: 1.0
00005 ************************************************************/
00006 #include "sram23x.h"
00007 
00008 #define HIGH(x) (x >> 8)
00009 #define LOW(x) (x & 0xff)
00010 
00011 SRAM23X::SRAM23X(PinName mosi, PinName miso, PinName sclk, PinName cs, TypeSram type) : _spi(mosi, miso, sclk) 
00012 {
00013   
00014   _errnum = SRAM23X_NoError;
00015   _type = type;
00016   _cs = new DigitalOut(cs);
00017   if(_cs == NULL)
00018     _errnum = SRAM23X_CsError;
00019     
00020   // Don't select chip
00021   deselect();
00022   
00023     // Size in bytes
00024   _size = _type;
00025   
00026   // Set SPI frequency
00027   _spi.frequency(10000000);
00028   
00029   // Set format
00030   _spi.format(8,0);
00031   
00032   // Mode sequential
00033   select();
00034   writeStatus(SRAM23X_SEQ);
00035   deselect();
00036 }
00037 
00038 // Initialization
00039 uint8_t SRAM23X::init(uint16_t address, uint16_t size, uint8_t mode)
00040 {
00041   
00042   // Check error
00043   if(_errnum) 
00044     return(_errnum);
00045     
00046   // Check address
00047   if(!checkAddress(address)) {
00048     _errnum = SRAM23X_OutOfRange;
00049     return(_errnum);
00050   }
00051   
00052   // Check address
00053   if(!checkAddress(address + size - 1)) {
00054     _errnum = SRAM23X_OutOfRange;
00055     return(_errnum);
00056   }
00057   
00058   // No error
00059   _errnum = SRAM23X_NoError;
00060 
00061   select();
00062   // Acces instruction
00063   _spi.write(mode);
00064   
00065   // High address part
00066   _spi.write(HIGH(address));
00067   
00068   // Low address part
00069   _spi.write(LOW(address));
00070   
00071   return(_errnum);
00072 }
00073 
00074 // Sequential read bytes
00075 void SRAM23X::read(uint16_t address, int8_t *data, uint16_t size)
00076 {
00077   uint8_t ret;
00078   uint16_t i;
00079   
00080   ret = init(address,size,SRAM23X_READ);
00081   if(ret != 0) {
00082     // Deselect chip
00083     deselect();
00084     return;
00085   }
00086   
00087   // Datas
00088   for(i = 0;i < size;i++) {
00089     data[i] = _spi.write(0);
00090   }
00091   
00092   // Deselect chip
00093   deselect();
00094   
00095 }
00096 
00097 // Sequential read anything
00098 void SRAM23X::read(uint16_t address, void *data, uint16_t size)
00099 {
00100   int8_t *cmd = NULL;
00101   
00102   cmd = (int8_t *)malloc(size);
00103   if(cmd == NULL) {
00104     _errnum = SRAM23X_MallocError;
00105     return;
00106   }
00107   
00108   read(address,cmd,size);
00109   
00110   memcpy(data,cmd,size);
00111   
00112   free(cmd);
00113 }
00114 
00115 // Sequential read int16
00116 void SRAM23X::read(uint16_t address, int16_t *data, uint16_t size)
00117 {
00118   uint16_t i,j;
00119   uint8_t cmd[2];
00120   uint8_t ret;
00121   
00122   ret = init(address,size,SRAM23X_READ);
00123   if(ret != 0) {
00124     // Deselect chip
00125     deselect();
00126     return;
00127   }
00128   
00129   // Datas
00130   for(i = 0;i < size / 2;i = i + 2) {
00131      for(j = 0;j < 2;j++)
00132         cmd[j] = _spi.write(0);
00133      memcpy(&data[i],cmd,2);
00134   }
00135   
00136   // Deselect chip
00137   deselect();
00138 
00139 }
00140 
00141 // Sequential read int32
00142 void SRAM23X::read(uint16_t address, int32_t *data, uint16_t size)
00143 {
00144   uint16_t i,j;
00145   uint8_t cmd[4];
00146   uint8_t ret;
00147   
00148   ret = init(address,size,SRAM23X_READ);
00149   if(ret != 0) {
00150     // Deselect chip
00151     deselect();
00152     return;
00153   }
00154   
00155   // Datas
00156   for(i = 0;i < size / 4;i = i + 4) {
00157      for(j = 0;j < 4;j++)
00158         cmd[j] = _spi.write(0);
00159      memcpy(&data[i],cmd,4);
00160   }
00161   
00162   // Deselect chip
00163   deselect();
00164 
00165 }
00166 
00167 // Sequential read float
00168 void SRAM23X::read(uint16_t address, float *data, uint16_t size)
00169 {
00170   uint16_t i,j;
00171   uint8_t cmd[4];
00172   uint8_t ret;
00173   
00174   ret = init(address,size,SRAM23X_READ);
00175   if(ret != 0) {
00176     // Deselect chip
00177     deselect();
00178     return;
00179   }
00180   
00181   // Datas
00182   for(i = 0;i < size / 4;i = i + 4) {
00183      for(j = 0;j < 4;j++)
00184         cmd[j] = _spi.write(0);
00185      memcpy(&data[i],cmd,4);
00186   }
00187   
00188   // Deselect chip
00189   deselect();
00190 
00191 }
00192 
00193 // Sequential write bytes
00194 void SRAM23X::write(uint16_t address, int8_t *data, uint16_t size)
00195 {
00196   uint16_t i;
00197   uint8_t ret;
00198   
00199   ret = init(address,size,SRAM23X_WRITE);
00200   if(ret != 0) {
00201     // Deselect chip
00202     deselect();
00203     return;
00204   }
00205   
00206   // Datas
00207   for(i = 0;i < size;i++) {
00208     _spi.write(data[i]);
00209   }
00210   
00211   // Deselect chip
00212   deselect();
00213   
00214 }
00215 
00216 // Sequential write anything
00217 void SRAM23X::write(uint16_t address, void *data, uint16_t size)
00218 {
00219   int8_t *cmd = NULL;
00220   
00221   cmd = (int8_t *)malloc(size);
00222   if(cmd == NULL) {
00223     _errnum = SRAM23X_MallocError;
00224     return;
00225   }
00226   
00227   memcpy(cmd,data,size);
00228   
00229   write(address,cmd,size);
00230   
00231   free(cmd);
00232 }
00233 
00234 // Sequential write int16
00235 void SRAM23X::write(uint16_t address, int16_t *data, uint16_t size)
00236 {
00237   uint16_t i,j;
00238   uint8_t ret;
00239   uint8_t cmd[2];
00240   
00241   ret = init(address,size,SRAM23X_WRITE);
00242   if(ret != 0) {
00243     // Deselect chip
00244     deselect();
00245     return;
00246   }
00247   
00248   // Datas
00249   for(i = 0;i < size / 2;i = i + 2) {
00250      memcpy(cmd,&data[i],2);
00251      for(j = 0;j < 2;j++)
00252         _spi.write(cmd[j]);
00253   }
00254   
00255   // Deselect chip
00256   deselect();
00257   
00258 }
00259 
00260 // Sequential write int32
00261 void SRAM23X::write(uint16_t address, int32_t *data, uint16_t size)
00262 {
00263   uint16_t i,j;
00264   uint8_t ret;
00265   uint8_t cmd[4];
00266   
00267   ret = init(address,size,SRAM23X_WRITE);
00268   if(ret != 0) {
00269     // Deselect chip
00270     deselect();
00271     return;
00272   }
00273   
00274   // Datas
00275   for(i = 0;i < size / 4;i = i + 4) {
00276      memcpy(cmd,&data[i],4);
00277      for(j = 0;j < 4;j++)
00278         _spi.write(cmd[j]);
00279   }
00280   
00281   // Deselect chip
00282   deselect();
00283   
00284 }
00285 
00286 // Sequential write float
00287 void SRAM23X::write(uint16_t address, float *data, uint16_t size)
00288 {
00289   uint16_t i,j;
00290   uint8_t ret;
00291   uint8_t cmd[4];
00292   
00293   ret = init(address,size,SRAM23X_WRITE);
00294   if(ret != 0) {
00295     // Deselect chip
00296     deselect();
00297     return;
00298   }
00299   
00300   // Datas
00301   for(i = 0;i < size / 4;i = i + 4) {
00302      memcpy(cmd,&data[i],4);
00303      for(j = 0;j < 4;j++)
00304         _spi.write(cmd[j]);
00305   }
00306   
00307   // Deselect chip
00308   deselect();
00309   
00310 }
00311 
00312 // Get SRAM size in bytes
00313 uint16_t SRAM23X::getSize(void)
00314 {
00315   return(_size);
00316 }
00317 
00318 // Select chip
00319 void SRAM23X::select(void)
00320 {
00321   _cs->write(0);
00322   wait_us(10.0);
00323 }
00324 
00325 // Deselect chip
00326 void SRAM23X::deselect(void)
00327 {
00328 
00329   wait_us(10.0);
00330   _cs->write(1);
00331 }
00332 
00333 // Read status register
00334 uint8_t SRAM23X::readStatus(void)
00335 {
00336   uint8_t ret;
00337   
00338   select();
00339   _spi.write(SRAM23X_RDSR);
00340   ret = _spi.write(0);
00341   deselect();
00342   
00343   return(ret);
00344 }
00345 
00346 // Write status register
00347 void SRAM23X::writeStatus(uint8_t status)
00348 {
00349   
00350   select();
00351   _spi.write(SRAM23X_WRSR);
00352   _spi.write(status);
00353   deselect();
00354 }
00355 
00356 // Check address
00357 bool SRAM23X::checkAddress(uint16_t address)
00358 {
00359   bool ret = true;
00360   
00361   if(address >= _type)
00362     ret = false;
00363   
00364   return(ret);
00365 }  
00366 
00367 // Get current error number
00368 uint8_t SRAM23X::getError(void)
00369 { 
00370   return(_errnum);
00371 }