SD SPI Bytes lesen

[Flo W. (Firma: privat) (florian1x)]

Hallo,
ich habe ein Problem Bytes zu lesen
hier mal mein Code

#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

------------------------------------------------------------

die c file zur h

#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

-------------------------------------------------

und die main:

/* 
   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;
}

ich hoffe das reicht an quelltext.
ich versuche derzeit die ersten 32 byte der karte zu lesen. bekomme aber 
nur nullen raus.

Hardware: Myethernet 2.03, Uart über MySmartUsb, Kingston 4GB SDHC karte

Also initialisieren klappt soweit ... nur habe ich hinterher nur nullen 
drin stehen. Weiss einer woran das liegt?

mfG Flo

[Sascha W. (sascha-w)]

Hallo,

welche spi.h verwendest du?

'spi_send_byte' gibt glaube ich keinen Wert zurück, wie wärs mit 
'spi_Transfer_Byte'

Sascha

[Flo W. (Firma: privat) (florian1x)]

oh das hätte ich vlt noch dazu packen sollen, ich verwende meine eigene 
SPI methoden. Funktionieren auch soweit. Ich gebe halt das Byte zurück 
welches mit der clock ankommt in der ich auch sende.

meine ausgabe in GTKTerm sieht wie folgt aus:

UART Initialized

SPI Initialized
USART as SPI Initialized

Welcome to WeSa System v0.0.1a

Starting SD initialsation.
Go IDLE mode ...
Sending CMD: 0, ARGS: 0x0, 0x0, 0x0, 0x0, CRC: 0x95, recv.: 0x1.

Card is in IDLE mode. Begin to verify version

Sending CMD: 8, ARGS: 0x0, 0x0, 0x1, 0xaa, CRC: 0x87, recv.: 0x1.
ocr: 0x0 0x0 0x0 0x0

Sending CMD: 58, ARGS: 0x0, 0x0, 0x0, 0x0, CRC: 0x1, recv.: 0x1.
ocr: 0x0 0x0 0x0 0x0

Sending CMD: 55, ARGS: 0x40, 0x0, 0x0, 0x0, CRC: 0xff, recv.: 0x1.
Sending CMD: 41, ARGS: 0x40, 0x0, 0x0, 0x0, CRC: 0xff, recv.: 0x1.

Sending CMD: 55, ARGS: 0x40, 0x0, 0x0, 0x0, CRC: 0xff, recv.: 0x1.

Sending CMD: 41, ARGS: 0x40, 0x0, 0x0, 0x0, CRC: 0xff, recv.: 0x0.
0Sending CMD: 17, ARGS: 0x0, 0x0, 0x0, 0x0, CRC: 0xff, recv.: 0x0.
read 32 Bytes after address 0x10cc

offset  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F

0x0  2c  e3  f5  aa  ff  f  69  c2  a2  cf  ad  98  fe  7d  f8

0x1  cf  5e  3d  f1  60  d4  eb  e9  67  99  8  d8  f7  c5  f6


edit ... ok ich hab seid gestern ncihts mehr gemacht und auf einma 
spuckt der was aus.

[Flo W. (Firma: privat) (florian1x)]

Ok nachdem es nun einige male Werte ausgegeben hat, jedoch andere, wie 
die die bei mir in WinHex angezeigt werden. Kommt nun wieder nix

UART Initialized
SPI Initialized

USART as SPI Initialized

Welcome to WeSa System v0.0.1a
Starting SD initialsation.
Go IDLE mode ...
Sending CMD: 0, ARGS: 0x0, 0x0, 0x0, 0x0, CRC: 0x95, recv.: 0x1f.
Sending CMD: 0, ARGS: 0x0, 0x0, 0x0, 0x0, CRC: 0x95, recv.: 0x5.

Sending CMD: 0, ARGS: 0x0, 0x0, 0x0, 0x0, CRC: 0x95, recv.: 0x1.

Card is in IDLE mode. Begin to verify version

Sending CMD: 8, ARGS: 0x0, 0x0, 0x1, 0xaa, CRC: 0x87, recv.: 0x1.
ocr: 0x0 0x0 0x0 0x0

Sending CMD: 58, ARGS: 0x0, 0x0, 0x0, 0x0, CRC: 0x1, recv.: 0x1.

ocr: 0x0 0x0 0x0 0x0
Sending CMD: 55, ARGS: 0x40, 0x0, 0x0, 0x0, CRC: 0xff, recv.: 0x1.

Sending CMD: 41, ARGS: 0x40, 0x0, 0x0, 0x0, CRC: 0xff, recv.: 0x1.
Sending CMD: 55, ARGS: 0x40, 0x0, 0x0, 0x0, CRC: 0xff, recv.: 0x1.
Sending CMD: 41, ARGS: 0x40, 0x0, 0x0, 0x0, CRC: 0xff, recv.: 0x0.

0Sending CMD: 17, ARGS: 0x0, 0x0, 0x0, 0x0, CRC: 0xff, recv.: 0x0.
read 32 Bytes
offset  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
0x0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
0x1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0


anfangs will cmd0 aber auch nicht so recht vlt liegs auch daran.

[Flo W. (Firma: privat) (florian1x)]

ahhh fail, hab meinen fehler :), hatte die Abfrage zum timeout falsch, 
weshalb der immer direkt aus der Methode raus is. Aber der liest dann 
ziehmlich lange.