Несколько месяцев изучаю и использую Rust. Я все еще учусь, но меня очень впечатлил мощный и крутой язык программирования, яркая экосистема, продвинутые концепции и инструменты. Изучая Rust, я использовал среду разработки Visual Studio Code IDE, и она отлично работает с Rust. Но мне было интересно: могу ли я использовать его для моей «обычной» разработки на C / C ++ и на устройствах ARM Cortex-M? Ответ однозначный: «да», и эта мини-серия статей также должна помочь вам начать работу.

По сути, Visual Studio Code - это очень удобная, быстрая и современная IDE со множеством классных плагинов и помощников. Кажется, он не так часто используется для встраиваемой разработки, но со временем это определенно может измениться. Начать работу с Visual Studio Code и встроенной целью может быть сложно, потому что для нее может не быть специальной поддержки со стороны поставщиков микросхем. Но немного поучившись, и я надеюсь, что с помощью этой серии статей вы сможете приступить к работе.

В этой серии руководств я использую NXP K22FN512 ( плата FRDM-K22 ), но вы сможете использовать любое другое устройство NXP Kinetis или LPC, если оно поддерживается NXP MCUXpresso SDK. Я расскажу об установке, первом простом проекте, его отладке на целевом компьютере и, наконец, расширении его до полного проекта SDK, а также изучу некоторые расширенные функции.

Итак, вот что: если вы не знаете Visual Studio Code, я приглашаю вас в путешествие в новый мир ...

Настройка

Для этой статьи я использовал версию 1.55.2 Visual Studio Code. Установщик доступен по адресу https://code.visualstudio.com/ и поддерживает Windows, Mac и Linux:

После установки запустите IDE:

В любое время я могу обновить среду IDE, если есть доступные обновления (я тоже буду получать уведомления):

IDE включает в себя представление терминала или консоли, откройте новый:

Область терминала и консоли по умолчанию находится в нижней части, но ее можно переместить куда угодно:

Установка расширений

По сравнению с другими полностью интегрированными IDE, я должен установить другие пакеты в дополнение к IDE: расширения IDE, инструменты сборки (компилятор, компоновщик, библиотеки), Cmake и поддержку отладчика.

Чтобы установить плагины IDE, это можно сделать с помощью командной строки оболочки хоста или непосредственно в Терминале внутри IDE. Чтобы установить расширения (также известные как плагины в Eclipse), я использую следующий формат команды:

code --install-extension <code>

Или через меню View > Extensions.

Для встраиваемой разработки для ARM Cortex-M я рекомендую следующие расширения:

C/C++, ms-vscode.cpptools
Cortex-Debug, marus25.cortex-debug
CMake Tools, ms-vscode.cmake-tools
CMake Syntax highlighting, twxs.cmake
ARM Assembly highlighting, dan-c-underwood.arm
Linker Script highlighting, zixuanwang.linkerscript

Первые три являются обязательными, остальные - необязательными, но рекомендуются.

Самый простой способ - установить их из командной строки внутри IDE:

{source}code --install-extension ms-vscode.cpptools
code --install-extension marus25.cortex-debug
code --install-extension twxs.cmake
code --install-extension dan-c-underwood.arm
code --install-extension zixuanwang.linkerscript{/source}

Ниже моих установленных расширени(menu File > Preferences > Extensions):

CMake

CMake can be downloaded and installed from https://cmake.org/download/

Install it with the defaults. I’m using v3.20.2.

Make or Ninja

Я использую как Make, так и Ninja с CMake. Оба должны присутствовать в PATH, поэтому проверьте, установлен ли он у вас:

Установщик Make доступен по адресу https://www.gnu.org/software/make/.

Ninja доступен по адресу https://github.com/ninja-build/ninja/releases . Установите его там, где он найден системой, я обычно помещаю его в C: \ Program Files \ CMake \ bin

По устаревшим причинам я все еще использую Make, потому что на нем я вырос. Но Ninja - это тот, который я использую все чаще и чаще, потому что он такой быстрый :-).

Встроенный набор инструментов GNU Arm

Набор инструментов GNU для ARM доступен по адресу https://developer.arm.com/tools-and-software/open-source-software/developer-tools/gnu-toolchain/gnu-rm/downloads.

Я установил версию gcc-arm-none-eabi-10-2020-q4-major-win32 с настройками по умолчанию.

Отладчик

Чтобы подключить GDB (отладчик) к целевой плате, мне нужен программатор. Я использую для этого SEGGER J-Link. MCUXpresso IDE уже поставляется с установкой J-Link, поэтому очень вероятно, что она уже существует на вашем компьютере. Если нет, вы можете загрузить программное обеспечение J-Link с https://www.segger.com/downloads/jlink#J-LinkSoftwareAndDocumentationPack.

Установите его с настройками по умолчанию. У меня установлен V7.20 с настройками по умолчанию:

Также можно использовать OpenOCD или PEMicro. Сначала я сосредоточусь на интерфейсе J-Link.

Теперь у нас должно быть установлено все необходимое программное обеспечение.

Часть 2 - Проект

Это вторая часть серии статей о том, как использовать код Microsoft Visual Studio для встраиваемой разработки на ARM Cortex-M. В этой части я собираюсь показать, как создать и собрать проект, используя CMake, запускающий Make или Ninja в качестве системы сборки.

В части 1 мы установили необходимые инструменты, поэтому убедитесь, что вы выполнили эту часть. Часть 2 посвящена созданию очень простого проекта C. Цель состоит в том, чтобы создать что-то простое и легкое, что вы можете использовать в своих собственных проектах. Речь идет об использовании наиболее важных инструментов для выполнения работы без необходимости использования других «фреймворков», если они вам действительно не нужны. Речь идет о создании основного файла, добавлении кода запуска и сборке его как проекта.

Я не собираюсь использовать «причудливых» мастеров или фреймворков, я просто использую базовые инструменты по одной причине: для простоты.

Не волнуйтесь: это просто. И все используемые / созданные файлы находятся на GitHub: https://github.com/ErichStyger/mcuoneclipse/tree/master/Examples/VisualStudioCode

SDK

Помимо компилятора / компоновщика / отладчика вам понадобятся несколько минимальных файлов для сборки проекта:

Основной : файл с основной точкой входа в приложение (main ()).
Код запуска : он выполняется после сброса, инициализирует систему, память, библиотеку и переходит к main ().
Система : в среде CMSIS код запуска вызывает обратный вызов инициализации системы (SystemInit () для установки часов, настройки сторожевого таймера,…). Кроме того, он предоставляет файлы заголовков для регистров устройств с отображением памяти и периферийных устройств, таких как I2C, SPI,…
Файл компоновщика : определяет отображение памяти и способ связывания приложения.

Первый пункт - это то, что вы легко можете написать самостоятельно. Остальные элементы вы можете получить из примеров (например, из моего GitHub ) или из SDK / примеров, предоставленных поставщиком вашего кремниевого устройства, например, NXP.

NXP предоставляет все необходимые файлы в MCUXpresso SDK . Убедитесь, что у вас есть SDK для GNU gcc:

Преимущество использования такого SDK заключается в том, что у вас есть свобода выбора и полный контроль, без «привязки» к пользовательским фреймворкам и зависимостям с самого начала.

Цвета? Цвета!

Пока не забыл: начать с чего-то очень простого: вот где вы можете изменить цветовую тему в Visual Studio Code на все, что вам нравится:

Рабочее пространство и проект (ы)

Подобно другим IDE, VSC использует концепцию «рабочего пространства». Проще говоря, рабочая область - это набор папок, открытых в среде IDE. См. Https://code.visualstudio.com/docs/editor/workspaces для получения более подробной информации. В самом простом случае рабочее пространство просто содержит папку, которая является папкой для проекта. Итак, все, что нам нужно, это добавить папку.

Перейдите к существующей новой (пустой) папке или просто создайте ее в диалоговом окне:

Ниже я создал новую папку FRDM-K22F_Simple, а затем добавил ее:

Эта папка теперь отображается в рабочей области:

Файл main.c

Добавьте новый файл: main.c

Реализуйте основную функцию, затем сохраните ее (CTRL + S):

Папки

Рекомендую разложить файлы по папкам.

Это действительно зависит от вас, как вы будете организовывать файлы. Моя предпочтительная "стандартная" организация использует следующие папки:

CMSIS : содержит файлы заголовков ARM CMSIS.
устройство : файлы заголовков для конкретного устройства, инициализация системы, код запуска и файл компоновщика
src : исходные файлы приложения, включая основной файл
build : Scratch, содержит все сгенерированные файлы сборки, объектные файлы и исполняемый файл. Все, что находится в этой папке, может быть удалено / удалено / очищено, поскольку оно создано из исходных кодов.

Опять же, выбор за вами. В остальной части статьи я буду использовать эту структуру.

Файлы запуска, системы и компоновщика

Из SDK скопируйте в папку проекта файлы системы, автозагрузки и компоновщика.

Следующие шаги касаются компиляции и компоновки.

Toolchain CMake File

I’m going to use CMake with Make to build the project. CMake needs some information where to find the tools. A simple and easy way is to to add a the following file to the project. I have named it arm-none-eabi-gcc.cmake and placed it in the project root folder. Below is a template as well on GitHub.

set(CMAKE_SYSTEM_NAME Generic)
set(CMAKE_SYSTEM_PROCESSOR ARM)

set(ARM_TOOLCHAIN_DIR "C:/Program Files (x86)/GNU Arm Embedded Toolchain/10 2020-q4-major/bin")
set(BINUTILS_PATH ${ARM_TOOLCHAIN_DIR})

set(TOOLCHAIN_PREFIX ${ARM_TOOLCHAIN_DIR}/arm-none-eabi-)

set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)

set(CMAKE_C_COMPILER "${TOOLCHAIN_PREFIX}gcc.exe")
set(CMAKE_ASM_COMPILER ${CMAKE_C_COMPILER})
set(CMAKE_CXX_COMPILER "${TOOLCHAIN_PREFIX}g++.exe")

set(CMAKE_OBJCOPY ${TOOLCHAIN_PREFIX}objcopy CACHE INTERNAL "objcopy tool")
set(CMAKE_SIZE_UTIL ${TOOLCHAIN_PREFIX}size CACHE INTERNAL "size tool")

set(CMAKE_FIND_ROOT_PATH ${BINUTILS_PATH})
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

ARM_TOOLCHAIN_DIR specifies the compiler to be used (I have multiple versions of the toolchain installed on my system, update it to match your version).

Additionally it defines extra tools as size and objcopy.

Примечание : вышесказанное и эта статья имеют в виду простоту, и, как вы можете видеть, там есть абсолютный путь к существующей инструментальной цепочке. Есть и другие, более сложные способы сделать это, начиная с папки cmake с более продвинутыми или переносимыми скриптами cmake . Существуют и другие специальные расширения, такие как https://marketplace.visualstudio.com/items?itemName=ilg-vscode.xpack, которые могут вам в этом помочь.

CMake CMakeLists.txt

Чтобы указать CMake, что делать, создайте файл с именем CMakeList.txt в корне проекта. Ниже приведен шаблон для него также на GitHub .

cmake_minimum_required(VERSION 3.15.3)

# Optional: print out extra messages to see what is going on. Comment it to have less verbose messages
set(CMAKE_VERBOSE_MAKEFILE ON)

# Path to toolchain file. This one has to be before 'project()' below
set(CMAKE_TOOLCHAIN_FILE ${CMAKE_SOURCE_DIR}/arm-none-eabi-gcc.cmake)

# Setup project, output and linker file
project(FRDM-K22F_Simple)
set(EXECUTABLE ${PROJECT_NAME}.elf)
set(LINKER_FILE ${CMAKE_SOURCE_DIR}/device/MK22FN512xxx12_flash.ld)

enable_language(C ASM)
set(CMAKE_C_STANDARD 99)
set(CMAKE_C_STANDARD_REQUIRED ON)
set(CMAKE_C_EXTENSIONS OFF)

# Optional: issue a message to be sure it uses the correct toolchain file.
message(STATUS "CMAKE_TOOLCHAIN_FILE is: ${CMAKE_TOOLCHAIN_FILE}")

# List of source files
set(SRC_FILES
        src/main.c
        device/startup_MK22F51212.S
        device/system_MK22F51212.c
        )

# Build the executable based on the source files
add_executable(${EXECUTABLE} ${SRC_FILES})

# List of compiler defines, prefix with -D compiler option
target_compile_definitions(${EXECUTABLE} PRIVATE
        -DCPU_MK22FN512VLH12
        -DCPU_MK22FN512VLH12_cm4
        )

# List of includ directories
target_include_directories(${EXECUTABLE} PRIVATE
        src 
        device
        CMSIS
        )

# Compiler options
target_compile_options(${EXECUTABLE} PRIVATE
        -mcpu=cortex-m4
        -mthumb
        -mfpu=fpv4-sp-d16
        -mfloat-abi=hard

        -fdata-sections
        -ffunction-sections

        -Wall
        -O0
        -g3
        )

# Linker options
target_link_options(${EXECUTABLE} PRIVATE
        -T${LINKER_FILE}
        -mcpu=cortex-m4
        -mthumb
        -mfpu=fpv4-sp-d16
        -mfloat-abi=hard
        -specs=nano.specs
        -lc
        -lm
        -lnosys
        -Wl,-Map=${PROJECT_NAME}.map,--cref
        -Wl,--gc-sections
        -Xlinker -print-memory-usage -Xlinker
        )

# Optional: Print executable size as part of the post build process
add_custom_command(TARGET ${EXECUTABLE}
        POST_BUILD
        COMMAND ${CMAKE_SIZE_UTIL} ${EXECUTABLE})

# Optional: Create hex, bin and S-Record files after the build
add_custom_command(TARGET ${EXECUTABLE}
        POST_BUILD
        COMMAND ${CMAKE_OBJCOPY} -O srec --srec-len=64 ${EXECUTABLE} ${PROJECT_NAME}.s19
        COMMAND ${CMAKE_OBJCOPY} -O ihex ${EXECUTABLE} ${PROJECT_NAME}.hex
        COMMAND ${CMAKE_OBJCOPY} -O binary ${EXECUTABLE} ${PROJECT_NAME}.bin)

Наиболее важные разделы / записи:

project (<здесь название вашего проекта>): дайте вашему проекту имя
set ( LINKER_FILE <ваш файл компоновщика здесь>): укажите имя файла компоновщика
set ( SRC_FILES <ваши исходные файлы здесь>): список исходных файлов для компиляции
target_compile_definitions ($ {EXECUTABLE} PRIVATE <компилятор определяет здесь>): список компиляторов #define
target_include_directories ($ {EXECUTABLE} PRIVATE <список включаемых каталогов>): список включаемых каталогов
target_compile_options ($ {EXECUTABLE} PRIVATE <параметры компилятора>): список параметров компилятора
target_link_options ($ {EXECUTABLE} PRIVATE <параметры компоновщика>): список параметров компоновщика

На этом настройка конфигурации для сборки завершена.

Настройка

Далее мы собираемся его построить. На самом деле нам нужно сначала его «настроить». С CMake это двухэтапный процесс: запуск CMake для создания (или настройки) файлов make или ninja, а затем я использую make или ninja для его создания.

Откройте терминал в выходной папке сборки:

При использовании make : вызовите CMake для создания файлов make:

cmake -DCMAKE_MAKE_PROGRAM=make.exe -G "Unix Makefiles" ..

затем создайте его с помощью:

make

При использовании ниндзя : вызовите CMake со следующей командной строкой:

cmake -DCMAKE_MAKE_PROGRAM = ninja.exe -G "Ninja" ..

затем создайте его с помощью:

ninja

Простой способ переключаться между двумя системами сборки или начать с нуля - это удалить содержимое папки build. И да: ниндзя намного быстрее 🙂

Строительство

Вместо вызова make или ninja внутри папки сборки можно использовать следующее, что делает то или другое:

cmake --build.

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

Если вы вносите изменения в структуру: убедитесь, что вы выполнили настройку, чтобы убедиться, что все настроено правильно.

Уборка

«Чистая-чистая» - это удалить все файлы в папке сборки. Но в CMake есть и «чистая» команда:

cmake --build. - цель очистить

Чтобы выполнить «очистку с последующей сборкой», используйте следующее:

cmake --build. - сначала очистить

Резюме

Таким образом, мы создали проект с кодом Visual Studio с использованием CMake для создания проекта для ARM Cortex с использованием инструментов GNU. Правда (может быть, шокирующая?) В том, что Visual Studio Code - это просто редактор, и ничего больше. Таким образом, вы можете сделать то же самое с любым редактором или IDE, которые вам нравятся: imho, это одна из вещей, которые мне нравятся в VSC: это помощник и помощник, и он не заставляет меня, как что-то делать. Точно так же у вас есть свобода делать то, что вам нравится.

Часть 3 - Сборка

Опубликовано 6 мая 2021 г. по Эриха Styger

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

В предыдущем уроке я использовал командную строку для создания проекта. Это замечательно и очень гибко, но было бы лучше, если бы я мог легко запускать сценарии или команды из IDE. Код Visual Studio - это в первую очередь редактор, но в нем есть инфраструктура, позволяющая выполнять сценарии или запускать программы, не вводя их в командной строке.

Идея состоит в том, что мы можем нажать <CTRL> + <SHIFT> + B для выполнения сборки. Вы можете найти сочетания клавиш в https://code.visualstudio.com/shortcuts/keyboard-shortcuts-windows.pdf или в меню File> Preferences> Keyboard Shortcuts:

Задачи

Существуют различные способы создания и настройки задач кода Visual Studio, см. Код Visual Studio: документация по задачам . Легкий и простой способ - создать папку с именем .vscode и добавить в нее файл tasks.json :

Внутри корневой папки проекта создайте новую папку с именем .vscode.
Внутри этой папки создайте новый файл с именем tasks.json и добавьте следующий контент (доступен на GitHub ):

{
        // See https://go.microsoft.com/fwlink/?LinkId=733558
        // for the documentation about the tasks.json format
        "version": "2.0.0",
        "tasks": [
            {
                "type": "shell",
                "label": "Build Project",
                "command": "cmake --build .",
                "options": {
                    "cwd": "${workspaceFolder}/build"
                },
                "group": {
                    "kind": "build",
                    "isDefault": true
                },
                "problemMatcher": {
                    "base": "$gcc", 
                    "fileLocation": ["relative", "${workspaceFolder}/build"]
                }
            }
        ]
    }

Это создает «задачу» для создания проекта с помощью команды «оболочки» (консоли). «CMake -Build.» команда, которую мы видели в предыдущем уроке .

Для текущего каталога он использует «$ {workspaceFolder} / build », потому что это должен быть текущий рабочий каталог для cmake.

В следующей группе он помечается как команда сборки по умолчанию, которая назначает ее сочетанию клавиш <CTRL> + <SHIFT> + :

"group": {
       "kind": "build",
       "isDefault": true
    },

«ProblemMatcher» назначает сопоставление для gcc для сканирования вывода консоли на предмет сообщений от gcc, поэтому я могу видеть вещи в представлении «Проблемы».

Это всего лишь минимальная задача и далеко не идеальная, но она заставляет нас работать.

Сборка

Теперь я могу просто нажать <CTRL> + <SHIFT> + , чтобы построить проект, с выводом в Терминале внизу:

Один из способов запуска задач - из меню терминала :

В противном случае задачи можно запускать из палитры команд (<CTRL> + <SHIFT> + ):

А затем отфильтруйте и выберите задачу для запуска:

Дополнительные задачи

Таким же образом можно добавлять и выполнять другие задачи. Ниже добавлена задача, добавленная для выполнения команды cmake «очистить с помощью сборки»: добавить следующее в список задач (через запятую):

{
                "type": "shell",
                "label": "clean & build",
                "command": "cmake --build . --clean-first",
                "options": {
                    "cwd": "${workspaceFolder}/build"
                },
                "group": "build",
                "problemMatcher": {
                    "base": "$gcc", 
                    "fileLocation": ["relative", "${workspaceFolder}/build"]
                }
    }

Задача «сборка по умолчанию» может быть только одна, поэтому она просто добавляется в группу «сборка».

Выбор задач для запуска

Выполнить задачу сборки по умолчанию легко с помощью <CTRL> + <SHIFT> + .

Мне потребовалось время, чтобы понять, как выполнить произвольные задачи, которые я определил. Лучший способ, который я нашел, - это:

Сначала нажмите <CTRL> +  . В следующем диалоговом окне введите « задача » (обратите внимание на пробел в конце):

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

Другой способ - снова использовать меню терминала :

Если вы знаете лучший способ без установки расширений, я хочу услышать об этом.

Резюме

С этим я назначил задачу сборки по умолчанию и могу использовать ярлык для ее выполнения. Кроме того, я могу определять собственные задачи или интегрировать скрипты в IDE.

Для более продвинутой настройки: обратите внимание на такие расширения, как xPack C / C ++ Manged Build Tools .

Часть 4 - Отладка

Это об отладке микроконтроллера ARM Cortex-M с помощью кода Visual Studio:

Cortex-M4 (NXP K22FN512) Отладка с помощью кода Visual Studio

Контур

В этой статье я покажу, как отлаживать микроконтроллер ARM Cortex (M4F, NXP K22FN512) с помощью кода Microsoft Visual Studio. Для этого мне понадобятся инструменты и расширения, установленные в части 1 этой серии руководств. Отладка осуществляется с помощью отладочного зонда (J-Link), либо внешнего (автономный отладочный зонд), либо встроенного (доступно на многих платах разработки, например, от NXP или STM). Я использую SWD здесь, потому что FRDM-K22F имеет SWD только в отладочном заголовке, но также можно использовать JTAG.

Отладочный зонд

В этой статье я использую отладочный зонд SEGGER J-Link EDU Mini . Технически можно использовать и другие датчики. J-Link широко доступен, а EDU стоит всего 20 или 20 евро, он очень маленький и универсально работает для многих-многих устройств из коробки.

Кроме того, многие платы производителей микросхем ( LPC4322 или FRDM OpenSDA ) и датчики отладки могут загружать микропрограммное обеспечение J-Link, включая NXP LPC-Link2 или STLink . J-Link можно использовать с GDB, LLDB, OpenOCD или CMSI -DAP .

Запустить файл JSON

Внутри папки .vscode создайте новый файл с именем launch.json со следующим содержимым:

{
        // Use IntelliSense to learn about possible attributes.
        // Hover to view descriptions of existing attributes.
        // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
        "version": "0.2.0",
        "configurations": [
            {
                "cwd": "${workspaceRoot}",
                "executable": "./build/FRDM-K22F_Simple.elf",
                "name": "Debug Microcontroller",
                "request": "launch",
                "type": "cortex-debug",
                "servertype": "jlink",
                "serverpath": "C:/Program Files (x86)/SEGGER/JLink/JLinkGDBServerCL.exe",
                "armToolchainPath": "C:/Program Files (x86)/GNU Arm Embedded Toolchain/10 2020-q4-major/bin",
                "device": "MK22FN512xxx12",
                "interface": "swd",
                "serialNumber": "", // add J-Link serial number if having multiple attached the same time.
                "runToMain": true,
                "svdFile": "${workspaceRoot}/device/MK22F51212.svd",
    
            }
        ]
    }

Вы также можете найти все файлы на GitHub .

Наиболее важные настройки:

« Исполняемый файл »: двоичный файл для загрузки и отладки.
« Serverpath »: путь и имя файла исполняемого файла J-Link GDB Server. См. Часть 1 .
« ArmToolchainPath »: путь к исполняемому файлу arm-none-eabi-gdb. См. Часть 1 .
« Устройство »: идентификатор устройства, используемый для J-Link, см. Веб-сайт SEGGER J-Link .
« RunToMain »: если отладчик должен установить временную точку останова на main () и работать до этого момента.
« SvdFile »: необязательно, это файл CMSIS-SVD для детальной отладки регистров.

Файлы SVD

Запись «svdFile» в файле launch.json является необязательной, но имеет решающее значение для отладки встроенной системы, поскольку она описывает регистры периферийных устройств устройства. Они используются, например, в представлении Eclipse EmbSysRegView, и это хороший источник для получения файлов. При использовании устройств NXP файлы SVD присутствуют в NXP MCUXpresso SDK , но их труднее найти, поскольку NXP не использует стандартное расширение * .svd .

Для файла запуска расширение значения не имеет, но для наглядности рекомендую переименовать его в .svd .

Отладка

Используйте F5 или меню «Выполнить»> «Начать отладку», чтобы начать сеанс отладки:

Это запускает сеанс отладки. В случае проблем проверьте консоль отладки:

Проверьте вкладку ВЫХОД (Вывод адаптера) для вывода из C: / Program Files (x86) /SEGGER/JLink/JLinkGDBServerCL.exe
    Запускающий сервер: "C: / Program Files (x86) /SEGGER/JLink/JLinkGDBServerCL.exe" "-if" "swd" "-port" "50000" "-swoport" "50001" "-telnetport" "50002" " -устройство «MK22FN512xxx12»
    Запуск GDB: "C: \ Program Files (x86) \ GNU Arm Embedded Toolchain \ 10 2020-q4-major \ bin \ arm-none-eabi-gdb.exe" "-q" "--interpreter = mi2"
    undefined C: \ Program Files (x86) \ GNU Arm Embedded Toolchain \ 10 2020-q4-major \ bin \ arm-none-eabi-gdb.exe: предупреждение: не удалось определить путь к каталогу индексного кеша.
    Чтение символов из C: \ Users \ erich \ Data \ GitRepos \ McuOnEclipse \ Examples \ VisualStudioCode \ FRDM-K22F \ FRDM-K22F_Simple \ build \ FRDM-K22F_Simple.elf ...
    0x000006b0 в _exit ()
    Не реализована причина остановки (при условии исключения): undefined
    Сброс цели
    Сброс цели
    
    Временная точка останова 1, main () в ../src/main.c:7
    7 int local = 0;

У меня есть предупреждение и «причина невыполненной остановки» (не знаю почему), но оно работает, и я отлаживаю 🙂

Отладка ARM Cortex-M4F с помощью кода Visual Studio

По умолчанию доступно несколько представлений отладки. С файлом .svd (см. Выше) у меня тоже есть доступ к периферийному регистру:

Шагая

Есть обычные действия отладки (продолжить, пошаговое выполнение, перезапуск) плюс панель инструментов «запустить и отладить» слева:

Сборка Stepping

Для представления «Разборка» или пошагового выполнения кода сборки используйте палитру команд (CTRL + SHIFT + P) с «Cortex»:

Используйте "View Disassembly (Function") с именем функции для отладки этой функции в коде сборки. Используйте "Set Force Disassembly", чтобы переключиться на шаг дизассемблирования для всех функций.

Можно установить точки останова в коде сборки, но нельзя увидеть высокоуровневый (C / C ++) рядом с кодом сборки. И представление дизассемблирования не показывает больше информации или символических символов, как это делает вид дизассемблирования Eclipse CDT.

Вернитесь к «авто», только чтобы показать дизассемблированный код без отладочной / исходной информации:

объем памяти

Для просмотра памяти используйте палитру команд (CTRL + SHIFT + P) с Cortex:

Затем укажите выражение для ячейки памяти и длины:

Затем это показывает память:

Представление памяти очень простое по сравнению с представлениями памяти Eclipse (многими), но для проверки памяти это лучше, чем ничего.

Резюме

Надеюсь, это поможет вам начать работу (ну, отладку) с кодом Microsoft Visual Studio на ARM Cortex-M. Встроенные возможности отладки (память, регистры, сборка) намного более просты по сравнению с представлениями в Eclipse или MCUXpresso IDE, так что точно не до этого уровня (пока?). Но, по крайней мере, с этим я могу выполнять базовую аппаратную отладку на ARM Cortex.

часть 5 - ToolKit

Опубликовано 11 мая 2021 г. по Эриха Styger

Предыдущие части были посвящены установке , настройке проекта , сборке и отладке . Это об определении «набора инструментов», чтобы я мог использовать больше инфраструктуры CMake в Visual Studio Code:

Цепочка инструментов загружена в код Visual Studio

Контур

Для нашего проекта еще нужно настроить несколько вещей. Мы можем создавать и отлаживать, но сборка выполняется с помощью « Задач », а не напрямую через CMake. Это потому, что я еще не настроил «комплект». Я вижу это по статусному сообщению внизу:

Если я попытаюсь создать CMake: clean (используйте палитру команд или CTRL + SHIFT + P ) с помощью CMake: Clean

Есть список «комплектов» (как-то обнаруживаемых автоматически?), Но набор инструментов GNU ARM Embedded, который я установил и использую, не указан:

Сканирование комплектов или использование « неопределенного » просто привело к использованию неправильных комплектов / компилятора, что нарушило сборку ARM Cortex-M, которую я использую :-(.

Очевидно, что CMake с интеграцией Visual Studio чего-то не хватает. Благодаря исследованию и комментариям Мартина в предыдущей части 3 проблема была решена : мне нужно добавить дополнительный файл cmake-kits.json .

Добавление набора с помощью cmake-kits.json

Создайте новый файл в папке .vscode и назовите его cmake-kits.json со следующим содержимым (или скопируйте его с GitHub ):

[
        {
            "name": "GCC Arm Embedded",
            "toolchainFile": "${workspaceRoot}/arm-none-eabi-gcc.cmake"
        }
    ]

Вы можете дать ему любое имя, но оно должно указывать на правильный файл инструментальной цепочки для Cmake. Благодаря этому у меня распознан «комплект», и я могу назначить его проекту, используя значок на нижней панели инструментов:

Действия CMake

Если настроен правильный набор инструментов или набор, я могу использовать такие команды, как CMake: Build или CMake: Clean :

Резюме

Чтобы использовать команды CMake, Visual Studio Code необходимо знать о цепочке инструментов, используя файл cmake-kits.json, находящийся в папке .vscode. Обязательно добавьте его в проект, чтобы разблокировать больше возможностей Visual Studio Code.

часть 6 - IntelliSense

Опубликовано 24 мая 2021 г. по Эриха Styger

Предыдущие части были посвящены установке , настройке проекта , сборке , отладке и настройке комплекта . Речь идет о настройке IntelliSense для кросс-разработки в Visual Studio Code, которая позволяет просматривать символы или автозавершение кода:

Контур

Мощный IntelliSense в Visual Studio Code, вероятно, является * особенностью * Visual Studio Code. Eclipse IDE имеет аналогичную функцию с « Индексатором », но имхо тот, что в Visual Studio Code, не только проще в настройке, но и более мощный.

Если вы не знаете, что делает IntelliSense, посетите https://code.visualstudio.com/docs/editor/intellisense.

Настраивать

Как и все остальное, индексатор в Visual Studio Code использует файл конфигурации JSON. С расширением Microsoft C / C ++ существует графическая утилита настройки (UI). Используйте <CTRL> + :

В следующем пользовательском интерфейсе можно настроить все параметры:

Настройки хранятся в файле .vscode / c_cpp_properties.json внутри проекта. Поэтому вместо использования мастера, описанного выше, просто создайте файл и скопируйте и вставьте шаблон ниже:

{
        "configurations": [
             {
                "name": "CrossARM",
                "includePath": [
                    "${workspaceFolder}/**"
                ],
                "defines": [
                    "CPU_MK22FN512VLH12",
                    "CPU_MK22FN512VLH12_cm4"
                ],
                "forcedInclude": ["${workspaceFolder}/src/IncludeMcuLibConfig.h"],
                "compilerPath": "C:/Program Files (x86)/GNU Arm Embedded Toolchain/10 2020-q4-major/bin/arm-none-eabi-gcc.exe",
                "cStandard": "c17",
                "cppStandard": "c++17",
                "intelliSenseMode": "gcc-arm"
            }
        ],
        "version": 4
    }

name : произвольное имя для конфигурации
includePath : перечислите здесь все места, где IntelliSense будет искать файлы заголовков. Он автоматически будет использовать те, которые находятся в инсталляции инструментальной цепочки (компилятора). Обозначение '**' означает, что он будет искать эту папку рекурсивно.
define : перечислить все дополнительные определения, которые необходимо учитывать.
forceInclude : при использовании параметра компилятора -include убедитесь, что вы указали этот файл здесь
compilerPath : путь к исполняемому файлу компилятора.
cStandard и cppStandard : используемые стандарты C и C ++
intelliSenseMode : используемый режим. 'gcc-arm' считается устаревшим, но не знаете, что использовать в противном случае для ARM?

Применение

Благодаря этому IntelliSense может находить правильные файлы заголовков и определения с помощью используемой инструментальной цепочки. Вы можете проверить это с помощью контекстного меню в стандартной библиотеке, включая (Контекстное меню> Просмотр> Определение ):

Завершение кода и IntelliSense в целом запускаются <CTRL> + <SPACE>:

Вы можете нажать <CTRL>, а затем использовать мышь для перехода к месту: нажмите <CTRL>, наведите на него указатель мыши и щелкните.

Еще одна приятная вещь - предварительный просмотр «скрытно»: удерживайте нажатой кнопку <CTRL> и перемещайте мышь, чтобы увидеть предварительный просмотр этой реализации:

Другой совет - использовать <TAB>: он выберет «наилучшее соответствие» из списка предложений.

Что делает его приятным, так это его осведомленность о документации Doxygen в источниках:

Резюме

Visual Studio Code поставляется с мощным механизмом IntelliSense, который легко настраивается с помощью файла JSON. IntelliSense и автозавершение кода делают кодирование намного проще: это * причина * использования IDE, такой как Visual Studio Code.

часть 7 - FreeRTOS

Опубликовано 2 июня 2021 г. по Эриха Styger

Это новая статья из моей серии об использовании Microsoft Visual Studio Code : после установки , настройки проекта , сборки , отладки , настройки комплекта и IntelliSense . Это о настройке и использовании FreeRTOS :

Код Microsoft Visual Studio с отладкой приложения FreeRTOS на ARM Cortex-M

Контур

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

В этой статье я покажу, как вы можете использовать FreeRTOS и отлаживать его с помощью кода Visual Studio, включая поддержку потоков. Я предполагаю, что вы прочитали мои предыдущие учебные статьи (см. Ссылки в конце этой статьи).

Вы можете найти общие проекты на GitHub: https://github.com/ErichStyger/mcuoneclipse/tree/master/Examples/VisualStudioCode . В этой статье я использую FRDM-K22F_Blinky.

Настраивать

Во-первых, добавьте в свой проект McuLib с FreeRTOS, который включает FreeRTOS:

В ваш CMakeLists.txt добавьте исходные файлы FreeRTOS:

McuLib/src/McuRTOS.c

McuLib/FreeRTOS/FreeRTOShooks.c

McuLib/FreeRTOS/Source/croutine.c

McuLib/FreeRTOS/Source/event_groups.c

McuLib/FreeRTOS/Source/list.c

McuLib/FreeRTOS/Source/queue.c

McuLib/FreeRTOS/Source/stream_buffer.c

McuLib/FreeRTOS/Source/tasks.c

McuLib/FreeRTOS/Source/timers.c

McuLib/FreeRTOS/Source/portable/MemMang/heap_1.c

McuLib/FreeRTOS/Source/portable/MemMang/heap_2.c

McuLib/FreeRTOS/Source/portable/MemMang/heap_3.c

McuLib/FreeRTOS/Source/portable/MemMang/heap_4.c

McuLib/FreeRTOS/Source/portable/MemMang/heap_5.c

McuLib/FreeRTOS/Source/portable/MemMang/heap_useNewlib.c

McuLib/FreeRTOS/Source/portable/GCC/ARM_CM4F/port.c

McuLib/FreeRTOS/Source/portable/GCC/ARM_CM4F/portasm.s

Перечислите каталоги включения RTOS:

1 2	`McuLib/FreeRTOS/Source/include` `McuLib/FreeRTOS/Source/portable/GCC/ARM_CM4F`

Обновите конфигурацию, чтобы включить FreeRTOS:

/* ------------------- RTOS ---------------------------*/
#define McuLib_CONFIG_SDK_USE_FREERTOS              (1)
#define configTOTAL_HEAP_SIZE                       (24*1024)
#define configUSE_HEAP_SECTION_NAME                 (1)
#define configHEAP_SECTION_NAME_STRING              ".bss.$SRAM_LOWER.FreeRTOS"
#define configQUEUE_REGISTRY_SIZE                   (10)

При этом соберите приложение и добавьте задачи по мере необходимости.

Отладка с помощью FreeRTOS Thread Awareness

Я использую SEGGER J-Link для отладки. У него есть возможность включить поддержку потоков FreeRTOS. Добавьте в файл launch.json следующее :

1	`"rtos": "FreeRTOS"`

Осведомленность о FreeRTOS для подключения отладки J-Link

Благодаря этому я могу выполнять отладку со всеми перечисленными потоками FreeRTOS:

Резюме

В коде Visual Studio есть базовая поддержка FreeRTOS, включая поддержку потоков. Конечно, это не на должном уровне с поддержкой отладки FreeRTOS, которую вы получаете в бесплатных IDE на основе Eclipse, таких как NXP MCUXpresso IDE, но этого достаточно для отладки приложений FreeRTOS на любом ARM Cortex.