[2] STM32F429I - Discovery - SDRAM ISSI IS42S16400, CubeMx

Ten post chciałbym poświęcić na opisanie sposobu generacji oraz wykonania projektu, w oparciu o biblioteki hala oraz środowisko CubeMx w celu przygotowania projektu obsługującego pamieć SDRAM ISSI IS42S16400.

Cube Mx:

Poniżej przedstawię sposób wykonania projektu dla pamięci SDRAM w programie CubeMx.

Podłączenie pamięci na płytce SDRAM jest następujące:

• FMC SDCKE1 - PB5;
• FMC SDNE1 - PB6;
• FMC SDNWE - PC0;
• FMC D2 - PD0;
• FMC D3 - PD1;
• FMC D13 - PD8;
• FMC D14 - PD9;
• FMC D15 - PD10;
• FMC D0 - PD14;
• FMC D1 - PD15;
• FMC NBL0 - PE0;
• FMC NBL1 - PE1;
• FMC D4 - PE7;
• FMC D5 - PE8;
• FMC D6 - PE9;
• FMC D7 - PE10;
• FMC D8 - PE11;
• FMC D9 - PE12;
• FMC D10 - PE13;
• FMC D11 - PE14;
• FMC D12 - PE15;
• FMC A0 - PF0;
• FMC A1 - PF1;
• FMC A2 - PF2;
• FMC A3 - PF3;
• FMC A4 - PF4;
• FMC A5 - PF5;
• FMC SDNRAS - PF11;
• FMC A6 - PF12;
• FMC A7 - PF13;
• FMC A8 - PF14;
• FMC A9 - PF15;
• FMC A10 - PG0;
• FMC A11 - PG1;
• FMC BA0 - PG4;
• FMC BA1 - PG5;
• FMC SDCLK - PG8;
• FMC SDNCAS - PG15;

Konfiguracja FMC w pinout wygląda następująco:

Konfiguracja zegara wygląda następująco:

Ustawienie FMC w głównej konfiguracji prezentuje się następująco:

Programowanie:

Funkcja uruchamiająca zegary, wygląda następująco:

1. static void SystemClock_Config(void)
2. {
3.   RCC_ClkInitTypeDef RCC_ClkInitStruct;
4.   RCC_OscInitTypeDef RCC_OscInitStruct;
6.   /* Enable Power Control clock */
7.   __HAL_RCC_PWR_CLK_ENABLE();
9.   /* The voltage scaling allows optimizing the power consumption when the device is
10.      clocked below the maximum system frequency, to update the voltage scaling value
11.      regarding system frequency refer to product datasheet.  */
12.   __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
14.   /* Enable HSE Oscillator and activate PLL with HSE as source */
15.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
16.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
17.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
18.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
19.   RCC_OscInitStruct.PLL.PLLM = 8;
20.   RCC_OscInitStruct.PLL.PLLN = 360;
21.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
22.   RCC_OscInitStruct.PLL.PLLQ = 7;
23.   HAL_RCC_OscConfig(&RCC_OscInitStruct);
25.   /* Activate the Over-Drive mode */
26.   HAL_PWREx_EnableOverDrive();
28.   /* Select PLL as system clock source and configure the HCLK, PCLK1 and PCLK2
29.      clocks dividers */
30.   RCC_ClkInitStruct.ClockType = (RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2);
31.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
32.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
33.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;  
34.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;  
35.   HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5);
36. }

Procedura inicjalizacyjna przygotowana w programie Cube Mx wygląda następująco:

1. uint8_t SDRAM_Init(void)
2. {
3.     static uint8_t initialized = 0;
4.    
5.     /* SDRAM handler declaration */
6.     SDRAM_HandleTypeDef hsdram;
7.     FMC_SDRAM_TimingTypeDef SDRAM_Timing;
8.     FMC_SDRAM_CommandTypeDef command;
10.     /* If it is already initialized */
11.     if (initialized) { return 1; }
12.    
13.     /* Set instance */
14.     hsdram.Instance = FMC_SDRAM_DEVICE;
15.    
16.     /* Init pins of FMC controler */
17.     SDRAM_InitPins();
18.    
19.     /* Enable FMC clock */
20.     __HAL_RCC_FMC_CLK_ENABLE();
21.    
22.     /* Timing configuration for 90 Mhz of SD clock frequency (180Mhz/2) */
23.     /* TMRD: 2 Clock cycles */
24.     SDRAM_Timing.LoadToActiveDelay    = 2;          /* 1 clock cycle = 1 / 90MHz = 11.1ns */
25.     SDRAM_Timing.ExitSelfRefreshDelay = 7;          /* TXSR: min=70ns (6x11.10ns) */
26.     SDRAM_Timing.SelfRefreshTime      = 4;          /* TRAS: min=42ns (4x11.10ns) max=120k (ns) */
27.     SDRAM_Timing.RowCycleDelay        = 7;          /* TRC:  min=70 (6x11.10ns) */
28.     SDRAM_Timing.WriteRecoveryTime    = 2;          /* TWR:  2 Cycles */  
29.     SDRAM_Timing.RPDelay              = 2;          /* TRP:  20ns => 2x11.10ns */
30.     SDRAM_Timing.RCDDelay             = 2;          /* TRCD: 20ns => 2x11.10ns */
31.    
32.    
33.     /* FMC SDRAM control configuration */
34.     hsdram.Init.SDBank             = FMC_SDRAM_BANK2;
35.     hsdram.Init.ColumnBitsNumber   = FMC_SDRAM_COLUMN_BITS_NUM_8;
36.     hsdram.Init.RowBitsNumber      = FMC_SDRAM_ROW_BITS_NUM_12;
37.     hsdram.Init.MemoryDataWidth    = FMC_SDRAM_MEM_BUS_WIDTH_16;
38.     hsdram.Init.InternalBankNumber = FMC_SDRAM_INTERN_BANKS_NUM_4;
39.     hsdram.Init.CASLatency         = FMC_SDRAM_CAS_LATENCY_3;
40.     hsdram.Init.WriteProtection    = FMC_SDRAM_WRITE_PROTECTION_DISABLE;
41.     hsdram.Init.SDClockPeriod      = FMC_SDRAM_CLOCK_PERIOD_2;
42.     hsdram.Init.ReadBurst          = FMC_SDRAM_RBURST_DISABLE;
43.     hsdram.Init.ReadPipeDelay      = FMC_SDRAM_RPIPE_DELAY_1;
44.    
45.   /* Initialize the SDRAM controller */
46.   if(HAL_SDRAM_Init(&hsdram, &SDRAM_Timing) != HAL_OK)
47.   {
48.     /* Initialization Error */
49.   }
50.     /* SDRAM Init sequence */
51.    
52.     /* Configure a clock configuration enable command */
53.     command.CommandMode             = FMC_SDRAM_CMD_CLK_ENABLE;
54.     command.CommandTarget           = SDRAM_COMMAND_TARGET_BANK;
55.     command.AutoRefreshNumber       = 1;
56.     command.ModeRegisterDefinition  = 0;
57.    
58.     /* Send command */
59.     HAL_SDRAM_SendCommand(&hsdram, &command, SDRAM_TIMEOUT);
60.    
61.     /* Little delay */
62.     HAL_Delay(130);
63.    
64.     /* Configure a PALL (precharge all) command */
65.     command.CommandMode             = FMC_SDRAM_CMD_PALL;
66.     command.CommandTarget           = FMC_SDRAM_CMD_TARGET_BANK2;
67.     command.AutoRefreshNumber       = 1;
68.     command.ModeRegisterDefinition  = 0;
69.    
70.     /* Send the command */
71.     HAL_SDRAM_SendCommand(&hsdram, &command, SDRAM_TIMEOUT);
73.     /* Configure a Auto-Refresh command */
74.     command.CommandMode             = FMC_SDRAM_CMD_AUTOREFRESH_MODE;
75.     command.CommandTarget           = FMC_SDRAM_CMD_TARGET_BANK2;
76.     command.AutoRefreshNumber       = 4;
77.     command.ModeRegisterDefinition  = 0;
78.    
79.     /* Send the command */
80.     HAL_SDRAM_SendCommand(&hsdram, &command, SDRAM_TIMEOUT);
81.    
82.     /* Configure a load Mode register command */
83.     command.CommandMode             = FMC_SDRAM_CMD_LOAD_MODE;
84.     command.CommandTarget           = SDRAM_COMMAND_TARGET_BANK;
85.     command.AutoRefreshNumber       = 1;
86.     command.ModeRegisterDefinition  = (uint32_t)SDRAM_REG_VALUE;
87.    
88.     /* Wait until the SDRAM controller is ready */
89.     HAL_SDRAM_SendCommand(&hsdram, &command, SDRAM_TIMEOUT);
91.     /* Set the refresh rate counter */
92.     HAL_SDRAM_ProgramRefreshRate(&hsdram, SDRAM_REFRESH_COUNT);
94.     HAL_Delay(100);
95.    
96.     /* Check if there is nor Error in initialization */
97.     SDRAM_Write_8_Bit(0x20, 0xA5);
98.    
99.     /* Read and check */
100.     if (SDRAM_Read_8_Bit(0x20) == 0xA5) {
101.         initialized = 1;
102.         return 1;
103.     }
104.    
105.     /* Not initialized ERROR */
106.     initialized = 0;
107.    
108.     /* ERROR */
109.     return 0;
110. }

W przypadku wykorzystywania funkcji wygenerowanej przez program, która wygląda następująco:

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

To aby uruchomić poprawnie SDRAM należy jeszcze przesłać odpowiednie komendy do układu, wywołuje się funkcjami umieszczonymi w bibliotece:

1. //=================================================================================
2. uint8_t SDRAM_Set_Operation(void)
3. {
4.     FMC_SDRAM_CommandTypeDef command;
5.        
6.     /* Configure a clock configuration enable command */
7.     command.CommandMode             = FMC_SDRAM_CMD_CLK_ENABLE;
8.     command.CommandTarget           = FMC_SDRAM_CMD_TARGET_BANK2;
9.     command.AutoRefreshNumber       = 1;
10.     command.ModeRegisterDefinition  = 0;
11.    
12.     /* Send command */
13.     HAL_SDRAM_SendCommand(&hsdram1, &command, SDRAM_TIMEOUT);
14.    
15.     /* Little delay */
16.     HAL_Delay(130);
17.    
18.     /* Configure a PALL (precharge all) command */
19.     command.CommandMode             = FMC_SDRAM_CMD_PALL;
20.     command.CommandTarget           = FMC_SDRAM_CMD_TARGET_BANK2;
21.     command.AutoRefreshNumber       = 1;
22.     command.ModeRegisterDefinition  = 0;
23.    
24.     /* Send the command */
25.     HAL_SDRAM_SendCommand(&hsdram1, &command, SDRAM_TIMEOUT);
27.     /* Configure a Auto-Refresh command */
28.     command.CommandMode             = FMC_SDRAM_CMD_AUTOREFRESH_MODE;
29.     command.CommandTarget           = FMC_SDRAM_CMD_TARGET_BANK2;
30.     command.AutoRefreshNumber       = 4;
31.     command.ModeRegisterDefinition  = 0;
32.    
33.     /* Send the command */
34.     HAL_SDRAM_SendCommand(&hsdram1, &command, SDRAM_TIMEOUT);
35.    
36.     /* Configure a load Mode register command */
37.     command.CommandMode             = FMC_SDRAM_CMD_LOAD_MODE;
38.     command.CommandTarget           = FMC_SDRAM_CMD_TARGET_BANK2;
39.     command.AutoRefreshNumber       = 1;
40.     command.ModeRegisterDefinition  = (uint32_t)SDRAM_REG_VALUE;
41.    
42.     /* Wait until the SDRAM controller is ready */
43.     HAL_SDRAM_SendCommand(&hsdram1, &command, SDRAM_TIMEOUT);
45.     /* Set the refresh rate counter */
46.     HAL_SDRAM_ProgramRefreshRate(&hsdram1, SDRAM_REFRESH_COUNT);
48.   HAL_Delay(100);
49.    
50.     if(Check_If_SDRAM_Works_OK() == 1)
51.     {
52.         return 1;
53.     }
54.    
55.     /* ERROR */
56.     return 0;
57. }
58. //=================================================================================
59. static uint8_t Check_If_SDRAM_Works_OK(void)
60. {
61.     static uint8_t check = 0;
62.    
63.     SDRAM_Write_8_Bit(0x20, 0xA5);
64.    
65.     if (SDRAM_Read_8_Bit(0x20) == 0xA5) {
66.         check = 1;
67.         return check;
68.     }
69.    
70.     /* Not initialized ERROR */
71.     check = 0;
72.    
73.     return check;
74. }

Włączenie podłączonych wyprowadzeń wykonuje się za pomocą następującej instrukcji:

1. /* Private functions */
2. static void SDRAM_InitPins(void)
3. {
4.   GPIO_InitTypeDef GPIO_InitStruct;
5.    
6.   /* Enable clocks */
7.   __HAL_RCC_GPIOB_CLK_ENABLE();
8.   __HAL_RCC_GPIOC_CLK_ENABLE();
9.   __HAL_RCC_GPIOD_CLK_ENABLE();
10.   __HAL_RCC_GPIOE_CLK_ENABLE();
11.   __HAL_RCC_GPIOF_CLK_ENABLE();
12.   __HAL_RCC_GPIOG_CLK_ENABLE();
13.    
14.   /* GPIO B */
15.   GPIO_InitStruct.Pin = GPIO_PIN_5 | GPIO_PIN_6;
16.   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
17.   GPIO_InitStruct.Pull = GPIO_NOPULL;
18.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
19.   GPIO_InitStruct.Alternate = GPIO_AF12_FMC;
20.   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
21.    
22.   /* GPIO C */
23.   GPIO_InitStruct.Pin = GPIO_PIN_0;
24.   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
25.   GPIO_InitStruct.Pull = GPIO_NOPULL;
26.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
27.   GPIO_InitStruct.Alternate = GPIO_AF12_FMC;
28.   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
30.   /* GPIO D */ 
31.   GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_8 |
32.                         GPIO_PIN_9 | GPIO_PIN_10 | GPIO_PIN_14 | GPIO_PIN_15;
33.   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
34.   GPIO_InitStruct.Pull = GPIO_NOPULL;
35.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
36.   GPIO_InitStruct.Alternate = GPIO_AF12_FMC;
37.   HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
38.    
39.   /* GPIO E */
40.   GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_7 |
41.                         GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10 |
42.                         GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13 |
43.                         GPIO_PIN_14 | GPIO_PIN_15;
44.   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
45.   GPIO_InitStruct.Pull = GPIO_NOPULL;
46.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;    
47.   GPIO_InitStruct.Alternate = GPIO_AF12_FMC;
48.   HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
49.    
50.   /* GPIO F */
51.   GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 |
52.                         GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_11 |
53.                         GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15;
54.   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
55.   GPIO_InitStruct.Pull = GPIO_NOPULL;
56.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
57.   GPIO_InitStruct.Alternate = GPIO_AF12_FMC;
58.   HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);
59.    
60.   /* GPIO G */
61.   GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_4 |
62.                         GPIO_PIN_5 | GPIO_PIN_8 | GPIO_PIN_15;
63.   GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
64.   GPIO_InitStruct.Pull = GPIO_NOPULL;
65.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;    
66.   GPIO_InitStruct.Alternate = GPIO_AF12_FMC;
67.   HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);
68. }

Włączenie pinów odbywa się albo poprzez CubeMx gdzie wybiera się odpowiednie wyprowadzenia wraz z wszystkimi ustawieniami. W przypadku korzystania z funkcji z biblioteki, procedura inicjalizująca odwołuje się do funkcji statycznej, która ustawia wyprowadzenia dla pamięci.

Teraz funkcje pozwalające na wpisywanie podanych danych do programu. Funkcje zapisu i odczytu danych 8 bitowych:

1. //=================================================================================
2. /*
3.  * @brief   Write 8 bit data value into SDRAM
4.  * @param   addressOffset from start value                     
5.  *          dataToSave data that will be save in SDRAM
6.  * @ret     none
7.  */
8. inline void SDRAM_Write_8_Bit(uint32_t addressOffset, uint8_t dataToSave){
9.     (*(__IO uint8_t *) (SDRAM_START_ADR + (addressOffset)) = (dataToSave));
10. }
11. //=================================================================================
12. /*
13.  * @brief   read 8 bit data value from SDRAM
14.  * @param   addressOffset from start value                     
15.  * @ret     value that has been read from Sdram
16.  */
17. inline uint8_t SDRAM_Read_8_Bit(uint32_t addressOffset){
18.     return (*(__IO uint8_t *) (SDRAM_START_ADR + (addressOffset)));
19. }

Funkcje zapisu i odczytu danych 16 bitowych:

1. //=================================================================================
2. /*
3.  * @brief   Write 16 bit data value into SDRAM
4.  * @param   addressOffset from start value                     
5.  *                  dataToSave data that will be save in SDRAM
6.  * @ret         none
7.  */
8. inline void SDRAM_Write_16_Bit(uint32_t addressOffset, uint16_t dataToSave) {
9.     (*(__IO uint16_t *) (SDRAM_START_ADR + (addressOffset)) = (dataToSave));
10. }
11. //=================================================================================
12. /*
13.  * @brief   Read 16 bit data value into SDRAM
14.  * @param   addressOffset from start value                     
15.  * @ret         none
16.  */
17. inline uint16_t SDRAM_Read_16_Bit(uint32_t address){
18.     return (*(__IO uint16_t *) (SDRAM_START_ADR + (address)));
19. }

Funkcje zapisu i odczytu danych 32 bitowych:

1. //=================================================================================
2. /*
3.  * @brief   Write 32 bit data value into SDRAM
4.  * @param   addressOffset from start value                     
5.  *                  dataToSave data that will be save in SDRAM
6.  * @ret         none
7.  */
8. inline void SDRAM_Write_32_Bit(uint32_t addressOffset, uint32_t dataToSave){
9.     (*(__IO uint32_t *) (SDRAM_START_ADR + (addressOffset)) = (dataToSave));
10. }
11. //=================================================================================
12. /*
13.  * @brief   Reads 32 bit data value into SDRAM
14.  * @param   addressOffset from start value                     
15.  *                  dataToSave data that will be save in SDRAM
16.  * @ret         none
17.  */
18. inline uint32_t SDRAM_Read_32_Bit(uint32_t address){
19.     return (*(__IO uint32_t *) (SDRAM_START_ADR + (address)));
20. }

Funkcje zapisu i odczytu danych float:

1. //=================================================================================
2. /*
3.  * @brief   Write float bit data value into SDRAM
4.  * @param   addressOffset from start value                     
5.  *                  dataToSave data that will be save in SDRAM
6.  * @ret         none
7.  */
8. inline void SDRAM_Write_Float(uint32_t addressOffset, uint32_t dataToSave){
9.     (*(__IO float *) (SDRAM_START_ADR + (addressOffset)) = (dataToSave));
10. }
11. //=================================================================================
12. /*
13.  * @brief   Reads float bit data value into SDRAM
14.  * @param   addressOffset from start value                     
15.  *                  dataToSave data that will be save in SDRAM
16.  * @ret         none
17.  */
18. inline float SDRAM_Read_Float(uint32_t addressOffset){
19.     return (*(__IO float *) (SDRAM_START_ADR + (addressOffset)));
20. }

Pętla główna programu wygląda następująco:

1. /* Private function prototypes -----------------------------------------------*/
2. void SystemClock_Config(void);
3. static void MX_GPIO_Init(void);
4. static void MX_FMC_Init(void);
5. static void MX_USART1_UART_Init(void);
7. /* USER CODE BEGIN PFP */
8. /* Private function prototypes -----------------------------------------------*/
10. /* USER CODE END PFP */
12. /* USER CODE BEGIN 0 */
13. uint32_t WriteBuffer[32];
14. uint32_t ReadBuffer[32];
15. /* USER CODE END 0 */
17. int main(void)
18. {
19.   /* USER CODE BEGIN 1 */
20.   uint8_t i = 0;
21.   /* USER CODE END 1 */
23.   /* MCU Configuration----------------------------------------------------------*/
25.   /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
26.   HAL_Init();
28.   /* USER CODE BEGIN Init */
30.   /* USER CODE END Init */
32.   /* Configure the system clock */
33.   SystemClock_Config();
35.   /* USER CODE BEGIN SysInit */
37.   /* USER CODE END SysInit */
39.   /* Initialize all configured peripherals */
40.   MX_GPIO_Init();
41.   MX_FMC_Init();
42.     SDRAM_Set_Operation();
43.   MX_USART1_UART_Init();
44.        
45.   /* USER CODE BEGIN 2 */
46.     /* When using functions from library */
47.     //SDRAM_Init();
48.    
49.     /* Fill write data */
50.     for (i = 0; i < 255; i++) {
51.         WriteBuffer[i] = 0xA5;
52.        
53.         /* Write to SDRAM */
54.         SDRAM_Write_32_Bit(16 * i, WriteBuffer[i]);
55.     }
57.     /* Read data from SDRAM */
58.     for (i = 0; i < 255; i++) {
59.         ReadBuffer[i] = SDRAM_Read_32_Bit(16 * i);
60.     }
61.         /* Memory compare */
62.     if (memcmp((uint8_t *)ReadBuffer, (uint8_t *)WriteBuffer, sizeof(ReadBuffer)) == 0) {
63.         /* SDRAM is OK */
64.         HAL_GPIO_WritePin(GPIOG, GPIO_PIN_13, GPIO_PIN_SET);
65.     } else {
66.         /* SDRAM failed */
67.         HAL_GPIO_WritePin(GPIOG, GPIO_PIN_14, GPIO_PIN_SET);
68.     }
69.    
70.   /* USER CODE END 2 */
72.   /* Infinite loop */
73.   /* USER CODE BEGIN WHILE */
74.   while (1)
75.   {
76.   /* USER CODE END WHILE */
78.   /* USER CODE BEGIN 3 */
80.   }
81.   /* USER CODE END 3 */
82. }

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