Vs code stm32 настройка windows - Windowsa.top - ваш верный помощник с OS Windows

Статья о настройке Visual Studio Code для работы с микроконтроллерами STM32 в среде Windows используя минимальный набор файлов без HAL библиотек, данный шаблон одинаково хорошо подходит для Windows и Linux.

Описанный шаблон можно легко расширить. Для примера Я использую отладочную плату STM32F407G-DISC1 с чипом STM32F407VGT6, но если у Вас что то другое, то данный пример легко можно изменить под ваши задачи.

Список необходимого:

Visual Studio Code
Набор инструментов под ARM
Openocd — бесплатный отладчик.
Менеджер пакетов «Minimalist GNU for Windows»
CMAKE
Исходники CMSIS и другое бирем с гита

Visual Studio Code

После установки (ссылка), добовляем необходимые расширения C/C++ и Cortex-Debug:

C/C++ IntelliSense, debugging, and code browsing.

Cortex-Debug ARM Cortex-M GDB Debugger support for VSCode

Картинка с сайта: blog.grugu.ru

Набора инструментов ARM

Набор инструментов под ARM (качаем на оф. сайте)

Не забудте поставить галку на пункте «Добавить путь в переменные окружения»

Иначе придется вручную добавлять путь в переменную Path:

C:\Program Files (x86)\GNU Arm Embedded Toolchain\10 2021.10\bin

Для проверки наберите в командной строке

arm-none-eabi-gcc -v

Получаем вывод установленных компонентов, если этого не произошло, то проверяем Path в переменных ОС.

Установка Openocd

penocd — отладчик, качаем тут версию для Windows

Прямая ссылка на актуальную версию в момент написания статьи

Распаковываем в Program Files например..

Настройка Переменных Windows для Openocd

Добавляем путь до отладчика в переменную Path

Картинка с сайта: blog.grugu.ru

Проверяем вывод отладчика набрав в командной строке openocd. Если что-то пошло не так, то проверяйте добавленные пути.

MinGW Installation Manager

Устанавливаем менеджер пакетов «Minimalist GNU for Windows» скачать

После выбираем mingw32-make-bin и жмем Apply Changes для установки. mingw32-make-bin необходим для сборки прокта.

CMAKE

качаем тут https://cmake.org/download/

CMake нужен для описания правил сборки проекта.

Настройка шаблона проекта

Данная информация скорее предназначина для того если у вас другой микроконтрллер и вы хотитите собрать свой шаблон ориентируясь на пример.

Готовый шаблон выложен на https://bitbucket.org/ivankoff/stm32f407_cmsis/src/master/

Вот така структура каталогов должна получиться для STM32F407. Соответственно используя другой микроконтроллер следует использовать соответствующие файлы.

stm32f407_cmsis
│   build_all.bat
│   build_all.sh
│   build_debug.bat
│   build_debug.sh
│   build_release.bat
│   build_release.sh
│   clean.bat
│   clean.sh
│   CMakeLists.txt
│   gcc_cm4f.cmake
│   README.md
│   STM32F407.svd
│
├───.vscode
│       .cortex-debug.peripherals.state.json
│       .cortex-debug.registers.state.json
│       c_cpp_properties.json
│       launch.json
│       settings.json
│       tasks.json
│
├───app
│       main.c
│
└───STM32F407_sdk
    └───platform
        ├───CMSIS
        │   └───Core
        │       └───Include
        │               cmsis_compiler.h
        │               cmsis_gcc.h
        │               cmsis_version.h
        │               core_cm4.h
        │               mpu_armv7.h
        │
        └───Device
            └───ST
                └───STM32F407
                    │   License.md
                    │
                    ├───Include
                    │       stm32f407xx.h
                    │       stm32f4xx.h
                    │       system_stm32f4xx.h
                    │
                    └───Source
                        │   system_stm32f4xx.c
                        │
                        └───GCC
                                startup_STM32F407.s
                                STM32F407.ld

Чтобы не описывать покажу что и откуда нужно взять и куда переместить и переименовать

Скрипт для линковщика (*.ld)

STM32CubeF4\Projects\STM32F4-Discovery\Templates_LL\SW4STM32\STM32F4-Discovery\STM32F407VGTx_FLASH.ld

копируем и переименовываем в

stm32f407_cmsis\STM32F407_sdk\platform\Device\ST\STM32F407\Source\GCC\STM32F407.ld

Файл startup

STM32CubeF4\Drivers\CMSIS\Device\ST\STM32F4xx\Source\Templates\gcc\startup_stm32f407xx.s

копируем и переименовываем в

stm32f407_cmsis\STM32F407_sdk\platform\Device\ST\STM32F407\Source\GCC\startup_STM32F407.s

Заголовочные файлы микроконтроллера

STM32CubeF4\Drivers\CMSIS\Device\ST\STM32F4xx\Include\stm32f4xx.h

копируем в

stm32f407_cmsis\STM32F407_sdk\platform\Device\ST\STM32F407\Include\stm32f4xx.h

STM32CubeF4\Drivers\CMSIS\Device\ST\STM32F4xx\Include\stm32f407xx.h

копируем в

stm32f407_cmsis\STM32F407_sdk\platform\Device\ST\STM32F407\Include\stm32f407xx.h

STM32CubeF4\Drivers\CMSIS\Device\ST\STM32F4xx\Include\system_stm32f4xx.h

копируем в

stm32f407_cmsis\STM32F407_sdk\platform\Device\ST\STM32F407\Include\system_stm32f4xx.h

STM32CubeF4\Drivers\CMSIS\Device\ST\STM32F4xx\Source\Templates\system_stm32f4xx.c

копируем в

stm32f407_cmsis\STM32F407_sdk\platform\Device\ST\STM32F407\Source\system_stm32f4xx.c

CMSIS : Заголовочные файлы ядра

STM32CubeF4\Drivers\CMSIS\Core\Include\cmsis_compiler.h

копируем в

stm32f407_cmsis\STM32F407_sdk\platform\CMSIS\Core\Include\cmsis_compiler.h

STM32CubeF4\Drivers\CMSIS\Core\Include\cmsis_gcc.h

копируем в

stm32f407_cmsis\STM32F407_sdk\platform\CMSIS\Core\Include\cmsis_gcc.h

STM32CubeF4\Drivers\CMSIS\Core\Include\cmsis_version.h

копируем в

stm32f407_cmsis\STM32F407_sdk\platform\CMSIS\Core\Include\cmsis_version.h

STM32CubeF4\Drivers\CMSIS\Core\Include\core_cm4.h

копируем в

stm32f407_cmsis\STM32F407_sdk\platform\CMSIS\Core\Include\core_cm4.h

Файл модуля управления защитой памяти STM32

STM32CubeF4\Drivers\CMSIS\Core\Include\mpu_armv7.h

копируем в

stm32f407_cmsis\STM32F407_sdk\platform\CMSIS\Core\Include\mpu_armv7.h

CMSIS-SVD файл микроконтроллера

stm32f407_cmsis\STM32F407.svd

скачан отсюда: https://github.com/posborne/cmsis-svd/blob/master/data/STMicro/STM32F407.svd

Также там-же можно скачать файл svd если у вас другая модель микроконтроллера https://github.com/posborne/cmsis-svd/tree/master/data/STMicro

Описаник файлов конфигурации VSCode

В каталоге .vscode находятся файлы конфигурации для работы в VSCode

tasks.json — содержит команды для сборки различных конфигурация (Build All, Build Debug, Build Release, Clean Project). Чтобы вызвать определенную конфигурацию для сборки проекта нажмите CTRL+SHIFT+B. В самом файле находятся только ссылки на скрипты для сборки проекта.

{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "Build All",
            "type": "shell",
            "command": "${workspaceFolder}/build_all",
            "group": "build"
        },
        {
            "label": "Build Debug",
            "type": "shell",
            "command": "${workspaceFolder}/build_debug",
            "group": "build"
        },
        {
            "label": "Build Release",
            "type": "shell",
            "command": "${workspaceFolder}/build_release",
            "group": "build"
        },
        {
            "label": "Clean Project",
            "type": "shell",
            "command": "${workspaceFolder}/clean",
            "group": "build"
        }
    ]
}

launch.json

settings.json

c_cpp_properties.json

.cortex-debug.peripherals.state.json

.cortex-debug.registers.state.json

Подключение платы и тестирование

Источник

Время на прочтение7 мин

Количество просмотров41K

На хабре уже есть немало информации об отладке МК в VSCode на Linux (тыц, тыц), также было написано как настроить тулчейн для работы под Windows в QT Creator, Eclipse, etc.

Пришло и моё время написать похожую статью, но для VS Code и под Widnows.

Инициализация проекта будет проводиться с помощью STM32CubeMX. Сборкой будет управлять CMake с тулчейном stm32-cmake. В качестве компилятора используется ARM GNU Toolchain. Тестовым стендом является NUCLEO-F446ZE.

Источниками вдохновения послужили:

Репозиторий stm32-template
Видео EbeddedGeek
Видео Matej Blagšič

Предисловие окончено, приступаем к настройке.

Установка необходимых утилит

Для удобства установки будем пользоваться пакетным менеджером Scoop.

Для его установки достаточно прописать в powershell следующие команды:

Set-ExecutionPolicy RemoteSigned -Scope CurrentUser;
irm get.scoop.sh | iex

Добавим необходимые репозитории

scoop bucket add main
scoop bucket add extras

И, наконец, сами программы:

scoop install meson
scoop install ninja
scoop install cmake
scoop install llvm
scoop install gcc-arm-none-eabi
scoop install stlink
scoop install openocd
scoop install git

meson, ninja, cmake, llvm и gcc-arm-none-eabi используются для конфигурации и сборки проекта, stlink и openocd являются gdb-серверами, git необходим для подключения различных тулчейнов.

P.S.

Если у вас уже есть что-то из этого и вы можете вызвать его через консоль (т.е. программа добавлена в path) то советую либо убрать её из скрипта либо удалить у себя, и установить через scoop.

Настройка VS Code

Для работы потребуются установить в VS Code следующие расширения:

C/C++ Extension Pack
CMake
CMake Tools
Cortex-Debug
Memory View
Tasks
Command Variable

Также рекомендую Doxygen Documentation

Инициализация проекта

Открываем CubeMX и создаем проект для нашей платы. Всю периферию оставляем настроенной по умолчанию.

В параметрах проекта (Project Manajer) выбираем Make в качестве тулчейна

Настройки Project Manajer

В параметрах генератора кода указываем подключение бибилотек только в виде ссылок

Настройки Code Generator

Настройка системы сборки

Открываем папку проекта в VS Code и вызываем терминал командой Ctr+~
Скачиваем stm32-cmake

git clone --recurse-submodules -j8 https://github.com/ObKo/stm32-cmake.git

Также потребуются файлы .clang-format, .clang-tidy , fetch_svd.cmake , и CMakeLists.txt из репозитория stm32-template. Для удоства клонируем его в соседнюю директорию.

git clone https://github.com/Dooez/stm32-template.git ../stm32-template

.clang-format, .clang-tidy необходимы LLVM, а fetch_svd.cmake используется для поиска файла описания регистров конкретного микроконтроллера.

Отредактируем CMakeLists.txt под наш проект.

Изменим переменную MCU на STM32F446ZE

set(MCU STM32F446ZE)

По умолчанию «кубик» инициализирует на плате NUCLEO-F446ZE USART3, USB_OTG_FS и несколько GPIO. Добавим библиотеки в проект, для этого необходимо для сборки прописать команду target_link_libraries. Также добавим библиотеку CMSIS и, для уменьшения размеров прошивки, Newlib Nano и NoSys

target_link_libraries(${PROJECT_NAME}
    HAL::STM32::${MCU_FAMILY}::RCC
    HAL::STM32::${MCU_FAMILY}::GPIO
    HAL::STM32::${MCU_FAMILY}::UART
    HAL::STM32::${MCU_FAMILY}::CORTEX
    HAL::STM32::${MCU_FAMILY}::LL_USB
    HAL::STM32::${MCU_FAMILY}::PCD
    HAL::STM32::${MCU_FAMILY}::PCDEx
    CMSIS::STM32::${MCU_MODEL}
    STM32::Nano
    STM32::NoSys
)

Чтобы CMake мог увидеть файлы, сгенерированные кубиком, необходимо добавить их в Include Path и явно указать исполняемые c/cpp файлы.

add_executable(${PROJECT_NAME} 
Core/Src/main.c
Core/Src/stm32f4xx_it.c
Core/Src/stm32f4xx_hal_msp.c
) 

target_include_directories(${PROJECT_NAME} PRIVATE 
${CMAKE_CURRENT_SOURCE_DIR} 
${CMAKE_CURRENT_SOURCE_DIR}/Core/Inc 
${CMAKE_CURRENT_SOURCE_DIR}/Core/Src
)

main.c содержит, собственно, функцию main(), в stm32f4xx_it.c находится функция, которая считает количество срабатываний SysTick, без которой не будут работать такие функции как HAL_Delay(), а в stm32f4xx_hal_msp.c содержится часть инициализации периферии.

Также для уменьшения размера исполняемого файла, добоавим следующие директивы компилятора:

target_compile_options(${PROJECT_NAME} PUBLIC -Os -fno-exceptions -fno-rtti)

Настройка проекта под VS Code

Нажимаем сочетание клавиш Ctrl+Shift+P и в появившейся строке находим
Preferences: Open Workspace Settings (JSON)

В создавшемся файле .vscode/settings.json указаны параметры для расширений и корректного отображения кода. Пишем:

{
  "cmake.generator": "Ninja",
  "cmake.configureEnvironment": {
    "CMAKE_EXPORT_COMPILE_COMMANDS": "on"
  },
  "C_Cpp.default.intelliSenseMode": "gcc-arm",
  "cortex-debug.gdbPath": "arm-none-eabi-gdb",
  "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools"
}

Далее по тому же сочетанию находим Tasks: Configure Task и выбираем cmake build

В создавшийся файл .vscode/tasks.json добавляем задания для прошивки и очистки памяти микроконотроллера с помощью st-flash. Итоговый файл tasks.json выглядит следующим образом:

{
  "version": "2.0.0",
  "tasks": [
    {
      "type": "cmake",
      "label": "CMake: build",
      "command": "build",
      "targets": [
          "ALL_BUILD"
      ],
      "problemMatcher": [],
      "group": "build"
    },
    {
      "type": "shell",
      "label": "flash",
      "command": "st-flash",
      "args": [
        "--reset",
        "write",
        "${input:workspaceFolderForwardSlash}/build/${workspaceFolderBasename}.bin",
        "0x8000000"
      ],
      "options": {
        "cwd": "${workspaceFolder}/build"
      },
      "dependsOn": "CMake: build",
      "problemMatcher": [],
      "group": {
        "kind": "build",
        "isDefault": true
      },
      "detail": "Builds project and flashes firmware."

    },
    {
      "type": "shell",
      "label": "erase",
      "command": "st-flash",
      "args": [
        "--connect-under-reset",
        "erase"
      ],
      "detail": "mass erase of chip"
    }
  ],
  
  "inputs": [
    {
      "id": "workspaceFolderForwardSlash",
      "type": "command",
      "command": "extension.commandvariable.transform",
      "args": {
        "text": "${workspaceFolder}",
        "find": "\\\\",
        "replace": "/",
        "flags": "g"
      }
    }
  ]
}

Также при желании можно добавить команду для прошивки с помощью OpenOCD

Для STM32F4 она выглядит следующим образом

{
      "type": "shell",
      "label": "flash-openocd",
      "command": "openocd -f interface/stlink.cfg -f target/stm32f4x.cfg -c 'program ${input:workspaceFolderForwardSlash}/build/${workspaceFolderBasename}.bin verify reset exit' ",
      "dependsOn": "CMake: build",
      "problemMatcher": [],
      "group": {
        "kind": "build",
        "isDefault": true
      },
      "detail": "Builds project, connects to the openOCD server and flashes new firmware."
    }

Далее необходимо сконфигурировать расширение CMake для VS Code

Нажимаем сочетание клавиш Ctrl+Shift+P и в появившейся строке находим
CMake: Configure и выбираем конфигурацию под arm-none-eabi

После конфигурации автоматически сгенерируется файл .vscode/launch.json, рассмотрим его поподробнее:

{
  "configurations" : 
  [
    {
      "cwd" : "${workspaceRoot}",
      "device" : "STM32F446ZE",
      "executable" : "${workspaceRoot}/build/${workspaceFolderBasename}.elf",
      "name" : "Cortex Debug (generated)",
      "preLaunchTask" : "CMake: build",
      "preRestartCommands" : [ "load", "enable breakpoint", "monitor reset" ],
      "request" : "launch",
      "runToEntryPoint" : "main",
      "servertype" : "stutil",
      "showDevDebugOutput" : "raw",
      "svdFile" : "${workspaceRoot}/build/_deps/st-svd-archive-src/STM32F4_svd_V1.8/STM32F446.svd",
      "type" : "cortex-debug"
    }
  ],
  "version" : "0.2.0"
}

svdFile – путь до файла, который необходим, чтобы просматривать регистры периферии МК

Картинка

"preLaunchTask": CMake: build – компилирует проект перед прошивкой МК.

preRestartCommands – отправляет команды через GDB при нажатии на кнопку перезапуска отладки

Скрипт fetch_svd.cmake по умолчанию использует в качетсве GDB-сервера stutils. Примеры конфигурации под OpenOCD и JLink можно посмотреть на вики cortex-debug в приложенных ссылках.

Переходим к коду (наконец-то)

Не мудрствуя лукаво, пойдём мигать светодиодом. (и ещё немного поиграемся с выделением памяти). Изменим main() следующим образом

#include "stdlib.h"

uint8_t* data;
int main(void)
{
  HAL_Init();
  SystemClock_Config();
  MX_GPIO_Init();
  MX_USART3_UART_Init();
  
  /* USER CODE BEGIN 2 */
  data = new uint8_t[16];
  uint8_t const_data[16];
  
  for(int i = 0; i < 16; i++){
    data[i] = i+1;
    const_data[i] = i+1;
  }
  /* USER CODE END 2 */

  /* Infinite loop */
  while (1)
  {
    HAL_GPIO_TogglePin(LD3_GPIO_Port, LD3_Pin);
    HAL_Delay(50);
  }
}

Компиляция проекта осуществляется нажатием клавиши F7 либо сочетанием Ctrl+Shift+B. Так как ранее мы в launch.json указали сборку перед прошивкой, то нам будет достаточно нажать F5 и перейти сразу к отладке. Рассмотрим интерфейс:

Отладочный GUI в VS Code

Первая кнопка осуществляет программный сброс (software reset) устройства
Вторая запускает код (горячая клавиша F5)
Третья, четвёртая и пятая – «шаг» вперёд к следующей функции, «шаг» вперёд к следующей инструкции (т.е. с погружением) и выполнение код до выхода из функции.
Шестая клавиша осуществляет пересборку проекта и перезапуск прошивки.
А седьмая останавливает отладку.

Окно слева содержит следующие разделы:

Отладочный GUI в VS Code

Cortex Registers – регистры процессора
Cortex Peripherals – регистры периферии (например, там можно смотреть и изменять состоянием регистров GPIO и мигать светодиодом с помощью мышки, хехе)
Breakpoints – список выставленных прерываний. Отмечу, что у разных микроконтроллеров и отладчиков допустимо различное число брейкпоинтов (Например, у ST-Link V2.1 их всего 6)
В CallStack можно посмотреть очередь вызова (вплоть до main, что логично)
Раздел Variables позволяет просматривать как локально объявленные переменные, так и глобальные, например uwTick, показывающую количество милисекунд от момента запуска МК
В Memory View можно посмотреть в любой доступный раздел памяти МК

Адреса недоступные к прочтению (по причине отсутствия в этом мире на данном МК) показаны тильдой

Рассмотрим возможности Watch Window (и заодно сравним его с Keil MDK)

Массив const_data был объявлен статически, и его можно посмотреть просто по названию, тут всё как везде

А теперь попробуем посмотреть содержимое динамически выделенного массива:

Здесь, так же как и везде, дебаггер отобразит лишь первый элемент (в кавычках можно увидеть содержимое до первого \0 ). Однако, в отличие от, например, Keil MDK, мы можем явно указать, как именно следует воспринимать данный указатель:

Такая возможность часто бывает необходима не только для динамически выделенных массивов, но и, например, при передаче в функцию указателя на какой-либо буфер.

Также мы можем переопределить этот указатель написав, например, такой запрос:
*(uint16_t*)data@8Тогда в Watch Window будет показано отображение массива типа short, а не uchar

Источник

Не знаю куда писать, поэтому пишу тут. Не могу решить проблему. При открытии скачанного файла вместо русских букв показывает знаки вопроса

сделай 1251 кодировкой по умолчанию и перекачай файл

сделать 1251 кодировкой по умолчанию и перекачай файл

Тупой конечно вопрос, но как. Копался в настройках не нашёл

Тупой конечно вопрос, но как. Копался в настройках не нашёл

Никак, да и смысла в этом не много, так как другие языки нормально справляются в UTF8
У тебя сломалась кодировка при сохранении не в той кодировке
Перекачай и первое что делай. при открытии lua — меняй на windows1251

Тупой конечно вопрос, но как. Копался в настройках не нашёл

Спасибо большое, как всегда лучший👍

Источник

Некоторые пользователи Windows 11 сталкиваются с ситуацией, когда вместо русских букв в интерфейсе системы или приложениях появляются «иероглифы», «кракозябры», квадраты или знаки вопроса. Это может происходить при установке приложений, использовании старого ПО или даже в системных элементах. Проблема связана с неправильными настройками кодировки или шрифтов. В этой инструкции мы подробно разберём, как вернуть корректное отображение кириллицы в Windows 11 — как для отдельных утилит, так и для системы в целом.

Приобрести оригинальные ключи активации Windows 11 можно у нас в каталоге от 1690 ₽

Когда это не связано с системой

Если иероглифы появляются только в текстовых документах или на сайтах, проблема, скорее всего, в кодировке файла, а не в Windows. В таких случаях:

— Откройте файл в текстовом редакторе с поддержкой выбора кодировки (например, Sublime Text или Notepad++), выберите Windows-1251 или UTF-8.

— В браузере используйте расширения для смены кодировки (например, Change Charset) или меню «Кодировка» (в Firefox: Вид → Кодировка текста).

— При необходимости конвертируйте файл через онлайн сервисы.

Эта статья посвящена системным проблемам, а не отдельным файлам.

Проверка настроек Юникод (UTF-8)

Если иероглифы появляются в новых приложениях (не старше 10-15 лет), причина может быть в региональных настройках Windows, а именно в опции «Использовать Юникод (UTF-8) для поддержки языка во всем мире». Эта функция влияет на кодировку не локализованных приложений. Чтобы проверить и исправить:

1. Откройте Панель управления:

— Используйте поиск на панели задач, введя «Панель управления».

— Или нажмите Win + R, введите control intl.cpl,,1 и нажмите Enter для перехода сразу на вкладку «Дополнительно».

2. Перейдите в раздел «Региональные стандарты» → вкладка «Дополнительно».

3. Нажмите кнопку «Изменить язык системы».

4. Проверьте настройки:

— Текущий язык системы: убедитесь, что стоит «Русский (Россия)». Если выбран другой (например, English), измените на русский.

— Использовать Юникод (UTF-8): по умолчанию галочка снята.

— Если она включена, снимите её и нажмите OK.

— Если отключена, попробуйте включить и нажмите OK.

5. Перезагрузите компьютер после изменения и проверьте, исчезли ли иероглифы.

Этот метод помогает, если проблема связана с несовместимостью программы с глобальной кодировкой UTF-8 или её отсутствием.

Исправление кодовых страниц в реестре

Если Windows 11 была русифицирована через языковой пакет или основана на англоязычной сборке, иероглифы могут появляться из-за неверной кодовой страницы. В России стандартная кодовая страница для кириллицы — Windows-1251, но иногда используется 1252 (западноевропейская). Исправить это можно через реестр:

1. Создайте точку восстановления:

— Нажмите Win + R, введите systempropertiesprotection, включите защиту системного диска (если отключена) и нажмите «Создать».

2. Откройте редактор реестра:

— Нажмите Win + R, введите regedit и нажмите Enter.

3. Перейдите в раздел:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Nls\CodePage

4. Найдите параметр ACP в правой части:

— Если значение не 1251 (например, 1252), дважды щёлкните по параметру.

— Измените значение на 1251, нажмите OK.

5. Закройте редактор реестра и перезагрузите компьютер.

Альтернативный способ (с заменой файла)

Менее безопасный вариант — подмена файла кодовой страницы:

— В папке C:\Windows\System32 найдите файл c_1252.NLS.

— Сделайте его резервную копию (например, переименуйте в c_1252_backup.NLS).

— Скопируйте файл c_1251.NLS, переименуйте копию в c_1252.NLS и замените оригинал.

— Для этого нужно взять права на файл:

1. Щёлкните правой кнопкой по файлу → Свойства → Безопасность → Дополнительно.

2. В поле «Владелец» нажмите «Изменить», введите имя вашей учётной записи, примените изменения.

3. Дайте себе полный доступ следующим образом как показано на скриншотах ниже в разделе разрешений:

— После замены перезагрузите ПК. Если что-то пойдёт не так, восстановите файл и выполните sfc /scannow в командной строке от имени администратора.

Дополнительные причины и решения

Если вышеуказанные методы не помогли, рассмотрите другие варианты:

1. Проблема со шрифтами:

— Если вы меняли системный шрифт (например, через сторонние утилиты или реестр), он может не поддерживать кириллицу, из-за чего вместо букв появляются квадраты.

— Верните стандартный шрифт Segoe UI:

— Откройте реестр (regedit) → раздел HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\FontSubstitutes.

— Убедитесь, что параметр MS Shell Dlg и MS Shell Dlg 2 равен Segoe UI. Если нет, исправьте.

— Или используйте точку восстановления системы.

2. Старые программы:

— Для устаревшего ПО (например, из эпохи Windows XP) включите режим совместимости:

— Щёлкните правой кнопкой по .exe-файлу → Свойства → Совместимость.

— Выберите старую версию Windows (например, Windows 7) и примените.

Иероглифы вместо кириллицы в Windows 11 — это проблема настроек кодировки или шрифтов, которую можно решить. Начните с проверки Юникод (UTF-8) в региональных стандартах, затем исправьте кодовую страницу в реестре, если нужно. Для старых программ используйте совместимость, а при замене шрифтов верните стандартные. Следуя этим шагам, вы вернёте нормальное отображение русских букв в системе и приложениях!

Источник

Метод работы с официальным плагином, описанный в предыдущей статье, на практике оказался не самым удобным. Поэтому сегодня мы разберем, как вручную настроить VS Code для работы с контроллерами STM32. Также рассмотрим основные принципы настройки VS Code, которые могут быть полезны для работы в других аналогичных проектах.

Для начала я бы предложил разобраться с тем, почему я считаю, что плагин от производителя не подходит для работы. Я вижу следующие основные проблемы:

Зависимость от IntelliSense, а значит невозможность использования VSCodium или Code — OSS (конечно, если соблюдать Terms of Use).
Для работы используется CMake Tools, который создает бесполезное окно и, кроме того, автоматически запускает cmake при открытии любого проекта. Это расширение бесполезно и только мешает работе.
Плагин сам создает лишнее бесполезное окно, которое захламляет VS Code ненужными функциями.
Для работы обязательно использовать инструменты STM32CubeCLT, которые тоже зря засоряют систему, особенно если уже используется компилятор и утилиты из репозиториев. А главное, они лишают нас выбора: всегда нужно использовать именно ST-LINK server, а не OpenOCD или PyOCD (несмотря на поддержку в Cortex Debug).

В совокупности эти факторы приводят нас к решению о полном отказе от STM32 VS Code Extension.

Далее я думаю следует задаться вопросом: а что бы мы хотели от редактора кода в 21 веке? Я бы выделил три основных момента:

Сборка
Отладка
Статический анализ

Далее рассмотрим, как VS Code подразумевает решать каждую из этих задач. Однако для начала нужно создать проект. Для этого можно использовать инструкцию из прошлой статьи (Создание проекта -> Cube MX) или можно использовать любой другой конфиг и контроллер. Главное, чтобы проект был сгенерирован именно для CMake.

Создание проекта

Далее создаем папку App с тестовым кодом, ровно так, как описано в разделе Организация проекта на С. Для проверки того, что всё работает корректно, можно собрать код с помощью консоли. Сделать это достаточно просто, находясь в папке с проектом:

mkdir build && cd build
cmake ..
cmake --build .

Для того чтобы это сработало, в системе должен быть установлен тулчейн arm-none-eabi-gcc. Его можно установить через пакетный менеджер:

sudo pacman -S arm-none-eabi-gcc arm-none-eabi-newlib # Arch linux
sudo apt install arm-none-eabi-gcc # Debian based

Или можно скачать бинарные файлы непосредственно с сайта ARM.

Сборка

VS Code предлагает механизм тасков для решения задач сборки или запуска чего-либо. По сути, таск — это просто обёртка над консольной командой, которую можно запустить из консоли или другими способами.

Другой способ запуска, в нашем случае, — это кнопки на статус-баре. Для их создания необходимо установить плагин Tasks.

Настройка статусов и команд осуществляется в файле .vscode/tasks.json:

{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "clean",
            "group": "build",
            "type": "shell",
            "command": "rm -rf build",
            "options": {
                "statusbar": {
                    "color": "#ff8b8b",
                    "label": "$(clear-all) Clean",
                    "detail": "Clean ALL"
                }
            }
        },
        {
            "label": "Configure_Debug",
            "group": "build",
            "type": "shell",
            "command": "cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug",
            "options": {
                "cwd": "${workspaceFolder}",
                "statusbar": {
                    "color": "#8bdeff",
                    "label": "$(gear) Debug",
                    "detail": "Cmake configure Debug"
                }
            }
        },
        {
            "label": "Configure_RelWithDebInfo",
            "group": "build",
            "type": "shell",
            "command": "cmake -S . -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo",
            "options": {
                "cwd": "${workspaceFolder}",
                "statusbar": {
                    "color": "#8bdeff",
                    "label": "$(gear) RelWithDebInfo",
                    "detail": "Cmake configure RelWithDebInfo"
                }
            }
        },
        {
            "label": "Configure_Release",
            "group": "build",
            "type": "shell",
            "command": "cmake -S . -B build -DCMAKE_BUILD_TYPE=Release",
            "options": {
                "cwd": "${workspaceFolder}",
                "statusbar": {
                    "color": "#8bdeff",
                    "label": "$(gear) Release",
                    "detail": "Cmake configure Release"
                }
            }
        },
        {
            "label": "Configure_MinSizeRel",
            "group": "build",
            "type": "shell",
            "command": "cmake -S . -B build -DCMAKE_BUILD_TYPE=MinSizeRel",
            "options": {
                "cwd": "${workspaceFolder}",
                "statusbar": {
                    "color": "#8bdeff",
                    "label": "$(gear) MinSizeRel",
                    "detail": "Cmake configure MinSizeRel"
                }
            }
        },
        {
            "label": "build",
            "group": "build",
            "type": "shell",
            "command": "cmake --build build",
            "options": {
                "cwd": "${workspaceFolder}",
                "statusbar": {
                    "color": "#8bff97",
                    "label": "$(code) Build",
                    "detail": "Build"
                }
            }
        }
    ]
}

Данный конфиг создает кнопки (и разукрашивает) для каждого типа конфигурации, описанной в CMakePresets.json, а также добавляет команды clean и build. Полагаю, что конфигурация и так достаточно понятна, и дополнительные объяснения излишни.

На самом деле, механизм тасков в VS Code достаточно сложен и интересен. Например, можно создавать зависимые таски. Если для запуска вашего приложения требуется сервер, вы можете настроить его запуск перед приложением, сделать его зависимым и задать регулярное выражение для анализа логов. Это позволит останавливать процесс в случае возникновения ошибок. Однако обо всём этом как-нибудь в другой раз — для работы с STM32 такой функционал не является необходимым.

Отладка

VS Code с помощью плагинов позволяет подключиться к GDB-серверу и, с помощью парсинга его вывода, реализовать управление отладкой прямо в редакторе. Для работы с C/C++ на микроконтроллерах подходят три решения:

Cortex-Debug — Это самый популярный плагин для работы с архитектурой ARM. Мы остановимся именно на нём. Подробнее о работе с этим плагином можно почитать в прошлой статье, а здесь обсудим только его настройку.
Официальный плагин от Microsoft — C/C++ for Visual Studio Code — Этот плагин можно использовать с микроконтроллерами, приложив немного больше усилий при настройке. Однако, мы откажемся от него по уже описанным выше причинам.
Native Debug — Интересный плагин, который умеет работать как с GDB, так и с LLDB. Его тоже можно настроить для работы с Cortex-контроллерами, но это несколько сложнее, чем в случае с Cortex-Debug, из-за большей универсальности. Мы остановимся на первом варианте, однако, вероятно, этот плагин понадобится в следующих статьях, если будет рассматриваться программирование RISC-V.

Для работы с Cortex-Debug на компьютере должны быть установлены GDB (подразумевается использование gdb-multiarch, а не arm-none-eabi-gdb), а так-же OpenOCD:

sudo pacman -S openocd gdb # ARCH Linux
sudo apt install openocd gdb # Debian based

Как я писал выше, возможно использование PyOCD или J-Link server. Однако эти инструменты не будут рассмотрены в данной статье, так как OpenOCD решает практически все задачи в контексте работы с STM32.

Перед настройкой непосредственно VS Code, лучше сначала убедиться в работоспособности OpenOCD и GDB в консоли. Для этого:

openocd -f interface/stlink.cfg -f target/stm32g4x.cfg
# Другой терминал
telnet localhost 4444
> reset halt
> flash write_image erase /home/zen/projects/stm32/vscode-cubemx-pro-guide/build/vscode-cubemx-pro-guide.hex
> reset

Для сборки HEX, а не только ELF нужно добавить строки в конец CMakeLists.txt (описано в прошлой статье):

...
# Add custom commands to generate .bin and .hex files
add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD
COMMAND ${CMAKE_OBJCOPY} -O binary $<TARGET_FILE:${CMAKE_PROJECT_NAME}> ${CMAKE_PROJECT_NAME}.bin
COMMAND ${CMAKE_OBJCOPY} -O ihex $<TARGET_FILE:${CMAKE_PROJECT_NAME}> ${CMAKE_PROJECT_NAME}.hex
COMMENT "Building ${CMAKE_PROJECT_NAME}.bin and ${CMAKE_PROJECT_NAME}.hex"
)

Также, в Arch Linux для работы telnet необходимо установить пакет inetutils.

После этого плата должна быть прошита, и диод на ней должен замигать.

Далее можно проверить работоспособность GDB сервера. Для этого нужно его запустить:

gdb
> target remote localhost:3333
> monitor reset halt
> monitor flash write_image erase /home/zen/projects/stm32/vscode-cubemx-pro-guide/build/vscode-cubemx-pro-guide.hex
> c

Для работы с GDB необходимо, чтобы OpenOCD был запущен. Вопрос отладки с использованием консольного GDB (вероятно) будет рассмотрен в дальнейших статьях.

В VS Code расширение Cortex-Debug выполнит все эти действия автоматически без нашего участия. Для этого достаточно настроить файл .vscode/launch.json:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "STM32",
            "cwd": "${workspaceRoot}",
            "executable": "build/${workspaceFolderBasename}.elf",
            "request": "launch",
            "type": "cortex-debug",
            "servertype": "openocd",
            "preLaunchTask": "build",
            "gdbPath": "gdb",
            // Add you svd file
            // "svdFile": "${workspaceRoot}/Docs/STM32F3x4.svd",
            // Set you programmer and trget controller
            "configFiles": [
                "interface/stlink.cfg",
                "target/stm32g4x.cfg"
            ],
            // "runToEntryPoint": "main",
            "showDevDebugOutput": "none",
            "swoConfig": {
                "enabled": true,
                "swoFrequency": 2000000,
                "cpuFrequency": 170000000,
                "decoders": [
                    {
                        "port": 0,
                        "type": "console"
                    }
                ]
            }
        }
    ]
}

Важные моменты по данному конфигу:

servertype — можно использовать не только openocd, но и другие значения, например pyocd или jlink.
preLaunchTask — это тот самый таск, который мы настраивали в прошлом разделе.
gdbPath — путь до GDB. Если используется системный gdb-multiarch, достаточно указать просто gdb.
svdFile — путь до файла с описанием адресов регистров, что может быть полезно при отладке, так как делает их доступными для просмотра в отладчике. Такой файл можно взять на сайте ST. Например, для STM32G431 он доступен здесь (нужен файл STM32G4 System View Description).
configFiles — файлы конфигурации, определяющие отладчик и серию контроллера. Эти параметры передаются в OpenOCD.
runToEntryPoint — останавливает выполнение в начале функции main.
swoConfig — активирует консоль SWO. Для работы обязательно нужно указать правильную частоту процессора в параметре cpuFrequency. Чтобы использовать printf() с SWO, необходимо переопределить функцию _write():

// For use SWO
int _write(int file, char *ptr, int len) {
  (void)file; // hack for fix warning - unused int file.
  for (int i = 0; i < len; i++)
    ITM_SendChar((*ptr++));
  return len;
}

Подробнее про конфигурацию SWO можно посмотреть тут.

Статический анализ

В этом разделе я рассмотрю инструменты, которые помогают в написании кода, такие как сниппеты, линтеры, автодополнение, автоформатирование, подсветка и т.д. При использовании расширения от ST предполагается, что для этих целей используется C/C++ for Visual Studio Code. Однако, как уже не раз говорилось в этой статье, мы откажемся от него.

Этот функционал будет построен вокруг языкового сервера clangd и плагина clangd. Для работы этой системы clangd должен быть установлен в системе:

sudo pacman -S clangd # ARCH Linux
sudo apt install clangd # Debian based

Данный языковой сервер использует список исходных файлов из compile_commands.json для построения синтаксического дерева. CubeMX по умолчанию добавляет строку в CMakeLists.txt, которая включает генерацию файла compile_commands.json.

Однако, так как clangd изначально заточен под работу с инструментарием clang, для работы с gcc нужно добавить некоторые дополнительные настройки. Дальнейшая настройка производится в файле .vscode/settings.json:

{
    "clangd.arguments": [
        "--compile-commands-dir=build",
        "--enable-config",
        "--clang-tidy",
        "-j=12",
        "--completion-style=detailed",
        "--suggest-missing-includes",
        "--header-insertion-decorators",
        "--background-index",
    ]
}

Однако, из-за особенностей парсинга параметров командной строки, необходимо использовать параметр --enable-config и создать отдельный файл .clangd в корне проекта с дополнительными опциями сборки:

CompileFlags:
  Add: 
    - "-I/usr/arm-none-eabi/include"
    - "-D__INT32_TYPE__=long"
    - "-D__UINT32_TYPE__=unsigned long"

В файле .clangd нужно указать инклуды от newlib, а также переопределить тип long. Это необходимо, так как его размерность отличается на 32-битных и 64-битных системах.

Из остальных параметров нужно поменять значение -j=12 на количество ядер вашего процессора. Остальное можно оставить без изменений. Описание доступных параметров можно получить с помощью команды:

clangd --help

После создания конфигурационных файлов перезапустите VS Code. Во вкладке PROBLEMS появятся все проблемы, выявленные статическим анализатором.

Это не единственный статический анализатор, который можно использовать. На самом деле, их достаточно много, но большинство из них являются платными. Для VS Code существует плагин, который позволяет объединить несколько анализаторов, — C/C++ Advanced Lint.

Из поддерживаемых этим плагином инструментов нас интересует только CppCheck благодаря его широким возможностям в бесплатной и открытой версии. Остальные анализаторы мы использовать не будем (но при желании вы можете попробовать их самостоятельно).

Настройка данного плагина также выполняется через файл .vscode/settings.json:

...
    // Advanced Lint
    "c-cpp-flylint.clang.enable": false,
    "c-cpp-flylint.flexelint.enable": false,
    "c-cpp-flylint.cppcheck.enable": true,
    "c-cpp-flylint.lizard.enable": false,
    "c-cpp-flylint.flawfinder.enable": false,
    "c-cpp-flylint.cppcheck.standard": [
        "c11",
        "c++20"
    ],
    "c-cpp-flylint.cppcheck.severityLevels": {
        "error": "Error",
        "warning": "Warning",
        "style": "Information",
        "performance": "Information",
        "portability": "Information",
        "information": "Information"
    },
    "c-cpp-flylint.cppcheck.suppressions": [
        "cstyleCast"
    ],
    "c-cpp-flylint.cppcheck.extraArgs": [
        "--cppcheck-build-dir=build",
        "--platform=arm32-wchar_t2",
        // "--addon=misra.py",
        "--enable=all",
        "--force",
        "-j12",
        "-D__GNUC__",
        "-D__INT32_TYPE__=long",
        "-D__UINT32_TYPE__=\"unsigned long\"",
        "-I/usr/arm-none-eabi/include",
    ]
...

Анализатор clangd отключен в этом конфиге, так как он уже работает в составе предыдущего плагина.

Для работы в системе должен быть установлен cppcheck:

sudo pacman -S cppcheck     # ARCH Linux
sudo apt install cppcheck   # Debian based

Cppcheck — это достаточно сложный и продвинутый статический анализатор с множеством опций. Подробнее о его использовании можно почитать здесь. В его функционале даже есть частичная поддержка MISRA C в открытой версии. Однако, поскольку HAL не предполагает использование MISRA, в моем конфиге данная опция не включена.

Дополнительные плагины для удобства работы

Для более удобной и эффективной работы стоит установить следующие плагины:

Error Lens — Отображает ошибки и предупреждения прямо на строке с кодом, как это реализовано в Qt Creator.
Better C++ Syntax — Улучшает подсветку синтаксиса для C/C++.
C/C++ Snippets — Предоставляет полезные сниппеты для C/C++.
Плагины для работы с CMake:
- CMake — добавляет базовую поддержку синтаксиса.
- cmake-format — добавляет автоформатирование. Для работы последнего в системе должен быть установлен cmake-format.
Плагины для документации:
- Doxygen — добавляет поддержку синтаксиса Doxygen.
- Doxygen Documentation Generator — автоматически генерирует описание функций на основе их объявлений.
Подсветка специфических форматов:
- GNU Linker Map files — подсвечивает синтаксис map файлов.
- LinkerScript — добавляет подсветку синтаксиса для linker скриптов.

Регулярно проверяйте, нет ли новых интересных плагинов для работы с типами файлов, которые вы начали использовать. Возможно, кто-то уже решил вашу проблему с помощью плагина, что упростит вашу работу.

В итоге получаем:

Используемые плагины

Tasks — кнопки тасков на статус баре.
Cortex-Debug — плагин для отладки.
Сlangd — плагин для работы с языковым сервером clangd.
C/C++ Advanced Lint — поддержка набора синтаксических анализаторов.
Error Lens — отображение ошибок сразу в тексте программы.
Better C++ Syntax — чуть лучшая подсветка синтаксиса.
C/C++ Snippets — набор сниппетов.
CMake — базовая поддержка Cmake.
Cmake-format — авто форматирование cmake скриптов.
Doxygen — поддержка синтаксиса Doxygen.
Doxygen Documentation Generator — генерация описания функции по его обьявлению.
GNU Linker Map files — подсветка linker file.
LinkerScript — подсветка linker script.

Так-же их можно автоматически добавить в систему создав файл extensions.json в папке .vscode:

{
  "recommendations": [
    "actboy168.tasks",
    "marus25.cortex-debug",
    "llvm-vs-code-extensions.vscode-clangd",
    "jbenden.c-cpp-flylint",
    "usernamehw.errorlens",
    "jeff-hykin.better-cpp-syntax",
    "hars.CppSnippets",
    "twxs.cmake",
    "cheshirekow.cmake-format",
    "bbenoist.Doxygen",
    "cschlosser.doxdocgen",
    "trond-snekvik.gnu-mapfiles",
    "ZixuanWang.linkerscript"
  ]
}

Ссылки

Проект на гит с примером из статьи.
Документация по vscode.

Источник