[13] STM32F7 - Discovery - SDRAM, Generacja własnego projektu

Ten poświęcę na przygotowanie krótkiego programu pozwalającym na wprowadzanie danych do pamięci SDRAM. Na płytce Discovery F7 znajduje się zewnętrzna pamięć MT48LC4M32B2.

Pamięć SDRAM już opisywałem na tym blogu, w tym poście zajmę się przygotowaniem programu pozwalającego na wpisywanie do niej danych, bez użycia bibliotek BSP.

CubeMx:

Poniżej przejdę przez wszystkie elementy jakie muszą zostać uruchomione w celu poprawnej pracy układu.

Włączenie zegara RCC:

Uruchomienie Debugera:

Uruchomienie pamięci USARTu:

Uruchomienie FMC dla SDRAM:

Konfiguracja zegara:

USART zostawiam ze standardowymi ustawieniami. Nie potrzebuję włączać przerwań ani DMA dla tego układu. Jedyną rzeczą jaką należy zmienić jest podłączenie pinu TX, który w celu wykorzystywania bez zewnętrznego konwertera musi zostać podłączony pod pin PA9.

Należy jeszcze pamiętać o konfiguracji samego rdzenia a dokładnie pamięci ICache, DCache oraz włączeniu jednostki ochrony pamięci:

No i najważniejsze. Uruchomienie pamięci SDRAM prezentuje się w następujący sposób:

Rozmieszczenie pinów na mikrokontrolerze wygląda następująco:

Po wszystkich procedurach kod należy wygenerować dla wybranego środowiska programistycznego, ja wykorzystałem Keila.

Dodatkowym elementem o którym należałoby pamiętać jest zwiększenie pamięci stosu i sterty. Wykonuje się to podczas generacji projektu:

Programowanie:

Dla kontrolera FMC wygenerowana procedura inicjalizacji dla pamięci SDRAM powinna wyglądać w następujący sposób:

1. static void MX_FMC_Init(void)
2. {
3.   FMC_SDRAM_TimingTypeDef SdramTiming;
5.   /** Perform the SDRAM1 memory initialization sequence
6.   */
7.   hsdram1.Instance = FMC_SDRAM_DEVICE;
8.   /* hsdram1.Init */
9.   hsdram1.Init.SDBank = FMC_SDRAM_BANK1;
10.   hsdram1.Init.ColumnBitsNumber = FMC_SDRAM_COLUMN_BITS_NUM_8;
11.   hsdram1.Init.RowBitsNumber = FMC_SDRAM_ROW_BITS_NUM_12;
12.   hsdram1.Init.MemoryDataWidth = FMC_SDRAM_MEM_BUS_WIDTH_16;
13.   hsdram1.Init.InternalBankNumber = FMC_SDRAM_INTERN_BANKS_NUM_2;
14.   hsdram1.Init.CASLatency = FMC_SDRAM_CAS_LATENCY_2;
15.   hsdram1.Init.WriteProtection = FMC_SDRAM_WRITE_PROTECTION_DISABLE;
16.   hsdram1.Init.SDClockPeriod = FMC_SDRAM_CLOCK_PERIOD_2;
17.   hsdram1.Init.ReadBurst = FMC_SDRAM_RBURST_ENABLE;
18.   hsdram1.Init.ReadPipeDelay = FMC_SDRAM_RPIPE_DELAY_0;
19.   /* SdramTiming */
20.   SdramTiming.LoadToActiveDelay = 2;
21.   SdramTiming.ExitSelfRefreshDelay = 7;
22.   SdramTiming.SelfRefreshTime = 4;
23.   SdramTiming.RowCycleDelay = 6;
24.   SdramTiming.WriteRecoveryTime = 2;
25.   SdramTiming.RPDelay = 2;
26.   SdramTiming.RCDDelay = 2;
28.   if (HAL_SDRAM_Init(&hsdram1, &SdramTiming) != HAL_OK)
29.   {
30.     _Error_Handler(__FILE__, __LINE__);
31.   }
32. }

Plik .h z inicjalizacją SDRAM oraz funkcją zapisującą dane wygląda następująco:

1. #ifndef __MT48LC4M32B2_H
2. #define __MT48LC4M32B2_H
3. //---------------------------------------------
4. #include "stm32f7xx_hal.h"
5. //---------------------------------------------
6. #define SDRAM_BANK_ADDR                             ((uint32_t)0xC0000000)
7. //---------------------------------------------
8. #define SDRAM_TIMEOUT                                           ((uint32_t)0xFFFF)
9. #define SDRAM_MR_BURST_LENGTH_1                 ((uint16_t)0x0000)
10. #define SDRAM_MR_BURST_LENGTH_2                 ((uint16_t)0x0001)
11. #define SDRAM_MR_BURST_LENGTH_4                 ((uint16_t)0x0002)
12. #define SDRAM_MR_BURST_LENGTH_8                 ((uint16_t)0x0004)
13. #define SDRAM_MR_BURST_TYPE_SEQUENTIAL          ((uint16_t)0x0000)
14. #define SDRAM_MR_BURST_TYPE_INTERLEAVED         ((uint16_t)0x0008)
15. #define SDRAM_MR_CAS_LATENCY_2                  ((uint16_t)0x0020)
16. #define SDRAM_MR_CAS_LATENCY_3                  ((uint16_t)0x0030)
17. #define SDRAM_MR_OPERATING_MODE_STANDARD        ((uint16_t)0x0000)
18. #define SDRAM_MR_WRITEBURST_MODE_PROGRAMMED     ((uint16_t)0x0000)
19. #define SDRAM_MR_WRITEBURST_MODE_SINGLE         ((uint16_t)0x0200)
20. //---------------------------------------------
21. void F7_SDRAM_Init(SDRAM_HandleTypeDef *hsdram);
22. void Fill_Buffer(uint32_t *bufferData, uint32_t bufferLenght, uint32_t offSet);
23. #endif /* __MT48LC4M32B2_H */

Do tego pliku zostały też dodane deklaracje wszystkich adresów oraz rejestrów.

W tym momencie uruchamiany jest sam kontroler, należy jeszcze pamiętać, o drugiej procedurze inicjalizacyjnej dla samej kości RAM. Którą należy najpierw przygotować. Można ją znaleźć w jednym z przykładów udostępnionych przez firmę ST (przykład znajduje się w folderze Examples, w pakietach dla środowiska CubeMx).

Wspomniana funkcja wygląda następująco:

1. void F7_SDRAM_Init(SDRAM_HandleTypeDef *hsdram)
2. {
3.     __IO uint32_t tmpmrd = 0;
4.    
5.     /* Configurate a clock config command */
6.   command.CommandMode = FMC_SDRAM_CMD_CLK_ENABLE;
7.   command.CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1;
8.   command.AutoRefreshNumber = 1;
9.   command.ModeRegisterDefinition = 0;
10.    
11.     /* Send configurate command */
12.   halStatus = HAL_SDRAM_SendCommand(hsdram, &command, SDRAM_TIMEOUT);
13.    
14.     if(halStatus != HAL_OK){
15.     _Error_Handler(__FILE__, __LINE__);
16.   }
17.    
18.     /* Delay between commands need to be at least 100us */
19.   FMC_SDRAM_DELAY(1);
20.    
21.     /* Configurate precharge command */
22.     command.CommandMode = FMC_SDRAM_CMD_PALL;
23.   command.CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1;
24.   command.AutoRefreshNumber = 1;
25.   command.ModeRegisterDefinition = 0;
26.    
27.     /* Send configurate command */
28.   halStatus = HAL_SDRAM_SendCommand(hsdram, &command, SDRAM_TIMEOUT);
29.    
30.     if(halStatus != HAL_OK){
31.     _Error_Handler(__FILE__, __LINE__);
32.   }
33.    
34.     FMC_SDRAM_DELAY(1);
36.     /* Configurate Autorefresh command */
37.   command.CommandMode = FMC_SDRAM_CMD_AUTOREFRESH_MODE;
38.   command.CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1;
39.   command.AutoRefreshNumber = 8;
40.   command.ModeRegisterDefinition = 0;
41.    
42.     /* Send configurate command */
43.     halStatus = HAL_SDRAM_SendCommand(hsdram, &command, SDRAM_TIMEOUT);
44.    
45.     if(halStatus != HAL_OK){
46.     _Error_Handler(__FILE__, __LINE__);
47.   }
48.    
49.     FMC_SDRAM_DELAY(1);
51.     /* Program external memory mode register */
52.     tmpmrd = (uint32_t) SDRAM_MR_BURST_LENGTH_1          |
53.                                             SDRAM_MR_BURST_TYPE_SEQUENTIAL   |
54.                                             SDRAM_MR_CAS_LATENCY_2           |
55.                                             SDRAM_MR_OPERATING_MODE_STANDARD |
56.                                             SDRAM_MR_WRITEBURST_MODE_SINGLE;
57.   command.CommandMode = FMC_SDRAM_CMD_LOAD_MODE;
58.   command.CommandTarget = FMC_SDRAM_CMD_TARGET_BANK1;
59.   command.AutoRefreshNumber = 1;
60.   command.ModeRegisterDefinition = tmpmrd;
61.    
62.     /* Send configurate command */
63.   halStatus = HAL_SDRAM_SendCommand(hsdram, &command, SDRAM_TIMEOUT);
64.     if(halStatus != HAL_OK){
65.     _Error_Handler(__FILE__, __LINE__);
66.   }
67.    
68.     /* Set the refresh rate counter (15.62 us x Freq) - 20 */
69.   /* Set the device refresh counter */
70.     hsdram->Instance->SDRTR |= ((uint32_t)((1292)<< 1));   
71. }

Funkcja wpisująca dane jak i odczytująca dane z niego znajduje się w głównej pętli programu:

1. #include "main.h"
2. #include "stm32f7xx_hal.h"
4. /* USER CODE BEGIN Includes */
5. #include "f7_sdram_mt48lc4m32b2.h"
6. #include "string.h"
7. /* USER CODE END Includes */
9. /* Private variables ---------------------------------------------------------*/
11. UART_HandleTypeDef huart1;
12. SDRAM_HandleTypeDef hsdram1;
14. /* USER CODE BEGIN PV */
15. /* Private variables ---------------------------------------------------------*/
16. #define BUFFER_SIZE         ((uint32_t)0x0400)
17. #define WRITE_READ_ADDR     ((uint32_t)0x0800)
19. uint32_t BufferSend[BUFFER_SIZE];
20. uint32_t BufferReceive[BUFFER_SIZE];
22. uint32_t iLoop = 0;
23. __IO uint32_t statusData = 0;
24. /* USER CODE END PV */
26. /* Private function prototypes -----------------------------------------------*/
27. void SystemClock_Config(void);
28. static void MPU_Config(void);
29. static void MX_GPIO_Init(void);
30. static void MX_USART1_UART_Init(void);
31. static void MX_FMC_Init(void);
33. /* USER CODE BEGIN PFP */
34. /* Private function prototypes -----------------------------------------------*/
36. /* USER CODE END PFP */
38. /* USER CODE BEGIN 0 */
40. /* USER CODE END 0 */
42. int main(void)
43. {
45.   /* USER CODE BEGIN 1 */
46.   char bufferUSART[20]={0};
47.   /* USER CODE END 1 */
49.   /* MPU Configuration----------------------------------------------------------*/
50.   MPU_Config();
52.   /* Enable I-Cache-------------------------------------------------------------*/
53.   SCB_EnableICache();
55.   /* Enable D-Cache-------------------------------------------------------------*/
56.   SCB_EnableDCache();
58.   /* MCU Configuration----------------------------------------------------------*/
60.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
61.   HAL_Init();
63.   /* USER CODE BEGIN Init */
65.   /* USER CODE END Init */
67.   /* Configure the system clock */
68.   SystemClock_Config();
70.   /* USER CODE BEGIN SysInit */
72.   /* USER CODE END SysInit */
74.   /* Initialize all configured peripherals */
75.   MX_GPIO_Init();
76.   MX_USART1_UART_Init();
77.   MX_FMC_Init();
79.   /* USER CODE BEGIN 2 */
80.   F7_SDRAM_Init(&hsdram1);
81.     Fill_Buffer(BufferSend, BUFFER_SIZE, 0x00000001);
82.    
83.     /* Write data to SDRAM */
84.     for (iLoop = 0; iLoop < BUFFER_SIZE; iLoop++)
85.   {
86.     *(__IO uint32_t*) (SDRAM_BANK_ADDR + WRITE_READ_ADDR + 4*iLoop) = BufferSend[iLoop];
87.   }
88.    
89.     /* Read data from SDRAM */
90.     for (iLoop = 0; iLoop < BUFFER_SIZE; iLoop++)
91.   {
92.     BufferReceive[iLoop] = *(__IO uint32_t*) (SDRAM_BANK_ADDR + WRITE_READ_ADDR + 4*iLoop);
93.   }
94.    
95.     for (iLoop = 0; iLoop < BUFFER_SIZE; iLoop++)
96.   {
97.         sprintf(bufferUSART,"%04ld: 0x%08lX \r\n",(unsigned long)iLoop,(unsigned long)BufferReceive[iLoop]);
98.         HAL_UART_Transmit(&huart1, (uint8_t*)bufferUSART,strlen(bufferUSART),0x1000);
99.         HAL_Delay(100);  
100.   }
102.   for (iLoop = 0; (iLoop < BUFFER_SIZE) && (statusData == 0); iLoop++)
103.   {
104.     if (BufferReceive[iLoop] != BufferSend[iLoop])
105.     {
106.       statusData++;
107.     }
108.   }
110.     /* Printf 32 bit status data */
111.     sprintf(bufferUSART,"Data veryfication: %zu \r\n",statusData);
112.     HAL_UART_Transmit(&huart1, (uint8_t*)bufferUSART,strlen(bufferUSART),0x1000);
113.    
114.     /* Check data */
115.     if (statusData > 0x0000)
116.   {
117.       HAL_UART_Transmit(&huart1, (uint8_t*)"Error\r\n",7,0x1000);
118.       HAL_Delay(200);
119.   }
120.   else if(statusData == 0x0000)
121.   {
122.     /* OK, turn on LED1 */
123.         HAL_UART_Transmit(&huart1, (uint8_t*)"Passed\r\n",8,0x1000);
124.   }
125.   /* USER CODE END 2 */
127.   /* Infinite loop */
128.   /* USER CODE BEGIN WHILE */
129.   while (1)
130.   {
131.   /* USER CODE END WHILE */
133.   /* USER CODE BEGIN 3 */
134.     HAL_GPIO_WritePin(GPIOI, GPIO_PIN_1, GPIO_PIN_RESET);
135.     HAL_Delay(1000);
136.     HAL_GPIO_WritePin(GPIOI, GPIO_PIN_1, GPIO_PIN_SET);
137.     HAL_Delay(1000);
138.   }
139.   /* USER CODE END 3 */
141. }

Pliki z projektem można znaleźć na dysku Google pod tym linkiem.