|
V.I.P.
Регистрация: 02.04.2023
Сообщений: 252
Поблагодарил: 2 раз(а)
Поблагодарили 39 раз(а)
Фотоальбомы:
не добавлял
Репутация: 120
|
хорошо перейдем к схемам.
схема основной платы
предварительный усилитель с компрессором, индикатором.
схемка кнопок
можно углубится в программное обеспечение.
Alex_Mn добавил 12.10.2023 в 18:11
файл main.c
PHP код:
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file : main.c
* @brief : Main program body
******************************************************************************
* @attention
* Autor Mordovin A A
*
* Copyright (c) 2023 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "cmsis_os.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "task.h"
#include "timers.h"
#include "queue.h"
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* структура кнопок */
typedef enum {
BUTTON_IDLE,
BUTTON_PRESSED,
BUTTON_LONG_PRESSED,
BUTTON_RELEASED
} button_state_t;
typedef struct {
GPIO_TypeDef *port;
uint16_t pin;
button_state_t state;
TickType_t press_start_time;
} button_t;
typedef struct {
GPIO_TypeDef *port;
uint16_t pin;
}led_t;
/* USER CODE END PTD */
/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
#define BUTTON_DEBOUNCE_TIME_MS 20 // время антидребезга
#define prm 1 // автоматическое вкл с дежурн прм в прм при нажатии sourse 1 вкл, 0 выкл
#define SOURCE_BUTTONS 4 // задаем кол-во кнопок селектор подкл
#define OP_BUTTONS 6 // задаем кол-во кнопок оповещения
#define PRD_BUTTONS 2 // задаем кол-во кнопок ПРД. сама кнопка ПРД и педаль ПРД
#define NUM_LED_IN 4 // задаем кол-во светодиодов 4шт селектор подкл
#define NUM_LED_OP 6 // задаем кол-во светодиодов 6 шт оповещения
#define time_out 1 // автоматическое ворачивание sourse к СДПС 1 вкл, 0 выкл.
#define Time 60000 // время через какое вернется sourse к СДПС (мс)
/* USER CODE END PD */
/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
///// создаем массив кнопок селектор источника
button_t buttons_s[SOURCE_BUTTONS] =
{
{SB2_GPIO_Port, SB2_Pin, BUTTON_IDLE, 0},
{SB3_GPIO_Port, SB3_Pin, BUTTON_IDLE, 0},
{SB4_GPIO_Port, SB4_Pin, BUTTON_IDLE, 0},
{SB5_GPIO_Port, SB5_Pin, BUTTON_IDLE, 0},
};
///// создаем массив кнопок оповещения
button_t buttons_op[OP_BUTTONS] =
{
{SD1_GPIO_Port, SD1_Pin, BUTTON_IDLE, 0},
{SD2_GPIO_Port, SD2_Pin, BUTTON_IDLE, 0},
{SD3_GPIO_Port, SD3_Pin, BUTTON_IDLE, 0},
{SD4_GPIO_Port, SD4_Pin, BUTTON_IDLE, 0},
{SD5_GPIO_Port, SD5_Pin, BUTTON_IDLE, 0},
{SD6_GPIO_Port, SD6_Pin, BUTTON_IDLE, 0},
};
///// создаем массив кнопка прд и педаль прд
button_t buttons_prd[PRD_BUTTONS] =
{
{SB1_GPIO_Port, SB1_Pin, BUTTON_IDLE, 0},
{Pedal_GPIO_Port, Pedal_Pin, BUTTON_IDLE, 0}//
};
///// создаем массив светодиодов селектора ситочника
led_t led_in[NUM_LED_IN] =
{
{LB2_A_GPIO_Port, LB2_A_Pin},
{LB3_A_GPIO_Port, LB3_A_Pin},
{LB4_A_GPIO_Port, LB4_A_Pin},
{LB5_A_GPIO_Port, LB5_A_Pin},
};
////
led_t led_in_B[NUM_LED_IN] =
{
{LB2_B_GPIO_Port, LB2_B_Pin},
{LB3_B_GPIO_Port, LB3_B_Pin},
{LB4_B_GPIO_Port, LB4_B_Pin},
{LB5_B_GPIO_Port, LB5_B_Pin},
};
////
led_t led_op_A[NUM_LED_OP] =
{
{LD1_A_GPIO_Port, LD1_A_Pin},
{LD2_A_GPIO_Port, LD2_A_Pin},
{LD3_A_GPIO_Port, LD3_A_Pin},
{LD4_A_GPIO_Port, LD4_A_Pin},
{LD5_A_GPIO_Port, LD5_A_Pin},
{LD6_A_GPIO_Port, LD6_A_Pin},
};
//////
led_t led_op_B[NUM_LED_OP] =
{
{LD1_B_GPIO_Port, LD1_B_Pin},
{LD2_B_GPIO_Port, LD2_B_Pin},
{LD3_B_GPIO_Port, LD3_B_Pin},
{LD4_B_GPIO_Port, LD4_B_Pin},
{LD5_B_GPIO_Port, LD5_B_Pin},
{LD6_B_GPIO_Port, LD6_B_Pin},
};
/* USER CODE END PM */
/* Private variables ---------------------------------------------------------*/
osThreadId defaultTaskHandle;
osThreadId button_s_TaskHandle;
osThreadId button_op_TaskHandle;
osThreadId button_prd_TaskHandle;
osThreadId read_Queue_sHandle;
osThreadId flash_LED_TaskHandle;
osThreadId read_Queue_opHandle;
osThreadId mig_ledHandle;
osMessageQId myQueue_sHandle;
osMessageQId myQueue_opHandle;
osTimerId myTimer01Handle;
osSemaphoreId myBinarySem01Handle;
osSemaphoreId myBinarySem02Handle;
/* USER CODE BEGIN PV */
//TaskHandle_t xTaskToNotify;
GPIO_PinState portValue;
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
void StartDefaultTask(void const * argument);
void Vbutton_s_Task(void const * argument);
void Vbutton_op_Task(void const * argument);
void Vbutton_prd_Task(void const * argument);
void V_read_Queue_s(void const * argument);
void Vflash_LED_Task(void const * argument);
void V_read_Queue_op(void const * argument);
void Vmig_led(void const * argument);
void Callback01(void const * argument);
/* USER CODE BEGIN PFP */
void Reset_Led(void);
//void migan_led(void);
/* USER CODE END PFP */
/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void Reset_Led() //обнуление светодиодов
{
for (int i = 0; i < NUM_LED_IN; i++)
{
HAL_GPIO_WritePin(led_in[i].port, led_in[i].pin, GPIO_PIN_RESET);//
}
}
/* 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();
/* USER CODE BEGIN 2 */
/* мигание светодиодами */
for (int i = 0; i < NUM_LED_OP; ++i)
{
HAL_GPIO_TogglePin(led_op_A[i].port, led_op_A[i].pin);//
HAL_Delay(150);
HAL_GPIO_TogglePin(led_op_A[i].port, led_op_A[i].pin);//
}
for (int i = 0; i < NUM_LED_OP; ++i)
{
HAL_GPIO_TogglePin(led_op_B[i].port, led_op_B[i].pin);//
HAL_Delay(150);
HAL_GPIO_TogglePin(led_op_B[i].port, led_op_B[i].pin);//
}
for (int i = 0; i < NUM_LED_IN; ++i)
{
HAL_GPIO_TogglePin(led_in[i].port, led_in[i].pin);//
HAL_Delay(150);
HAL_GPIO_TogglePin(led_in[i].port, led_in[i].pin);//
}
for (int i = 0; i < NUM_LED_IN; ++i)
{
HAL_GPIO_TogglePin(led_in_B[i].port, led_in_B[i].pin);//
HAL_Delay(150);
HAL_GPIO_TogglePin(led_in_B[i].port, led_in_B[i].pin);//
}
/* mute отключаем везде микрофоны */
HAL_GPIO_WritePin(Mut1_GPIO_Port, Mut1_Pin, GPIO_PIN_SET); // mute ON СДПС
HAL_GPIO_WritePin(Mut2_GPIO_Port, Mut2_Pin, GPIO_PIN_SET); // mute ON ПРС КВ
HAL_GPIO_WritePin(Mut3_GPIO_Port, Mut3_Pin, GPIO_PIN_SET); // mute ON ПРС УКВ
HAL_GPIO_WritePin(Mut4_GPIO_Port, Mut4_Pin, GPIO_PIN_SET); // mute ON СРС УКВ
HAL_GPIO_WritePin(LB2_A_GPIO_Port, LB2_A_Pin, GPIO_PIN_SET); // включаем sourse к СДПС
/* USER CODE END 2 */
/* USER CODE BEGIN RTOS_MUTEX */
/* add mutexes, ... */
/* USER CODE END RTOS_MUTEX */
/* Create the semaphores(s) */
/* definition and creation of myBinarySem01 */
osSemaphoreDef(myBinarySem01);
myBinarySem01Handle = osSemaphoreCreate(osSemaphore(myBinarySem01), 1);
/* definition and creation of myBinarySem02 */
osSemaphoreDef(myBinarySem02);
myBinarySem02Handle = osSemaphoreCreate(osSemaphore(myBinarySem02), 1);
/* USER CODE BEGIN RTOS_SEMAPHORES */
/* add semaphores, ... */
/* USER CODE END RTOS_SEMAPHORES */
/* Create the timer(s) */
/* definition and creation of myTimer01 */
osTimerDef(myTimer01, Callback01);
myTimer01Handle = osTimerCreate(osTimer(myTimer01), osTimerOnce, NULL);
/* USER CODE BEGIN RTOS_TIMERS */
/* start timers, add new ones, ... */
xTimerChangePeriod(myTimer01Handle, Time, 0);
// xTimerStart(myTimer01Handle, 0);
/* USER CODE END RTOS_TIMERS */
/* Create the queue(s) */
/* definition and creation of myQueue_s */
osMessageQDef(myQueue_s, 2, int);
myQueue_sHandle = osMessageCreate(osMessageQ(myQueue_s), NULL);
/* definition and creation of myQueue_op */
osMessageQDef(myQueue_op, 1, int);
myQueue_opHandle = osMessageCreate(osMessageQ(myQueue_op), NULL);
/* USER CODE BEGIN RTOS_QUEUES */
/* add queues, ... */
/* USER CODE END RTOS_QUEUES */
/* Create the thread(s) */
/* definition and creation of defaultTask */
osThreadDef(defaultTask, StartDefaultTask, osPriorityBelowNormal, 0, 128);
defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);
/* definition and creation of button_s_Task */
osThreadDef(button_s_Task, Vbutton_s_Task, osPriorityBelowNormal, 0, 128);
button_s_TaskHandle = osThreadCreate(osThread(button_s_Task), NULL);
/* definition and creation of button_op_Task */
osThreadDef(button_op_Task, Vbutton_op_Task, osPriorityBelowNormal, 0, 128);
button_op_TaskHandle = osThreadCreate(osThread(button_op_Task), NULL);
/* definition and creation of button_prd_Task */
osThreadDef(button_prd_Task, Vbutton_prd_Task, osPriorityBelowNormal, 0, 128);
button_prd_TaskHandle = osThreadCreate(osThread(button_prd_Task), NULL);
/* definition and creation of read_Queue_s */
osThreadDef(read_Queue_s, V_read_Queue_s, osPriorityBelowNormal, 0, 128);
read_Queue_sHandle = osThreadCreate(osThread(read_Queue_s), NULL);
/* definition and creation of flash_LED_Task */
osThreadDef(flash_LED_Task, Vflash_LED_Task, osPriorityBelowNormal, 0, 128);
flash_LED_TaskHandle = osThreadCreate(osThread(flash_LED_Task), NULL);
/* definition and creation of read_Queue_op */
osThreadDef(read_Queue_op, V_read_Queue_op, osPriorityBelowNormal, 0, 128);
read_Queue_opHandle = osThreadCreate(osThread(read_Queue_op), NULL);
/* definition and creation of mig_led */
osThreadDef(mig_led, Vmig_led, osPriorityBelowNormal, 0, 128);
mig_ledHandle = osThreadCreate(osThread(mig_led), NULL);
/* USER CODE BEGIN RTOS_THREADS */
/* add threads, ... */
/* USER CODE END RTOS_THREADS */
/* Start scheduler */
osKernelStart();
/* We should never get here as control is now taken by the scheduler */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* 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};
/** Initializes the RCC Oscillators according to the specified parameters
* in the RCC_OscInitTypeDef structure.
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/** Initializes the CPU, AHB and APB buses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
{
Error_Handler();
}
}
/**
* @brief GPIO Initialization Function
* @param None
* @retval None
*/
static void MX_GPIO_Init(void)
{
GPIO_InitTypeDef GPIO_InitStruct = {0};
/* USER CODE BEGIN MX_GPIO_Init_1 */
/* USER CODE END MX_GPIO_Init_1 */
/* GPIO Ports Clock Enable */
__HAL_RCC_GPIOE_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOD_CLK_ENABLE();
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOE, LB4_B_Pin|LB5_A_Pin|PLA5_Pin|PLA4_Pin
|PLA3_Pin|PRD2_Pin|PRD4_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOA, PLA7_Pin|LD1_B_Pin|LD3_B_Pin|LD5_B_Pin
|LD5_A_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOA, Mut3_Pin|Mut2_Pin, GPIO_PIN_SET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOC, PLA6_Pin|LD6_B_Pin|LD6_A_Pin|LD4_A_Pin
|LD2_A_Pin|LD3_A_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(Mut1_GPIO_Port, Mut1_Pin, GPIO_PIN_SET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(Mut4_GPIO_Port, Mut4_Pin, GPIO_PIN_SET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOB, PRD3_Pin|PLA2_Pin|PLA1_Pin|LB3_A_Pin
|LB3_B_Pin|LB4_A_Pin, GPIO_PIN_RESET);
/*Configure GPIO pin Output Level */
HAL_GPIO_WritePin(GPIOD, PRD_SDPS_Pin|LD2_B_Pin|LD4_B_Pin|LD1_A_Pin
|LB5_B_Pin|LB1_A_Pin|LB1_B_Pin|LB2_A_Pin
|LB2_B_Pin, GPIO_PIN_RESET);
/*Configure GPIO pins : LB4_B_Pin LB5_A_Pin PLA5_Pin Mut4_Pin
PLA4_Pin PLA3_Pin PRD2_Pin PRD4_Pin */
GPIO_InitStruct.Pin = LB4_B_Pin|LB5_A_Pin|PLA5_Pin|Mut4_Pin
|PLA4_Pin|PLA3_Pin|PRD2_Pin|PRD4_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
/*Configure GPIO pins : SB5_Pin SB4_Pin */
GPIO_InitStruct.Pin = SB5_Pin|SB4_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
/*Configure GPIO pins : PLA7_Pin Mut3_Pin Mut2_Pin LD1_B_Pin
LD3_B_Pin LD5_B_Pin LD5_A_Pin */
GPIO_InitStruct.Pin = PLA7_Pin|Mut3_Pin|Mut2_Pin|LD1_B_Pin
|LD3_B_Pin|LD5_B_Pin|LD5_A_Pin;
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 : RECLED7_Pin */
GPIO_InitStruct.Pin = RECLED7_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(RECLED7_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pins : PLA6_Pin LD6_B_Pin LD6_A_Pin LD4_A_Pin
LD2_A_Pin LD3_A_Pin */
GPIO_InitStruct.Pin = PLA6_Pin|LD6_B_Pin|LD6_A_Pin|LD4_A_Pin
|LD2_A_Pin|LD3_A_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
/*Configure GPIO pins : Mut1_Pin PRD3_Pin PLA2_Pin PLA1_Pin
LB3_A_Pin LB3_B_Pin LB4_A_Pin */
GPIO_InitStruct.Pin = Mut1_Pin|PRD3_Pin|PLA2_Pin|PLA1_Pin
|LB3_A_Pin|LB3_B_Pin|LB4_A_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/*Configure GPIO pins : RECLED6_Pin RECLED3_Pin RECLED2_Pin */
GPIO_InitStruct.Pin = RECLED6_Pin|RECLED3_Pin|RECLED2_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/*Configure GPIO pins : RECLED5_Pin RECLED4_Pin */
GPIO_InitStruct.Pin = RECLED5_Pin|RECLED4_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);
/*Configure GPIO pins : Pedal_Pin SB3_Pin SB2_Pin */
GPIO_InitStruct.Pin = Pedal_Pin|SB3_Pin|SB2_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
/*Configure GPIO pin : RECLED1_Pin */
GPIO_InitStruct.Pin = RECLED1_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(RECLED1_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pins : PRD_SDPS_Pin LD2_B_Pin LD4_B_Pin LD1_A_Pin
LB5_B_Pin LB1_A_Pin LB1_B_Pin LB2_A_Pin
LB2_B_Pin */
GPIO_InitStruct.Pin = PRD_SDPS_Pin|LD2_B_Pin|LD4_B_Pin|LD1_A_Pin
|LB5_B_Pin|LB1_A_Pin|LB1_B_Pin|LB2_A_Pin
|LB2_B_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/*Configure GPIO pins : SD2_Pin SD4_Pin SD6_Pin SD1_Pin
SB1_Pin */
GPIO_InitStruct.Pin = SD2_Pin|SD4_Pin|SD6_Pin|SD1_Pin
|SB1_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
/*Configure GPIO pin : SD5_Pin */
GPIO_InitStruct.Pin = SD5_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(SD5_GPIO_Port, &GPIO_InitStruct);
/*Configure GPIO pin : SD3_Pin */
GPIO_InitStruct.Pin = SD3_Pin;
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_PULLUP;
HAL_GPIO_Init(SD3_GPIO_Port, &GPIO_InitStruct);
/* USER CODE BEGIN MX_GPIO_Init_2 */
/* USER CODE END MX_GPIO_Init_2 */
}
/* USER CODE BEGIN 4 */
/* USER CODE END 4 */
/* USER CODE BEGIN Header_StartDefaultTask */
/**
* @brief Function implementing the defaultTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartDefaultTask */
void StartDefaultTask(void const * argument)
{
/* USER CODE BEGIN 5 */
/* Infinite loop */
for(;;)
{
osDelay(1);
}
/* USER CODE END 5 */
}
/* USER CODE BEGIN Header_Vbutton_s_Task */
/**
* @brief Function implementing the button_s_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_Vbutton_s_Task */
void Vbutton_s_Task(void const * argument)
{
/* USER CODE BEGIN Vbutton_s_Task */
TickType_t now; // Обьявляем переменную для системного времени отсчета
int data; // Обьявляем переменную для отправки в очередь
/* Infinite loop */
for(;;)
{
now = xTaskGetTickCount(); // Записываем системный тик в переменную
for (int i = 0; i < SOURCE_BUTTONS; i++) // цикл сканирования кнопок
{
if (HAL_GPIO_ReadPin(buttons_s[i].port, buttons_s[i].pin) == GPIO_PIN_RESET && buttons_s[i].state == BUTTON_IDLE) // если нажали кнопку
{
buttons_s[i].state = BUTTON_PRESSED; // пометили что нажали
buttons_s[i].press_start_time = now; // засекли время
}
else if (HAL_GPIO_ReadPin(buttons_s[i].port, buttons_s[i].pin) == GPIO_PIN_SET && buttons_s[i].state == BUTTON_PRESSED) //если кнопку отпустили и статус был нажат
{
buttons_s[i].state = BUTTON_IDLE; // исходное ссостояние
}
else if (HAL_GPIO_ReadPin(buttons_s[i].port, buttons_s[i].pin) == GPIO_PIN_SET && buttons_s[i].state == BUTTON_RELEASED) //если исполнено и кнопка отпущена
{
buttons_s[i].state = BUTTON_IDLE; // исходное ссостояние
}
/*--антидребезг--*/
if (buttons_s[i].state == BUTTON_PRESSED && now - buttons_s[i].press_start_time >= BUTTON_DEBOUNCE_TIME_MS)// если кнопка находится в нажатом состояние больше дребезга
{
data = i; // Номер кнопки записали в переменную
buttons_s[i].state = BUTTON_RELEASED; // пометили исполнено
xQueueSendToFront(myQueue_sHandle, &data, 0); // Номер кнопки послали в очередь для исполнения
}
}
osDelay(10);
}
/* USER CODE END Vbutton_s_Task */
}
/* USER CODE BEGIN Header_Vbutton_op_Task */
/**
* @brief Function implementing the button_op_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_Vbutton_op_Task */
void Vbutton_op_Task(void const * argument)
{
/* USER CODE BEGIN Vbutton_op_Task */
TickType_t now;
int data_op;
/* Infinite loop */
for(;;)
{
now = xTaskGetTickCount();
for (int i = 0; i < OP_BUTTONS; ++i)
{
if (HAL_GPIO_ReadPin(buttons_op[i].port, buttons_op[i].pin) == GPIO_PIN_RESET && buttons_op[i].state == BUTTON_IDLE) // если нажали кнопку
{
buttons_op[i].state = BUTTON_PRESSED; // пометили что нажали
buttons_op[i].press_start_time = now; // засекли время //
}
else if (HAL_GPIO_ReadPin(buttons_op[i].port, buttons_op[i].pin) == GPIO_PIN_SET && buttons_op[i].state == BUTTON_PRESSED) //если кнопку отпустили и статус был нажат
{
buttons_op[i].state = BUTTON_IDLE; // исходное ссостояние
}
else if (HAL_GPIO_ReadPin(buttons_op[i].port, buttons_op[i].pin) == GPIO_PIN_SET && buttons_op[i].state == BUTTON_RELEASED) //если исполнено и кнопка отпущена
{
buttons_op[i].state = BUTTON_IDLE; // исходное ссостояние
}
/*--антидребезг--*/
if (buttons_op[i].state == BUTTON_PRESSED && now - buttons_op[i].press_start_time >= BUTTON_DEBOUNCE_TIME_MS)// если кнопка находится в нажатом состояние больше дребезга
{
data_op = i;
buttons_op[i].state = BUTTON_RELEASED; // пометили исполнено
if (uxQueueMessagesWaiting(myQueue_opHandle) == 0)
{
if (HAL_GPIO_ReadPin(led_op_A[i].port, led_op_A[i].pin)
== GPIO_PIN_RESET) // если первый светодиод не горит
{
HAL_GPIO_WritePin(led_op_A[i].port, led_op_A[i].pin,
GPIO_PIN_SET); // включаем первый светодиод
}
else // если иначе
{
HAL_GPIO_WritePin(led_op_B[i].port, led_op_B[i].pin, GPIO_PIN_SET); // включаем второй светодиод//
}
xQueueSendToFront(myQueue_opHandle, &data_op, 0); // послали в очередь
xSemaphoreGive(myBinarySem02Handle); //послали в семофор мигать светодиодом
}
}
}
osDelay(20);
}
/* USER CODE END Vbutton_op_Task */
}
/* USER CODE BEGIN Header_Vbutton_prd_Task */
/**
* @brief Function implementing the button_prd_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_Vbutton_prd_Task */
void Vbutton_prd_Task(void const * argument)
{
/* USER CODE BEGIN Vbutton_prd_Task */
TickType_t now;
/* Infinite loop */
for (;;)
{
now = xTaskGetTickCount();
for (int i = 0; i < PRD_BUTTONS; i++)
{
if (HAL_GPIO_ReadPin(buttons_prd[i].port, buttons_prd[i].pin) == GPIO_PIN_RESET && buttons_prd[i].state == BUTTON_IDLE) // если нажали кнопку
{
buttons_prd[i].state = BUTTON_PRESSED; // пометили что нажали
buttons_prd[i].press_start_time = now; // засекли время
}
else if (HAL_GPIO_ReadPin(buttons_prd[i].port, buttons_prd[i].pin) == GPIO_PIN_SET && buttons_prd[i].state == BUTTON_PRESSED) //если кнопку отпустили и статус был нажат
{
buttons_prd[i].state = BUTTON_IDLE; // исходное ссостояние
}
else if (HAL_GPIO_ReadPin(buttons_prd[i].port, buttons_prd[i].pin) == GPIO_PIN_SET && buttons_prd[i].state == BUTTON_RELEASED) //если исполнено и кнопка отпущена
{
buttons_prd[i].state = BUTTON_IDLE; // исходное ссостояние
}
}
/*--исполнение антидребезг--*/
if (buttons_prd[0].state == BUTTON_PRESSED && now - buttons_prd[0].press_start_time >= BUTTON_DEBOUNCE_TIME_MS)
// if (buttons_prd[0].state == BUTTON_PRESSED && HAL_GPIO_ReadPin(SB1_GPIO_Port, SB1_Pin) == GPIO_PIN_RESET) //если кнопка ПРД нажата
{
buttons_prd[0].state = BUTTON_RELEASED; // пометили исполнено
HAL_GPIO_WritePin(LB1_A_GPIO_Port, LB1_A_Pin, GPIO_PIN_SET); // включили светодиод LB1А
xSemaphoreGive(myBinarySem01Handle); //послать в семофор разруливать все будем в чтении семофора
}
else if (buttons_prd[1].state == BUTTON_PRESSED && now - buttons_prd[1].press_start_time >= BUTTON_DEBOUNCE_TIME_MS)
// else if (buttons_prd[1].state == BUTTON_PRESSED && HAL_GPIO_ReadPin(Pedal_GPIO_Port, Pedal_Pin) == GPIO_PIN_RESET) //если педаль ПРД нажата
{
buttons_prd[1].state = BUTTON_RELEASED; // пометили исполнено
HAL_GPIO_WritePin(LB1_B_GPIO_Port, LB1_B_Pin, GPIO_PIN_SET); // включили светодиод LB1B
xSemaphoreGive(myBinarySem01Handle); //послать в семофор разруливать все будем в чтении семофора
}
else if (buttons_prd[0].state == BUTTON_IDLE)
{
HAL_GPIO_WritePin(LB1_A_GPIO_Port, LB1_A_Pin, GPIO_PIN_RESET); // отключили светодиод LB1А
}
else if (buttons_prd[1].state == BUTTON_IDLE)
{
HAL_GPIO_WritePin(LB1_B_GPIO_Port, LB1_B_Pin, GPIO_PIN_RESET); // отключили светодиод LB1B//
}
/*
else
{
HAL_GPIO_WritePin(LB1_A_GPIO_Port, LB1_A_Pin, GPIO_PIN_RESET); // отключили светодиод LB1А//
HAL_GPIO_WritePin(LB1_B_GPIO_Port, LB1_B_Pin, GPIO_PIN_RESET); // отключили светодиод LB1B
}
*/
}
/* USER CODE END Vbutton_prd_Task */
}
/* USER CODE BEGIN Header_V_read_Queue_s */
/**
* @brief Function implementing the read_Queue_s thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_V_read_Queue_s */
void V_read_Queue_s(void const * argument)
{
/* USER CODE BEGIN V_read_Queue_s */
int read_data;
BaseType_t xstatus;
/* Infinite loop */
for(;;)
{
xstatus = xQueueReceive(myQueue_sHandle, &read_data, portMAX_DELAY);
if (xstatus == pdTRUE)
{
if (read_data == 0) // если пришло 0 (нажали кнопку СДПС)
{
Reset_Led(); // выключить все светодиоды
HAL_GPIO_WritePin(LB2_A_GPIO_Port, LB2_A_Pin, GPIO_PIN_SET); // вкл светодиод СДПС
}
else if (read_data == 1) // если пришло 1 (нажали кнопку ПРС ГМВ)
{
Reset_Led(); // выключить все светодиоды
HAL_GPIO_WritePin(LB3_A_GPIO_Port, LB3_A_Pin, GPIO_PIN_SET); // вкл светодиод ПРС ГМВ
if (time_out) xTimerReset(myTimer01Handle, 0); // запустили однократный тймер
/* кратковременно нажать ПРД (Прием) */
if (prm)
{
HAL_GPIO_WritePin(PRD2_GPIO_Port, PRD2_Pin, GPIO_PIN_SET); // включить ПРД ПРС ГМВ
osDelay(50);
HAL_GPIO_WritePin(PRD2_GPIO_Port, PRD2_Pin, GPIO_PIN_RESET); // отключить ПРД ПРС ГМВ
}
}
else if (read_data == 2) // если пришло 2 (нажали кнопку ПРС МВ)
{
Reset_Led(); // выключить все светодиоды
HAL_GPIO_WritePin(LB4_A_GPIO_Port, LB4_A_Pin, GPIO_PIN_SET); // вкл светодиод ПРС МВ
if (time_out) xTimerReset(myTimer01Handle, 0); // запустили однократный тймер
/* кратковременно нажать ПРД (Прием) */
if (prm)
{
HAL_GPIO_WritePin(PRD3_GPIO_Port, PRD3_Pin, GPIO_PIN_SET); // включить ПРД ПРС МВ
osDelay(50);
HAL_GPIO_WritePin(PRD3_GPIO_Port, PRD3_Pin, GPIO_PIN_RESET); // отключить ПРД ПРС МВ
}
}
else if (read_data == 3) // если пришло 3 (нажали кнопку СРС МВ)
{
Reset_Led(); // выключить все светодиоды
HAL_GPIO_WritePin(LB5_A_GPIO_Port, LB5_A_Pin, GPIO_PIN_SET); // вкл светодиод СРС МВ
if (time_out) xTimerReset(myTimer01Handle, 0); // запустили однократный тймер
/* кратковременно нажать ПРД (Прием) */
if (prm)
{
HAL_GPIO_WritePin(PRD4_GPIO_Port, PRD4_Pin, GPIO_PIN_SET); // включить ПРД СРС МВ
osDelay(50);
HAL_GPIO_WritePin(PRD4_GPIO_Port, PRD4_Pin, GPIO_PIN_RESET); // отключить ПРД СРС МВ
}
}
}
}
/* USER CODE END V_read_Queue_s */
}
/* USER CODE BEGIN Header_Vflash_LED_Task */
/**
* @brief Function implementing the flash_LED_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_Vflash_LED_Task */
void Vflash_LED_Task(void const * argument)
{
/* USER CODE BEGIN Vflash_LED_Task */
/* Infinite loop */
for(;;)
{
xSemaphoreTake(myBinarySem01Handle, portMAX_DELAY);
if (HAL_GPIO_ReadPin(LB2_A_GPIO_Port, LB2_A_Pin) == GPIO_PIN_SET) // если включен СДПС
{
HAL_GPIO_WritePin(Mut1_GPIO_Port, Mut1_Pin, GPIO_PIN_RESET); // отключить mute 1
HAL_GPIO_WritePin(PRD_SDPS_GPIO_Port, PRD_SDPS_Pin, GPIO_PIN_SET); // включить ПРД СДПС
while (HAL_GPIO_ReadPin(LB1_A_GPIO_Port, LB1_A_Pin) == GPIO_PIN_SET || HAL_GPIO_ReadPin(LB1_B_GPIO_Port, LB1_B_Pin) == GPIO_PIN_SET) // пока нажата кнопка ПРД
// while ((HAL_GPIO_ReadPin(SB1_GPIO_Port, SB1_Pin) == GPIO_PIN_RESET && buttons_prd[0].state == BUTTON_RELEASED) || (HAL_GPIO_ReadPin(Pedal_GPIO_Port, Pedal_Pin) == GPIO_PIN_RESET && buttons_prd[1].state == BUTTON_RELEASED))
{
HAL_GPIO_TogglePin(LB2_B_GPIO_Port, LB2_B_Pin); // мигаем соответствующим светодиодом (СДПС)
osDelay(200);
}
HAL_GPIO_WritePin(LB2_B_GPIO_Port, LB2_B_Pin, GPIO_PIN_RESET); // выключить принудительно светодиод LB2B
buttons_prd[0].state = BUTTON_IDLE; // статус в исходное состояние
buttons_prd[1].state = BUTTON_IDLE; // статус в исходное состояние
HAL_GPIO_WritePin(Mut1_GPIO_Port, Mut1_Pin, GPIO_PIN_SET); // включить mute 1
HAL_GPIO_WritePin(PRD_SDPS_GPIO_Port, PRD_SDPS_Pin, GPIO_PIN_RESET); // отключить ПРД СДПС
}
else if (HAL_GPIO_ReadPin(LB3_A_GPIO_Port, LB3_A_Pin) == GPIO_PIN_SET) // если включен ПРС ГМВ
{
HAL_GPIO_WritePin(Mut2_GPIO_Port, Mut2_Pin, GPIO_PIN_RESET); // отключить mute 2
HAL_GPIO_WritePin(PRD2_GPIO_Port, PRD2_Pin, GPIO_PIN_SET); // включить ПРД ПРС ГМВ
while (HAL_GPIO_ReadPin(LB1_A_GPIO_Port, LB1_A_Pin) == GPIO_PIN_SET || HAL_GPIO_ReadPin(LB1_B_GPIO_Port, LB1_B_Pin) == GPIO_PIN_SET) // пока нажата кнопка ПРД
// while ((HAL_GPIO_ReadPin(SB1_GPIO_Port, SB1_Pin) == GPIO_PIN_RESET && buttons_prd[0].state == BUTTON_RELEASED) || (HAL_GPIO_ReadPin(Pedal_GPIO_Port, Pedal_Pin) == GPIO_PIN_RESET && buttons_prd[1].state == BUTTON_RELEASED))
{
HAL_GPIO_TogglePin(LB3_B_GPIO_Port, LB3_B_Pin); // мигаем светодиодом (ПРС ГМВ)
osDelay(200);
xTimerReset(myTimer01Handle, 0); // рестарт однократный таймер
}
HAL_GPIO_WritePin(LB3_B_GPIO_Port, LB3_B_Pin, GPIO_PIN_RESET); // выключаем принудительно светодиод LB3B
buttons_prd[0].state = BUTTON_IDLE; // статус в исходное состояние
buttons_prd[0].state = BUTTON_IDLE; // статус в исходное состояние
HAL_GPIO_WritePin(Mut2_GPIO_Port, Mut2_Pin, GPIO_PIN_SET); // включить mute 2
HAL_GPIO_WritePin(PRD2_GPIO_Port, PRD2_Pin, GPIO_PIN_RESET); // отключить ПРД ПРС ГМВ
}
else if (HAL_GPIO_ReadPin(LB4_A_GPIO_Port, LB4_A_Pin) == GPIO_PIN_SET) // если включен ПРС МВ
{
HAL_GPIO_WritePin(Mut3_GPIO_Port, Mut3_Pin, GPIO_PIN_RESET); // отключить mute 3
HAL_GPIO_WritePin(PRD3_GPIO_Port, PRD3_Pin, GPIO_PIN_SET); // включить ПРД ПРС МВ
while (HAL_GPIO_ReadPin(LB1_A_GPIO_Port, LB1_A_Pin) == GPIO_PIN_SET || HAL_GPIO_ReadPin(LB1_B_GPIO_Port, LB1_B_Pin) == GPIO_PIN_SET) // пока нажата кнопка ПРД
// while ((HAL_GPIO_ReadPin(SB1_GPIO_Port, SB1_Pin) == GPIO_PIN_RESET && buttons_prd[0].state == BUTTON_RELEASED) || (HAL_GPIO_ReadPin(Pedal_GPIO_Port, Pedal_Pin) == GPIO_PIN_RESET && buttons_prd[1].state == BUTTON_RELEASED))
{
HAL_GPIO_TogglePin(LB4_B_GPIO_Port, LB4_B_Pin); // мигаем светодиодом (ПРС МВ)
osDelay(200);
xTimerReset(myTimer01Handle, 0); // рестарт однократный таймер
}
HAL_GPIO_WritePin(LB4_B_GPIO_Port, LB4_B_Pin, GPIO_PIN_RESET); // выключаем принудительно светодиод LB4B
buttons_prd[0].state = BUTTON_IDLE; // статус в исходное состояние
buttons_prd[0].state = BUTTON_IDLE; // статус в исходное состояние
HAL_GPIO_WritePin(Mut3_GPIO_Port, Mut3_Pin, GPIO_PIN_SET); // включить mute 3
HAL_GPIO_WritePin(PRD3_GPIO_Port, PRD3_Pin, GPIO_PIN_RESET); // отключить ПРД ПРС МВ
}
else if (HAL_GPIO_ReadPin(LB5_A_GPIO_Port, LB5_A_Pin) == GPIO_PIN_SET) // если включен СРС МВ
{
HAL_GPIO_WritePin(Mut4_GPIO_Port, Mut4_Pin, GPIO_PIN_RESET); // отключить mute 4
HAL_GPIO_WritePin(PRD4_GPIO_Port, PRD4_Pin, GPIO_PIN_SET); // включить ПРД СРС МВ
while (HAL_GPIO_ReadPin(LB1_A_GPIO_Port, LB1_A_Pin) == GPIO_PIN_SET || HAL_GPIO_ReadPin(LB1_B_GPIO_Port, LB1_B_Pin) == GPIO_PIN_SET) // пока нажата кнопка ПРД
// while ((HAL_GPIO_ReadPin(SB1_GPIO_Port, SB1_Pin) == GPIO_PIN_RESET && buttons_prd[0].state == BUTTON_RELEASED) || (HAL_GPIO_ReadPin(Pedal_GPIO_Port, Pedal_Pin) == GPIO_PIN_RESET && buttons_prd[1].state == BUTTON_RELEASED))
{
HAL_GPIO_TogglePin(LB5_B_GPIO_Port, LB5_B_Pin); // Мигаем светодиодом (СРС МВ)
osDelay(200);
xTimerReset(myTimer01Handle, 0); // запускаем однократный тймер
}
HAL_GPIO_WritePin(LB5_B_GPIO_Port, LB5_B_Pin, GPIO_PIN_RESET);
buttons_prd[0].state = BUTTON_IDLE; // статус в исходное состояние
buttons_prd[0].state = BUTTON_IDLE; // статус в исходное состояние
HAL_GPIO_WritePin(Mut4_GPIO_Port, Mut4_Pin, GPIO_PIN_SET); // включить mute 4
HAL_GPIO_WritePin(PRD4_GPIO_Port, PRD4_Pin, GPIO_PIN_RESET); // отключить ПРД СРС МВ
}
}
/* USER CODE END Vflash_LED_Task */
}
/* USER CODE BEGIN Header_V_read_Queue_op */
/**
* @brief Function implementing the read_Queue_op thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_V_read_Queue_op */
void V_read_Queue_op(void const * argument)
{
/* USER CODE BEGIN V_read_Queue_op */
int read_data;
BaseType_t status;
uint32_t xMaxBlockTime = 0;
/* Infinite loop */
for(;;)
{
status = xQueueReceive(myQueue_opHandle, &read_data, portMAX_DELAY);
if (status == pdTRUE)
{
HAL_GPIO_WritePin(PRD_SDPS_GPIO_Port, PRD_SDPS_Pin, GPIO_PIN_SET); // Нажать кнопку ПРД СДПС
// HAL_GPIO_WritePin(PRD_SDPS_GPIO_Port, PRD_SDPS_Pin, GPIO_PIN_SET);
if (read_data == 0) // если нажали кнопку 1
{
/* рингтон */
HAL_GPIO_WritePin(PLA1_GPIO_Port, PLA1_Pin, GPIO_PIN_SET); // нажали кнопку "вкл оповещение" запуск ISD1820
osDelay(50); // подождали 50мсек
HAL_GPIO_WritePin(PLA1_GPIO_Port, PLA1_Pin, GPIO_PIN_RESET); // отпустили кнопку "вкл оповещение"
xMaxBlockTime = 5000; // установили таймаут ожидания
while ((portValue = HAL_GPIO_ReadPin(RECLED1_GPIO_Port, RECLED1_Pin)) != GPIO_PIN_RESET && xMaxBlockTime > 0) // цикл ожидания конца оповещения
{
osDelay(1); // задержка 1 мсек
xMaxBlockTime--; // отнимаем -1
}
////---------------
/* оповещение */
HAL_GPIO_WritePin(PLA2_GPIO_Port, PLA2_Pin, GPIO_PIN_SET); // нажали кнопку "вкл оповещение"
osDelay(50); // подождали 50мсек
HAL_GPIO_WritePin(PLA2_GPIO_Port, PLA2_Pin, GPIO_PIN_RESET); // отпустили кнопку "вкл оповещение"
xMaxBlockTime = 12000; // установили таймаут ожидания
while ((portValue = HAL_GPIO_ReadPin(RECLED2_GPIO_Port, RECLED2_Pin)) != GPIO_PIN_RESET && xMaxBlockTime > 0) // цикл ожидания конца оповещения
{
osDelay(1); // задержка 1 мсек
xMaxBlockTime--; // отнимаем -1
}
/* конец оповещения */
/* отключение лед индикации */
if (HAL_GPIO_ReadPin(LD1_A_GPIO_Port, LD1_A_Pin) == GPIO_PIN_SET && HAL_GPIO_ReadPin(LD1_B_GPIO_Port, LD1_B_Pin) == GPIO_PIN_SET)
{
HAL_GPIO_WritePin(LD1_B_GPIO_Port, LD1_B_Pin, GPIO_PIN_RESET); //
}
else if (HAL_GPIO_ReadPin(LD1_A_GPIO_Port, LD1_A_Pin) == GPIO_PIN_SET && HAL_GPIO_ReadPin(LD1_B_GPIO_Port, LD1_B_Pin) == GPIO_PIN_RESET)
{
HAL_GPIO_WritePin(LD1_A_GPIO_Port, LD1_A_Pin,
GPIO_PIN_RESET); //
}
}
else if (read_data == 1)
{
/* рингтон */
HAL_GPIO_WritePin(PLA1_GPIO_Port, PLA1_Pin, GPIO_PIN_SET); // нажали кнопку "вкл оповещение"
osDelay(50); // подождали 50мсек
HAL_GPIO_WritePin(PLA1_GPIO_Port, PLA1_Pin, GPIO_PIN_RESET); // отпустили кнопку "вкл оповещение"
xMaxBlockTime = 5000; // установили таймаут ожидания
while ((portValue = HAL_GPIO_ReadPin(RECLED1_GPIO_Port, RECLED1_Pin)) != GPIO_PIN_RESET && xMaxBlockTime > 0) // цикл ожидания конца оповещения
{
osDelay(1); // задержка 1 мсек
xMaxBlockTime--; // отнимаем -1
}
////---------------
/* оповещение */
HAL_GPIO_WritePin(PLA3_GPIO_Port, PLA3_Pin, GPIO_PIN_SET); // нажали кнопку "вкл оповещение"
osDelay(50); // подождали 50мсек
HAL_GPIO_WritePin(PLA3_GPIO_Port, PLA3_Pin, GPIO_PIN_RESET); // отпустили кнопку "вкл оповещение"
xMaxBlockTime = 12000; // установили таймаут ожидания
while ((portValue = HAL_GPIO_ReadPin(RECLED3_GPIO_Port, RECLED3_Pin)) != GPIO_PIN_RESET && xMaxBlockTime > 0) // цикл ожидания конца оповещения
{
osDelay(1); // задержка 1 мсек
xMaxBlockTime--; // отнимаем -1
}
/* конец оповещения */
/* отключение лед индикации */
if (HAL_GPIO_ReadPin(LD2_A_GPIO_Port, LD2_A_Pin) == GPIO_PIN_SET && HAL_GPIO_ReadPin(LD2_B_GPIO_Port, LD2_B_Pin) == GPIO_PIN_SET)
{
HAL_GPIO_WritePin(LD2_B_GPIO_Port, LD2_B_Pin, GPIO_PIN_RESET); //
}
else if (HAL_GPIO_ReadPin(LD2_A_GPIO_Port, LD2_A_Pin) == GPIO_PIN_SET && HAL_GPIO_ReadPin(LD2_B_GPIO_Port, LD2_B_Pin) == GPIO_PIN_RESET)
{
HAL_GPIO_WritePin(LD2_A_GPIO_Port, LD2_A_Pin, GPIO_PIN_RESET); //
} //
}
else if (read_data == 2)
{
// osDelay(5000); // время для выполнения оповещения
/* оповещение */
HAL_GPIO_WritePin(PLA4_GPIO_Port, PLA4_Pin, GPIO_PIN_SET); // нажали кнопку "вкл оповещение"
osDelay(50); // подождали 50мсек
HAL_GPIO_WritePin(PLA4_GPIO_Port, PLA4_Pin, GPIO_PIN_RESET); // отпустили кнопку "вкл оповещение"
xMaxBlockTime = 12000; // установили таймаут ожидания
while ((portValue = HAL_GPIO_ReadPin(RECLED4_GPIO_Port, RECLED4_Pin)) != GPIO_PIN_RESET && xMaxBlockTime > 0) // цикл ожидания конца оповещения
{
osDelay(1); // задержка 1 мсек
xMaxBlockTime--; // отнимаем -1
}
/* конец оповещения */
/* отключение лед индикации */
if (HAL_GPIO_ReadPin(LD3_A_GPIO_Port, LD3_A_Pin) == GPIO_PIN_SET && HAL_GPIO_ReadPin(LD3_B_GPIO_Port, LD3_B_Pin) == GPIO_PIN_SET)
{
HAL_GPIO_WritePin(LD3_B_GPIO_Port, LD3_B_Pin, GPIO_PIN_RESET); //
}
else if (HAL_GPIO_ReadPin(LD3_A_GPIO_Port, LD3_A_Pin) == GPIO_PIN_SET && HAL_GPIO_ReadPin(LD3_B_GPIO_Port, LD3_B_Pin) == GPIO_PIN_RESET)
{
HAL_GPIO_WritePin(LD3_A_GPIO_Port, LD3_A_Pin, GPIO_PIN_RESET); //
} //
}
else if (read_data == 3)
{
// osDelay(5000); // время для выполнения оповещения
/* оповещение */
HAL_GPIO_WritePin(PLA5_GPIO_Port, PLA5_Pin, GPIO_PIN_SET); // нажали кнопку "вкл оповещение"
osDelay(50); // подождали 50мсек
HAL_GPIO_WritePin(PLA5_GPIO_Port, PLA5_Pin, GPIO_PIN_RESET); // отпустили кнопку "вкл оповещение"
xMaxBlockTime = 12000; // установили таймаут ожидания
while ((portValue = HAL_GPIO_ReadPin(RECLED5_GPIO_Port, RECLED5_Pin)) != GPIO_PIN_RESET && xMaxBlockTime > 0) // цикл ожидания конца оповещения
{
osDelay(1); // задержка 1 мсек
xMaxBlockTime--; // отнимаем -1
}
/* конец оповещения */
/* отключение лед индикации */
if (HAL_GPIO_ReadPin(LD4_A_GPIO_Port, LD4_A_Pin) == GPIO_PIN_SET && HAL_GPIO_ReadPin(LD4_B_GPIO_Port, LD4_B_Pin) == GPIO_PIN_SET)
{
HAL_GPIO_WritePin(LD4_B_GPIO_Port, LD4_B_Pin, GPIO_PIN_RESET); //
}
else if (HAL_GPIO_ReadPin(LD4_A_GPIO_Port, LD4_A_Pin) == GPIO_PIN_SET && HAL_GPIO_ReadPin(LD4_B_GPIO_Port, LD4_B_Pin) == GPIO_PIN_RESET)
{
HAL_GPIO_WritePin(LD4_A_GPIO_Port, LD4_A_Pin, GPIO_PIN_RESET); //
} //
}
else if (read_data == 4)
{
// osDelay(5000); // время для выполнения оповещения
/* оповещение */
HAL_GPIO_WritePin(PLA6_GPIO_Port, PLA6_Pin, GPIO_PIN_SET); // нажали кнопку "вкл оповещение"
osDelay(50); // подождали 50мсек
HAL_GPIO_WritePin(PLA6_GPIO_Port, PLA6_Pin, GPIO_PIN_RESET); // отпустили кнопку "вкл оповещение"
xMaxBlockTime = 12000; // установили таймаут ожидания
while ((portValue = HAL_GPIO_ReadPin(RECLED6_GPIO_Port, RECLED6_Pin)) != GPIO_PIN_RESET && xMaxBlockTime > 0) // цикл ожидания конца оповещения
{
osDelay(1); // задержка 1 мсек
xMaxBlockTime--; // отнимаем -1
}
/* конец оповещения */
/* отключение лед индикации */
if (HAL_GPIO_ReadPin(LD5_A_GPIO_Port, LD5_A_Pin) == GPIO_PIN_SET && HAL_GPIO_ReadPin(LD5_B_GPIO_Port, LD5_B_Pin) == GPIO_PIN_SET)
{
HAL_GPIO_WritePin(LD5_B_GPIO_Port, LD5_B_Pin, GPIO_PIN_RESET); //
}
else if (HAL_GPIO_ReadPin(LD5_A_GPIO_Port, LD5_A_Pin) == GPIO_PIN_SET && HAL_GPIO_ReadPin(LD5_B_GPIO_Port, LD5_B_Pin) == GPIO_PIN_RESET)
{
HAL_GPIO_WritePin(LD5_A_GPIO_Port, LD5_A_Pin, GPIO_PIN_RESET); //
} //
}
else if (read_data == 5)
{
// osDelay(5000); // время для выполнения оповещения
/* оповещение */
HAL_GPIO_WritePin(PLA7_GPIO_Port, PLA7_Pin, GPIO_PIN_SET); // нажали кнопку "вкл оповещение"
osDelay(50); // подождали 50мсек
HAL_GPIO_WritePin(PLA7_GPIO_Port, PLA7_Pin, GPIO_PIN_RESET); // отпустили кнопку "вкл оповещение"
xMaxBlockTime = 12000; // установили таймаут ожидания
while ((portValue = HAL_GPIO_ReadPin(RECLED7_GPIO_Port, RECLED7_Pin)) != GPIO_PIN_RESET && xMaxBlockTime > 0) // цикл ожидания конца оповещения
{
osDelay(1); // задержка 1 мсек
xMaxBlockTime--; // отнимаем -1
}
/* конец оповещения */
/* отключение лед индикации */
if (HAL_GPIO_ReadPin(LD6_A_GPIO_Port, LD6_A_Pin) == GPIO_PIN_SET && HAL_GPIO_ReadPin(LD6_B_GPIO_Port, LD6_B_Pin) == GPIO_PIN_SET)
{
HAL_GPIO_WritePin(LD6_B_GPIO_Port, LD6_B_Pin, GPIO_PIN_RESET); //
}
else if (HAL_GPIO_ReadPin(LD6_A_GPIO_Port, LD6_A_Pin) == GPIO_PIN_SET && HAL_GPIO_ReadPin(LD6_B_GPIO_Port, LD6_B_Pin) == GPIO_PIN_RESET)
{
HAL_GPIO_WritePin(LD6_A_GPIO_Port, LD6_A_Pin, GPIO_PIN_RESET); //
} //
}
}
HAL_GPIO_WritePin(PRD_SDPS_GPIO_Port, PRD_SDPS_Pin, GPIO_PIN_RESET); // отпустить кнопку ПРД СДПС
osDelay(300);
}
/* USER CODE END V_read_Queue_op */
}
/* USER CODE BEGIN Header_Vmig_led */
/**
* @brief Function implementing the mig_led thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_Vmig_led */
void Vmig_led(void const * argument)
{
/* USER CODE BEGIN Vmig_led */
/* Infinite loop */
for(;;)
{
xSemaphoreTake(myBinarySem02Handle, portMAX_DELAY);
for (int i = 0; i < NUM_LED_OP; ++i)
{
while (HAL_GPIO_ReadPin(led_op_A[i].port, led_op_A[i].pin) == GPIO_PIN_SET || HAL_GPIO_ReadPin(led_op_B[i].port, led_op_B[i].pin) == GPIO_PIN_SET) //
{
HAL_GPIO_TogglePin(LB2_B_GPIO_Port, LB2_B_Pin);
osDelay(200);//
}
}
HAL_GPIO_WritePin(LB2_B_GPIO_Port, LB2_B_Pin, GPIO_PIN_RESET);
osDelay(1);
}
/* USER CODE END Vmig_led */
}
/* Callback01 function */
void Callback01(void const * argument)
{
/* USER CODE BEGIN Callback01 */
Reset_Led();
HAL_GPIO_WritePin(LB2_A_GPIO_Port, LB2_A_Pin, GPIO_PIN_SET);
/* USER CODE END Callback01 */
}
/**
* @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 */
__disable_irq();
while (1)
{
}
/* 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(uint8_t *file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */
Alex_Mn добавил 12.10.2023 в 18:16
ну и 3д чертеж платы
Последний раз редактировалось Alex_Mn; 12.10.2023 в 18:16.
Причина: Добавлено сообщение
|
