SD Card mit RL-FlashFS über SPI ansprechen (STM32F2)

[Mathias S. (stucmath)]

Hallo zusammen

Ich möchte momentan mit einem STM32F207IG Board 
(http://www.keil.com/mcbstm32f200/) über das RL-FlashFS eine SD-Card 
ansprechen.
Mit dem Beispielprojekt funktioniert dies wunderbar.
Jedoch muss bei meinem Projekt die SD Card mittels SPI angesteuert 
werden.
Deshalb musste ich den SPI Treiber (SPI_STM32F1xx) auf den F2 anpassen.
Und genau dieses Vorhaben klappt momentan nicht.

Ich hoffe jemand von euch hat genau dies bereits realisiert und kann mir 
ein wenig Unterstützung liefern.

Danke im voraus.

Hier der angepasste SPI Treiber:

/*----------------------------------------------------------------------------
 *      RL-ARM - FlashFS
 *----------------------------------------------------------------------------
 *      Name:    SPI_STM32F107.c
 *      Purpose: Serial Peripheral Interface Driver for ST STM32F105/7
 *      Rev.:    V4.20
 *----------------------------------------------------------------------------
 *      This code is part of the RealView Run-Time Library.
 *      Copyright (c) 2004-2011 KEIL - An ARM Company. All rights reserved.
 *---------------------------------------------------------------------------*/
 
#include <stdio.h>
#include <File_Config.h>
#include "stm32f2xx.h"                /* STM32F2 Library Definitions */


/*----------------------------------------------------------------------------
  SPI Driver instance definition
   spi0_drv: First SPI driver
   spi1_drv: Second SPI driver
 *---------------------------------------------------------------------------*/

#define __DRV_ID  spi0_drv
#define __FPCLK    72000000  

/* SPI Driver Interface functions */
static BOOL Init (void);
static BOOL UnInit (void);
static U8   Send (U8 outb);
static BOOL SendBuf (U8 *buf, U32 sz);
static BOOL RecBuf (U8 *buf, U32 sz);
static BOOL BusSpeed (U32 kbaud);
static BOOL SetSS (U32 ss);
static U32  CheckMedia (void);        /* Optional function for SD card check */

/* SPI Device Driver Control Block */
SPI_DRV __DRV_ID = {
  Init,
  UnInit,
  Send,
  SendBuf,
  RecBuf,
  BusSpeed,
  SetSS,
  CheckMedia                          /* Can be NULL if not existing         */
};


#define SPIx   SPI1


/* SPI_SR - bit definitions. */
#define RXNE    0x01
#define TXE     0x02
#define BSY     0x80
#define FPCLK   __FPCLK/1000


/*--------------------------- spi_init --------------------------------------*/

static BOOL Init (void) 
{
    GPIO_InitTypeDef GPIO_InitStructure;
  SPI_InitTypeDef SPI_InitStructure;
  
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE); 

  // Card Sensor PA.8 input 
    // 1 = NO Card, 0 = Card plugged.
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  // Card Locked PB.0 input 
    // 1 = Card locked, 0 = Card unlocked.
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOB, &GPIO_InitStructure);


  // Configure SPI as alternate function     
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;          
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; 
  GPIO_Init(GPIOA, &GPIO_InitStructure); 
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;          
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; 
  GPIO_Init(GPIOA, &GPIO_InitStructure); 
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;          
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;    
  GPIO_Init(GPIOA, &GPIO_InitStructure); 

  // Map the USART1 alternate function
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource5, GPIO_AF_SPI1);
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_SPI1);
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_SPI1);

  // Configure PA4 (/CS) as output
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOA, &GPIO_InitStructure);    



  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
  SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
  SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
  SPI_Init(SPI1,&SPI_InitStructure);
  SPI_Cmd(SPI1, ENABLE);  
  return (__TRUE);  
}


/*--------------------------- UnInit ----------------------------------------*/

static BOOL UnInit (void) 
{
  /* Return SSP interface to default state. */
  /*
  GPIOA->CRL = (GPIOA->CRL & 0x0000FFFF) | 0x44440000;

  
  GPIOE->ODR &= ~0x01; 
  GPIOE->CRL  = (GPIOE->CRL & 0xFFFFFFF0) | 0x00000004;
  
  SPIx->CR1  = 0x0000;
  SPIx->CR2  = 0x0000;    
    */
  return (__TRUE);  
}  



/*--------------------------- Send ------------------------------------------*/

static U8 Send (U8 outb) {
  /* Write and Read a byte on SPI interface. */

  SPIx->DR = outb;   
  /* Wait if RNE cleared, Rx FIFO is empty. */
  while (!(SPIx->SR & RXNE));
  return (SPIx->DR);
}


/*--------------------------- SendBuf ---------------------------------------*/

static BOOL SendBuf (U8 *buf, U32 sz) {
  /* Send buffer to SPI interface. */
  U32 i;                       

  for (i = 0; i < sz; i++) {    
    SPIx->DR = buf[i];
  /* Wait if TXE cleared, Tx FIFO is full. */
    while (!(SPIx->SR & TXE));
    
    SPIx->DR;
  }
  /* Wait until Tx finished, drain Rx FIFO. */
  while (SPIx->SR & (BSY | RXNE)) {
    SPIx->DR;
  }
  return (__TRUE);               
}


/*--------------------------- RecBuf ----------------------------------------*/

static BOOL RecBuf (U8 *buf, U32 sz) {
  /* Receive SPI data to buffer. */
  U32 i;

  for (i = 0; i < sz; i++) {
    SPIx->DR = 0xFF;
    /* Wait if RNE cleared, Rx FIFO is empty. */
    while (!(SPIx->SR & RXNE));
    buf[i] = SPIx->DR;
  }
  return (__TRUE);
}


/*--------------------------- BusSpeed --------------------------------------*/

static BOOL BusSpeed (U32 kbaud) {
  /* Set an SPI clock to required baud rate. */
  U8  br;

  if      (kbaud >= FPCLK / 2)   br = 0;                       /* FPCLK/2    */
  else if (kbaud >= FPCLK / 4)   br = 1;                       /* FPCLK/4    */
  else if (kbaud >= FPCLK / 8)   br = 2;                       /* FPCLK/8    */
  else if (kbaud >= FPCLK / 16)  br = 3;                       /* FPCLK/16   */
  else if (kbaud >= FPCLK / 32)  br = 4;                       /* FPCLK/32   */
  else if (kbaud >= FPCLK / 64)  br = 5;                       /* FPCLK/64   */
  else if (kbaud >= FPCLK / 128) br = 6;                       /* FPCLK/128  */
  else                           br = 7;                       /* FPCLK/256  */

  SPIx->CR1 = (SPIx->CR1 & ~(7 << 3)) | (br << 3); 
  
  return (__TRUE);
}


/*--------------------------- SetSS -----------------------------------------*/

static BOOL SetSS (U32 ss) {
  /* Enable/Disable SPI Chip Select (drive it high or low). */
  if (ss) 
  {
    printf ("High\n");
    GPIO_SetBits (GPIOA, GPIO_Pin_4);             /* SSEL is GPIO, output set to high. */
  }
  else 
  {
    printf ("Low\n");
    GPIO_ResetBits (GPIOA, GPIO_Pin_4);           /* SSEL is GPIO, output set to low. */
  }
  return (__TRUE);
}


/*--------------------------- CheckMedia ------------------------------------*/

static U32 CheckMedia (void) {
  /* Read CardDetect and WriteProtect SD card socket pins. */
  U32 stat = 0;
 
  if (!GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_8)) 
  {
    printf("Card inserted\n");
    /* Card is inserted (CD=0). */
    stat |= M_INSERTED;
  }
#if 0
  if (GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_0)) 
  {
    printf("Card locked\n");
    /* Write Protect switch is active (WP=1). */
    stat |= M_PROTECTED;
  }
#endif
  return (stat);
}

/*----------------------------------------------------------------------------
 * end of file
 *---------------------------------------------------------------------------*/

[holger (Gast)]

Probier das mal so:

/*--------------------------- SendBuf ---------------------------------------*/

static BOOL SendBuf (U8 *buf, U32 sz) {
  /* Send buffer to SPI interface. */
  U32 i;                       

  for (i = 0; i < sz; i++) {    
    SPIx->DR = buf[i];
    while (!(SPIx->SR & RXNE));
    SPIx->DR;
  }
 
 return (__TRUE);               
}

[Mathias S. (stucmath)]

Danke für die schnelle Antwort.

Dies hat leider mein Problem nicht gelöst.
Ist das SPI Init in meinem Code korrekt?
Hat vielleicht sonst noch jemand eine Idee
Bin dankbar für jede Hilfestellung.

Gruss

[Archie F. (archie)]

Schaue dir die SPI Ansteuerung von der F1 Serie an, dürfte sich nicht 
viel geändert haben.
http://gandalf.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/index.html#chanfat_stm32

[holger (Gast)]

RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);


Wo wird RCC für GPIOA freigeschaltet?

[Mathias S. (stucmath)]

Vielen Dank für die Unterstützung.

GPIOA wurde immer hier freigeschaltet:

void RCC_Configuration(void)
{  
    /* Enable clocks */      
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE); 
}

Habe nun alles wieder dort hinein gepackt.

Ohne Erfolg.

[Mathias S. (stucmath)]

#define __FPCLK    72000000

Müsste das nicht

 #define __FPCLK    120000000

 sein?

Aber somit wäre der Clock beim SD Init über 400khz oder nicht?

Was meint ihr dazu?