STM32 ISP Flash S25FL256S Problem

[Berger (Gast)]

Hallo,

ich habe ein Problem mit dem Flash Speicher von Spansion und versuche 
schon seit Tagen das Problen zu lösen, komme aber irgendwie nicht 
weiter.
Der Befehl read ID (90h) wird hier mit der Funktion 
S25FL256S_ReadID(void) ausgeführt und sollte 01 18 hex liefert. dieser 
liefert aber Werte wie 01 FF oder 18 FF. Wenn ich einfach mal 4 statt 2 
Bytes lese, dann haben die letzten beiden Bytes die richtigen Werte.
Aufgefallen ist mir das wenn ich die zweite Funktion read Status 
Register-1 aufrufe, hatte diese dann den Wert 01 18 geliefert, also die 
Werte vom ersten Befehl. Im Datenblatt steht das der Befehl zwei bytes 
liefern sollte.

Ich sehe wahrscheinlich den Walt vor lauter Bäume nicht.
Hat jemand einen Tip wie das Problem gelöst bekomme?

// Chip Select für externen Speicher
#define S25FL256S_ChipSelect()        GPIO_ResetBits(S25FL_PORT, S25FL_CS_PIN)
// Chip Deselect für externen Speicher
#define S25FL256S_ChipDeselect()      GPIO_SetBits(S25FL_PORT, S25FL_CS_PIN) 

void S25FL_Configuration()
{

  GPIO_InitTypeDef GPIO_InitStructure;
  SPI_InitTypeDef SPI_InitStructure;

  // RCC Konfiguration
  //------------------------------------------------------------------------------------
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO | RCC_APB2Periph_SPI1, ENABLE);

  // Konfiguriert den Not CS Pin als Ausgang
  //------------------------------------------------------------------------------------
  GPIO_InitStructure.GPIO_Pin   = S25FL_CS_PIN;
  GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_Out_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_Init(S25FL_PORT, &GPIO_InitStructure);
  
  // Konfiguriert die SPI Pins
  //------------------------------------------------------------------------------------
  GPIO_InitStructure.GPIO_Pin = S25FL_SCK_PIN | S25FL_SO_PIN | S25FL_SI_PIN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(S25FL_PORT, &GPIO_InitStructure);

  // SPI Master Konfiguration
  //------------------------------------------------------------------------------------
  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_CPOL_High, SPI_CPOL_Low
  SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge; // SPI_CPHA_1Edge, SPI_CPHA_2Edge
  SPI_InitStructure.SPI_NSS  = SPI_NSS_Soft; // SPI_NSS_Soft, SPI_NSS_Hard
  SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_64;//SPI_BaudRatePrescaler_128;//SPI_BaudRatePrescaler_16;// 72M / 64 = 1.125M 
  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
  SPI_InitStructure.SPI_CRCPolynomial = 7;

  SPI_I2S_DeInit(S25FL_SPI);
  SPI_Init(S25FL_SPI, &SPI_InitStructure);

  // Enable SPI_MASTER 
  SPI_Cmd(S25FL_SPI, ENABLE);
  SPI_CalculateCRC(S25FL_SPI, DISABLE);
}


u8 S25FL256S_FlashRead(u8 command, u32 address, u8* buffer, int number_Of_Read_Bytes)
{
  u8 status = TRUE;
  int data_cycle;
  
  // Sendet den Befehl
  while(SPI_I2S_GetFlagStatus(S25FL_SPI, SPI_I2S_FLAG_TXE) == RESET); // Wartet bis der TX-Puffer leer ist.  
  SPI_I2S_SendData(S25FL_SPI, command); // Sendet das Byte.
  while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == SET); // Warten bis Byte vollständig gesendet ist

  // Sendet die Adresse
  if(address != ADDRESS_NOT_USED)
  {    
    while(SPI_I2S_GetFlagStatus(S25FL_SPI, SPI_I2S_FLAG_TXE) == RESET); // Wartet bis der TX-Puffer leer ist.  
    SPI_I2S_SendData(S25FL_SPI, (u8)((address >> 16) & 0x000000FF)); // Sendet das Byte.     
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == SET); // Warten bis Byte vollständig gesendet ist
    
    while(SPI_I2S_GetFlagStatus(S25FL_SPI, SPI_I2S_FLAG_TXE) == RESET); // Wartet bis der TX-Puffer leer ist.  
    SPI_I2S_SendData(S25FL_SPI, (u8)((address >> 8) & 0x000000FF)); // Sendet das Byte.
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == SET); // Warten bis Byte vollständig gesendet ist

    while(SPI_I2S_GetFlagStatus(S25FL_SPI, SPI_I2S_FLAG_TXE) == RESET); // Wartet bis der TX-Puffer leer ist.  
    SPI_I2S_SendData(S25FL_SPI, (u8)(address & 0x000000FF)); // Sendet das Byte.
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == SET); // Warten bis Byte vollständig gesendet ist
  }

  if(number_Of_Read_Bytes != 0)
  {         
    for(data_cycle = 0; data_cycle < number_Of_Read_Bytes; data_cycle++)
    {     
      while( (S25FL_SPI->SR & SPI_I2S_FLAG_TXE) == RESET); // Wartet bis der TX-Puffer leer ist.  
      SPI_I2S_SendData(S25FL_SPI, 0);
             
      while(SPI_I2S_GetFlagStatus(S25FL_SPI, SPI_I2S_FLAG_RXNE) == RESET);
      *(buffer + data_cycle) = (u8)SPI_I2S_ReceiveData(S25FL_SPI);
    }
  }

  return status;
}

void S25FL256S_Wait(u32 ticks)
{
  while(ticks)
  {
    ticks--;
    __NOP();
  }
}

u16 S25FL256S_ReadID(void)
{
  u32 returnValue;

  S25FL256S_ChipSelect();

  // Wenn ich hier vier Bytes lade, liefert ist returnValue 0 x 01 18 18 FF
  // die zuletzt gelesenen Bytes 01 18 haben die richtigen Werte.
  // S25FL256S_FlashRead(S25FL256S_CMD_READ_ID, 0x000000, (u8*)&returnValue, 4);    

  // Read Identification - REMS (Read_ID or REMS 90h)
  S25FL256S_FlashRead(S25FL256S_CMD_READ_ID, 0x000000, (u8*)&returnValue, 2); // Soll 0x 01 18 liefert

  S25FL256S_Wait(0x0F);  
  while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == SET); // Warten bis Byte vollständig gesendet ist
  S25FL256S_ChipDeselect();  

  return (u16)(returnValue & 0x0000ffff);
}

u16 S25FL256S_ReadStatusReg1(void)
{
  u16 returnValue;

  S25FL256S_ChipSelect();
  S25FL256S_Wait(0x0F);

  S25FL256S_FlashRead(S25FL256S_CMD_READ_STATUS_REG1, ADDRESS_NOT_USED, (u8*)&returnValue, 2);  

  S25FL256S_Wait(0x0F);  
  while(SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == SET); // Warten bis Byte vollständig gesendet ist
  S25FL256S_ChipDeselect();  

  return returnValue;
}

// ---------------------------------------

int main(void)
{ 
  u16 a, b;

  InitializeProgram();
  S25FL_Configuration();

  while(1)
  {
    a = S25FL256S_ReadID();    
    b = S25FL256S_ReadStatusReg1();

    S25FL256S_Wait(0xffff);
  }
}

[Berger (Gast)]

Noch eine Anmerkung, in der Funktion S25FL256S_ReadStatusReg1(void) wird 
normalerweise nur ein Byte gelesen.

[Berger (Gast)]

Kleiner Tippfehler es ist natürlich die SPI-Schnittstelle.

[Lötlackl *. (pappnase)]

Hast Du schon mal versucht, den "S25FL_SI_PIN" als Eingang zu 
konfigurieren? Ich könnte auch den Pin "S25FL_SO_PIN" meinen, keine 
Ahnung, wie die definiert sind. Oder habe ich was übersehen?

  // Konfiguriert die SPI Pins
  //------------------------------------------------------------------------------------
  GPIO_InitStructure.GPIO_Pin = S25FL_SCK_PIN | S25FL_SO_PIN/* | S25FL_SI_PIN*/;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(S25FL_PORT, &GPIO_InitStructure);

  GPIO_InitStructure.GPIO_Pin = S25FL_SI_PIN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; // oder meinetwegen GPIO_Mode_IPU, GPIO_Mode_IPD
  GPIO_Init(S25FL_PORT, &GPIO_InitStructure);

mfg

[Berger (Gast)]

@ ** Lötlackl (pappnase)
Nein, das wäre nur nötig wenn man ein Software SPI machen würde. Ich 
benutze den Hardware gesteuerten SPI. Bei der Hardware Variante muß man 
die Pins mit GPIO_Mode_AF_PP konfigurieren, der Mikrokontroller steuert 
dann die PIN automatisch.

GPIO_InitStructure.GPIO_Pin = S25FL_SCK_PIN | S25FL_SO_PIN | S25FL_SI_PIN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(S25FL_PORT, &GPIO_InitStructure);

Ich habe aber mitlerweile das Problem lösen können. immer wenn Ich Daten 
sende, empfängt der MC Datenschrott, also die unerwünschten FF Bytes.
Gelöst habe Ich das in dem Ich für RX den Interrupt benutze, dieser 
filtert dann den Datenschrott raus.