SPI SRAM 23X library
Embed:
(wiki syntax)
Show/hide line numbers
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 }
Generated on Wed Jul 20 2022 13:32:55 by 1.7.2