因为疫情，最近在做红外温度检测设备，一些设备组合控制逻辑
灯控及蜂鸣器驱动
支持循环响，响多少次，响多少秒
/*
* FILE: misc_drv.c
*
* Created on: 2020/2/23
*
* Author: aron566
*
* DESCRIPTION:--
*/
#ifdef __cplusplus //use C compiler
extern "C" {
#endif
#include "misc_drv.h"
#include "relay_control.h"
#include "modbus_reg.h"
Misc_device_t light_relay_device[LAMP_RELAY_DEVICE_MAX] =
{
{
.mode = RUN_DELAY, //运行模式--设置
.set_run_time = 1, //运行时间--设置
.set_stop_time = 1, //停止时间--auto
.is_active = 0, //是否激活--设置
.is_run_flag = 0, //不是运行态
.start = fault_LED_on, //执行开启--初始化
.stop = fault_LED_off //执行关闭--初始化
},
{
.mode = RUN_DELAY, //运行模式--设置
.set_run_time = 1, //运行时间--设置
.set_stop_time = 1, //停止时间--auto
.is_active = 0, //是否激活--设置
.is_run_flag = 0, //不是运行态
.start = Relay1_Start_Out, //执行开启--初始化
.stop = Relay1_Stop_Out //执行关闭--初始化
},
{
.mode = RUN_DELAY, //运行模式--设置
.set_run_time = 1, //运行时间--设置
.set_stop_time = 1, //停止时间--auto
.is_active = 0, //是否激活--设置
.is_run_flag = 0, //不是运行态
.start = Relay2_Start_Out, //执行开启--初始化
.stop = Relay2_Stop_Out //执行关闭--初始化
}
};
start_beep_mode_t beep_device[BEEP_DEVICE_MAX] =
{
{
.mode = ONCE_MODE,
.statrt_times = 1, //运行次数
.interval_ms = 500, //间隔时间
.run_time_ms = 0, //运行时间
.is_active = 0, //是否激活
.transpose = 0, //翻转标志
.start = beep1_on, //执行开启
.stop = beep1_off //执行关闭
},
{
.mode = ALWAYS_ON_MODE,
.statrt_times = 1, //运行次数
.interval_ms = 500, //间隔时间
.run_time_ms = 0, //运行时间
.is_active = 0, //是否激活
.transpose = 0, //翻转标志
.start = beep2_on, //执行开启
.stop = beep2_off //执行关闭
}
};
/*启动按照模式启动蜂鸣器*/
void Start_Beep_out_loop(start_beep_mode_t *beep_device)
{
for(uint8_t index = 0; index < BEEP_DEVICE_MAX;index++)
{
if(beep_device[index].is_active == 1)
{
//启动对应beep
Real_start_beep(index);
if(beep_device[index].statrt_times == 0)
{
//取消激活
beep_device[index].is_active = 0;
//恢复参数
Init_beep_par(index);
}
}
else
{
//停止运行
Real_stop_beep(index);
}
}
}
void Real_start_beep(uint8_t index)
{
beep_device[index].run_time_ms++;
if(!(beep_device[index].run_time_ms % beep_device[index].interval_ms))
{
//反转电平
if(beep_device[index].mode != ALWAYS_ON_MODE)
{
beep_device[index].transpose ^= 1;
//每切换到运行状态，运行次数减小
if(beep_device[index].transpose == 0)
{
//运行次数--
beep_device[index].statrt_times--;
}
}
}
if(beep_device[index].transpose == 0)
{
beep_device[index].start();
}
else
{
beep_device[index].stop();
}
}
void Real_stop_beep(uint8_t index)
{
beep_device[index].is_active = 0;
beep_device[index].stop();
}
/*设置运行间隔时间*/
void Set_run_interval_ms(uint8_t index ,uint32_t interval_ms)
{
beep_device[index].interval_ms = interval_ms;
}
/*设置运行次数 == 运行次数*间隔时间 = 运行时间*/
void Set_run_time(uint8_t index ,uint32_t time_ms)
{
beep_device[index].user_start_times = (time_ms/(beep_device[index].interval_ms*2));
beep_device[index].user_start_times = (beep_device[index].user_start_times>0)?beep_device[index].user_start_times:1;
}
void Init_beep_par(uint8_t index)
{
switch(beep_device[index].mode)
{
case ONCE_MODE:
beep_device[index].statrt_times = 1;
break;
case THREE_TIMES_MODE:
beep_device[index].statrt_times = 3;
break;
case ALWAYS_ON_MODE:
beep_device[index].statrt_times = 0xFFFF;
break;
case SPECIFIED_MODE: //指定参数
beep_device[index].statrt_times = beep_device[index].user_start_times;
break;
}
beep_device[index].transpose = 0;
beep_device[index].run_time_ms = 0;
}
void Set_beep_run_mode(uint8_t index ,start_mode_t mode)
{
beep_device[index].mode = mode;
Init_beep_par(index);
}
void Enable_beep_out(uint8_t index ,start_mode_t mode)
{
beep_device[index].is_active = 1;
//更新参数
if(mode != beep_device[index].mode)
{
beep_device[index].mode = mode;
Init_beep_par(index);
}
}
void Disable_beep_out(uint8_t index)
{
beep_device[index].is_active = 0;
Init_beep_par(index);
}
/* 轮询遥控器复位报警是否有效
*
* 参数：遥控器当前使能状态
*
* 返回：1有效 0无效
*/
uint8_t Get_Remote_Reset_Alarm_Button_State(void)
{
if(device_v_info.set_remote_ctl_active == 1)
{
if(device_v_info.command_val == 2)
{
device_v_info.command_val = 0;
return 1;
}
}
return 0;
}
/* 轮询复位报警按钮状态
*
* 按键设置 - 是否启用
*
* 返回 1代表有效 0无效
*/
uint8_t Get_Reset_Alarm_Button_State(uint16_t setting)
{
static uint16_t s_time = 0;
//检测按钮状态
if(Key_State_Check(Button_GPIO_Port ,Button_Pin ,GPIO_PIN_RESET ,KEY_DELAY_DEFAULT_VAL ,&s_time))
{
//按键终止报警有效
if(setting == 0)
{
return 1;
}
}
return 0;
}
/*
* 每1ms检测按键按下事件处理 ,需将方法1ms调用一次
* - - - - - - - - - - -- - - -----
* 参数：端口号 引脚号 需检测的状态 检测标准时间（消抖时间ms）|_全局或静态数据保存区指针赋值0_|time
*
* 返回：1状态正确 0状态错误
*/
uint8_t Key_State_Check(GPIO_TypeDef* GPIOx ,uint16_t GPIO_Pin
,GPIO_PinState state ,uint16_t check_time
,uint16_t *static_time)
{
if(state == HAL_GPIO_ReadPin(GPIOx, GPIO_Pin))//读取按键状态
{
//消除抖动
(*static_time)++;
if(*static_time >= check_time)
{
*static_time = check_time;
return 1;
}
}
else
{
*static_time = 0;
return 0;
}
return 0;
}
/*
* 轮询定时运行设备 /ms
*/
void Start_Misc_device_loop(Misc_device_t *device)
{
for(uint8_t index = 0;index < LAMP_RELAY_DEVICE_MAX;index++)
{
if(device[index].is_active != 0)
{
//轮询已启动的设备
Run_Misc_Task_execute(&device[index]);
}
else
{
Stop_Misc_task(&device[index]);
}
}
}
/*
* 运行指定时间长度 任务放入 1ms 轮询执行
*
* 参数：启动任务 停止任务 运行时间set_run_time
*/
void Run_Misc_Task_execute(Misc_device_t *device)
{
//持续计算时间
if(device->mode != ALWAYS_ON)
{
device->set_stop_time++;
}
if(device->set_stop_time >= device->set_run_time)
{
device->set_stop_time = 0;
if(device->mode != ALWAYS_ON)
{
device->is_active = 0;
device->is_run_flag = 0;
device->stop();
}
}
else
{
if(device->is_run_flag == 0)
{
device->is_run_flag = 1;
device->start();
}
}
}
void Stop_Misc_task(Misc_device_t *device)
{
device->is_active = 0; //停止运行
device->is_run_flag = 0; //初始化运行标志
device->set_stop_time = 0;//初始化参数
}
void Enable_Misc_device(uint8_t index ,Misc_Run_mode_t mode ,uint32_t run_time)
{
if(mode != light_relay_device[index].mode)
{
light_relay_device[index].mode = mode;
}
if(light_relay_device[index].mode == RUN_DELAY)
{
if(light_relay_device[index].is_active == 0)
{
light_relay_device[index].is_active = 1; //使能轮询
light_relay_device[index].is_run_flag = 0; //初始化运行标志
light_relay_device[index].set_stop_time = 0; //初始化参数
light_relay_device[index].set_run_time = run_time; //设置运行时间ms
}
}
else if(light_relay_device[index].mode == ALWAYS_ON)
{
light_relay_device[index].is_active = 1; //使能轮询
light_relay_device[index].is_run_flag = 0; //初始化运行标志
light_relay_device[index].set_stop_time = 0; //初始化参数
light_relay_device[index].set_run_time = 0xFFFF; //最大化
}
}
void Set_Misc_device_run_time(uint8_t index ,uint32_t time_ms)
{
light_relay_device[index].set_run_time = time_ms;
}
void Disable_Misc_device(uint8_t index)
{
light_relay_device[index].is_active = 0;//禁用轮询
light_relay_device[index].stop(); //stop now
}
/*
* 1Khz 每1ms调用
*
* 参数：全局或静态 device参数
*/
void Simulation_Pwm_Control(PWM_Control_t *device)
{
//依据总运行时间，pwm是否正在运行
if(device->total_runn_time == 0)
{
device->total_runn_time = device->total_time;
device->time_cnt = 0;
}
else
{
device->time_cnt++;
device->total_runn_time--;
if((device->time_cnt % device->run_time) && device->transpose == 0)//属于运行时间范围内，则运行（高电平时间）
{
device->start_operate();//run;
}
else
{
device->transpose = 1;//高电平周期到，反转电平
}
if((device->time_cnt % device->run_time) && device->transpose == 1)
{
device->stop_operate();//stop
}
else
{
device->transpose = 0;//低电平周期到，反转电平
}
}
}
/*继电器控制接口*/
void Relay1_Stop_Out(void)
{
stop_relay(RELAY_1);
}
void Relay2_Stop_Out(void)
{
stop_relay(RELAY_2);
}
void Relay1_Start_Out(void)
{
start_relay(RELAY_1);
}
void Relay2_Start_Out(void)
{
start_relay(RELAY_2);
}
#ifdef __cplusplus //end extern c
}
#endif
头文件
/*
* FILE: misc_drv.h
*
* Created on: 2020/2/23
*
* Author: aron66
*
* DESCRIPTION:--
*/
#ifndef MISC_DRV_H
#define MISC_DRV_H
#ifdef __cplusplus //use C compiler
extern "C" {
#endif
#include <stdint.h>
#include "peripheral.h"
#include "misc_task.h"
#define BEEP_DEVICE_MAX 2U
#define LAMP_RELAY_DEVICE_MAX 3U
typedef void (*p_misc_process)(void);
/**********************************pwm仿真输出*********************************/
typedef struct{
uint32_t time_cnt;
uint8_t transpose;
uint32_t total_runn_time;
uint32_t run_time;
uint32_t total_time;
p_misc_process start_operate;
p_misc_process stop_operate;
}PWM_Control_t;
/*****************运行指定次数指定间隔 or 长久运行****************************/
typedef enum
{
ONCE_MODE = 0,
THREE_TIMES_MODE,
ALWAYS_ON_MODE,
SPECIFIED_MODE
}start_mode_t;
typedef struct
{
start_mode_t mode; //启动模式--设置
volatile uint32_t statrt_times; //运行次数--auto
volatile uint32_t user_start_times;//用户自定义运行时间
volatile uint32_t interval_ms; //间隔时间--auto
volatile uint32_t run_time_ms; //运行时间--auto
volatile uint8_t transpose; //翻转标志--auto
volatile uint8_t is_active; //是否激活--设置
volatile p_misc_process start; //执行开启--初始化
volatile p_misc_process stop; //执行关闭--初始化
}start_beep_mode_t;
/*****************运行一段时间自动关闭 or 长久运行****************************/
typedef enum
{
ALWAYS_ON = 0,
RUN_DELAY
}Misc_Run_mode_t;
typedef struct
{
Misc_Run_mode_t mode; //运行模式--设置
uint32_t set_run_time; //运行时间--设置
uint32_t set_stop_time; //停止时间--auto
uint8_t is_active; //是否激活--设置
uint8_t is_run_flag; //是运行态--auto
p_misc_process start; //执行开启--初始化
p_misc_process stop; //执行关闭--初始化
}Misc_device_t;
extern start_beep_mode_t beep_device[];
/***************遥控器报警消除检测*************/
uint8_t Get_Remote_Reset_Alarm_Button_State(void);
/******************按键检测驱动****************/
uint8_t Key_State_Check(GPIO_TypeDef* GPIOx ,uint16_t GPIO_Pin ,GPIO_PinState state
,uint16_t check_time ,uint16_t *static_time);
uint8_t Get_Reset_Alarm_Button_State(uint16_t setting);
/******************定时任务******************/
extern Misc_device_t light_relay_device[];
void Start_Misc_device_loop(Misc_device_t *device);
void Run_Misc_Task_execute(Misc_device_t *device);
void Enable_Misc_device(uint8_t index ,Misc_Run_mode_t mode ,uint32_t run_time);
void Set_Misc_device_run_time(uint8_t index ,uint32_t time_ms);
void Disable_Misc_device(uint8_t index);
void Stop_Misc_task(Misc_device_t *device);
/******************模拟pwm******************/
void Simulation_Pwm_Control(PWM_Control_t *device);
/******************beep控制******************/
void Start_Beep_out_loop(start_beep_mode_t *beep_device);
void Real_start_beep(uint8_t index);
void Real_stop_beep(uint8_t index);
void Init_beep_par(uint8_t index);
void Set_beep_run_mode(uint8_t index ,start_mode_t mode);
void Set_run_interval_ms(uint8_t index ,uint32_t interval_ms);//设置运行间隔
void Set_run_time(uint8_t index ,uint32_t time_ms);
void Enable_beep_out(uint8_t index ,start_mode_t mode);/*依据参数开启输出*/
void Disable_beep_out(uint8_t index);
void Relay1_Stop_Out(void);
void Relay2_Stop_Out(void);
void Relay1_Start_Out(void);
void Relay2_Start_Out(void);
#ifdef __cplusplus //end extern c
}
#endif
#endif
按键消抖使用例子
/* 轮询复位报警按钮状态
*
* 按键设置 - 是否启用
*
* 返回 1代表有效 0无效
*/
static uint8_t Get_Reset_Alarm_Button_State(uint16_t setting)
{
static uint16_t s_time = 0;
//检测按钮状态
if(Key_State_Check(Button_GPIO_Port ,Button_Pin ,GPIO_PIN_RESET ,KEY_DELAY_DEFAULT_VAL ,&s_time))
{
//按键终止报警有效
if(setting == 0)
{
return 1;
}
}
return 0;
}
蜂鸣器控制列子
//任务中，检测事件，设置相关报警，Start_Beep_out_loop循环1ms检测一次
//Start_Misc_device_loop1ms检测一次
for(;;)
{
Check_Complete_Alarm();
Check_Temperature_Is_Alarm(1);
alarm_task_excute();
Start_Beep_out_loop(beep_device);
Start_Misc_device_loop(light_relay_device);
osDelay(1);
}
/*其他人数根据要求启动设备*/
void alarm_task_excute(void)
{
static uint16_t last_event = 0;
//检测复位按键状态
uint8_t button_state = Get_Reset_Alarm_Button_State(0);
//获取实时人员检测状态
People_State_t state = Check_People_Is_Exist();
if(button_state) //is manual stop
{
Disable_beep_out(0);
Disable_beep_out(1); //is manual
Disable_Misc_device(0);
Disable_Misc_device(1);
Disable_Misc_device(2);
alarm_task_event = 0;
}
if(state == PEOPLE_LEAVE)
{
normal_LED_off(); //人员离开必须关闭正常指示灯
}
if(alarm_task_event & SET_NORMAL_EVENT)
{
normal_LED_on(); //开绿灯 leave stop
if(last_event == SET_NO_CHECK_EVENT)
{
Disable_beep_out(0); //the last event is no check关闭板载蜂鸣器
}
Enable_beep_out(0 ,ONCE_MODE);//开板载蜂鸣器 滴一声 auto stop
if(device_v_info.set_next_test_auto_stop != 0 ||
last_event != SET_HEAT_ALARM_EVENT) //is new test device stop
{
Disable_Misc_device(0); //is new test stop 关红灯
Disable_beep_out(1); //is new test stop 关外报
}
last_event = SET_NORMAL_EVENT;
alarm_task_event &= ~SET_NORMAL_EVENT;
}
/*漏测和测到发热：外接红灯亮、外接声报警响、继电器动作，
收到按键确认后，红灯灭、声报警停、继电器恢复*/
if(alarm_task_event & SET_HEAT_ALARM_EVENT)
{
last_event = SET_HEAT_ALARM_EVENT;
if(device_v_info.set_auto_stop_s != 0) //指定运行时间
{
Set_run_time(1 ,device_v_info.set_auto_stop_s*1000);
Enable_beep_out(1 ,SPECIFIED_MODE);//外部蜂鸣器 滴三声 auto stop
Enable_Misc_device(0 ,RUN_DELAY ,device_v_info.set_auto_stop_s*1000); //开红灯 manual stop
Enable_Misc_device(1 ,RUN_DELAY ,device_v_info.set_auto_stop_s*1000); //开继电器1 manual stop
Enable_Misc_device(2 ,RUN_DELAY ,device_v_info.set_auto_stop_s*1000); //开继电器2 manual stop
alarm_task_event &= ~SET_HEAT_ALARM_EVENT;
}
else
{
Set_run_interval_ms(1 ,500);
Enable_beep_out(1 ,THREE_TIMES_MODE); //外部蜂鸣器 持续滴三声 manual stop
Enable_Misc_device(0 ,ALWAYS_ON ,0); //开红灯 manual stop
Enable_Misc_device(1 ,ALWAYS_ON ,0); //开继电器1 manual stop
Enable_Misc_device(2 ,ALWAYS_ON ,0); //开继电器2 manual stop
}
}
if(alarm_task_event & SET_NO_CHECK_EVENT)
{
last_event = SET_NO_CHECK_EVENT;
// Enable_beep_out(1 ,ALWAYS_ON_MODE); //外部蜂鸣器 持续响 new test stop
Set_run_time(0 ,30*1000); //板载蜂鸣器 持续响 30s new test stop
Enable_beep_out(0 ,SPECIFIED_MODE);
// Enable_Misc_device(0 ,ALWAYS_ON ,0); //开红灯 new test stop
alarm_task_event &= ~SET_NO_CHECK_EVENT;
}
}
数据处理校验计算类
/*
* 计算连续数据中，中位值 最大值 平均值 最小值
*
* 参数：返回数据类型 数据地址 数据长度
*
* 返回：依据设置mode 中位值 最大值 平均值 最小值
*/
uint16_t Calc_Tmp(Calc_Mode_t mode ,uint16_t *data ,uint16_t len)
{
uint16_t ret = 0;
uint8_t index = 0;
uint16_t i,j,temp;
//插入
for(i = 1;i < len ;i++) //从数组元素1开始
{
temp = data[i]; //将当前数组元素的值给临时变量temp
for( j = i ;j > 0 && data[j-1] > temp ;j--) //将当前的数组元素号给J 满足j>0且当前元素的前一个元素 大于当前值。则
{
data[j] = data[j-1];//将大值给
}
data[j] = temp;
}
switch(mode)
{
case MEDIAN_VALUE_MODE:
//查询中位值
if(mode == MEDIAN_VALUE_MODE)
{
if(len % 2)
{
index = (len-1) /2;
ret = data[index];
}
else
{
index = len /2;
ret = (data[index]+data[index-1])/2;
}
}
return ret;
case MAX_VALUE_MODE:
//查询最大值
return data[len-1];
case AVERAGE_VALUE_MODE:
//查询平均值
ret = data[0];
for(uint16_t index = 1;index < len;index++)
{
ret = (ret+data[index])/2;
}
return ret;
case MIN_VALUE_MODE:
//查询最小值
return data[0];
default:
return 0;
}
}
/*
* 计算连续数据中，最大值 最小值
*
* 参数：返回数据类型 数据地址 数据长度
*
* 返回：依据设置mode 最大值 最小值
*/
uint16_t Calc2_Tmp(Calc_Mode_t mode ,uint16_t *data ,uint16_t len)
{
uint16_t ret = data[0];
uint8_t index = 0;
switch(mode)
{
case MEDIAN_VALUE_MODE:
//查询中位值
if(mode == MEDIAN_VALUE_MODE)
{
if(len % 2)
{
index = (len-1) /2;
ret = data[index];
}
else
{
index = len /2;
ret = (data[index]+data[index-1])/2;
}
}
return ret;
case MAX_VALUE_MODE:
//查询最大值
for(uint16_t index = 1;index < len;index++)
{
if(data[index] > ret)
{
ret = data[index];
}
}
return ret;
case AVERAGE_VALUE_MODE:
//查询平均值
for(uint16_t index = 1;index < len;index++)
{
ret = (ret+data[index])/2;
}
return ret;
case MIN_VALUE_MODE:
//查询最小值
for(uint16_t index = 1;index < len;index++)
{
if(data[index] < ret)
{
ret = data[index];
}
}
return ret;
default:
return 0;
}
}
/* 检测温度值是否整定完毕
*
* 参数：数据地址 数据长度 标准最小值 极限值
* 返回：1数据稳定 0数据不稳定
*/
uint8_t Check_Data_Is_Ture(uint16_t *data ,uint16_t len ,uint16_t standrad_min
,uint16_t standrad_max)
{
uint16_t max_val = 0;
uint16_t min_val = 0;
max_val = Calc_Tmp(MAX_VALUE_MODE ,data ,len);
min_val = Calc_Tmp(MIN_VALUE_MODE ,data ,len);
//最大最小值相同
if(max_val == min_val && min_val > standrad_min && min_val < standrad_max)
{
printf("*******1*******\n");
return 1;
}
else
{
return 0;
}
}
//判断温度稳定，在人体范围内的温度，且最大最小偏差<0.1度
uint16_t Check2_Data_Is_Ture(uint16_t *data ,uint16_t len ,uint16_t standrad_min
,uint16_t standrad_max)
{
uint16_t max_val = 0;
uint16_t min_val = 0;
max_val = Calc2_Tmp(MAX_VALUE_MODE ,data ,len);
min_val = Calc2_Tmp(MIN_VALUE_MODE ,data ,len);
// min_val = Calc_Tmp(MEDIAN_VALUE_MODE ,data ,len);
//最大最小值相同
if(((max_val - min_val) <= 5) && min_val > standrad_min && min_val < standrad_max)
{
return max_val;
}
else
{
return 0;
}
}
/* 代入最新稳点温度值，判断数据变化是否>=standrad_val
*
* 返回：符合>20返回
*/
uint16_t Check_Tmp_Is_Modified(uint8_t new_test_flag ,uint16_t current_tmp ,uint16_t standrad_val)
{
static uint16_t last_tmp = 0;
if(new_test_flag == 1)
{
//当前测量温度不同于上次温度，且大于上次温度
if(current_tmp > last_tmp && (current_tmp - last_tmp) >= standrad_val)
{
last_tmp = current_tmp; //更新大值返回
return last_tmp;
}
}
else
{
last_tmp = 0;
return last_tmp;
}
return last_tmp;
}
/* 16bit和校验 -判断连续len个数据和 ，CL在前 CH在后 判断与 len len+1位置的数据是否一致
*
* 参数：连续数据地址的首地址 校验的数据长度
*
* 返回：校验结果：1 正确 0错误
*/
uint8_t Check_16bitData_Sum(uint8_t *data ,uint16_t len)
{
uint16_t result = 0;
uint16_t value16 = 0;
uint16_t value_num = 0; //值的数量
value_num = len / 2 - 1;
for(uint16_t i = 0;i < value_num; i++)
{
value16 = data[2 * i] + data[2 * i+ 1] * 256;
result += value16;
}
value16 = data[len - 2] + data[len - 1] * 256;
if( result == value16 )
{
return 1;
}
return 0;
}
/* 16bit和校验 -判断连续len个字节数据和保留16bit ，CL在前 CH在后 判断与 len len+1位置的数据是否一致
*
* 参数：连续数据地址的首地址 校验的数据长度
*
* 返回：校验结果：1 正确 0错误
*/
uint8_t Check2_16bitData_Sum(uint8_t *data ,uint16_t len)
{
uint16_t result = 0;
uint16_t value16 = 0;
for(uint16_t i = 0;i < len; i++)
{
result += data[i];
}
value16 = data[len] + data[len+1] * 256;
if( result == value16 )
{
return 1;
}
return 0;
}
/* 8bit和校验 -判断连续len个数据和 ，与len+1位置的数据是否一致
*
* 参数：连续数据地址的首地址 校验的数据长度
*
* 返回：校验结果：1 正确 0错误
*/
uint8_t Check_Data_Sum(uint8_t *data ,uint16_t len)
{
uint8_t ret = 0;
for(uint16_t i = 0;i < len;i++)
{
ret += data[i];
}
if(ret == data[len])
{
return 1;
}
return 0;
}
