Sonder Design Team / Memory25L16_fast

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependents:   BlackBoard_Firmware_Fast_read_not_test

Fork of Memory by Sonder Design Team

Memory.cpp@10:96b5e7dcc91f, 2018-04-17 (annotated)

Committer:
ThomasSonderDesign
Date:
Tue Apr 17 03:20:30 2018 +0000
Revision:
10:96b5e7dcc91f
Parent:
9:2587f246bf48
Parent:
5:2fa79108a29b
Child:
11:e3cbdbe3d77b
againg?;

Who changed what in which revision?

UserRevisionLine numberNew contents of line
ThomasSonderDesign 0:c2e41d203cdb 1 #include "mbed.h"
ThomasSonderDesign 0:c2e41d203cdb 2 #include "Memory.h"
ThomasSonderDesign 0:c2e41d203cdb 3
ThomasSonderDesign 0:c2e41d203cdb 4
ThomasSonderDesign 0:c2e41d203cdb 5 Memory::Memory(PinName chipSelect) : _cs_mem(chipSelect)
ThomasSonderDesign 0:c2e41d203cdb 6 {
ThomasSonderDesign 0:c2e41d203cdb 7 _cs_mem=1;
ThomasSonderDesign 0:c2e41d203cdb 8 }
ThomasSonderDesign 0:c2e41d203cdb 9 /**
ThomasSonderDesign 0:c2e41d203cdb 10 * Reads 'length' elements into a char array starting at the 24bit Address.
ThomasSonderDesign 0:c2e41d203cdb 11 *If length is greater than BufferSize (3840 bytes) the function will terminate
ThomasSonderDesign 0:c2e41d203cdb 12 *and return the start address.
ThomasSonderDesign 0:c2e41d203cdb 13 */
ThomasSonderDesign 8:6af25b9563df 14 int Memory::readData(SPI my_spi, short value [], int Address, int length)
ThomasSonderDesign 0:c2e41d203cdb 15 {
ThomasSonderDesign 8:6af25b9563df 16 //if(length>bufferSize) {
ThomasSonderDesign 8:6af25b9563df 17 //printf("\nLength %i exceeds Max Length\n",length);
ThomasSonderDesign 8:6af25b9563df 18 //return Address;
ThomasSonderDesign 8:6af25b9563df 19 //}
ThomasSonderDesign 8:6af25b9563df 20 int temp = 0;
ThomasSonderDesign 8:6af25b9563df 21 int temp1 = 0;
ThomasSonderDesign 8:6af25b9563df 22 int temp2 =0;
ThomasSonderDesign 0:c2e41d203cdb 23 _cs_mem = 1; //Ensure cs is deselected
ThomasSonderDesign 0:c2e41d203cdb 24 wait_us(10);
ThomasSonderDesign 0:c2e41d203cdb 25 _cs_mem = 0; //memory is selected
ThomasSonderDesign 0:c2e41d203cdb 26 my_spi.write(0x03); //Send read command
ThomasSonderDesign 0:c2e41d203cdb 27 my_spi.write(Address>>16); //Send high address byte
ThomasSonderDesign 0:c2e41d203cdb 28 my_spi.write(Address>>8); //Send mid address byte
ThomasSonderDesign 0:c2e41d203cdb 29 my_spi.write(Address); //Send low address byte
ThomasSonderDesign 0:c2e41d203cdb 30
ThomasSonderDesign 0:c2e41d203cdb 31
ThomasSonderDesign 0:c2e41d203cdb 32 for(int i =0; i <length; i++) {
ThomasSonderDesign 8:6af25b9563df 33 temp = my_spi.write(dummy);//Send dummy byte to read out value ate Address
ThomasSonderDesign 8:6af25b9563df 34 value[i]= (temp);
ThomasSonderDesign 8:6af25b9563df 35 //printf(" %X",value[i]);
ThomasSonderDesign 0:c2e41d203cdb 36 Address++;
ThomasSonderDesign 0:c2e41d203cdb 37 }
ThomasSonderDesign 0:c2e41d203cdb 38 _cs_mem = 1;
ThomasSonderDesign 0:c2e41d203cdb 39 return Address; //Return the address of the next unread byte
ThomasSonderDesign 0:c2e41d203cdb 40 }
ThomasSonderDesign 0:c2e41d203cdb 41
ThomasSonderDesign 0:c2e41d203cdb 42
ThomasSonderDesign 0:c2e41d203cdb 43 /**
ThomasSonderDesign 0:c2e41d203cdb 44 * Sector Erase, erases everything in the 4KB sector that includes Address
ThomasSonderDesign 0:c2e41d203cdb 45 */
ThomasSonderDesign 0:c2e41d203cdb 46 void Memory::sectorErase(SPI my_spi, long Address)
ThomasSonderDesign 0:c2e41d203cdb 47 {
ThomasSonderDesign 0:c2e41d203cdb 48 _cs_mem = 1;
ThomasSonderDesign 0:c2e41d203cdb 49 _cs_mem=0;
ThomasSonderDesign 0:c2e41d203cdb 50 my_spi.write(0x06); //Send Write enable command
ThomasSonderDesign 0:c2e41d203cdb 51 _cs_mem= 1;
ThomasSonderDesign 0:c2e41d203cdb 52 wait_us(5);
ThomasSonderDesign 0:c2e41d203cdb 53 _cs_mem=0;
ThomasSonderDesign 0:c2e41d203cdb 54 my_spi.write(0x20); //Send sector erase comand
ThomasSonderDesign 0:c2e41d203cdb 55 my_spi.write(Address>>16); //Send high address byte
ThomasSonderDesign 0:c2e41d203cdb 56 my_spi.write(Address>>8); //Send mid address byte
ThomasSonderDesign 0:c2e41d203cdb 57 my_spi.write(Address); //Send low address byte
ThomasSonderDesign 0:c2e41d203cdb 58 _cs_mem=1;
ThomasSonderDesign 0:c2e41d203cdb 59 wait_us(5);
ThomasSonderDesign 0:c2e41d203cdb 60
ThomasSonderDesign 0:c2e41d203cdb 61 //Pol the status register untill the Write In Progress bit is no longer set
ThomasSonderDesign 0:c2e41d203cdb 62 _cs_mem=0;
ThomasSonderDesign 0:c2e41d203cdb 63 my_spi.write(05);
ThomasSonderDesign 0:c2e41d203cdb 64 int byte1 = my_spi.write(dummy);
ThomasSonderDesign 0:c2e41d203cdb 65 while(byte1>0) {
ThomasSonderDesign 0:c2e41d203cdb 66 byte1 = my_spi.write(dummy);
ThomasSonderDesign 0:c2e41d203cdb 67 }
ThomasSonderDesign 0:c2e41d203cdb 68 _cs_mem=1;
ThomasSonderDesign 0:c2e41d203cdb 69 }
ThomasSonderDesign 0:c2e41d203cdb 70
ThomasSonderDesign 0:c2e41d203cdb 71
ThomasSonderDesign 0:c2e41d203cdb 72 /**
ThomasSonderDesign 0:c2e41d203cdb 73 * Block Erase, erases everything in a 4KB block that includes Address
ThomasSonderDesign 0:c2e41d203cdb 74 */
ThomasSonderDesign 2:5c70c0334ed0 75 int Memory::blockErase(SPI my_spi, int Address)
ThomasSonderDesign 0:c2e41d203cdb 76 {
ThomasSonderDesign 0:c2e41d203cdb 77 _cs_mem = 1;
ThomasSonderDesign 0:c2e41d203cdb 78 _cs_mem=0;
ThomasSonderDesign 0:c2e41d203cdb 79 my_spi.write(0x06); //Send Write enable command
ThomasSonderDesign 0:c2e41d203cdb 80 _cs_mem= 1;
ThomasSonderDesign 0:c2e41d203cdb 81 wait_us(5);
ThomasSonderDesign 0:c2e41d203cdb 82 _cs_mem=0;
ThomasSonderDesign 0:c2e41d203cdb 83 my_spi.write(0xD8); //Send sector erase comand
ThomasSonderDesign 0:c2e41d203cdb 84 my_spi.write((Address>>16)&0xff); //Send high address byte
ThomasSonderDesign 0:c2e41d203cdb 85 my_spi.write((Address>>8)&0xff); //Send mid address byte
ThomasSonderDesign 0:c2e41d203cdb 86 my_spi.write((Address)&0xff); //Send low address byte
ThomasSonderDesign 0:c2e41d203cdb 87 _cs_mem=1;
ThomasSonderDesign 0:c2e41d203cdb 88 wait_us(5);
ThomasSonderDesign 0:c2e41d203cdb 89
ThomasSonderDesign 0:c2e41d203cdb 90 //Pol the status register untill the Write In Progress bit is no longer set
ThomasSonderDesign 0:c2e41d203cdb 91 _cs_mem=0;
ThomasSonderDesign 0:c2e41d203cdb 92 my_spi.write(05);
ThomasSonderDesign 0:c2e41d203cdb 93 int byte1 = my_spi.write(dummy);
ThomasSonderDesign 0:c2e41d203cdb 94 while(byte1>0) {
ThomasSonderDesign 0:c2e41d203cdb 95 byte1 = my_spi.write(dummy);
ThomasSonderDesign 0:c2e41d203cdb 96 }
ThomasSonderDesign 0:c2e41d203cdb 97 _cs_mem=1;
ThomasSonderDesign 2:5c70c0334ed0 98 int returnVal = (Address/0x10000);
ThomasSonderDesign 2:5c70c0334ed0 99 returnVal*=0x10000;
ThomasSonderDesign 2:5c70c0334ed0 100 returnVal+=0x10000;
ThomasSonderDesign 2:5c70c0334ed0 101 return returnVal;
ThomasSonderDesign 0:c2e41d203cdb 102 }
ThomasSonderDesign 0:c2e41d203cdb 103
ThomasSonderDesign 0:c2e41d203cdb 104 /**
ThomasSonderDesign 0:c2e41d203cdb 105 * Writes a char array containg 'length' elements to memory sarting at address.
ThomasSonderDesign 0:c2e41d203cdb 106 *If length is greater than BufferSize (3840 bytes) the function will terminate
ThomasSonderDesign 0:c2e41d203cdb 107 *and return the start address.
ThomasSonderDesign 0:c2e41d203cdb 108 */
ThomasSonderDesign 0:c2e41d203cdb 109 int Memory::writeData(SPI my_spi, char buffer[], int address, int length)
ThomasSonderDesign 0:c2e41d203cdb 110 {
ThomasSonderDesign 9:2587f246bf48 111
ThomasSonderDesign 9:2587f246bf48 112 //printf("\n C0 ");
ThomasSonderDesign 0:c2e41d203cdb 113 if(length>bufferSize) {
ThomasSonderDesign 0:c2e41d203cdb 114 printf("\nLength %i exceeds Max Length\n",length);
ThomasSonderDesign 0:c2e41d203cdb 115 return address;
ThomasSonderDesign 0:c2e41d203cdb 116 }
ThomasSonderDesign 10:96b5e7dcc91f 117 <<<<<<< local
ThomasSonderDesign 9:2587f246bf48 118 //printf("\n C1 ");
ThomasSonderDesign 10:96b5e7dcc91f 119 =======
ThomasSonderDesign 4:bb4fd1147054 120
ThomasSonderDesign 4:bb4fd1147054 121 //Enable the memory for wiring. This segment is only required if not writing to the start of a page.
ThomasSonderDesign 4:bb4fd1147054 122 if(address%256!=0){
ThomasSonderDesign 4:bb4fd1147054 123 _cs_mem=1;
ThomasSonderDesign 4:bb4fd1147054 124 _cs_mem=0; //Selet memory
ThomasSonderDesign 4:bb4fd1147054 125 my_spi.write(06); //Set Write Enable flag in the status reg
ThomasSonderDesign 4:bb4fd1147054 126 _cs_mem=1; //Deslect memory
ThomasSonderDesign 4:bb4fd1147054 127 wait_us(10);
ThomasSonderDesign 4:bb4fd1147054 128 _cs_mem=0; //Selet memory
ThomasSonderDesign 4:bb4fd1147054 129 my_spi.write(0x02); //Send write comand
ThomasSonderDesign 4:bb4fd1147054 130 my_spi.write(address>>16); //Send high address byte
ThomasSonderDesign 4:bb4fd1147054 131 my_spi.write(address>>8); //Send middle adress byte
ThomasSonderDesign 4:bb4fd1147054 132 my_spi.write(address); //Send low address
ThomasSonderDesign 4:bb4fd1147054 133 }
ThomasSonderDesign 4:bb4fd1147054 134
ThomasSonderDesign 10:96b5e7dcc91f 135 >>>>>>> other
ThomasSonderDesign 0:c2e41d203cdb 136 for(int i =0; i<length; i++) {
ThomasSonderDesign 4:bb4fd1147054 137 //Handle start and end of pages. aAt the page boundry the memory must be deselected and and re-enabled for writng to the next page.
ThomasSonderDesign 4:bb4fd1147054 138 if(address%256==0) {
ThomasSonderDesign 4:bb4fd1147054 139 _cs_mem=1;
ThomasSonderDesign 0:c2e41d203cdb 140 wait_us(10);
ThomasSonderDesign 4:bb4fd1147054 141 //wait for the WIP bit to go low
ThomasSonderDesign 4:bb4fd1147054 142 _cs_mem=0; //Selet memory
ThomasSonderDesign 4:bb4fd1147054 143 my_spi.write(0x05); //Send read status register command
ThomasSonderDesign 4:bb4fd1147054 144 int byte1 = my_spi.write(dummy);//Send dummy byte to read status reg
ThomasSonderDesign 4:bb4fd1147054 145 while ((byte1&1)>0) {
ThomasSonderDesign 4:bb4fd1147054 146 wait_us(10);
ThomasSonderDesign 4:bb4fd1147054 147 my_spi.write(0x05); //Send read status register command
ThomasSonderDesign 4:bb4fd1147054 148 byte1 = my_spi.write(dummy);//Send dummy byte to read status reg
ThomasSonderDesign 4:bb4fd1147054 149 }
ThomasSonderDesign 4:bb4fd1147054 150 _cs_mem=1;
ThomasSonderDesign 4:bb4fd1147054 151 _cs_mem=0; //Selet memory
ThomasSonderDesign 4:bb4fd1147054 152 my_spi.write(06); //Set Write Enable flag in the status reg
ThomasSonderDesign 4:bb4fd1147054 153 _cs_mem=1; //Deslect memory
ThomasSonderDesign 4:bb4fd1147054 154 wait_us(10);
ThomasSonderDesign 4:bb4fd1147054 155 _cs_mem=0; //Selet memory
ThomasSonderDesign 4:bb4fd1147054 156 my_spi.write(0x02); //Send write comand
ThomasSonderDesign 4:bb4fd1147054 157 my_spi.write(address>>16); //Send high address byte
ThomasSonderDesign 4:bb4fd1147054 158 my_spi.write(address>>8); //Send middle adress byte
ThomasSonderDesign 4:bb4fd1147054 159 my_spi.write(address); //Send low address
ThomasSonderDesign 0:c2e41d203cdb 160 }
ThomasSonderDesign 4:bb4fd1147054 161
ThomasSonderDesign 4:bb4fd1147054 162 my_spi.write(buffer[i]); //Write the value of the buffer to memory
ThomasSonderDesign 0:c2e41d203cdb 163 wait_us(5);
AdminSonderDesign 3:339efdc5134f 164 address=address+1; //Increment address
ThomasSonderDesign 0:c2e41d203cdb 165 }
ThomasSonderDesign 0:c2e41d203cdb 166 _cs_mem=1;
ThomasSonderDesign 0:c2e41d203cdb 167 return address;
ThomasSonderDesign 0:c2e41d203cdb 168 }
ThomasSonderDesign 0:c2e41d203cdb 169
AdminSonderDesign 3:339efdc5134f 170 /**
AdminSonderDesign 3:339efdc5134f 171 * Arrange the data to the NEW address for icon refreshing
AdminSonderDesign 3:339efdc5134f 172 */
AdminSonderDesign 3:339efdc5134f 173 int Memory::arrangeData(SPI my_spi, int Address, int addressNew, int length)
AdminSonderDesign 3:339efdc5134f 174 {
AdminSonderDesign 3:339efdc5134f 175 char value[length];
AdminSonderDesign 3:339efdc5134f 176 _cs_mem = 1; //Ensure cs is deselected
AdminSonderDesign 3:339efdc5134f 177 wait_us(10);
AdminSonderDesign 3:339efdc5134f 178 _cs_mem = 0; //memory is selected
AdminSonderDesign 3:339efdc5134f 179 my_spi.write(0x03); //Send read command
AdminSonderDesign 3:339efdc5134f 180 my_spi.write(Address>>16); //Send high address byte
AdminSonderDesign 3:339efdc5134f 181 my_spi.write(Address>>8); //Send mid address byte
AdminSonderDesign 3:339efdc5134f 182 my_spi.write(Address); //Send low address byte
AdminSonderDesign 3:339efdc5134f 183
AdminSonderDesign 3:339efdc5134f 184
AdminSonderDesign 3:339efdc5134f 185 for(int i =0; i <length; i++) {
AdminSonderDesign 3:339efdc5134f 186 value[i]= my_spi.write(dummy);//Send dummy byte to read out value ate Address
AdminSonderDesign 3:339efdc5134f 187 Address++;
AdminSonderDesign 3:339efdc5134f 188 }
AdminSonderDesign 3:339efdc5134f 189 _cs_mem = 1;
AdminSonderDesign 3:339efdc5134f 190
AdminSonderDesign 5:2fa79108a29b 191 wait_us(10);//wait for command transfer
AdminSonderDesign 5:2fa79108a29b 192
AdminSonderDesign 5:2fa79108a29b 193 //Enable the memory for wiring. This segment is only required if not writing to the start of a page.
AdminSonderDesign 5:2fa79108a29b 194 if(addressNew%256!=0){
AdminSonderDesign 5:2fa79108a29b 195 _cs_mem=1;
AdminSonderDesign 5:2fa79108a29b 196 _cs_mem=0; //Selet memory
AdminSonderDesign 5:2fa79108a29b 197 my_spi.write(06); //Set Write Enable flag in the status reg
AdminSonderDesign 5:2fa79108a29b 198 _cs_mem=1; //Deslect memory
AdminSonderDesign 5:2fa79108a29b 199 wait_us(10);
AdminSonderDesign 5:2fa79108a29b 200 _cs_mem=0; //Selet memory
AdminSonderDesign 5:2fa79108a29b 201 my_spi.write(0x02); //Send write comand
AdminSonderDesign 5:2fa79108a29b 202 my_spi.write(addressNew>>16); //Send high address byte
AdminSonderDesign 5:2fa79108a29b 203 my_spi.write(addressNew>>8); //Send middle adress byte
AdminSonderDesign 5:2fa79108a29b 204 my_spi.write(addressNew); //Send low address
AdminSonderDesign 5:2fa79108a29b 205 }
AdminSonderDesign 3:339efdc5134f 206
AdminSonderDesign 3:339efdc5134f 207 for(int i =0; i<length; i++) {
AdminSonderDesign 3:339efdc5134f 208 if(addressNew%256==0) { //Handle start and end of pages
AdminSonderDesign 3:339efdc5134f 209 _cs_mem=1;
AdminSonderDesign 3:339efdc5134f 210 wait_us(10);
ThomasSonderDesign 9:2587f246bf48 211 //printf("\n C2 ");
ThomasSonderDesign 9:2587f246bf48 212
AdminSonderDesign 3:339efdc5134f 213 //wait for the WIP bit to go low
AdminSonderDesign 3:339efdc5134f 214 _cs_mem=0; //Selet memory
AdminSonderDesign 3:339efdc5134f 215 my_spi.write(0x05); //Send read status register command
AdminSonderDesign 3:339efdc5134f 216 int byte1 = my_spi.write(dummy);//Send dummy byte to read status reg
ThomasSonderDesign 9:2587f246bf48 217 //printf("\n C3 ");
AdminSonderDesign 3:339efdc5134f 218 while ((byte1&1)>0) {
AdminSonderDesign 3:339efdc5134f 219 wait_us(10);
ThomasSonderDesign 9:2587f246bf48 220 printf("\n C4 ");
AdminSonderDesign 3:339efdc5134f 221 my_spi.write(0x05); //Send read status register command
AdminSonderDesign 3:339efdc5134f 222 byte1 = my_spi.write(dummy);//Send dummy byte to read status reg
AdminSonderDesign 3:339efdc5134f 223 }
AdminSonderDesign 3:339efdc5134f 224 _cs_mem=1;
AdminSonderDesign 3:339efdc5134f 225
AdminSonderDesign 3:339efdc5134f 226 _cs_mem=0; //Selet memory
AdminSonderDesign 3:339efdc5134f 227 my_spi.write(06); //Set Write Enable flag in the status reg
AdminSonderDesign 3:339efdc5134f 228 _cs_mem=1;
AdminSonderDesign 3:339efdc5134f 229 wait_us(10);
ThomasSonderDesign 9:2587f246bf48 230
ThomasSonderDesign 9:2587f246bf48 231 //printf("\n C5 ");
AdminSonderDesign 3:339efdc5134f 232 _cs_mem=0; //Selet memory
AdminSonderDesign 3:339efdc5134f 233 my_spi.write(0x02); //Send read comand
AdminSonderDesign 3:339efdc5134f 234 my_spi.write(addressNew>>16); //Send high address byte
AdminSonderDesign 3:339efdc5134f 235 my_spi.write(addressNew>>8); //Send middle adress byte
AdminSonderDesign 3:339efdc5134f 236 my_spi.write(addressNew); //Send low address
AdminSonderDesign 3:339efdc5134f 237
AdminSonderDesign 3:339efdc5134f 238 }
ThomasSonderDesign 10:96b5e7dcc91f 239 <<<<<<< local
ThomasSonderDesign 9:2587f246bf48 240 //printf("\n C6 ");
ThomasSonderDesign 0:c2e41d203cdb 241 my_spi.write(buffer[i]); //Write the calue of the buffer to memory
ThomasSonderDesign 6:c11cb6709b8b 242 //printf("%i%i%i%i%i%i%i%i",sixtyBytes[i]>>7&&1,buffer[i]>>6&&1,buffer[i]>>5&&1,buffer[i]>>4&&1,buffer[i]>>3&&1,buffer[i]>>2&&1,buffer[i]>>1&&1,buffer[i]&&1);
ThomasSonderDesign 6:c11cb6709b8b 243
ThomasSonderDesign 10:96b5e7dcc91f 244 =======
AdminSonderDesign 3:339efdc5134f 245 my_spi.write(value[i]); //Write the calue of the buffer to memory
ThomasSonderDesign 10:96b5e7dcc91f 246 >>>>>>> other
AdminSonderDesign 3:339efdc5134f 247 wait_us(5);
AdminSonderDesign 3:339efdc5134f 248 addressNew=addressNew+1; //Increment address
AdminSonderDesign 3:339efdc5134f 249 }
AdminSonderDesign 3:339efdc5134f 250 _cs_mem=1;
ThomasSonderDesign 10:96b5e7dcc91f 251 <<<<<<< local
ThomasSonderDesign 0:c2e41d203cdb 252 return address;
ThomasSonderDesign 0:c2e41d203cdb 253 }
ThomasSonderDesign 0:c2e41d203cdb 254
ThomasSonderDesign 8:6af25b9563df 255
ThomasSonderDesign 10:96b5e7dcc91f 256 =======
AdminSonderDesign 3:339efdc5134f 257 wait_ms(10); //Need to wait register response, otherwise will cause the output full of dummies
AdminSonderDesign 3:339efdc5134f 258 return addressNew;
ThomasSonderDesign 10:96b5e7dcc91f 259 }>>>>>>> other