682 lines
19 KiB
C
682 lines
19 KiB
C
/*
|
||
* @Author : stark1898y 1658608470@qq.com
|
||
* @Date : 2024-12-15 15:01:15
|
||
* @LastEditors : stark1898y 1658608470@qq.com
|
||
* @LastEditTime : 2025-02-24 17:58:40
|
||
* @FilePath : \BLE_TYQ_CH584M\BSP\src\bsp_valve.c
|
||
* @Description :
|
||
*
|
||
* Copyright (c) 2024 by yzy, All Rights Reserved.
|
||
*/
|
||
#include "bsp_valve.h"
|
||
#include "bsp_flash.h"
|
||
|
||
#include "bsp_beep_led_emv.h"
|
||
// 0xAA CMD/DATA/ DATA_LEN (DATA) checksum 0x55
|
||
|
||
#include "bsp_uart.h"
|
||
#include "log.h"
|
||
|
||
#include "peripheral.h"
|
||
|
||
#include "SLEEP.h"
|
||
|
||
#include "bsp_adc.h"
|
||
|
||
#undef LOG_ENABLE
|
||
#define LOG_ENABLE 1
|
||
|
||
#undef LOG_TAG
|
||
#define LOG_TAG "BSP_VALVE"
|
||
|
||
TsValveData gValveData = {0};
|
||
|
||
TsRawFrameData RelyData;
|
||
|
||
// 存储 当前task id 的全局变量
|
||
tmosTaskID vavle_task_id = INVALID_TASK_ID;
|
||
|
||
#define ARRAY_SIZE(freq_arr) (sizeof(freq_arr) / sizeof((freq_arr)[0]))
|
||
|
||
volatile uint8_t cap_flag = 0;
|
||
__attribute__((aligned(4))) uint32_t cap_buf[20];
|
||
|
||
#define CAP_BUF_LEN (20)
|
||
|
||
#define CAP_FREQ_MIN (2000U)
|
||
#define CAP_FREQ_MAX (10000U)
|
||
|
||
uint16_t valve_switch_on_freq = 6535;
|
||
uint16_t valve_switch_off_freq = 7508;
|
||
|
||
uint16_t valve_switch_freq = 0;
|
||
|
||
volatile uint8_t valve_switch_dect_flag = 0;
|
||
|
||
/**
|
||
* @description: 从帧起始符开始到校验码之前所有字节的和的模256，即各字节不计超过255的溢出值的二进制算术和。
|
||
* @param {uint8_t} *data
|
||
* @param {uint16_t} len
|
||
* @return {*}
|
||
*/
|
||
uint8_t CheckSum(const uint8_t *data, size_t len)
|
||
{
|
||
uint8_t sum = 0;
|
||
|
||
for (size_t i = 0; i < len; i++)
|
||
{
|
||
sum += data[i];
|
||
}
|
||
|
||
return sum;
|
||
}
|
||
|
||
void VavleDect_Start(void)
|
||
{
|
||
BSP_BlockSleep();
|
||
BSP_RequestBoost();
|
||
DelayMs(1);
|
||
|
||
tmos_memset(cap_buf, 0, sizeof(cap_buf));
|
||
|
||
TMR3_CapInit(FallEdge_To_FallEdge);
|
||
TMR3_CAPTimeoutCfg(GetSysClock() / 100); // 设置捕捉超时时间 10ms
|
||
|
||
// TMR3_CAPTimeoutCfg(0x3FFFFFF); // 设置捕捉超时时间
|
||
TMR3_DMACfg(ENABLE, (uint16_t)(uint32_t)&cap_buf[0], (uint16_t)(uint32_t)&cap_buf[CAP_BUF_LEN], Mode_Single);
|
||
TMR3_ITCfg(ENABLE, TMR0_3_IT_DMA_END); // 开启DMA完成中断
|
||
PFIC_EnableIRQ(TMR3_IRQn);
|
||
|
||
logDebug("VavleDect_Start");
|
||
}
|
||
|
||
// 一个数组中，去掉最大最小值，计算平均值
|
||
uint16_t VavleDect_CalFreq(uint16_t freq_arr[], uint8_t n)
|
||
{
|
||
if (freq_arr == NULL || n <= 2)
|
||
{
|
||
logError("数组太小或为空，无法去除最大最小值");
|
||
return 0;
|
||
}
|
||
|
||
uint16_t min, max;
|
||
double average = 0;
|
||
|
||
for (uint8_t i = 0; i < n; i++)
|
||
{
|
||
average += freq_arr[i];
|
||
if (i == 0)
|
||
{
|
||
min = freq_arr[i];
|
||
max = freq_arr[i];
|
||
}
|
||
min = ((min > freq_arr[i]) ? freq_arr[i] : min); // 软件滤波
|
||
max = ((max < freq_arr[i]) ? freq_arr[i] : max);
|
||
}
|
||
logDebug("min = %d, max = %d", min, max);
|
||
average = (average - min - max) / (CAP_BUF_LEN - 2);
|
||
|
||
return (uint16_t)average;
|
||
}
|
||
|
||
uint16_t VavleDect_GetFreq(void)
|
||
{
|
||
uint16_t freq = 0;
|
||
if (cap_flag == 0)
|
||
{
|
||
// TMR3_ITCfg(DISABLE, TMR0_3_IT_DMA_END); // 使用单次DMA功能+中断，注意完成后关闭此中断使能，否则会一直上报中断。
|
||
// TMR3_ClearITFlag(TMR0_3_IT_DMA_END); // 清除中断标志
|
||
logError("cap err");
|
||
return 0;
|
||
}
|
||
cap_flag = 0;
|
||
uint16_t t[CAP_BUF_LEN] = {0};
|
||
uint16_t f[CAP_BUF_LEN] = {0};
|
||
for (uint8_t i = 0; i < CAP_BUF_LEN; i++)
|
||
{
|
||
// logDebug("%08ld ", cap_buf[i] & 0x1ffffff); // 26bit, 最高位表示 高电平还是低电平
|
||
t[i] = ((cap_buf[i] & 0x1ffffff) * 1.0f) / FREQ_SYS * 1000000;
|
||
f[i] = 1000000 / t[i];
|
||
logDebug("T = %04d us, f = %04d Hz", t[i], f[i]);
|
||
BSP_UART1_TxLoop();
|
||
}
|
||
freq = VavleDect_CalFreq(&f[0], CAP_BUF_LEN);
|
||
|
||
return freq;
|
||
}
|
||
|
||
void VavleDect_Switch(void)
|
||
{
|
||
if (valve_switch_freq == 0)
|
||
{
|
||
gValveData.switch_status = kDisconnect;
|
||
logError("valve_switch_freq err");
|
||
return;
|
||
}
|
||
if (valve_switch_freq >= (valve_switch_off_freq - 100))
|
||
{
|
||
gValveData.switch_status = kOpened;
|
||
logDebug("valve_switch_on");
|
||
}
|
||
else if (valve_switch_freq <= (valve_switch_on_freq + 100))
|
||
{
|
||
gValveData.switch_status = kClosed;
|
||
logDebug("valve_switch_off");
|
||
}
|
||
}
|
||
|
||
|
||
#if 0
|
||
/**
|
||
* @description: 从接收缓冲区中获取一帧有效数据
|
||
* @param {TsFrameData} *pFrameData 主机帧
|
||
* @param {uint8_t} *p_src 接收缓冲区
|
||
* @param {uint16_t} src_len 接收缓冲区长度
|
||
* @return {*}
|
||
*/
|
||
TsFrameData *HR_GetFrameData(const uint8_t *p_src, const uint8_t src_len)
|
||
{
|
||
uint8_t data_field_len = 0;
|
||
uint8_t check_sum = 0;
|
||
|
||
TsFrameData *get_buffer = NULL;
|
||
|
||
for (uint8_t i = 0; i < src_len; i++)
|
||
{
|
||
// 找帧头
|
||
if (p_src[i] == FRAME_HEADER)
|
||
{
|
||
// 找数据长度
|
||
data_field_len = p_src[i + 2];
|
||
// 找帧尾
|
||
if (p_src[i + 2 + data_field_len + 2] == FRAME_TAIL)
|
||
{
|
||
check_sum = CheckSum(&p_src[i], (3 + data_field_len));
|
||
|
||
if (p_src[i + 2 + data_field_len + 1] == check_sum)
|
||
{
|
||
get_buffer = (TsFrameData *)tmos_msg_allocate(sizeof(TsFrameData) + sizeof(uint8_t) * data_field_len);
|
||
if (get_buffer == NULL)
|
||
{
|
||
logError("tmos_msg_allocate fail");
|
||
return NULL;
|
||
}
|
||
get_buffer->cmd = p_src[i + 1];
|
||
get_buffer->len = data_field_len;
|
||
|
||
if (data_field_len > 0)
|
||
{
|
||
tmos_memcmp(get_buffer->data, &p_src[i + 4], data_field_len);
|
||
}
|
||
logDebug("HR_GetDataFrame Success!");
|
||
|
||
return get_buffer;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
logError("HR_GetDataFrame Fail!");
|
||
|
||
return get_buffer;
|
||
}
|
||
#endif
|
||
|
||
TsFrameData *BSP_VAVLE_GetFrameData(uint8_t *data, uint8_t len)
|
||
{
|
||
int ret = 0;
|
||
uint16_t index = 0;
|
||
|
||
TsFrameData *get_buffer = NULL;
|
||
// 解析接收到的数据帧，先寻找AA开头，然后再找AA下一个字节，其代表了数据长度，然后找到代表长度的值的长度的下一位，其为校验码，校验码后为结束码0x55，
|
||
// 如果数据正确，则提取数据，不正确，则不处理
|
||
if (len < 4)
|
||
{ // 至少需要 4 个字节：起始码、长度、校验码、结束码
|
||
logError("数据帧长度不足");
|
||
// logHexDumpAll(data, len);
|
||
// return 1;
|
||
return NULL;
|
||
}
|
||
while (index < len && data[index] != FRAME_HEADER) // 寻找起始码 0xAA
|
||
{
|
||
index++;
|
||
}
|
||
if (index >= len - 3) // 不够空间容纳长度、校验码和结束码
|
||
{
|
||
logError("数据帧起始码错误");
|
||
// logHexDumpAll(data, len);
|
||
return NULL;
|
||
// return 2;
|
||
}
|
||
uint16_t data_len = data[index + 2]; // 读取数据长度
|
||
if (index + 3 + data_len + 1 >= len) // 检查数据长度是否合理 数据长度 + 校验码 + 结束码
|
||
{
|
||
logError("数据帧长度错误");
|
||
// logHexDumpAll(data, len);
|
||
return NULL;
|
||
// return 3;
|
||
}
|
||
|
||
uint8_t check_sum = data[index + 3 + data_len]; // 读取校验码
|
||
uint8_t calculated_sum = CheckSum(&data[index], data_len + 3); // 计算校验码
|
||
if (check_sum != calculated_sum)
|
||
{
|
||
logError("数据帧校验码错误 check_sum = %02X, calculated_sum = %02X", check_sum, calculated_sum);
|
||
// logHexDumpAll(data, len);
|
||
return NULL;
|
||
// return 4;
|
||
}
|
||
if (data[index + 3 + data_len + 1] != FRAME_TAIL) // 检查结束码
|
||
{
|
||
logError("数据帧结束码错误");
|
||
// logHexDumpAll(data, len);
|
||
return NULL;
|
||
// return 5;
|
||
}
|
||
logDebug("数据帧校验通过");
|
||
|
||
get_buffer = (TsFrameData *)tmos_msg_allocate(sizeof(TsFrameData) + sizeof(uint8_t) * data_len);
|
||
if (get_buffer == NULL)
|
||
{
|
||
logError("tmos_msg_allocate fail");
|
||
return NULL;
|
||
}
|
||
|
||
get_buffer->cmd = data[index + 1];
|
||
get_buffer->len = data_len;
|
||
// get_buffer->data = data;
|
||
|
||
if (data_len > 0)
|
||
{
|
||
tmos_memcpy(get_buffer->data, &data[index + 3], data_len);
|
||
return get_buffer;
|
||
}
|
||
|
||
// //有效数据长度
|
||
// size_t data_len = (data_len + 5);
|
||
// //到这一步说明数据没问题，将接收到的数据通过中心任务发送出去
|
||
// uint8_t *p_data;
|
||
// p_data = tmos_msg_allocate(data_len);
|
||
// if (p_data)
|
||
// {
|
||
// tmos_memcpy(p_data, data, data_len);
|
||
// tmos_msg_send(BtRxTaskId, p_data);
|
||
// tmos_start_task(BtRxTaskId, SYS_EVENT_MSG, 0);
|
||
// }
|
||
}
|
||
|
||
uint8_t GenerateRawFrame(TsRawFrameData *pRawData, uint8_t cmd, const uint8_t *p_src, uint8_t src_len)
|
||
{
|
||
// 0xAA CMD/DATA/ DATA_LEN (DATA) checksum 0x55
|
||
pRawData->len = src_len + 5;
|
||
|
||
tmos_memset(pRawData->buf, 0, sizeof(pRawData->buf));
|
||
|
||
pRawData->buf[0] = FRAME_HEADER;
|
||
pRawData->buf[1] = cmd;
|
||
pRawData->buf[2] = src_len;
|
||
|
||
tmos_memcpy(&pRawData->buf[3], p_src, src_len);
|
||
|
||
// 从帧起始符开始到校验码之前所有字节的和的模256
|
||
// ，即各字节不计超过255的溢出值的二进制算术和。
|
||
pRawData->buf[pRawData->len - 2] = CheckSum(&pRawData->buf[0], pRawData->len - 2);
|
||
pRawData->buf[pRawData->len - 1] = FRAME_TAIL;
|
||
|
||
// logHexDumpAll(&pRawData->buf[0], pRawData->len);
|
||
|
||
return 0;
|
||
}
|
||
|
||
void BSP_VALVE_Generate_UploadData(TsRawFrameData *pRawData)
|
||
{
|
||
GenerateRawFrame(pRawData, kCmdData, (uint8_t *)&gValveData, sizeof(gValveData));
|
||
// logHexDumpAll(&pRawData->buf[0], pRawData->len);
|
||
}
|
||
|
||
void BSP_VALVE_Generate_Data(TsRawFrameData *pRawData, uint8_t switch_status, uint8_t bat, int8_t temp, uint8_t humi)
|
||
{
|
||
TsValveData ValveData;
|
||
|
||
ValveData.switch_status = 0;
|
||
ValveData.temp = temp; // 阀门温度 有符号整数 25 ℃
|
||
|
||
ValveData.in_pressure = 0;
|
||
ValveData.out_pressure = 0;
|
||
ValveData.atm_pressure = 0;
|
||
|
||
ValveData.type = kTyq; // 阀门类型
|
||
ValveData.bat = bat; // 电池电压 30=3V,18=1.8V
|
||
ValveData.humi = humi; // 阀门湿度 %RH
|
||
|
||
ValveData.rssi = 0;
|
||
|
||
GenerateRawFrame(pRawData, kCmdData, (uint8_t *)&ValveData, sizeof(ValveData));
|
||
// logHexDumpAll(&pRawData->buf[0], pRawData->len);
|
||
}
|
||
|
||
void BSP_VALVE_Generate_ValveResponse(TsRawFrameData *pRawData, TeFrameCmd cmd, uint8_t status)
|
||
{
|
||
uint8_t data = 0;
|
||
data = status;
|
||
GenerateRawFrame(pRawData, cmd, &data, 1);
|
||
// logHexDumpAll(&pRawData->buf[0], pRawData->len);
|
||
}
|
||
|
||
void BSP_CloseValve(void)
|
||
{
|
||
|
||
DelayMs(100);
|
||
}
|
||
|
||
static void VAVLE_Task_ProcessTmosMsg(uint8_t *p_rev_msg)
|
||
{
|
||
if (p_rev_msg)
|
||
{
|
||
#if 1
|
||
TsFrameData *HostFrameData = BSP_VAVLE_GetFrameData(&p_rev_msg[1], p_rev_msg[0]);
|
||
if (HostFrameData != NULL)
|
||
{
|
||
// logHexDumpAll(&HostFrameData->data[0], HostFrameData->len); // 数据段
|
||
switch (HostFrameData->cmd)
|
||
{
|
||
case kCmdCfg:
|
||
// uint8_t data_buf[64] = {0};
|
||
// tmos_memset(data_buf, 0, sizeof(data_buf));
|
||
// 处理数据帧
|
||
logDebug("kCmdCfg");
|
||
break;
|
||
case kCmdCloseVavle:
|
||
logDebug("kCmdCloseVavle");
|
||
tmos_set_event(vavle_task_id, VAVLE_CLOSE_START_EVT);
|
||
|
||
// TODO:注意这里
|
||
|
||
// tmos_set_event(vavle_task_id, VAVLE_CLOSE_START_EVT);
|
||
// // TODO: 关阀动作
|
||
// peripheralChar4Notify((uint8_t *)&RawData.buf[0], RawData.len);
|
||
break;
|
||
|
||
case kCmdOpenVavle:
|
||
logDebug("kCmdOpenVavle");
|
||
|
||
// BSP_UART1_TxLoop();
|
||
break;
|
||
default:
|
||
logError("无效的命令");
|
||
// logHexDumpAll(data, len);
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
logError("数据帧解析失败");
|
||
}
|
||
tmos_msg_deallocate((uint8_t *)HostFrameData);
|
||
HostFrameData = NULL;
|
||
#endif
|
||
}
|
||
else
|
||
{
|
||
logError("pMsg is NULL");
|
||
}
|
||
}
|
||
|
||
// task的event处理回调函数,需要在注册task时候,传进去
|
||
static uint16_t VAVLE_Task_ProcessEvent(uint8_t task_id, uint16_t events)
|
||
{
|
||
if (events & SYS_EVENT_MSG)
|
||
{
|
||
uint8_t *p_rev_msg;
|
||
if ((p_rev_msg = tmos_msg_receive(vavle_task_id)) != NULL)
|
||
{
|
||
VAVLE_Task_ProcessTmosMsg(p_rev_msg);
|
||
// Release the TMOS message
|
||
tmos_msg_deallocate(p_rev_msg);
|
||
}
|
||
// return unprocessed events
|
||
return (events ^ SYS_EVENT_MSG);
|
||
}
|
||
if (events & VAVLE_RX_DATA_EVT)
|
||
{
|
||
logDebug("VAVLE_RX_DATA_EVT");
|
||
|
||
return (events ^ VAVLE_RX_DATA_EVT);
|
||
}
|
||
if (events & VAVLE_TX_DATA_EVT)
|
||
{
|
||
logDebug("VAVLE_TX_DATA_EVT");
|
||
|
||
return (events ^ VAVLE_TX_DATA_EVT);
|
||
}
|
||
if (events & VAVLE_CLOSE_START_EVT)
|
||
{
|
||
logDebug("VAVLE_CLOSE_START_EVT");
|
||
|
||
BSP_BlockSleep();
|
||
BSP_RequestBoost();
|
||
DelayUs(200);
|
||
|
||
// EMV_CHARGE
|
||
// EMV_CHARGE_EN;
|
||
// DelayUs(500);
|
||
// EMV_CHARGE_OFF_DEINIT;
|
||
// DelayUs(200);
|
||
|
||
// DelayUs(500);
|
||
// EMV_CHARGE_OFF_DEINIT;
|
||
// DelayUs(200);
|
||
|
||
EMV_CHARGE_EN;
|
||
|
||
logDebug("EMV_CHARGE_EN");
|
||
|
||
// 开始一个定时event,1s后产生,当前语句只会产生一次event
|
||
// 可以在event产生后去开启event,可以是别的task的,也可以是当前task的event
|
||
tmos_start_task(vavle_task_id, VAVLE_CLOSE_ACTION_EVT, MS1_TO_SYSTEM_TIME(CHARGE_TIME_MS));
|
||
|
||
return (events ^ VAVLE_CLOSE_START_EVT);
|
||
}
|
||
if (events & VAVLE_CLOSE_ACTION_EVT)
|
||
{
|
||
BSP_BlockSleep();
|
||
BSP_RequestBoost();
|
||
logDebug("VAVLE_CLOSE_ACTION_EVT");
|
||
|
||
BOOST_EN;
|
||
// EMV_CHARGE_EN;
|
||
// 关阀动作,一定要先关充电的，防止其他12V用电
|
||
EMV_CHARGE_OFF_DEINIT;
|
||
|
||
BEEP_ON;
|
||
|
||
logDebug("EMV_CHARGE_OFF_DEINIT");
|
||
|
||
// DelayMs(10);
|
||
|
||
// EMV_CTRL
|
||
EMV_ON;
|
||
// DelayMs(50);
|
||
|
||
// {BEEP_OFF_DEINIT;
|
||
|
||
// EMV_CHARGE_OFF_DEINIT;
|
||
// EMV_OFF_DEINIT;
|
||
|
||
// BSP_NoNeedBoost();
|
||
|
||
// gValveData.switch_status = kClosed;
|
||
|
||
// tmos_memset(&RelyData, 0, sizeof(RelyData));
|
||
// BSP_VALVE_Generate_ValveResponse(&RelyData, kCmdCloseVavle, 1);
|
||
|
||
// tmos_set_event(Peripheral_TaskID, SBP_REPLY_CMD_EVT);}
|
||
|
||
logDebug("EMV_ON");
|
||
tmos_start_task(vavle_task_id, VAVLE_CLOSE_END_EVT, MS1_TO_SYSTEM_TIME(100));
|
||
|
||
return (events ^ VAVLE_CLOSE_ACTION_EVT);
|
||
}
|
||
if (events & VAVLE_CLOSE_END_EVT)
|
||
{
|
||
BEEP_OFF_DEINIT;
|
||
|
||
EMV_CHARGE_OFF_DEINIT;
|
||
EMV_OFF_DEINIT;
|
||
|
||
LED_ALL_OFF_DEINIT;
|
||
|
||
BSP_NoNeedBoost();
|
||
|
||
gValveData.switch_status = kClosed;
|
||
|
||
tmos_memset(&RelyData, 0, sizeof(RelyData));
|
||
BSP_VALVE_Generate_ValveResponse(&RelyData, kCmdCloseVavle, 1);
|
||
|
||
tmos_set_event(Peripheral_TaskID, SBP_REPLY_CMD_EVT);
|
||
|
||
logDebug("VAVLE_CLOSE_END_EVT");
|
||
return (events ^ VAVLE_CLOSE_END_EVT);
|
||
}
|
||
// 开始测量电磁铁电感
|
||
if (events & VAVLE_DECT_SWITCH_START_EVT)
|
||
{
|
||
valve_switch_dect_flag = 0;
|
||
logDebug("VAVLE_DECT_SWITCH_START_EVT");
|
||
VavleDect_Start();
|
||
tmos_start_task(vavle_task_id, VAVLE_DECT_SWITCH_END_EVT, MS1_TO_SYSTEM_TIME(12));
|
||
return (events ^ VAVLE_DECT_SWITCH_START_EVT);
|
||
}
|
||
if (events & VAVLE_DECT_SWITCH_END_EVT)
|
||
{
|
||
logDebug("VAVLE_DECT_SWITCH_END_EVT");
|
||
|
||
valve_switch_freq = VavleDect_GetFreq();
|
||
logDebug("valve_switch_freq = 04%d Hz", valve_switch_freq);
|
||
VavleDect_Switch();
|
||
valve_switch_dect_flag = 1;
|
||
|
||
// logDebug("LED显示状态");
|
||
// // tmos_set_event(led_task_id, LED_SHOW_START_EVT);
|
||
// BSP_BlockSleep();
|
||
// BSP_RequestBoost();
|
||
// DelayMs(1);
|
||
// ShowLed();
|
||
|
||
return (events ^ VAVLE_DECT_SWITCH_END_EVT);
|
||
}
|
||
if (events & VAVLE_DECT_SWITCH_CALIB_EVT)
|
||
{
|
||
logDebug("VAVLE_DECT_SWITCH_CALIB_EVT");
|
||
|
||
return (events ^ VAVLE_DECT_SWITCH_CALIB_EVT);
|
||
}
|
||
|
||
if (events & VAVLE_LOW_VBAT_ALARM_EVT)
|
||
{
|
||
logDebug("VAVLE_LOW_VBAT_ALARM_EVT");
|
||
|
||
// BSP_BlockSleep();
|
||
// BSP_RequestBoost();
|
||
|
||
// LED_ALL_OFF_DEINIT;
|
||
// LED_Y_ON;
|
||
|
||
// BEEP_ON;
|
||
|
||
// DelayMs(10);
|
||
|
||
// LED_ALL_OFF_DEINIT;
|
||
// BEEP_OFF_DEINIT;
|
||
|
||
// BSP_NoNeedBoost();
|
||
// BSP_RequestSleep();
|
||
|
||
// tmos_set_event(vavle_task_id, VAVLE_CLOSE_START_EVT);
|
||
|
||
// tmos_start_task(vavle_task_id, VAVLE_LOW_VBAT_ALARM_EVT, MS1_TO_SYSTEM_TIME(VALVE_LOW_VBAT_ALARM_PERIOD_MS));
|
||
|
||
return (events ^ VAVLE_LOW_VBAT_ALARM_EVT);
|
||
}
|
||
if (events & VAVLE_LOOP_DECT_EVT)
|
||
{
|
||
logDebug("VAVLE_LOOP_DECT_EVT");
|
||
|
||
gValveData.bat = BSP_ReadVbat();
|
||
|
||
// 电压过低就关阀
|
||
if (gValveData.bat <= LOW_VABAT_CLOSE_VALUE)
|
||
{
|
||
gValveData.switch_status = kClosed;
|
||
tmos_set_event(vavle_task_id, VAVLE_CLOSE_START_EVT);
|
||
}
|
||
else if (gValveData.bat <= LOW_VABAT_ALARM_VALUE)
|
||
{
|
||
tmos_set_event(vavle_task_id, VAVLE_LOW_VBAT_ALARM_EVT);
|
||
}
|
||
tmos_start_task(vavle_task_id, VAVLE_LOOP_DECT_EVT, MS1_TO_SYSTEM_TIME(VALVE_DECT_PERIOD_MS));
|
||
|
||
return (events ^ VAVLE_LOOP_DECT_EVT);
|
||
}
|
||
|
||
// Discard unknown events
|
||
return 0;
|
||
}
|
||
|
||
void BSP_VAVLE_Init(void)
|
||
{
|
||
vavle_task_id = TMOS_ProcessEventRegister(VAVLE_Task_ProcessEvent);
|
||
|
||
tmos_memset(&gValveData, 0, sizeof(gValveData));
|
||
|
||
gValveData.switch_status = kClosed;
|
||
gValveData.temp = -100;
|
||
gValveData.in_pressure = 0;
|
||
gValveData.out_pressure = 0;
|
||
gValveData.atm_pressure = 0;
|
||
|
||
gValveData.type = kTyq;
|
||
gValveData.bat = BSP_ReadVbat();
|
||
|
||
// //立即开始一个event
|
||
// tmos_set_event(vavle_task_id, VAVLE_RX_DATA_EVT);
|
||
|
||
// PA2
|
||
/* 定时器3，CAP捕捉， */
|
||
GPIOA_ResetBits(GPIO_Pin_2);
|
||
GPIOA_ModeCfg(GPIO_Pin_2, GPIO_ModeIN_PU);
|
||
|
||
// TMR3功能引脚映射选择位：
|
||
// 1：TMR3_/PWM3_/CAP3_映射到PA[2]；
|
||
R16_PIN_ALTERNATE |= (1 << 3);
|
||
|
||
// TMR3_CapInit(FallEdge_To_FallEdge);
|
||
// // (1 / 62.4MHz) * 2的26次方 = 0.01602564102564102564102564102564 us * 67108864 约等于 1.0754625641025641025641025641025 S
|
||
// // TMR3_CAPTimeoutCfg(FREQ_SYS ); // 设置捕捉超时时间
|
||
// TMR3_CAPTimeoutCfg(GetSysClock() / 100); // 设置捕捉超时时间 10ms
|
||
|
||
tmos_start_task(vavle_task_id, VAVLE_LOOP_DECT_EVT, MS1_TO_SYSTEM_TIME(VALVE_DECT_PERIOD_MS));
|
||
|
||
logInfo("BSP_Valve_Init");
|
||
}
|
||
|
||
|
||
|
||
/*********************************************************************
|
||
* @fn TMR3_IRQHandler
|
||
*
|
||
* @brief TMR3中断函数
|
||
*
|
||
* @return none
|
||
*/
|
||
__INTERRUPT
|
||
__HIGH_CODE
|
||
void TMR3_IRQHandler(void) // TMR3 定时中断
|
||
{
|
||
if (TMR3_GetITFlag(TMR0_3_IT_DMA_END))
|
||
{
|
||
TMR3_ITCfg(DISABLE, TMR0_3_IT_DMA_END); // 使用单次DMA功能+中断，注意完成后关闭此中断使能，否则会一直上报中断。
|
||
TMR3_ClearITFlag(TMR0_3_IT_DMA_END); // 清除中断标志
|
||
cap_flag = 1;
|
||
}
|
||
}
|