piątek, 25 listopada 2016

[2] STM32F7 - SDRAM

Ten post chciałbym poświęcić na opisanie sposobu zaprogramowania pamięci SDRAM zamontowanej na płytce STM32F7 Discovery. Jest to model MT48LC432B2B5-6A firmy Micron. Zastosowana kość posiada 128Mb pamięci, dla mikrokontrolera jest dostępne 64Mb. Linie DQ16 do DQ31 są podłączone do rezystorów podciągających do masy.

Rys. 1. Schemat podłączenia [UM1907]

Pamięć sterowana jest poprzez układ FMC (ang. Flexible Memmory Controler). Maksymalny ustawiony dla niego zegar nie może przekraczać ponad połowę maksymalnej częstotliwości taktowania systemu, czyli 100MHz, lub 1/3 częstotliwości taktowania. Wartość 100MHz spowodowana jest częstotliwością taktowania układu SDRAM

Pamięć do których uzyskuje się dostęp podzielona jest na cztery banki pamięci. Każdy bank składa się z 256 kolumn i 4096 rzędów. Każda komórka składa się z 32 bitów. Ograniczony dostęp do 64Mb jest spowodowany nie wykorzystywaniem wszystkich linii, o czym wspomniałem wcześniej.

Programowanie


Teraz przejdę przez poszczególne etapy programowania tej pamięci:

Najpierw należy zdefiniować wszystkie potrzebne adresy oraz wartości jako #define:

  1. #define SDRAM_START_ADR      ((uint32_t)0xC0000000)
  2. #define SDRAM_MAX_ADR         0x800000  // max=8MByte //Rozmiar pamięci
  4. #define SDRAM_MEMORY_WIDTH FMC_SDRAM_MEM_BUS_WIDTH_16
  5. #define SDCLOCK_PERIOD     FMC_SDRAM_CLOCK_PERIOD_2
  6. #define SDRAM_TIMEOUT      ((uint32_t)0xFFFF)
  7. #define REFRESH_COUNT      ((uint32_t)0x0603)
  9. #define SDRAM_MODEREG_BURST_LENGTH_1             ((uint16_t)0x0000)
  10. #define SDRAM_MODEREG_BURST_LENGTH_2             ((uint16_t)0x0001)
  11. #define SDRAM_MODEREG_BURST_LENGTH_4             ((uint16_t)0x0002)
  12. #define SDRAM_MODEREG_BURST_LENGTH_8             ((uint16_t)0x0004)
  13. #define SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL      ((uint16_t)0x0000)
  14. #define SDRAM_MODEREG_BURST_TYPE_INTERLEAVED     ((uint16_t)0x0008)
  15. #define SDRAM_MODEREG_CAS_LATENCY_2              ((uint16_t)0x0020)
  16. #define SDRAM_MODEREG_CAS_LATENCY_3              ((uint16_t)0x0030)
  17. #define SDRAM_MODEREG_OPERATING_MODE_STANDARD    ((uint16_t)0x0000)
  18. #define SDRAM_MODEREG_WRITEBURST_MODE_PROGRAMMED ((uint16_t)0x0000)
  19. #define SDRAM_MODEREG_WRITEBURST_MODE_SINGLE     ((uint16_t)0x0200)

Dodatkowo należy stworzyć kilka zmiennych typów strukturalnych dla funkcji inicjalizujących:

  1. static SDRAM_HandleTypeDef sdramHandle;
  2. static FMC_SDRAM_TimingTypeDef Timing;
  3. static FMC_SDRAM_CommandTypeDef Command;
  4. static GPIO_InitTypeDef gpio_init_structure;

Proces inicjalizacji peryferiów wygląda następująco. W pierwsze kolejności włączane są GPIO oraz zegary. Następnie wywoływane jest wprowadzenie danych do FMC.

Definicja funkcji wygląda następująco:

  1. __weak void SDRAM_MSPINIT_PRIVATE(SDRAM_HandleTypeDef  *hsdram, void *Params)
  2. {
  3.   //Zegar dla FMC
  4.   __HAL_RCC_FMC_CLK_ENABLE();
  6.   //Wlaczenie zegarow dla GPIO
  7.   __HAL_RCC_GPIOC_CLK_ENABLE();
  8.   __HAL_RCC_GPIOD_CLK_ENABLE();
  9.   __HAL_RCC_GPIOE_CLK_ENABLE();
  10.   __HAL_RCC_GPIOF_CLK_ENABLE();
  11.   __HAL_RCC_GPIOG_CLK_ENABLE();
  12.   __HAL_RCC_GPIOH_CLK_ENABLE();
  14.   //Wspolne ustawienia dla pinow
  15.   gpio_init_structure.Mode      = GPIO_MODE_AF_PP;
  16.   gpio_init_structure.Pull      = GPIO_PULLUP;
  17.   gpio_init_structure.Speed     = GPIO_SPEED_FAST;
  18.   gpio_init_structure.Alternate = GPIO_AF12_FMC;
  20.   //GPIOC _ PIN3
  21.   gpio_init_structure.Pin   = GPIO_PIN_3;
  22.   HAL_GPIO_Init(GPIOC, &gpio_init_structure);
  24.   //GPIOD _ PIN0 | PIN1| PIN3 | PIN8 | PIN9 | PIN10 | PIN14 | PIN15
  25.   gpio_init_structure.Pin   = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_3 |
  26.                               GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_14 | GPIO_PIN_15;
  28.   HAL_GPIO_Init(GPIOD, &gpio_init_structure);
  30.   //GPIOE _ PIN0 | PIN1| PIN7 | PIN8 | PIN9 | PIN10 | PIN11 | PIN12 | PIN13 | PIN14 | PIN15
  31.   gpio_init_structure.Pin   = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_7| GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 |
  32.                               GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15;
  34.   HAL_GPIO_Init(GPIOE, &gpio_init_structure);
  36.   //GPIOF _ PIN0 | PIN1| PIN2 | PIN3 | PIN4 | PIN5 | PIN11 | PIN12 | PIN13 | PIN14 | PIN15
  37.   gpio_init_structure.Pin   = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2| GPIO_PIN_3 | GPIO_PIN_4 |
  38.                               GPIO_PIN_5 | GPIO_PIN_11 | GPIO_PIN_12 |
  39.                               GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15;
  41.   HAL_GPIO_Init(GPIOF, &gpio_init_structure);
  43.   //GPIOG _ PIN0 | PIN1| PIN4 | PIN5 | PIN8 | PIN15
  44.   gpio_init_structure.Pin   = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_4| GPIO_PIN_5 | GPIO_PIN_8 | GPIO_PIN_15;
  46.   HAL_GPIO_Init(GPIOG, &gpio_init_structure);
  48.   //GPIOH _ PIN3 | PIN5
  49.   gpio_init_structure.Pin   = GPIO_PIN_3 | GPIO_PIN_5;
  51.   HAL_GPIO_Init(GPIOH, &gpio_init_structure);
  52. }

Kolejnym elementem jest procedura pozwalająca na konfiguracje FMC:

  1. ErrorStatus SDRAM_INIT_PRIVATE(void)
  2. {
  3.   static ErrorStatus sdramstat = ERROR;
  5.   //Konfiguracja urzadzenia
  6.   sdramHandle.Instance = FMC_SDRAM_DEVICE;
  8.   //Czas skonfigurowany na 100MHz jako zegar dla SD, systemowy zegar 200MHz
  9.   Timing.LoadToActiveDelay    = 2;
  10.   Timing.ExitSelfRefreshDelay = 7;
  11.   Timing.SelfRefreshTime      = 4;
  12.   Timing.RowCycleDelay        = 7;
  13.   Timing.WriteRecoveryTime    = 2;
  14.   Timing.RPDelay              = 2;
  15.   Timing.RCDDelay             = 2;
  17.   sdramHandle.Init.SDBank             = FMC_SDRAM_BANK1;             //numer banku pamieci
  18.   sdramHandle.Init.ColumnBitsNumber   = FMC_SDRAM_COLUMN_BITS_NUM_8; //Ilosc bitow w adresie kolumny
  19.   sdramHandle.Init.RowBitsNumber      = FMC_SDRAM_ROW_BITS_NUM_12;   //Ilosc bitow w adresie wiersza
  20.   sdramHandle.Init.MemoryDataWidth    = SDRAM_MEMORY_WIDTH;            
  21.   sdramHandle.Init.InternalBankNumber = FMC_SDRAM_INTERN_BANKS_NUM_4; //Liczba wewnetrznych bankow pamieci
  22.   sdramHandle.Init.CASLatency         = FMC_SDRAM_CAS_LATENCY_2;     //Czas dostepu w cyklach
  23.   sdramHandle.Init.WriteProtection    = FMC_SDRAM_WRITE_PROTECTION_DISABLE; //Wylaczenie blokowania pamieci, mozna wprowadzac dane
  24.   sdramHandle.Init.SDClockPeriod      = SDCLOCK_PERIOD;    
  25.   sdramHandle.Init.ReadBurst          = FMC_SDRAM_RBURST_ENABLE;   //Pozwala na pobieranie kolejnych komend podczas CAS Latency
  26.   sdramHandle.Init.ReadPipeDelay      = FMC_SDRAM_RPIPE_DELAY_0;   //Delay w cycklach przy odczycie danych
  28.   //Inicjalizacja FMC
  29.   if(HAL_SDRAM_Init(&sdramHandle, &Timing) == HAL_OK) { sdramstat = SUCCESS; }
  31.   //Incjalizacja kontrolera SDRAM
  32.   SDRAM_MSPINIT_PRIVATE(&sdramHandle, NULL);
  34.   //SDRAM procedura startowa
  35.   SDRAM_INITIALIZATION_PRIVATE(REFRESH_COUNT);
  37.   return sdramstat;
  38. }

Teraz czas na procedurę startową, która składa się z 5 określonych kroków:

  1. void SDRAM_INITIALIZATION_PRIVATE(uint32_t RefreshCount)
  2. {
  3.   __IO uint32_t tmp = 0;
  5.   //Krok 1: Konfiguracja zegarow
  6.   Command.CommandMode            = FMC_SDRAM_CMD_CLK_ENABLE;
  7.   Command.CommandTarget          = FMC_SDRAM_CMD_TARGET_BANK1;
  8.   Command.AutoRefreshNumber      = 1;
  9.   Command.ModeRegisterDefinition = 0;
  11.   //Wyslanie komendy
  12.   HAL_SDRAM_SendCommand(&sdramHandle, &Command, SDRAM_TIMEOUT);
  14.   //Krok 2: Opoznienie 100us minimum, wyslane 1ms Systick
  15.   HAL_Delay(1);
  17.   //Krok 3: Konfiguracja PALL (precharge all)
  18.   Command.CommandMode            = FMC_SDRAM_CMD_PALL;
  19.   Command.CommandTarget          = FMC_SDRAM_CMD_TARGET_BANK1;
  20.   Command.AutoRefreshNumber      = 1;
  21.   Command.ModeRegisterDefinition = 0;
  23.   //Wyslanie komendy
  24.   HAL_SDRAM_SendCommand(&sdramHandle, &Command, SDRAM_TIMEOUT);
  26.   //Krok 4: Komenda Auto Refresh
  27.   Command.CommandMode            = FMC_SDRAM_CMD_AUTOREFRESH_MODE;
  28.   Command.CommandTarget          = FMC_SDRAM_CMD_TARGET_BANK1;
  29.   Command.AutoRefreshNumber      = 8;
  30.   Command.ModeRegisterDefinition = 0;
  32.   //Przeslanie komendy
  33.   HAL_SDRAM_SendCommand(&sdramHandle, &Command, SDRAM_TIMEOUT);
  35.   //Krok 5: Programowanie trybu dla zewnetrznej pamieci
  36.  tmp = (uint32_t)SDRAM_MODEREG_BURST_LENGTH_1 | SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL | SDRAM_MODEREG_CAS_LATENCY_2 |SDRAM_MODEREG_OPERATING_MODE_STANDARD | SDRAM_MODEREG_WRITEBURST_MODE_SINGLE;
  37.   Command.CommandMode            = FMC_SDRAM_CMD_LOAD_MODE;
  38.   Command.CommandTarget          = FMC_SDRAM_CMD_TARGET_BANK1;
  39.   Command.AutoRefreshNumber      = 1;
  40.   Command.ModeRegisterDefinition = tmp;
  42.   //Przeslanie komendy
  43.   HAL_SDRAM_SendCommand(&sdramHandle, &Command, SDRAM_TIMEOUT);
  45.   //Krok 6: Ustawienie licznika odswiezania
  46.   HAL_SDRAM_ProgramRefreshRate(&sdramHandle, RefreshCount);
  47. }

Trzy funkcje przedstawione powyżej mogą zostać zdefiniowane jako funkcje funkcje prywatne w pliku biblioteki. Wszystkie te funkcje można połączyć w jedną, która już będzie przekazywana do dalszej części programu:

  1. ErrorStatus SDRAM_INIT(void)
  2. {
  3.   ErrorStatus stat=ERROR;
  4.   uint16_t data1;
  5.   static uint8_t init_pass=0; //Jako statyczna, musi być pamiętana
  7.   //Inicjalizacje musza byc wykonane tylko jeden raz
  8.   if(init_pass != 0)
  9.   {
  10.     if(init_pass==1) { return(SUCCESS); }
  11.     else { return(ERROR); }
  12.   }
  14.   //FMC_konfiguracja
  15.   stat=SDRAM_INIT_PRIVATE();
  16.   if(stat!=SUCCESS) { return(ERROR); }
  18.   //Zapis oraz odczyt danych z pamięci
  19.   SDRAM_WRITE_16b(0x00, 0x7BC5);
  20.   data1 = SDRAM_READ_16b(0x00);
  22.   //Sprawdzenie danych
  23.   if(0x7BC5 == data1) { stat = SUCCESS; }
  25.   //Zaznaczenie że inicjalizacja przeszla pomyslnie
  26.   if(SUCCESS = stat)
  28.   //Zapisanie wartosci startowej
  29.   if(stat==SUCCESS) { init_pass=1; }
  30.   else { init_pass=2; }
  32.   return(stat);
  33. }

Jeśli chodzi o zapis oraz odczyt danych to funkcje można zakodować zwyczajnie, z parametrem inline, bądź całą procedurę zawrzeć w #define: 

  1. inline uint8_t SDRAM_READ_8B(uint32_t adres)
  2. {
  3.     return(*(__IO uint8_t*)(SDRAM_START_ADR + adres));
  4. }
  6. inline uint8_t SDRAM_READ_16B(uint32_t adres)
  7. {
  8.     return(*(__IO uint16_t*)(SDRAM_START_ADR + adres));
  9. }
  11. inline uint8_t SDRAM_READ_32B(uint32_t adres)
  12. {
  13.     return(*(__IO uint32_t*)(SDRAM_START_ADR + adres));
  14. }

Zapis:

  1. inline void SDRAM_WRITE_8b(uint32_t adres, uint8_t zmienna)
  2. {
  3.   (*(_IO uint8_t*) (SDRAM_START_ADR + adres) = zmienna);
  4. }
  6. inline void SDRAM_WRITE_16b(uint32_t adres, uint8_t zmienna)
  7. {
  8.   (*(_IO uint16_t*) (SDRAM_START_ADR + adres) = zmienna);
  9. }
  11. inline void SDRAM_WRITE_32b(uint32_t adres, uint8_t zmienna)
  12. {
  13.   (*(_IO uint32_t*) (SDRAM_START_ADR + adres) = zmienna);
  14. }

Dodatkowo do pamięci SDRAM zapisu można dokonać poprzez DMA z wykorzystam funkcji z biblioteki HAL'a:

  1. ErrorStatus SDRAM_READ_BUFFER_32b(uint32_t* ptrBuffer, uint32_t startAdres, uint32_t lenBuffer)
  2. {
  3.   if(HAL_SDRAM_Read_32b(&sdramHandle, (uint32_t *)(startAdres+SDRAM_START_ADR), ptrBuffer, lenBuffer) != HAL_OK)
  4.   { return ERROR; }
  5.   else{ return SUCCESS; }
  6. }
  7. ErrorStatus SDRAM_WRITE_BUFFER_32b_DMA(uint32_t* ptrBuffer, uint32_t startAdr, uint32_t lenBuffer)
  8. {
  9.   if(HAL_SDRAM_Write_DMA(&sdramHandle, (uint32_t *)(startAdr+SDRAM_START_ADR), ptrBuffer, lenBuffer) != HAL_OK)
  10.   { return ERROR; }
  11.   else { return SUCCESS; }
  12. }


CUBE MX


Jeśli chodzi o konfigurację z użyciem środowiska CUBEMx, to należy kontroler FMC włączyć z następującymi ustawieniami:

Rys. 2. Inicjalizacja FMC

Zegar należy ustawić następująco:

Rys. 3. Konfiguracja zegarów

Konfiguracja FMC przeniesiona z wcześniejszych funkcji do cuba wygląda następująco:

Rys 4. Konfiguracja FMC
Autor: o
Etykiety: ,