Радио Модуль Ам 433Мгц Без Шумов На Выходе

[artos5]

Добрый вечер уважаемые! Существуют ли модули в которых отсутствуют помехи на выходе при отсутствии модуляции?

Если да - пожалуйста киньте названия таких или ссылки для ознакомления, буду весьма признателен!

PS: Надо для специального контроллера захвата кодов с ДУ.

С ув. Артем

Изменено 29 октября, 2013 пользователем artos5

[Реклама]

Реклама: ООО ТД Промэлектроника, ИНН: 6659197470, Тел: 8 (800) 1000-321

[Геннадий]

RXQ2-433.

[Реклама]

20% скидка на весь каталог электронных компонентов в ТМ Электроникс!

Акция "Лето ближе - цены ниже", успей сделать выгодные покупки!

Плюс весь апрель действует скидка 10% по промокоду APREL24 + 15% кэшбэк и бесплатная доставка!

Перейти на страницу акции

Реклама: ООО ТМ ЭЛЕКТРОНИКС, ИНН: 7806548420, info@tmelectronics.ru, +7(812)4094849

[artos5]

"Спасибище" огромное! Они точно не генерят помех когда команды не посылаешь?!

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

Ай, не то.... надо модуль АМ и только в режиме приема. ((

Изменено 29 октября, 2013 пользователем artos5

[Реклама]

Выбираем схему BMS для корректной работы литий-железофосфатных (LiFePO4) аккумуляторов

 Обязательным условием долгой и стабильной работы Li-FePO4-аккумуляторов, в том числе и производства EVE Energy, является применение специализированных BMS-микросхем. Литий-железофосфатные АКБ отличаются такими характеристиками, как высокая многократность циклов заряда-разряда, безопасность, возможность быстрой зарядки, устойчивость к буферному режиму работы и приемлемая стоимость. Но для этих АКБ, также как и для других, очень важен контроль процесса заряда и разряда, а специализированных микросхем для этого вида аккумуляторов не так много. Инженеры КОМПЭЛ подготовили список имеющихся микросхем и возможных решений от разных производителей. Подробнее>>

Реклама: АО КОМПЭЛ, ИНН: 7713005406, ОГРН: 1027700032161

[Геннадий]

Это приемо-передатчики. Никаких шумов, чистый уровень. Мало того, имеют программируемый адрес и возможность передавать адресованные пакеты (остальные приемники даже не пикнут). Аппаратный контроль ошибки пакета.

[artos5]

Я уже увидел, спасибо! Хорошие "трансиверы" . Но у меня спец задача: Надо слушать эфир , и мычать когда что то пёрднет в зоне действия. То есть когда появится модуляция (сигнал с брелка , любого с соответствующей частотой). Модуляция - амплитудная. То есть надо модуль с аппаратным блоком "MUTE" который отрезает шум при отсутствии модуляции.

[Геннадий]

Тогда смотри в сторону схемотехники китайских радиозвонков.

[artos5]

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

[artos5]

Оживлю тему.

Пробовал такие модули:

http://www.terraelectronica.ru/pdf/TELC/RR8-433.pdf

http://www.olimex.cl/pdf/Wireless/Telecontrolli/rr10.pdf

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

[Mahno]

Есть в метеостанциях модули,на выходе компаратор,иногда проскакивают щелчки,гдя взять ХЗ у меня пара валяется.Покрути приёмопередатчик от сигналки типа шериф-давинчи,те что с обратной связью,там чистая цифра на выходе.

[artos5]

Купил бы у Тебя , если не дают шума на выходе. Продашь?

[Mahno]

Шума нет точно,так отдельные щелчки проскакивают и команды от местных устройств.Пересылка напрягает

[artos5]

Ничего напряжного... высылаешь Новой почтой - а я тут подхватываю. Доставку оплачу.

Можешь Укр почтой , дольше и дешевле для меня

Частота 433 ? Модуляция АМ? Светодиод когда вешаешь - не мигает?

А может еще есть на 315 мгц ? Возьму 1 такой а один на 433

Изменено 31 октября, 2013 пользователем artos5

[Mahno]

Сверхгенеративный каскад,дальше компаратор на ОУ,только на 433,можешь перестроить.Завтра давай в личке.

[artos5]

Проверь пожалуйста , светодиод мигает хаотично при отсутствии несущей.

В личке спишемся

[Геннадий]

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

[artos5]

Попробую Мне дальность большая не нужна! Мне нужно отсутствие помех на выходе...

[artos5]

Мне тут иногда пишут по поводу решения этой задачи. Поэтому Апну тему:

Научился я работать с обычными приемниками . Нужно просто грамотно подойти к решению задачи. Микроконтроллер должен определять наличие старт последовательности (если попали в интервал) . После обрабатывать битовый поток (если попадаем в интервал). Моя реализация очень хорошо работает , и принимает команды на довольно большой дальности. Ложных срабатываний нету, и плохого обучения команд. Все обработки команд и их прием работает четко! 

Пример фиксации старт последовательности (алгоритм работает с любыми пультами на 433мГц ) :

 switch(state)
 {
 case 0:
	 timer_cnt=TIMER->CNT=0;
	 DATA_RX[0]=0;

	if((RX_IN)==0)// считаем первый захват . Предположительно это стартовый сигнал низкого уровня
	{state=1;}
	break;
 case 1:
	 // если насчитали подходящее число - фиксируем старт условие
	 if(RX_IN)
	 {
		if(TIMER->CNT>2000 || timer_cnt) // если больше 2мс. то словили старт условие
		{
			timer_cnt=TIMER->CNT=0;
			state=2;
			code=1;
		}
		else
		{
			code=2;
			state=0; // если не попали в интервал - сброс
		}
	 }
	 break;
 case 2:
     ...
       ...

Пример обработки битового потока (работает на любых пультах 433мГц) :

 case 2:
	    if((RX_IN)==0)
		 {
			if(TIMER->CNT>90 && TIMER->CNT<1800 && timer_cnt==0) // ограничиваем диапазон 90мкс - 1800мкс
			{
				BIT_TIME[0] = TIMER->CNT;
				timer_cnt=TIMER->CNT=0;
				state=3;
				code=3;
			}
			else
			{
				//BIT_TIME[5]=state;
				//BIT_TIME[6]=TIMER->CNT;

				code=4;
				state=0; // если не попали в интервал - сброс
			}
		 }
	 break;
 case 3:
	 if(RX_IN)
	 		 {
	 			if(TIMER->CNT>90 && TIMER->CNT<1800 && timer_cnt==0) // ограничиваем диапазон 90мкс - 1800мкс
	 			{
	 				BIT_TIME[1] = TIMER->CNT;
	 				if(BIT_TIME[0] > (BIT_TIME[1]+BIT_TIME[1])) DATA_RX[0] |=(1<<25);
	 				DATA_RX[0]>>=1;
	 				timer_cnt=TIMER->CNT=0;
	 				state=4;
	 				code=5;
	 			}
	 			else
	 			{
	 				//BIT_TIME[5]=state;
	 				//BIT_TIME[6]=TIMER->CNT;
	 				timer_cnt=TIMER->CNT=0;
	 				code=6;
	 				state=0; // если не попали в интервал - сброс
	 			}
	 		 }
	 break;
 default:

	 if(TIMER->CNT>90 && TIMER->CNT<1800 && timer_cnt==0) // ограничиваем диапазон 90мкс - 1800мкс
	    	 	 			{

	    	        	        if((RX_IN)==0)
	    	        	        {
	    	        	         BIT_TIME[2] = TIMER->CNT;
	    	        	     	 timer_cnt=TIMER->CNT=0;
	    	        	     	 state++;
	    	        	     	}
	    	        	        else
	    	 	 				{
	    	 	 				 if(TIMER->CNT > (BIT_TIME[2]+BIT_TIME[2])) DATA_RX[0] |=(1<<25);
	    	 	 				 DATA_RX[0]>>=1;
	    	 	 				 timer_cnt=TIMER->CNT=0;
	    	 	 				 state++;
	    	 	 				code++;
	    	 	 				}

	    	 	 				if(state>48) // если набрали нужное количество бит
	    	 	 				{
	    	 	 					DATA_RX[1] = DATA_RX[0];
	    	 	 					BIT_TIME[3] = BIT_TIME[0];
	    	 	 					BIT_TIME[4] = BIT_TIME[1];
	    	 	 					code=250;
	    	 	 				}

	    	 	 				if(state>35)
	    	 	 				{
	    	 	 				 if(RX_IN){LED_ON;}
	    	 	 				 else{ LED_OFF;}
	    	 	 				}
	    	 	 			}
	    	 	 			else
	    	 	 			{
	    	 	 				BIT_TIME[5]=state;
	    	 	 				BIT_TIME[6]=TIMER->CNT;
	    	 	 				state=0; // если не попали в интервал - сброс
	    	 	 				code1++;

	    	 	 			}
	    	         if(state>48) // если набрали нужное количество бит
	    	            {
	    	        	 DATA_RX[1] = DATA_RX[0];
	    	        	 BIT_TIME[3] = BIT_TIME[0];
	    	        	 BIT_TIME[4] = BIT_TIME[1];
	    	        	 code++;
	    	            }

	 break;
 }

Универсальный протокол обработки команд с ДУ . С функцией обучения пультов.

 

Полный работчий код для микроконтроллера STM32F030F4P6:
 

Спойлер

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2019 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
//#define STANDART==0 // 0 стандартная прошивка , если закомментировано - то не стандартная
#define STANDART 2 // 1 для домофона , без вызова
                 // 2 для домофона с вызовом
                 // 3 для применения к обычным весам

#define PWM1 TIM3->CCR1
#define PWM2 TIM3->CCR2
#define PWM3 TIM3->CCR4
#define PWM4 TIM1->CCR2

#define TIMER TIM16    //задаем таймер, используемый для формирования отсчетов

#define LED_ON GPIOA->ODR|=(1<<1)
#define LED_OFF GPIOA->ODR&=~(1<<1)
#define RX_IN GPIOA->IDR&(1<<4)
#define USER_DATA 48
#define CONFIG GPIOA->IDR&(1<<0)

uint16_t timer_cnt=0;
uint8_t cmd=0, code=0, config=0;

#if  STANDART==0

#elif STANDART==1
#elif STANDART==2
#else
uint8_t flags_=0, flg_pr=0;
#endif

//uint8_t PWM[4], revers=0;
 uint32_t DATA_RX[2];
 uint16_t BIT_TIME[7];
/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim3;
TIM_HandleTypeDef htim14;
TIM_HandleTypeDef htim16;

UART_HandleTypeDef huart1;

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_TIM14_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_TIM1_Init(void);
static void MX_TIM3_Init(void);
static void MX_TIM16_Init(void);
/* USER CODE BEGIN PFP */

extern uint8_t rx_buffer0[];
extern uint8_t rx_wr_index0;
char tx_buffer0[64];
 uint8_t state=0, code1=0;
 uint32_t data_ir_eep0[USER_DATA];

 uint8_t User_PWM1[22], flg=1, reset=1, timer_reset=0, Programm=0;
 uint16_t  timer=0;

 //uint8_t byte_block_cnt=0;
/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void usart1_tx(char *str)
{

		int x=0;
		str+=0;
	  while(str[x])
	  {
		 x++;
		}

	   HAL_UART_Transmit(&huart1,(uint8_t*)str,x, 1000);
}

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{

 switch(state)
 {
 case 0:
	 timer_cnt=TIMER->CNT=0;
	 DATA_RX[0]=0;

	if((RX_IN)==0)// считаем первый захват . Предположительно это стартовый сигнал низкого уровня
	{state=1;}
	break;
 case 1:
	 // если насчитали подходящее число - фиксируем старт условие
	 if(RX_IN)
	 {
		if(TIMER->CNT>2000 || timer_cnt)
		{
			timer_cnt=TIMER->CNT=0;
			state=2;
			code=1;
		}
		else
		{
			//BIT_TIME[5]=state;
			//BIT_TIME[6]=TIMER->CNT;

			code=2;
			state=0; // если не попали в интервал - сброс
		}
	 }
	 break;
 case 2:
	    if((RX_IN)==0)
		 {
			if(TIMER->CNT>90 && TIMER->CNT<1800 && timer_cnt==0) // ограничиваем диапазон 90мкс - 1800мкс
			{
				BIT_TIME[0] = TIMER->CNT;
				timer_cnt=TIMER->CNT=0;
				state=3;
				code=3;
			}
			else
			{
				//BIT_TIME[5]=state;
				//BIT_TIME[6]=TIMER->CNT;

				code=4;
				state=0; // если не попали в интервал - сброс
			}
		 }
	 break;
 case 3:
	 if(RX_IN)
	 		 {
	 			if(TIMER->CNT>90 && TIMER->CNT<1800 && timer_cnt==0) // ограничиваем диапазон 90мкс - 1800мкс
	 			{
	 				BIT_TIME[1] = TIMER->CNT;
	 				if(BIT_TIME[0] > (BIT_TIME[1]+BIT_TIME[1])) DATA_RX[0] |=(1<<25);
	 				DATA_RX[0]>>=1;
	 				timer_cnt=TIMER->CNT=0;
	 				state=4;
	 				code=5;
	 			}
	 			else
	 			{
	 				//BIT_TIME[5]=state;
	 				//BIT_TIME[6]=TIMER->CNT;
	 				timer_cnt=TIMER->CNT=0;
	 				code=6;
	 				state=0; // если не попали в интервал - сброс
	 			}
	 		 }
	 break;
 default:

	 if(TIMER->CNT>90 && TIMER->CNT<1800 && timer_cnt==0) // ограничиваем диапазон 90мкс - 1800мкс
	    	 	 			{

	    	        	        if((RX_IN)==0)
	    	        	        {
	    	        	         BIT_TIME[2] = TIMER->CNT;
	    	        	     	 timer_cnt=TIMER->CNT=0;
	    	        	     	 state++;
	    	        	     	}
	    	        	        else
	    	 	 				{
	    	 	 				 if(TIMER->CNT > (BIT_TIME[2]+BIT_TIME[2])) DATA_RX[0] |=(1<<25);
	    	 	 				 DATA_RX[0]>>=1;
	    	 	 				 timer_cnt=TIMER->CNT=0;
	    	 	 				 state++;
	    	 	 				code++;
	    	 	 				}

	    	 	 				if(state>48) // если набрали нужное количество бит
	    	 	 				{
	    	 	 					DATA_RX[1] = DATA_RX[0];
	    	 	 					BIT_TIME[3] = BIT_TIME[0];
	    	 	 					BIT_TIME[4] = BIT_TIME[1];
	    	 	 					code=250;
	    	 	 				}

	    	 	 				if(state>35)
	    	 	 				{
	    	 	 				 if(RX_IN){LED_ON;}
	    	 	 				 else{ LED_OFF;}
	    	 	 				}
	    	 	 			}
	    	 	 			else
	    	 	 			{
	    	 	 				BIT_TIME[5]=state;
	    	 	 				BIT_TIME[6]=TIMER->CNT;
	    	 	 				state=0; // если не попали в интервал - сброс
	    	 	 				code1++;

	    	 	 			}
	    	         if(state>48) // если набрали нужное количество бит
	    	            {
	    	        	 DATA_RX[1] = DATA_RX[0];
	    	        	 BIT_TIME[3] = BIT_TIME[0];
	    	        	 BIT_TIME[4] = BIT_TIME[1];
	    	        	 code++;
	    	            }

	 break;
 }


}

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim16)
{
	timer_cnt+=1;
}

#define USE_FLASH_STM
#ifdef USE_FLASH_STM
//=== чтение и запись с/в флешь ===//
//#define FLASH_KEY1 ((uint32_t)0x45670123)
//#define FLASH_KEY2 ((uint32_t)0xCDEF89AB)
void flash_unlock(void) {
  FLASH->KEYR = FLASH_KEY1;
  FLASH->KEYR = FLASH_KEY2;
  //FLASH_Unlock();
}

void flash_lock() {
  FLASH->CR |= FLASH_CR_LOCK;
}

uint32_t flash_read(uint32_t address) {
  return (*(__IO uint32_t*) address);
}

//Функция возврщает true когда можно стирать или писать память.
uint8_t flash_ready(void) {
  return !(FLASH->SR & FLASH_SR_BSY);
}

//Функция стирает ВСЕ страницы. При её вызове прошивка самоуничтожается
void flash_erase_all_pages(void) {
  FLASH->CR |= FLASH_CR_MER; //Устанавливаем бит стирания ВСЕХ страниц
  FLASH->CR |= FLASH_CR_STRT; //Начать стирание
  while(!flash_ready()) // Ожидание готовности.. Хотя оно уже наверное ни к чему здесь...
    ;
  FLASH->CR &= FLASH_CR_MER;
}

//Функция стирает одну страницу. В качестве адреса можно использовать любой
//принадлежащий диапазону адресов той странице которую нужно очистить.
void flash_erase_page(uint32_t address) {
  FLASH->CR|= FLASH_CR_PER; //Устанавливаем бит стирания одной страницы
  FLASH->AR = address; // Задаем её адрес
  FLASH->CR|= FLASH_CR_STRT; // Запускаем стирание
  while(!flash_ready())
    ;  //Ждем пока страница сотрется.
  FLASH->CR&= ~FLASH_CR_PER; //Сбрасываем бит обратно
}

void flash_write(uint32_t address,uint32_t data) {
  FLASH->CR |= FLASH_CR_PG; //Разрешаем программирование флеша
  while(!flash_ready()) //Ожидаем готовности флеша к записи
    ;
  *(__IO uint16_t*)address = (uint16_t)data; //Пишем младшие 2 байта
  while(!flash_ready())
    ;
  address+=2;
  data>>=16;
  *(__IO uint16_t*)address = (uint16_t)data; //Пишем старшие 2 байта
  while(!flash_ready())
    ;
  FLASH->CR &= ~(FLASH_CR_PG); //Запрещаем программирование флеша
}


void save_cmd_eeprom(uint32_t p)
{
	uint32_t st_address = FLASH_BASE + p * 1024;

	flash_unlock();
	flash_erase_page(st_address);
	//flash_erase_page(st_address+1024);


	     usart1_tx("The page has been erased.");
	     usart1_tx("\r\n");

		for(uint8_t byte_block_cnt=0; byte_block_cnt<USER_DATA; byte_block_cnt++)
		{

		 flash_write((st_address+byte_block_cnt*4), data_ir_eep0[byte_block_cnt]);

		}
		//flash_write((st_address+1024), data_eep0);

		usart1_tx("The page has been writed.");
		usart1_tx("\r\n");
}

void load_cmd_eeprom(uint32_t p)
{
	uint32_t st_address = FLASH_BASE + p * 1024;
	usart1_tx("Read data!\r\n");
	for(uint8_t byte_block_cnt=0; byte_block_cnt<USER_DATA; byte_block_cnt++)
	{
	 data_ir_eep0[byte_block_cnt] = flash_read(st_address+byte_block_cnt*4);
	}

	usart1_tx("Read data Done!\r\n");
}

// === конец функций === //
#endif
/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */
  

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM14_Init();
  MX_USART1_UART_Init();
  MX_TIM1_Init();
  MX_TIM3_Init();
  MX_TIM16_Init();
  /* USER CODE BEGIN 2 */

  NVIC_EnableIRQ(USART1_IRQn);
  NVIC_SetPriority(USART1_IRQn, 1);
  USART1->CR1 |= USART_CR1_RXNEIE;

#define NDEBUG

#ifdef NDEBUG
//#warning "FLASH Read OUT Protection ON. DEBUG is OFF."

// Проверяем установлена или сброшена защита
     FLASH_OBProgramInitTypeDef Optbyte;

     __disable_irq();
     HAL_FLASHEx_OBGetConfig(&Optbyte);   	// read out RDPLvL
     if(Optbyte.RDPLevel == OB_RDP_LEVEL_0){   //
    	 usart1_tx("Flash read Lock!...\r\n");
    	 //HAL_Delay(500);
       Optbyte.OptionType=OPTIONBYTE_RDP; 	// select RDP optionbyte
       Optbyte.RDPLevel=OB_RDP_LEVEL_1;   	// select RDP level 1
       HAL_FLASH_Unlock();                	// unlock Flash
       HAL_FLASH_OB_Unlock();             	// unlock Optionbytes
       HAL_FLASHEx_OBProgram(&Optbyte);   	// set RDP=1
       HAL_FLASH_OB_Launch();             	// write OB to Flash and reset
       HAL_FLASH_OB_Lock();                // Lock Optionbytes
       HAL_FLASH_Lock();                   // lock Flash

     }
     __enable_irq();

#endif

  HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_2);
  HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
  HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_2);
  HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_4);
  LED_ON;
  HAL_Delay(500);
  LED_OFF;
  HAL_TIM_Base_Start(&htim16);

  /*
  data_ir_eep0[0]=0xAAAABBBB;
  data_ir_eep0[2]=0xCCCCCCCC;
  data_ir_eep0[4]=0x11112222;
  data_ir_eep0[5]=0xDDDDDDDD;
  save_cmd_eeprom(14);*/
  load_cmd_eeprom(14);
          usart1_tx("\r\ncmd Data!\r\n");
          for(uint8_t x=0; x<8; x++)
          {
        	  sprintf(tx_buffer0,"Data %lu\r\n", data_ir_eep0[x*3]);
        	  usart1_tx(tx_buffer0);
        	  sprintf(tx_buffer0,"Bit0 %d\r\n", (uint16_t)(data_ir_eep0[x*3+1]));
        	  usart1_tx(tx_buffer0);
        	  sprintf(tx_buffer0,"Bit1 %d\r\n\r\n", (uint16_t)(data_ir_eep0[x*3+2]));
        	  usart1_tx(tx_buffer0);
          }
          for(uint8_t x=24; x<44; x++)
                    {
        	          User_PWM1[x-24] = (uint8_t)data_ir_eep0[x];
                  	  sprintf(tx_buffer0,"User PWM %d\r\n", User_PWM1[x-24]);
                  	  usart1_tx(tx_buffer0);

                    }

if((CONFIG)==0)
{
	 for(uint8_t x=24; x<45; x++)
	 		           {
	 		        	data_ir_eep0[x] = User_PWM1[x-24] = 0;
	 		           }
	  User_PWM1[20] = 0;
	  User_PWM1[21] = 0;

   usart1_tx("Reset data User program OK!......");
   save_cmd_eeprom(14);
}


#if STANDART==0
if(data_ir_eep0[44]>1000)
{
	while(1)
	  {
		LED_ON;
	  }
}
#elif STANDART==1
if(data_ir_eep0[44]>2000)
{
	while(1)
	  {
		LED_ON;
	  }
}
#elif STANDART==2

#else
if(data_ir_eep0[44]>800)
{
	while(1)
	  {
		LED_ON;
	  }
}
#endif

data_ir_eep0[44]++;

sprintf(tx_buffer0,"User cnt %d\r\n", (uint16_t) data_ir_eep0[44]);
                 	  usart1_tx(tx_buffer0);
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {

	 if((CONFIG)==0) // программирование команд ДУ
	 {
		HAL_Delay(1000);
		if((CONFIG)==0)
			 {
			   if(config==0)usart1_tx("\r\nConfig mode ON!\r\n");
			   else { usart1_tx("\r\nConfig mode OFF!\r\n");
			   save_cmd_eeprom(14);
			   }

			   if(++config>1)config=0;// else config=1;

			 }
	 }

	 if(config==0)
	 {
		 if(DATA_RX[1])
		 {
			 HAL_Delay(150);
		  cmd=0;
		  for(uint8_t x=0; x<8; x++)
		  {
			  //cmd&=~(1<<x);
			 if(data_ir_eep0[x*3] == DATA_RX[1])
			 {
			 // if(data_ir_eep0[x*3+1] > (BIT_TIME[4]-70) && data_ir_eep0[x*3+1] < (BIT_TIME[4]+70))
			 // {
			 //  if(data_ir_eep0[x*3+2] > (BIT_TIME[3]-70) && data_ir_eep0[x*3+2] < (BIT_TIME[3]+70))
			 //  {
                cmd|=(1<<x);
                sprintf(tx_buffer0,"Press key: %d\r\n", (x+1));
                		  usart1_tx(tx_buffer0);

			 //  }
			 // }
			 }
		  }


         if(cmd==0)
        {
		  usart1_tx("\r\nTest RX Data!\r\n");
		  sprintf(tx_buffer0,"code: %d state: %d\r\n", code, state);
		  usart1_tx(tx_buffer0);
		  sprintf(tx_buffer0,"bit0 %d stt:%d bit_err:%d\r\n", BIT_TIME[3], BIT_TIME[5], BIT_TIME[6]);
		  usart1_tx(tx_buffer0);
		  sprintf(tx_buffer0,"bit1 %d code1 %d\r\n", BIT_TIME[4], code1);
		  usart1_tx(tx_buffer0);
		  sprintf(tx_buffer0,"%lu \r\n", DATA_RX[1]);
		  usart1_tx(tx_buffer0);

        }
         else
         {
#if STANDART==0
        	 if(cmd&(1<<0)) // - веса 1
        	   {

        	     if(User_PWM1[Programm*5])User_PWM1[Programm*5]--;
        	     User_PWM1[Programm*5+1] = User_PWM1[Programm*5];
        	     //if(User_PWM1[Programm*5+1])User_PWM1[Programm*5+1]--;
	         		if(User_PWM1[Programm*5]==0)
	         		{
	           		 if(User_PWM1[Programm*5+2]<255)User_PWM1[Programm*5+2]++;
	           		 User_PWM1[Programm*5+3] = User_PWM1[Programm*5+2];
	           		 //if(User_PWM1[Programm*5+3]<255)User_PWM1[Programm*5+3]++;
	         		}


        	   }
        	 if(cmd&(1<<1)) // + веса 1
        	   {

                 if(User_PWM1[Programm*5+2] == 0)
                 {
        		     if(User_PWM1[Programm*5]<255)User_PWM1[Programm*5]++;
        		     User_PWM1[Programm*5+1] = User_PWM1[Programm*5];
        		     //if(User_PWM1[Programm*5+1]<255)User_PWM1[Programm*5+1]++;
                 }

            	     if(User_PWM1[Programm*5+2])User_PWM1[Programm*5+2]--;
            	     User_PWM1[Programm*5+3] = User_PWM1[Programm*5+2];

        	   }
        	 if(cmd&(1<<2)) // программа 1
        	   {
                 Programm=0;
        	   }
        	 if(cmd&(1<<3)) // программа 2
        	   {
        		 Programm=1;
        	   }
        	 if(cmd&(1<<4)) // программа 3
        	   {
        		 Programm=2;
        	   }
        	 if(cmd&(1<<5)) // программа 4
        	   {
        		 Programm=3;
        	   }



        	 if(cmd&(1<<6)) // реверс веса
        	 {
        	   if(User_PWM1[Programm*5+4])User_PWM1[Programm*5+4]=0; else User_PWM1[Programm*5+4]=1;
        	   sprintf(tx_buffer0,"revers: %d\r\n", (uint8_t) User_PWM1[Programm*5+4]);
        	   usart1_tx(tx_buffer0);

        		 timer=flg=0;

        		 if(++timer_reset>10)
        		 {
        			 for(uint8_t x=24; x<44; x++)
        			 		           {
        			 		        	data_ir_eep0[x] = User_PWM1[x-24] = 0;
        			 		            //sprintf(tx_buffer0,"User PWM save %-2d %d\r\n",x-24, (uint8_t)data_ir_eep0[x]);

        			 		           }
        			                   usart1_tx("Reset data User program OK!");
        			                   data_ir_eep0[44]++;              // incr demo
        			 		          save_cmd_eeprom(14);
        			 timer_reset=0;
        		 }
        	 }


        	 if(cmd&(1<<7)) // сброс воздействия
        	 {
        		 PWM1=0;
        		 PWM2=0;
        		 PWM3=0;
        		 PWM4=0;
        		 reset=1;
        		 usart1_tx("reset ok!\r\n");
        	 }

         }

		  DATA_RX[1]=0;

		 }


		 LED_OFF;

  if(reset==0)
  {
	  uint16_t PWM_Buff[4];

	  if(User_PWM1[Programm*5]<3) PWM_Buff[0] = User_PWM1[Programm*5];
	  else
		  {
		   PWM_Buff[0] = User_PWM1[Programm*5];
		   PWM_Buff[0] *=16;
		  }
	  if(User_PWM1[Programm*5+1]<3) PWM_Buff[1] = User_PWM1[Programm*5+1];
	  else
	  {
		   PWM_Buff[1] = User_PWM1[Programm*5+1];
		   PWM_Buff[1] *=16;
	  }
	  if(User_PWM1[Programm*5+2]<3) PWM_Buff[2] = User_PWM1[Programm*5+2];
	  else
	  {
		   PWM_Buff[2] = User_PWM1[Programm*5+2];
		   PWM_Buff[2] *=16;
	  }
	  if(User_PWM1[Programm*5+3]<3) PWM_Buff[3] = User_PWM1[Programm*5+3];
	  else
	  {
		   PWM_Buff[3] = User_PWM1[Programm*5+3];
		   PWM_Buff[3] *=16;
	  }

		 if(User_PWM1[Programm*5+4])
		 {
			PWM1 = PWM_Buff[0];
			PWM2 = PWM_Buff[1];
			PWM3 = PWM_Buff[2];
			PWM4 = PWM_Buff[3];
		 }
		 else
		 {
			 PWM1 = PWM_Buff[2];
			 PWM2 = PWM_Buff[3];
			 PWM3 = PWM_Buff[0];
			 PWM4 = PWM_Buff[1];
		 }
  }
else
{
	 PWM1=0;
	 PWM2=0;
	 PWM3=0;
	 PWM4=0;
}

	 if(cmd&0b00111111) // отображаем значение ШИМ
	 {
 	   sprintf(tx_buffer0,"PWM1:%-3d PWM2:%-3d PWM3:%-3d PWM4:%-3d\r\n", User_PWM1[Programm*5],User_PWM1[Programm*5+1],User_PWM1[Programm*5+2],User_PWM1[Programm*5+3]);
 	   usart1_tx(tx_buffer0);
 	   reset=0;
 	   timer=flg=0;
	 }
	 if(cmd&0b01000000) HAL_Delay(1000);
	 cmd=0;

	 if(flg==0)
	 {
		 HAL_Delay(25);
		 if(++timer>800)
		 {

	          for(uint8_t x=24; x<44; x++)
	           {
	        	data_ir_eep0[x] = User_PWM1[x-24];
	            sprintf(tx_buffer0,"User PWM save %-2d %d\r\n",x-24, (uint8_t)data_ir_eep0[x]);
	            usart1_tx(tx_buffer0);
	           }
	          save_cmd_eeprom(14);
	          timer=0;
	          flg=1;
		 }
		    if(timer>100 && timer<102)
		    {
		     timer_reset=0;
		     usart1_tx("timer_reset_data = 0\r\n");
			}
	 }

#elif STANDART==1 // код для управления открытием замка видеодомофона



    	 if(cmd) // программа 1
    	   {
             //Programm=0;
    		 usart1_tx("DOOR=OPEN;\r\n");
             PWM2=4081;
             HAL_Delay(2000);
             PWM3=4081;
             HAL_Delay(2000);
             PWM2=PWM3=0;
    	   }


     }

	  DATA_RX[1]=0;

	 }


	 LED_OFF;


 PWM1=0;
 PWM2=0;
 PWM3=0;
 PWM4=0;


/* if(cmd&0b00111111) // отображаем значение ШИМ
 {
	   sprintf(tx_buffer0,"PWM1:%-3d PWM2:%-3d PWM3:%-3d PWM4:%-3d\r\n", User_PWM1[Programm*5],User_PWM1[Programm*5+1],User_PWM1[Programm*5+2],User_PWM1[Programm*5+3]);
	   usart1_tx(tx_buffer0);
	   reset=0;
	   timer=flg=0;
 }*/
// if(cmd&0b01000000) HAL_Delay(1000);
 cmd=0;

#elif STANDART==2 // код для управления открытием замка видеодомофона



    	 if(cmd) // программа 1
    	   {
             //Programm=0;
    		 usart1_tx("DOOR=OPEN;\r\n");
             PWM3=4081;
             HAL_Delay(200);
             PWM3=0;
             HAL_Delay(2000);
             PWM1=4081;
             HAL_Delay(2000);
             PWM1=PWM3=0;
    	   }


     }

	  DATA_RX[1]=0;

	 }


	 LED_OFF;


 PWM1=0;
 PWM2=0;
 PWM3=0;
 PWM4=0;


/* if(cmd&0b00111111) // отображаем значение ШИМ
 {
	   sprintf(tx_buffer0,"PWM1:%-3d PWM2:%-3d PWM3:%-3d PWM4:%-3d\r\n", User_PWM1[Programm*5],User_PWM1[Programm*5+1],User_PWM1[Programm*5+2],User_PWM1[Programm*5+3]);
	   usart1_tx(tx_buffer0);
	   reset=0;
	   timer=flg=0;
 }*/
// if(cmd&0b01000000) HAL_Delay(1000);
 cmd=0;


#else // код обработки для весов напольных 
//static uint8_t flags_=0
      		 if(cmd&(1<<0)) // - веса 1
      	 	   {
      		flags_=1;
      	   if(User_PWM1[20])User_PWM1[20]--;

      		         		if(User_PWM1[20]==0)
      		         		{
      		           		 if(User_PWM1[21]<255)User_PWM1[21]++;
      		         		}
      		         		reset=0;
 	   }
 	 if(cmd&(1<<1)) // сброс воздействия
 	   {
 		flags_=0;

		 PWM1=0;
		 PWM2=0;
		 PWM3=0;
		 PWM4=0;
		 User_PWM1[20]=0;
		 User_PWM1[21]=0;
		 reset=1;
		 usart1_tx("reset ok!\r\n");

 	   }
 	 if(cmd&(1<<2)) // программа 1 10%
 	   {
         if(flg_pr&0x01){ flg_pr&=~0x01; } else { flg_pr |=0x01; Programm=0; usart1_tx("program=0");}
         reset=0;

 	   }
 	 if(cmd&(1<<3)) // программа 2 20%
 	   {
 		flg_pr&=0b00000010;
 		if(flg_pr&0x02){flg_pr&=~0x02; } else { flg_pr |=0x02; Programm=1; usart1_tx("program=1");}
 		reset=0;

 	   }
 	 if(cmd&(1<<4)) // программа 3 30%
 	   {
 		if(flg_pr&0x04){flg_pr&=~0x04; } else { flg_pr |=0x04; Programm=2; usart1_tx("program=2");}
 		reset=0;

 	   }
 	 if(cmd&(1<<5)) // программа 4
 	   {
 		flg_pr&=0b00001000;
 		if(flg_pr&0x08){flg_pr&=~0x08; } else { flg_pr |=0x08; Programm=3; usart1_tx("program=3");}
 		reset=0;

 	   }



 	 if(cmd&(1<<6)) // - веса предустановки
 	 {

 		 if(User_PWM1[Programm*5])User_PWM1[Programm*5]--;
 		        	     User_PWM1[Programm*5+1] = User_PWM1[Programm*5];
 		        	     //if(User_PWM1[Programm*5+1])User_PWM1[Programm*5+1]--;
 			         		if(User_PWM1[Programm*5]==0)
 			         		{
 			           		 if(User_PWM1[Programm*5+2]<255)User_PWM1[Programm*5+2]++;
 			           		 User_PWM1[Programm*5+3] = User_PWM1[Programm*5+2];
 			           		 //if(User_PWM1[Programm*5+3]<255)User_PWM1[Programm*5+3]++;
 			         		}
 			         		reset=0;
 	/*	 if(++timer_reset>10)
 		 {
 			 for(uint8_t x=24; x<44; x++)
 			 		           {
 			 		        	data_ir_eep0[x] = User_PWM1[x-24] = 0;
 			 		            //sprintf(tx_buffer0,"User PWM save %-2d %d\r\n",x-24, (uint8_t)data_ir_eep0[x]);

 			 		           }
 			                   usart1_tx("Reset data User program OK!");
 			 		          save_cmd_eeprom(14);
 			 timer_reset=0;
 		 }*/
 	 }


 	 if(cmd&(1<<7)) // + веса предустановки
 	 {
 		 if(User_PWM1[Programm*5+2] == 0)
 		                 {
 		        		     if(User_PWM1[Programm*5]<255)User_PWM1[Programm*5]++;
 		        		     User_PWM1[Programm*5+1] = User_PWM1[Programm*5];
 		        		     //if(User_PWM1[Programm*5+1]<255)User_PWM1[Programm*5+1]++;
 		                 }

 		            	     if(User_PWM1[Programm*5+2])User_PWM1[Programm*5+2]--;
 		            	     User_PWM1[Programm*5+3] = User_PWM1[Programm*5+2];
 		            	    reset=0;
 	 }

 	/* if(cmd&0b11111100) // отображаем значение ШИМ
 	 {
     	   sprintf(tx_buffer0,"PWM1:%-3d PWM2:%-3d PWM3:%-3d PWM4:%-3d\r\n", User_PWM1[Programm*5],User_PWM1[Programm*5+1],User_PWM1[Programm*5+2],User_PWM1[Programm*5+3]);
     	   usart1_tx(tx_buffer0);
     	   reset=0;
     	   timer=flg=0;
 	 }*/


  }

	  DATA_RX[1]=0;

	 }


	 LED_OFF;

if(reset==0)
{
	if(flags_==0)
	{
	  User_PWM1[20] = 0;
	  User_PWM1[21] = 0;
      if(flg_pr&0x01)
     {
	  User_PWM1[20] += User_PWM1[0];
	  User_PWM1[21] += User_PWM1[2];
     }
      if(flg_pr&0x02)
     {
	  User_PWM1[20] += User_PWM1[5];
	  User_PWM1[21] += User_PWM1[7];
     }
      if(flg_pr&0x04)
     {
	  User_PWM1[20] += User_PWM1[10];
	  User_PWM1[21] += User_PWM1[12];
     }
      if(flg_pr&0x08)
     {
	  User_PWM1[20] += User_PWM1[15];
	  User_PWM1[21] += User_PWM1[17];
     }
	}
	else
	{
	 if(flg_pr){flg_pr=0;	User_PWM1[20]=User_PWM1[21]=0;}
	}

	 uint16_t PWM1_buff[2];
	 PWM1_buff[0] = User_PWM1[20];
	 PWM1_buff[1] = User_PWM1[21];


     if(User_PWM1[Programm*5+4])
	 {
    	 if((User_PWM1[20]<30 && User_PWM1[21]<30) || flags_==1)
    	 {
		  PWM1 = PWM1_buff[0];
		  PWM2 = PWM1_buff[0];
		  PWM3 = PWM1_buff[1];
		  PWM4 = PWM1_buff[1];
    	 }
    	 else
    	 {
   		  PWM1 = PWM1_buff[0]*16;
   		  PWM2 = PWM1_buff[0]*16;
   		  PWM3 = PWM1_buff[1]*16;
   		  PWM4 = PWM1_buff[1]*16;
    	 }
	 }
	 else
	 {
		 if((User_PWM1[20]<30 && User_PWM1[21]<30) || flags_==1)
		{
		 PWM1 = PWM1_buff[1];
		 PWM2 = PWM1_buff[1];
		 PWM3 = PWM1_buff[0];
		 PWM4 = PWM1_buff[0];
		}
		 else
		 {
			  PWM1 = PWM1_buff[1]*16;
			  PWM2 = PWM1_buff[1]*16;
			  PWM3 = PWM1_buff[0]*16;
			  PWM4 = PWM1_buff[0]*16;
		 }
	 }
}
else
{
PWM1=0;
PWM2=0;
PWM3=0;
PWM4=0;
}

if(cmd) // отображаем значение ШИМ
	 {
    	   sprintf(tx_buffer0,"PWM1:%-3d PWM2:%-3d\r\n", (uint16_t)PWM1, (uint16_t)PWM3);
    	   usart1_tx(tx_buffer0);
    	   reset=0;
    	   timer=0;
    	   if(cmd&0b11000000)flg=0;
    	   if(cmd&0b00111100) HAL_Delay(500);
    	 	 cmd=0;
	 }

if(flg==0)
{
	 HAL_Delay(25);
	 if(++timer>800)
	 {

         for(uint8_t x=24; x<44; x++)
          {
       	data_ir_eep0[x] = User_PWM1[x-24];
           sprintf(tx_buffer0,"User PWM save %-2d %d\r\n",x-24, (uint8_t)data_ir_eep0[x]);
           usart1_tx(tx_buffer0);
          }
         save_cmd_eeprom(14);
         timer=0;
         flg=1;
	 }
	    if(timer>100 && timer<102)
	    {
	     timer_reset=0;
	     usart1_tx("timer_reset_data = 0\r\n");
		}
}

#endif


	 }
	 else
	 {

		 LED_ON;
		 HAL_Delay(250);
		 LED_OFF;
		 HAL_Delay(250);
		 //usart1_tx("Config mode!\r\n");

		if(DATA_RX[1])
		{

			LED_ON;
			HAL_Delay(100);
			LED_OFF;
			HAL_Delay(100);
			LED_ON;
			HAL_Delay(100);
			LED_OFF;
			HAL_Delay(100);
			LED_ON;
			HAL_Delay(100);
			LED_OFF;
			HAL_Delay(100);
			LED_ON;
			HAL_Delay(100);
			LED_OFF;
			HAL_Delay(100);
			//cmd = config;
			  sprintf(tx_buffer0,"\r\nConfig cmd %d...\r\nbit0 %d\r\n", config, BIT_TIME[3]);
							  usart1_tx(tx_buffer0);
							  sprintf(tx_buffer0,"bit1 %d\r\n", BIT_TIME[4]);
							  usart1_tx(tx_buffer0);
							  sprintf(tx_buffer0,"data %lu\r\n", DATA_RX[1]);
							  usart1_tx(tx_buffer0);

			 data_ir_eep0[(config-1)*3]   = DATA_RX[1];
			 data_ir_eep0[(config-1)*3+1] = BIT_TIME[4];
			 data_ir_eep0[(config-1)*3+2] = BIT_TIME[3];

			 if(++config>8)config=0;
			 if(config==0)
			 {
				 save_cmd_eeprom(14);
				 config=0;
				// return;
//#define DEBUG
#ifdef DEBUG
				 usart1_tx("\r\ncmd Data!\r\n");
				           for(uint8_t x=0; x<8; x++)
				           {
				           sprintf(tx_buffer0,"cmd Data %d\r\n", x+1);
				           usart1_tx(tx_buffer0);
				           sprintf(tx_buffer0,"Data %lu\r\n", data_ir_eep0[x*3]);
				           usart1_tx(tx_buffer0);
				           sprintf(tx_buffer0,"Bit0 %d\r\n", (uint16_t)(data_ir_eep0[x*3+1]));
				           usart1_tx(tx_buffer0);
				           sprintf(tx_buffer0,"Bit1 %d\r\n\r\n", (uint16_t)(data_ir_eep0[x*3+2]));
				           usart1_tx(tx_buffer0);
				           }
				           load_cmd_eeprom(14);

				           usart1_tx("\r\ncmd Data!\r\n");
				                     for(uint8_t x=0; x<8; x++)
				                     {
				                     sprintf(tx_buffer0,"cmd Data %d\r\n", x+1);
				                     usart1_tx(tx_buffer0);
				             		  sprintf(tx_buffer0,"Data %lu\r\n", data_ir_eep0[x*3]);
				             		  usart1_tx(tx_buffer0);
				             		  sprintf(tx_buffer0,"Bit0 %d\r\n", (uint16_t)(data_ir_eep0[x*3+1]));
				             		  usart1_tx(tx_buffer0);
				             		  sprintf(tx_buffer0,"Bit1 %d\r\n\r\n", (uint16_t)(data_ir_eep0[x*3+2]));
				             		  usart1_tx(tx_buffer0);
				                     }
#endif
			 }
			 else
			 {
			  sprintf(tx_buffer0,"\r\nConfig next cmd %d...\r\n", config);
			  usart1_tx(tx_buffer0);
			 }
			 LED_ON;
			 HAL_Delay(2000);
			 LED_OFF;
			 DATA_RX[1]=BIT_TIME[3]=BIT_TIME[4]=0;




		}


		// DATA_RX[1] = DATA_RX[0];
	    // BIT_TIME[3] = BIT_TIME[0];
	    // BIT_TIME[4] = BIT_TIME[1];
	 }

	// if(state==0)
	// {
		 //TIMER->CNT=0;
		 //HAL_Delay(2);
		 //BIT_TIME[5] = TIMER->CNT;
	 //}
	                     //DATA_RX[1] = DATA_RX[0];
	      	        	 //BIT_TIME[3] = BIT_TIME[0];
	      	        	 //BIT_TIME[4] = BIT_TIME[1];
	 /* if(rx_buffer0[0] )//&& (rx_wr_index0>=12))
	  {
		  LED_ON;
		  HAL_Delay(5);
		  LED_OFF;

		 // usart1_tx((char*) rx_buffer0);
		  rx_wr_index0=0;

		  //HAL_Delay(5);
		  LED_ON;
		  HAL_Delay(5);
		  LED_OFF;
		  HAL_Delay(5);
		  LED_ON;
		  HAL_Delay(5);
		  LED_OFF;
	  }*/
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

  /** Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB busses clocks 
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1;
  PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK1;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief TIM1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM1_Init(void)
{

  /* USER CODE BEGIN TIM1_Init 0 */

  /* USER CODE END TIM1_Init 0 */

  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_OC_InitTypeDef sConfigOC = {0};
  TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};

  /* USER CODE BEGIN TIM1_Init 1 */

  /* USER CODE END TIM1_Init 1 */
  htim1.Instance = TIM1;
  htim1.Init.Prescaler = 2;
  htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim1.Init.Period = 255;
  htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim1.Init.RepetitionCounter = 0;
  htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_PWM_Init(&htim1) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 0;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
  sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
  if (HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
  sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
  sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
  sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
  sBreakDeadTimeConfig.DeadTime = 0;
  sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
  sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
  sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
  if (HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM1_Init 2 */

  /* USER CODE END TIM1_Init 2 */
  HAL_TIM_MspPostInit(&htim1);

}

/**
  * @brief TIM3 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM3_Init(void)
{

  /* USER CODE BEGIN TIM3_Init 0 */

  /* USER CODE END TIM3_Init 0 */

  TIM_MasterConfigTypeDef sMasterConfig = {0};
  TIM_OC_InitTypeDef sConfigOC = {0};

  /* USER CODE BEGIN TIM3_Init 1 */

  /* USER CODE END TIM3_Init 1 */
  htim3.Instance = TIM3;
  htim3.Init.Prescaler = 1;
  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim3.Init.Period = 4081;
  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_PWM_Init(&htim3) != HAL_OK)
  {
    Error_Handler();
  }
  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim3, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }
  sConfigOC.OCMode = TIM_OCMODE_PWM1;
  sConfigOC.Pulse = 0;
  sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
  sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
  if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_2) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_4) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM3_Init 2 */

  /* USER CODE END TIM3_Init 2 */
  HAL_TIM_MspPostInit(&htim3);

}

/**
  * @brief TIM14 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM14_Init(void)
{

  /* USER CODE BEGIN TIM14_Init 0 */

  /* USER CODE END TIM14_Init 0 */

  /* USER CODE BEGIN TIM14_Init 1 */

  /* USER CODE END TIM14_Init 1 */
  htim14.Instance = TIM14;
  htim14.Init.Prescaler = 0;
  htim14.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim14.Init.Period = 0;
  htim14.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim14.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim14) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM14_Init 2 */

  /* USER CODE END TIM14_Init 2 */

}

/**
  * @brief TIM16 Initialization Function
  * @param None
  * @retval None
  */
static void MX_TIM16_Init(void)
{

  /* USER CODE BEGIN TIM16_Init 0 */

  /* USER CODE END TIM16_Init 0 */

  /* USER CODE BEGIN TIM16_Init 1 */

  /* USER CODE END TIM16_Init 1 */
  htim16.Instance = TIM16;
  htim16.Init.Prescaler = 8;
  htim16.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim16.Init.Period = 65535;
  htim16.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim16.Init.RepetitionCounter = 0;
  htim16.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim16) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN TIM16_Init 2 */

  /* USER CODE END TIM16_Init 2 */

}

/**
  * @brief USART1 Initialization Function
  * @param None
  * @retval None
  */
static void MX_USART1_UART_Init(void)
{

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 38400;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */

  /* USER CODE END USART1_Init 2 */

}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_1, GPIO_PIN_RESET);

  /*Configure GPIO pins : PA0 PA10 */
  GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_10;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pin : PA1 */
  GPIO_InitStruct.Pin = GPIO_PIN_1;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /*Configure GPIO pin : RX_IN_Pin */
  GPIO_InitStruct.Pin = RX_IN_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING_FALLING;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(RX_IN_GPIO_Port, &GPIO_InitStruct);

  /* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI4_15_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);

}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */

  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(char *file, uint32_t line)
{ 
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/