FLProg: От первого запуска до загрузки в контроллер

Знакомство с FLProg и философией визуального программирования

Представьте, что вы проектируете умную теплицу. Задача звучит предельно просто: если температура падает ниже заданного порога ( $T < 20$ , где $T$ — текущая температура воздуха в градусах Цельсия), должен включиться обогреватель. В традиционном программировании для реализации этой логики придется изучать синтаксис языка C++, разбираться в типах переменных, расставлять фигурные скобки и искать пропущенные точки с запятой. На это могут уйти недели. Но что, если бы вы могли просто взять на экране блок «Датчик температуры», соединить его линией с блоком сравнения и вывести сигнал на блок «Реле обогревателя»? Именно эту задачу решает визуальное программирование.

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

Традиционное написание кода требует от человека думать как машина: строками, командами и строгими правилами пунктуации. Визуальное программирование переворачивает этот подход: оно заставляет машину понимать человеческую логику.

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

Для наглядности сравним два подхода:

Характеристика	Традиционное программирование (C++)	Визуальное программирование (FLProg)
Единица логики	Строка кода	Графический блок
Главная причина ошибок	Опечатки, забытая пунктуация	Логические ошибки в связях
Порог входа	Высокий (нужно учить язык)	Низкий (достаточно понимать логику процесса)
Читаемость	Требует вдумчивого анализа текста	Выглядит как понятная электрическая схема

Что такое FLProg?

FLProg — это бесплатная среда разработки, созданная специально для того, чтобы программировать мощные 32-битные микроконтроллеры семейства STM32 (например, популярную плату STM32F103C8T6, известную как «Blue Pill») без написания классического кода. Официальная поддержка этого семейства контроллеров была добавлена в программу начиная с версии 8.0.1, что сделало промышленную мощь доступной для новичков.

Программа позволяет создавать алгоритмы на визуальном языке, пришедшем прямиком из промышленной автоматизации:

FBD (Function Block Diagram) — это графический язык программирования, где логика системы строится из блоков (прямоугольников), имеющих входы (слева) и выходы (справа). Сигналы текут от входов к выходам, преобразуясь внутри блоков по заданным правилам.

Стандарт IEC 61131-3

Как это работает: от схемы к железу

У новичков часто возникает закономерный вопрос: «Понимает ли микроконтроллер эти картинки с блоками напрямую?»

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

Вы собираете визуальную схему из блоков в окне FLProg, выстраивая логику работы устройства.
Нажимаете кнопку компиляции.
FLProg мгновенно анализирует вашу графическую схему и автоматически генерирует правильный код на языке C++.
Этот сгенерированный код загружается в память контроллера через аппаратный программатор ST-Link или специализированную утилиту STM32CubeProgrammer.

Практика: визуальная логика и аппаратные особенности

Чтобы понять, как визуальная логика соединяется с реальным «железом», рассмотрим классическую задачу — мигание встроенным светодиодом на плате Blue Pill.

У этой платы есть важная аппаратная особенность: встроенный светодиод физически подключен к пину PC13 и управляется инверсным сигналом. Это означает, что светодиод загорается при подаче логического нуля (LOW) и гаснет при подаче логической единицы (HIGH). В классическом коде новичок часто путается, почему команда включения на самом деле выключает свет.

В FLProg эта аппаратная специфика решается изящно и наглядно:

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

Вы не написали ни строчки кода, но создали алгоритм, который ритмично мигает светодиодом, автоматически учитывая сложную инверсную логику самой платы. Примечание: подробное руководство по первичной настройке платы Blue Pill и программатора доступно на официальном сайте FLProg.

Инженерия вместо рутины

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

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

Аппаратная платформа: выбор микроконтроллера и подготовка компонентов

Мы уже выяснили, что FLProg превращает визуальные схемы в код на C++, который затем отправляется в память контроллера. Но чтобы этот код начал управлять реальным миганием светодиода или умной теплицей, ему нужен физический «мозг». Прежде чем устанавливать программу на компьютер, нам необходимо подготовить аппаратную часть на рабочем столе.

Выбор «мозга»: почему STM32 Blue Pill?

В мире любительской электроники исторически доминирует платформа Arduino. Однако в нашем курсе мы используем плату на базе микроконтроллера STM32F103C8T6, которую в сообществе разработчиков прозвали «Blue Pill» (Синяя таблетка) за характерный цвет текстолита и форм-фактор.

Почему для старта в FLProg мы берем именно её, а не классическую Arduino Uno? Ответ кроется в соотношении цены и вычислительной мощности. FLProg генерирует достаточно объемный код, и для сложных проектов ресурсы базовых плат быстро заканчиваются.

Характеристика	Arduino Uno (ATmega328P)	STM32 Blue Pill (STM32F103C8T6)
Разрядность	8 бит	32 бита (ARM Cortex-M3)
Тактовая частота	16 МГц	72 МГц
Флеш-память (для кода)	32 КБ	64 КБ (часто 128 КБ по факту)
Оперативная память (RAM)	2 КБ	20 КБ
Рабочее напряжение логики	5 В	3.3 В

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

Что понадобится для старта?

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

Сама плата STM32 Blue Pill.
Программатор ST-Link V2. Это устройство, похожее на USB-флешку. В отличие от Arduino, которую можно прошивать просто по USB-кабелю, микроконтроллеры STM32 требуют специального «переводчика» между компьютером и платой для надежной загрузки кода.
Соединительные провода (Dupont). Нам понадобятся четыре провода типа «мама-мама» (Female-Female) для соединения контактов программатора и платы.

Физическое подключение: собираем стенд

Связь между программатором ST-Link и платой STM32 осуществляется по интерфейсу SWD (Serial Wire Debug). Это специализированный протокол, которому для работы нужно всего два провода для передачи данных, плюс питание и земля.

На плате Blue Pill контакты для программирования вынесены в отдельную гребенку из четырех штырьков (обычно они расположены на торце платы, противоположном от USB-разъема). На программаторе ST-Link V2 нужные контакты подписаны прямо на алюминиевом корпусе.

Вам нужно соединить их проводами строго по следующей схеме:

3.3V (на ST-Link) $\rightarrow$ 3.3V (на Blue Pill) — питание платы.
GND (на ST-Link) $\rightarrow$ GND (на Blue Pill) — общая земля.
SWDIO (на ST-Link) $\rightarrow$ DIO или SWDIO (на Blue Pill) — линия передачи данных.
SWCLK (на ST-Link) $\rightarrow$ CLK или SWCLK (на Blue Pill) — линия тактирования (синхронизации).

Критическое правило питания Логика STM32 работает от напряжения 3.3 В. Никогда не подключайте пин 5V программатора к пину 3.3V на плате — это мгновенно выведет микроконтроллер из строя.

После того как вы соединили эти четыре провода, ваш аппаратный стенд полностью готов. Пока не подключайте программатор к USB-порту компьютера — мы сделаем это позже. Сейчас наша задача — подготовить программную среду FLProg, чтобы ей было что отправлять по этим проводам.

Установка и базовая настройка программной среды FLProg

Стенд собран: четыре провода надежно соединяют контроллер STM32 Blue Pill и программатор. Но если прямо сейчас подключить эту связку к USB-порту компьютера, ничего не произойдет. Операционная система не поймет, что за устройство в нее вставили, а без среды разработки вы не сможете написать ни строчки логики. Сегодня мы превратим обычный компьютер в готовую лабораторию визуального программирования, заставив софт и железо «увидеть» друг друга.

Шаг 1. Обучение компьютера: установка драйвера ST-Link

Программатор ST-Link V2 — это мост между USB-портом вашего ПК и отладочным интерфейсом микроконтроллера. Чтобы Windows смогла передавать данные через этот мост, ей нужен переводчик — драйвер.

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

Перейдите на официальный сайт компании STMicroelectronics или используйте проверенные архивы для скачивания драйвера STSW-LINK009.
Распакуйте скачанный архив.
Запустите файл dpinst_amd64.exe (для 64-битных систем Windows) или dpinst_x86.exe (для 32-битных).
Пройдите стандартные шаги мастера установки и дождитесь сообщения об успешном завершении.

Только теперь вставьте ST-Link V2 (вместе с подключенной платой Blue Pill) в USB-порт компьютера. На программаторе должен загореться светодиод.

Чтобы убедиться, что всё прошло успешно, откройте «Диспетчер устройств» Windows. В разделе «Контроллеры USB» (или «Устройства универсальной последовательной шины») должна появиться строка STMicroelectronics STLink dongle. Если рядом с ней нет желтого треугольника с восклицательным знаком — железо готово к работе.

Шаг 2. Выбор и загрузка FLProg

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

На официальном сайте (flprog.ru) в разделе загрузок вы встретите два основных выбора: версию (Full или Basic) и формат (Installer или Portable).

Full против Basic

Характеристика	Full-версия	Basic-версия
Комплектация	Включает саму среду FLProg и встроенный компилятор (Arduino IDE со всеми нужными ядрами под капотом).	Только графическая оболочка FLProg.
Настройка	Работает «из коробки», пути прописаны автоматически.	Требует ручной установки Arduino IDE и указания путей в настройках.
Вес архива	Около 1–1.5 ГБ.	Менее 200 МБ.
Кому подходит	Новичкам и тем, кто хочет быстрый старт.	Опытным пользователям со своей настроенной экосистемой.

Installer против Portable

Формат Installer (установщик .exe) классически устанавливает программу в папку Program Files. Однако Windows часто жестко ограничивает права на запись в эту системную директорию. Из-за этого FLProg может выдавать ошибки при сохранении временных файлов компиляции.

Формат Portable (архив .zip) не требует установки. Вы просто распаковываете его в любую папку, и программа работает прямо оттуда.

Оптимальный выбор для нашего курса: скачиваем Full Portable версию (начиная с 8.0.1, так как именно с нее появилась поддержка STM32). Распакуйте архив в корень диска, например, в папку C:\FLProg. Избегайте русских букв и пробелов в пути — компиляторы этого не любят.

Шаг 3. Архитектура среды и первый запуск

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

FLProg — это не самостоятельный компилятор, а умная визуальная оболочка. Она переводит ваши графические FBD-схемы в текстовый код C++, который затем незаметно передается встроенным инструментам для компиляции и загрузки в чип.

Этот многослойный процесс (от графики к тексту, от текста к машинному коду) полностью автоматизирован в Full-версии.

Зайдите в папку C:\FLProg и запустите файл FLProg.exe. При первом запуске среда может на несколько секунд задуматься — в этот момент она проверяет наличие встроенного компилятора и формирует конфигурационные файлы.

Перед вами откроется стартовое окно программы. Базовая настройка на этом завершена: драйверы установлены, программатор распознан системой, а среда разработки распакована и готова генерировать код. Фундамент заложен, и в следующей главе мы детально разберем интерфейс FLProg, чтобы вы могли уверенно ориентироваться в его рабочих зонах.

Обзор пользовательского интерфейса и навигация по рабочему пространству

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

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

Анатомия главного окна: сборочный цех

Рабочее пространство спроектировано так, чтобы весь цикл создания алгоритма — от объявления физического контакта микроконтроллера до настройки логики — происходил на одном экране.

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

Зона интерфейса	Расположение	Аналогия из жизни	Назначение в FLProg
Панель инструментов	Сверху	Командный пункт	Сохранение, компиляция, настройки проекта.
Дерево проекта	Слева	Склад материалов	Уникальные данные вашего проекта (входы, выходы, переменные).
Рабочий холст	По центру	Сборочный стол	Место, где вы соединяете логику воедино.
Библиотека элементов	Справа	Ящик с инструментами	Универсальные логические блоки (таймеры, математика).

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

Слева и Справа: Материалы и Инструменты

Главное правило интерфейса FLProg: слева лежат уникальные данные проекта, а справа — универсальные инструменты для их обработки.

Левая панель: Дерево проекта

Здесь хранится всё, что делает ваш проект индивидуальным. Дерево проекта содержит:

Входы и Выходы: Физические ножки вашего контроллера. Например, вы объявляете, что пин PA0 будет считывать нажатие кнопки, а пин PC13 — управлять светодиодом.
Переменные: Контейнеры для хранения промежуточных данных (например, текущего значения температуры с датчика).

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

Правая панель: Библиотека элементов

Здесь находится язык FBD в чистом виде — блоки, из которых строится логика. Библиотека организована в виде древовидного каталога и содержит сотни элементов:

Базовые элементы: Фундаментальные логические операции (И, ИЛИ, НЕ), триггеры.
Таймеры и генераторы: Блоки для работы со временем.
Математика: Операции сложения, сравнения, масштабирования.

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

Центральная область: Рабочий холст

Холст — это главная область, где происходит магия программирования. Именно здесь «материалы» из левой панели встречаются с «инструментами» из правой.

Важнейшая концепция центральной области — это система Плат. В контексте интерфейса FLProg термин «Плата» означает не физический кусок текстолита, а логическую вкладку (страницу) вашей схемы.

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

Плата 1: Опрос датчиков температуры и влажности.
Плата 2: Логика управления обогревателем и насосом.
Плата 3: Вывод информации на дисплей.

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

Единый конвейер: как это работает вместе

Теперь, когда мы знаем назначение каждой зоны, картина складывается воедино. Логика работы в FLProg всегда подчиняется простому алгоритму сближения к центру:

Вы берете исходный сигнал из Дерева проекта (слева) — например, контакт кнопки включения.
Вы берете логический блок из Библиотеки (справа) — например, таймер задержки отключения.
Вы размещаете их на Холсте (в центре) и соединяете линией связи.
Результат работы таймера вы отправляете обратно на физический выход контроллера, взятый из левой панели.

Кабина авиалайнера перестала казаться пугающей: теперь это понятный конвейер, где у каждой детали есть свое место. В следующей главе мы применим этот конвейер на практике: создадим наш самый первый проект, выберем в настройках плату STM32 Blue Pill и подготовим холст к реальной работе.

Создание нового проекта и конфигурирование параметров контроллера

Интерфейс изучен, драйверы установлены, а программатор подключен к плате. Но если прямо сейчас перетащить логический блок на рабочий холст, FLProg не поймет, что с ним делать. Программа еще не знает, чьим «мозгом» ей предстоит управлять — мощным 32-битным чипом или базовой 8-битной платой. Без точной аппаратной привязки визуальная схема никогда не превратится в рабочий C++ код.

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

Шаг 1: Выбор языка и архитектуры

При нажатии «Новый проект» FLProg предлагает выбрать язык визуального программирования. Как мы определили в самом начале курса, нашим стандартом является FBD (Function Block Diagram).

Сразу после выбора языка открывается окно выбора контроллера. Это критический момент: микроконтроллеры разных семейств имеют разную архитектуру памяти, разные регистры и разное количество портов ввода-вывода.

Ошибка на этапе выбора платы приведет к тому, что компилятор сгенерирует инструкции для несуществующих физических контактов, и прошивка завершится критическим сбоем.

В левой части окна представлено дерево поддерживаемых платформ. Наш путь к целевой плате выглядит так: 32-bit $\rightarrow$ STM32 $\rightarrow$ STM32F103 $\rightarrow$ STM32F103C8 (Blue Pill).

Выбрав нужную плату, мы сообщаем ядру FLProg карту пинов (Pinout) и объем доступной памяти (20 КБ RAM для нашего чипа).

Шаг 2: Настройка ядра и программатора

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

Метод загрузки (Программатор)

По умолчанию среда может предлагать загрузку через USB (DFU) или UART. Нам необходимо принудительно выбрать ST-Link. Именно этот аппаратный мост, подключенный по интерфейсу SWD, обеспечит прямую и безотказную запись скомпилированной программы в память контроллера.

Тактовая частота (Clock Speed)

Микроконтроллер выполняет инструкции, опираясь на внутренний генератор импульсов. Для STM32 Blue Pill стандартная максимальная частота составляет 72 МГц. В настройках FLProg необходимо убедиться, что выбрано значение 72 MHz.

Почему это важно? Все временные задержки, таймеры и протоколы связи в сгенерированном коде рассчитываются математически, исходя из заявленной частоты. Базовая формула связи времени и частоты:

t = \frac{N}{f}

где $t$ — реальное время выполнения задержки (в секундах), $N$ — количество тактов процессора (рассчитывается компилятором), $f$ — тактовая частота (в герцах).

Если в настройках FLProg указать $f = 72$ МГц, компилятор для создания задержки в 1 секунду заложит в код $N = 72\,000\,000$ тактов. Если при этом физический чип по какой-то причине настроен на работу при $f = 36$ МГц, то отсчет этих 72 миллионов тактов займет ровно 2 секунды. Вся логика времени в проекте «поплывет».

Шаг 3: Регистрация периферии в Дереве проекта

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

Вся уникальная периферия создается в левой панели — Дереве проекта. Наша ближайшая цель — научиться управлять встроенным светодиодом на плате Blue Pill.

В Дереве проекта находим папку Выходы и дважды кликаем по ней.
В открывшемся окне задаем имя: System_LED. Имя должно быть понятным и состоять из латинских букв.
В выпадающем списке контактов выбираем пин PC13 (именно к нему физически припаян светодиод на плате).
Вспоминаем аппаратную особенность нашей платы: светодиод подключен по схеме с инверсной логикой. Чтобы не путаться при сборке алгоритма (где 1 — это включить, а 0 — выключить), прямо в настройках выхода ставим галочку «Инвертировать».

Теперь FLProg возьмет на себя перевод нашей прямой человеческой логики в инверсную аппаратную. Когда алгоритм пошлет на выход System_LED логическую единицу, программа автоматически выдаст на физическом пине PC13 логический ноль, и светодиод загорится.

Проект полностью сконфигурирован. Среда знает, с каким железом работает, как его программировать и к какому контакту обращаться. Фундамент заложен — можно переходить в Библиотеку элементов и собирать первую логическую цепь.

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

У нас есть настроенный контроллер и созданный в Дереве проекта выход System_LED. Но пока он остается лишь абстрактной записью в базе данных проекта. Чтобы микроконтроллер действительно подал напряжение на ножку PC13, этот выход должен стать частью электрической цепи на нашем виртуальном холсте. Программа в FLProg не пишется строками кода — она собирается из кирпичиков, как конструктор Lego.

В этой главе мы перенесем наши настройки на рабочий холст, добавим источник сигнала и соберем первую работающую логическую схему.

Анатомия FBD-блока

Первый шаг к созданию алгоритма — материализация переменных. Зажмите левой кнопкой мыши тег System_LED в Дереве проекта (левая панель) и перетащите его в пустую область Платы на рабочем холсте.

Как только вы отпустите кнопку, текстовая переменная превратится в графический прямоугольник — FBD-блок.

Любой блок в FLProg имеет строгую направленность. Чтобы схема работала, нужно понимать всего два правила маршрутизации:

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

Сравним, как выглядят цифровой вход и цифровой выход на холсте:

Тип блока	Где находится пин подключения	Роль в цепи	Пример
Вход (Input)	Справа	Отдает сигнал в схему (источник)	Кнопка, датчик движения
Выход (Output)	Слева	Принимает сигнал из схемы (потребитель)	Светодиод, реле мотора

Наш System_LED — это выход. Его пин находится слева. Сейчас он висит в воздухе, а значит, светодиод никогда не загорится, потому что на него не приходит никаких команд. Ему нужен источник сигнала.

Добавление логики: Генератор импульсов

Чтобы светодиод мигал, нам нужно устройство, которое будет ритмично выдавать команды «Включить» (логическая 1) и «Выключить» (логический 0). В традиционном программировании для этого пишут циклы с задержками delay(). В FLProg мы просто берем готовый прибор из Библиотеки элементов.

Разверните правую панель (Библиотека элементов), найдите папку «Таймеры» и перетащите блок «Генератор» на холст, разместив его левее нашего светодиода.

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

В окне настроек выберите тип генератора: Симметричный мультивибратор. Это означает, что фаза активности будет равна фазе покоя. Задайте длительность импульса: $500$ (в миллисекундах).

Общий период работы такого генератора вычисляется по формуле: $T = t_{импульс} + t_{пауза}$ где $t_{импульс}$ — время, когда генератор выдает логическую единицу, а $t_{пауза}$ — время логического нуля. Поскольку мультивибратор симметричный, пауза автоматически равна импульсу. Итоговый период $T$ составит $1000$ миллисекунд, то есть ровно одну секунду. Светодиод будет загораться полсекунды и гаснуть на полсекунды.

Сборка цепи: соединение блоков

Теперь у нас есть источник (Генератор) и потребитель (System_LED). Осталось проложить между ними провод.

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

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

Подготовка к будущим задачам: Цифровой вход

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

В левой панели (Дерево проекта) нажмите плюс в разделе «Входы».
Назовите тег User_Button.
Привяжите его к пину PA0 (как мы обсуждали в обзоре архитектуры).
Обязательно поставьте галочку «Включить подтягивающий резистор (Pull-Up)» — это аппаратная защита от дребезга контактов, которая стабилизирует сигнал, когда кнопка не нажата.
Перетащите User_Button на холст ниже нашей мигающей цепи.

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

Алгоритм полностью готов. Логика мигания собрана и привязана к физическим пинам микроконтроллера. Следующий шаг — превратить эту графическую схему в машинный код и физически передать ее в память STM32.

Разработка первого алгоритма: логика управления светодиодом

У нас есть настроенный генератор импульсов и программный выход System_LED. По отдельности они — как двигатель и колеса, лежащие в разных углах мастерской. Алгоритм не заработает, пока мы не соединим эти элементы в единую цепь передачи данных и не дадим системе команду на запуск.

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

Управляющий вход EN и логические константы

Если вы просто перетащите генератор на холст и соедините его выход с тегом System_LED, при запуске контроллера ничего не произойдет. Это одна из самых частых ловушек визуального программирования.

Обратите внимание на левую сторону блока генератора: там находится вход EN (Enable).

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

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

В Дереве проекта (или в Библиотеке элементов, в зависимости от версии FLProg) есть раздел «Константы». Нам нужна логическая (Boolean) константа. Она может принимать только два состояния:

True (Истина / Логическая 1) — включено.
False (Ложь / Логический 0) — выключено.

Состояние входа EN	Поведение генератора	Результат на выходе Q
Не подключен	Блок игнорируется программой	Сигнала нет
Подключена константа `False`	Блок принудительно остановлен	Постоянный логический 0
Подключена константа `True`	Блок генерирует импульсы	Чередование 1 и 0

Сборка алгоритма на холсте

Теперь у нас есть все три необходимых компонента. Соберем их в единую цепь, помня главное правило FBD: сигнал всегда течет слева направо.

Источник разрешения: Вытащите на левый край холста логическую константу и задайте ей значение True.
Логика: Поместите правее блок генератора. Соедините выход константы со входом EN генератора. Теперь генератор всегда включен.
Исполнитель: Поместите на правый край холста тег выхода System_LED. Соедините выход генератора (обычно обозначается буквой Q) со входом тега System_LED.

При наведении курсора на контакт блока он подсвечивается. Зажмите левую кнопку мыши и протяните линию к контакту следующего блока. Как только линия станет сплошной — виртуальный провод проложен.

Математика времени и инверсия логики

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

Полный период работы алгоритма описывается формулой: $T = t_{on} + t_{off}$

Где:

$T$ — полный период (в нашем случае 1000 мс или 1 секунда).
$t_{on}$ — время, когда генератор выдает логическую единицу (500 мс).
$t_{off}$ — время, когда генератор выдает логический ноль (500 мс).

Важный нюанс: генератор отправляет логическую 1 в тег System_LED. Но мы помним, что светодиод на пине PC13 аппаратно инвертирован (включается нулем). Здесь проявляется сила среды FLProg: поскольку при создании тега мы поставили галочку «Инвертировать», программа сама перевернет сигнал «под капотом». Когда генератор выдает 1, контроллер подаст на физическую ножку 0, и светодиод загорится. Нам не нужно усложнять визуальную схему дополнительными блоками отрицания (NOT).

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

Физическое подключение платы к компьютеру и настройка COM-портов

Схема собрана, генератор отсчитывает виртуальные миллисекунды на рабочем холсте FLProg, а провода Dupont надежно соединяют контроллер с программатором. Но пока вы не вставите ST-Link в USB-порт компьютера, ваш проект остается лишь картинкой на экране. Компьютер и микроконтроллер существуют в разных измерениях, и сейчас мы построим между ними мост.

Первое включение: аппаратный отклик

Возьмите ваш ST-Link V2 с уже подключенной платой Blue Pill и вставьте его в свободный USB-порт компьютера. Желательно использовать порты на материнской плате (на задней панели системного блока), так как USB-хабы на передней панели иногда не обеспечивают стабильного питания.

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

На корпусе ST-Link загорится красный светодиод — это означает, что программатор получил питание от USB.
На плате STM32 Blue Pill загорится светодиод питания (обычно красный или синий, маркирован как PWR).

Питание на плату поступает именно потому, что на этапе сборки стенда мы соединили пин 3.3V программатора с пином 3.3V контроллера. Теперь вся логика запитана от компьютера.

Парадигма COM-портов: Arduino против STM32

Если вы ранее программировали 8-битные платы вроде Arduino Uno, то привыкли к стандартному ритуалу: подключить кабель, зайти в настройки среды и выбрать порт (например, COM3 или COM5). Название этой статьи также упоминает настройку COM-портов, но именно здесь кроется главное архитектурное отличие профессиональной отладки от любительской.

При работе с Arduino интерфейс USB-UART на плате создает в системе виртуальный COM-порт. Компьютер думает, что общается со старым последовательным портом из 90-х годов.

При работе с STM32 через ST-Link парадигма меняется. ST-Link общается с компьютером напрямую по протоколу USB, минуя эмуляцию устаревших COM-портов.

Виртуальный COM-порт (VCP) — это программная эмуляция физического последовательного интерфейса. Компьютер передает данные через USB, но операционная система и программы видят это подключение как классический COM-порт.

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

Характеристика	Классический подход (Arduino Uno)	Профессиональный подход (STM32 + ST-Link)
Интерфейс связи	USB-UART преобразователь (CH340/FTDI)	Аппаратный программатор ST-Link
Отображение в ОС	Порты (COM и LPT) -> USB-SERIAL CH340 (COM5)	Устройства USB -> STMicroelectronics STLink
Выбор в программе	Обязательный выбор конкретного номера COM-порта	Автоматическое обнаружение программатора
Возможности	Только загрузка кода и текстовый монитор	Загрузка кода и глубокая пошаговая отладка

Проверка связи в Диспетчере устройств Windows

Чтобы убедиться, что компьютер корректно распознал наше устройство, нам нужно проверить работу драйвера STSW-LINK009, который мы устанавливали ранее.

Нажмите правой кнопкой мыши на меню «Пуск» и выберите «Диспетчер устройств».
Поскольку мы выяснили, что ST-Link не использует COM-порты, не ищите его в разделе «Порты (COM и LPT)».
Разверните раздел «Контроллеры USB» (Universal Serial Bus devices).
Найдите в списке устройство с названием STMicroelectronics STLink dongle.

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

Что происходит в FLProg?

Возникает закономерный вопрос: нужно ли что-то настраивать в самой среде FLProg на этом этапе?

Поскольку на этапе создания проекта мы жестко задали метод загрузки как «ST-Link», компилятор FLProg автоматически отключил требования к поиску COM-портов для заливки прошивки. Среда знает, что при нажатии кнопки компиляции ей нужно будет обратиться напрямую к утилите STM32CubeProgrammer, которая сама найдет подключенный ST-Link на шине USB.

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

Процесс компиляции и загрузка готовой программы в контроллер

Схема собрана, генератор настроен на период в 1000 миллисекунд, а на программаторе ST-Link горит красный светодиод, подтверждая физическое подключение. Однако сейчас микроконтроллер STM32 Blue Pill абсолютно «глух» к нашему визуальному алгоритму. Кремниевый чип не понимает, что такое функциональные блоки, линии связи или графический интерфейс — он способен оперировать только нулями и единицами. Чтобы плата ожила, нарисованную схему нужно перевести на язык аппаратной логики и физически поместить внутрь чипа.

Этот переход от картинки на мониторе к мигающему светодиоду на столе состоит из двух этапов: программной трансляции и аппаратной прошивки.

Трансляция: как картинка становится кодом

Когда вы нажимаете кнопку «Компилировать проект» (иконка с шестеренкой) на верхней панели FLProg, программа не отправляет схему напрямую в контроллер. FLProg выступает в роли умного переводчика.

Программа анализирует всё, что вы разместили на рабочем холсте, считывает настройки портов из Дерева проекта и автоматически пишет текстовый код на языке C++.

Компиляция (в контексте FLProg) — это процесс автоматической генерации исходного кода на языке C++ на основе визуальной FBD-схемы, с последующим его преобразованием в машинный код.

Как только генерация завершается, FLProg автоматически открывает окно Arduino IDE. Это стороннее приложение выступает в роли «движка», который возьмет сгенерированный C++ код и превратит его в финальный бинарный файл для контроллера.

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

void setup()
{
  pinMode(PC13, OUTPUT);
}
void loop()
{
  // Здесь скрыта математика нашего симметричного мультивибратора
}

Вам не нужно редактировать этот код. Архитектура комплекса выстроена так, что FLProg делегирует Arduino IDE самую сложную техническую часть — сборку машинного кода с учетом архитектуры ядра ARM Cortex-M3, на котором построен наш STM32.

Разделение зон ответственности

Чтобы путаницы не возникало, давайте четко разделим, какая программа за что отвечает на этом этапе.

Среда	Что мы в ней делаем	Что происходит «под капотом»
FLProg	Рисуем схему, задаем логику, нажимаем «Компилировать».	Генерирует C++ код и передает его дальше.
Arduino IDE	Ничего не пишем. Только нажимаем кнопку «Загрузка» (стрелка вправо).	Превращает C++ в нули и единицы, связывается с ST-Link.
ST-Link (железо)	Просто подключен к USB.	Подает сигналы на пины SWD микроконтроллера.

Прошивка памяти микроконтроллера

В окне Arduino IDE, в левом верхнем углу, находится кнопка «Загрузка» (круглая иконка со стрелкой вправо). При её нажатии запускается финальная стадия.

Arduino IDE компилирует бинарный файл и обращается к драйверу ST-Link, который мы установили ранее. Программатор берет управление микроконтроллером на себя через интерфейс SWD.

Процесс записи программы в чип не происходит мгновенно. Он всегда состоит из двух обязательных аппаратных шагов:

Стирание (Erase): Нельзя записать новые данные поверх старых. Программатор подает специальный сигнал, который очищает сектора Flash-памяти микроконтроллера, заполняя их логическими единицами.
Запись (Write): Только после очистки программатор начинает последовательно, байт за байтом, загружать наш скомпилированный алгоритм мигания.

Flash-память — энергонезависимая память микроконтроллера, в которой хранится исполняемая программа. Она сохраняет данные даже после отключения питания платы.

В нижней части окна Arduino IDE (в черной консоли) побегут белые строки. Это отчет утилиты STM32CubeProgrammer (которая встроена в ядро), рапортующий о ходе стирания и записи.

Момент истины

Как только в консоли появится надпись «Done uploading» (Загрузка завершена), программатор отдаст команду микроконтроллеру на перезагрузку.

В эту же секунду чип STM32 начнет выполнять загруженную в него программу. Вы увидите, как зеленый светодиод на плате Blue Pill (подключенный к пину PC13) начнет ритмично мигать: полсекунды горит, полсекунды не горит. Аппаратная инверсия, которую мы учли в настройках выхода, сработала корректно — логика генератора идеально совпала с физическим поведением светодиода.

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

Диагностика и решение типичных проблем при прошивке устройства

Вы нажимаете кнопку «Загрузить», с предвкушением смотрите в консоль, но вместо заветного «Done uploading» экран взрывается полотном красного текста. Прошивка прервана, светодиод не мигает. Для начинающего разработчика это момент паники, а для инженера — абсолютно штатная ситуация и начало нормального рабочего процесса.

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

Анатомия ошибки: кто с нами говорит?

Когда FLProg передает эстафету Arduino IDE для компиляции и прошивки, в дело вступает скрытая утилита OpenOCD.

OpenOCD (Open On-Chip Debugger) — это программа-переводчик, которая берет скомпилированный машинный код и через программатор ST-Link побайтово укладывает его в память микроконтроллера.

Именно OpenOCD генерирует 90% красного текста при неудачной прошивке. Главное правило чтения логов: ищите первую ошибку. Программа может выдать пятьдесят строк красного текста, но 49 из них — это лишь следствие того, что на первом шаге что-то пошло не так. Прокрутите консоль в самый верх красного блока и найдите строку, начинающуюся со слова Error:.

Топ-3 аппаратных ошибок и их решения

Чаще всего среда разработки и код абсолютно исправны, а проблема кроется в физическом мире: проводах, контактах и самих чипах. Рассмотрим три самые популярные ситуации.

1. Ошибка связи: «No target connected»

Как выглядит в консоли: Error: init mode failed (unable to connect to the target) или Target voltage: 0.000000

Что это значит: Программатор ST-Link успешно определился компьютером, но он «не видит» микроконтроллер на другом конце проводов. Физическая цепь разорвана.

Решение: Пройдитесь по чек-листу аппаратного соединения:

Питание: Горит ли красный светодиод (PWR) на самой плате Blue Pill? Если нет, проверьте провода 3.3V и GND.
Перекрестное подключение: Самая частая ошибка новичков — перепутать информационные линии. Сигнал синхронизации (SWCLK) должен идти строго в пин CLK, а линия данных (SWDIO) — в пин DIO. В отличие от интерфейса UART, где контакты подключаются крест-накрест (RX к TX), в интерфейсе SWD подключение прямое: контакт в контакт.

2. Война клонов: «UNEXPECTED idcode»

Как выглядит в консоли: Error: expected 1 of 1: 0x1ba01477, found 0x2ba01477 Error: UNEXPECTED idcode: 0x2ba01477

Что это значит: У каждого микроконтроллера есть свой уникальный аппаратный паспорт — IDCODE. OpenOCD стучится в чип и спрашивает: «Ты оригинальный STM32F103?». Чип отвечает: «Нет, мой код другой».

Из-за дефицита оригинальных компонентов платы Blue Pill часто собирают на базе китайских чипов-клонов: CKS32, CS32, APM32. Они на 99% совместимы с оригиналом по логике работы, но имеют другой IDCODE, из-за чего OpenOCD отказывается их прошивать в целях безопасности.

Решение: Внимательно посмотрите на сам черный квадрат микроконтроллера на вашей плате.

Если вместо логотипа ST и надписи STM32 вы видите другие буквы (например, CKS32), вам нужно сказать среде разработки игнорировать проверку паспорта. В Arduino IDE в меню «Инструменты» (Tools) найдите пункт, связанный с оптимизацией или вариантом платы, и выберите опцию, поддерживающую клоны (часто обозначается как Generic STM32F103C series или требует выбора метода загрузки STLink (Clone), в зависимости от установленного ядра).

3. Плата "оглохла": программная блокировка пинов

Как выглядит в консоли: Ошибка похожа на первую (unable to connect), но вы на 100% уверены, что провода подключены верно, и вчера эта же плата прошивалась без проблем.

Что это значит: Вы загрузили в контроллер программу, которая переназначила пины PA13 и PA14 (именно на них физически висит интерфейс SWD) под другие задачи. Например, вы случайно настроили их как обычные выходы для светодиодов. Как только контроллер получает питание, он запускает вашу программу, отключает интерфейс отладки, и ST-Link больше не может до него «достучаться».

Решение: Аппаратный сброс через BOOT0 На плате Blue Pill есть два желтых джемпера (перемычки). Верхний отвечает за режим загрузки — пин BOOT0.

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

Отключите плату от USB.
Переставьте перемычку BOOT0 из положения 0 в положение 1. При состоянии $BOOT0 = 1$ микроконтроллер загружается в безопасном системном режиме, игнорируя вашу программу во Flash-памяти.
Подключите плату к USB. Теперь интерфейс SWD свободен.
Загрузите пустую или исправленную схему из FLProg.
Отключите питание, верните перемычку BOOT0 обратно в положение 0 и снова подайте питание. Плата спасена.

Сводная таблица диагностики

Симптом (текст ошибки)	Вероятная причина	Быстрое действие
`Target voltage: 0.000`	Нет питания на плате	Проверить провода 3.3V и GND
`unable to connect to the target`	Перепутаны информационные линии	Проверить соответствие SWDIO -> DIO, SWCLK -> CLK
`UNEXPECTED idcode`	На плате установлен чип-клон	Проверить маркировку чипа, изменить настройки платы в IDE
Вчера работало, сегодня `init mode failed`	Программа заблокировала пины SWD	Прошить плату с перемычкой $BOOT0 = 1$

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

Практика: модификация схемы и добавление управления кнопкой

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

Физическое подключение кнопки

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

Для подключения вам понадобится тактовая кнопка и два провода Dupont.

Подключите первый контакт кнопки к пину PA0 на плате STM32 Blue Pill.
Подключите второй контакт кнопки к любому пину GND (земля) на той же плате.

Подтягивающий резистор (Pull-Up) — это внутренний компонент микроконтроллера, который принудительно соединяет пин с линией питания (3.3 В), когда внешняя цепь разомкнута.

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

Благодаря включенному Pull-Up, мы получаем стабильную картину:

Кнопка отпущена: цепь разорвана, напряжение на пине $U_{pin} = 3.3$ В (где $U_{pin}$ — напряжение на контакте микроконтроллера). Контроллер считывает уверенную логическую единицу.
Кнопка нажата: ток уходит по пути наименьшего сопротивления в землю (GND). Напряжение $U_{pin} = 0$ В. Контроллер считывает логический ноль.

Модификация FBD-схемы

Откройте ваш проект в FLProg, где собран мигающий светодиод. Наша задача — убрать «заглушку» и пустить реальный сигнал на управляющий вход генератора.

Шаг 1: Удаление константы

На рабочем холсте найдите блок генератора. К его входу EN (Enable) сейчас подключена зеленая константа True. Выделите константу кликом мыши и нажмите клавишу Delete на клавиатуре. Связь разорвется, и вход EN освободится.

Шаг 2: Добавление входа на холст

В левой панели (Дерево проекта) раскройте папку «Входы» и найдите созданный ранее тег User_Button. Зажмите его левой кнопкой мыши и перетащите на рабочий холст, расположив слева от генератора.

Шаг 3: Соединение логики

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

Ловушка инверсной логики

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

Давайте проследим цепочку:

Кнопка отпущена $\rightarrow$ физический сигнал на пине PA0 равен 1 (благодаря Pull-Up).
Единица приходит на вход EN генератора.
Генератор видит разрешающий сигнал и запускает мигание.

Нам нужно перевернуть эту логику. В традиционном программировании мы бы написали условие с отрицанием. В визуальном FBD можно поставить блок логического НЕ (NOT) из библиотеки. Но FLProg предлагает более изящное решение на уровне конфигурации самого входа.

Дважды кликните по входу User_Button в Дереве проекта (не на холсте, а именно в левой панели). В открывшемся окне настроек поставьте галочку «Инвертировать» и нажмите «Готово».

Теперь FLProg будет автоматически переворачивать физический сигнал в программный:

Физический 0 (кнопка нажата) превратится в программную 1 $\rightarrow$ генератор включится.
Физический 1 (кнопка отпущена) превратится в программный 0 $\rightarrow$ генератор остановится.

Загрузка и проверка

Схема готова. Нажмите кнопку «Компилировать проект» на верхней панели FLProg. Дождитесь открытия Arduino IDE и нажмите кнопку «Загрузка» (стрелка вправо), как мы делали в предыдущих главах.

После появления сообщения «Done uploading» протестируйте ваше устройство. Светодиод на плате должен молчать. Нажмите и удерживайте подключенную кнопку — светодиод начнет ритмично мигать с периодом, который мы задали в настройках генератора. Отпустите кнопку — мигание мгновенно прекратится.

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

Подведение итогов модуля и задание для самостоятельной работы

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

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

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

Уровень	Суть этапа	Критические точки контроля
1. Аппаратный стенд	Физическое соединение компонентов	Верная распиновка SWD, наличие подтягивающего резистора (Pull-Up) для кнопки, питание 3.3 В.
2. Конфигурация среды	Синхронизация FLProg с железом	Выбор чипа STM32F103C8, установка тактовой частоты 72 МГц, привязка входов/выходов к реальным пинам (PA0, PC13).
3. Логика FBD	Построение алгоритма	Маршрутизация сигнала слева направо, использование констант, управление входом EN (Enable).
4. Компиляция и загрузка	Перевод схемы в машинный код	Успешная генерация C++, отсутствие ошибок OpenOCD, стирание Flash-памяти перед записью.

Визуальное программирование не отменяет необходимости понимать «железо». FBD-схема лишь автоматизирует написание C++ кода, но разработчик по-прежнему обязан знать, на каком пине висит светодиод и почему «висящий в воздухе» контакт кнопки убьет логику алгоритма.

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

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

Техническое задание: проект «Тревожный маяк»

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

Аппаратные требования:

Целевая платформа: STM32F103C8 (Blue Pill).
Исполнительное устройство: Встроенный светодиод на пине PC13.
Управляющее устройство: Тактовая кнопка, подключенная к пину PA1 (обратите внимание, это новый пин, не PA0) и GND.

Требования к логике (FBD):

В состоянии покоя (кнопка не нажата) светодиод должен быть выключен.
При удержании кнопки нажатой светодиод должен начать мигать.
Полный период мигания задан как $T = 200$ мс, где $100$ мс светодиод горит, и $100$ мс — погашен. (Формула периода: $T$ определяет общее время одного цикла генератора).
Как только кнопка отпускается, мигание должно мгновенно прекратиться, светодиод возвращается в выключенное состояние.

Чек-лист для самопроверки:

[ ] Проект создан заново, контроллер выбран верно.
[ ] В Дереве проекта создан цифровой вход для PA1.
[ ] Для входа PA1 включен внутренний подтягивающий резистор (Pull-Up).
[ ] Настроена программная инверсия для кнопки (чтобы нажатие давало True).
[ ] В Дереве проекта создан цифровой выход для PC13.
[ ] Настроена программная инверсия для выхода PC13 (так как встроенный светодиод управляется нулем).
[ ] На рабочий холст добавлен блок «Генератор», настроенный на симметричный мультивибратор с нужными таймингами.
[ ] Вход генератора EN соединен с цифровым входом кнопки, а выход генератора — с цифровым выходом светодиода.
[ ] Программа успешно скомпилирована и загружена в плату через ST-Link.
[ ] Физическое поведение платы полностью соответствует Техническому заданию.

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