josh
/
Teacup_Firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Teacup_Firmware/sd.c

279 lines
8.2 KiB
C
Raw Blame History

/*
ganked from http://www.arduino.cc/playground/Code/SDCARD
*/
/*
Basic instructions for recording data in an SD Card in native mode
The SD card (3.3 V) must be properly interfaced to Arduino (5 V)
The typical procedure is:
Initialize SPI
Initialize SD Card
START
-Blank vector of data (vBlock)
-Record data in vector of data
-Copy data from vector to CSD card
GOTO START
At your convenience:
-Copy data from CSD card to vector of data
-Read data from vector
Starting from there, you will have to build your own file system...
Useful links
http://elm-chan.org/docs/mmc/mmc_e.html
http://www.retroleum.co.uk/mmc_cards.html
http://www.maxim-ic.com/appnotes.cfm/an_pk/3969
No warranty, no claims, just fun
Didier Longueville invenit et fecit February 2010
*/
#ifdef SD
// Ports
int PIN_CS = PINB2; // chip select
int PIN_MOSI = PINB3; // master out slave in
int PIN_MISO = PINB4; // master in slave out
int PIN_CLOCK = PINB5; // clock
/********************** SPI SECTION BELOW **********************/
// SPI Variables
byte clr; // dummy variable used to clear some of the SPI registers
byte spi_err; // SPI timeout flag, must be cleared manually
// send an SPI command, includes time out management
// returns spi_err: "0" is "no error"
byte spi_cmd(volatile char data) {
spi_err = 0; // reset spi error
SPDR = data; // start the transmission by loading the output byte into the spi data register
int i = 0;
while (!(SPSR & (1<<SPIF))) {
i++;
if (i >= 0xFF) {
spi_err = 1;
return(0x00);
}
}
// returned value
return(SPDR);
}
// initialize SPI port
void spi_initialize(void) {
SPCR = (1<<SPE) | (1<<MSTR); // spi enabled, master mode
clr = SPSR; // dummy read registers to clear previous results
clr = SPDR;
}
/********************** SD CARD SECTION BELOW **********************/
// SD Card variables
#define blockSize 512 // block size (default 512 bytes)
byte vBlock[blockSize]; // set vector containing data that will be recorded on SD Card
byte vBuffer[16];
#define GO_IDLE_STATE 0x00 // resets the SD card
#define SEND_CSD 0x09 // sends card-specific data
#define SEND_CID 0x0A // sends card identification
#define READ_SINGLE_BLOCK 0x11 // reads a block at byte address
#define WRITE_BLOCK 0x18 // writes a block at byte address
#define SEND_OP_COND 0x29 // starts card initialization
#define APP_CMD 0x37 // prefix for application command
// Send a SD command, num is the actual index, NOT OR'ed with 0x40.
// arg is all four bytes of the argument
byte sdc_cmd(byte commandIndex, long arg) {
PORTB &= ~(1<<PIN_CS); // assert chip select for the card
spi_cmd(0xFF); // dummy byte
commandIndex |= 0x40; // command token OR'ed with 0x40
spi_cmd(commandIndex); // send command
for (int i=3; i>=0; i--) {
spi_cmd(arg>>(i*8)); // send argument in little endian form (MSB first)
}
spi_cmd(0x95); // checksum valid for GO_IDLE_STATE, not needed thereafter, so we can hardcode this value
spi_cmd(0xFF); // dummy byte gives card time to process
byte res = spi_cmd(0xFF);
return (res); // query return value from card
}
// initialize SD card
// retuns 1 if successful
byte sdc_initialize(void) {
// set slow clock: 1/128 base frequency (125Khz in this case)
SPCR |= (1<<SPR1) | (1<<SPR0); // set slow clock: 1/128 base frequency (125Khz in this case)
SPSR &= ~(1<<SPI2X); // No doubled clock frequency
// wake up SD card
PORTB |= (1<<PIN_CS); // deasserts card for warmup
PORTB |= (1<<PIN_MOSI); // set MOSI high
for(byte i=0; i<10; i++) {
spi_cmd(0xFF); // send 10 times 8 pulses for a warmup (74 minimum)
}
// set idle mode
byte retries=0;
PORTB &= ~(1<<PIN_CS); // assert chip select for the card
while(sdc_cmd(GO_IDLE_STATE, 0) != 0x01) { // while SD card is not in iddle state
retries++;
if (retries >= 0xFF) {
return(NULL); // timed out!
}
delay(5);
}
// at this stage, the card is in idle mode and ready for start up
retries = 0;
sdc_cmd(APP_CMD, 0); // startup sequence for SD cards 55/41
while (sdc_cmd(SEND_OP_COND, 0) != 0x00) {
retries++;
if (retries >= 0xFF) {
return(NULL); // timed out!
}
sdc_cmd(APP_CMD, 0);
}
// set fast clock, 1/4 CPU clock frequency (4Mhz in this case)
SPCR &= ~((1<<SPR1) | (1<<SPR0)); // Clock Frequency: f_OSC / 4
SPSR |= (1<<SPI2X); // Doubled Clock Frequency: f_OSC / 2
return (0x01); // returned value (success)
}
// clear block content
void sdc_clearVector(void) {
for (int i=0; i<blockSize; i++) {
vBlock[i] = 0;
}
}
// get nbr of blocks on SD memory card from
long sdc_totalNbrBlocks(void) {
sdc_readRegister(SEND_CSD);
// compute size
long C_Size = ((vBuffer[0x08] & 0xC0) >> 6) | ((vBuffer[0x07] & 0xFF) << 2) | ((vBuffer[0x06] & 0x03) << 10);
long C_Mult = ((vBuffer[0x08] & 0x80) >> 7) | ((vBuffer[0x08] & 0x03) << 2);
return ((C_Size+1) << (C_Mult+2));
}
// read SD card register content and store it in vBuffer
void sdc_readRegister(byte sentCommand) {
byte retries=0x00;
byte res=sdc_cmd(sentCommand, 0);
while(res != 0x00) {
delay(1);
retries++;
if (retries >= 0xFF) return; // timed out!
res=spi_cmd(0xFF); // retry
}
// wait for data token
while (spi_cmd(0xFF) != 0xFE);
// read data
for (int i=0; i<16; i++) {
vBuffer[i] = spi_cmd(0xFF);
}
// read CRC (lost results in blue sky)
spi_cmd(0xFF); // LSB
spi_cmd(0xFF); // MSB
}
// write block on SD card
// addr is the address in bytes (multiples of block size)
void sdc_writeBlock(long blockIndex) {
byte retries=0;
while(sdc_cmd(WRITE_BLOCK, blockIndex * blockSize) != 0x00) {
delay(1);
retries++;
if (retries >= 0xFF) return; // timed out!
}
spi_cmd(0xFF); // dummy byte (at least one)
// send data packet (includes data token, data block and CRC)
// data token
spi_cmd(0xFE);
// copy block data
for (int i=0; i<blockSize; i++) {
spi_cmd(vBlock[i]);
}
// write CRC (lost results in blue sky)
spi_cmd(0xFF); // LSB
spi_cmd(0xFF); // MSB
// wait until write is finished
while (spi_cmd(0xFF) != 0xFF) delay(1); // kind of NOP
}
// read block on SD card and copy data in block vector
// retuns 1 if successful
void sdc_readBlock(long blockIndex) {
byte retries = 0x00;
byte res = sdc_cmd(READ_SINGLE_BLOCK, (blockIndex * blockSize));
while(res != 0x00) {
delay(1);
retries++;
if (retries >= 0xFF) return; // timed out!
res=spi_cmd(0xFF); // retry
}
// read data packet (includes data token, data block and CRC)
// read data token
while (spi_cmd(0xFF) != 0xFE);
// read data block
for (int i=0; i<blockSize; i++) {
vBlock[i] = spi_cmd(0xFF); // read data
}
// read CRC (lost results in blue sky)
spi_cmd(0xFF); // LSB
spi_cmd(0xFF); // MSB
}
// // print vector of data
// void sdc_printVectorContent(void) {
// for (int i=0; i<blockSize; i++) {
// Serial.print("0x");
// if (vBlock[i] <= 0x0F) Serial.print("0");
// Serial.print(vBlock[i], HEX);
// Serial.print(" ");
// // append crlf to each line of 16 bytes
// if (((i+1) % 16) == 0) Serial.println();
// }
// Serial.println();
// }
//
// /********************** MAIN ROUTINES SECTION BELOW **********************/
//
// void setup() {
// // Set ports
// // Data in
// DDRB &= ~(1<<PIN_MISO);
// // Data out
// DDRB |= (1<<PIN_CLOCK);
// DDRB |= (1<<PIN_CS);
// DDRB |= (1<<PIN_MOSI);
// // Initialize serial communication
// Serial.begin(115200);
// // Initialize SPI and SDC
// spi_err=0; // reset SPI error
// spi_initialize(); // initialize SPI port
// sdc_initialize(); // Initialize SD Card
// Serial.print(sdc_totalNbrBlocks(), DEC);
// Serial.println(" blocks");
// }
//
// void loop() {
// // This is just an example
// Serial.println("Writing blocks...");
// for (int b=0; b<255; b++) {
// Serial.print("Writing block ");
// Serial.println(b, HEX);
// for (int i=0; i<blockSize; i++){
// vBlock[i] = b; // write incremental data
// }
// sdc_writeBlock(b); // copy vector of data on SD card
// }
// Serial.println("Reading blocks...");
// for (int b=0; b<255; b++) {
// Serial.print("Reading block ");
// Serial.println(b, HEX);
// sdc_readBlock(b); // copy SD card block of data in vector of data
// sdc_printVectorContent(); // print vector of data content
// }
// }
#endif /* SD */
Reference in New Issue View Git Blame Copy Permalink