[45] STM32F4 - Discovery - Makefile, Visual Studio Code

W tym poście opiszę sposób generowania projektu jako Makefile oraz obsługę projektu z edytora VSC.

[Źródło: http://www.st.com/en/evaluation-tools/stm32f4discovery.html]

Generacja projektu Makefile:

Projekt należy wygenerować jako Makefile:

Następnie projekt otwieram w Visual Studio Code. Gdzie w terminalu generacja projektu odbywa się po wpisaniu następującego komunikatu:

1. mingw32-make.exe

Zostanie stworzony folder zawierający wygenerowane pliki:

Teraz można do projektu dodać prostą obsługę diod wbudowanych w płycie:

1.   while (1)
2.   {
3.     /* USER CODE END WHILE */
4.  
5.     /* USER CODE BEGIN 3 */
6.     HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_12);
7.     HAL_Delay(500);
8.     HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_13);
9.     HAL_Delay(500);
10.     HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_14);
11.     HAL_Delay(500);
12.     HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_15);
13.     HAL_Delay(500);
14.   }

Następnie ponowne wygenerowanie projektu:

Projekt można też uruchomić wykorzystując Make for Windows. W tym przypadku po wypakowaniu Binaries i Dependencies należy je umieścić w jednym folderze. Aby uruchomić projekt należy ścieżkę do katalogu bin do zmiennych środowiskowych i wywołać w folderze z projektem. Można też to wykonać w następujący sposób:

1. C:\lokalizacja\make-3.81\bin\make.exe

Wynik działania powyższej instrukcji jest następujący:

Teraz tak utworzony plik *.bin można wgrać na płytkę mikrokontrolera wykorzystując program STM32 ST-Link Utility. 

Konfiguracja:

Projekt wymaga konfiguracji w celu usunięcia błędów wyświetlanych w VS:

Aby się ich pozbyć należy do projektu dołożyć plik konfigurowalny JSON (c_cpp_properties.json):

Domyślnie stworzony plik wygląda następująco:

1. {
2.     "configurations": [
3.         {
4.             "name": "Win32",
5.             "includePath": [
6.                 "${workspaceFolder}/**"
7.             ],
8.             "defines": [
9.                 "_DEBUG",
10.                 "UNICODE",
11.                 "_UNICODE"
12.             ],
13.             "windowsSdkVersion": "10.0.19041.0",
14.             "compilerPath": "C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Community\\VC\\Tools\\MSVC\\14.16.27023\\bin\\Hostx64\\x64\\cl.exe",
15.             "cStandard": "c17",
16.             "cppStandard": "c++17",
17.             "intelliSenseMode": "windows-msvc-x64",
18.             "configurationProvider": "ms-vscode.makefile-tools"
19.         }
20.     ],
21.     "version": 4
22. }

Plik po edycji powinien wyglądać następująco:

1. {
2.     "configurations": [
3.         {
4.             "name": "STM32 F4",
5.             "includePath": [
6.                 "${workspaceFolder}/**"
7.             ],
8.             "defines": [
9.                 "_DEBUG",
10.                 "UNICODE",
11.                 "_UNICODE",
12.                 "USE_HAL_DRIVER",
13.                 "STM32F407xx"
14.             ],
15.             "intelliSenseMode": "gcc-arm",
16.             "compilerPath": "C:/Program Files (x86)/GNU Arm Embedded Toolchain/
17. 10 2020-q4-major/bin/arm-none-eabi-gcc.exe",
18.             "compilerArgs": [
19.                 "-mcpu=cortex-m4",
20.                 "-mthumb",
21.                 "-mfpu=fpv4-sp-d16",
22.                 "-mfloat-abi=hard"
23.             ],
24.             "cStandard": "c11",
25.             "cppStandard": "c++17",
26.             "configurationProvider": "ms-vscode.makefile-tools"
27.         }
28.     ],
29.     "version": 4
30. }

Do powyższego pliku dołączyłem dane odczytane z pliku Makefile.

• Nazwa konfiguracji - tutaj wprowadzamy przykładowy ciąg znaków,
• Ścieżki do plików - powyżej zostały dodane wszystkie pliki znajdujące się w strukturze projektu. Można też dołożyć ścieżki zdefiniowane w C_SOURCES w pliku Makefile. 
• Definicję preprocesora,
• Wykorzystywany kompilator,
• Ścieżkę do pliku kompilatora,
• Argumenty kompilatora skopiowane z pliku Makefile CFLAGS.
• Standard języka C,
• Standard języka C++,

Więcej informacji można znaleźć pod tym linkiem. 

Po wprowadzeniu zmian błędy nie będą już widoczne w programie VS. 

Openocd:

Openocd pozwala na debugowanie oraz wgrywanie kodu do mikrokontrolera. Pakiet można pobrać pod tym linkiem.

W celu wgrania kodu do układu należy wykonać pewne modyfikacje w pliku Makefile, przez dołożenie komendy flash:

1. flash: all
2.     openocd -f interface/stlink.cfg -f target/stm32f4x.cfg -c "program $(BUILD_DIR)/$(TARGET).elf verify reset exit"

Powyższa linia wywołuje openocd z konfiguracją stlink dla mikrokontrolerów STM. Następnie wybierane jest urządzenie na jakie ma być wgrywany program. Ostatnia część podaje ścieżkę do programu z weryfikacją kodu po wgraniu oraz resetem mikrokontrolera do przeładowania programu.

Wywołanie komendy wraz z wynikiem działania operacji wygląda następująco:

W celu uruchomienia debuggera przez VSC należy zainstalować pakiet Cortex-Debug wraz z pakietem dla miktokontrolerów F4 Cortex-Debug: Device Support Pack - STM32F4. 

Niestety w tym pakiecie nie będzie konfiguracji dla układu STM32F407VG. Można ją pobrać z serwisu GitHub pod tym linkiem. Dla testowanego przezemnie układu będzie to STM32F407.svd. Pobrany plik należy umieścić w głównym folderze projektu.

Kolejnym elementem jest dołożenie pliku konfiguracyjnego dla OpenOCD oraz Cortex-Debug. W tym celu należy stworzyć plik .vscode/launch.json. Plik ten będzie zawierał instrukcję do debugowania programu. 

1. {
2.     "version": "0.4.4",
3.     "configurations": [
4.         {
5.             "name": "Cortex Debug",
6.             "cwd": "${workspaceRoot}",
7.             "executable": "./build/stm32f407_makefile.elf",
8.             "request": "launch",
9.             "type": "cortex-debug",
10.             "servertype": "openocd",
11.             "device": "STM32F407VG",
12.             "configFiles": [
13.                 "interface/stlink.cfg",
14.                 "target/stm32f4x.cfg"
15.             ],
16.             "svdFile": "./STM32F407.svd"
17.         }
18.     ]
19. }

Uruchomiona opcja debugowania wygląda następujaco:

Projekt można pobrać z dysku Google pod tym linkiem.