Keil руководство на русском

Статья носит характер небольшого мануала о том, как начать программировать микроконтроллеры STMicroelectroniks на примере популярного и простого в освоении семейства stm32f1

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

Основные вопросы этой заметки:

• как начать разрабатывать ПО для stm32 в Keil;
• что для этого необходимо.

Начать необходимо со второго вопроса. Необходимый минимум это среда программирования (Keil), программатор и отладочная плата. Можно конечно и в симуляторе запускать программу, но это не так инетресно, так что плата и программатор нужны. Где брать писать не буду, не моя это забота.

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

Я сразу же после установки на новую машину произвожу настройку среды программирования:

Вот так они выглядят. Теперь по пунктам, что и где настроено.

• Изменена кодировка файлов на юникод, так у вас гарантированно будут отображаться русские символы в комментариях
• Настраиваю замену табуляции на 4 пробела (это довольно холиварная тема, но я любю так), с такими настройками код гарантированно одинаково будет выглядить в любом редакторе.

Теперь установим паки (различные библиотеки) необходимые для разработки под наш чип. Минимум установлен на картинке. FreeRTOS на самом деле не обязательно устанавливать, но пусть будет, ведь после игр с различной переферией будет пытаться оседлать её.

И так, все настройки сделаны, всё установлено, пробудем создать новый проект. Делается это через меню Project->New μVision Project...
Сразу после нажатия откроется окно с предложением выбрать используемый чип, его название можно посмотреть на корпусе =)

Следующим этапом нам будет предложено выбрать необходимые в нашей работе паки. Отмечаем всё как на картинке.

• CMSIS (Cortex Microcontroller Software Interface Standard);
• Startup — это ассемблерный файл для запуска нашей программы, с содержимым можно будет ознакомиться самостоятельно;
• STDPeriph — Библиотека переферийных устройств:
  • Fraemwork — оснойной файл, подлючающий бибилотеку;
  • GPIO — для управления портами ввода-вывода;
  • RCC — для управления тактированием.

Всё выбрано, значить пожно приступать к следующему шагу. Настройка проекта. открывается через меню Project->Option for Target...

Рассмотрим наиболее интересные и необходимые вкладки.

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

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

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

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

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

Ну вот с настройка мы разобрались.

Приступим к написанию кода.

Программа для микроконтроллера выглядит в виде бесконечного цикла. Что бы это понять предлагаю ознакомиться с кодом:

/* Точка входа в программу */
int main( void )
{
    /*
    Здесь производится инициализация основных узлов программы и микроконтроллера
    */

    while( 1 )
    {
        /*
        Вечный цикл необходим для работы, иначе программа останомиться
        Сюда обычно помещают код который выполняется постоянно 
        или оставляют цикл пустым если работают на прерываниях, можно совмещать.
        */
    }
}

Что нужно сделать чтоб ы помигать светодиодом?

1. Включить тактирование порта к которому подключен светодиод;
2. Настроить порт на выход;
3. в вечном цикле переключать вывод с небольшой задержкой то в 0, то в 1.

Вот и наш учебный код:

#include "stm32f10x.h"
#include "stm32f10x_gpio.h"     // Файл с функциями управления ножками контроллера
#include "stm32f10x_rcc.h"      // Управление тактированием
#include <stdint.h>             // Правильные типы данных, вместо всяких int, char и тому подобных

// Далее будут ссылки на страницы референс мануала, его можно сказать по ссылке:
// https://www.st.com/resource/en/reference_manual/CD00171190.pdf

// Примитивнейшая функция задержки
// Для орагнизации задержек (или периодических событий)
// обычно применяются таймеры, но нам пока рано, так что
// тупо мотаем такты

void Delay( void )
{
    for( uint16_t i = 0; i <= 50000; i++ )
        for( uint16_t j = 0; j <= 25; j++ );
}

// точка входа в программу, всегда именно "int main ( void )"
int main( void )
{

    // ---------------- Включаем тактирование порта GPIOC
    // 1. С использованием SPL
    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOC, ENABLE );  

    // 2. С использованием CMSIS, магические числа
//    RCC->APB2ENR |= (1 << 4);                       // см 146 стр. 
    // ---------------- 

    // ---------------- Инициализируем ногу со светодиодом (PC13 - Порт С нога 13)    
    // 1. С использованием SPL
    GPIO_InitTypeDef PortC;                     // Структура с необходимыми полями
    PortC.GPIO_Mode         = GPIO_Mode_Out_PP;     // Выход пуш-пул, см 164 стр.
    PortC.GPIO_Speed        = GPIO_Speed_10MHz;     // По сути это ток который сможет обеспечить вывод
    PortC.GPIO_Pin          = GPIO_Pin_13;          // Номер ноги
    GPIO_Init(GPIOC, &PortC);                       // Применяем настройки

    // 2. С использованием CMSIS
//    GPIOC->CRH |= (0x00 << 22) | (0x01 << 20);      // см 172 стр. 
    // ---------------- 

    // Основной цикл, программа ВСЕГДА должна зацикливаться!!!
    // Не всегда наполнен чем-то вразумительным, иногда может быть пустым, 
    // например когда вся логика реализована в прерываниях.
    while( 1 )
    {
        // ---------------- Устанавливае ногу со светодиодом (PC13 - Порт С нога 13)
        // 1. С использованием SPL
        GPIO_WriteBit(GPIOC, GPIO_Pin_13, Bit_SET);     
        // 2. С использованием CMSIS и ODR регистра, см 173 стр.
//        GPIOC->ODR |= (1 << 13);                     
        // 3. C использованием CMSIS и BSRR регистра, см 173 стр.
//        GPIOC->BSRR = (1 << 13);                        
        // ---------------- 

        Delay();

        // ---------------- Сбрасываем ногу со светодиодом (PC13 - Порт С нога 13)
        // 1. С использованием SPL
        GPIO_WriteBit(GPIOC, GPIO_Pin_13, Bit_RESET);   
        // 2. С использованием CMSIS и ODR регистра, см 173 стр.
//        GPIOC->ODR &= ~(1 << 13);                       
        // 3. С использованием CMSIS и BRR регистра , см 174 стр.
//        GPIOC->BRR = (1 << 13);         
        // 4. С использованием CMSIS и BSRR регистра , см 173 стр.
//        GPIOC->BSRR = (1 << 29);                 
        // ---------------- 

        Delay();        
    }
}
// В конце файла для Кейла обязательна пустая строка! Хз зачем, просто нужна.

Код мигалки специально реализован несколькими возможными способами, используя STDPeriph и без него (только CMSIS)

Проект с этим кодом можно скачать здесь. Но лучше научиться создавать проект с нуля.

Будут вопросы пишите в комментариях, я обычно быстро отвечаю.

Как всегда — Спасибо за внимание и хорошего кодинга! =)

Статья посвящается Пановой Ксении.

Все картинки в этой статье кликабельны.

STM32 — это семейство 32-разрядных микроконтроллеров фирмы STMicroelectronics.

Микроконтроллеры содержат микропроцессорное ядро ARM, точнее ARM Cortex-M. Это ядро присуще не только микроконтроллерам STM32, оно существует само по себе, и на его основе выпускается множество микроконтроллеров от разных производителей.

Keil MDK-ARM (произносится «Кеил эм-ди-кей арм») — это среда разработки для микроконтроллеров с ядром ARM Cortex-M.

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

Существует множество других сред разработки. Например, последнее время автор пользуется средой, которую описал в другой статье. Но в этой пойдет речь о Keil MDK-ARM, потому что она имеет большую популярность и достаточно проста.

Первым делом качаем последнюю версию Keil MDK-ARM с официального сайта. Она имеет ряд ограничений, которые не влияют на большинство задач. Самое существенное ограничение состоит в том, что среда не сгенерирует программу объемом больше 32 КБ, но такую программу надо постараться написать. Хотя микроконтроллеры STM32 часто имеют намного больший объем, вплоть до 2 МБ.

На момент написания статьи последняя версия Keil MDK-ARM — 5.18 (от 5 февраля 2016).

Чтобы скачать среду, надо заполнить форму на сайте Keil:

Следует ввести настоящий адрес электронной почты, иначе сайт будет ругаться. После заполнения и нажатия Submit, дается ссылка для скачивания:

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

Качаем и устанавливаем. Установленная среда занимает на диске около 1,3 ГБ. После установки автоматически запускается менеджер пакетов:

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

Менеджер пакетов появился в MDK-ARM версии 5, что уменьшило объем установочного файла почти в два раза (версия 4.71 была объемом 550 МВ, а версия 5.00 — 300 МБ).

В левой части менеджера мы выбираем устройства (микроконтроллеры), а в правой соответствующие им пакеты.

Допустим, нам надо вести разработку под микроконтроллер STM32F407VG, который установлен на отладочной плате STM32F4-Discovery.

Тогда находим этот микроконтроллер в списке слева и устанавливаем соответствующий пакет DFP:

Можно заметить, что среди установленных пакетов есть CMSIS. CMSIS — это библиотека для ядра Cortex-M, общая для всех микроконтроллеров. Библиотека разрабатывается фирмой ARM и доступна для скачивания с официального сайта после регистрации. Можно было бы не устанавливать этот пакет, а пользоваться официальным выпуском библиотеки, но это дополнительные сложности.

Закрываем менеджер пакетов и запускаем Keil uVision5 (произносится мю-вижен):

Keil uVision5 — это часть MDK-ARM, графический интерфейс среды, который включает редактор кода:

Я рекомендую произвести небольшую настройку редактора. Выбираем меню «Edit -> Configuration…», и производим следующие настройки:

1. Кодировка UTF-8.
2. Правая граница кода в 80 символов.
3. Отступы по 4  пробела.

Эти настройки довольно спорные. У каждого разработчика свои предпочтения.

Теперь создаем проект. Для этого выбираем меню «Project -> New uVision Project…». В открывшемся окне выбираем расположение и имя проекта. Для проекта лучше создать отдельную папку и сохранить проект туда.

После сохранения появится окно выбора устройства. Выбираем нужный микроконтроллер и нажимаем «ОК». Если бы мы не установили нужный пакет, то микроконтроллера не было бы в списке:

В следующем окне предстоит выбрать компоненты, которые будут использоваться в проекте. Необходимо выбрать «CMSIS:CORE» и «Device:Startup»:

После нажатия «OK» процесс создания проекта завершится.

В дальнейшем вы всегда сможете запустить окно выбора компонентов, чтобы добавить или удалить их. Для этого надо выбрать меню «Project -> Manage -> Run-Time Evironment…».

При выборе компонентов может оказаться, что какой-то компонент зависит от других компонентов, которые вы не выбрали. Об этом вы узнаете из сообщений в нижней части окна. Необходимо будет выбрать зависимые компоненты.

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

Здесь мы видим название проекта «example», цель проекта «Target 1», пустую группу файлов «Source Group 1», компоненты CMSIS и Device.

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

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

В структуре мы видим два файла. Один с расширением «s». Он содержит исходный код на языке ассемблера. Другой с расширением «с». Он содержит исходный код на языке Си.

Собрать проект и получить файл прошивки можно нажав клавишу F7. Но в таком виде проект не будет собран и вы получите ошибку, потому что отсутствует функция «main()».

Функция «main()» — это точка входа в вашу программу, то с чего начинается программа. Ее наличие обязательно если вы пишите программу на языке Си.

Давайте создадим эту функцию. Кликнем на группе «Source Group 1» правой кнопкой и выберем «Add New Item to ‘Source Group 1’…» (перевод: добавить новый элемент в группу ‘Source Group 1’). Создадим файл «main.c»:

В созданный файл добавим код:

int main() {
    return 0;
}

В конец файла стоит добавить пустую строку, иначе при сборке вы получите предупреждение «warning: #1-D: last line of file ends without a newline».

Теперь проект можно собрать клавишей F7. В результате вы получите файл «Objects\example.axf» (по умолчанию имя файла совпадает с именем проекта). Файл располагается в папке с проектом.

Обычно разработчику требуется файл прошивки в формате Intel HEX. Чтобы получить его, надо произвести настройку цели. Чтобы увидеть настройки цели нажмите Alt-F7, перейдите на вкладку «Output» и выберите «Create HEX File».

После очередной сборки вы получите файл «Objects\example.hex».

Сейчас программа не делает ничего, и прошивать ее бессмысленно. Давайте напишем программу, которая управляет состоянием ножки микроконтроллера.

Запустим выбор компонентов с помощью меню «Project -> Manage -> Run-Time Evironment…» и выберем компонент «Device:STM32Cube Hal:GPIO».

В нижней части окна мы увидим неудовлетворенную зависимость «Device:STM32Cube Hal:Common». Выберем этот компонент и увидим еще больший список зависимостей. Необходимо выбрать все требуемые зависимости:

• Device:STM32Cube Hal:Common
• Device:STM32Cube Hal:RCC
• Device:STM32Cube Hal:PWR
• Device:STM32Cube Hal:Cortex
• Device:STM32Cube Framework:Classic

STM32Cube — это библиотека, которую предоставляет STMicroelectronics.

При выборе компонентов мы выбираем какие возможности этой библиотеки использовать.

Микроконтроллер, кроме ядра, содержит большое количество периферийных устройств: АЦП, ЦАП, таймеры, различные интерфейсы и многое другое. Каждое периферийное устройство имеет свое название. Например, устройство для работы с портами микроконтроллера называется GPIO, об этом можно узнать из документации на микроконтроллер.

Библиотека STM32Cube многоуровневая, то есть включает в себя множество промежуточных библиотек. Одна из промежуточных библиотек называется STM32Cube HAL, или просто HAL. Она поделена на модули и каждый модуль соответствует какому-нибудь периферийному устройству. Название модуля совпадает с названием устройства, например, имеется модуль GPIO.

Существует большое количество документации по STM32Cube. Но основное описание по работе с периферийными устройствами содержится в руководстве по HAL. Это руководство разработчик использует большую часть времени. Обратимся к нему, чтобы заставить шевелиться ножки микроконтроллера.

Для начала подключим HAL в нашей программе, добавив строчку перед определением функции «main()»:

#include "stm32f4xx_hal.h"

В самом начале функции «main()» вызовем функцию «HAL_Init()», которая инициализирует библиотеку.

Таким образом мы получим следующий код в файле «main.c»:

#include "stm32f4xx_hal.h"

int main() {
    HAL_Init();

    return 0;
}

Продолжение следует…

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

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

В статье я хотел еще привести конечный код и объяснить, как он работает. Могу лишь поделиться непроверенной программой:

#include "stm32f4xx_hal.h"

int main() {
    HAL_Init();

    // Разрешить тактирование порта A.
    __HAL_RCC_GPIOA_CLK_ENABLE();

    // Настройки порта.
    GPIO_InitTypeDef s;
    s.Pin   = GPIO_PIN_0;                // Вывод 0.
    s.Mode  = GPIO_MODE_OUTPUT_PP;       // Цифровой выход.
    s.Pull  = GPIO_NOPULL;               // Без подтяжки.
    s.Speed = GPIO_SPEED_FREQ_VERY_HIGH; // Максимальная скорость.

    // Настроить вывод 0 порт A.
    HAL_GPIO_Init(GPIOA, &s);

    // Бесконечно переключать состояние порта с максимальной скоростью.
    while(1) {
        HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_0);
    }

    //return 0;
}

void SysTick_Handler(void) {
    HAL_IncTick();
}

Ссылки

1. Скачать продукты Keil без заполнения формы.
2. Скринкаст «Eclipse и GNU Tools для разработки под ARM-микроконтроллеры«.
3. Микроконтроллер STM32F407VG.
4. Отладочная плата STM32F4-Discovery.
5. Библиотека STM32CubeF4.
6. Руководство по STM32CubeF4 HAL.
7. Библиотека CMSIS.
8. Отсчет времени в STM32Cube.

Итак, компилятор установлен, пришло время создания первого проекта. Сразу думаю надо обсудить библиотеки, которые мы будем использовать в нашей работе с STM32.

Во-первых, CMSIS. Это замечательная библиотека, единый стандарт для всех Cortex. CMSIS  позволяет легко переносить код с одного контроллера с ядром ARM Cortex на любой другой. Короче, в CMSIS стандартизирован доступ к разной периферии разных микроконтроллеров STM.  Библиотека состоит из нескольких файлов, которые нам надо будет добавить в проект, но об этом немного позднее.

Время традиционной вставки: поскольку компания STMicroelectronics прекратила поддержку библиотеки SPL, которая использовалась в этом курсе, я создал новый, посвященный работе уже с новыми инструментами, так что буду рад видеть вас там — STM32CubeMx. Кроме того, вот глобальная рубрика по STM32, а также статья на смежную тему из нового курса: STM32. Быстрый старт с STM32CubeMx.

Во-вторых, библиотека Standard Peripheral Library. В SPL очень удобно реализована настройка всевозможных периферийных модулей, а также есть множество функций для работы с ними же. Эту библиотеку достаточно подробно будем изучать при обсуждении какой-либо конкретной периферии в будущих статьях. А сейчас кратенько рассмотрим ее структуру в общих чертах. Для любого модуля микроконтроллера есть 2 файла: заголовочный файл и, собственно, файл с исходным кодом. Так что, создавая проект для работы, например, с АЦП, мы будем включать в проект два файла из Standard Peripheral Library.

Возможно, кто-то сомневается, стоит ли использовать эту библиотеку. Речь, конечно о SPL (по поводу CMSIS думаю ни у кого нет особых сомнений). Так вот, я для себя однозначно решил, что стоит. Потому что ни к чему изобретать велосипед, библиотека написана и очень удобна, гораздо удобнее, чем напрямую ковыряться в многочисленных регистрах. НО! При всем этом, надо все-таки иметь представление какой регистр за что отвечает, и как с ними работать. Для этого не лишним будет просматривать раздел даташита на конкретную периферию при работе с ней.

Итак, скачиваем CMSIS и Standard Peripheral Library (SPL) и шагаем дальше:

• скачать CMSIS — STM32_CMSIS
• скачать Standard Peripheral Library — STM32_SPL

Теперь, наконец-то, переходим к нашему первому проекту. Создадим отдельную папку для проектов, и в ней будем создавать по папке для каждого отдельно взятого проекта. Если этого не делать, то в итоге получится просто каша из файлов. А если проект большой, то есть включает большое количество файлов, то лучше сгруппировать файлы в группы и разложить по разным подпапкам. Итак, запускаем Keil!

Идем в Project -> New uVision Project. Появляется окошко для выбора папки, в которой будет создан проект. Также надо дать нашему проекту имя. Пусть будет, например, test, это будет просто тестовый проект. Скриншот приводить не буду, тут все и так понятно. Теперь нам надо выбрать микроконтроллер. Я остановил свой выбор на STM32F103CB:

Жмем OK,  появляется диалоговое окно, жмем «Да», и вот первый шаг позади.

В левой части видим окошко Project. Там будут отображаться все файлы, добавленные в наш проект. Я обычно переименовываю группы, которые по умолчанию называются Target 1 и Source Group 1 в STM32 и StartUp соответственно. Сразу же добавим еще пару групп – для библиотек, а также для наших файлов, в которых будет собственно сам код. У меня после модификации все выглядит вот так:

Конечно, такой вариант не является единственно верным, просто так удобнее, а пока проект содержит немного файлов, пары папок вполне хватит. Идем дальше. Создадим пустой файл .c: File — New .

Появляется пустой файл, жмем File — Save As и называем наш первый файл test.c. Готово! Теперь нужно добавить все необходимые файлы в проект. Дважды тыкаем на папку CMSIS  в дереве проекта и добавляем следующие файлы:

• core_cm3.c
• system_stm32f10x.c

И вот они, первые грабли, с которыми я столкнулся. Проект отказался собираться без файла stm32f10x_conf.h. А в моей скачанной CMSIS  он напрочь отсутствовал. Поэтому качаем его отдельно и тоже добавляем в проект (если качали библиотеки по ссылкам выше, то там уже есть этот файл). Далее открываем этот файл, находим строчку #include «stm32f10x_type.h» и комментируем ее. Этот файл мы использовать не будем. Такие действия лично мне пришлось осуществить, чтобы успокоить компилятор,  возможно, у меня просто оказалась битая библиотека. Мне было проще поправить имеющуюся под себя, чем искать какие то другие варианты 🙂

Теперь аналогично добавим файлы библиотеки SPL. Пока они нам не понадобятся, но пусть будут. Добавим, например stm32f10x_rcc.c и подхватим includ’ом stm32f10x_rcc.h (файлы, содержащие все связанное с тактированием различной периферии). И наконец добавим наш созданный файл test.c в папку Source Files в дереве проекта.

Далее идем в Project — Options for target… Тут несколько вкладок для различных настроек. Идем во вкладку Output и ставим галку Create HEX File. Теперь наша цель – вкладка C/C++. В поле define пишем следующее: USE_STDPERIPH_DRIVER. Без этого проект не соберется. Осталось в Include Paths добавить пути ко всем(!) файлам, включенным в проект. Получим примерно следующее:

И вот тут еще одни грабли. Все папки, которые добавляем в Include Paths не должны содержать пробелов. Так что мои Header Files, Source Files и Project Files плавно превращаются в Header_Files, Source_Files и Project_Files.

Еще один шаг к созданию проекта сделан, в принципе, осталось совсем чуть-чуть. В файл test.c закинем следующий тестовый код, который абсолютно ничего не делает:

#include "stm32f10x.h"
#include "stm32f10x_rcc.h"

int main()
{
	while(1);
}

Осталось лишь нажать F7 (build) и проект соберется. Все отлично, но мы наблюдаем непредвиденные warning’и. Хорошо написанная программа не должна их содержать, так что будем править. К счастью, это потребует от нас минимум усилий. Итак:

incompatible redefinition of macro "HSE_Value"

Чтобы это не вылетало, открываем stm32f10x_conf.h, ищем:

#define HSE_Value    ((u32)8000000) /* Value of the External oscillator in Hz*/

И беспощадно комментируем эту строку. Вот и все… Если у кого-то вылезло:

warning:  #1-D: last line of file ends without a newline

то надо сделать так, чтобы файл test.c не заканчивался строкой кода. Проще говоря, ставим курсор после последней скобки в этом файле и жмем Enter. Warning сразу же пропадает.

Ну вот, первые шаги сделаны. Мы создали пустой проект, который абсолютно ничего не делает полезного (бесполезного впрочем тоже 🙂 ). Но для начала уже неплохо, в следующих статьях будем заполнять проект кодом. Кстати, если у кого-нибудь возникли какие-либо трудности при создании проекта, пишите в комментарии, не стесняйтесь! И не пропустите статью нашего курса по STM32CubeMx, описывающую аналогичный процесс создания базового проекта.

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

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

Вступление

В прошлой статье я поделился личными впечатлениями о полученном мною наборе и запрограммировал контроллер демонстрацонным проектом с помощью MT-LINK (так же был предоставлен). Теперь, когда мы детально рассмотрели весь комплект, настало время начать его осваивать.
Для нетерпеливых — итог.

Создаем пустой проект в Keil 5 для К1986ВЕ92QI.

Для начала следует создать чистый проект. Можно конечно использовать демонстрационный проект как основу, но проект с номером «2» так и не запустился, а в проекте «3» почему-то в меню выбора контроллера чистый лист. Это меня как-то насторожило. Проекта с номером «1» нет в принципе.

• 1. Заходим в Project -> New uVision Project…

  

• 2. Создаем папку для проекта (в пути не должно быть русских букв), пишем имя (так же на английском) и сохраняем.

  

• 3. Выбираем наш контроллер.
• 4. В появившемся окне просто жмем «Ок». Честно сказать, мне никогда не удавалось настроить проект через этот редактор так, чтобы все скомпилировалось с 1-го раза. Всегда приходилось что-то менять. Чаще всего оказывалось, что проще сделать самому.

  
• 5. В левом верхнем углу появилось дерево проекта. Теперь нам нужно создать необходимые подкатегории. Для этого по самой верхней папке жмем правой кнопкой мыши и выбираем «Manage Project items…»

  

• 6. В данном меню 2 раза нажимаем левой кнопкой мыши на папку, название которой хотим изменить и пишем то, что хотим. Опять же, лучше на английском. Для добавления новый папок служит иконка слева от «красного крестика».
  Нам понадобятся минимум 4 папки:
  • 1. Под пользовательские данные (наши файлы).
  • 2. Под драйвера LCD (те, что в комплекте).
  • 3. Для кода работы с Flash.
  • 4. Под SMSIS и подобие SPL.

  

• 7. После того, как переименовали все папки, жмем «ОК». Каталог должен иметь примерный вид.

  

• 8. Далее нам нужно достать все эти файлы. Брать мы их будем из рабочего демонстрационного проекта. Кстати. Только сейчас заметил, что проект был написан под keil 2. Это меня немного поразило. Еще одним интересным фактом стало то, что между демонстрационным проектом «2» и «3», судя по информации последнего изменения — прошло 3 месяца. Причем к нашему времени ближе работающий проект. Из него и будем брать файлы (где достать этот демонстрационный проект – сказано в предыдущей статье-обзоре). Скопировать нужно выделенные файлы. Причем main.c (как и любые свои файлы) лучше убрать в отдельную папку. Я для этого создал папку User и туда поместил main.c (его мы изменим и будем базироваться на нем).

  

• 9. Далее нам нужно добавить файлы библиотеки в проект. Добавление происходит следующем образом. Щелкаем правой кнопкой по нужной папке в дереве проекта и выбираем «Add Existing Files to Group ‘Имя группы’…».

  

  В открывшемся окне нужно выбрать тип файлов «All files (*.*)». После чего выбрать 1 или выделить несколько файлов.

  

  Добавить нужно:

  • 1. В папку User -> «User -> main.c». Это наш самый главный файл. Чуть изменив его, мы начнем писать свой код именно в нем.
  • 2. В папку Flash -> «flash -> MilFlash.c». Здесь хранится библиотека для работы с Flash контроллера.
  • 3. В папку LCD -> «mlt -> mlt_lcd.c». Библиотека работы с LCD, который установлен на плате.
  • 4. В папку SMSIS_and_Drivers -> «Libraries\1986BE9x_StdPeriph_Driver\src -> все файлы .c». Тут хранится аналог SPL у STM32. Проще говоря, это «обертки», которые позволяют не вдаваясь в структуру контроллера управлять его периферией (выводы, uart и т. д.).
  • 5. В папку SMSIS_and_Drivers -> « Libraries\CMSIS\CM3\DeviceSupport\1986BE9x\startup\arm -> startup_1986be9x.s». Это файл «стартап». Тут прописаны все «вектора переходов». Иначе говоря, по любому прерыванию (к примеру, нажатие кнопки) контроллер возвращается к этой таблице и смотрит, куда ему перейти, чтобы выполнять код дальше.
  • 6. В папку SMSIS_and_Drivers -> «Libraries\CMSIS\CM3\DeviceSupport\1986BE9x\startup\arm -> system_1986BE9x.c».

  Итогом должно стать такое дерево.

  
• 10. Далее нам нужно немного почистить файл main.c. Для этого кликаем на него щелчком левой мыши в дереве каталога. Удаляем все, кроме оболочки функции main и #include файлов. Должно остаться так.

  

• 11. Как можно было заметить, около самого верхнего #include файла стоит крестик. Keil просто не видит данного файла. Для того, чтобы исправить это, мы должны указать ему, где ему брать этот файл. Для этого жмем Alt+F7. В открывшемся окне переходим во вкладку C/C++. Маленькое отвлечение. В будущем я часто буду использовать приемы, которые keil не будет понимать по умолчанию. Для того, чтобы исправить это, нужно нажать галочку около надписи «C99 Mode». Это даст возможность писать на более совершенном стандарте языка Си, чем это можно было делать изначально. Далее следует нажать на прямоугольник с «…» внутри. Справа около строчки с подписью «Include Paths».

  

• 12. В открывшемся окне нажимаем на иконку с прямоугольником, слева от крестика. Это создаст пустую строку. В правом углу созданной строчки жмем на «…». После чего указываем нужную папку, в которой лежат интересующие нас файлы. После этого жмем «ОК». Папка будет добавлена. Необходимо добавить все эти пути. Если вы заметили, то все ссылки кроме одной – относительные. То есть идут от корневого каталога. Но 1 идет начиная от «C:\». Это ссылка на сам каталог с проектом. Его тоже следует указать.

  

  Жмем «ОК» и переходим в файл main.c.

Компилируем простейшую программу.

Вставим в функцию main бесконечный цикл с увеличением счетчика на 1. Теперь наш файл должен выглядеть так.

Не забываем о том, что в конце каждого файла должна быть пустая строка. Keil считает это как предупреждение, которое частенько действует на нервы. Конечно компилироваться будет, но сам факт предупреждения – настораживает.
На этом настройка закончена. Мы можем перекомпилировать наш проект нажав F7. Если все прошло хорошо, ты мы увидим это.

Теперь осталось лишь в настройках настроить J-LINK и можно заливать. О том, как его настраивать – было подробно рассказано в предыдущей статье.

Кстати. J-LINK видит чип и без подключения дополнительного питания, а так же позволяет отлаживать чип. Так что внешнее питание не особо нужно. При переходах по строкам кода видно, как мелькает подцветка экрана.

Настраиваем ножку контроллера для работы со светодиодом

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

Для начала поймем, какой именно порт нам нужно настроить. В «Отладочная плата 1986ВЕ92У, К1986ВЕ92QI (MDR32F9Q2I)\Печатная плата 1986EvBrd_LQFP64» есть файл 1986EvBrd_64_Rev2.pdf, в котором приведена схема платы. На ней мы можем увидеть, что 2 светодиода подключены к пинам PC0 и PC1. Отлично. Не придется мучиться со смещением.

Очень понравилось, что у Миландра вся информация о линейке чипов в одном документе. В STM32 очень путался в документах… Взглянем на схему порта ввода-вывода. Чем-то отдаленно напоминает схему порта у STM32. Не увидев ничего, что бы бросилось в глаза, идем настраивать регистры.

Так как я не знал, как именно Миландр назвал свои порты, я полез в библиотеку настройки портов. Там увидел следующее.

Ну и чуть выше.

Убедившись, что адрес порта C совпадает с адресом в датащите, я создал новую функцию в файле main.c (Обязательно выше функции main! Иначе придется описывать прототипы функции в .h файле. А это лишние пока что заморочки.).

Начинаю писать PORTC-> (по привычке), зажимаю ctrl+пробел и вижу следующее.

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

Нам нужен светодиод на порту «0», так что можем записать: PORTC->RXTX |= 1;

Этим мы переводим 0-й бит порта в 1. Тем самым зажигая диод на порту 0. Но перед его включением стоит его настроить…
Так что данное действие выполняем в последнюю очередь, а перед.

У нас выход, так что: PORTC->OE |= 1;

Оставляем без изменений, так как по умолчанию везде нули.

А вот тут нам нужен цифровой: PORTC->ANALOG |= 1;

Подтяжка нам не нужна, так что, пропускаем.

Ну и это нам тоже не надо…

А вот тут нам нужно выбрать скорость. По умолчанию – все. Выбираем медленный фронт. Для светодиода его вполне хватит: PORTC->PWR |= 1;

Ну и последний регистр. Вообще неведомая для меня ранее вещь. С этим еще предстоит разобраться.

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

Нам нужны порты. Это вполне подходит под описание «периферийные блоки». Ищем этот регистр и вот.

Оставалось только понять, как в keil называется этот регистр. Так как в библиотеках толком ничего не нашел, то пошел подбором. В итоге выяснилось, что он именуется RST_CLK. Ну а дальше нам нужно лишь записать «1» в нужный блок.

RST_CLK->PER_CLOCK |=(1<<23);
На «PER_CLOCK» вышел случайно. Когда написал «RST_CLK» нажал ctrl+пробел и после появления списка, «p». После выбрал подходящий вариант.

В итоге получился такой код.

Код компилируется и мы получаем.

Русские комментарии в keil 5

Сейчас стоит расставить комментарии по коду, но на русском этого сделать не получается. Выходят непонятные символы, для того, чтобы можно было писать русский комментарии, нужно зайти Edit -> Configuration.

И там сменить кодировку, как показано на рисунке. После чего нажать «ОК».

Мигаем светодиодом

Теперь напишем код, который будет с помощью цикла мигать светодиодом.

Зашиваем и радуемся! Скорость взята по опыту мигания светодиодом на STM32. Светодиод мигает с частотой примерно раз в секунду.

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

Проект на github.

Еще раз напоминаю. В настройках проекта есть одна ссылка к директории проекта относительно «C:\». Так что проект будет работать лишь по тому же пути, что и в статье. Вы легко можете сменить путь и свободно пользоваться.
Спасибо sguwenka за исправления.

Интегрированная
система предназначена:

• для
  проектирования программного обеспечения
  путем формиро­вания
  текстов программ на одном из языков
  программирования (ассемблер
  или Си) в специализированном текстовом
  редакторе:

• компиляции
  с получением исполнимого кода для
  микроконтрол­лера:

• формирования
  модели работы портов ввода — вывода,
  тестирова­ния
  программ микроконтроллера путем
  симуляции их выполне­ния:

• загрузки
  программ из компьютера в микроконтроллерную
  систему через интер­фейсы
  различных типов:

• обмена
  данными между персональными ЭВМ и
  микроконтрол­лерной
  системой в реальном времени.

Современные
программные системы, ориентированные
на поддержку процесса проектирования,
как правило, используют концепцию
проектов.

Проект
—
это совокупность файлов, которые
составляют некоторую разработку
и фактически являются элементами
описания прикладной
про­граммы для
выбранного микроконтроллера. Таким
образом, каждый файл проекта может быть
сформирован пользователем. Обычно в
проекте поддер­живается организация
прикладной программы для микроконтроллера
на ос­нове модульного подхода, то есть
прикладная программа может состоять
из произвольного количества программных
модулей (файлов), которые содер­жат
взаимные ссылки. Целевые файлы проекта
формируются автоматически системой
из исходных файлов в процессе построения
при компиляции. При
построении
проекта на основе исходных файлов
формируются промежуточ­ные
файлы, файлы, которые используются при
симуляции, а также исполни­мые
файлы в определенных форматах.

Базовым
понятием является также понятие модели
контроллера.
Мо­дель
контроллера определяет совокупность
аппаратных ресурсов, которые учитываются
компилятором и симулятором в составе
системы. Каждая мо­дель контроллера
соответствует аппаратной структуре
определенной моди­фикации
физического микроконтроллера семейства
MCS-51.
Таким образом, модель
микроконтроллера — это совокупность
следующих параметров:

• объемы внутренней
  и внешней памяти программ и данных;

• номенклатура
  и количество компонентов периферии,
  используе­мых
  в данной модификации микроконтроллера:

• конфигурационные
  параметры, используемые при симуляции,
  например,
  размер и скорость доступа для модели
  памяти EEPROM.

С
каждым проектом связывается определенная
модель микрокон­троллера,
для которого создается программа в этом
проекте. Таким образом,

параметры
модели непосредственно влияют на процесс
компиляции
про­граммы
и симуляцию ее выполнения при тестировании.

Для
систем с микроконтроллерами 8051 разработаны
мощные инструментальные средства,
позволяющие снизить до минимума время
разработки и отладки программного
обеспечения. Среди прочих лидирующие
позиции занимают программные средства,
разработанные фирмой Keil. Инструментальные
средства этой фирмы включают целый ряд
мощных приложений, таких как компилятор
языка Cи для микроконтроллеров 8051,
известный под названием Keil C51, макроассемблер
A51, совместимый с ASM-51, и наконец, удобная
графическая оболочка для разработки и
отладки программ Keil uVision.

Среда
разработки Keil uVision (в настоящее время
используются версии 3 и 4) позволяет
создавать сколь угодно сложные проекты,
состоящие из разных модулей, написанных
как на C, так и на языке ассемблера,
подключать библиотеки функций и т.д.
Кроме того, эта среда включает удобный
отладчик (симулятор), позволяющий оценить
и быстро проверить работоспособность
программы. Хотя при разработке программ
можно обойтись только командной строкой,
откомпилировав и собрав программу вне
среды Keil uVision, графическая среда разработки
все же более удобна, поскольку позволяет
автоматизировать сборку программ и
проверить их работоспособность с помощью
отладчика.

Для
разработки и отладки программ в среде
Keil желательно иметь установленную
графическую среду Keil uVision версии 3 или
4 и компиляторы C51 и A51. Можно использовать
демонстрационные версии этих программных
инструментов, доступные для скачивания
на сайте www.keil.com. Более того, для разработки
программ на языке C в среде Keil uVision можно
использовать и свободно распространяемый
компилятор SDCC, который разработан в
рамках открытого лицензионного соглашения
GNU и не имеет ограничений по размеру
исполняемого программного кода. Несмотря
на некоторые отличия в синтаксисе,
многие (если не большинство) из принципов
программирования систем с 8051, используемые
в Keil C51, работают и в SDCC.

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

• #
• #
• #
• #
• #
• #
• #
• #
• #
• #
• #