STM32F7 Bitmap auf SD-Karte speichern via DMA2D

[Adri G. (dgst)]

Hallo allerseits,

ich habe eine kleine Kamera Demo Plattform für den MT9D111-Sensor von 
Aptina auf einem STM32F7-discovery Board entwickelt. Ich habe mich dabei 
an die Beispiele aus der HAL-Library von ST gehalten.

Der Datenfluss für die Preview ist wie folgt:
DCMI-Interface -> DMA -> Frame Ringbuffer im SDRAM (0xC0260000). Nach 
jeder übertragenen Zeile gibt es ein Interrupt, wo dann der DMA2D 
benutzt wird, um die Zeile von RGB565 in ARGB8888 zu wandeln und in den 
Display Buffer (0xC0130000) zu kopieren.

Außerdem habe ich eine Fotofunktion implementiert, bei der ein Bild mit 
höherer Auflösung (VGA) in einen weiteren Bereich des SDRAMs 
(0xC0390000) gepeichert wird. Dieses Bild kann auch wieder über den 
DMA2D in den LCD Framebuffer kopiert werden, damit man es sich ansehen 
kann.

Das funktioniert alles wunderbar, daher nun zum eigentlichen Problem:
Ich möchte nun ein Bild aus der Fotofunktion als Bitmap auf einer FAT 
formatierten SD-Karte speichern, um es mir am PC anzugucken.

Hier der Code dafür:

void SD_write_image(void)
{
  uint8_t sd_check = SD_Check();//check if SD card is inserted

  switch (sd_check)
  {
  case SD_NOT_PRESENT:
  {
    BSP_LCD_DisplayStringAt(10, 154, (uint8_t*)"No SD card!", LEFT_MODE);
    HAL_Delay(1000);
    Draw_UI();
    break;
  }
  case SD_PRESENT:
  {
    FIL file; //file object
    char file_str[30] = "image01.bmp";//filename

    DMA2D_HandleTypeDef hdma2d_buf;

    int32_t i, j;
    uint32_t tmp = 0;

    uint16_t img_buf[640];

    UINT bytes_written;

    FRESULT fs_error;

    file_str[6] = (char)((img_counter % 10) + 48);//increase the filename
    file_str[5] = (char)(((img_counter/10) % 10) + 48);

    //create a test pattern, black
    for(j = 0; j < 640; j++)
    {
      if((j%2) == 0) img_buf[j] = 0x0;
      else img_buf[j] = 0x0;
    }

    fs_error = SD_Mount();
    if(fs_error != FR_OK) Filesystem_ErrorHandler(fs_error);

    fs_error = SD_OpenFile(&file, file_str, F_WR_CLEAR);
    if(fs_error != FR_OK) Filesystem_ErrorHandler(fs_error);

    fs_error = f_write(&file, bmp_fileheader640, 138, &bytes_written);

    if(fs_error != FR_OK)
    {
      Filesystem_ErrorHandler(fs_error);
    }

    for(i = 0; i < 480; i++)//480 lines
    {
      //copy one line in a RAM buffer using DMA2D

      /* Enable DMA2D clock */
      __HAL_RCC_DMA2D_CLK_ENABLE();

      /* Configure the DMA2D Mode, Color Mode and output offset */
      hdma2d_buf.Init.Mode         = DMA2D_M2M;
      hdma2d_buf.Init.ColorMode    = DMA2D_RGB565;
      hdma2d_buf.Init.OutputOffset = 0;

      /* Foreground Configuration */
      hdma2d_buf.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
      hdma2d_buf.LayerCfg[1].InputAlpha = 0xFF;
      hdma2d_buf.LayerCfg[1].InputColorMode = CM_RGB565;
      hdma2d_buf.LayerCfg[1].InputOffset = 0;

      hdma2d_buf.Instance = DMA2D;

      /* DMA2D Initialization */
      if(HAL_DMA2D_Init(&hdma2d_buf) == HAL_OK)
      {
        if(HAL_DMA2D_ConfigLayer(&hdma2d_buf, 1) == HAL_OK)
        {
          if (HAL_DMA2D_Start(&hdma2d_buf, (uint32_t)(CAPTURE_FRAME_BUFFER + tmp), (uint32_t)&img_buf, 640, 1) == HAL_OK)
          {
            /* Polling For DMA transfer */
            HAL_DMA2D_PollForTransfer(&hdma2d_buf, 10);
          }
        }
      }



      fs_error = f_write(&file, img_buf, 1280, &bytes_written);
      if(fs_error != FR_OK)
      {
        Filesystem_ErrorHandler(fs_error);
      }
      tmp = tmp + 640*sizeof(uint16_t);//increase the SDRAM address
    }

}

    fs_error = SD_CloseFile(&file);
    if(fs_error != FR_OK) Filesystem_ErrorHandler(fs_error);

    fs_error = SD_UnMount();
    if(fs_error != FR_OK) Filesystem_ErrorHandler(fs_error);

    img_counter++;
    sprintf((char*)text, "Images stored: %d", (int)img_counter);
    BSP_LCD_DisplayStringAt(5, LINE(9), (uint8_t*)text, LEFT_MODE);

    break;
  }
  default: break;
  };
}

Kurze Erklärung dazu:
Ich hole immer eine Zeile des Bildes via DMA2D aus dem SDRAM und 
speichere sie im onchip SRAM. Pixel Format Conversion ist hier nicht 
notwendig, da der BMP-Header entsprechend angepasst ist (alles RGB565, 
2Byte/pixel).
*Nun bekomme ich aber offensichtlich nicht die richtigen bzw. 
unvollständige Daten aus dem SDRAM. Das BMP sieht aus wie im Anhang.*

Teilweise sind schon Bilddaten zu sehen, aber was mich am meisten 
verwundert sind die schwarzen Balken. Diese kommen daher, dass ich den 
Zeilenpuffer im SRAM vor der DMA2D-Aktion mit Nullen beschreiben.
Nach meinem Verständnis sollten die aber später alle wieder 
überschrieben werden.

Habt ihr vielleicht eine Ahnung, wo der Fehler liegen könnte?
Ich stehe gerade echt auf dem Schlauch, vor allem da zwei ähnliche 
Funktionen ohne Probleme funtionieren.

[Jim M. (turboj)]

Ich mag da was übersehen haben, aber müsste nicht ein

fs_error = f_write(&file, (uint8_t*)CAPTURE_FRAME_BUFFER, 640*480*2, &bytes_written);

auch ganz ohne den HAL DMA funktionieren? Das ist hier doch nur ein 
memcpy() Ersatz.

[Adri G. (dgst)]

Hätte ich auch gedacht und habe es deswegen auch erst so probiert.

Da bekomme ich dann allerdings eine Hard Fault exception (auch wenn ich 
das zeilenweise mache).

[Dr. Sommer (Gast)]

Adrian O. schrieb:
> Da bekomme ich dann allerdings eine Hard Fault exception (auch wenn ich
> das zeilenweise mache).

Das liegt vermutlich daran, dass du einen unaligned Zugriff auf den 
SDRAM machst (d.h. Halfword-Zugriff mit ungerader Adresse, oder 
Word-Zugriff mit Adresse die kein Vielfaches von 4 ist). Wenn du die 
f_write Routine dementsprechend korrigierst, solltest du direkt aus dem 
SDRAM schreiben können, ohne das erst per DMA umkopieren zu müssen.

[Adri G. (dgst)]

Hm ok, die f_write gehört zu der FATFS Library und da wollte ich 
eigentlich ungerne drin rumfuhrwerken. Zumal ich auch nur rudimentär 
verstehe, was da drin passiert.

Ich muss auch nicht direkt aus dem SDRAM schreiben. Es würde mich schon 
glücklich machen, wenn das mit dem DMA funktionieren würde.
Irgendwelche Datan bekomme ich da ja, es ist nur rätselhalft wieso es 
nicht die richtigen sind.

Edit:
Habe mal im Debugging die Speicheradressen ab 0xC0390000 mit meiner 
ersten Zeile in img_buf verglichen. Siehe dazu die beiden Screenshots.

Das komische ist ja auch, dass bei Adresse 0xC0390000 der richtige Wert 
drin steht (passt von der Farbe her zu meinem Bild), aber er den in 
img_buf nicht überschreibt...Da bleibt einfach die Null mit der ich 
vorher initialisiert habe.

Ab Adresse 0xC039001C passt es dann und irgendwann kommen dann wieder 
ein paar Nullen usw.

Woran kann es denn liegen, dass schon das nicht korrekt funktioniert?

Edit2:

Außerdem seltsam: Wenn ich die Funktion mehrmals hintereinander aufrufe, 
ohne ein neues bild gemacht zu haben, bekomme ich trotzdem 
unterschiedliche Ergebnisse.