STM32 QuadSPI CS-Frequenz erhöhen

[Kevin L. (kevka2908)]

Moin,

und zwar möchte ich mit dem STM32F767ZI Chip per QuadSPI einen ADC 
ansprechen (AD4001). Wie im Protokoll definiert, habe ich dafür bereits 
das Turbobit gesetzt, sowie den SPI-Takt auf mind. 70 MHz gesetzt. Der 
Chip läuft mit 216MHz. Mein Problem besteht momentan noch darin, dass 
der CS vom Controller zu lange auf High ist bevor das nächste Sample 
ausgelesen wird (2µs von einer fallenden Flanke zur nächsten). Für die 2 
MSPs Abtastrate müsste dieser Abstand aber bei 500ns liegen.

Initialisierung QSPI:

static void MX_QUADSPI_Init(void)
{
  /* QUADSPI parameter configuration*/
  hqspi.Instance = QUADSPI;
  hqspi.Init.ClockPrescaler = 2;
  hqspi.Init.FifoThreshold = 1;
  hqspi.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_NONE;
  hqspi.Init.FlashSize = 1;
  hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_2_CYCLE;
  hqspi.Init.ClockMode = QSPI_CLOCK_MODE_0;
  hqspi.Init.FlashID = QSPI_FLASH_ID_1;
  hqspi.Init.DualFlash = QSPI_DUALFLASH_DISABLE;
  if (HAL_QSPI_Init(&hqspi) != HAL_OK)
  {
    Error_Handler();
  }
}

Und hier die Konfiguration zum Auslesen der Daten im Indirect Read Mode.

    //Configure QSPI for receiving

    QSPI_CommandTypeDef qspicommand = {0};
    qspicommand.DdrMode = QSPI_DDR_MODE_DISABLE;
    qspicommand.DdrHoldHalfCycle = QSPI_DDR_HHC_ANALOG_DELAY;
    qspicommand.SIOOMode = QSPI_SIOO_INST_ONLY_FIRST_CMD;
    qspicommand.DataMode = QSPI_DATA_1_LINE;
    qspicommand.DummyCycles = 0;
    qspicommand.AlternateBytes = QSPI_ALTERNATE_BYTES_8_BITS;
    qspicommand.AlternateByteMode = QSPI_ALTERNATE_BYTES_NONE;
    qspicommand.AddressSize = QSPI_ADDRESS_8_BITS;
    qspicommand.AddressMode = QSPI_ADDRESS_NONE;
    qspicommand.InstructionMode = QSPI_INSTRUCTION_NONE;
    qspicommand.NbData = 2;

    HAL_QSPI_Command(&hqspi, &qspicommand, 0xFFFF);

Innerhalb meiner Main Methode erfolgt dann der Aufruf der Funktion zum 
Auslesen der Daten:

uint8_t tmp[2] = {0};
while(1){
HAL_QSPI_Receive(&hqspi, (uint8_t*)&tmp, 0x0000);
}

Da die HAL-Funktion ziemlich aufgebläht mit Statusabfragen und ähnlichem 
ist, habe ich die Methode etwas verkürzt:

HAL_StatusTypeDef HAL_QSPI_Receive(QSPI_HandleTypeDef *hqspi, uint8_t *pData, uint32_t Timeout)
{
  HAL_StatusTypeDef status = HAL_OK;
  uint32_t tickstart = HAL_GetTick();
  uint32_t addr_reg = READ_REG(hqspi->Instance->AR);
  __IO uint32_t *data_reg = &hqspi->Instance->DR;

  /* Configure counters and size of the handle */
  hqspi->RxXferCount = 2;
  hqspi->RxXferSize = 2;
  hqspi->pRxBuffPtr = pData;

      /* Configure QSPI: CCR register with functional as indirect read */
      MODIFY_REG(hqspi->Instance->CCR, QUADSPI_CCR_FMODE, QSPI_FUNCTIONAL_MODE_INDIRECT_READ);

      /* Start the transfer by re-writing the address in AR register */
      WRITE_REG(hqspi->Instance->AR, addr_reg);

      while(hqspi->RxXferCount > 0U)
      {
        /* Wait until FT or TC flag is set to read received data */
        status = QSPI_WaitFlagStateUntilTimeout(hqspi, (QSPI_FLAG_FT | QSPI_FLAG_TC), SET, tickstart, Timeout);

        *hqspi->pRxBuffPtr = *((__IO uint8_t *)data_reg);
        hqspi->pRxBuffPtr++;
        hqspi->RxXferCount--;
      }

     
        /* Wait until TC flag is set to go back in idle state */

        status = QSPI_WaitFlagStateUntilTimeout(hqspi, QSPI_FLAG_TC, SET, tickstart, Timeout);

          /* Clear Transfer Complete bit */
          __HAL_QSPI_CLEAR_FLAG(hqspi, QSPI_FLAG_TC);


  return status;
}

Damit habe ich die CS-Frequenz inzwischen auf 1 MHz erhöhen können, 
höher ging es bisher nicht. Ich habe auch schon versucht, den CS Pin 
ohne Alternate Function direkt anzusprechen und zu setzen, jedoch ohne 
nennenswerte Zeitersparnis. Die Compilerflags sind auch auf O3 gesetzt.

[pegel (Gast)]

Kevin L. schrieb:
> hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_2_CYCLE;

Geht das kleiner?

[pegel (Gast)]

Und wie lang ist der "Cycle" überhaupt?

[Kevin L. (kevka2908)]

pegel schrieb:
> Kevin L. schrieb:
>> hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_2_CYCLE;
>
> Geht das kleiner?

Geht noch auf einen Cycle runter ja, hat aber an der Frequenz nichts 
geändert.





pegel schrieb:
> Und wie lang ist der "Cycle" überhaupt?

Der Prescaler von QSPI beträgt drei, ergo ist ein Cycle 14 Nanosekunden 
lang, bzw. hat ne Frequenz von 72 MHz.

[pegel (Gast)]

Habe es gerade mit CubeMX getestet, das stellt von sich aus auf ein 
Cycle.
Aber wenn das so wenig ausmacht ....

[A. B. (Gast)]

Da ist vielleicht immer noch viel zu viel Drumherum ... Das Abfragen der 
Flags kann man sich auch schenken, am besten gleich die 2 Bytes mit 
einem Halfword-Zugriff aus dem FIFO lesen. Wenn noch keine Daten da 
sind, blockiert der Zugriff so lange ...

Das ist ja auch ziemlich am Sinn dieses QSPI-Interfaces vorbei: Da ist 
darauf optimiert, mit einer CS-Aktivierung gleich einen großen 
Datenblock zu lesen/zu schreiben, deshalb ja auch ein FIFO. Für immer 
nur zwei kümmerliche Bytes ist wie Fahren mit angezogener Handbremse.