В данной статье я хотел бы рассказать о начале работы с микроконтроллерами STM32 в бесплатной среде CoIDE, которая основана на Eclipse. В отличии от IAR и других сред разработки, CooCox CoIDE бесплатна и проста в освоении, а также содержит встроенный отладчик ST-Link, что позволяет начинающим изучать STM32 уже через 10 минут заставить вашу плату помигать светодиодом. Если вы еще незнакомы с серией STM32, то рекомендую почитать трилогию об архитектуре STM32, особенностях программирования и прочую полезную информацию.
В качестве STM32 использовалась отладочная плата STM32VLDiscovery доставшаяся нахаляву от фирмы STMicroelectronics с процессором STM32F100RBT6B на борту:
Итак приступим. Идем на официальный сайт CooCox и качаем последнюю версию CooCox CoIDE. Для скачивания необходимо зарегистрироваться, регистрация простая и бесплатная. Затем инсталлируем скачанный файл и запускаем.
CooCox CoIDE — среда разработки, на базе Eclipse, которая помимо STM32 поддерживает кучу других семейств микроконтроллеров: Freescale, Holtek, NXP, Nuvoton, TI, Atmel SAM, Energy Micro и др. С каждой новой версией CoIDE список МК постоянно пополняется. После успешной установки CoIDE запускаем:
Появится стартовое окно Step 1, в котором необходимо выбрать производителя нашего микроконтроллера. Нажимаем ST и переходим к Step 2 (выбор микроконтроллера), в котором необходимо выбрать конкретную модель. У нас STM32F100RBT6B, поэтому нажимаем на соответствующую модель:
Справа, в окне Help отображаются краткие характеристики каждого чипа. После выбора нужного нам микроконтроллера переходим к третьему шагу Step 3 — к выбору необходимых библиотек для работы:
Давайте создадим простейший проект для мигания светодиодом, как это принято для изучения микроконтроллеров.
Для этого нам понадобится библиотека GPIO, при включении которой, CoIDE попросит создать новый проект. На это предложение нажимаем Yes, указываем папку где будет храниться наш проект и его название. При этом, CoIDE подключит к проекту 3 другие, необходимые для работы библиотеки, а также создаст всю необходимую структуру проекта:
Чем еще хорош CoIDE, это тем, что в нем есть возможность загружать примеры прямо в среду разработки. В вкладке Components вы можете видеть, что почти к каждой библиотеке есть примеры, нажимаем на GPIO (with 4 examples) и видим их:
Туда можно добавлять и свои примеры. Как видно на скриншоте выше, в примерах уже присутствует код для мигания светодиодом GPIO_Blink. Можно нажать кнопку add и он добавиться в проект, но как подключаемый файл, поэтому мы сделаем по другому просто скопируем весь код примера в файл main.c. Единственное, строку void GPIO_Blink(void) замените на int main(void). Итак, нажимаем F7 (или в меню выбираем Project->Build), чтобы скомпилировать проект и… не тут то было!
Среде нужен компилятор GCC, а у нас его нет. Поэтому идем на страничку GNU Tools for ARM Embedded Processors, справа выбираем тип вашей ОС и качаем последнюю версию тулчайна. Затем запускаем файл и инсталируем gcc toolchain. Далее, в настройках CoIDE укажем правильный путь к тулчайну:
Опять нажимаем F7 (Project->Build) и видим, что компиляция прошла успешно:
Осталось прошить микроконтроллер. Для этого при помощи USB подключаем нашу плату к компьютеру. Затем, в настройках дебаггера необходимо поставить ST-Link, для этого в меню выбираем Project->Configuration и открываем вкладку Debugger. В выпадающем списке выбираем ST-Link и закрываем окно:
Попробуем прошить МК. В меню выбираем Flash->Program Download (или на панели инструментов щелкаем по соответствующей иконке) и видим, что МК успешно прошит:
На плате наблюдаем мигающий светодиод, видео или фото я думаю приводить нет смысла, т.к. все это видели.
Также, в CoIDE работают различные режимы отладки, для этого нажимаем CTRL+F5 (или в меню Debug->Debug):
На этом все. Как видите, настройка среды CoIDE и работа с ней очень проста. Надеюсь данная статья подтолкнет вас в изучении очень перспективных и недорогих микроконтроллеров STM32.
Теги:
Вознаградить
Я собрал
0
0
x
Оценить статью
- Техническая грамотность
- Актуальность материала
- Изложение материала
- Полезность устройства
- Повторяемость устройства
- Орфография
0
Средний балл статьи: 0
Проголосовало: 0 чел.
Всем привет. В прошлой статье (№77)мы с Вами познакомились с ARM. В этой статье описан пример настройки программного комплекса для работы с микроконтроллером STM32, в данном случае stm32f303vct6 (STM32f3 discovery). Сделав обзор программного обеспечения для работы с STM можно выделить следующие:
— IAR, Keil, Atollic TrueStudio. Все коммерческие, несмотря на то что последняя основана на Eclipse;
— Eclipse с плагином GNU Tools for ARM Embedded Processor и компилятором ARM-GCC;
— CooCox IDE (CoIDE) — основана на Eclipse, бесплатна. Включает в себя всё для работы с ARM;
— STMStudio — программа позволяющая в реальном времени наблюдать значения переменных в МК;
— STM32CubeMX. Громоздкость и сложность периферии в STM32 на начальном этапе может облегчить данная программа. STM32CubeMX позволяет выбрать контроллер и сгенерировать код инициализации настроив пины и схему тактирования под свои нужды.
Еще одна полезная ссылка http://www.st.com/en/development-tools/st-link.html, по ней можна скачать следующие пакеты:
STSW-LINK004. Содержит STM32 ST-LINK utility – утилита для программирования STM. Здесь мы можем по быстрому проверить микроконтроллер на работоспособность. Устанавливаем программу, в ней находится драйвер STLinkDriver. Подключаем плату (контроллер), в моем случае плата STM32F3DISCOVERY (на контроллере stm32f303vct6). Проверяем диспетчер устройств, получаем PID/VID устройства USBVID_0483&PID_374B, что соответствует ST-LINK/V2-1.
Запускаем STM32 ST-LINK Utility – Target –Connect. Соединение прошло успешно.
Хочется добавить что плата идет уже с демонстрационной прошивкой. Также данный файл идет с другими примерами для данной модели с программой STCube, либо можно скачать отдельно пакет en.stm32cubef3.
STSW-LINK009 ST-LINK, ST-LINK/V2, ST-LINK/V2-1 USB driver signed for Windows7, Windows8, Windows10. Это драйвера на всякий случай.
На начальном этапе я выбрал CooCox CoIDE и STM32CubeMX. Давайте знакомится.
CooCox CoIDE — это бесплатная среда разработки для ARM Cortex (ARM Cortex-M0/M0+/M3/M4 based microcontrollers) микроконтроллеров. CoIDE имеет все необходимые инструменты для создания микроконтроллерных программ высокого качества. Это обрезанная версия инструментальной цепочки Eclipse + GCC (GCC-ARM Embedded). Скачиваем программу CoIDE-V2Beta-20170510.exe по следующей ссылке http://www.coocox.org/software/coide.php. Устанавливаем.
Далее устанавливаем компилятор GNU Tools for ARM Embedded Processor по ссылке launchpad.net/gcc-arm-embedded, скачиваем установщик последней версии -arm-none-eabi-6-2017-q2-update-win32. Настраиваем путь к компилятору. Project – Select Toolchain Path — Browse — C:ToolsARMgcc_arm6 2017-q2-updatebin.
Теперь друзья создадим проект Project – New Project. В открывшемся Repositoty, выбираем серию чипа в данном случае STM32F303VC. Созданный файл main.c можем смело удалять.
Дальнейшее содержимое проекта мы наполним с помощью STM32CubeMX, является частью STMicroelectronics STMCube ™, который обеспечивает генерацию кода инициализации C с использованием графических мастеров. STM32Cube охватывает весь портфель STM32. Переходим по ссылке www.st.com/web/en/catalog/tools/PF259242, скачиваем внизу страницы через кнопку «Download», распаковываем скачанный архив и устанавливаем. Запускаем STM32CubeMX.exe(в дальнейшем — просто Куб) и через меню «Help->Install New Libraries» запускаем обновление библиотек, нас интересует Software to configure and manage STM32 MCUs и Firmware Package for family STM32H3.
Создаем проект New Project и выбираем серию и тип контроллера, либо плату. В визуальном редакторе, я всего лишь настраиваю ногу на котором «сидит» светодиод, как выход: PE8 – GPIO_OUTPUT. В закладку «Clock Configuration» можно пока не заходить, нам все равно внешний генератор будет или внутренний. Наша задача настроить комплекс, скомпилировать файл, загрузить и настроить отладку.
Следующий шаг заходим в настройки проекта. Вкладка Project – settings. Вписываем имя проекта, как и в CooCox, выбираем ту же директорию (Projekt Location). Toolchain/IDE выбираем либо SW4STM32 либо TrueStudio, необходимые файлы сгенерируются одинаковые. И генерируем код: Project – Generate Code. По окончанию – Open folder.
Открываем CooCox и простым перетаскиванием добавляем три папки, которые сгенерировал Cube: Drive, Inc, Src. Переходим к настройке проекта. Открываем файл DriversCMSISDeviceSTSTM32F3xxInclude/stm32f3xx.h и определяем тип микроконтроллера, в моем случае #define STM32F303xC.
Далее необходимо открыть папку: C :Cocooxprjtest2 DriversCMSIS Device STSTM32F3xxSourceTemplatesgcc и проверить наличие файла startup_stm32f303xc.s. Если отсутствует то скопировать с папки startap, которая генерируется CubeMX. И необходимо заменить _estack на _eram в файле. _estack-значение по умолчанию в библиотеке ST, но называется так называемым _eram. Определяет конец раздела ПЗУ и указатель стека по умолчанию. Компилятор не понимает и выдаст ошибку. Якобы это для поддержания новых контроллеров.
И последнее, если путь C:UsersАлександр AppDataRoaming CooCoxCoIDEconfigflashCooCox-FlashCoIDE_STM32F3xx_256K STM32F3xx_256.elf до файла, как у меня содержит кириллицу, то обязательно вылезет ошибка Error: Failed to open flash driver file. Здесь необходимо последний файл переместить в какое-нибудь другое место без кириллицы и прописать это в настройках View->Configuration->Download. Добавляем в основной файл,в цикл следующий код, который через 100мс переключает сотояние ноги:
HAL_GPIO_TogglePin (GPIOE, GPIO_PIN_8);
HAL_Delay (100);
Можно компилировать. Ниже результат работы платы STM32f3discovery :
Скомпилировали.Теперь заливаем код: Flash – Program Download. C:CooCoxCoIDE_V2Beta>»C:/CooCox/CoIDE_V2Beta/bincoflash.exe» program STM32F303VC «C:/Cocooxprj/test2/test2/Debug/bin/test2.elf» —adapter-name=ST-Link —port=SWD —adapter-clk=1000000 —erase=affected —reset=SYSRESETREQ —driver=»C:/coocox/stm32f3xx_256.elf»
Erase: Done
Program: Done
Verify: Done
Прошивка выполнилась удачно. На рисунке слева результат.
Теперь про внутрисхемную отладку.для этого заходим в C: CooCoxCoIDE_V2Betabin и открываем батник start_gdbserver.bat, и прописываем в нем реальное расположение файлов.
«C:/CooCox/CoIDE_V2Beta/bingdbserver.exe» «C:/CooCox/CoIDE_V2Beta/binGDBServerParam.ini»
Настраиваем GDBServerParam.ini
[Adapter]
AdapterName=ST-Link
MaxClock=1000000
TraceMode=0
[Device]
Device=STM32F303VC
[Debug]
DebugPort=SWD
ResetMode=2
IfCacheRom=1
[GDBServer]
IP=127.0.0.1
Port=2009
Запускаем в командной строке батник для запуска отладчика. Все можно нажимать Debbug из CooCox отлаживать.
Ниже файл .hex для прошивки:
Blink led at stm32f303vct6 ( Скачали: 66 чел. )
К сожелению в данной программе отладчик не запускается и выдает ошибку gdbserver.exe launch failed! Try to restart debugging again. Поэтому придется в ручном режиме В следующей статье №77 поближе познакомимся с платой STM32F3discovery, и библиотеками для работы с контроллером.
Просмотрено
13879
раз.
В прошлой части мы закончили с настройкой параметров экспорта в программе Cube MX.
Ну собственно теперь нам осталось дать имя проекту и сделать экспорт. По окончанию экспорта, выскочит сообщение в котором мы можем открыть папку с нашим сгенерированным проектом.
На этом с CubeMX закончили. Переходим к среде разработки Coocox (Кокос в простонародии)))
Открываем Кокос
далее вверху выбираем — создать новый проект — Create New Project
Далее выбираем CHIP (ведь мы будем работать с процессором)
Далее в списке выбираем нужный нам процессор. В моём случает это STM2F407VG6T
После этого ствавим галчку напртив CMSIS BOOT. Вместе с ней установится галочка и напротив M4 CMSIS Core — вот её нам нужно снять.
Далее в левой части, нам нужно удалить два файла которые начинаются на system и также после этого удаляем файл main.c (он нам не нужен)
После этого, нам нужно скопировать папки сгенерированные нашим CubeMX в папку с проектом Кокоса. Копируем три папки.
И далее выделяем эти три папки и перетягиваем их в Кокос (добавляем в проект). Стрелочкой указано куда.
Получаем вот такой вид файлов нашего проекта
Далее начинаем раскрывать наш список файлов в папке
Driver->CMSIS->Device->ST->STM32f4xx->Source->Templates-gcc
и удаляем файл startup_.
далее сворачиваем пару папок и переходим вот по такому пути
Driver->CMSIS->Device->ST->STM32f4xx->Include и открываем файл отмеченный на картике указателем мыши. В нашем основном окне этот файл откроется. Листаем вниз и ищем наш процессор, и выделяем его как на картинке и нажимаем копировать — это нужно чтобы добавить это название в конфигурацию проекта
Далее, нажимаем на корневой файл проекта правой кнопкой мыши и выбираем Configuration
У нас откроется вот такое окно
Нажимаем в правой части ADD и добавляем скопированое значение в поле как на картинке
Получаем пот такой вид
ну и переходим к третьей части нашего урока по ссылке — Урок 1. Часть 3
ну и не забываем про спасибо)))
Время на прочтение
10 мин
Количество просмотров 148K
Добрый день, уважаемые хабровчане. В своих прошлых статьях (STM32F1xx — лечимся от ардуинозависимости вместе, STM32F1хх — продолжаем лечение от ардуинозависимости при помощи LCD) я постарался осветить вопросы перехода с 8-битных микроконтроллеров на новые 32-битные STM32F1xx.
В процессе работы с ними, я, разумеется выбирал инструменты себе «по руке» — то есть, старался найти наиболее удобные для меня отладочные платы, программаторы, IDE. В этой статье я хочу поделиться с вами несколькими соображениями на этот счет, а также описать процесс сборки в выбранной IDE операционной системы реального времени FreeRTOS.
Железо
Традиционно начнем с железа.
В прошлых статьях ядром системы была плата STM32VLDISCOVERY.
Плата, безусловно, хороша, и подкупает тем, что ее цена всего 300 рублей. В принципе, хороший инструмент для того, чтобы начать знакомиться с этим семейством микроконтроллеров. Но.
Дело в том, что при выборе отладочной платы, всегда хочется соблюсти баланс количества и качества, то есть с одной стороны, иметь все необходимое для работы, с другой – не хочется чтобы плата превращалась в огромного и дорогого монстра. У STM32VLDISCOVERY баланс смещен в сторону дешевизны и минимализма.
Полазив по e-bay, я нашел для себя более удобную, на мой взгляд, плату, которую и представляю вашему вниманию. Вот она:
Mini-STM32
За 46 долларов нам предлагают:
- Микроконтроллер STM32F103VE, имеющий на борту 512 килобайт флеша и 64 килобайта RAM, USB, SDIO (то есть с карточки читать будет намного быстрее, чем по SPI). Кроме того, так как на плате установлена 100-ногая его версия, у него хватает внешних пинов для управления памятью через FSMC. FSMC – это Flexible Static Memory Controller, очень удобный контроллер статической памяти, начиная с, собственно, SRAM и заканчивая NAND флешками. Настроив его и подключив память к управляющим пинам, мы получаем нашу память, мапированную на адресное пространство контроллера. То есть, с этого момента, все взаимодействия с ней будут для нас прозрачны и эквивалентны простой записи в RAM.
- Цветной TFT-дисплей с разрешением 320х240 и предустановленным резистивным тач-скрином. Дисплей ставится на плату в виде модуля, при желании, можно отвинтить стоечки, к которым он крепится, и использовать плату без него. В дисплейный модуль, помимо дисплея входит еще и повышающий преобразователь для питания его подсветки, а также контроллер тач-скрина, который управляется по SPI. Кроме того, разъем подключен к упомянутому выше FSMC, что делает взаимодействие с ним в разы удобнее.
Для примера – вот так выглядит запись в регистры дисплея, а после – в его память, с использованием DMA:#define LCDRegister (*((volatile u16*) 0x60000000)) #define LCDMemory (*((volatile u16*) 0x60020000)) //… void LCDWriteRegister(unsigned short reg, unsigned short data) { LCDRegister=reg; LCDMemory=data; } void LCDBeginRAMWrite() { LCDRegister=CTR_WRITE_DATA; } int main(void) { //… RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); DMA_InitTypeDef DMA_InitStructure; DMA_DeInit(DMA1_Channel1); //Адрес буфера-источника графики DMA_InitStructure.DMA_PeripheralBaseAddr = (u32) PlasmaBuffer1; //Адрес «точки мапирования» дисплейной памяти DMA_InitStructure.DMA_MemoryBaseAddr = (u32)(&LCDMemory); DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; DMA_InitStructure.DMA_BufferSize = PLASMA_WIDTH*PLASMA_HEIGHT; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Enable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord; DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; DMA_InitStructure.DMA_Priority = DMA_Priority_High; DMA_InitStructure.DMA_M2M = DMA_M2M_Enable; DMA_Init(DMA1_Channel1, &DMA_InitStructure); //… //Собственно, вывод LCDBeginRAMWrite(); DMA_SetCurrDataCounter(DMA1_Channel1, PLASMA_WIDTH*PLASMA_HEIGHT); DMA_Cmd(DMA1_Channel1, ENABLE); }После выполнения последней строчки, управление возвращается программе, так что можно сразу же начинать просчет следующего кадра, пока первый выводится через DMA.
- Слот micro-SD, подключенный к управляющим пинам SDIO-контроллера STMки. Ситуация та же, что и с дисплеем – в нашем распоряжении быстрый и удобный способ общаться с карточкой памяти, намного быстрее, чем SPI.
- USB-разъем и сопутствующая схематика. Как известно, USB-хост определяет наличие устройства на шине по подтягивающему резистору. Соответственно, чтобы иметь возможность сначала совершить какие-либо действия и только потом дать сигнал хосту «я подключен!» нужно подсоединить подтягивающий резистор через транзисторный ключ
На плате это уже сделано за нас, управляющий транзистор подключен к одному из GPIO-пинов, подтягивающие резисторы настроены на Full-Speed USB. - Неиспользованные пины выведены на двухрядный сорокапиновый разъем, второй разъем – дисплейный, третий – разъем под программатор, J-Link совместимый.
- Из приятных бонусов – на плате также присутствует разъем для батарейки, питающей RTC, двухметровая SPI-флешка, один управляемый светодиод, одна кнопка, хороший стабилизатор для питания от USB и max232-конвертер, вместе с разъемом для ком-порта.
Последний, конечно, по моему мнению – самая лишняя часть во всей плате, только занимающая место, но ладно уж, пусть будет.
Кроме того, по отдельной просьбе, за 28 долларов, продавец приложит к плате J-Link-совместимый программатор (а попросту, настоящий клон Segger J-Link, беззастенчиво под него маскирующийся), со шлейфом, полностью совместимым с разъемом на плате.
Подводя итог вышесказанному, я считаю данную плату вещью первой необходимости для человека, который решил начать изучение STM32F1xx микроконтроллеров.
Софт
Теперь то, что касается IDE. Изначально я выбрал Keil uVision, так как когда-то уже работал с ней.
Ну, что я могу сказать – я проработал в кейле достаточно, и в принципе с ним можно примириться. Но, положа руку на сердце – ИДЕ там ужасна. Также ужасна как и ИДЕ IAR’a, на мой взгляд.
IAR и Keil – признанные лидеры в разработке компиллеров, этого у них не отнять, но я до сих пор не могу понять, почему, имея такие компиллеры, они продолжают тянуть свои IDE, застрявшие по удобству на уровне 2002 года. Как пример могу привести Texas Instruments – у них раньше тоже была своя IDE, в довесок к компиллеру. Потом им это надоело, они взяли Eclipse, допилили его, прикрутили к своим компиллеру и профайлеру, и получили отличный продукт. Почему так не поступят Keil и IAR для меня остается загадкой, но на мой взгляд их IDE не такие удобные, как могли бы быть. Раздражает не очень удобная подсветка синтаксиса, полное отсутствие code-completion’а, не самая удобная навигация по коду. Плюс, uVision частенько у меня падала, но это можно списать на драйвер программатора.
Как бы то ни было, я стал искать альтернативу и нашел ее в виде CooCox IDE.
Это бесплатная среда разработки на базе эклипса, которая призвана работать, разумеется, с GCC.
Из плюсов отмечу все достоинства эклипса – удобная навигация, есть автозавершение кода и т.п.
Кроме того прикручен удобный просмотрщик периферии процессора, мне понравился больше чем Кейловский. Очень удобно наличие репозитория компонентов – говоря по-простому, при старте проекта мы как в визарде выбираем нужный нам процессор из списка, после чего отмечаем галочками те из модулей Standard Peripheral Library, которые хотели бы использовать, и они автоматически подключаются к проекту (Об этом чуть подробнее в следующем разделе статьи). Также сразу же можно просмотреть примеры, идущие в комплекте с этим модулем SPL и справку по его функциям.
Минусы CooCox IDE вобрала также из Eclipse, к коим относится тяжеловесность – у меня она потребляет около 180 метров оперативной памяти, занимая на диске 800 мегабайт.
Еще одним минусом является ее работа с этим самым J-Link-ком. Отладка происходит через приложение от создателей J-Link’a, предоставляющее стандартный gdb-шный интерфейс, но почему-то среда при каждом дебаге это приложение перезапускает, в отличие от того же кейла (который вообще работает через свои дллки).
Поэтому старт отладки в Кейле начинается через секунду, в CooCox же – через секунд 20. Возможно, это можно как-нибудь исправить настройками, но я пока таких настроек не видел, поэтому буду благодарен, если кто подскажет.
Тем не менее, я все таки остановился на CooCox — если вас тоже не устраивает IDE от Keil или IAR, или вы не хотите пользоваться ломанным ПО и предпочитаете опенсорс – качайте не задумываясь.
CooCox и FreeRTOS
Об операционной системе FreeRTOS было сказано много, в частности, на хабре (вот, например, одна из статей: FreeRTOS: введение)
Я решил тоже приобщиться к этой технологии и расширить свой арсенал инструментов, тем более, что FreeRTOS не навязывает никакого HAL (Hardware Abstraction Layer, слой абстракции от оборудования, драйверы то бишь), и предоставляет только средства работы с задачами, синхронизацию и меж-процессное взаимодействие, поэтому во многих случаях будет очень удобна.
Рассмотрим поподробнее, что же нам необходимо, чтобы использовать FreeRTOS вместе с CooCox IDE на нашей плате Mini-STM32.
На самом деле, все очень просто. Архитектурное портирование (портирование кода, требуемого шедулером под архитектуру Cortex M3) уже давно выполнено, и нам нужно, по сути, просто правильно составить проект для CooCox.
Начинаем с того, что скачиваем исходники FreeRTOS с их официального сайта.
Вот прямая ссылка: http://sourceforge.net/projects/freertos/files/.
Тем временем создаем новый проект в CooCox, я назвал его FreeRTOS-Mini.
Выбираем в визарде производителя ST, в списке чипов – чип, на котором построена отладочная плата, STM32F103VE.
После этого перед нами открывается уже упомянутое окошечко репозитория компонентов, представляющих собой части SPL.
Выбираем там CMSIS Core и CMSIS Boot – это собственно ядро CMSIS и стартовый код, который производит настройку и дергает main()
Кстати, обратите внимание – в CooCox стартовый код написан целиком на C, ни одной асмовой строчки. Лежит в файле cmsis_bootstartupstartup_stm32f10x_hd.c – запомните этот путь, нам нужно будет там кое-что подправить. Заодно добавляем в проект модуль GPIO, чтобы было что поделать в тестовом таске FreeRTOS. Этот модуль автоматом потянет за собой зависимый RCC, отвечающий за настройку клоков.
Теперь возвращаемся к скаченным исходникам FreeRTOS. Для начала скопируем всю папку в папку с нашим проектом. После, начнем удалять лишнее. Итак, лично у меня под нож сразу пошло содержимое папки Demo – там лежат демо-приложения для разных контроллеров, вся папка вам не нужна в любом случае, но при желании можно оставить то, что относится к STM32F103. Единственное, что нам оттуда обязательно понадобится – файл настроек ядра FreeRTOS, который можно взять из любого подходящего проекта, допустим отсюда: DemoCORTEX_STM32F103_Primer_GCCFreeRTOSConfig.h
Его можно скопировать в любую папку инклудов, я лично положил в самый корень проекта, рядом с main.c
Далее, в папке sourceportable есть множество под-папок, где лежит код, рассчитанный на разные компиллеры и среды. Заходим в папку sourceportableGCCARM_CM3, копируем ее двумя уровнями выше, в sourceportable. Обращаем внимание на папку sourceportableMemMang – она нам тоже понадобится. Поэтому удаляем все, кроме sourceportableMemMang и свежескопированной sourceportableARM_CM3
После этого кликаем правой кнопкой в прожект эксплорере CooCox, нажимаем Add Linked Folder и добавляем нашу папку с подготовленными исходниками FreeRTOS. В итоге должно получиться вот такое дерево проекта:
Теперь начинаем править файлы проекта. Начнем с настроек ядра. Оттуда нам нужно будет убрать только пару строчек, связанных со старым проектом – левый, ненужный нам инклуд.
/* Library includes. */
#include "stm32f10x_lib.h"
Все остальное можно оставить без изменений, а можно прочитать статью о настройке ядра FreeRTOS и поменять опции по необходимости, этим мы сейчас заниматься не будем.
Теперь идем в стартап код (cmsis_bootstartupstartup_stm32f10x_hd.c) и делаем следующее: находим строки:
/*----------Function prototypes-----------------------------------------------*/
extern int main(void); /*!< The entry point for the application. */
extern void SystemInit(void); /*!< Setup the microcontroller system(CMSIS) */
void Default_Reset_Handler(void); /*!< Default reset handler */
static void Default_Handler(void); /*!< Default exception handler */
У меня это строки 114-122, и добавляем после них такой код:
extern void xPortPendSVHandler( void ) __attribute__ (( naked ));
extern void xPortSysTickHandler( void );
extern void vPortSVCHandler( void ) __attribute__ (( naked ));
Это обработчики прерываний из ядра ОС, которые объявлены в файле port.c. Теперь нам нужно запихнуть их в вектор прерываний, который идет ниже (строки 129-209):
__attribute__ ((section(".isr_vector")))
void (* const g_pfnVectors[])(void) =
{
/*----------Core Exceptions-------------------------------------------------*/
(void *)&pulStack[STACK_SIZE-1], /*!< The initial stack pointer */
Reset_Handler, /*!< Reset Handler */
NMI_Handler, /*!< NMI Handler */
HardFault_Handler, /*!< Hard Fault Handler */
MemManage_Handler, /*!< MPU Fault Handler */
BusFault_Handler, /*!< Bus Fault Handler */
UsageFault_Handler, /*!< Usage Fault Handler */
0,0,0,0, /*!< Reserved */
vPortSVCHandler, /*!< SVCall Handler */
DebugMon_Handler, /*!< Debug Monitor Handler */
0, /*!< Reserved */
xPortPendSVHandler, /*!< PendSV Handler */
xPortSysTickHandler, /*!< SysTick Handler */
Соответственно, меняем вектор так, как написано в вышеизложенном коде, заменив строки, отмеченные SVCall Handler, PendSV Handler, SysTick Handler на vPortSVCHandler, xPortPendSVHandler и xPortSysTickHandler соответственно.
UPD:
В комментариях мне подсказали более изящный вариант, чем ковыряние стартового файла. Достаточно просто переопределить обработчики следующими дефайнами:
#define vPortSVCHandler SVC_Handler
#define xPortPendSVHandler PendSV_Handler
#define vPortSVCHandler SVC_Handler
#define xPortSysTickHandler SysTick_Handler
После открываем в дереве проекта папку SourceMemMang, и выбираем ту реализацию мемори менеджмента, которая нам подходит. Подробнее об этом написано тут: FreeRTOS Memory Management.
Если коротко – файл номер 1 это упрощенная реализация с выделением памяти, но без освобождения, файл номер 2 – более продвинутая реализация, позволяющая освобождение памяти, и номер 3 – реализация, которая потребует от вас библиотеки с реализованными malloc и free. Я выбрал вторую реализацию, оставшиеся два файла исключаем из компиляции, кликнув правой кнопкой на имя файла в дереве проекта и выбрав пункт Exclude from build.
Осталось совсем чуть-чуть – открываем файл main.c, добавляем туда нужные нам инклуды от SPL:
#include "stm32f10x.h"
#include "stm32f10x_gpio.h"
#include "stm32f10x_rcc.h"
Инклуды от FreeRTOS:
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
После объявляем функцию, которая будет вызвана до старта шедулера, в соответствии с рекомендациями в таком виде:
static void prvSetupHardware( void );
И функцию, которая будет исполнять роль нашего тестового таска, вот так:
static void prvLedBlink( void *pvParameters );
Реализация функций выглядит так:
void prvSetupHardware()
{
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
}
void prvLedBlink( void *pvParameters )
{
GPIO_SetBits(GPIOB,GPIO_Pin_5);
while(1);
}
В тестовых целях ничего полезного не написал, задача просто зажигает светодиод на плате.
Осталась сама функция main(), которая стартанет задачу и шедулер:
int main(void)
{
prvSetupHardware();
xTaskCreate(prvLedBlink,(signed char*)"LED",configMINIMAL_STACK_SIZE,
NULL, tskIDLE_PRIORITY + 1, NULL);
/* Start the scheduler. */
vTaskStartScheduler();
while(1);
}
Вот в принципе и все. Осталось настроить дебаг – для этого жмем «Debug configuration», во вкладке Debugger выбираем наш программатор (J-Link) и порт JTAG.
Ставим галочку Run To Main, чтобы не барахтаться в стартап-коде, в строке GDBServer cmdline tool указываем путь к экзешнику, идущему с программатором (скачать можно с сайта Segger), у меня это C:SEGGERJLinkARM_V440bJLinkGDBServerCL.exe
После жмем Apply и Close.
Теперь компиллим наш проект и жмем на дебаг – если все получилось, после аплода и выполнения, должен загореться светодиод.
Заключение
Правильный выбор инструментов разработчика, безусловно, обеспечит наиболее быстрое и комфортное освоение новых технологий. Я надеюсь, что, осветив в данной статье отладочную плату Mini-STM32 и CooCox IDE, я помог разработчикам приглядеться к новому инструменту. Что касается операционной системы FreeRTOS – это бесспорно очень мощное средство, и, на мой взгляд, хорошая ступень, для перехода от программирования прошивок «в лоб» к использованию эмбеддед операционных систем.
Ссылки
Страничка eBay где можно купить отладочную плату
Официальный сайт CooCox
Официальный сайт FreeRTOS
Русский мануал по FreeRTOS
Доброго дня! В предыдущих моих статьях по микроконтроллерам STM32 я ничего не говорил об аппаратной части, а только о программной, касающейся больше языка СИ, показав возможности этого типа микроконтроллеров в работе с графическим дисплеем.
Сейчас мы приступим к созданию проекта с нуля. Итак, среди большого выбора микроконтроллеров семейства STM32 мы выбрали тот, который популярен, недорог и является достаточно мощным — пусть будет все тот же STM32F103VCT6. Чтобы работать с ним нам нужны два мануала STM32F103VCT6-STMicroelectronics.pdf (2Mb) и STM32 Reference manuals.pdf (10Mb). В Reference manual дается общее описание для семейства STM32 F101,F102,F103,F105,F107 — а именно, то, что имеет общее устройство и общие принципы работы. В STM32F103VCT6-STMicroelectronics.pdf даны распиновка разных типов корпусов, адресация модулей и памяти — то есть то, что имеет частные отличия от основного описания.
Итак скачиваем оба мануала, открываем тот, который 2Mb и смотрим Pinouts. STM32F103VCT6 выпускается в трех корпусах (64pin, 100pin, 144pin). Пусть мы будем использовать контроллер с платы HY-MINI STM32, то есть на 100 вывод0в,
Хочу обратить внимание, что распиновка у микроконтроллеров STM32 F101 — F107 одинаковая. Переходим к выбору среды разработки. В настоящее время среди наиболее популярных сред есть Keil, IAR и CooCox IDE. Первые две платные, а третья абсолютно бесплатна и это значит, что есть смысл начать именно с нее. Но забегу вперед. Если вы займетесь отладкой устройств на данных типах микроконтроллеров, то тут безусловный лидер Keil (о нем я немного рассказал в предыдущих уроках). А с точки зрения удобства для тех, кто только начал изучать STM32 здесь я отдаю предпочтение CooCox IDE.
И так, если вы решили пользоваться Keil: будем считать, что он установлен на вашем компьютере (как это сделать сказано в предыдущих уроках). Создаем папку, в которой будет располагаться наш проект, назовем ее My_project или как сами хотите. Потом нам потребуется библиотека с описанием ядра и других периферийных модулей Libraries.rar. Эта библиотека подходит для всех микроконтроллеров типа STM32F10X, так что вам не составит труда выбрать другой тип микроконтроллера. Скачиваем её и разархивируем в папку My_project. Этого набора достаточно для того, чтобы начать писать свой проект с использованием названий, которые используются в datasheet на микроконтроллер. Без них каждому регистру, биту, пришлось бы прописывать свой адрес (об этом позже). Это было бы познавательно с точки зрения изучения, но совсем неудобно для работы, так как отнимало бы кучу времени. Благо это сделали за нас и нам достаточно будет просто их использовать.
Скачаем еще один архив User.rar и разархивируем в папку My_project. В нем есть файл настройки частоты тактирования system_stm32f10x.c. У микроконтроллера нет фьюзов, к которым мы привыкли у PIC и AVR, поэтому первоначально микроконтроллер запускается на внутреннем RC генераторе 8Мгц. После он налету переключает настройки, в данном файле происходит настройка на частоту 72Мгц. В разархивированной папке User есть также файл stm32f10x_conf.h, который необходим для подключения тех самых модулей из Libraries, которую скачали выше. Рекомендую скачать этот архив, а потом редактировать файлы…
Создаем третью папку в My_project под названием MDK-ARM.
Я придерживаюсь стандартной иерархии папок, то есть в папке проекта создаю три другие папки: User, MDK-ARM и Libraries. Папку Libraries никогда не трогаю, в User хранятся все собственные файлы и дополнительные наши библиотеки, в MDK-ARM — файлы проекта, здесь же и все его дополнительные файлы, появляющиеся по ходу компиляции. Это очень удобно, и у Вас никогда не будет путаницы. Советую сделать так (пример можете посмотреть из предыдущего урока по STM32).
И запускаем среду разработки Keil. Выбираем из меню Project вкладку New uVision Project. Появляется окно CreateNewProject. Вводим имя и сохраняем в MDK-ARM. Далее открывается полный список микроконтроллеров — здесь производители Samsung, Cypress, Atmel, Actel, Analog Devices и другие, что не может не радовать, потому что все эти микроконтроллеры разных производителей принадлежат одному семейству ARM. Выбираем наш STMicroelectonics и там STM32F103VC. Потом среда предлагает скопировать файл startup, с которого запускается проект, соглашаемся. В окне Project отображается дерево проекта, сейчас там только файл startup. Нажимаем правой кнопкой наTarget 1 и выбираем Add Group, там создаем User. Опять нажимаем правой кнопкой на Target 1 и выбираем Manage Components. Здесь мы можем переименовать Target 1 на другое осознанное имя — какое больше нравится. На списке Groups отображается наша User. Группы мы можем удалить, переименовать, добавить новые. Создаем еще группу StdPeriph_Driver. Названия могут быть любые, просто я назвал так как называются папки. Нам сейчас надо добавить файлы в каждую группу. Сделаем это как у меня на картинке. 
А в группу StdPeriph_Driver добавляем все файлы из My_projectLibrariesSTM32F10x_StdPeriph_Driversrc. Добавлять можно и проще в окне Project дважды щелкнув левой кнопкой мыши на нужной нам группе и выбрав сразу много файлов. Хочу обратить внимание: добавление файлов в окно Project равнозначно действию директивы #include «file».
Если вам надо создать файл, то открываем обычным способом папку User, там нажимаем правой кнопкой мыши создать файл txt, переименовываем его и его расширение на xxx.c (обратите внимание чтобы у вас показывались расширения файлов), потом возвращаемся в Keil и добавляем указанный файл. Жмем на меню Project ->Options for Target, переходим на Output, ставим галочку Create Hex File, иначе он не будет генерироваться. Переходим на C/C++, ставим галочку на One ELF Section per Function и в Incluse Path подключаем все папки нашего проекта, иначе компилятор не будет знать где искать — нажимаем на кнопке многоточие. Получается вот так 
Жмем OK. Теперь на вкладке Debug надо настроить отладчик. Если Вы оставите как есть, то в процессе отладки он будет ждать ответа в нашей функции SystemInit() и зависнет и могут возникнуть проблемы с заливкой, поэтому настраиваем так
С настройками проекта закончено. Открываем файл main.c из группы User. Этот файл и является основным файлом проекта, в нем то мы и начинаем писать текст. Здесь подключен уже заголовочный файл #include «stm32f10x.h». Функция main() содержит только SystemInit(), которую можно убрать если хотите (перестройка частоты на 72 Мгц от внешнего кварца). Жмем Project->Build Target. Если вы все сделали правильно, то проект откомпилируется — выдаст: 0Errors; если нет — то проверяйте заново, возможно что-то не добавили.
Теперь откройте файл stm32f10x_conf.h из группы User. В нем должны быть не закомментированы следующие строки
#include «stm32f10x_gpio.h» // для работы с портами ввода-вывода
#include «stm32f10x_rcc.h» // для работы с системой тактирования
Далее создаем функцию void Setup_pin(void) {} выше главной функции main, в ней включим тактирование порта, как это сделать можно посмотреть в файле stm32f10x_rcc.h:
(строки 691-693).
Для тактирования порта D добавляем строку: RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD , ENABLE); //
После настраиваем выводы. Здесь очень странная особенность — объявлять структуру нужно в самом верху функции, поэтому нам пришлось создать новую функцию Setup_pin() (иначе компилятор выдаст ошибку), поэтому функцию Setup_pin() вызываем из main() после SystemInit().
В файле stm32f10x_gpio.h смотрим структуру настройки выводов (строки 90-100)
Объявляем GPIO_Struct1 структурой типа GPIO_InitTypeDef:
GPIO_InitTypeDef GPIO_Struct1;
У каждого вывода есть следующие параметры, такие как скорость
тип вывода
номер вывода
Из вышеприведенного пишем
GPIO_Struct1.GPIO_Pin=GPIO_Pin_1; // то есть PORTD.1
GPIO_Struct1.GPIO_Speed=GPIO_Speed_2MHz; // работает со скоростью 2 Мгц. Чем больше скорость тем больше расход тока
GPIO_Struct1.GPIO_Mode=GPIO_Mode_Out_PP; // на выход с подтягиванием к нулю или напряжению питания
GPIO_Init(GPIOD , &GPIO_Struct1); // инициализация выше написанного
Из того же файла stm32f10x_gpio.h функции работы с портами 
Мигание реализуем в функции while (1), чтобы оно было бесконечно
GPIO_SetBits(GPIOD, GPIO_Pin_1); // установить бит
Delay(500000); // задержка, иначе мигание мы не увидим
GPIO_ResetBits(GPIOD, GPIO_Pin_1); // сбросить бит
Delay(500000); // 500 тысяч тактов
Чтобы работала функция Delay(), ее надо создать
void Delay(int i) {for (; i != 0; i—);} и разместить выше функции main().
В итоге должно получиться вот так и откомпилироваться.
Как видим очень много того, на что терять время и не стоило — обычно берется шаблон какой-нибудь программы и переделывается. Для тех у кого не получилось, можете скачать архив после проделывания всех этих махинаций My_project.rar.
Теперь вернемся к CooCox IDE.Скачиваем среду разработки отсюда CooCox IDE. Нажимаем на Download through CoCenter (Recommend). Вводим адрес эл.почты любой даже не ваш. В первой строчке, где написано CooCox CoIDE нажимаем Download. Весит более 400Мб. Как скачается, устанавливаем.
Потом ищем gcc компилятор. Справа в колонке Download скачиваем файл ***.exe и устанавливаем. Открываем программу CooCox CoIDE, на меню Project выбираем вкладку Select Toolchain Path. Указываем путь к файлу arm-none-eabi-gcc.exe (по-умолчанию ищем его в Program FilesGNU Tools ARM Embedded4.9 2014q4bin). Всё — мы установили среду CooCox IDE.
Теперь повторим то же что мы сделали в Keil.
Как только запускаем CooCox открывается страница Welcome. На ней выбираем Browse in Repository. Потом ST. Потом свой микроконтроллер STM32F103VC и у нас открывается список подключаемых библиотек
Как мы видим, такого удобного подключения библиотек в Keil просто нет, там все библиотеки мы подключаем вручную!!! Я думаю, что вы это попробовали выше.
Для нашей первой программы понадобится: CMSIS core, CMSIS Boot, RCC, GPIO. CMSIS core и CMSIS Boot — системные, подключить обязательно. RCC — для работы с системой тактирования, GPIO — для работы с портами ввода-вывода.
Потом из меню View->Configuration на вкладке Debugger выбираем адаптер. Программного отладчика здесь нет, чего нельзя сказать о Keil, а вот это большой недостаток CooCox!!!! Надеемся, когда-нибудь они его исправят. Из аппаратных отладчиков я рекомендую St-link, так он самый популярный и его можно использовать в среде Keil или вообще отдельно от среды разработки — с утилитой STM32 ST-LINK utility для заливки/сливки прошивки.
В окне Project открываем файл main.c, в начале которого добавляем строки
#include «stm32f10x_gpio.h»
#include «stm32f10x_rcc.h»
Как и в примере для Keil размещаем функццию задержки
void Delay(int i) {for (; i != 0; i—);}
Настраивать частоту мы здесь не будем, поэтому настройку портов пишем сразу в функции main(). Вообще файлы на си взаимозаменяемы. И можете файлы оттуда разместить здесь, а из этой среды туда. Скорее, даже не потребуются изменения. Вот что у нас получается
Еще обе среды разработки чувствительны к регистру — если поменять заглавную на строчную, то при компиляции появится ошибка.
Всего Вам доброго.