SD SPI Bytes lesen

#ifndef __SDCARD__

#define __SDCARD__

/* Includes */

#include "../uart/uart.h"

#include "../spi/spi.h"

#include <util/delay.h>

#ifndef DEBUG

  #define DEBUG //Should be only defined if Debug messages are needed

#endif

/*spi methods*/

#define spi_send_byte(x)   spi2_transmit(x)  //Method to transmit a Byte via SPI

#define spi_speed_low()   {SPSR|=(1<<SPI2X);SPCR|=(1<<SPR1);SPCR&=~(1<<SPR0);} //sets SPI Clockrate between 100kHz and 400kHz

#define spi_speed_high()    {SPSR&=~(1<<SPI2X);SPCR&=~(1<<SPR1);SPCR&=~(1<<SPR0);} //sets SPI Clockrate to maximum

/*defines for Hardware Initialisation*/

#define SD_CS_PIN        PC6    //Chipselect for SD Card

#define SD_CS_PORT       PORTC  //Port of SD_CS

#define SD_CS_DDR        DDRC   //Data Direction Register for SD_CS

#define sd_cs_low()       SD_CS_PORT &= ~(1 << SD_CS_PIN) // SD_CS -> '1'

#define sd_cs_high()      SD_CS_PORT |= (1 << SD_CS_PIN)  // SD_CS -> '0'

/*some other defines:*/

#define SD_INIT_TIMEOUT   30 //value between 0 and 254 

#define SD_HCS            1   // 0 = SDHC disable, 1 = SDHC enable

/*SD Card Versions*/

#define SD_UNSUPPORTED    0

#define SD_SPEC1      1 

#define SD_SPEC2       2 

#define SD_SDHC       3 

/* 

Command defines:

Command Format (6 Bytes): 

start bit ('0') + transmission bit('1') + command index (6bit) + arguments (4 byte) + CRC7 (7bit)+ end bit('1')

*/

/*SPI specifik commands (start bit+transmission bit+command index):*/   

#define SD_GO_IDLE_STATE        0x00 //CMD0

#define SD_SEND_OP_COND        0x01 //CMD1

#define SD_SWITCH_FUNC        0x06 //CMD6

#define SD_SEND_IF_COND        0x08 //CMD8

#define SD_SEND_CSD         0x09 //CMD9

#define SD_SEND CID         0x0A //CMD10

#define SD_STOP_TRANSMISSION     0x0C //CMD12

#define SD_SEND_STATUS         0x0D //CMD13

#define SD_SET_BLOCKLEN       0x10 //CMD16

#define SD_READ_SINGLE_BLOCK     0x11 //CMD17

#define SD_READ_MULTIPLE_BLOCK     0x12 //CMD18

#define SD_WRITE_BLOCK         0x18 //CMD24

#define SD_WRITE_MULTIPLE_BLOCK    0x19 //CMD25

#define SD_PROGRAM_CSD         0x1B //CMD27

#define SD_SET_WRITE_PROT        0x1C //CMD28

#define SD_CLR_WRITE_PROT       0x1D //CMD29

#define SD_SEND_WRITE_PROT       0x1E //CMD30

#define SD_ERASE_WR_BLK_START_ADDR   0x20 //CMD32

#define SD_ERASE_WR_BLK_END_ADDR   0x21 //CMD33

#define SD_ERASE          0x26 //CMD38

#define SD_LOCK_UNLOCK         0x2A //CMD42

#define SD_APP_CMD           0x37 //CMD55

#define SD_GEN_CMD           0x38 //CMD56

#define SD_READ_OCR         0x3A //CMD58

#define SD_CRC_ON_OFF         0x3B //CMD59

#define SD_SD_SEND_OP_COND      0x29 //ACMD41s

#define SD_CMD_MASK         0x40; //star bit and transmission bit

/* command responses */

/* Format R1 (1 byte)*/

#define SD_R1_IDLE_STATE       1

#define SD_R1_ERASE_RESET        2

#define SD_R1_ILLEGAL_COMMAND     3

#define SD_R1_COM_CRC_ERR       4

#define SD_R1_ERASE_SEQ_ERR     5

#define SD_R1_ADDRESS_ERR      6

#define SD_R1_PARAMETER_ERR     7

/* Format R3 (5 bytes)*/

#define SD_R3_IDLE_STATE       33

#define SD_R3_ERASE_RESET       34

#define SD_R3_ILLEGAL_COMMAND     35

#define SD_R3_COM_CRC_ERR       36

#define SD_R3_ERASE_SEQ_ERR     37

#define SD_R3_ADDRESS_ERR       38

#define SD_R3_PARAM_ERR       39

/*Methods*/

//initialize SD Card 

uint8_t sd_init(void); 

//Sends a 6 Byte long SD/MMC-Cardcommand via SPI

uint8_t sd_send_cmd(uint8_t, uint32_t, uint8_t); 

//Reads the next 4 Bytes after a command with R3 response

uint32_t sd_read_four_byte(void);

uint8_t sd_read_single_block(uint32_t, uint8_t *buffer, uint16_t);

void sd_print_buffer(uint8_t *buffer, uint16_t);

#endif

#include "sd.h"

volatile uint8_t sdversion = SD_UNSUPPORTED; 

// Method to initialize SDCard/MMC after Powerup

// name: sd_init()

// @param

// @return returns type of inserted Card

uint8_t sd_init(){

  spi_speed_low();

  /* Hardware initialisation */

  //Chips select for SDCard to output

    SD_CS_DDR |= ( 1 << SD_CS_PIN );  

    //CS to logic 1

    sd_cs_high();

  //wait 1 ms

  _delay_ms(1);

    //send 74+ dummy clocks

    for(uint8_t i = 0; i<8 ; i++)

        spi_send_byte(0xFF);

  /* Software initialisation - Go IDLE MODE */

  #ifdef DEBUG

    printf("Go IDLE mode ... \n");

  #endif

  uint8_t timeout = SD_INIT_TIMEOUT;

  uint8_t rec = 0;

    //CMD0 to get Card into IDLE State

    while(rec!=1){

    rec = sd_send_cmd( SD_GO_IDLE_STATE, 0, 0x95 );

    if(!timeout--){

      #ifdef DEBUG

        printf("Timeout reached. Stop card initialisation\n");

      #endif

      return sdversion = SD_UNSUPPORTED;

    }

  }

  /* Software initialisation - Card verification */

    #ifdef DEBUG

    printf("Card is in IDLE mode. Begin to verify version\n");

  #endif

  //send CMD08

  rec = sd_send_cmd(SD_SEND_IF_COND, 0x1AA, 0x87);

  if(rec==0x05){ //means SDC V1 or MMC

    sdversion = SD_SPEC1;

    #ifdef DEBUG

      printf("MMC/SDCV1\n");

    #endif

  }else{

    uint32_t ocr = sd_read_four_byte();

    if((ocr&0x0FFF)==0x01AA){ //means SDC V2

      #ifdef DEBUG

        sdversion = SD_SPEC2;

        printf("SDCV2\n");

      #endif

    }

    rec = sd_send_cmd(SD_READ_OCR, 0, 0);

    sd_read_four_byte();

  }

  /* Software initialisation - Initialisation with ACMD41 */

  timeout = SD_INIT_TIMEOUT;

  while(rec){

    sd_send_cmd(SD_APP_CMD, 1L<<30, 0xFF); //CMD55

    rec = sd_send_cmd(SD_SD_SEND_OP_COND, 1L<<30, 0xFF);//ACMD41

    if(!(--timeout)){

      #ifdef DEBUG

        printf("Timeout reached. Stop card initialisation with ACMD41\n");

      #endif

      break;

    }

  }

  /* Software initialisation - Initialisation with CMD1 */

  #ifdef DEBUG

    if(rec)

      printf("Try to initiate with CMD1\n");

  #endif

  timeout = SD_INIT_TIMEOUT;

  while(rec){

    rec = sd_send_cmd(SD_SEND_OP_COND, 0, 0xFF); //CMD1

    if(!(--timeout)){

      #ifdef DEBUG

        printf("Timeout reached. Stop card initialisation\n");

      #endif

      return sdversion = SD_UNSUPPORTED;

    }

  }

  spi_speed_high();

  return rec;

}  

// Sends a command to SDC via SPI and returns R1

// name: sd_hw_init

// @param cmd command for SD Card

// @param arg Arguments for the CMD

// @param crc checksum

// @return command response in R1 format

uint8_t sd_send_cmd(uint8_t cmd, uint32_t arg, uint8_t crc){

  /*build complete Command*/

  uint8_t buffer[6] ;                   //temporary Buffer for the CMD

  buffer[0] = cmd | SD_CMD_MASK;        //Set start and transmission bit + Command

  buffer[1] = (arg & 0xFF000000) >> 24; //Set parameter byte 1

  buffer[2] = (arg & 0x00FF0000) >> 16; //Set parameter byte 2 

  buffer[3] = (arg & 0x0000FF00) >> 8;  //Set parameter byte 3

  buffer[4] = (arg & 0x000000FF);       //Set parameter byte 4

  buffer[5] = crc | 0x01;               //CRC + Endbit '1'

  #ifdef DEBUG

    //Prints the Command

    printf("Sending CMD: ");

    printf("%d, ", buffer[0]&0b00111111);

    printf("ARGS: ");

    for(uint8_t i=1; i<5; i++)

      printf("0x%x, ", buffer[i]);

    printf("CRC: 0x%x, ", buffer[5]);

  #endif

  sd_cs_low();

  spi_send_byte(0xFF); 

  //Send complete Command via SPI

    for(uint8_t i=0; i<6; i++)

        spi_send_byte(buffer[i]); 

  //receive answer byte

  uint8_t ret = 0xFF;

  uint8_t timeout = 0;

  while(ret==0xFF){

    ret = spi_send_byte(0xFF);

    if(timeout++>100)

      break;

  }

  sd_cs_high();            //clear SPI  

  #ifdef DEBUG

    //Prints the Command

    printf("recv.: 0x%x", ret);

    printf(".\n");

  #endif  

    return ret;

}

uint32_t sd_read_four_byte(){

  uint32_t values = (uint32_t)spi_send_byte(0xFF)<<24;

  values |= (uint32_t)spi_send_byte(0xFF)<<16;

  values |= (uint32_t)spi_send_byte(0xFF)<<8;

  values |= spi_send_byte(0xFF);

  #ifdef DEBUG

    printf("ocr: 0x%x 0x%x 0x%x 0x%x\n", (uint8_t)((values>>24)&0xFF), (uint8_t)((values>>16)&0xFF), (uint8_t)((values>>8)&0xFF), (uint8_t)(values&0xFF));

  #endif  

  return values;

}

uint8_t sd_read_single_block(uint32_t startBlock, uint8_t *buffer, uint16_t buf_size){

  //Send command to MMC/SDC/SDHC Card

  uint8_t rec = sd_send_cmd(SD_READ_SINGLE_BLOCK, startBlock, 0xFF); //read a Block command

  //Check for errors 

  if(rec != 0x00) 

    return rec; 

  /*read Bytes and write to Buffer*/

  sd_cs_low();

  //Wait for startbyte 

  uint8_t timeout = 100;

  while(spi_send_byte(0xFF) != 0xfe){

    if(timeout--){

      sd_cs_high(); 

      return 0;

    } 

  }

  //Read Block

  while(buf_size--){ //read buf_size bytes

    *buffer++ = spi_send_byte(0xFF);

  }

  //receive CRC

  spi_send_byte(0xFF); //ignored

  spi_send_byte(0xFF); //ignored

  sd_cs_high(); 

  return 1;

}

#ifdef DEBUG

  void sd_print_buffer(uint8_t *buffer, uint16_t buf_size){

    printf("read %d Bytes after address %p\n", buf_size, &buffer);

    printf("offset\t1\t2\t3\t4\t5\t6\t7\t8\t9\tA\tB\tC\td\n");

    uint8_t offset = 0;

    for(uint8_t i = 0; i<buf_size; i=i+16){

      printf("0x%x", offset++);  //Offset

      printf("\t%x", *buffer++); //1

      printf("\t%x", *buffer++); //2

      printf("\t%x", *buffer++); //3

      printf("\t%x", *buffer++); //4

      printf("\t%x", *buffer++); //5

      printf("\t%x", *buffer++); //6

      printf("\t%x", *buffer++); //7

      printf("\t%x", *buffer++); //8

      printf("\t%x", *buffer++); //9

      printf("\t%x", *buffer++); //A

      printf("\t%x", *buffer++); //B

      printf("\t%x", *buffer++); //C

      printf("\t%x", *buffer++); //D

      printf("\t%x", *buffer++); //E

      printf("\t%x", *buffer++); //F

      printf("\n"); 

    }

  }

#endif

/* 

   Name: main.c

   Author: Mathäus Sander & Florian Weinhold

   Desc.: Main Programm for testing purposes

   License: LGPL

*/

#define F_CPU 20000000L

#define BAUD 9600L

#define DEBUG

#include <avr/io.h>

#include <util/delay.h>

#include "uart/uart.h"

#include "spi/spi.h"

#include "sd/sd.h"

#include "enc28j60/enc28j60.h"

int main(void) {

  USART_Init();

  SPI1_Init(); //ENC OR SDCard

    SPI2_Init(); //ENC OR SDCard

  printf("Welcome to WeSa System v0.0.1a\n");

    printf("Starting SD initialsation.\n");  

  printf("%x", sd_init());

  uint8_t buff[32];

  sd_read_single_block(0, buff, 32);

  sd_print_buffer(buff, 32);

  while(1) {  

    _delay_ms(500);

  }

  return 0;

}