Привет, Хабр!

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

В данной статье будет представлен пример контроля напряжения, над блоком питания - внутри которого (никель-металлгидридная аккумуляторная сборка NiMH 14.4В/12 банок по 1.2В(1.4В- при полной зарядке)).

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

• Работа с кнопкой;

• Работа со светодиодом;

• Работа с пъезоэлектрическим излучателем(звуковая индикация);

• Контроль заряда/разряда аккумулятора(дает звуковой сигнал при напряжении менее 9 вольт и более 14).

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

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

Для решения данной проблемы я продемонстрирую пример системы контроля напряжения блока питания, в качестве микроконтроллера выбран STM32F103С8T6, который выполняет следующие задачи:

• Непрерывный мониторинг напряжения аккумуляторной сборки, измерение производится через АЦП с использованием DMA;

• Оповещение пользователя о низком заряде, при падении напряжения ниже установленного порога (в данном примере - 9.0В) система активизирует звуковой сигнал, время работы оповещения ограничено - звуковая индикация будет длится 5 минут;

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

Схема подключения NiMH АКБ, делителя напряжения к АЦП МК, кнопки вкл/выкл и пъезо-излучателя

Перечень компонентов

Объяснение схемы

Узел[1]

• Входной силовой ключ, исток подключен к +12V, сток идет к блоку питания(+12_АКК) через предохранители, а затвор подтянут к земле, применение (защищенная подача напряжения питания с аккумуляторного блока);

Узел[2]

• Вторичный силовой ключ, обеспечивает управляемое включение/отключение напряжения питания основной нагрузки системы, управление происходит через МК, сигнал PWR_ON, после включения данного узла, на стоке напряжение питания +12ВК активизируется и передает напряжение другим частям схемы, в моем примере это (узел[4]-Звуковая индикация и узел[5]-lделитель напряжения), но также можно использовать данный узел и на включение преобразователей напряжения;

Узел[3]

• Данный узел обеспечивает логику взаимодействия с кнопкой включения/выключения, кнопка sa2, при нажатии формирует управляющий сигнал, диод АD4 и конденсатор С1 обеспечивают фильтрацию и антидребезг.

Узел[4]

• Данный узел обеспечивает звуковую индикацию, сигнал BEEP подключается к МК;

Узел[5]

Данный узел является делителем напряжения, делит напряжение до уровня, подходящего для измерения АЦП МК (обычно до 3.3V), подстроечный резистор R8, выставлен на 1.7кОм.

Настройка микроконтроллера STM32F103 в CubeIDE

Конфигурация TIM1(PA11)

Таймер TIM1 выполняет роль генератора для звуковой индикации.

Настройка таймера:

• Предделитель (Prescaler) и период (Auto-Reload) выбраны так, чтобы на выходе формировался сигнал с частотой в диапазоне, воспринимаемом слухом (обычно 1–5 кГц);

• Режим работы – PWM (широтно-импульсная модуляция);

• Коэффициент заполнения (Pulse) определяет громкость и характер звучания.

Принцип работы:
Таймер генерирует ШИМ-сигнал, который подаётся на транзисторный ключ. Транзистор управляет пьезоизлучателем или динамиком. В результате получается слышимый звук.

Преимущества такого решения:

• Микроконтроллеру не нужно вручную формировать частоту – этим занимается таймер;

• Легко изменять тональность: достаточно переписать значения ARR/PSC;

• Можно реализовать разные звуковые эффекты (короткие сигналы, мелодии) простым управлением таймером из программы.

Конфигурация ADC(PA1)

В проекте используется многоканальный режим работы АЦП с двумя каналами в последовательности (Regular conversion sequence).

Rank 1 – внешний канал (ADC Channel 1).
Этот вход подключён к делителю напряжения и используется для измерения напряжения аккумулятора.
Благодаря этому микроконтроллер может в реальном времени контролировать состояние питания устройства.

Rank 2 – внутренний канал (Vrefint).
Это встроенный источник опорного напряжения микроконтроллера. Он служит для автоматической калибровки и компенсации возможных изменений питающего напряжения. С его помощью можно более точно измерять значение внешних сигналов, в том числе напряжение аккумулятора.

Для повышения эффективности задействован DMA: результаты обоих измерений (Rank 1 и Rank 2) автоматически передаются в память, а процессор получает только готовые данные.

Для правильной настройки ADC я воспользовался данной информацией, там подробно расписано как работать с ADC МК-STM32.

Конфигурация пина для работы с кнопкой

Для работы с кнопкой выбран вывод PB11, сконфигурированный в режиме:

• GPIO_EXTI – внешний прерывающий вход. Это значит, что нажатие кнопки обрабатывается не опросом в цикле, а через аппаратное прерывание;

• Mode - External interrupt, Falling edge trigger – прерывание срабатывает по спаду сигнала (при замыкании кнопки на землю);

• Pull-up – включен внутренний подтягивающий резистор, который удерживает вход в состоянии логической «1», пока кнопка не нажата.

Кнопка подключена так, что в обычном состоянии на входе PB11 присутствует логическая «1» благодаря встроенному подтягивающему резистору (Pull-up). При нажатии контакт замыкается на землю, формируется логический «0» и происходит спад сигнала. Этот спад фиксируется модулем EXTI, который вызывает прерывание.

Конфигурация пина для работы с сигналом PWR_ON

Сигнал PWR_ON играет роль электронного «выключателя питания».

В исходном состоянии (Low) нагрузка обесточена.

При активации (перевод вывода в High) силовой MOSFET открывается, и напряжение +12ВК подаётся на остальные узлы системы.

В примере данная линия питает:

узел [4] – звуковую индикацию,

узел [5] – делитель напряжения для мониторинга питания.

Аналогично этот узел можно использовать и для включения DC/DC-преобразователей или других модулей, требующих управляемого питания.

Конфигурация Clock

Реализация программного кода

Ссылка на скачивание исходного кода [ https://t.me/ChipCraft В закрепленном сообщении [ #исскуствомк_исходный_код -Исходный код для Adc_VoltageControl_STM32F103C8T6]

Заголовочный файл keys.h (работа с кнопками)

В данном файле определены:

• Функции работы с кнопками;

• Битовые маски состояний;

• константы для различных сценариев нажатий.

#ifndef INC_PROJECT_BU_KEYS_H_
#define INC_PROJECT_BU_KEYS_H_

unsigned short getKeyState(void);
//выдаёт состояние пинов кнопок в данный момент без учёта задержек для дребезга
unsigned short getKeyPinState_AtNow(void);
void keysDrv_Handler(void);//эту функцию нужно вызывать постоянно

#ifndef KEY1_Drv
#define KEY1_Drv			1u //кнопка нажата
#endif
#ifndef KEY1Double_Click_Drv
#define KEY1Double_Click_Drv			
#endif
#ifndef KEY3_Drv
#define KEY3_Drv			4u
#endif
#ifndef KEY4_Drv
#define KEY4_Drv			8u
#endif

#ifndef KEY1Hold_Drv
#define KEY1Hold_Drv			16u // кнопка удерживается
#endif
#ifndef KEY2Hold_Drv
#define KEY2Hold_Drv			32u
#endif
#ifndef KEY3Hold_Drv
#define KEY3Hold_Drv			64u
#endif
#ifndef KEY4Hold_Drv
#define KEY4Hold_Drv			128u
#endif

#ifndef KEY1Release_Drv
#define KEY1Release_Drv			256u //Бит отпускания кнопки
#endif
#ifndef KEY2Release_Drv
#define KEY2Release_Drv			512u
#endif
#ifndef KEY3Release_Drv
#define KEY3Release_Drv			1024u
#endif
#ifndef KEY4Release_Drv
#define KEY4Release_Drv			2048u
#endif

#endif /* INC_PROJECT_BU_KEYS_H_ */

Реализация модуля keys.c (работа с кнопками)

Данный модуль включает в себя задачи:

• Устранение дребезга контактов;

• Различие между коротким и долгим нажатием;

• Отслеживание событий нажатия, удержания и отпускания.

keysDrv_Handler()

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

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

2.	if(gl_kDrv_key1_blockEvent == 0 && ON_OFFB_state == KEY_PRESS) {
3.	    gl_kDrv_key1_blockEvent = 1;
4.	    gl_kDrv_time_key1_press = ms;
5.	}

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

Фильтр дребезга

else if(gl_kDrv_key1_blockEvent == 1 && 
        ON_OFFB_state==KEY_PRESS && 
        gl_kDrv_key1_short_state==0 && 
        (ms - gl_kDrv_time_key1_press) > DELAY4TIMER){
		//прошло время защиты от дребезга, кнопка нажата
		gl_kDrv_key1_short_state=1;
		keyState &= ~KEY1Release_Drv;//снимаем бит отпускания кнопки
		keyState |= KEY1_Drv;
	}

Если прошло больше DELAY4TIMER, считаем кнопку реально нажатой.

Определение удержания

else if(gl_kDrv_key1_blockEvent == 1 && 
        ON_OFFB_state==KEY_PRESS && 
        gl_kDrv_key1_short_state==1 && 
        (ms - gl_kDrv_time_key1_press) > DELAY_HOLD_TIMER){
		keyState |= KEY1Hold_Drv;
	}

Если прошло больше DELAY_HOLD_TIMER, выставляем бит удержания.

Отпускание кнопки

else if(gl_kDrv_key1_blockEvent == 1 && ON_OFFB_state==KEY_UNPRESS && gl_kDrv_key1_short_state==1){
		gl_kDrv_key1_blockEvent=0;
		gl_kDrv_key1_short_state=0;
		keyState |= KEY1Release_Drv;
		keyState &= ~KEY1_Drv;//снимаем бит нажатия кнопки
		keyState &= ~KEY1Hold_Drv;//снимаем бит удержания кнопки
	}

При отпускании кнопки сбрасываются флаги удержания и нажатия, выставляется бит отпускания.

getKeyState()

Возвращает текущее состояние кнопок в виде битовой маски

• Позволяет определить, была ли кнопка нажата, удержана или отпущена;

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

getKeyPinState_AtNow()

Возвращает моментальное состояние ножек GPIO, без учета дребезга

• Полезно для отладки или когда нужно мгновенно узнать, нажата ли кнопка прямо сейчас

#include "./Project/BU/keys.h"
#include "./Project/shared.h"
#include "main.h"
#include <stdlib.h>//abs
#include <string.h>//memset
#include <stdio.h>

//установки
#define DELAY4TIMER			20//задержка для таймера в миллисекундах (на дребезг)
//25u//больше чем COUNT_HOLD_PERIODS, то считается, что кнопка зажата (долгое нажатие)
#define COUNT_HOLD_PERIODS	40
#define DELAY_HOLD_TIMER	400//задержка для отслеживания удержания в миллисекундах
//E N D установки

//настройки
#define KEY1_GPIO_Port GPIOB //буква порта для кнопки  (GPIOA, GPIOB, GPIOC, ...)
#define KEY1_Pin GPIO_PIN_11 //номер пина на порту для кнопки
//E N D настройки

volatile unsigned short keyState=0x0;//установка битов что кнопки отпущены

#define KEY_PRESS 1 //1=нажатая кнопка это логическая единица, иначе 0
#define KEY_UNPRESS 0//0=отпущенная кнопка это логический ноль, иначе 1

uint8_t gl_kDrv_key1_blockEvent = 0;//обрабатывать ли событие нажатия кнопки 1
uint32_t gl_kDrv_time_key1_press = 0;//время, когда была нажата кнопка
uint8_t gl_kDrv_key1_short_state = 0;//обработали ли короткое нажатие


void keysDrv_Handler(){

	uint32_t ms = HAL_GetTick();
	uint8_t ON_OFFB_state = HAL_GPIO_ReadPin(KEY1_GPIO_Port, KEY1_Pin);

	//кнопка 1
	//если не заблокировано обработка события и кнопка нажата
	if(gl_kDrv_key1_blockEvent == 0 && ON_OFFB_state==KEY_PRESS){
		gl_kDrv_key1_blockEvent=1;
		gl_kDrv_time_key1_press = ms;
	}else if(gl_kDrv_key1_blockEvent == 1 && ON_OFFB_state==KEY_PRESS && gl_kDrv_key1_short_state==0
			&& (ms - gl_kDrv_time_key1_press) > DELAY4TIMER){
		//прошло время защиты от дребезга, кнопка нажата
		gl_kDrv_key1_short_state=1;
		keyState &= ~KEY1Release_Drv;//снимаем бит отпускания кнопки
		keyState |= KEY1_Drv;
	//кнопка удерживается
	}else if(gl_kDrv_key1_blockEvent == 1 && ON_OFFB_state==KEY_PRESS
			&& gl_kDrv_key1_short_state==1 && (ms - gl_kDrv_time_key1_press) > DELAY_HOLD_TIMER){
		keyState |= KEY1Hold_Drv;
	//кнопка отпущена
	}else if(gl_kDrv_key1_blockEvent == 1 && ON_OFFB_state==KEY_UNPRESS && gl_kDrv_key1_short_state==1){
		gl_kDrv_key1_blockEvent=0;
		gl_kDrv_key1_short_state=0;
		keyState |= KEY1Release_Drv;
		keyState &= ~KEY1_Drv;//снимаем бит нажатия кнопки
		keyState &= ~KEY1Hold_Drv;//снимаем бит удержания кнопки
	//если сработало первое условие но не сработали остальные
	}else if(gl_kDrv_key1_blockEvent == 1 && ON_OFFB_state==KEY_UNPRESS
			&& (ms - gl_kDrv_time_key1_press) > COUNT_HOLD_PERIODS*2){
		gl_kDrv_key1_blockEvent=0;
		gl_kDrv_key1_short_state=0;
	}
}
	unsigned short getKeyState(void){
		// данный блок служит для проверки срабатывает ли keyState никуда дальше не идет.
		if(keyState){//-проверяет является ли выражение не нулевым
			int i=0;
			i++;
		}

		unsigned short ret=keyState;//здесь я получаю состояние кнопки

		keyState &= 0xF0FF;//снимаем бит отпускания кнопки

		return ret;
	}
	//выдаёт состояние пинов кнопок в данный момент без учёта задержек для дребезга
	unsigned short getKeyPinState_AtNow(void)
	{
		unsigned short ret=0;

		uint8_t key1_state = HAL_GPIO_ReadPin(KEY1_GPIO_Port, KEY1_Pin);

		if(key1_state==KEY_PRESS){//если кнопка нажата
			ret |= KEY1_Drv;
		}
		return ret;
	}

Реализация модуля ADC_Calc.c (работа с АЦП)

Данный модуль реализует контроль напряжения питания через АЦП микроконтроллера STM32F103C8T6, измерения выполняются с использованием:

• DMA (циклическая запись данных в буфер);

• Встроенного опорного напряжения Vrefint;

• Собственного делителя напряжения на входе.

ADC_Calc_Handler() - главный обработчик вычислений

• Проверяет, заполнена ли первая или вторая половина DMA-буфера;

• Усредняет значения для канала измерения и Vrefint;

• Конвертирует результат в напряжение вызовом adc_calcVoltage();

• Если напряжение ниже порога critical_stress → возвращает команду отключения питания (FORCE_POWER_OFF);

• Производит фильтрацию значений по диапазону 750 < val_input < 2800 (защита от шумов и выбросов).

HAL_ADC_ConvCpltCallback()

Вызывается по прерыванию DMA Transfer Complete → устанавливает флаг adcIRFullDone

HAL_ADC_ConvHalfCpltCallback()

Вызывается по прерыванию DMA Half Transfer Complete → устанавливает флаг adcIRHalfDone

adc_init()

• Сброс флагов и буфера.

adc_start()

Запускает АЦП в режиме DMA, далее происходит циклическое заполнение adcDMAbuf без участия процессора

adc_stop()

• Останавливает АЦП и DMA;

• Сбрасывает флаги готовности

adc_calcVoltage()

Ключевая функция — переводит «сырые» значения АЦП в напряжение

adc_GetVoltage()

Геттер для получения последнего значения рассчитанного напряжения

Общий алгоритм работы:

• DMA заполняет буфер парами значений (input, Vrefint);

• При заполнении половины буфера → срабатывает прерывание, ставится флаг;

• ADC_Calc_Handler считывает данные, фильтрует и усредняет;

• Вызывается adc_calcVoltage, которая переводит вольты;

• Значение доступно через adc_GetVoltage();

• Если напряжение меньше 9 В (по critical_stress) → отрабатывает аварийное выключение.

#include "./Project/shared.h"
#include "./Project/BU/keys.h"
#include "./Project/BU/ADC_Calc.h"
#include "main.h"
#include <stdlib.h>//abs
#include <string.h>//memset
#include <stdio.h>
//у F103 нет калибр.значения, взято из datasheet
#define VREFINT_TYP 1.20

#define SIZE_DMABUF	400

volatile uint16_t adcDMAbuf[SIZE_DMABUF] = {0,};
volatile uint8_t adcIRFullDone=0; //сработало прерывание
volatile uint8_t adcIRHalfDone=0; //сработало прерывание

float gl_voltage=0;

void adc_calcVoltage(uint16_t avg_input, uint16_t avg_vref);

float vadc_ = 0.0f;
float vin = 0.0f;
float vdda = 0.0f;
float critical_stress =9.0f;
unsigned char ret = 0;

uint16_t avg_input = 0;
uint16_t avg_vref = 0;

uint16_t vrefint_cal_adr = 0;

unsigned char ADC_Calc_Handler()
{
	uint32_t sum_input = 0;
	uint32_t sum_vrefint = 0;
	int count = 0;

	if(adcIRHalfDone){//готова первая половина буфера
		adcIRHalfDone = 0;

		for (int i = 0; i < SIZE_DMABUF / 2; i += 2) {
			uint16_t val_input = adcDMAbuf[i];
			uint16_t val_vref = adcDMAbuf[i + 1];

			if (val_input > 750 && val_input < 2800) {
				sum_input += val_input;
				sum_vrefint += val_vref;
				count++;
			}
		}
	}

	if(adcIRFullDone){//готова вторая половина буфера
		adcIRFullDone = 0;

		for (int i = SIZE_DMABUF / 2; i < SIZE_DMABUF; i += 2) {
			uint16_t val_input = adcDMAbuf[i];
			uint16_t val_vref = adcDMAbuf[i + 1];

			if (val_input > 750 && val_input < 2800) {
				sum_input += val_input;
				sum_vrefint += val_vref;
				count++;
			}
		}
	}
	if (count > 0) {
		 avg_input = sum_input / count; //uint16_t
		 avg_vref = sum_vrefint / count;
		adc_calcVoltage(avg_input, avg_vref);
	}
	if(gl_voltage && gl_voltage<=critical_stress && HAL_GetTick()>2000){
		ret=FORCE_POWER_OFF;
	}
	return ret;
}

void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef *hadc)
{
	if(hadc->Instance == ADC1){
		adcIRFullDone=1;
	}
}

void HAL_ADC_ConvHalfCpltCallback(ADC_HandleTypeDef *hadc)
{
	if(hadc->Instance == ADC1){
		adcIRHalfDone=1;
	}
}

void adc_init(void)
{
	adcIRFullDone = 0;
	adcIRHalfDone = 0;
	adcDMAbuf[0] = 0;

#if defined(S_T_M_32F1XX)
	HAL_ADCEx_Calibration_Start(&hadc1);
#endif
}

void adc_start(void)
{
	adcDMAbuf[0] = 0;

	HAL_ADC_Start_DMA(&hadc1, (uint32_t*)&adcDMAbuf, SIZE_DMABUF);
}
void adc_stop()
{
	HAL_ADC_Stop_DMA(&hadc1);
	adcIRFullDone = 0;
	adcIRHalfDone = 0;
}

void adc_calcVoltage(uint16_t avg_input,uint16_t avg_vref)//переводит значение АЦП в напряжение
{
	const float R1 = 221000.0f;
	const float R2 = 27000.0f;
	// считаем VDDA через Vrefint
	float vdda = VREFINT_TYP * 4095.0f / (float)avg_vref;

	// переводим значение канала в напряжение
	float vadc = ((float)avg_input / 4095.0f) * vdda;

	// напряжение на входе через делитель
	 vin = vadc * (R1 + R2) / R2 - 0.5f;
	 gl_voltage = vin;
	// вывод значения для отладки
	vadc_ = vadc;
}
float adc_GetVoltage(void)
{
	return gl_voltage;
}

Пояснение к функции adc_calcVoltage()

Расчет VDDA, где:

VREFINT_TYP - калибровочное значение 1.20, взято из datasheet, у других МК на заводе производитель прошивает калибровочное значение в ПЗУ при изготовлении, пример получения значения с МК STM32F030CCTx [0x1FFFF7BA];

4095 - когда измеряется источник встроенным АЦП, результат выражается в единицах квантования, максимум которых равен 4095, поэтому в формуле используется множитель 4095 - это нормализация значения, чтобы связать измеренный АЦП с напряжением VDDA.

ADC_vref - значение встроенного источника опорного напряжения

Перевод значения канала в напряжение

ADC_in - напряжение измеренное с делителя напряжения (узел[5])

Коррекция через делитель напряжения

Вход подключен через делитель R1=221кОм и R2 = 27кОм, переводим в Ом,

добавил смещение (-0.5) для подстройки измерений.

Таблица замеров напряжения от 14.5 вольт до 7 вольт.

Прикладываю видео-тестирования прохода по спаду напряжения, а также видео-тестирования, сброс напряжения и уход в сон микроконтроллера при низком напряжении ссылка [ https://t.me/ChipCraft В закрепленном сообщении [ #исскуствомк_тестирование_ Adc_VoltageControl]

Реализация модуля proj_main.c (Главный метод)

Данный модуль объединяет несколько подсистем:

• Кнопка управления (одиночное и двойное нажатие);

• Контроль напряжения питания через АЦП;

• Звуковая индикация состояния;

• Автоматический переход в сон при низком напряжении.

#include "./Project/shared.h"
#include "./Project/proj_main.h"
#include "./Project/BU/ADC_Calc.h"
#include "./Project/BU/keys.h"
#include "main.h"

char gl_main_stateKey = 0; //отработали ли код по нажатию на кнопку
char count = 0;//используется для того чтобы пъезо не включался на повторное нажатие кнопки
// Глобальный флаг, установленный при прерывании
volatile uint8_t button_pressed = 0;
float adc_GetVoltage_ = 0;
typedef enum {
    BUZZER_NONE = 0,
    BUZZER_BEEP_1,
    BUZZER_BEEP_2,
    BUZZER_BEEP_3,
	BUZZER_BEEP_4,
} buzzer_state_t;

volatile buzzer_state_t buzzer_state = BUZZER_NONE;
volatile uint32_t buzzer_timer = 0;

volatile uint8_t test_stop = 0;
volatile uint8_t test_stop_1 = 0;

uint8_t adc_ret=0;

#define START_DELAY 250

//для двойного нажатия
uint32_t btnPress_time_start = 0;//время, когда нажали кнопку
#define MIN_DelayDblClck	100 //100 было -50
#define MAX_DelayDblClck	600 //600  было-700
//E N D для двойного нажатия

//переменные для обработки логики при низком напряжении
uint32_t lowVoltageStart = 0;//время начала низкого уровня напряжения
uint8_t lowVoltageActive = 0;//флаг что система в режиме отсчета
#define SHUTDOWN_DELAY 15000
//E N D переменные для обработки логики при низком напряжении

//для звуковой индикации в режиме низкого напр.
uint32_t lowVoltageBeepTimer = 0;  // время последнего писка
#define LOW_VOLTAGE_BEEP_PERIOD 2000 // каждые 2 секунды
//E N D для звуковой индикации в режиме низкого напр.

void SystemClock_Config(void);
void shutdownAndSleep();


void proj_main()
{
	volatile const char *ch = ";V-F-BIN;ver: "VER_PROG(VER_a,VER_b,VER_c);(void)ch;//0x8008b00
	unsigned short keysState=0;//состояние кнопки

	HAL_Delay(1);//чтобы HAL_GetTick() не выдавал ноль
	while (HAL_GetTick()<START_DELAY){;}//задержка, иначе иногда сразу уходит в сон

	keysState=getKeyPinState_AtNow();  //
	if((keysState & KEY1_Drv)==0){//защита от случайного нажатия
		shutdownAndSleep();
	}

	uint32_t ms = 0;
	ms = HAL_GetTick();

	adc_init();
	adc_start();

	while (1){
		//хэндлеры
		keysDrv_Handler();//работа с кнопкой
		// Работа с ADC
		adc_ret = ADC_Calc_Handler();
		// Работа со звуковой индикацией
		buzzer_handler();
		//E N D хэндлеры

		ms = HAL_GetTick();

		keysState=getKeyState();//получаю состояние кнопки
		adc_GetVoltage_ = adc_GetVoltage();//получение измер.напряж.

		// --- Проверка напряжения ---
		if(adc_ret == FORCE_POWER_OFF) {
			if(!lowVoltageActive) {
				lowVoltageActive = 1;
				lowVoltageStart = HAL_GetTick();
				//внести обработку пищалки.
				// первый писк сразу
				buzzer_tripleBeep();
				lowVoltageBeepTimer = HAL_GetTick();
			}
			// проверка тайм-аута //
			if(lowVoltageActive && (HAL_GetTick() - lowVoltageStart >= SHUTDOWN_DELAY)) {
				adc_ret = 0;
				count = 0;
				shutdownAndSleep();
			}

			// периодическая звуковая индикация
			if (HAL_GetTick() - lowVoltageBeepTimer >= LOW_VOLTAGE_BEEP_PERIOD) {
				buzzer_tripleBeep();
				lowVoltageBeepTimer = HAL_GetTick();
			}
			if(adc_GetVoltage_ > 9.0f ){
				// напряжение восстановилось → сброс
				lowVoltageStart = 0;
				lowVoltageActive = 0;
				lowVoltageBeepTimer = 0;

				buzzer_state = BUZZER_NONE;
				buzzer_off();
			}
		}
		if(keysState & KEY1Release_Drv){//если произошло короткое нажатие включение системы
			//button_pressed =0;
			if(test_stop == 1){
				test_stop = 0;
				adc_init();
				adc_start();
			}

			if(gl_main_stateKey == 0){
				gl_main_stateKey=1;
				count ++;
				if(count <= 1){
					//запуск двойной звуковой индикации
					buzzer_doubleBeep();
				}
				// — устанавливает пин в ЕДИНИЦУ, включение 3.3в и 12в
				HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_SET);

				//действие для двойного нажатия кнопки
				if(btnPress_time_start && (ms - btnPress_time_start) > MIN_DelayDblClck){
					if(btnPress_time_start && (ms - btnPress_time_start) < MAX_DelayDblClck){
						count = 0;
						shutdownAndSleep();
					}
				}
				btnPress_time_start=ms;
			}
		}
		else{
			if(gl_main_stateKey==1){
				gl_main_stateKey=0;
			}
		}
		//ss
	}//while (1)
}

//Включение пъезо_излучателя
void buzzer_on()
{
	HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_4);
}
//Выключение пъезо_излучателя
void buzzer_off()
{
	HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_4);
	HAL_GPIO_WritePin(GPIOA, GPIO_PIN_11, GPIO_PIN_RESET);
}
// E N D

void buzzer_doubleBeep(void) {
	buzzer_state = BUZZER_BEEP_1;
	buzzer_timer = HAL_GetTick();
	buzzer_on();
}

// Запуск тройного писка
void buzzer_tripleBeep(void) {
	buzzer_state = BUZZER_BEEP_1;
	buzzer_timer = HAL_GetTick();
	buzzer_on();
}

void buzzer_handler(void) {
	switch (buzzer_state) {
	case BUZZER_NONE:
		break;

	case BUZZER_BEEP_1:
		if (HAL_GetTick() - buzzer_timer > 100) {
			buzzer_off();
			buzzer_timer = HAL_GetTick();
			buzzer_state = BUZZER_BEEP_2;
		}
		break;

	case BUZZER_BEEP_2:
		if (HAL_GetTick() - buzzer_timer > 100) {
			buzzer_on();
			buzzer_timer = HAL_GetTick();
			buzzer_state = BUZZER_BEEP_3;
		}
		break;

	case BUZZER_BEEP_3:
		if (HAL_GetTick() - buzzer_timer > 100) {
			buzzer_off();
			buzzer_state = BUZZER_NONE;
		}
		break;

	case BUZZER_BEEP_4:
		if (HAL_GetTick() - buzzer_timer > 100) {
			buzzer_on();
			buzzer_timer = HAL_GetTick();
			buzzer_state = BUZZER_NONE; // завершаем на третьем писке
		}
		break;
	}
}

void shutdownAndSleep(){
	adc_stop();
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_RESET);
	test_stop =1;

	//Сброс флага пробуждения
	//__HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_11);
	__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);

	//Остановить SysTick, чтобы он не будил
	HAL_SuspendTick();

	//Переход в режим STOP
	HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);

	/* Configure the system clock */
	//Восстановить тактирование после пробуждения
	SystemClock_Config();

	//Включить обратно
	HAL_ResumeTick();
}

// Обработчик прерывания от кнопки (PB11 → EXTI11)
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	if (GPIO_Pin == GPIO_PIN_11)
	{
		button_pressed = 1;
	}
}

Вывод

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

• Обработку кнопок с фильтрацией дребезга, с поддержкой короткого/долгого/двойного нажатия и отпускания;

• Мониторинг напряжения через АЦП с защитой от просадок и автоматическим отключением при критическом низком уровне;

• Звуковая индикация (короткие, двойные сигналы) для информирования пользователя о событиях;

• Энергосбережение переход в режим STOP и пробуждение по прерыванию.

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

Если статья показалась Вам интересной, буду рад выпустить для Вас еще множество статей исследований по всевозможным видам устройств, так что, если не хотите их пропустить – буду благодарен за подписку на мой ТГ-канал: https://t.me/ChipCraft.