/******************************************************************************
版权所有： 深圳市科技有限公司
文件名： api_key.c
作者： wangdy
创建日期： 2020/07/8
描述： 按键控制函数
其它：
修改历史： //修改历史记录列表，每条修改记录应包含修改日期、修改者及修改内容简述
序号 修改时间 修改人 修改内容
???? ????/??/?? ?????? 参考样式
******************************************************************************/
/************************************头文件************************************/
#include "bsp_key.h"
#include "api_key.h"
#include "yc_gpio.h"
#include <string.h>
#include "api_power_control.h"
#include "api_paper_calibration.h"
#include "api_state_check.h"
#include "api_print.h"
/*************************************变量*************************************/
KeyVarTypeDef KeyVar = {0}; //按键相关变量
/*************************************函数*************************************/
//按键检测状态 过程
void Key_CheckProcess(void)
{
//MyPrintf("Key_CheckProcess..\n");
static uint16_t TestCountii = 0;
TestCountii++;
if(TestCountii >= 600){
MyPrintf("Check..22\n");
TestCountii = 0;
}
if(false == KeyVar.Key_Lock_Flag){
return;
}
MyPrintf("Check..333\n");
//长按关机
if(KEY_LONG_PRESS == KeyVar.Key_State){
KeyVar.Key_Lock_Flag = false; //取消锁定
Print_Gap_CheckInfo.PaperGap_ErrorFlag_Clear_Flag = true; //清空间隙相关的错误标记信息
//已经开机了允许关机
if((Var_Power_Control.Power_Off_Start_Flag)&&(Var_Power_Control.Power_On_Flag == true))
{
;
//_ API_Machine_Power_OnOff(false); //PA9和PB6置低
}
else
{
// if(Var_Power_Control.Power_On_Flag)
SYS_POWER_EN_ON; //开机 //PA9置高
}
// MyPrintf("key_long_press\n");
}
if((KeyVar.Key_Calibration_Running_Flag == true)||(KeyVar.Key_Short_Press_Feed_Flag == true)) return ;
MyPrintf("Check..444\n");
//短按走纸
if(KEY_SHORT_PRESS == KeyVar.Key_State){
KeyVar.Key_Lock_Flag = false; //取消锁定
// KeyVar.Key_State = KEY_RELEASE; //置为release
MyPrintf("key_short_press_00\n");
if((Print_Gap_CheckInfo.No_Paper_Flag)||(Transfer_Error_Flag.UpCoverState)||(Print_Data_Cache.PrintGoingAllFlag == true)
||(State_Check_Para.State_BatteryTemp_Check!=BATTERY_TEMP_NORMAL)) //打印机缺纸,开盖，打印中,电池温度不正常
{
return;
}
Print_Gap_CheckInfo.PaperGap_ErrorFlag_Clear_Flag = true; //清空间隙相关的错误标记信息
if(Var_Power_Control.Power_Off_Start_Flag){
MyPrintf("key_short_press_11\n");
KeyVar.Key_Short_Press_Feed_Flag = true;
// Var_Power_Control.Auto_Power_Off_Reclock_Flag = true;
Print_Process_Para.Print_Total_Copies_Finish_Flag = true; //单击按键时把总份数标志置为真
Key_Feed_Paper();
}
}
//按2下 定标
if(KEY_SHORT_TWO_TIMES_PRESS == KeyVar.Key_State){
KeyVar.Key_Lock_Flag = false; //取消锁定
// KeyVar.Key_State = KEY_RELEASE; //置为release
MyPrintf("key_short_two_times_press_00\n");
if((Print_Gap_CheckInfo.No_Paper_Flag)||(Transfer_Error_Flag.UpCoverState)||(Print_Data_Cache.PrintGoingAllFlag == true)||
(State_Check_Para.State_BatteryTemp_Check!=BATTERY_TEMP_NORMAL)) //打印机缺纸,开盖，打印中,电池温度不正常
{
return;
}
// Var_Power_Control.Auto_Power_Off_Reclock_Flag = true;
Print_Gap_CheckInfo.PaperGap_ErrorFlag_Clear_Flag = true; //清空间隙相关的错误标记信息
MyPrintf("key_short_two_times_press\n");
if(Var_Power_Control.Power_Off_Start_Flag){
KeyVar.Key_Calibration_Running_Flag = true;
Print_Process_Para.Print_Total_Copies_Finish_Flag = true; //定标时总份数打完标志置为真
PaperCali_Process();
}
}
}
//key irq
void IRQ_KeyCheck(){
static uint16_t TestCount = 0;
static uint16_t TestCountII = 0;
// TestCount++;
// if(TestCount >= 1000){
// MyPrintf("Check..\n");
// TestCount = 0;
// }
//共有3种状态 短按 长按 和按2次
if(SET == GET_POWER_FEED_KEY_STATE){ //按下/
KeyVar.Key_Press_Time_Count++;
KeyVar.Key_Release_Time_Count = 0;
KeyVar.Key_Press_Flag = true;
//长按
if(KeyVar.Key_Press_Time_Count >= TIMEOUT_KEY_PRESS_LONG){
// MyPrintf("KEY_LONG_PRESS--00\n");
if(Var_Power_Control.Power_Off_Start_Flag) {
//已经开机了，且长按大于2秒，先去执行关LED灯
KeyVar.Key_Turn_Off_The_Light_Flag = true;
}
KeyVar.Key_State = KEY_LONG_PRESS;
KeyVar.Key_Lock_Flag = true;
// return;
}
// MyPrintf("KEY_PRESS--00\n");
//按2次
//上一次按下去 需要消除抖动
if(KeyVar.Key_Press_Time_Count >= TIMEOUT_KEY_JITTER_TIME){
KeyVar.Key_Last_Press_Flag = true; //上一次按下的状态
// MyPrintf("AVBGBFGFG..\n");
}
}
else if(RESET == GET_POWER_FEED_KEY_STATE) //释放按键
{
Var_Power_Control.Power_On_Flag = true; //已经开机
Var_Power_Control.Power_Start_Charge = true;
//1 MyPrintf("kptc-11=%d\n",KeyVar.Key_Press_Time_Count);
if(KeyVar.Key_Press_Time_Count >= TIMEOUT_KEY_PRESS_LONG) {
MyPrintf("Release_Flag--00--11\n");
KeyVar.Key_Last_Press_Flag = false;
// KeyVar.Key_First_Release_Flag = true; //目前没用到
KeyVar.Key_State = KEY_RELEASE; //置为release
if(Var_Power_Control.Power_Off_Start_Flag){
API_Machine_Power_OnOff(false); //PA9和PB6置低
}
KeyVar.Key_Press_Time_Count = 0; //按键按下时间
KeyVar.Key_Press_Flag = false;
}
// if(KeyVar.Key_First_Release_Flag){
// MyPrintf("Release_Flag--00--22\n");
// KeyVar.Key_Press_Time_Count = 0; //按键按下时间清零
//_ KeyVar.Key_First_Release_Flag = false;
// return ;
// }
//第1次开机的状态
// MyPrintf("Release_Flag--00--33\n");
KeyVar.Key_Press_Time_Count = 0; //按键按下时间
// if(KeyVar.Key_Press_Flag)
KeyVar.Key_Release_Time_Count++; //按键释放时间
// MyPrintf("pcp=%d\n",Print_Data_Cache.PrintCopies);
// MyPrintf("pcN.=%d\n",Print_Data_Cache.PrintCurrentNum);
if((Print_Data_Cache.PrintGoingAllFlag == true)||((Print_Data_Cache.PrintCopies != 0)&&(Print_Data_Cache.PrintCurrentNum != 0))){
//3 MyPrintf("PAF-44=%d\n",Print_Data_Cache.PrintGoingAllFlag);
KeyVar.Key_Release_Time_Count = 0;
KeyVar.Key_Last_Press_Flag = false;
KeyVar.Key_Press_Flag = false;
return;
}
// TestCountII++;
// if(TestCountII >= 1000){
// MyPrintf("Release_Flag--00--55\n");
// TestCountII = 0;
// }
//如果上一次按下了 此次未按下 重复2次 认为是按2下
if(true == KeyVar.Key_Last_Press_Flag){
//按2次状态判断
// MyPrintf("Release_Flag--00--12345678\n");
if(KeyVar.Key_Release_Time_Count >= TIMEOUT_KEY_JITTER_TIME){
KeyVar.Key_Last_Press_Flag = false;
KeyVar.Key_Press_Release_Count++;
if((Print_Data_Cache.PrintGoingAllFlag == true)||((Print_Data_Cache.PrintCopies != 0)&&(Print_Data_Cache.PrintCurrentNum != 0))) //在打印中则清零
{
KeyVar.Key_Press_Release_Count = 0; //按下次数清零
KeyVar.Key_Release_Time_Count = 0; //按键释放时间清零
KeyVar.Key_Press_Flag = false;
return;
}
if(KeyVar.Key_Press_Release_Count >= 2){
KeyVar.Key_Press_Release_Count = 0;
//状态置为按2次的状态
if((KeyVar.Key_Short_Press_Feed_Flag == true)||(KeyVar.Key_Calibration_Running_Flag == true)) {
// MyPrintf("Release_Flag--00--66\n");
KeyVar.Key_Release_Time_Count = 0; //按键释放时间清零
KeyVar.Key_Press_Flag = false;
return;
}
KeyVar.Key_State = KEY_SHORT_TWO_TIMES_PRESS;
Var_Power_Control.Auto_Power_Off_Reclock_Flag = true; //自动关机时间重计时标志
KeyVar.Key_Lock_Flag = true;
KeyVar.Key_Press_Flag = false;
KeyVar.Key_Release_Time_Count = 0; //按键释放时间清零
return;
}
}
}
//超时没有按下第2次 则认为短按1次
if(KeyVar.Key_Release_Time_Count >= TIMEOUT_KEY_PRESS_SHORT){
//只按了1次
// MyPrintf("Release_Flag--00--44\n");
if(1 == KeyVar.Key_Press_Release_Count){
KeyVar.Key_Press_Release_Count = 0;
// MyPrintf("KEY_SHORT_PRESS--111\n");
if((KeyVar.Key_Short_Press_Feed_Flag == true)||(KeyVar.Key_Calibration_Running_Flag == true)) {
KeyVar.Key_Release_Time_Count = 0; //按键释放时间清零
KeyVar.Key_Press_Flag = false;
return;
}
KeyVar.Key_State = KEY_SHORT_PRESS;
Var_Power_Control.Auto_Power_Off_Reclock_Flag = true; //自动关机时间重计时标志
KeyVar.Key_Lock_Flag = true;
KeyVar.Key_Release_Time_Count = 0; //按键释放时间清零
KeyVar.Key_Press_Flag = false;
return;
}
}
}
}
/******************************************************************************
版权所有： 深圳科技有限公司
文件名： api_key.h
作者： wangdy
创建日期： 2020/7/9
描述： 按键控制
其它：
修改历史： //修改历史记录列表，每条修改记录应包含修改日期、修改者及修改内容简述
******************************************************************************/
/*********************************防止多次编译*********************************/
#ifndef _API_KEY_H
#define _API_KEY_H
/************************************头文件************************************/
#include <stdint.h>
#include <stdbool.h>
/************************************宏定义************************************/
#define TIMEOUT_KEY_PRESS_LONG 2000 //长按N MS
#define TIMEOUT_KEY_PRESS_SHORT 200 //短按N MS
#define TIMEOUT_KEY_JITTER_TIME 30 //抖动时间
#define TIMEOUT_KEY_DISABLE_TIME 200 // 按键失效超时时间
#define SYS_POWER_EN_PORT GPIOA //上电输出高
#define SYS_POWER_EN_PIN GPIO_Pin_9
//power
#define SYS_POWER_EN_ON GPIO_SetBits(SYS_POWER_EN_PORT,SYS_POWER_EN_PIN)
#define SYS_POWER_EN_OFF GPIO_ResetBits(SYS_POWER_EN_PORT,SYS_POWER_EN_PIN)
//获取按键状态
typedef enum
{
KEY_RELEASE = 0,
KEY_SHORT_PRESS,
KEY_SHORT_TWO_TIMES_PRESS, //按2次
KEY_LONG_PRESS
}KeyStateEnum;
typedef struct{
bool Key_First_Release_Flag; //上电后按键第一次松开标记
bool Key_Press_Flag; //按键按下去的标记
uint32_t Key_Press_Time_Count; //按键定时器 高电平计数信息
uint32_t Key_Release_Time_Count; //按键定时器 低电平计数信息
bool Key_Lock_Flag; //按键按下去标记
KeyStateEnum Key_State; //按键终级状态信息
uint32_t Key_Press_Release_Count; //按键按->松开的次数
bool Key_Last_Press_Flag; //上一次按下了按键
bool Key_Short_Press_Feed_Flag; //单击按键走纸标志
bool Key_Feed_Paper_Running_Flag; //单击按键走纸运行标志 没用到
bool Key_Calibration_Running_Flag; //双击定标运行标志 没用到
bool Key_Feed_Paper_Finish_Flag; //单击按键走纸完成标志
bool Key_Calibration_Finish_Flag; //双击定标完成标志
uint16_t Key_Disabled_time; //按键失效时间
bool Key_Turn_Off_The_Light_Flag;
}KeyVarTypeDef;
/************************************结构体************************************/
/**********************************可导出变量**********************************/
/***********************************函数实现***********************************/
void IRQ_KeyCheck(); //定时器 中断 用于检测按键
void Key_CheckProcess(void); //按键检测状态
extern KeyVarTypeDef KeyVar; //
#endif
/******************************************************************************
版权所有： 深圳市科技有限公司
文件名： api_led_watchdog.c
作者： ***
创建日期： 2020/07/8
描述： 蓝牙模块协议解析及处理
其它：
修改历史： //修改历史记录列表，每条修改记录应包含修改日期、修改者及修改内容简述
序号 修改时间 修改人 修改内容
???? ????/??/?? ?????? 参考样式
******************************************************************************/
/************************************头文件************************************/
#include "api_led_watchdog.h"
#include "api_power_control.h"
#include <string.h>
#include "bsp_led_control.h"
#include "bsp_bt.h"
#include "api_state_check.h"
#include "api_print.h"
#include "hal_SuppliesAuth.h"
#include "api_key.h"
#include "bsp_charge_control.h"
/*************************************变量*************************************/
unsigned int BlinkTime = 0; //闪烁次数
_LED_CONTROL_STR LedControlList[LED_SUM] =
{
{LED_RED_STATE_SHOW,1000,0,0,false},
{LED_BULE_BT_SHOW,1000,0,0,false},
};
_LED_ONOFF_FLAG_STR LedStatus;
/*************************************函数*************************************/
/*******************************************************************************
* 名称: API_Led_Control_Init
* 描述: 指示灯控制 初始化
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void API_Led_Control_Init(void)
{
LED_Control_Init(); //指示灯IO初始化
}
/*******************************************************************************
* 名称: API_Led_OnOff
* 描述: LED常高或者常低
* 输入参数: state： 1-常亮 0-常灭
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void API_Led_OnOff(_LED_ENUM led, uint8_t state)
{
LedControlList[led].LED_Cycle = 1000;
if(1 == state)
{
LedControlList[led].LED_Light_Persent = 100;
LedControlList[led].LED_Cycle_High = 1000;
}
else
{
LedControlList[led].LED_Light_Persent = 0;
LedControlList[led].LED_Cycle_High = 0;
}
}
/*******************************************************************************
* 名称: API_Set_Led_Freq
* 描述: LED以频率变化 （设置LED的周期频率）
* 输入参数: state： 1-常亮 0-常灭
led_cycle: 一周期内的时间
led_light_persent: 一周期内亮百分比时间
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void API_Set_Led_Freq(_LED_ENUM led, uint16_t cycle, uint8_t persent)
{
LedControlList[led].LED_Cycle = cycle;
LedControlList[led].LED_Light_Persent = persent;
LedControlList[led].LED_Cycle_High = persent*cycle/100;
}
/*******************************************************************************
* 名称: IRQ_Led_Control
* 描述: 放到1ms中断定时器内
* 输入参数: state： 1-常亮 0-常灭
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void IRQ_Led_Control(void)
{
int i = 0;
static uint16_t temp_count[LED_SUM];
for(i = 0; i < LED_SUM; i++)
{
//常不亮
if(0 == LedControlList[i].LED_Light_Persent)
{
temp_count[i] = 0;
LedControlList[i].LED_HighLow = false;
}
//常亮
else if(100 == LedControlList[i].LED_Light_Persent)
{
temp_count[i] = 0;
LedControlList[i].LED_HighLow = true;
}
else
{
//超过最长时间 则回0继续
temp_count[i]++;
if(temp_count[i] > LedControlList[i].LED_Cycle)
{
temp_count[i] = 0;
}
//更新当前状态（判断高低状态）
if(temp_count[i] <= LedControlList[i].LED_Cycle_High)
{
if(LedStatus.LED_STATE == BLUE_LIGHT_BLINK) //只有蓝色闪烁
{ if(i==1)
LedControlList[i].LED_HighLow = true;
else
LedControlList[i].LED_HighLow = false;
}
else if(LedStatus.LED_STATE == RED_LIGHT_BLINK){
if(i==0)
LedControlList[i].LED_HighLow = true;
else
LedControlList[i].LED_HighLow = false;
}
}
else if( (temp_count[i] > LedControlList[i].LED_Cycle_High)
&&(temp_count[i] <= LedControlList[i].LED_Cycle) )
{
LedControlList[i].LED_HighLow = false;
}
}
}
}
/*******************************************************************************
* 名称: API_Led_Control_Process
* 描述: 放在while(1) 中 亮灯控制
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void API_Led_Control_Process(void)
{
uint8_t i = 0;
for(i = 0; i< LED_SUM; i++)
{
//状态变化
if(LedControlList[i].LED_Choice == LED_RED_STATE_SHOW)
{
if(LedControlList[i].LED_HighLow == true)
{
// MyPrintf("led-red\r\n");
LED_Red_Status_On();
}
else
{
// MyPrintf("led-red_off\r\n");
LED_Red_Status_Off();
}
}
else if(LedControlList[i].LED_Choice == LED_BULE_BT_SHOW)
{
if(LedControlList[i].LED_HighLow == true)
{
// MyPrintf("led-blue\r\n");
LED_Blue_Bt_On();
}
else
{
// MyPrintf("led-blue_off\r\n");
LED_Blue_Bt_Off();
}
}
}
}
/*******************************************************************************
* 名称: API_Led_Test_State
* 描述: led当前状态变更
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void API_Led_Test_State(void)
{
// static uint8_t led_count = 0;
//
// led_count++;
//
// if(1 == led_count)
// {
// LED_Red_Status_Off();
// LED_Blue_Bt_Off();
// }
// else if(2 == led_count)
// {
// LED_Red_Status_On();
// LED_Blue_Bt_Off();
// }
// else if(3 == led_count)
// {
// LED_Red_Status_Off();
// LED_Red_Status_On();
// }
// else if(led_count >= 4)
// {
// led_count = 0;
//
// LED_Red_Status_Off();
// LED_Blue_Bt_Off();
// }
}
/*******************************************************************************
* 名称: API_Led_State_Change
* 描述: led当前状态变更
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void API_Led_State_Change(_LED_CURRENT_STATE *state)
{
//电池没电 该充电了
if(state->Led_Bat_NoElectric)
{
API_Set_Led_Freq(LED_RED_STATE_SHOW,1000,50); //关0.5s 亮0.5s
API_Led_OnOff(LED_BULE_BT_SHOW,0);
LedStatus.LED_STATE = RED_LIGHT_BLINK; //(只有红色闪烁)
// MyPrintf("Led_Bat_NoElectric---\r\n");
}
// if(SUPPLIES_CHECK_OK) //读到标签
// {
// MyPrintf("Led_SUPPLIES_CHECK_OK---\r\n");
// API_Led_OnOff(LED_RED_STATE_SHOW,1); //常开
// API_Led_OnOff(LED_BULE_BT_SHOW,1);
// }
else if(state->Led_Key_Turn_Off_The_Light){ //按键长按关机先关灯等待按键释放才关机
API_Led_OnOff(LED_RED_STATE_SHOW,0); //常关
API_Led_OnOff(LED_BULE_BT_SHOW,0);
}
else //电池有电的情况下
{
if((state->Led_Print_Fault)||(Print_Gap_CheckInfo.No_Paper_Flag)
||(State_Check_Para.State_PrintHeadTemp_Check)||(Transfer_Error_Flag.UpCoverState)
||(Print_Gap_CheckInfo.PaperGap_Gap_NoCheck_ErrorFlag)) //打印电机堵转 ,打印机缺纸,打印头高温,开盖，未检测到间隙纸
{
API_Set_Led_Freq(LED_RED_STATE_SHOW,1000,50); //关0.5s 亮0.5s
API_Led_OnOff(LED_BULE_BT_SHOW,0);
LedStatus.LED_STATE = RED_LIGHT_BLINK; //(只有红色闪烁)
// MyPrintf("all_error---000\r\n");
}
else //未故障信息 判断蓝牙有没有连接
{
// MyPrintf("no_error---111\r\n");
if(state->Led_Bt_State) //蓝牙连接 蓝灯常亮
{
API_Led_OnOff(LED_RED_STATE_SHOW,0);
API_Led_OnOff(LED_BULE_BT_SHOW,1); //常亮
// MyPrintf("led44-\r\n");
}
else
{
//充电中 但未充满 蓝灯闪烁
if((state->Led_Bat_Charging)&&(!state->Led_Bat_ChargeFill)){
API_Led_OnOff(LED_RED_STATE_SHOW,0);
API_Set_Led_Freq(LED_BULE_BT_SHOW,1000,50); //关0.5s 亮0.5s
LedStatus.LED_STATE = BLUE_LIGHT_BLINK; //(只有蓝色闪烁) RED_LIGHT_BLINK
// MyPrintf("led22-\r\n");
}
//else if((ChargingState_Get() == false)||(state->Led_Bat_ChargeFill)) 开机未充电 或者已经充满 也没有蓝牙连接
else
{
API_Led_OnOff(LED_RED_STATE_SHOW,0); //红色长灭
API_Set_Led_Freq(LED_BULE_BT_SHOW,2000,50); //关1s 亮1s
LedStatus.LED_STATE = BLUE_LIGHT_BLINK; //(只有蓝色闪烁) RED_LIGHT_BLINK
// MyPrintf("led11-\r\n");
}
//充满电了 灯不亮
// if(state->Led_Bat_ChargeFill)
// {
// //充满电了
// API_Led_OnOff(LED_RED_STATE_SHOW,0); //常关
// API_Led_OnOff(LED_BULE_BT_SHOW,0);
// }
// else{
// //充满电了
// API_Led_OnOff(LED_RED_STATE_SHOW,0); //常关
// API_Led_OnOff(LED_BULE_BT_SHOW,0);
// }
}
}
}
}
//更新Led
void LED_Update(){
_LED_CURRENT_STATE led_state; //灯状态
//状态变更
led_state.Led_Bat_NoElectric = Charge_Control_Flag.Power_Bat_Low_Flag; //是否没电了
led_state.Led_Bat_ChargeFill = Charge_Control_Flag.ChargeFinish_Flag; //是否充满了
led_state.Led_Bat_Charging = Charge_Control_Flag.Charging_Flag; //当前充电状态
led_state.Led_Key_Turn_Off_The_Light = KeyVar.Key_Turn_Off_The_Light_Flag;
//超过一段时间 不去检测低电量
if(Var_Power_Control.Power_On_Start_Check_Power_Flag){
led_state.Led_Bt_State = BtRxTxVar.BtBleConnectStateFlag; //蓝牙连接状态
}
else{
led_state.Led_Bt_State = 0;
}
//打印出错 或者 电池温度不正常
if((State_Check_Para.State_MotorCheck.PrintMotor_ErrFlag)
|| (State_Check_Para.State_BatteryTemp_Check == BATTERY_TEMP_OVER_HIGH) || (State_Check_Para.State_BatteryTemp_Check == BATTERY_TEMP_OVER_LOW)){
// MyPrintf("Led_Print_Fault-\r\n");
led_state.Led_Print_Fault = true;
}else {
// MyPrintf("Led_Print_Normal-\r\n");
led_state.Led_Print_Fault = false;
}
API_Led_State_Change(&led_state);
API_Led_Control_Process();
}
//用于测试使用
//void RFIDState_test(char LEDType)
//{
// static unsigned char ucBlinkStep = 0;
//
// switch(ucBlinkStep)
// {
// case 0:
//
// if(BlinkTime >= Const_RFID_Time_500ms)
// {
// if(LEDType)
// {
// LED_Red_Status_On();
// LED_Blue_Bt_Off();
// }
// else
// {
// LED_Blue_Bt_On();
// LED_Red_Status_Off();
// }
// // Matchine_Bat_Charge_On();
// BlinkTime = 0;
// ucBlinkStep = 1;
// }
// break;
// case 1:
//
// if(BlinkTime>=Const_RFID_Time_500ms)
// {
// if(LEDType)
// LED_Red_Status_Off();
// else
// LED_Blue_Bt_Off();
Matchine_Bat_Charge_Off() ;
// BlinkTime = 0;
// ucBlinkStep = 0;
// }
// break;
// default :
// break;
// }
//
//}
/******************************************************************************
版权所有： 深圳科技有限公司
文件名： api_led_watchdog.h
作者： ***
创建日期： 2020/7/9
描述： 灯及看门狗处理
其它：
修改历史： //修改历史记录列表，每条修改记录应包含修改日期、修改者及修改内容简述
序号 修改时间 修改人 修改内容
???? ????/??/?? ?????? 参考样式
******************************************************************************/
/*********************************防止多次编译*********************************/
#ifndef _API_LED_WATCHDOG_H
#define _API_LED_WATCHDOG_H
/************************************头文件************************************/
#include <stdint.h>
#include <stdbool.h>
/************************************宏定义************************************/
#define Const_RFID_Time_500ms 500 //RFID 500ms闪灯
typedef enum
{
LED_RED_STATE_SHOW = 0,
LED_BULE_BT_SHOW ,
LED_SUM ,
}_LED_ENUM;
typedef enum
{
RED_LIGHT_OFF = 0, //红灯灯灭
RED_LIGHT_ON , //红灯灯亮
BLUE_LIGHT_OFF, //蓝灯灯灭
BLUE_LIGHT_ON , //蓝灯灯亮
RED_LIGHT_BLINK, // 只有红灯闪烁
BLUE_LIGHT_BLINK, //只有蓝灯闪烁
RED_AND_BLUE_BLINK, //红灯和蓝灯相间闪烁
}_LED_ONOFF_FLAG_ENUM;
typedef struct
{
volatile _LED_ONOFF_FLAG_ENUM LED_STATE; //LED灯状态
}_LED_ONOFF_FLAG_STR;
typedef struct
{
volatile _LED_ENUM LED_Choice; //选择配置哪个led
volatile uint16_t LED_Cycle; //LED亮灯周期 亮+不亮总时间(MS)
volatile uint8_t LED_Light_Persent; //亮灯所占的时间比： 0~100 0表示不亮 100表示常亮
volatile uint16_t LED_Cycle_High; //高电平时长（自动计算）
volatile bool LED_HighLow; //LED亮或者不亮
}_LED_CONTROL_STR;
//LED当前信息
typedef struct
{
uint8_t Led_Bt_State : 1; //蓝牙连接状态
uint8_t Led_Print_Fault : 1; //打印故障信息（打印头过热or电机堵转）
uint8_t Led_Bat_Charging : 1; //电池充电中
uint8_t Led_Bat_NoElectric : 1; //电池没电了
uint8_t Led_Bat_ChargeFill : 1; //电池充满了
uint8_t Led_Key_Turn_Off_The_Light:1; //按键长按2秒之后关灯
}_LED_CURRENT_STATE;
/************************************结构体************************************/
/**********************************可导出变量**********************************/
extern unsigned int BlinkTime ;
/***********************************函数实现***********************************/
void API_Led_Control_Init(void);
void API_Led_OnOff(_LED_ENUM led, uint8_t state);
void API_Set_Led_Freq(_LED_ENUM led, uint16_t cycle, uint8_t persent);
void IRQ_Led_Control(void);
void API_Led_Control_Process(void);
void API_Led_State_Change(_LED_CURRENT_STATE *state);
void API_Led_Test_State(void); //灯测试
void LED_Update(); //led状态更新
extern void RFIDState_test(char LEDType);
#endif
/******************************************************************************
版权所有： 深圳市科技有限公司
文件名： api_para_set.c
作者： ***
创建日期： 2020/08/12
描述： 参数配置 及读取
其它：
修改历史： //修改历史记录列表，每条修改记录应包含修改日期、修改者及修改内容简述
序号 修改时间 修改人 修改内容
???? ????/??/?? ?????? 参考样式
******************************************************************************/
/************************************头文件************************************/
#include "api_para_set.h"
#include "tools_calc_heattime.h"
#include <string.h>
#include "yc_encflash_bulk.h"
#include "yc_qspi.h"
#include "flash_addr_def.h"
#include "api_sensorcheck.h"
#include "api_paper_calibration.h"
/*************************************变量*************************************/
_STORE_PARA_INFO Store_Para; //普通存储测试参数
_STORE_TEST_INFO Store_Test; //测试数据
BtParaStoreTypeDef Bt_Para; //蓝牙参数
CalibrationParaStoreTypeDef Store_CalibrationPara; //校准参数
RFID_STORE_INFO RFID_Store; //RFID存储信息
//默认初始值
const BtParaStoreTypeDef BtParaStoreDefault =
{
.storeFlag = 0x00, //存储标记
.Bt_NvRam = {0x00}, //NVRAM配对信息
};
//定标参数 间隙纸默认初始化
const CalibrationParaStoreTypeDef CalibrationParaStoreDefault =
{
.storeFlag = 0x00, //存储标记信息
.SelectIndex = SELECTED_INDEX_DEFAULT, //间隙纸的所选择的光耦的强度（一般为1~4或者1~16）
.GapRef = GAP_THRESHOLD_DEFAULT, //间隙纸的反馈值
.BlackRef = BLACK_THRESHOLD_DEFAULT, //黑标纸的反馈值
.HavePaperRef = NOPAPER_THRESHOLD_DEFAULT, //有纸及无纸的阈值
.isSuccess = false , //定标成功标志
};
//定标参数 黑标纸默认初始化
const CalibrationParaStoreTypeDef BlackCalibrationParaStoreDefault =
{
.storeFlag = 0x00, //存储标记信息
.SelectIndex = BLACK_SELECTED_INDEX_DEFAULT, //间隙纸的所选择的光耦的强度（一般为1~4或者1~16）
.GapRef = GAP_THRESHOLD_DEFAULT, //间隙纸的反馈值
.BlackRef = BLACK_THRESHOLD_DEFAULT, //黑标纸的反馈值
.HavePaperRef = NOPAPER_THRESHOLD_DEFAULT, //有纸及无纸的阈值
.isSuccess = false , //定标成功标志
};
/*************************************函数*************************************/
static uint8_t hex_lookup[16] = { '0', '1', '2', '3', '4', '5', '6', '7','8','9', 'A', 'B', 'C', 'D', 'E', 'F' };
void array2hex(uint8_t* in, int inlen, uint8_t* out)
{
int i;
for (i = 0; i < inlen; ++i)
{
out[2 * i] = hex_lookup[in[i] >> 4];
out[2 * i + 1] = hex_lookup[in[i] & 0x0f];
}
}
//uint8_t bt_name[10] = "PT26_ ";
uint8_t bt_name[14] = "U20_ ";
//uint8_t Bt_Name[10] ={0};
//void bt_name_connect()
//{
// uint8_t chip_id[6]={0};
// uint8_t chip_id2_hex[6]={0};
// read_chipid(chip_id);
// for(size_t n=0;n<6;++n)
// {
// array2hex(chip_id+n,1,(chip_id2_hex+n));
array2hex(chip_id,1,bt_name+7);
// }
// for(size_t i=0;i<5;++i)
// {
// Bt_Name[i]=bt_name[i];
// }
// for(size_t j=0;j<6;++j)
// {
// MyPrintf("chip_id=%02x\r\n",chip_id2_hex[j]);
// Bt_Name[j+5]=chip_id2_hex[j];
// }
//}
/*******************************************************************************
* 名称: Para_Store_Init
* 描述: 参数存储 初始化
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void Para_Store_Init(void)
{
// uint8_t Bt_Name[10] = {0};
// connect((char*)Bt_Name);
uint8_t chip_id[6]={0};
read_chipid(chip_id);
array2hex(chip_id+1,1,bt_name+4);
array2hex(chip_id,1,bt_name+6);
//=========================读取设备信息
qspi_flash_read(PARA_STORE_START_BASE,(uint8_t *)(&Store_Para),sizeof(Store_Para));
//判断蓝牙参数数据是否有效
if(AVALIABLE_STORE_FLAG != Store_Para.BT_Name_Para.StoreFlag)
{
//蓝牙名称设置为默认的
memset(Store_Para.BT_Name_Para.Bt_Name,0x00,31);
memcpy(Store_Para.BT_Name_Para.Bt_Name,bt_name,10);
// memcpy(Store_Para.BT_Name_Para.Bt_Name,DEFAULT_BT_NAME,strlen(DEFAULT_BT_NAME));
}
//判断蓝牙密码参数是否有效
if(AVALIABLE_STORE_FLAG != Store_Para.BT_Passwd_Para.StoreFlag)
{
//蓝牙PIN设置为默认的
memset(Store_Para.BT_Passwd_Para.Bt_PIN,0x00,16);
memcpy(Store_Para.BT_Passwd_Para.Bt_PIN,DEFAULT_BT_PASSWD,strlen(DEFAULT_BT_PASSWD));
}
//判断偏位参数
if(AVALIABLE_STORE_FLAG != Store_Para.Pix_Offset_Para.StoreFlag)//(AVALIABLE_STORE_FLAG != Store_Para.Pix_Offset_Para.StoreFlag)
{
Store_Para.Pix_Offset_Para.Pix_Offset_6MM = 0; //默认偏位是0
Store_Para.Pix_Offset_Para.Pix_Offset_9MM = 0; //默认偏位是0
Store_Para.Pix_Offset_Para.Pix_Offset_12MM = 0; //默认偏位是0
}
//判断加热时间
if(AVALIABLE_STORE_FLAG != Store_Para.Print_Heattime_Para.StoreFlag)
{
Store_Para.Print_Heattime_Para.BasicHeatTime = DEFAULT_HEAT_TIME; //默认的基本加热时间
}
if( (Store_Para.Print_Heattime_Para.BasicHeatTime < MIN_HEAT_TIME) &&
(Store_Para.Print_Heattime_Para.BasicHeatTime > MAX_HEAT_TIME) ) //超出阈值 则用默认值
{
Store_Para.Print_Heattime_Para.BasicHeatTime = DEFAULT_HEAT_TIME; //默认的基本加热时间
}
//判断当前的纸张类型
if(AVALIABLE_STORE_FLAG != Store_Para.Print_Paper_Type_Para.StoreFlag)
{
Store_Para.Print_Paper_Type_Para.PrintPaperType = PAPER_GAP; //默认走间隙纸
}
//判断关机时间是否有效
MyPrintf("ss_StoreFlag=%04x\r\n",Store_Para.Shutdown_Time_Set_Para.StoreFlag);
if(AVALIABLE_STORE_FLAG != Store_Para.Shutdown_Time_Set_Para.StoreFlag)
{
// MyPrintf("11-------------11....\r\n");
memset(Store_Para.Shutdown_Time_Set_Para.ShutDownTime,0x00,31);
// memcpy(Store_Para.Shutdown_Time_Set_Para.ShutDownTime,DEFAULT_SHUTDOWN_TIME,1);
Store_Para.Shutdown_Time_Set_Para.ShutDownTime = DEFAULT_SHUTDOWN_TIME;
Para_Store_ShutDown_Time_Para_Write();
MyPrintf("ShutDownTime=%d\r\n",Store_Para.Shutdown_Time_Set_Para.ShutDownTime);
}
//=========================蓝牙信息
qspi_flash_read(BT_STORE_START_BASE,(uint8_t *)&Bt_Para,sizeof(BtParaStoreTypeDef));
//参数合法性判断 不合法 直接用默认值
if(AVALIABLE_STORE_FLAG != Bt_Para.storeFlag)
{
Bt_Para = BtParaStoreDefault;
MyPrintf("bt use default value\r\n");
}
//=========================定标校准信息
qspi_flash_read(CALIBRATION_STORE_START_BASE,(uint8_t *)&Store_CalibrationPara,sizeof(CalibrationParaStoreTypeDef));
//参数合法性判断 不合法 直接用默认值
if(AVALIABLE_STORE_FLAG != Store_CalibrationPara.storeFlag){
if(Store_Para.Print_Paper_Type_Para.PrintPaperType == PAPER_GAP)
Store_CalibrationPara = CalibrationParaStoreDefault;
else if(Store_Para.Print_Paper_Type_Para.PrintPaperType == PAPER_BLACKLABLE)
Store_CalibrationPara = BlackCalibrationParaStoreDefault;
MyPrintf("calibdata use default value\r\n");
}
}
/*******************************************************************************
* 名称: Para_Store_BtPara_Write
* 描述: 蓝牙参数存储 写数据
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
bool Para_Store_BtName_Para_Write(void)
{
//标志位置为有效
Store_Para.BT_Name_Para.StoreFlag = AVALIABLE_STORE_FLAG; //
// qspi_flash_sectorerase(PARA_STORE_START_BASE);
// if(! qspi_flash_write(PARA_STORE_START_BASE,(uint8_t *)(&Store_Para),sizeof(Store_Para)))
qspi_flash_sectorerase(BT_STORE_START_BASE);
if(! qspi_flash_write(BT_STORE_START_BASE,(uint8_t *)(&Store_Para),sizeof(Store_Para)))
{
return false;
}
return true;
}
/*******************************************************************************
* 名称: Para_Store_BtPara_Write
* 描述: 蓝牙密码存储 写数据
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
bool Para_Store_BtPass_Para_Write(void)
{
//标志位置为有效
Store_Para.BT_Passwd_Para.StoreFlag = AVALIABLE_STORE_FLAG; //
// qspi_flash_sectorerase(PARA_STORE_START_BASE);
// if(! qspi_flash_write(PARA_STORE_START_BASE,(uint8_t *)(&Store_Para),sizeof(Store_Para)))
qspi_flash_sectorerase(BT_STORE_START_BASE);
if(! qspi_flash_write(BT_STORE_START_BASE,(uint8_t *)(&Store_Para),sizeof(Store_Para)))
{
return false;
}
return true;
}
/*******************************************************************************
* 名称: Para_Store_PrintPaper_Type_Write
* 描述: 间隙纸色带种类型号
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
bool Para_Store_PrintPaper_Type_Write(void)
{
//标志位置为有效
Store_Para.Print_Paper_Type_Para.StoreFlag = AVALIABLE_STORE_FLAG;
qspi_flash_sectorerase(PARA_STORE_START_BASE);
if(! qspi_flash_write(PARA_STORE_START_BASE,(uint8_t *)(&Store_Para),sizeof(Store_Para)))
{
return false;
}
return true;
}
/*******************************************************************************
* 名称: Para_Store_Pix_Offset_Para_Write
* 描述: 写偏位参数
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
bool Para_Store_Pix_Offset_Para_Write(void)
{
//标志位置为有效
Store_Para.Pix_Offset_Para.StoreFlag = AVALIABLE_STORE_FLAG;
qspi_flash_sectorerase(PARA_STORE_START_BASE);
if(! qspi_flash_write(PARA_STORE_START_BASE,(uint8_t *)(&Store_Para),sizeof(Store_Para)))
{
return false;
}
return true;
}
/*******************************************************************************
* 名称: Para_Store_HeatTime_Para_Write
* 描述: 写加热时间参数
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
bool Para_Store_HeatTime_Para_Write(void)
{
//标志位置为有效
Store_Para.Print_Heattime_Para.StoreFlag = AVALIABLE_STORE_FLAG;
qspi_flash_sectorerase(PARA_STORE_START_BASE);
if(! qspi_flash_write(PARA_STORE_START_BASE,(uint8_t *)(&Store_Para),sizeof(Store_Para)))
{
return false;
}
return true;
}
/*******************************************************************************
* 名称: Para_Store_ShutDown_Time_Para_Write
* 描述: 写关机时间参数
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
bool Para_Store_ShutDown_Time_Para_Write(void)
{
//标志位置为有效
Store_Para.Shutdown_Time_Set_Para.StoreFlag = AVALIABLE_STORE_FLAG;
qspi_flash_sectorerase(PARA_STORE_START_BASE);
if(! qspi_flash_write(PARA_STORE_START_BASE,(uint8_t *)(&Store_Para),sizeof(Store_Para)))
{
MyPrintf("Current_Shutdown_Time!=\r\n");
return false;
}
return true;
}
/*******************************************************************************
* 名称: Write_RFID_INFO_TO_Flash
* 描述: 写RFID信息
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
bool Write_RFID_Info_To_Flash(void)
{
//标志位置为有效
// Store_Para.Shutdown_Time_Set_Para.StoreFlag = AVALIABLE_STORE_FLAG;
qspi_flash_sectorerase(RFID_STORE_START_BASE);
if(! qspi_flash_write(RFID_STORE_START_BASE,(uint8_t *)(&RFID_Store),sizeof(RFID_Store)))
{
return false;
}
return true;
}
/*******************************************************************************
* 名称: Test_Store_CutterTime_Write
* 描述: 测试数据 次数更新并写入
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
bool Test_Store_CutterTime_Write(void)
{
//标志位置为有效
Store_Test.Cutter_Test_Data.StoreFlag = AVALIABLE_STORE_FLAG; //
// qspi_flash_sectorerase(PARA_STORE_START_BASE);
// if(! qspi_flash_write(PARA_STORE_START_BASE,(uint8_t *)(&Store_Para),sizeof(Store_Para)))
qspi_flash_sectorerase(TEST_STORE_START_BASE);
if(! qspi_flash_write(TEST_STORE_START_BASE,(uint8_t *)(&Store_Test),sizeof(Store_Test)))
{
return false;
}
return true;
}
/*******************************************************************************
* 名称: Test_Store_Init
* 描述: 测试数据 初始化
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void Test_Store_Init(void)
{
//读取设备信息
qspi_flash_read(TEST_STORE_START_BASE,(uint8_t *)(&Store_Test),sizeof(_STORE_TEST_INFO));
//判断测试数据是否有效
if(AVALIABLE_STORE_FLAG != Store_Test.Cutter_Test_Data.StoreFlag)
{
//改为默认值
Store_Test.Cutter_Test_Data.StoreFlag = 0;
Store_Test.Cutter_Test_Data.Cutter_Test_Sum = 0;
}
}
/*******************************************************************************
* 名称: BtParaReadFromFlash
* 描述:
* 输入参数: 无
* 输出参数: 无
* 其它:
*******************************************************************************/
bool BtParaReadFromFlash(void)
{
uint8_t chip_id[6] = {0};
BtParaStoreTypeDef bt_para;
//flash
qspi_flash_read(BT_STORE_START_BASE,(uint8_t *)&bt_para,sizeof(BtParaStoreTypeDef));
//参数合法性判断 不合法 直接用默认值
if(AVALIABLE_STORE_FLAG != bt_para.storeFlag)
{
Bt_Para = BtParaStoreDefault;
MyPrintf("bt use default value\r\n");
}
else
{
Bt_Para = bt_para;
MyPrintf("bt use right value\r\n");
}
//MyPrintf("flash flag = %d\r\n",UserParaAll.BtPara.storeFlag);
return true;
}
/*******************************************************************************
* 名称: UserParaWritetoFlash
* 描述: 写入flash内存
* 输入参数: 无
* 输出参数: 无
* 其它:
*******************************************************************************/
bool BtParaWritetoFlash(void)
{
Bt_Para.storeFlag = AVALIABLE_STORE_FLAG;
qspi_flash_sectorerase(BT_STORE_START_BASE);
if(! qspi_flash_write(BT_STORE_START_BASE,(uint8_t *)(&Bt_Para),sizeof(BtParaStoreTypeDef)))
{
return false;
}
return true;
}
/*******************************************************************************
* 名称: Para_Store_Factory_Setting
* 描述: 恢复出厂设置
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
bool Para_Store_Factory_Setting(void)
{
//标记清空
memset((char *)(&Store_Para),0x00,sizeof(_STORE_PARA_INFO));
qspi_flash_sectorerase(PARA_STORE_START_BASE);
if(! qspi_flash_write(PARA_STORE_START_BASE,(uint8_t *)(&Store_Para),sizeof(Store_Para)))
{
return false;
}
return true;
}
//读取标定参数信息
bool CalibrateParaReadFromFlash(CalibrationParaStoreTypeDef *calipara){
CalibrationParaStoreTypeDef CaliPara;
//flash
qspi_flash_read(CALIBRATION_STORE_START_BASE,(uint8_t *)&CaliPara,sizeof(CalibrationParaStoreTypeDef)); //读出flash参数
//参数合法性判断 不合法 直接用默认值
if(AVALIABLE_STORE_FLAG != CaliPara.storeFlag)
{
if(Store_Para.Print_Paper_Type_Para.PrintPaperType == PAPER_GAP)
*calipara = CalibrationParaStoreDefault;
else if(Store_Para.Print_Paper_Type_Para.PrintPaperType == PAPER_BLACKLABLE)
*calipara = BlackCalibrationParaStoreDefault;
}
else
{
*calipara = CaliPara;
}
return true;
}
//写定标参数信息
bool CalibrateParaWritetoFlash(CalibrationParaStoreTypeDef *calipara){
calipara->storeFlag = AVALIABLE_STORE_FLAG; //写入数据
qspi_flash_sectorerase(CALIBRATION_STORE_START_BASE);
if(! qspi_flash_write(CALIBRATION_STORE_START_BASE,(uint8_t *)(calipara),sizeof(CalibrationParaStoreTypeDef)))
{
return false;
}
return true;
}
/******************************************************************************
版权所有： 深圳科技有限公司
文件名： api_test.h
作者： wangdy
创建日期： 2020/7/9
描述： 测试处理接口
其它：
修改历史： //修改历史记录列表，每条修改记录应包含修改日期、修改者及修改内容简述
序号 修改时间 修改人 修改内容
???? ????/??/?? ?????? 参考样式
******************************************************************************/
/*********************************防止多次编译*********************************/
#ifndef _API_PARA_SET_H
#define _API_PARA_SET_H
/************************************头文件************************************/
#include <stdint.h>
#include <stdbool.h>
#include "bsp_bt.h"
#include "var_global.h"
//#include "bsp_flash.h"
/************************************宏定义************************************/
#define DEFAULT_BT_PASSWD "0000" //默认配对码
//#define DEFAULT_BT_NAME "PT-Q1_12345678" //默认蓝牙名
//#define DEFAULT_BT_NAME "PT-210E_12345678" //默认蓝牙名
#define DEFAULT_BT_NAME "U20_long123456" //默认蓝牙名
#define DEFAULT_SHUTDOWN_TIME 0x05 //默认关机时间5分钟
#define AVALIABLE_STORE_FLAG 0x12345678
#define DEFAULT_EMPTY_VALUE 1600 //色带 小于该阈值 认为是无纸
//---连续纸
#define DEFAULT_CONTINEPAPER_PAPER_VALUE 2500 //色带 大于该阈值 认为是有纸
#define DEFAULT_CONTINEPAPER_GAP_VALUE 2499 //色带 连续纸不用测试间隙信息
//---间隙纸
#define DEFAULT_GAPPAPER_PAPER_VALUE 2500 //色带 大于该阈值 认为是有纸
#define DEFAULT_GAPPAPER_GAP_VALUE 2499 //色带 小于该阈值 认为是间隙
#define DEFAULT_GAPPAPER_GAP_DIFFER_VALUE 1 //最大值和最小值对应的差值信息
/************************************结构体************************************/
#pragma pack(push)
#pragma pack(1)
//===========================基本参数
//参数测试
typedef struct
{
uint32_t StoreFlag; //存储标志
uint8_t Bt_Name[31]; //蓝牙名称
}_BT_NAME_PARA;
//蓝牙PIN码
typedef struct
{
uint32_t StoreFlag; //存储标志
uint8_t Bt_PIN[16]; //蓝牙密码
}_BT_PASSWD_PARA;
typedef struct
{
uint32_t StoreFlag; //存储标记
int8_t Pix_Offset_6MM; //像素偏移
int8_t Pix_Offset_9MM; //像素偏移
int8_t Pix_Offset_12MM; //像素偏移
}_PIX_OFFSET_PARA;
//基本加热时间控制
typedef struct
{
uint32_t StoreFlag; //存储标记
uint16_t BasicHeatTime; //基本加热时间
}_PRINT_HEATTIME_PARA;
//纸张类型信息控制
typedef struct
{
uint32_t StoreFlag; //存储标记
PrintPaperTypeEnum PrintPaperType; //色带型号种类信息
}_PRINT_PAPER_TYPE_PARA;
typedef struct
{
uint32_t StoreFlag; //存储标记
uint8_t ShutDownTime; //关机时间
}_SHUTDOWN_TIME_SET_PARA;
typedef struct
{
_BT_NAME_PARA BT_Name_Para;
_BT_PASSWD_PARA BT_Passwd_Para;
_PRINT_HEATTIME_PARA Print_Heattime_Para; //加热时间参数
_PRINT_PAPER_TYPE_PARA Print_Paper_Type_Para; //纸张类型信息
_SHUTDOWN_TIME_SET_PARA Shutdown_Time_Set_Para; //关机时间设置
_PIX_OFFSET_PARA Pix_Offset_Para; //偏位测试
}_STORE_PARA_INFO;
//===========================测试数据
//测试数据写入
typedef struct
{
uint32_t StoreFlag; //存储标志
uint32_t Cutter_Test_Sum; //写入测试次数
}_CUTTER_TEST_DATA;
typedef struct
{
_CUTTER_TEST_DATA Cutter_Test_Data;
}_STORE_TEST_INFO;
//===========================蓝牙存储参数
//蓝牙存储信息
typedef struct
{
uint32_t storeFlag; //存储标记
uint8_t Bt_NvRam[NVRAM_LEN]; //NVRAM 存储配对信息
}BtParaStoreTypeDef;
//RFID存储信息
typedef struct
{
uint32_t storeFlag; //存储标记
PrintPaperTypeEnum RFIDPaperType; //识别到芯片的纸张类型信息
uint8_t RFID_Supplies_ID; //识别到芯片的耗材ID信息
}RFID_STORE_INFO;
//===========================定标及校准参数
//定标存储信息
typedef struct
{
uint32_t storeFlag; //存储标记信息
uint8_t SelectIndex; //间隙纸的所选择的光耦的强度（当前为1~3）
uint32_t GapRef; //间隙纸的反馈值
uint32_t HavePaperRef; //是否有纸 值
uint32_t BlackRef; //黑标纸的反馈值
bool isSuccess ;
}CalibrationParaStoreTypeDef;
#pragma pack(pop)
/**********************************可导出变量**********************************/
extern _STORE_PARA_INFO Store_Para; //一般参数GET
extern _STORE_TEST_INFO Store_Test; //测试数据
extern BtParaStoreTypeDef Bt_Para; //蓝牙参数
extern CalibrationParaStoreTypeDef Store_CalibrationPara; //校准参数
extern RFID_STORE_INFO RFID_Store; //RFID存储信息
/***********************************函数实现***********************************/
//基本存储参数
void Para_Store_Init(void); //参数初始化
bool Para_Store_BtName_Para_Write(void); //参数写
bool Para_Store_BtPass_Para_Write(void); //写密码
bool Para_Store_HeatTime_Para_Write(void); //写加热时间
bool Para_Store_GapPaper_Para_Write(void); //参数数据存储
bool Para_Store_PrintPaper_Type_Write(void); //色带种类信息存储
bool Para_Store_NoPaper_ADC_Write(void); //无纸ADC值 存储信息
bool Test_Store_CutterTime_Write(void); //切刀测试
bool Para_Store_Factory_Setting(void); //恢复出厂设置
bool Para_Store_ShutDown_Time_Para_Write(void); //写关机时间
bool Write_RFID_Info_To_Flash(void); //写RFID信息
//蓝牙参数
bool BtParaReadFromFlash(void);
bool BtParaWritetoFlash(void);
//测试参数
void Test_Store_Init(void); //测试数据 初始化
bool Test_Store_CutterTime_Write(void); //测试次数 ++
//定标参数存储
bool CalibrateParaReadFromFlash(CalibrationParaStoreTypeDef *calipara);
bool CalibrateParaWritetoFlash(CalibrationParaStoreTypeDef *calipara); //写定标参数信息
#endif
/******************************************************************************
版权所有： 深圳市科技有限公司
文件名： api_power_control.c
作者： ***
创建日期： 2020/07/8
描述： 蓝牙模块协议解析及处理
其它：
修改历史： //修改历史记录列表，每条修改记录应包含修改日期、修改者及修改内容简述
序号 修改时间 修改人 修改内容
???? ????/??/?? ?????? 参考样式
******************************************************************************/
/************************************头文件************************************/
#include "api_power_control.h"
#include "api_print.h"
#include "bsp_power_control.h"
#include "bsp_charge_control.h"
#include "api_state_check.h"
#include "api_test.h"
#include "driver_adc.h"
#include "driver_uart0.h"
#include "driver_adc.h"
#include "yc_7816.h"
#include <string.h>
#include "yc_systick.h"
#include "driver_adc.h"
#include "yc_systick.h"
#include "hard_config.h"
#include "api_para_set.h"
#include "api_key.h"
#include "task_print_process.h"
/*************************************变量*************************************/
_VAR_POWER_CONTROL Var_Power_Control = {0}; //电源开关控制变量
_ADC_CHANNEL_AVERAGE_VALUE adc_channel_average_value = {0}; //电源采样 控制变量
_CHARGE_CONTROL_STATE Charge_Control_Flag = {0}; //充电状态信息
/*************************************函数*************************************/
/*******************************************************************************
* 名称: API_Power_Control_Init
* 描述: 电源控制初始化 Var_Power_Control.Shutdown_Time_Set_Refresh_Flag
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void API_Power_Control_Init(void)
{
IpcInit(); //IPC初始化
Power_Control_Init(); //电源控制 初始化
Matchine_5V_PrintHead_Motor_Power_Off(); //关闭打印头及电机电源
Matchine_3V3_Power_On(); //再打开3V3电源 PA9
Task_Print_Process_Init(); //打印任务初始化
delay_ms(200);
Print_Gap_CheckInfo.PaperGap_GotoGap_Pre_Flag = false; //走间隙的标记 置为无效
Charge_Control_Init(); //充电控制 初始化
ADC_Configure(); //ADC配置 初始化
//获取机器名称
Get_MachineName(GlobleMachineVar.DefaultGenMachineName);
//获取机器序列号
Get_SerialNumber(GlobleMachineVar.MachineSerialNumber);
//特殊引脚功能使能
vcard_control(1); //初始化智能卡 可当智能卡应用
enable_gpio_32(); //使能GPIO32
//先把充电状态控制打开
API_Bat_Charge_OnOff(true); //启动充电
SysTick_Config(CPU_MHZ/100); //systick
}
/*******************************************************************************
* 名称: API_Bat_Charge_OnOff
* 描述: 电池充电功能开/关
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void API_Bat_Charge_OnOff(bool state)
{
if(state)
{
Charge_Control_Flag.ChargeControl_Flag = true;
Matchine_Bat_Charge_On();
}
else
{
Charge_Control_Flag.ChargeControl_Flag = false;
Matchine_Bat_Charge_Off();
}
//MyPrintf("charge_state:%d\n",state);
}
/*******************************************************************************
* 名称: API_Machine_Power_OnOff
* 描述: 机器开关机
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void API_Machine_Power_OnOff(bool state)
{
if(state)
{
Matchine_3V3_Power_On(); //再打开3V3电源
}
else
{
if(true == ChargingState_Get())
{
//复位
soft_reset(); //复位 充电时真正进入关机状态
}
else
{
API_Print_Stop(); //关闭打印 做善后处理
Matchine_3V3_Power_Off(); //关闭 3V3电源
Matchine_5V_PrintHead_Motor_Power_Off(); //关闭电机电源
//延时 复位 （防止没做3V3控制 导致不能关机）
delay_ms(100);
soft_reset(); //复位
}
MyPrintf("powerOff\n");
}
}
/*******************************************************************************
* 名称: Power_Bat_Charge_Control
* 描述: 电池充电控制
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void Power_Bat_Charge_Control(void)
{
if((MACHINE_TEST == Machine_State) && (TestMode_Print_Test.TestMode_Printing)) //测试模式，并且启停充电，不做控制的
{
//不做任何充电相关控制
}
else if((State_Check_Para.State_BatteryTemp_Check == BATTERY_TEMP_OVER_HIGH)||(State_Check_Para.State_BatteryTemp_Check == BATTERY_TEMP_OVER_LOW)){
Charge_Control_Flag.Charging_Flag = false;
// Charge_Control_Flag.ChargeFinish_Flag = false;
API_Bat_Charge_OnOff(false); //停止充电 关闭充电电路
}
else {
//判断usb是否插入
if(ChargingState_Get()){
// MyPrintf("Power_Bat_Charge_Control\n");
//如果在允许充电状态中
if(Charge_Control_Flag.ChargeControl_Flag){
// MyPrintf("Power_Bat_Charge_22222\n");
//判断电池温度 过高或者过低 则关闭充电
if((State_Check_Para.State_BatteryTemp_Check == BATTERY_TEMP_OVER_HIGH) || (State_Check_Para.State_BatteryTemp_Check == BATTERY_TEMP_OVER_LOW)){
Charge_Control_Flag.Charging_Flag = false;
// Charge_Control_Flag.ChargeFinish_Flag = false;
API_Bat_Charge_OnOff(false); //停止充电 关闭充电电路
}
//如果处在打印测试中 则停止充电
else if((MACHINE_TEST == Machine_State) && (TestMode_Print_Test.TestMode_Printing))
{
Charge_Control_Flag.Charging_Flag = false;
// Charge_Control_Flag.ChargeFinish_Flag = false;
API_Bat_Charge_OnOff(false); //停止充电 关闭充电电路
}
// //如果处在打印中 则停止充电
// else if(true == Print_Data_Cache.PrintGoingAllFlag)
// {
// Charge_Control_Flag.Charging_Flag = false;
// Charge_Control_Flag.ChargeFinish_Flag = false;
// API_Bat_Charge_OnOff(false); //停止充电 关闭充电电路
// }
else //不在上述情况下 则关注一下 是否在充电中 然后是否充满等状态
{
// MyPrintf("P_B_C_777\n");
//电池指示引脚，低电平有效 ,表示充电中
if(RESET == READ_CHARGE_FINISH_STATE)
{ //低电平 表示正在充电
Charge_Control_Flag.ChargeFinish_Flag = false;
Charge_Control_Flag.Charging_Flag = true;
API_Bat_Charge_OnOff(true); //继续充电
}else { //高电平 表示充满了 则停止
Charge_Control_Flag.ChargeFinish_Flag = true;
Charge_Control_Flag.Charging_Flag = false;
API_Bat_Charge_OnOff(false); //停止充电
}
}
}
else { //在不允许充电的状态下
//如果在插入USB的前提下 电池温度正常 并且 实际电压小于 8V
// MyPrintf("ChargeFinish_Flag=%d\n",Charge_Control_Flag.ChargeFinish_Flag);
// MyPrintf("Power_Bat_Value=%d\n",adc_channel_average_value.Power_Bat_Value);
API_Bat_Charge_OnOff(true); //启动充电
if(State_Check_Para.State_BatteryTemp_Check == BATTERY_TEMP_NORMAL)
{
// if((3960>= adc_channel_average_value.Power_Bat_Value)||(RESET == READ_CHARGE_FINISH_STATE))
if(RESET == READ_CHARGE_FINISH_STATE) //没充满
{
Charge_Control_Flag.ChargeFinish_Flag = false;
Charge_Control_Flag.Charging_Flag = true;
API_Bat_Charge_OnOff(true); //继续充电
}
else{
Charge_Control_Flag.ChargeFinish_Flag = true;
Charge_Control_Flag.Charging_Flag = false;
}
// if(Var_Power_Control.Power_Start_Charge){
// API_Bat_Charge_OnOff(true); //继续充电
// MyPrintf("P_B_C_444\n");
// }
// //电池指示引脚，低电平有效 ,表示充电中
// if(RESET == READ_CHARGE_FINISH_STATE)
// { //低电平 表示正在充电
// Charge_Control_Flag.ChargeFinish_Flag = false;
// Charge_Control_Flag.Charging_Flag = true;
// API_Bat_Charge_OnOff(true); //继续充电
// MyPrintf("P_B_C_555\n");
// }else if(SET == READ_CHARGE_FINISH_STATE){ //高电平 表示充满了 则停止
// Charge_Control_Flag.ChargeFinish_Flag = true;
// Charge_Control_Flag.Charging_Flag = false;
//
// API_Bat_Charge_OnOff(false); //停止充电
// MyPrintf("P_B_C_666\n");
// }
}
}
}else { //没插入usb 则任何条件下 都不允许 充电
Charge_Control_Flag.Charging_Flag = false;
// Charge_Control_Flag.ChargeFinish_Flag = false;
API_Bat_Charge_OnOff(false); //停止充电 关闭充电电路
}
}
}
/*******************************************************************************
* 名称: Power_Voltage_Check
* 描述: 各种电源电压检测
* 输入参数: 无
* 输出参数: 无
* 其它:
*******************************************************************************/
void Power_Voltage_Check(void)
{
static uint32_t Sum_Power_Bat_Value = 0;
static uint32_t Sum_Power_Bat_Value_II = 0;
static uint16_t CurrCnt = 0;
static uint16_t CurrCntII = 0;
static uint16_t BatLowCount = 0;
uint32_t temp_value = 0;
uint32_t temp_valueII = 0;
static uint16_t Adc_Error_Value = 223 ; //默认ADC值的误差是223（比真实值小）
//求和 并且计数 + 1
if(true == Print_Data_Cache.PrintGoingAllFlag) return; //打印不检测电量
if(KeyVar.Key_Short_Press_Feed_Flag) return; //单击走纸不检测电量
CurrCnt++;
// CurrCntII++;
Sum_Power_Bat_Value += ADC_Get_Value(ADC_BAT_POWER);
// Sum_Power_Bat_Value_II += ADC_Get_Value(ADC_BAT_POWER);
// if(CurrCntII >= 50){
// temp_valueII = Sum_Power_Bat_Value_II/50; //取得平均值
// temp_valueII = temp_valueII*247/47;
// adc_channel_average_value.Power_Bat_Value_II = temp_valueII ;
// CurrCntII = 0;
// Sum_Power_Bat_Value_II = 0;
// }
// MyPrintf("PBV_II=%d\r\n",adc_channel_average_value.Power_Bat_Value_II);
// MyPrintf("Bat_temp_valu。。。\r\n");
//求平均值 取100次
if(CurrCnt >= ADC_AVERAGE_COUNT){
//以下几个电压值，均为分压电阻分压 (200+47)/47 电压，则公式为： adc*247/47
//如果保留3位小数点，则公式为： adc*247/47*1000
//电池电压 电压取值3.2V-4.2V之间
temp_value = Sum_Power_Bat_Value/ADC_AVERAGE_COUNT; //取得平均值
temp_value = temp_value*247/47;
// MyPrintf("Bat_temp_value=%d\r\n",temp_value);
//高电平表示电池充满了，充满电压为4.2V
if(ChargingState_Get())//判断是否插上USB充电
{
adc_channel_average_value.Power_Bat_Value = temp_value; //电压值，保留3位小数点 280为误差值
// MyPrintf("READ_CHARGE_FINISH_STATE=%d\r\n",READ_CHARGE_FINISH_STATE);
if( READ_CHARGE_FINISH_STATE){//表示充满
Adc_Error_Value = 4250-temp_value ;
// MyPrintf("Adc_Error_Value=%d\r\n",Adc_Error_Value);
adc_channel_average_value.Power_Bat_Value = 4250 ;
}
else{
// MyPrintf("1234567890--\r\n");
adc_channel_average_value.Power_Bat_Value = (temp_value-100); //电压值，保留3位小数点 223为误差值
// adc_channel_average_value.Power_Bat_Value = temp_value+Adc_Error_Value; //电压值，保留3位小数点 223为误差值
// if(adc_channel_average_value.Power_Bat_Value> 3920)
// adc_channel_average_value.Power_Bat_Value = 3920 ;
// else if(adc_channel_average_value.Power_Bat_Value<=3400) //原来是3250
// adc_channel_average_value.Power_Bat_Value = 3400;
}
}
else{
adc_channel_average_value.Power_Bat_Value = temp_value; //电压值，保留3位小数点 280为误差值
// if(adc_channel_average_value.Power_Bat_Value<=3400) //原来是3250
// adc_channel_average_value.Power_Bat_Value = 3400;
}
if(adc_channel_average_value.Power_Bat_Value> 3920)
adc_channel_average_value.Power_Bat_Value = 3920 ;
else if(adc_channel_average_value.Power_Bat_Value<=3400) //原来是3250
adc_channel_average_value.Power_Bat_Value = 3400;
// MyPrintf("Bat_temp_value=%d\r\n",adc_channel_average_value.Power_Bat_Value);
adc_channel_average_value.Power_Bat_Percent = ((adc_channel_average_value.Power_Bat_Value-3400)/50)*10; //求百分比给自检打印显示用
// MyPrintf("Power_Bat_Value=%d\r\n",adc_channel_average_value.Power_Bat_Value);
if(true == Var_Power_Control.Power_On_Start_Check_Power_Flag) //开机1秒之后标记
{
//充电中 不检测低电
if((Charge_Control_Flag.Charging_Flag)&&(!Charge_Control_Flag.ChargeFinish_Flag))
{
Charge_Control_Flag.Power_Bat_Low_Flag = false;
}
//打印中，未到恢复时间 则不检测低电量信息
else if(false == Var_Power_Control.Power_Print_Start_Check_Power_Flag)
{
Charge_Control_Flag.Power_Bat_Low_Flag = false;
}
//测试模式，并且打印中，不做低电检测，并停止充电
else if((MACHINE_TEST == Machine_State)&&(TestMode_Print_Test.TestMode_Printing))
{
Charge_Control_Flag.Power_Bat_Low_Flag = false;
}
else
{
//判断电池是否过低 不能打印(低于3.5V,不恢复，则不动)
if(adc_channel_average_value.Power_Bat_Value <= (BAT_LOW_VOLATE_THRESHOLD/* - BAT_LOW_RANGE*/))
{
BatLowCount++;
if(BatLowCount>=10){
//小于最小值 认为没电
Charge_Control_Flag.Power_Bat_Low_Flag = true;
BatLowCount = 0;
}
}
else if(adc_channel_average_value.Power_Bat_Value >= (BAT_LOW_VOLATE_THRESHOLD + BAT_LOW_RANGE))
{
//大于最大值 认为有电
Charge_Control_Flag.Power_Bat_Low_Flag = false;
BatLowCount = 0;
}
}
}
else
{
Charge_Control_Flag.Power_Bat_Low_Flag = false;
}
CurrCnt = 0;
Sum_Power_Bat_Value = 0;
}
}
/*******************************************************************************
* 名称: Power_Auto_PowerOff
* 描述: 电源自动关机
* 输入参数: 无
* 输出参数: 无
* 其它: 中断调用 1s
*******************************************************************************/
void PowerAutoPowerOff(){
static uint32_t last_count = 0;
static uint32_t last_count_check_power = 0;
static bool init_state = false;
static uint16_t Low_Power_AutoShutdown_Count = 0;
// //处在测试模式 不自动关机
if(MACHINE_TEST == Machine_State)
{
last_count = GetMyTick();
}
// //处在打印模式 不自动关机
// MyPrintf("APORF..=%d\n",Var_Power_Control.Auto_Power_Off_Reclock_Flag);
if(Print_Data_Cache.PrintGoingAllFlag == true) //打印重新计时
{
last_count = GetMyTick();
}
// else if (BtRxTxVar.BtBleConnectStateFlag ){
// last_count = GetMyTick();
MyPrintf("BLEC..\n");
// }
else if(Var_Power_Control.Auto_Power_Off_Reclock_Flag == true){
last_count = GetMyTick();
Var_Power_Control.Auto_Power_Off_Reclock_Flag = false;
}
//充电中 不自动关机
// else if((Charge_Control_Flag.Charging_Flag)&&(!Charge_Control_Flag.ChargeFinish_Flag))
// {
// last_count = GetMyTick();
// }
// //低电，堵转，切刀故障， 保持待机，不做关机处理
// else if( (Charge_Control_Flag.Power_Bat_Low_Flag)
// || (State_Check_Para.State_MotorCheck.PrintMotor_ErrFlag) )
// {
// last_count =GetMyTick();
// }
else
{
if(Var_Power_Control.Shutdown_Time_Set_Refresh_Flag == true){
Var_Power_Control.Shutdown_Time_Set_Refresh_Flag = false ;
last_count =GetMyTick();
}
if(Store_Para.Shutdown_Time_Set_Para.ShutDownTime == 0xFF){
last_count = GetMyTick();
// MyPrintf("Shutdown_Time..=%d\n",Store_Para.Shutdown_Time_Set_Para.ShutDownTime);
}else{
//if(GetMyTick() - last_count > (POWER_AUTO_OFF_TIME * 1000))
if(GetMyTick() - last_count >= Store_Para.Shutdown_Time_Set_Para.ShutDownTime*MILLISECONDS_PER_MINUTE)
{
last_count = GetMyTick();
API_Machine_Power_OnOff(false); //关机 只走USB供电
}
}
}
if((Var_Power_Control.Power_Off_Start_Flag)&&(Print_Data_Cache.PrintGoingAllFlag == false)){
if(State_Check_Para.BlackPatchPrintFlag == false ){
// MyPrintf("Power_Bat_Value..1212=%d\n",adc_channel_average_value.Power_Bat_Value);
if(adc_channel_average_value.Power_Bat_Value <= (BAT_LOW_VOLATE_THRESHOLD - BAT_LOW_RANGE)) { //这里不屏蔽会开不了机
Low_Power_AutoShutdown_Count++;
// MyPrintf("Power_Bat_Value..1212=%d\n",adc_channel_average_value.Power_Bat_Value);
}else{
Low_Power_AutoShutdown_Count = 0;
}
if(Low_Power_AutoShutdown_Count >= 50)
API_Machine_Power_OnOff(false); //关机 只走USB供电
}
}
//做计数处理（开机N秒后检测低电）
if(false == init_state){
init_state = true;
last_count_check_power = GetMyTick();
}
if(false == Var_Power_Control.Power_On_Start_Check_Power_Flag){
if(GetMyTick() >= last_count_check_power){
last_count_check_power = GetMyTick();
Var_Power_Control.Power_On_Start_Check_Power_Flag = true;
}
}
}
//开关机控制
void PowerOnOffControl(){
static uint32_t last_count_poweron = 0;
static uint32_t last_count_lowpower = 0;
static bool init_flag = false;
//只初始化赋值
if(false == init_flag){
last_count_poweron = GetMyTick();
init_flag = true;
}
//如果检测到了开机
if(false == Var_Power_Control.Power_Off_Start_Flag)
{
if(Var_Power_Control.Power_On_Flag){
if(GetMyTick() - last_count_poweron >= (POWER_ON_OFF_TIME)) {
last_count_poweron = GetMyTick();
Var_Power_Control.Power_Off_Start_Flag = true; //允许关机
Var_Power_Control.Power_Start_Charge = false; //
}
}
}
//延时判断低电量
if(true == Print_Data_Cache.PrintGoingAllFlag){ //判断是否在打印中
Var_Power_Control.Power_Print_Start_Check_Power_Flag = false;
last_count_lowpower = GetMyTick();
}
else { //检测持续多久，超过一定的时间 则恢复检测低电量信息 （未在打印中 ）
if(false == Var_Power_Control.Power_Print_Start_Check_Power_Flag){
if(GetMyTick() - last_count_lowpower >= (POWER_START_RECOVER_TIME_MS )){
last_count_lowpower = GetMyTick();
Var_Power_Control.Power_Print_Start_Check_Power_Flag = true;
}
}
}
}
/******************************************************************************
版权所有： 深圳科技有限公司
文件名： api_power_control.h
作者： ***
创建日期： 2020/7/9
描述： 电源控制
其它：
修改历史： //修改历史记录列表，每条修改记录应包含修改日期、修改者及修改内容简述
序号 修改时间 修改人 修改内容
???? ????/??/?? ?????? 参考样式
******************************************************************************/
/*********************************防止多次编译*********************************/
#ifndef _API_POWER_CONTROL
#define _API_POWER_CONTROL
/************************************头文件************************************/
#include <stdint.h>
#include <stdbool.h>
#include "driver_adc.h"
/************************************宏定义************************************/
#define POWER_ON_OFF_TIME 1000 //开机1s后才允许关机
#define ADC_AVERAGE_COUNT 100
#define BAT_LOW_VOLATE_THRESHOLD 3500 //电压低于3.40V 不让打印
#define BAT_LOW_RANGE 100 //50 //0.05v波动，则认为不恢复
#define POWER_AUTO_OFF_TIME 600 //Ns
#define POWER_START_CHECK_BAT_POWER_TIME 3
#define POWER_START_RECOVER_TIME_MS 200 //多长时间恢复检测低电
#define MILLISECONDS_PER_MINUTE 60000 //每分钟多少毫秒
/************************************结构体************************************/
typedef struct
{
bool Power_On_Flag; //开机标志位
bool Power_Off_Start_Flag; //关机 开机计时 (开机1S之后才允许关机)
bool Auto_Power_Off_Reclock_Flag; //自动关机重计时 （开机之后如果有按键按下或者打印，或连接蓝牙就重新刷新关机时间）
// uint32_t Power_Off_Start_Press; //按下去 计数信息
// uint16_t Power_Off_Delay; //关机所用延时时间
// uint32_t Power_Off_Auto_Offset_Count; //自动超时
bool Power_On_Start_Check_Power_Flag; //开始检测电池（需要开机等一会）
// uint32_t Power_Print_Start_Check_Power_Count; //检测低电的情况标记
bool Power_Print_Start_Check_Power_Flag; //检测低电使能的计数信息
bool Power_OnOff_State; //开关机的状态（当前状态）
bool Shutdown_Time_Set_Refresh_Flag; //关机设置时间刷新标志
bool Power_Start_Charge; //充电标记
}_VAR_POWER_CONTROL;
typedef struct
{
volatile uint16_t Power_9V_Value; //平均值的(对应的电压值)
volatile uint16_t Power_Bat_Value; //电池电压
volatile uint16_t Printer_NTC_Temp_Value; //温度传感器
volatile uint16_t Power_Bat_Percent; //电池电量百分比
volatile uint16_t Power_Bat_Value_II; //电池电压
}_ADC_CHANNEL_AVERAGE_VALUE;
//充电状态信息
typedef struct
{
bool ChargeControl_Flag; //充电控制开关是否打开
bool Charging_Flag; //当前充电状态
bool ChargeFinish_Flag; //充电完成状态
bool Power_Bat_Low_Flag; //电池电量低
bool ChargeTakeOver_Flag; //充电接管标记
}_CHARGE_CONTROL_STATE;
/**********************************可导出变量**********************************/
extern _VAR_POWER_CONTROL Var_Power_Control; //电源控制
extern _ADC_CHANNEL_AVERAGE_VALUE adc_channel_average_value;
extern _CHARGE_CONTROL_STATE Charge_Control_Flag; //充电状态信息
/***********************************函数实现***********************************/
void API_Power_Control_Init(void); //电源初始化信息
void API_Machine_Power_OnOff(bool state); //开关机控制
void API_Bat_Charge_OnOff(bool state); //充电启停
void Power_Bat_Charge_Control(void); //充电控制
void PowerAutoPowerOff(); //自动关机控制
void PowerOnOffControl(); //开关机控制
void Power_Voltage_Check(void); //电压检测 求平均值
void Machine_Power_OnOff(bool onoff); //开关机整体控制
#endif
/******************************************************************************
版权所有： 深圳市科技有限公司
文件名： api_print.c
作者： ***
创建日期： 2020/07/9
描述： 打印接口
其它：
修改历史： //修改历史记录列表，每条修改记录应包含修改日期、修改者及修改内容简述
序号 修改时间 修改人 修改内容
???? ????/??/?? ?????? 参考样式
******************************************************************************/
/************************************头文件************************************/
#include "bsp_print_control.h"
#include "api_print.h"
#include "api_state_check.h"
#include "bsp_motor_control.h"
#include "tools_function.h"
#include "tools_calc_heattime.h"
#include "api_led_watchdog.h"
#include "api_para_set.h"
#include "var_global.h"
#include "var_pix_print.h"
#include "api_power_control.h"
#include "bsp_power_control.h"
#include "api_key.h"
#include <string.h>
#include "hal_SuppliesAuth.h"
#include "driver_spi.h"
/*************************************变量*************************************/
//打印过程中变量
_PRINT_PROCESS_PARA Print_Process_Para = {
.Print_Current_Pix = 0, //当前打印的步骤信息
.Paper_Back_Flag = PRINT_STILL_PAPER, //退纸标记（纸张后退OR前进）
.Paper_Back_Count = 0, //退纸计数
.PaperGap_Ready_Check_Flag = false, //准备检测间隙纸
.PaperGap_Ready_Check_Pix_Count = 0, //准备检测间隙纸的对应的像素点（开始）
.Print_FIFO_Empty_Flag = false, //FIFO空标记
.Print_FIFO_Empty_Count = 0, //FIFO空计数
.Print_Total_Copies_Finish_Flag = true , //打印总份数完成
.Print_Job_Status_Flag = PRINT_STATUS_UNKNOWN, //打印工作状态
};
//缓存的个数
_PRINT_DATA_CACHE Print_Data_Cache = {
.PrintDensityTemp = NORMAL_TEMP, //打印头对应的温度信息
.PrintHeatTime = PRINTHEAD_HEATTIME_DEFAULT, //打印头加热时间
.PrintBlank = PRINT_BLANK_DEFAULT, //留白配置
.PrintGoingAllFlag = false, //打印全部完成
.WriteProtocalCurrBytes = 0, //当前字长（下一包协议 没用）
.WriteProtocalTotalBytes = 0, //写协议总长（包含包头信息） ）
.PrintRealHight = 0, //为nL+nH*256个点(实际有效打印的高度)
.PrintStartOffset = 0, //表示本次打印标签纵向的起始偏移量
//长度为sL+sH*256个点(标签的起始位置到
//有效打印内容之间的距离)
.PrintAllPix = 0, //打印的总长度
.PrintRealWidth = 0, //打印的实际的宽度
.PrintCopies = 0, //打印的总份数
.PrintCurrentNum = 0, //当前打印的是第几张
.PrintAfterCutFlag = 0, //当前打印完成后 是否进行剪切
.PrintDensity = 6, //打印浓度
.PrintSpeed = 0, //打印速度
.PrintMode = 0, //打印模式
.TabWidthMM = 0, //xl xh为标签横向的宽度，单位毫米
.TabHightPix = 0, //yl yh为标签纵向的高度，单位点(像素)
.TTRLength = 0, //碳带长度
.TapeUsedLength = 0, //已使用色带长度
.TapeRemainLength = 0, //剩余色带长度
.PrintDevice = 0, //设备型号 ANDROID OR IOS???
.PrintPix_Offset_Stable = 0, //打印-固定像素偏移（结构工差）
.PrintPix_Tape_Offset = 0, //打印-像素偏移（用于6/9/12mm做像素偏移）
.PrintCutMode = 0, //剪切模式（剪切or不剪切）
};
//当前打印状态
_CURRENT_PRINT_STATE Current_Print_State = {
.PrintHeating = 0, //是否正在加热
.PrintPaperAvaliable = 0, //是否有纸可用
.PrintRecv = 0, //是否收到打印数据状态
.PrintFinish = 1, //打印机内容是否打印完成
.PrintError = 0, //打印机是否有错误
.PrintPause = 0, //打印机是否暂停
.PrintCancel = 0, //打印内容被取消
.NC = 0, //空余内容
};
//当前打印步骤
_CURRENT_PRINT_STEP Current_Print_Step = PRINT_NONE; //当前打印步骤
//当前间隙的检测信息
_PRINT_PAPER_CHECK_INFO Print_Gap_CheckInfo = {
.PaperGap_Check_Flag = 0, //打印的过程中的标记信息
//间隙打印 走到间隙位
.PaperGap_GotoGap_Pre_Flag = false, //间隙打印 准备定标标记
//定标用功能
.PaperGap_Calibration_Count = 0, //定标的计数信息
.PaperGap_Calibration_DestCount = 0, //定标的计数信息 目标距离 信息
.PaperGap_Calibration_Flag = false, //定标的标记信息
.PaperGap_CheckLocation_Finish_Flag = false, //定标的标记信息
.PaperGap_Calibration_Success_Flag = false, //定标的成功Or失败
.PaperGap_GotoGap_All_Count = 0, //总计数信息 - 间隙纸 多走一部分纸的功能信息
.PaperGap_Disable_Print_FIFO = false, //第1份只空走纸 不做其它操作
.PaperGap_Gap_NoCheck_ErrorFlag = false, //未找到间隙 错误
.PaperGap_Calibration_ErrorFlag = false, //定标失败 错误
.PaperGap_CheckGapTimesOver_Flag = false, //检测到了间隙一定的次数
.PaperGap_CheckGapTimesOver_Count = 0, //检测到了间隙的计数的信息
.No_Paper_Flag = false, //没有放耗材
.Uncover_Flag = false, //开盖检测
.Clear_Gap_NoCheck_ErrorFlag_Count = 0, //清除“未检测到间隙纸标志”计时
.Gap_Undetected_Flag = false, 超过步数了还没检测到间隙标志
};
/*************************************函数*************************************/
//=======================================内部函数==================================
//加热完成
static void API_Print_Heat_Finish(void){
//打印头停止加热
Print_Line_Stop_Write_Heat(); //停止加热
}
//更新蓝牙上传状态
void API_BT_State_Change(PRINT_UPLOAD_STATE upload_state){
if(upload_state == PRINT_END){
//打完了 变更状态信息
Current_Print_State.PrintRecv = 0; //打印机是否有接收到数据
Current_Print_State.PrintFinish = 1; //打印完成标记置为0
Current_Print_State.PrintPause = 0; //打印机暂停标志为0
Current_Print_State.PrintCancel = 0; //打印机取消标记为0
Calc_HeatTime_Struct.SamePrintLinePointCount = 0 ;
Calc_HeatTime_Struct.CurrentLinePoint = 0;
Calc_HeatTime_Struct.ThirdPrintLinePoint = 0;
Calc_HeatTime_Struct.SecondPrintLinePoint = 0;
Calc_HeatTime_Struct.FirstPrintLinePoint = 0;
}
else if(upload_state == PRINT_GO){
//打印机状态变更
Current_Print_State.PrintRecv = 1; //打印机是否有接收到数据
Current_Print_State.PrintFinish = 0; //打印完成标记置为0
Current_Print_State.PrintPause = 0; //打印机暂停标志为0
Current_Print_State.PrintCancel = 0; //打印机取消标记为0
}
}
//打印过程中，中间某一份停止 (临时停止)
void API_Print_NoLast_Copies_Stop(void){
//间隙判断标记信息
// Print_Gap_CheckInfo.PaperGap_CheckGapTimesOver_Count = 0;
// Print_Gap_CheckInfo.PaperGap_CheckGapTimesOver_Flag = false;
//退纸计数
Print_Process_Para.Paper_Back_Count = 0; //纸张后退计数
Print_Process_Para.Paper_Back_Flag = PRINT_STILL_PAPER; //纸张后退标记定为无效
// MyPrintf("PNCS_111\r\n");
State_Check_Para.CheckSuppliesFlag = 0;
API_Print_Heat_Finish(); //超过加热时间 则停止加热
Print_Process_Para.Print_Current_Pix = 0; //像素位清0
FIFO_PrintLineList_Clear(); //清掉FIFO 停止打印
//打完了 变更状态信息
API_BT_State_Change(PRINT_END);
//停止打印电机
PrintMotor_Stop(); //停止打印电机
//最后一张或取消时份数信息清空
if((Print_Data_Cache.PrintCopies == Print_Data_Cache.PrintCurrentNum)||(Print_Process_Para.Print_Job_Status_Flag == CANCEL_PRINT)
||(BtRxTxVar.BtBleConnectStateFlag == false)){
// MyPrintf("PrintCurrentNum_222\r\n");
Print_Data_Cache.PrintCurrentNum = 0;
Print_Data_Cache.PrintCopies = 0;
State_Check_Para.BlackPatchPrintFlag = false ;
Matchine_5V_PrintHead_Motor_Power_Off(); //取消打印或蓝牙断开关闭电机及打印头电源
}
//总标志关掉
Print_Data_Cache.PrintGoingAllFlag = false; //关停
Print_Process_Para.Print_Job_Status_Flag = PRINT_STATUS_UNKNOWN ;
}
//读缓存并打印数据
bool API_PrintData_Out(bool HeaveHeat){
static _PRINT_LINE_BUF PrintLineBuf; //打印缓存
bool FIFO_State = false ; //FIFO状态
uint8_t PrintPoint = 0; //打印点数信息
static uint8_t CurrentRepeatSize = 0; //当前重复的个数信息
//读FIFO数据 - 去读fifo的信息
if(FIFO_PrintLineList_Get((uint8_t *)(&PrintLineBuf)))
{
//计算当前行打印点数
PrintPoint = CalcPrintDataBitCount(PrintLineBuf.LineBuf,PRINTER_LINE_BYTES);
//计算加热时间
if(HeaveHeat){
Print_Data_Cache.PrintHeatTime = PRINTHEAD_HEAVE_HEATTIME;
}
else{
Print_Data_Cache.PrintHeatTime = Calc_Heattime(
adc_channel_average_value.Power_Bat_Value,
PrintPoint,
Print_Data_Cache.PrintDensity //浓度
);
PrintHeadDataInfo.print_heat_time = Print_Data_Cache.PrintHeatTime;
// MyPrintf("PrintHeatTime_11=%d\r\n",Print_Data_Cache.PrintHeatTime);//== 17,18,19
}
//如果读成功了 表明里面有数据的 则准备打印
if(State_Check_Para.BlackPatchPrintFlag)
{
memcpy((char *)PrintHeadDataInfo.print_all_buf,&PrintLineBuf,PRINTER_LINE_BYTES); //复制所有数据
memset((char *)PrintHeadDataInfo.print_current_buf,0x00,PRINTER_LINE_BYTES); //将当前行数据清0
memcpy((char *)PrintHeadDataInfo.print_current_buf + 6,(char *)PrintHeadDataInfo.print_all_buf + 6, PRINTER_LINE_BYTES-6); //像素信息 复制过来
// PrintHeadDataInfo.current_offset += PRINTER_WITH_STEP_BYTES;
Print_Line_Start_Write_Heat((char *)PrintHeadDataInfo.print_current_buf,false);
PrintHeadDataInfo.print_reversal_flsg = true;
}else if((Paper_Colour_Struct.Enum_Paper_Color == ENUM_BLUE_PAPER)||(Paper_Colour_Struct.Enum_Paper_Color == ENUM_GREEN_PAPER))
{
if(!KeyVar.Key_Calibration_Running_Flag){
memcpy((char *)PrintHeadDataInfo.print_all_buf,&PrintLineBuf,PRINTER_LINE_BYTES); //复制所有数据
memset((char *)PrintHeadDataInfo.print_current_buf,0x00,PRINTER_LINE_BYTES); //将当前行数据清0
memcpy((char *)PrintHeadDataInfo.print_current_buf + 0,(char *)PrintHeadDataInfo.print_all_buf + 0, PRINTER_LINE_BYTES); //像素信息 复制过来
Print_Line_Start_Write_Heat((char*)&PrintHeadDataInfo.print_current_buf[0],false);
}else
Print_Line_Start_Write_Heat(PrintLineBuf.LineBuf,false);
}
else
Print_Line_Start_Write_Heat(PrintLineBuf.LineBuf,false);
//开始加热
TIMER_HEATTIME_START;
}
else
{
Current_Print_State.PrintHeating = 0; //加热标记 无效
return true;
}
return false;
}
//打印虚线
void API_Print_DotLine(void){
//计算加热时间
Print_Data_Cache.PrintHeatTime = PRINTHEAD_HEAVE_HEATTIME;
//如果读成功了 表明里面有数据的 则准备打印
Print_Line_Start_Write_Heat((uint8_t *)BitMap_DotLine_Line,false);
}
//打印缓存内数据
void Print_BufferData(void){
API_PrintData_Out(false);
}
//-------------------------------后退与非后退 函数控制--------------------------
//启动打印并做加热处理 前段留白走完后 再执行这步
static void API_Start_PrintHeat(void){
SPI_PrintHead_Configure(); //打印头初始化
Matchine_5V_PrintHead_Motor_Power_On();
// MyPrintf("API_Start_PrintHeat\r\n");
//打印总标记 置为有效
Print_Data_Cache.PrintGoingAllFlag = true; //总打印标记 置为有效
//打印时间
Print_Process_Para.Print_Current_Pix = 0; //当前像素，清0
//未找到间隙错误标志 置为无效
Print_Gap_CheckInfo.PaperGap_Gap_NoCheck_ErrorFlag = false, //未找到间隙错误标志置为false
//间隙判断标记信息
// Print_Gap_CheckInfo.PaperGap_CheckGapTimesOver_Count = 0;
// Print_Gap_CheckInfo.PaperGap_CheckGapTimesOver_Flag = false;
Print_Process_Para.PaperGap_Ready_Check_Flag = false; //准备去检测间隙标志
// MyPrintf("PrintRealHight=%d\r\n",Print_Data_Cache.PrintRealHight);
//间隙纸的信息 - 用于判断间隙位置用的
// if(Print_Data_Cache.PrintRealHight >= PRINTHEAD_CHECK_PIX_INFO)
// {
// MyPrintf("1212333-\r\n");
// Print_Process_Para.PaperGap_Ready_Check_Pix_Count = Print_Data_Cache.PrintRealHight - PRINTHEAD_CHECK_PIX_INFO;
// }
// else
{
// MyPrintf("1212333-444\r\n");
Print_Process_Para.PaperGap_Ready_Check_Pix_Count = 16; //起始像素
}
//判断走的步数信息 - 省得多走再倒退(其它份走到打印头，最后一份走到切刀)
if((Print_Data_Cache.PrintCurrentNum == Print_Data_Cache.PrintCopies)||(Print_Process_Para.Print_Job_Status_Flag == CANCEL_PRINT)) //打印最后一份时或只有打印一份时
// if(Print_Data_Cache.PrintCurrentNum == Print_Data_Cache.PrintCopies)
{
// MyPrintf("PrintCurrentNum_111\r\n");
if(PAPER_GAP == Store_Para.Print_Paper_Type_Para.PrintPaperType)
Print_Gap_CheckInfo.PaperGap_GotoGap_All_Count = PRINTHEAD_OPTICALCOUPLER_CUTTER; //到切刀
else if(PAPER_BLACKLABLE == Store_Para.Print_Paper_Type_Para.PrintPaperType)
Print_Gap_CheckInfo.PaperGap_GotoGap_All_Count = (PRINTHEAD_OPTICALCOUPLER_CUTTER); //到切刀
}
else
{
// MyPrintf("PrintCurrentNum_222\r\n");
if(PAPER_GAP == Store_Para.Print_Paper_Type_Para.PrintPaperType)
Print_Gap_CheckInfo.PaperGap_GotoGap_All_Count = (PRINTHEAD_OPTICALCOUPLER_PIX + 4); //传感器到打印头
else if(PAPER_BLACKLABLE == Store_Para.Print_Paper_Type_Para.PrintPaperType){
if(Print_Data_Cache.PrintDevice == 0) // 安卓
Print_Gap_CheckInfo.PaperGap_GotoGap_All_Count = (PRINTHEAD_OPTICALCOUPLER_PIX - 8); //传感器到打印头 -8
else
Print_Gap_CheckInfo.PaperGap_GotoGap_All_Count = (PRINTHEAD_OPTICALCOUPLER_PIX -4);
}
}
//只有第1份，且上一次的总份数已经打印完成才做退纸处理
// if((1 == Print_Data_Cache.PrintCurrentNum)&&(Print_Process_Para.Print_Total_Copies_Finish_Flag))
if(1 == Print_Data_Cache.PrintCurrentNum)
{
//退纸计数
Print_Process_Para.Paper_Back_Count = 0; //计数清0
Print_Process_Para.Paper_Back_Flag = PRINT_BACK_PAPER; //电机反转
PrintMotor_Inverse_Start(); //启动电机
}
// else if(Print_Data_Cache.PrintCurrentNum > 1)
else
{
//退纸计数
Print_Process_Para.Paper_Back_Count = 0;
Print_Process_Para.Paper_Back_Flag = PRINT_FORWARD_PAPER; //电机正转
PrintMotor_Positive_Start();
}
// if(Print_Data_Cache.PrintCopies != Print_Data_Cache.PrintCurrentNum){
// Print_Process_Para.Print_Total_Copies_Finish_Flag = false;
// }else{
// Print_Process_Para.Print_Total_Copies_Finish_Flag = true;
// }
}
//间隙纸打印 此函数作用：多份打印时第一份回退，
//current_pix - 当前像素信息
static bool Print_Gap_Paper(uint32_t current_pix)
{
static uint16_t Print_Back_couter = 0;
//倒转，退纸(只有第一份才干的事)
if(PRINT_BACK_PAPER == Print_Process_Para.Paper_Back_Flag){
// MyPrintf("gap back run_1111111\n");
Print_Process_Para.Paper_Back_Count++;
// MyPrintf("Back_Count..=%d\r\n",Print_Process_Para.Paper_Back_Count);
if(PAPER_GAP == Store_Para.Print_Paper_Type_Para.PrintPaperType){
Print_Back_couter = PRINTHEAD_GAP_CUTTER_PIX + 0;
}
else if(PAPER_BLACKLABLE == Store_Para.Print_Paper_Type_Para.PrintPaperType){
if(Print_Data_Cache.PrintDevice == 0) //安卓
Print_Back_couter = PRINTHEAD_GAP_CUTTER_PIX + 8;
else
Print_Back_couter = PRINTHEAD_GAP_CUTTER_PIX + 4;
}
if(Print_Process_Para.Paper_Back_Count >= Print_Back_couter /*- Print_Data_Cache.PrintStartOffset*/)
{
Print_Process_Para.Paper_Back_Count = 0; //第1份打完了，后退纸张计数清0
Print_Process_Para.Paper_Back_Flag = PRINT_FORWARD_PAPER; //第1份打完了，纸沿正方向走
PrintMotor_Stop(); //停止步进电机
PrintMotor_Positive_Start(); //重新启动
// MyPrintf("gap back run_22222\n");
}
return false;
}
else if(PRINT_FORWARD_PAPER == Print_Process_Para.Paper_Back_Flag) //正向转时，走打印逻辑
{
//1 - 提前检测间隙 以下如果打印整张空白（偏移量=320时有问题）
// MyPrintf("cur_pix=%d\r\n",current_pix);
// if(current_pix == Print_Process_Para.PaperGap_Ready_Check_Pix_Count) //等于的时候容易导致各种不能进入位置检测程序而导致定标出错
if(current_pix >= Print_Process_Para.PaperGap_Ready_Check_Pix_Count)
{
// MyPrintf("star_to_check_gap---\r\n");
Print_Process_Para.PaperGap_Ready_Check_Flag = true; //打印完成了 (间隙纸)，开始检测
}
//安卓才走偏移
if(Print_Data_Cache.PrintDevice == 0){
if(PAPER_BLACKLABLE == Store_Para.Print_Paper_Type_Para.PrintPaperType){
if(current_pix < (Print_Data_Cache.PrintStartOffset+10) ) return false;
}else{
if(current_pix < (Print_Data_Cache.PrintStartOffset+6) ) return false;
}
}
//2 - 先走一段 越过去 GAP_PRINT_BLANK = 8
if(current_pix < GAP_PRINT_BLANK) {
// MyPrintf("current_pix2\n");
return false;
}
//3 - 有效数据打印
if(PAPER_BLACKLABLE == Store_Para.Print_Paper_Type_Para.PrintPaperType){
if( (current_pix <= (Print_Data_Cache.PrintRealHight + GAP_PRINT_BLANK+Print_Data_Cache.PrintStartOffset+10))
&&(current_pix >= GAP_PRINT_BLANK))
{
// MyPrintf("cur_pi_111\n");
Print_BufferData(); //从FIFO内读取数据，后进行打印
return false;
}
}else{
if((current_pix <= (Print_Data_Cache.PrintRealHight + GAP_PRINT_BLANK+Print_Data_Cache.PrintStartOffset+6))
&&(current_pix >= GAP_PRINT_BLANK))
{
// MyPrintf("cur_pi_222\n");
Print_BufferData(); //从FIFO内读取数据，后进行打印
return false;
}
}
//4 - 中间有效数据(结尾位置，用于停止电机用)
if(current_pix >= ( /* Print_Data_Cache.PrintRealHight //打印长度
+ PRINTHEAD_CUTTUR_PIX //打印头到切刀的距离
+ */PAPER_CALIBRATION_MAX_PIX //打印完，多久未检测到间隙，则停止打印 PAPER_CALIBRATION_MAX_PIX=800
+ GAP_PRINT_BLANK //间隙纸开始打印时，要先走多长的距离信息
))
{
//如果间隙值，大于结束像素的值 打印过程检测出错
MyPrintf("current_pix3\n");
Print_Gap_CheckInfo.Gap_Undetected_Flag = true;
return true;
}
}else{
MyPrintf("Print_check_err---\r\n");
}
return false;
}
/***********************************************************************************************************************
单击按键走纸到间隙位
*************************************************************************************************************************/
static bool Key_Feed_Gap_Paper(uint32_t current_pix)
{
{
//1 - 提前检测间隙 以下如果打印整张空白（偏移量=320时有问题）
// MyPrintf("current_pix=%d\r\n",current_pix);
if(current_pix == Print_Process_Para.PaperGap_Ready_Check_Pix_Count)
{
// MyPrintf("star_to_check_gap---\r\n");
Print_Process_Para.PaperGap_Ready_Check_Flag = true; //打印完成了 (间隙纸)，开始检测
}
//2 - 先走一段 越过去 GAP_PRINT_BLANK = 8
if(current_pix < GAP_PRINT_BLANK) {
// MyPrintf("current_pix2\n");
return false;
}
//3 - 有效数据打印
if( (current_pix <= (Print_Data_Cache.PrintRealHight + GAP_PRINT_BLANK+Print_Data_Cache.PrintStartOffset))
&&(current_pix >= GAP_PRINT_BLANK))
{
// MyPrintf("current_pix_111\n");
// Print_BufferData(); //从FIFO内读取数据，后进行打印
return false;
}
//4 - 中间有效数据(结尾位置，用于停止电机用)
if(current_pix >= ( /* Print_Data_Cache.PrintRealHight //打印长度
+ PRINTHEAD_CUTTUR_PIX //打印头到切刀的距离
+ */PAPER_CALIBRATION_MAX_PIX //打印完，多久未检测到间隙，则停止打印 PAPER_CALIBRATION_MAX_PIX=800
+ GAP_PRINT_BLANK //间隙纸开始打印时，要先走多长的距离信息
))
{
//如果间隙值，大于结束像素的值 打印过程检测出错
MyPrintf("current_pix3\n");
return true;
}
}
return false;
}
//连续纸打印
static bool Print_Continuous_Paper(uint32_t current_pix){
//倒转，退纸
if(PRINT_BACK_PAPER == Print_Process_Para.Paper_Back_Flag) {
Print_Process_Para.Paper_Back_Count++;
if(Print_Process_Para.Paper_Back_Count >= PRINTHEAD_CUTTUR_PIX) {
Print_Process_Para.Paper_Back_Count = 0; //纸张正转的计数信息
Print_Process_Para.Paper_Back_Flag = PRINT_FORWARD_PAPER; //纸张正转的标记信息
PrintMotor_Stop(); //停止步进电机
PrintMotor_Positive_Start(); //重新启动
//MyPrintf("continue back run,all_len:%d\n",Print_Data_Cache.PrintRealHight);
}
return false;
}
else if(PRINT_FORWARD_PAPER == Print_Process_Para.Paper_Back_Flag) { //正向转时，走打印逻辑
//1 - 加中间虚线
if(current_pix == (Print_Data_Cache.PrintBlank * 2 + Print_Data_Cache.PrintRealHight - 1)) {
if(Print_Data_Cache.PrintCurrentNum < Print_Data_Cache.PrintCopies)
{
API_Print_DotLine(); //打虚线
}
return false;
}
//2 - 前余白（不做处理，只走纸）
if(current_pix < (Print_Data_Cache.PrintBlank)) {
return false;
}
//3 - 中间有效数据
if( (current_pix <= (Print_Data_Cache.PrintBlank + Print_Data_Cache.PrintRealHight))
&&(current_pix >= Print_Data_Cache.PrintBlank) ) {
Print_BufferData(); //从FIFO内读取数据，后进行打印
return false;
}
//4 - 后余白结束
if(Print_Data_Cache.PrintCurrentNum == Print_Data_Cache.PrintCopies) { //最后一份，到多打出来给到切刀
if(current_pix >= (Print_Data_Cache.PrintBlank * 2 + Print_Data_Cache.PrintRealHight + PRINTHEAD_CUTTUR_PIX)){
return true;
}
}
else {
if(current_pix >= (Print_Data_Cache.PrintBlank * 2 + Print_Data_Cache.PrintRealHight)){
return true;
}
}
}
return false;
}
//============================================对外接口===============================================
//打印接口初始化 包括缓存 及打印头
void API_Print_Init(void){
//FIFO初始化
FIFO_PrintLineList_Init();
//打印头 初始化
Print_Control_Init();
}
//打印数据进入缓存
void API_PrintData_In(uint8_t* buf) {
// uint8_t offset_buf[PRINTER_LINE_BYTES] = {0}; //偏移位置缓存
// if(Print_Data_Cache.PrintRealWidth == 14){
// offset_buf[0] = 0;
// offset_buf[1] = buf[0];
// offset_buf[2] = buf[1];
// offset_buf[3] = buf[2];
// offset_buf[4] = buf[3];
// offset_buf[5] = buf[4];
// offset_buf[6] = buf[5];
// offset_buf[7] = buf[6];
// offset_buf[8] = buf[7];
// offset_buf[9] = buf[8];
// offset_buf[10] = buf[9];
// offset_buf[11] = buf[10];
// offset_buf[12] = buf[11];
// offset_buf[13] = 0;
// FIFO_PrintLineList_Add(offset_buf);
// }else
{
FIFO_PrintLineList_Add(buf);
}
}
//更新打印参数 (准备启动打印 0x17指令)
void API_PrintData_UpdatePar(_CMD_SET_TAPE_PARA *para) {
//收到参数后 计数重新归0
Print_Data_Cache.WriteProtocalCurrBytes = 0; //当前接字长
Print_Data_Cache.PrintCopies = para->PrintCopies; // 打印总份数
Print_Data_Cache.PrintCurrentNum = para->PrintCurrentNum; //当前打印的份数（第几份）
// MyPrintf("PrintCurrentNum..=%d\n",Print_Data_Cache.PrintCurrentNum);
Print_Data_Cache.PrintRealHight = para->PrintRealHight; //本次打印标签的总长度
// MyPrintf("PrintRealHight=%d\n",Print_Data_Cache.PrintRealHight); // 打印40的纸Print_Data_Cache.PrintRealHight=320， 打印75的纸是Print_Data_Cache.PrintRealHight=600
Print_Data_Cache.PrintRealWidth = para->PrintRealWidth; //本次打印标签的打印宽度
// MyPrintf("PrintRealWidth:%d\n",Print_Data_Cache.PrintRealWidth); //12
Print_Data_Cache.PrintStartOffset = para->PrintStartOffset; //本次打印偏移量
// MyPrintf("PrintStartOffset =%d\n",Print_Data_Cache.PrintStartOffset);
Print_Data_Cache.WriteProtocalTotalBytes = para->PrintTotalBytes; //本次打印标签的总字节数 包含包头
// MyPrintf("WriteProtocalTotalBytes =%d\n",Print_Data_Cache.WriteProtocalTotalBytes); //Print_Data_Cache.WriteProtocalTotalBytes = 3896,打印75长度纸时WriteProtocalTotalBytes = 7536
Print_Data_Cache.PrintDevice = para->PrintDevice; //设备型号 （安卓或苹果）
// MyPrintf("PrintDevice =%d\n",Print_Data_Cache.PrintDevice);
API_BT_State_Change(PRINT_GO); //打印机状态变更
API_Start_PrintHeat(); //开始打印并加热
Print_Gap_CheckInfo.PaperGap_ErrorFlag_Clear_Flag = true; //清掉“未检测到间隙纸”的报错标志
}
//强制停止打印
void API_Print_Stop(void){
//退纸计数
Print_Process_Para.Paper_Back_Count = 0; //纸张后退计数
Print_Process_Para.Paper_Back_Flag = PRINT_STILL_PAPER; //纸张后退标记定为无效
//间隙判断标记信息
// Print_Gap_CheckInfo.PaperGap_CheckGapTimesOver_Count = 0;
// Print_Gap_CheckInfo.PaperGap_CheckGapTimesOver_Flag = false;
// MyPrintf("APS_222.\r\n");
Print_Process_Para.Print_Current_Pix = 0; //像素位清0
FIFO_PrintLineList_Clear(); //清掉FIFO 停止打印
Calc_HeatTime_Struct.GridFlaf = false;
//打完了 变更状态信息
API_BT_State_Change(PRINT_END);
TIMER_MOTOR_STOP; //停止电机相关定时器
//停止打印电机
PrintMotor_Stop();
//份数信息清空
if(Print_Data_Cache.PrintCopies == Print_Data_Cache.PrintCurrentNum){
Print_Data_Cache.PrintCurrentNum = 0;
Print_Data_Cache.PrintCopies = 0;
}
//全部关停
Print_Data_Cache.PrintGoingAllFlag = false; //关停
State_Check_Para.CheckSuppliesFlag = 0;
//关闭打印头定时器 并停止加热
SPI_PrintHead_GPIO_Disability();
API_Print_Heat_Finish();
Print_Process_Para.Print_Job_Status_Flag = PRINT_STATUS_UNKNOWN ;
State_Check_Para.BlackPatchPrintFlag = false ; //打印黑块标志
}
//------------------------------------------------------单击按键走间隙纸---------------------------------------------------- U20目前没用
void Key_Short_Press_Feed_Gap()
{
static uint32_t Current_Temp_Count2 = 0;
static uint32_t Current_Temp_Count = 0;
MyPrintf("prees_ket_KeyVar----\r\n");
if(true == Print_Gap_CheckInfo.PaperGap_Check_Flag)
{
Current_Temp_Count++;
Current_Temp_Count2++;
//当走过的步数超过间隙纸最大步数或检测到间隙位时
// MyPrintf("Current_Temp_Count= %d\n\r",Current_Temp_Count);
MyPrintf("prees_ket_KeyVar----222222\r\n");
if((Current_Temp_Count >= Print_Gap_CheckInfo.PaperGap_GotoGap_All_Count) )
{
Current_Temp_Count = 0;
Current_Temp_Count2 = 0;
Print_Gap_CheckInfo.PaperGap_Check_Flag = false;
MyPrintf("prees_ket_KeyVar----33333\r\n");
//看是最后打印的1份还是中间的位数信息 像素信息置为0
Print_Process_Para.Print_Current_Pix = 0; //打印像素清0
Print_Process_Para.Paper_Back_Flag = PRINT_STILL_PAPER; //转为电机不动状态
Print_Gap_CheckInfo.PaperGap_GotoGap_Pre_Flag = false; //走间隙的标记 置为无效
// Var_Power_Control.Auto_Power_Off_Reclock_Flag = false;
//走到间隙位 则置为false 可以读fifo内的数据并且打印
Print_Gap_CheckInfo.PaperGap_Disable_Print_FIFO = false;
//强制停止
API_Print_Stop();
KeyVar.Key_Short_Press_Feed_Flag = false;
KeyVar.Key_Feed_Paper_Finish_Flag = true ; //走纸完成
MyPrintf("Key_Short_Press_Feed_Gap_1\n");
}
}
}
//标签控制 找到间隙位置或裁纸位置的信息
void IRQ_Tape_Control_Process(void)
{
static uint32_t Current_Temp_Count = 0;
//只有间隙纸 才OK
// if(PAPER_GAP != Store_Para.Print_Paper_Type_Para.PrintPaperType)
if(PAPER_CONTINUE == Store_Para.Print_Paper_Type_Para.PrintPaperType)
{
return;
}
{
// MyPrintf("print_to_GapVar----\r\n");
//检测到了间隙的位置
if(true == Print_Gap_CheckInfo.PaperGap_Check_Flag) {
//变量处理信息
Current_Temp_Count++;
// MyPrintf("Current_Temp_Count=%d\r\n",Current_Temp_Count);
// MyPrintf("All_Count=%d\r\n",Print_Gap_CheckInfo.PaperGap_GotoGap_All_Count);
if(Print_Process_Para.Print_Job_Status_Flag == CANCEL_PRINT){
if(PAPER_GAP == Store_Para.Print_Paper_Type_Para.PrintPaperType)
Print_Gap_CheckInfo.PaperGap_GotoGap_All_Count = PRINTHEAD_OPTICALCOUPLER_CUTTER; //到切刀
else if(PAPER_BLACKLABLE == Store_Para.Print_Paper_Type_Para.PrintPaperType)
Print_Gap_CheckInfo.PaperGap_GotoGap_All_Count = (PRINTHEAD_OPTICALCOUPLER_CUTTER-8); //到切刀
}
if(Current_Temp_Count >= Print_Gap_CheckInfo.PaperGap_GotoGap_All_Count) //当走过的步数超过裁纸位或打印位时
{
// Print_Gap_CheckInfo.PaperGap_Gap_NoCheck_ErrorFlag = true;
// Print_Gap_CheckInfo.PaperGap_GotoGap_Pre_Flag = false; //走间隙的标记 置
Current_Temp_Count = 0;
Print_Gap_CheckInfo.PaperGap_Check_Flag = false;
// MyPrintf("GapVar----\r\n");
//看是最后打印的1份还是中间的位数信息 像素信息置为0
Print_Process_Para.Print_Current_Pix = 0; //打印像素清0
Print_Process_Para.Paper_Back_Flag = PRINT_STILL_PAPER; //转为电机不动状态 IRQ_Print_Process()已经处理
Print_Gap_CheckInfo.PaperGap_GotoGap_Pre_Flag = false; //走间隙的标记 置为无效 IRQ_Print_Process()已经处理
Print_Gap_CheckInfo.PaperGap_Gap_NoCheck_ErrorFlag = false;
//走到间隙位 则置为false 可以读fifo内的数据并且打印
Print_Gap_CheckInfo.PaperGap_Disable_Print_FIFO = false;
//看是否为最后一份,如果是最后1份，就彻底停止。非最后一1份，则只更新状态信息
if(Print_Data_Cache.PrintCurrentNum >= Print_Data_Cache.PrintCopies)
{
// MyPrintf("GapVar----111\r\n");
//强制停止
API_Print_Stop();
Matchine_5V_PrintHead_Motor_Power_Off(); //关闭电机及打印头电源
}
else //非最后一份，则只需要更新当前状态
{
// MyPrintf("GapVar----222\r\n");
API_Print_NoLast_Copies_Stop();
}
}
} //未检测到会怎样？
}
}
//定时器打印控制（电机走1个像素 执行1次 ）
void IRQ_Print_Process(void)
{
//电机处于未前进&未后退的状态时 则不做打印流程
if(PRINT_STILL_PAPER == Print_Process_Para.Paper_Back_Flag) {
//打完了 变更状态信息(未处在定标模式下)
if(false == Print_Gap_CheckInfo.PaperGap_Calibration_Flag) {
// MyPrintf("PRINT_STILL_PAPER---\r\n");
API_BT_State_Change(PRINT_END);
}
return;
}
//正常打印逻辑
switch(Store_Para.Print_Paper_Type_Para.PrintPaperType)
{
//------------------------------------连续纸----------------------------------
case PAPER_CONTINUE:
{
//获取当前的像素信息(超过当前信息，则数据清0)
if(true == Print_Continuous_Paper(Print_Process_Para.Print_Current_Pix))
{
Print_Process_Para.Print_Current_Pix = 0;
//最后一份 则做彻底停止处理
if(Print_Data_Cache.PrintCurrentNum >= Print_Data_Cache.PrintCopies){
API_Print_Stop();
}
else{ //非最后一份，则只需要更新当前状态
API_Print_NoLast_Copies_Stop();
}
}
//像素计数 变更
if(PRINT_BACK_PAPER == Print_Process_Para.Paper_Back_Flag){
Print_Process_Para.Print_Current_Pix = 0; //倒转 像素值 = 0
}
else if(PRINT_FORWARD_PAPER == Print_Process_Para.Paper_Back_Flag){
Print_Process_Para.Print_Current_Pix++; //正转 像素值 + 1
}
break;
}
//------------------------------------间隙纸或者黑标纸----------------------------------
case PAPER_BLACKLABLE:
case PAPER_GAP:
{
//获取当前的像素信息(超过当前信息，则数据清0) （间隙纸停止由光耦控制）
if(true == Print_Gap_Paper(Print_Process_Para.Print_Current_Pix))
{
Print_Process_Para.Print_Current_Pix = 0; //打印的信息
Print_Process_Para.Paper_Back_Flag = PRINT_STILL_PAPER; //转为电机不动状态
// MyPrintf("PAPER_GAP11\r\n");
//未检测到间隙 报错
Print_Gap_CheckInfo.PaperGap_Gap_NoCheck_ErrorFlag = true;
Print_Gap_CheckInfo.PaperGap_GotoGap_Pre_Flag = false; //走间隙的标记 置为无效
// MyPrintf("Gap_NoCheck_ErrorFlag---\r\n");
Matchine_5V_PrintHead_Motor_Power_Off(); //关闭电机及打印头电源
//最后一份 则做彻底停止处理
if(Print_Data_Cache.PrintCurrentNum >= Print_Data_Cache.PrintCopies)
{
// MyPrintf("PAPER_GAP22\r\n");
//强制停止
API_Print_Stop();
}
else //非最后一份，则只需要更新当前状态
{
// MyPrintf("PAPER_GAP33\r\n");
API_Print_NoLast_Copies_Stop();
}
}else if((Print_Gap_CheckInfo.Uncover_Flag)||(Print_Gap_CheckInfo.No_Paper_Flag)||(Charge_Control_Flag.Power_Bat_Low_Flag)
||(State_Check_Para.State_PrintHeadTemp_Check)||(State_Check_Para.State_BatteryTemp_Check == BATTERY_TEMP_OVER_HIGH)
||(State_Check_Para.State_BatteryTemp_Check == BATTERY_TEMP_OVER_LOW)||(Print_Gap_CheckInfo.PaperGap_Gap_NoCheck_ErrorFlag))
{
Print_Process_Para.Print_Current_Pix = 0; //报错时 像素值 = 0
Matchine_5V_PrintHead_Motor_Power_Off(); //关闭电机及打印头电源
FIFO_PrintLineList_Clear(); //清掉FIFO 停止打印
FIFO_DataAnalysis_Clear(); //解析数据清除
Print_Data_Cache.PrintCurrentNum = 0;
Print_Data_Cache.PrintCopies = 0;
Calc_HeatTime_Struct.GridFlaf = false;
if(Print_Data_Cache.PrintCurrentNum >= Print_Data_Cache.PrintCopies)
{
API_Print_Stop();
}
else //非最后一份，则只需要更新当前状态
{
API_Print_NoLast_Copies_Stop();
}
}
//像素计数 变更
if(PRINT_BACK_PAPER == Print_Process_Para.Paper_Back_Flag) {
Print_Process_Para.Print_Current_Pix = 0; //倒转 像素值 = 0
// MyPrintf("PAPER_GAP44\r\n");
}
else if(PRINT_FORWARD_PAPER == Print_Process_Para.Paper_Back_Flag) {
Print_Process_Para.Print_Current_Pix++; //正转 像素值 + 1
// MyPrintf("PAPER_GAP55\r\n");
}
break;
}
default:
{
break;
}
}
Get_Gap_Current_Locate_Kalman();
}
/******************************************************************************
版权所有： 深圳科技有限公司
文件名： api_print.h
作者： ***
创建日期： 2020/7/9
描述： 打印处理接口
其它：
修改历史： //修改历史记录列表，每条修改记录应包含修改日期、修改者及修改内容简述
序号 修改时间 修改人 修改内容
???? ????/??/?? ?????? 参考样式
******************************************************************************/
/*********************************防止多次编译*********************************/
#ifndef _API_PRINT_H
#define _API_PRINT_H
/************************************头文件************************************/
#include <stdint.h>
#include <stdbool.h>
#include "bsp_print_control.h"
#include "api_data_analysis.h"
#include "tools_fifo.h"
/************************************宏定义************************************/
/*******************************************************************************
124 转速比
7.2 直径
7.09 打印头 1mm对应的像素点
步进电机转一圈对应的像素点： (1 / 124) * Pi * 7.2 * 7.09 = 1.29
步进电机一个脉冲所对应的像素点：(1 / 124) * Pi * 7.2 * 7.09 / 20 = 0.06455
一个像素点对步进电机的脉冲数： 1/（(1 / 124) * Pi * 7.2 * 7.09 / 20） = 15.49
现有的方案是 一个像素15个脉宽，下一个像素16个脉冲
*******************************************************************************/
/************************************枚举************************************/
//ID
typedef enum
{
Enum_Get_Bt_State = 0x40, //是否支持蓝牙升级
Enum_Firmware_ID, //Firmware版本ID
Enum_Productor , //厂商
Enum_PrinteName , //打印机名称
Enum_PrinteID , //打印机序列号
Enum_PrinteWordType , //支持汉字类型
Enum_BtMacAddr , //蓝牙的物理地址
Enum_Shutdown_Time, //读取关机时间
Enum_Get_Supplies_Info, //读取耗材信息
}PRINT_MSG_ID_INFO;
//写入的区域
typedef enum
{
RemainArea = 0x01, //保留区
EPCArea, //EPC区
TIDArea, //TID区
UserArea, //用户数据区
}RFID_WRITE_AREA_ENUM;
//当前打印状态
typedef enum
{
PRINT_GO = 1,
PRINT_END,
}PRINT_UPLOAD_STATE;
//打印浓度对应的温度值
typedef enum
{
NORMAL_TEMP = 41, //默认35度
}_PRINT_DENSITY_TEMP;
//当前打印的步骤
typedef enum
{
PRINT_NONE = 0x01, //未打印
MOTOR_BEFORE_PRINT, //主要是用于剪切处 判断当前的状态 看如何进行
PRINT_FINISH, //打印剪切完成
}_CURRENT_PRINT_STEP;
//判断是全部完成的包 还是部分完成的包
typedef enum
{
PRINT_NO_FINISH = 0x00,
PRINT_CURRENT_FINISH, //当前包完成
PRINT_ALL_FINISH, //所有包完成
}_PRINT_FINISH_TYPE_ENUM;
//退纸信息
typedef enum
{
PRINT_STILL_PAPER = 0, //当前前进后退无效状态，不进行操作
PRINT_BACK_PAPER, //纸张后退
PRINT_FORWARD_PAPER, //纸张前进
PRINT_BLANK_PAPER, //纸张前进(不打印 只走纸到间隙)
}_PRINT_BACK_PAPER_ENUM;
typedef enum {
PRINT_STATUS_UNKNOWN = 0,
CANCEL_PRINT, //取消打印
PAUSE_PRINTING, //暂停打印
CONTINUE_TO_PRINT, //继续打印
}PRINTJOBENUM;
/************************************结构体************************************/
#pragma pack(push)
#pragma pack(1)
//状态检测 参数信息
typedef struct
{
volatile uint32_t Print_Current_Pix; //当前打印的步骤信息
volatile _PRINT_BACK_PAPER_ENUM Paper_Back_Flag; //退纸标记（纸张后退OR前进）
volatile uint32_t Paper_Back_Count; //退纸计数
volatile bool PaperGap_Ready_Check_Flag; //准备检测间隙纸
volatile uint32_t PaperGap_Ready_Check_Pix_Count; //准备检测间隙纸的对应的像素点（开始）
volatile bool Print_FIFO_Empty_Flag; //FIFO空标记
volatile uint32_t Print_FIFO_Empty_Count; //FIFO空计数
volatile bool Print_Total_Copies_Finish_Flag ; //打印总份数完成标志
volatile PRINTJOBENUM Print_Job_Status_Flag; //打印任务状态标志
}_PRINT_PROCESS_PARA;
//打印字及其缓存信息
typedef struct
{
volatile _PRINT_DENSITY_TEMP PrintDensityTemp;//打印头对应的温度信息
volatile uint16_t PrintHeatTime; //打印头加热时间
volatile bool PrintGoingAllFlag; //打印全部完成
volatile uint32_t WriteProtocalCurrBytes; //当前字长（下一包协议 没用）
volatile uint32_t WriteProtocalTotalBytes; //写协议总长（包含包头信息） ）
volatile uint16_t PrintRealHight; //表示本次打印标签的实际内容的总长度
//为nL+nH*256个点(实际有效打印的高度)
volatile uint16_t PrintStartOffset; //表示本次打印标签纵向的起始偏移量
//长度为sL+sH*256个点(标签的起始位置到
//有效打印内容之间的距离)
volatile uint16_t PrintAllPix; //打印的总长度
volatile uint8_t PrintRealWidth; //打印的实际的宽度
volatile uint16_t PrintCopies; //打印的总份数
volatile uint16_t PrintCurrentNum; //当前打印的是第几张
volatile uint8_t PrintAfterCutFlag; //当前打印完成后 是否进行剪切
volatile uint8_t PrintDensity; //打印浓度
volatile uint8_t PrintSpeed; //打印速度
volatile uint8_t PrintMode; //打印模式
volatile uint16_t TabWidthMM; //xl xh为标签横向的宽度，单位毫米
volatile uint16_t TabHightPix; //yl yh为标签纵向的高度，单位点(像素)
volatile uint32_t TTRLength; //碳带长度
volatile uint16_t TapeUsedLength; //已使用色带长度
volatile uint16_t TapeRemainLength; //剩余色带长度
volatile uint8_t PrintDevice; //设备型号 ANDROID OR IOS???
// volatile _PRINTPAPER_TYPE_ENUM PrintPaperType; //纸张类型
volatile uint8_t PrintPix_Offset_Stable; //打印-固定像素偏移（结构工差）
volatile uint8_t PrintPix_Tape_Offset; //打印-像素偏移（用于6/9/12mm做像素偏移）
volatile uint16_t PrintBlank; //留白配置
volatile uint8_t PrintCutMode; //剪切模式（剪切or不剪切）
}_PRINT_DATA_CACHE;
//打印状态
typedef struct
{
uint32_t PrintHeating : 1; //是否正在加热
uint32_t PrintPaperAvaliable: 1; //是否有纸可用
uint32_t PrintRecv : 1; //是否收到打印数据状态
uint32_t PrintFinish : 1; //打印机内容是否打印完成
uint32_t PrintError : 1; //打印机是否有错误
uint32_t PrintPause : 1; //打印机是否暂停
uint32_t PrintCancel : 1; //打印内容被取消
uint32_t NC: 24; //空余内容
}_CURRENT_PRINT_STATE;
//记录光耦的每次对应的像素值的信息
typedef struct
{
bool PaperGap_Check_Flag; //打印的过程中的标记信息
//间隙打印 走到间隙位
bool PaperGap_GotoGap_Pre_Flag; //间隙打印 准备定标标记
//定标用功能
uint32_t PaperGap_Calibration_Count; //定标的计数信息
uint32_t PaperGap_Calibration_DestCount; //定标的计数信息 目标距离 信息
bool PaperGap_Calibration_Flag; //定标的标记信息
bool PaperGap_CheckLocation_Finish_Flag; //定标的标记信息
bool PaperGap_Calibration_Success_Flag;//定标的成功Or失败
//间隙纸 多走一部分纸的功能信息
uint32_t PaperGap_GotoGap_All_Count; //总计数信息
//开始读缓存 打印
bool PaperGap_Disable_Print_FIFO; //禁止从FIFO打印数据
//间隙纸相关信息
bool PaperGap_Calibration_ErrorFlag; //出错标记信息
bool PaperGap_Gap_NoCheck_ErrorFlag; //出错标记信息 ，未检测到间隙纸
//有发送过故障信息 则将数据清0
bool PaperGap_ErrorFlag_Clear_Flag; //间隙纸有关故障 发送完成后 清为无效
//临时变量 在找间隙的时候用
bool PaperGap_CheckGapTimesOver_Flag;//检测到了间隙一定的次数
uint8_t PaperGap_CheckGapTimesOver_Count;//检测到了间隙的计数的信息
bool No_Paper_Flag; //没有任何纸张或者耗材的标志
bool Uncover_Flag; //机器开盖标志
uint16_t Clear_Gap_NoCheck_ErrorFlag_Count; //清除“未检测到间隙纸”错误标志计时
bool Gap_Undetected_Flag; //超过步数了还没检测到间隙标志
}_PRINT_PAPER_CHECK_INFO;
#pragma pack(pop)
/**********************************可导出变量**********************************/
extern _PRINT_PROCESS_PARA Print_Process_Para; //打印过程中变量
extern _PRINT_DATA_CACHE Print_Data_Cache; //缓存的个数
extern _CURRENT_PRINT_STATE Current_Print_State; //当前打印状态
extern _CURRENT_PRINT_STEP Current_Print_Step; //当前打印步骤
extern _PRINT_PAPER_CHECK_INFO Print_Gap_CheckInfo; //当前间隙的检测信息
//extern _PRINT_DATA_CACHE Print_Data_Cache ;
/***********************************函数实现***********************************/
void API_Print_Init(void); //主要是fifo和变量初始化
void API_Print_Stop(void); //中途停止打印
void API_Print_NoLast_Copies_Stop(void);
void API_PrintData_In(uint8_t* buf); //进fifo(当前尺寸 用于0x15用)
void API_PrintData_UpdatePar(_CMD_SET_TAPE_PARA *para); //更新参数
//中断相关
void IRQ_Print_Process(void); //打印控制
void IRQ_Tape_Control_Process(void); //间隙纸控制
extern void API_BT_State_Change(PRINT_UPLOAD_STATE upload_state);
#endif
/******************************************************************************
版权所有： 深圳市普实科技有限公司
文件名： api_state_check.c
作者： ***
创建日期： 2020/07/9
描述： 打印过程状态检测
其它：
修改历史： //修改历史记录列表，每条修改记录应包含修改日期、修改者及修改内容简述
序号 修改时间 修改人 修改内容
???? ????/??/?? ?????? 参考样式
******************************************************************************/
/************************************头文件************************************/
#include "api_state_check.h"
#include "api_print.h"
#include "bsp_motor_control.h"
#include "api_led_watchdog.h"
#include "api_power_control.h"
#include "api_para_set.h"
#include "api_test.h"
#include "api_sensorcheck.h"
#include "bsp_beep_control.h"
#include <string.h>
#include "api_supplies.h"
#include "hal_SuppliesAuth.h"
#include "api_key.h"
#include "bsp_power_control.h"
#include "api_paper_calibration.h"
#include "bsp_charge_control.h"
#include "tools_calc_heattime.h"
/*************************************变量*************************************/
bool ErrorFlag = false; //错误打印
//传输错误信息
_TRANSFER_ERROR_STATE Transfer_Error_Flag = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; //传输错误信息
_BEEP_CONTROL_PARA Beep_Control_Para = {0}; //蜂鸣器控制参数信息
PaperStateInfoTypeDef PaperStateInfo = { //纸张当前的状态信息
.HavePaper = SENSOR_NOPAPER,
.Position = POSITION_UNKNOW,
.ADCValue = 0,
};
_STATE_CHECK_PARA State_Check_Para = {
.State_MotorCheck =
{
0,
MOTOR_STATE_STOP, //默认电机停止,
false,
},
.State_BatteryTemp_Check = BATTERY_TEMP_NORMAL,
.State_PrintHeadTemp_Check = PRINT_HEAD_TEMP_NORMAL,
.ToCoolingOfFirstFlag = 0, //降温标志1
.ToCoolingOfSecondFlag = 0, //降温标志2
.ToCoolingOfThirdFlag = 0, //降温标志3
.CheckSuppliesFlag = 0 , //
};
//ADC值转换为温度，打印头温度不能超过45°
const unsigned int Thermistor_ADC_Temp_Converter[26]={
148, //25° 0
142, //26° 1
136, //27°
130, //28°
125, //29°
120, //30°
115, //31°
110, //32°
105, //33°
100, //34°
95, //35° 10
91, //36°
87, //37°
83, //38°
79, //39°
75, //40° 15
71, //41°
67, //42°
63, //43°
59, //44°
55, //45° 20
51, //46°
48, //47°
45, //48°
42, //49°
38, //50°
};
/*************************************函数*************************************/
//打印电机初始化
void PrintMotor_Speed_Init(void) {
Motor_Control_Init();
PrintMotor_Control_Set(MOTOR_RUN_INVERSE,false);
}
//打印电机 启动 正转
void PrintMotor_Positive_Start(void) {
State_Check_Para.State_MotorCheck.PrintMotor_ErrFlag = false; //开始认为电机没错误
State_Check_Para.State_MotorCheck.PrintMotor_RunState = MOTOR_STATE_PRINTING; //电机准备启动（打印）
//启动电机
PrintMotor_Control_Set(MOTOR_RUN_POSITIVE,true);
// PrintMotor_Control_Set(MOTOR_RUN_INVERSE,true);
}
//打印电机 倒转
void PrintMotor_Inverse_Start(void) {
State_Check_Para.State_MotorCheck.PrintMotor_ErrFlag = false; //开始认为电机没错误
State_Check_Para.State_MotorCheck.PrintMotor_RunState = MOTOR_STATE_PRINTING; //电机准备启动（打印）
//启动电机
PrintMotor_Control_Set(MOTOR_RUN_INVERSE,true);
// PrintMotor_Control_Set(MOTOR_RUN_POSITIVE,true);
}
//正转N pix
void PrintMotor_Positive_Start_Steps(uint32_t pix){
if(State_Check_Para.State_MotorCheck.PrintMotor_RunState != MOTOR_STATE_STOP){
return;
}
State_Check_Para.State_MotorCheck.PrintMotor_ErrFlag = false; //开始认为电机没错误
State_Check_Para.State_MotorCheck.PrintMotor_Pix_Nums_Positive = pix;
State_Check_Para.State_MotorCheck.PrintMotor_RunState = MOTOR_STATE_RUN_PAPER_POSITIVE; //,
// State_Check_Para.State_MotorCheck.PrintMotor_RunState = MOTOR_STATE_RUN_PAPER_REVERSE;
//启动电机
PrintMotor_Control_Set(MOTOR_RUN_POSITIVE,true);
// PrintMotor_Control_Set(MOTOR_RUN_INVERSE,true);
}
//倒转N pix
void PrintMotor_Inverse_Start_Steps(uint32_t pix){
if(State_Check_Para.State_MotorCheck.PrintMotor_RunState != MOTOR_STATE_STOP){
return;
}
State_Check_Para.State_MotorCheck.PrintMotor_ErrFlag = false; //开始认为电机没错误
State_Check_Para.State_MotorCheck.PrintMotor_Pix_Nums_Reverse = pix;
State_Check_Para.State_MotorCheck.PrintMotor_RunState = MOTOR_STATE_RUN_PAPER_REVERSE;
// State_Check_Para.State_MotorCheck.PrintMotor_RunState = MOTOR_STATE_RUN_PAPER_POSITIVE;
//启动电机
PrintMotor_Control_Set(MOTOR_RUN_INVERSE,true);
// PrintMotor_Control_Set(MOTOR_RUN_POSITIVE,true);
}
//停止电机
void PrintMotor_Stop(void) {
State_Check_Para.State_MotorCheck.PrintMotor_RunState = MOTOR_STATE_STOP; //电机停止转动
//停止电机
PrintMotor_Control_Set(MOTOR_RUN_POSITIVE,false);
}
//机器状态检测
void Machine_State_Check(void) {
static uint16_t Btdisconnected_Count = 0; //蓝牙断开连接计数
//-------------------------错误状态更新，用于协议挂接-----------------------
//固定
//MyPrintf("PCN..=%d\r\n",Print_Data_Cache.PrintCurrentNum);
Transfer_Error_Flag.Fixed_1 = 1;
// Transfer_Error_Flag.NC = 0; //预留字节
//该设备不存在的故障信息
Transfer_Error_Flag.MovementState = 0;
Transfer_Error_Flag.RFIDWriteError = 0; //写RFID出错
Transfer_Error_Flag.CutterState = 0; //剪切正常
Transfer_Error_Flag.CurrentPrintState = 0; //剪切状态信息
Transfer_Error_Flag.NoLabel = 0; //1是没检测到标签
if((Print_Data_Cache.PrintCopies != 0)&&(Print_Data_Cache.PrintCurrentNum != 0)){
if(BtRxTxVar.BtBleConnectStateFlag == false) //蓝牙没连接
Btdisconnected_Count++;
if(50 <= Btdisconnected_Count){
Btdisconnected_Count = 0;
Print_Data_Cache.PrintCurrentNum = 0;
Print_Data_Cache.PrintCopies = 0;
}
}
// MyPrintf("Bt..c=%d\r\n",BtRxTxVar.BtBleConnectStateFlag);
if((Print_Data_Cache.PrintGoingAllFlag == false)&&(Print_Process_Para.Print_Job_Status_Flag == CANCEL_PRINT))
{
Print_Process_Para.Print_Job_Status_Flag = PRINT_STATUS_UNKNOWN;
Print_Data_Cache.PrintCurrentNum = 0;
Print_Data_Cache.PrintCopies = 0;
}
//判断有无色带
if(1)
{
Transfer_Error_Flag.TTRspent = 0; //碳带用完
// Transfer_Error_Flag.NoPapper = 0; //纸用完
Transfer_Error_Flag.TTRrecognize = 0; //碳带识别
}
else
{
Transfer_Error_Flag.TTRspent = 1; //碳带用完
// Transfer_Error_Flag.NoPapper = 1; //纸用完
Transfer_Error_Flag.TTRrecognize = 1; //碳带识别
}
// if(!Current_Print_State.PrintFinish){
// ErrorFlag = true;
// }
//电量过低
if(Charge_Control_Flag.Power_Bat_Low_Flag)
{
// MyPrintf("Power_Bat_Low--111\r\n");
Transfer_Error_Flag.BatLowPowerState = 1; //电池电量过低
State_Check_Para.BlackPatchPrintFlag = false ;
FIFO_PrintLineList_Clear(); //清掉FIFO 停止打印
FIFO_DataAnalysis_Clear(); //解析数据清除
Print_Data_Cache.PrintCurrentNum = 0;
Print_Data_Cache.PrintCopies = 0;
ErrorFlag = true;
}
else
{
Transfer_Error_Flag.BatLowPowerState = 0; //电池电量正常
// ErrorFlag = false;
}
//定标错误信息 && 未找到间隙 用一个标记位信息
if((Print_Gap_CheckInfo.PaperGap_Calibration_ErrorFlag)
||(Print_Gap_CheckInfo.PaperGap_Gap_NoCheck_ErrorFlag) )
{
MyPrintf("ErrorFlag--222\r\n");
Transfer_Error_Flag.PaperGap_NoCheckGapState = 1; //间隙纸定标错误
State_Check_Para.BlackPatchPrintFlag = false ;
ErrorFlag = true;
}
else
{
Transfer_Error_Flag.PaperGap_NoCheckGapState = 0; //间隙纸定标正常
// ErrorFlag = false;
}
//打印机缺纸
if(Print_Gap_CheckInfo.No_Paper_Flag){
// MyPrintf("ErrorFlag--333\r\n");
Transfer_Error_Flag.NoPapper = 1; //打印机缺纸
State_Check_Para.BlackPatchPrintFlag = false ;
ErrorFlag = true;
FIFO_PrintLineList_Clear(); //清掉FIFO 停止打印
FIFO_DataAnalysis_Clear(); //解析数据清除
Print_Data_Cache.PrintCurrentNum = 0;
Print_Data_Cache.PrintCopies = 0;
MyPrintf("NoPapper = 1\r\n");
}
else{
Transfer_Error_Flag.NoPapper = 0;
// ErrorFlag = false;
}
//电池温度异常
if((State_Check_Para.State_BatteryTemp_Check == BATTERY_TEMP_OVER_HIGH)||(State_Check_Para.State_BatteryTemp_Check == BATTERY_TEMP_OVER_LOW)){
MyPrintf("ErrorFlag--BatteryTemp_Check\r\n");
// Transfer_Error_Flag.NoLabel = 1;
Transfer_Error_Flag.BatTempState = 1;
State_Check_Para.BlackPatchPrintFlag = false ;
ErrorFlag = true;
FIFO_PrintLineList_Clear(); //清掉FIFO 停止打印
FIFO_DataAnalysis_Clear(); //解析数据清除
Print_Data_Cache.PrintCurrentNum = 0;
Print_Data_Cache.PrintCopies = 0;
}
else
{
// Transfer_Error_Flag.NoLabel = 0;
Transfer_Error_Flag.BatTempState = 0;
// ErrorFlag = false;
}
//打印头高温
if(State_Check_Para.State_PrintHeadTemp_Check){
MyPrintf("ErrorFlag--PrintHeadTemp_Check\r\n");
Transfer_Error_Flag.PrintHeadOverHeat = 1;
State_Check_Para.BlackPatchPrintFlag = false ;
ErrorFlag = true;
FIFO_PrintLineList_Clear(); //清掉FIFO 停止打印
FIFO_DataAnalysis_Clear(); //解析数据清除
Print_Data_Cache.PrintCurrentNum = 0;
Print_Data_Cache.PrintCopies = 0;
}
else{
Transfer_Error_Flag.PrintHeadOverHeat = 0;
// ErrorFlag = false;
}
//打印机开盖
if(Print_Gap_CheckInfo.Uncover_Flag){
MyPrintf("ErrorFlag--666\r\n");
Transfer_Error_Flag.UpCoverState = 1; //打印机开盖
State_Check_Para.BlackPatchPrintFlag = false ;
ErrorFlag = true;
FIFO_PrintLineList_Clear(); //清掉FIFO 停止打印
FIFO_DataAnalysis_Clear(); //解析数据清除
Print_Data_Cache.PrintCurrentNum = 0;
Print_Data_Cache.PrintCopies = 0;
}
else{
Transfer_Error_Flag.UpCoverState = 0;
// ErrorFlag = false;
}
//发送间隙故障信息完成后 标记清空为无效
if(true == Print_Gap_CheckInfo.PaperGap_ErrorFlag_Clear_Flag)
{
Print_Gap_CheckInfo.PaperGap_ErrorFlag_Clear_Flag = false; //清空间隙相关的错误标记信息
Print_Gap_CheckInfo.PaperGap_Gap_NoCheck_ErrorFlag = false; //清除掉未检测到间隙错误
//发送完 切刀和间隙问题故障后 该故障清0
if((Print_Gap_CheckInfo.PaperGap_Calibration_ErrorFlag)
||(Print_Gap_CheckInfo.PaperGap_Gap_NoCheck_ErrorFlag))
{
Print_Gap_CheckInfo.PaperGap_Calibration_ErrorFlag = false; //清掉色带定标错误信息
}
}
if(Print_Gap_CheckInfo.Clear_Gap_NoCheck_ErrorFlag_Count>3000){
Print_Gap_CheckInfo.PaperGap_Calibration_ErrorFlag = false; //清掉色带定标错误信息
Print_Gap_CheckInfo.PaperGap_Gap_NoCheck_ErrorFlag = false; //清除掉未检测到间隙错误
Print_Gap_CheckInfo.Clear_Gap_NoCheck_ErrorFlag_Count = 0;
}
//-------------------------------总故障状态---------------------------------
if(ErrorFlag)
{
Current_Print_State.PrintError = true ;
// MyPrintf("PrintError--check = %d \r\n",Current_Print_State.PrintError);
TestMode_Error_Flag = true;
Print_Data_Cache.PrintCurrentNum = 0;
Print_Data_Cache.PrintCopies = 0;
Calc_HeatTime_Struct.GridFlaf = false;
}
else
{
Current_Print_State.PrintError = 0;
TestMode_Error_Flag = false;
}
//-------------------------------打印关联----------------------------------
if(Print_Data_Cache.PrintGoingAllFlag) //打印中
{
if((Charge_Control_Flag.Power_Bat_Low_Flag))
{
API_Print_Stop();
}
}
if((Print_Gap_CheckInfo.Uncover_Flag == false) && (State_Check_Para.State_PrintHeadTemp_Check == false) && (Print_Gap_CheckInfo.No_Paper_Flag == false)
&&(Print_Gap_CheckInfo.PaperGap_Gap_NoCheck_ErrorFlag == false)&& (Charge_Control_Flag.Power_Bat_Low_Flag == false))
{
ErrorFlag = false;
}
// MyPrintf("Transfer_Error_Flag = %d\r\n",Transfer_Error_Flag);
}
//正转 固定长度 电机定时器中断触发 -----------------------------------------------------------------------------
void IRQ_Motor_Positive_RunSteps(){
if(State_Check_Para.State_MotorCheck.PrintMotor_Pix_Nums_Positive > 0){
State_Check_Para.State_MotorCheck.PrintMotor_Pix_Nums_Positive--;
if(0 == State_Check_Para.State_MotorCheck.PrintMotor_Pix_Nums_Positive){
State_Check_Para.State_MotorCheck.PrintMotor_RunState = MOTOR_STATE_STOP; //电机停止转动
PrintMotor_Control_Set(MOTOR_RUN_POSITIVE,false); //停止电机
}
}
}
//反转 固定长度 电机定时器中断触发
void IRQ_Motor_Reverse_RunSteps(){
if(State_Check_Para.State_MotorCheck.PrintMotor_Pix_Nums_Reverse > 0){
State_Check_Para.State_MotorCheck.PrintMotor_Pix_Nums_Reverse--;
if(0 == State_Check_Para.State_MotorCheck.PrintMotor_Pix_Nums_Reverse){
State_Check_Para.State_MotorCheck.PrintMotor_RunState = MOTOR_STATE_STOP; //电机停止转动
PrintMotor_Control_Set(MOTOR_RUN_INVERSE,false); //停止电机
}
}
}
//获取当前的位置信息
void Get_Gap_Current_Locate_Info() //目前没用
{
uint16_t ad_value;
static uint16_t last_ad_value;
static uint8_t Step = 0 ;
static uint8_t On_Gap_Counter = 0;
//只有间隙纸 才OK
if((PAPER_GAP == Store_Para.Print_Paper_Type_Para.PrintPaperType)||(PAPER_BLACKLABLE == Store_Para.Print_Paper_Type_Para.PrintPaperType))
{
EnableSensor(PAPER_GAP,Store_CalibrationPara.SelectIndex);
ad_value = StartSensorChannelADCValue();
MyPrintf("ad_value=%d\n\r",ad_value);
// MyPrintf("GapRef=%d\n\r",Store_CalibrationPara.GapRef);
//开始检测间隙位置
if(true == Print_Process_Para.PaperGap_Ready_Check_Flag)
{
switch(Step)
{
case 0:
if ((ad_value >= (Store_CalibrationPara.HavePaperRef-10)) && (ad_value<1200)) //有纸
{
if(ad_value <= (Store_CalibrationPara.GapRef-100)) //ADC值小于400
{
MyPrintf("Step=0\n\r");
Step = 1;
}
}
break;
case 1:
if(ad_value <= (Store_CalibrationPara.GapRef-130)) //ADC值小于320
{
MyPrintf("Step=1\n\r");
Step = 4;
}
break;
case 2:
if(ad_value <= (Store_CalibrationPara.GapRef-200)) //ADC值小于270
{
MyPrintf("Step=2\n\r");
Step = 4; //不去执行第三步了
}
break;
case 3:
if(ad_value <= (Store_CalibrationPara.GapRef-210)) //ADC值小于230
{
MyPrintf("Step=3\n\r");
Step = 4;
}
break;
case 4:
MyPrintf("Step=4\n\r");
last_ad_value = ad_value;
Step = 5;
break;
case 5:
if(ad_value>=last_ad_value ) //走过间隙ADC值开始变大
{
On_Gap_Counter ++ ;
if(On_Gap_Counter>=3){
//该标记置为有效 则计数处理
Print_Gap_CheckInfo.PaperGap_Check_Flag = true;
Print_Process_Para.PaperGap_Ready_Check_Flag = false;
MyPrintf("gap_true\n");
Step = 0;
}
else{
last_ad_value = ad_value;
Step = 5;
}
}
else{
last_ad_value = ad_value;
Step = 5;
}
break;
default:
break;
}
}
}else{
return;
}
}
//计算当前的位置信息
void Get_Gap_Current_Locate_Kalman()
{
static uint8_t Step = 0 ;
// MyPrintf("Get_Gap_Current_Locate_Kalman\n");
//只有间隙纸 才OK
if((PAPER_GAP == Store_Para.Print_Paper_Type_Para.PrintPaperType)||(PAPER_BLACKLABLE == Store_Para.Print_Paper_Type_Para.PrintPaperType))
{
//判断其是否持续一段时间的间隙
if(true == Print_Process_Para.PaperGap_Ready_Check_Flag)
{
// MyPrintf("111111111...\n");
switch(Step)
{
case 0:
// MyPrintf("current_gap_state=%d\n\r",Paper_Location_Info.current_gap_state);
if(PAPER_GAP == Store_Para.Print_Paper_Type_Para.PrintPaperType){
if(Paper_Location_Info.current_gap_state == PAPER_FILTER_UP && Paper_Location_Info.last_gap_state != PAPER_FILTER_HOLD)
{
// Print_Process_Para.PaperGap_Ready_Check_Flag = false;
// MyPrintf("gap_PAPER_FILTER_UP_11\n");
MyPrintf("gap_true_000\n");
Step = 1;
}else if(Print_Gap_CheckInfo.Gap_Undetected_Flag == true){
Print_Gap_CheckInfo.PaperGap_Check_Flag = false;
Print_Process_Para.PaperGap_Ready_Check_Flag = false;
Print_Gap_CheckInfo.Gap_Undetected_Flag = false;
MyPrintf("uncheck..\n");
Step = 0;
}
}
else if(PAPER_BLACKLABLE == Store_Para.Print_Paper_Type_Para.PrintPaperType){ //黑标纸
// MyPrintf("POSITION_ON_black_11\n");
if(Paper_Location_Info.current_gap_state == PAPER_FILTER_DOWM && Paper_Location_Info.last_gap_state != PAPER_FILTER_HOLD)
{
// Print_Process_Para.PaperGap_Ready_Check_Flag = false;
MyPrintf("gap_Blk_ee\n");
Step = 2;
}else if(Print_Gap_CheckInfo.Gap_Undetected_Flag == true){
Print_Gap_CheckInfo.PaperGap_Check_Flag = false;
Print_Process_Para.PaperGap_Ready_Check_Flag = false;
Print_Gap_CheckInfo.Gap_Undetected_Flag = false;
MyPrintf("uncheck..22\n");
Step = 0;
}
}
break;
case 1:
if(Paper_Location_Info.current_gap_state == PAPER_FILTER_DOWM && Paper_Location_Info.last_gap_state != PAPER_FILTER_HOLD)
{
//该标记置为有效 则计数处理
Print_Gap_CheckInfo.PaperGap_Check_Flag = true;
Print_Process_Para.PaperGap_Ready_Check_Flag = false;
MyPrintf("gap_true_1111\n");
Step = 0;
}else if(Print_Gap_CheckInfo.Gap_Undetected_Flag == true){
Print_Gap_CheckInfo.PaperGap_Check_Flag = false;
Print_Process_Para.PaperGap_Ready_Check_Flag = false;
Print_Gap_CheckInfo.Gap_Undetected_Flag = false;
MyPrintf("11_undetected_000\n");
Step = 0;
}
break;
case 2:
if(Paper_Location_Info.current_gap_state == PAPER_FILTER_UP && Paper_Location_Info.last_gap_state != PAPER_FILTER_HOLD)
{
//该标记置为有效 则计数处理
Print_Gap_CheckInfo.PaperGap_Check_Flag = true;
Print_Process_Para.PaperGap_Ready_Check_Flag = false;
MyPrintf("gap_true_2222\n");
Step = 0;
}else if(Print_Gap_CheckInfo.Gap_Undetected_Flag == true){
Print_Gap_CheckInfo.PaperGap_Check_Flag = false;
Print_Process_Para.PaperGap_Ready_Check_Flag = false;
Print_Gap_CheckInfo.Gap_Undetected_Flag = false;
MyPrintf("undetected_111\n");
Step = 0;
}
break;
default :
break;
}
}
}else{
return;
}
}
//走到间隙纸位置 如0x0c 及单按键
void PaperGap_GotoGap(void)
{
// MyPrintf("PrintPaperType=%d\n\r",Store_Para.Print_Paper_Type_Para.PrintPaperType);
//只有间隙纸 或黑标纸 才OK
if((PAPER_GAP == Store_Para.Print_Paper_Type_Para.PrintPaperType)||(PAPER_BLACKLABLE == Store_Para.Print_Paper_Type_Para.PrintPaperType))
{
if(false == Print_Gap_CheckInfo.PaperGap_GotoGap_Pre_Flag)
{
Print_Gap_CheckInfo.PaperGap_GotoGap_Pre_Flag = true; //准备走到空隙位置的标记
// MyPrintf("PrintGoingAllFlag=%d\n\r",Print_Data_Cache.PrintGoingAllFlag);
//如果未在打印中，则走纸到间隙处
if(false == Print_Data_Cache.PrintGoingAllFlag)
{
MyPrintf("PaperGap_GotoGap_222222\n\r");
Print_Gap_CheckInfo.PaperGap_GotoGap_All_Count = PRINTHEAD_OPTICALCOUPLER_CUTTER; //切刀到光耦的距离（走到切纸位）
Print_Process_Para.Paper_Back_Flag = PRINT_FORWARD_PAPER; //电机正转
// Print_Process_Para.PaperGap_Ready_Check_Flag = true; //准备做间隙控制了
PrintMotor_Positive_Start(); //启动电机了
}
}
}
else{
return;
}
// MyPrintf("PaperGap_GotoGap_11111111\n\r");
//色带计数 处理
}
//单按键走纸 --> U20
void Key_Feed_Paper(void)
{
//只有间隙纸 才OK
if(PAPER_CONTINUE == Store_Para.Print_Paper_Type_Para.PrintPaperType)
{
return;
}
//色带计数 处理
// if(false == Print_Gap_CheckInfo.PaperGap_GotoGap_Pre_Flag)
{
// Print_Gap_CheckInfo.PaperGap_GotoGap_Pre_Flag = true; //准备走到空隙位置的标记
//如果未在打印中，则走纸到间隙处
if(false == Print_Data_Cache.PrintGoingAllFlag)
{
Matchine_5V_PrintHead_Motor_Power_On(); //打开打印头及电机电源
MyPrintf("Key_Feed_Paper---111\n");
Print_Gap_CheckInfo.PaperGap_GotoGap_All_Count = PRINTHEAD_OPTICALCOUPLER_CUTTER; //切刀到光耦的距离（走到切纸位）
Print_Process_Para.Paper_Back_Flag = PRINT_FORWARD_PAPER; //电机正转
PrintMotor_Positive_Start(); //启动电机了
}
}
}
//蜂鸣器控制 主入口 period - 一周期总时长 continue_time - 响 /
void Beep_Control_State(uint16_t period,uint16_t duty,uint16_t beep_times) {
Beep_Control_Para.Beep_Current_Count = 0; //当前的计数信息
Beep_Control_Para.Beep_Current_Times = 0; //当前的计数信息
Beep_Control_Para.Beep_Duty = duty; //持续时长
Beep_Control_Para.Beep_Period = period; //周期信息
Beep_Control_Para.Beep_Times = beep_times; //次数
Beep_Control_Para.Beep_Control_Enable = true; //允许蜂鸣器响的标记置为有效
}
//蜂鸣器控制进程
void IRQ_Beep_Control_Process(void) {
if(false == Beep_Control_Para.Beep_Control_Enable)
{
return;
}
//次数信息
if(Beep_Control_Para.Beep_Current_Times < Beep_Control_Para.Beep_Times)
{
//当前次数 周期计数信息
if(Beep_Control_Para.Beep_Current_Count <= Beep_Control_Para.Beep_Period)
{
//刚开始响
if(Beep_Control_Para.Beep_Current_Count == 0)
{
Buzzer_OnOff(true); //启动蜂鸣器
}
//到了则不响
else if(Beep_Control_Para.Beep_Current_Count == Beep_Control_Para.Beep_Duty)
{
Buzzer_OnOff(false); //停止蜂鸣器
}
Beep_Control_Para.Beep_Current_Count++;
}
else if(Beep_Control_Para.Beep_Current_Count > Beep_Control_Para.Beep_Period)
{
Buzzer_OnOff(false); //停止蜂鸣器
Beep_Control_Para.Beep_Current_Count = 0;
Beep_Control_Para.Beep_Current_Times++; //次数追加
}
}
else if(Beep_Control_Para.Beep_Current_Times >= Beep_Control_Para.Beep_Times)
{
Beep_Control_Para.Beep_Current_Count = 0;
Beep_Control_Para.Beep_Current_Times = 0;
Beep_Control_Para.Beep_Control_Enable = false;
}
}
//光耦状态检测
void OptState_Check(){
// PaperStateInfo = GetSensorPosition_Print();
// Get_Gap_Current_Locate(PaperStateInfo.Position);
GetPaperState();
// Get_Gap_Current_Locate_Kalman();
// Get_Gap_Current_Locate_Info();
}
//电池温度检测 /
void Battery_Voltage_Check(){
static uint16_t Battery_High_Temp_Counter = 0; //电池高温次数计数
static uint16_t Battery_Low_Temp_Counter=0; //电池低温次数计数
// char Bat_Temp[] = {0,0} ;
#if 0
static uint32_t sum_values = 0; //求和
static uint32_t sum_count = 0; //计数
#endif
#if BATTERY_TEMPER_CHECK_ENABLE_FLAG
if(true == Print_Data_Cache.PrintGoingAllFlag) return; //打印不检测电量
int16_t adc_value = ADC_Get_Value(ADC_BATTERY_NTC_TEMP); //电池温度检测
// MyPrintf("battery_ad_value_Check = %d\r\n",adc_value);
if(ChargingState_Get()){
// if(adc_value <= 150)
adc_value -=15 ;
}
// MyPrintf("battery_ad_value_Check = %d\r\n",adc_value);
//当前是正常状态
if(State_Check_Para.State_BatteryTemp_Check == BATTERY_TEMP_NORMAL){
//小于0度
if((Print_Data_Cache.PrintCurrentNum == 0)&&(Print_Data_Cache.PrintCopies == 0)){ //不在打印的状态
if(adc_value >= BATTERY_LOW_TEMPERATURE_THRESHOLD) //1月份电池：//20240326确认电池0°低温时的ADC值是475，
{
Battery_Low_Temp_Counter++;
}
//大于45度
else if(adc_value <= BATTERY_HIGH_TEMPERATURE_THRESHOLD) //1月份电池是110 //20240326确认电池45°高温时的ADC值是95，
{
MyPrintf("BATTERY_TEMP_OVER_HIGH--000\r\n");
Battery_High_Temp_Counter++;
}
else{
Battery_Low_Temp_Counter = 0;
Battery_High_Temp_Counter = 0;
State_Check_Para.State_BatteryTemp_Check = BATTERY_TEMP_NORMAL;
}
}else{ //打印时的NTC值
if(adc_value >= BATTERY_LOW_TEMPERATURE_THRESHOLD) //1月份电池：500
{
// MyPrintf("BATTERY_TEMP_OVER_LOW--\r\n");
Battery_Low_Temp_Counter++;
}
//大于45度
else if(adc_value <= PRINTING_BAT_HIGH_TEMPERATURE_THRESHOLD) //打印时电池NTC值偏低，目前取40
{
MyPrintf("BATTERY_TEMP_OVER_HIGH--000\r\n");
Battery_High_Temp_Counter++;
}
else{
Battery_Low_Temp_Counter = 0;
Battery_High_Temp_Counter = 0;
State_Check_Para.State_BatteryTemp_Check = BATTERY_TEMP_NORMAL;
}
}
}
//如果当前是高温状态 >=95
if(State_Check_Para.State_BatteryTemp_Check == BATTERY_TEMP_OVER_HIGH){
if(adc_value >= BAT_HIGH_TEMPERATURE_RECOVER_THRESHOLD){ //130
// MyPrintf("BATTERY_TEMP_OVER_HIGH--222\r\n");
Battery_High_Temp_Counter = 0;
State_Check_Para.State_BatteryTemp_Check = BATTERY_TEMP_NORMAL;
}
}
//如果是低温状态 <=400
if(State_Check_Para.State_BatteryTemp_Check == BATTERY_TEMP_OVER_LOW){
if(adc_value <= BAT_LOW_TEMPERATURE_RECOVER_THRESHOLD){
// MyPrintf("BATTERY_TEMP_OVER_LOW--222\r\n");
Battery_Low_Temp_Counter = 0;
State_Check_Para.State_BatteryTemp_Check = BATTERY_TEMP_NORMAL;
}
}
if(BAT_TEMPERATURE_CHECK_TIMES<=Battery_Low_Temp_Counter){
State_Check_Para.State_BatteryTemp_Check = BATTERY_TEMP_OVER_LOW;
}
if(BAT_TEMPERATURE_CHECK_TIMES<=Battery_High_Temp_Counter){
State_Check_Para.State_BatteryTemp_Check = BATTERY_TEMP_OVER_HIGH;
}
#if 0
sum_values += adc_value;
sum_count++;
if(sum_count >= 10){
MyPrintf("on_v:%d_sta_%d\n",sum_values/sum_count,State_Check_Para.State_BatteryTemp_Check);
sum_count = 0;
sum_values = 0;
}
#endif
// MyPrintf("battery_temper:%d,state:%d\n",adc_value,State_Check_Para.State_BatteryTemp_Check);
#else
State_Check_Para.State_BatteryTemp_Check = BATTERY_TEMP_NORMAL;
#endif
}
//打印头温度检测-------------------------------------------------------------------------------------------
void PTH_NTC_Check()
{
static uint32_t CurrentCnt = 0;
static uint32_t CurrentCntII = 0;
static uint32_t Sum_PrintHead_NTC_ADC =0;
uint16_t print_ntc_adc_average_value = 0;
CurrentCnt++;
Sum_PrintHead_NTC_ADC += ADC_Get_Value(ADC_PRINTHEAD_NTC_TEMP); //打印头温度检测
// MyPrintf("PTH_adc_value_1= %d\n",ADC_Get_Value(ADC_PRINTHEAD_NTC_TEMP));
if(CurrentCnt >= 50)
{
print_ntc_adc_average_value = (Sum_PrintHead_NTC_ADC/50); //温度检测
if(State_Check_Para.BlackPatchPrintFlag == true ){
// MyPrintf("PTH_adc_value:%d\n",print_ntc_adc_average_value);
if(print_ntc_adc_average_value<=Thermistor_ADC_Temp_Converter[Temperature44]){
//报打印头高温
State_Check_Para.State_PrintHeadTemp_Check = PRINT_HEAD_TEMP_HIGH;
Print_Data_Cache.PrintGoingAllFlag = false;
// MyPrintf("PrintHeadTemp----\r\n");
}else if(print_ntc_adc_average_value>=Thermistor_ADC_Temp_Converter[Temperature38]){
State_Check_Para.State_PrintHeadTemp_Check = PRINT_HEAD_TEMP_NORMAL;
}
}else{
if(print_ntc_adc_average_value<=Thermistor_ADC_Temp_Converter[Temperature46])
CurrentCntII++;
else
CurrentCntII = 0;
if(CurrentCntII >= 100)
{
//报打印头高温
State_Check_Para.State_PrintHeadTemp_Check = PRINT_HEAD_TEMP_HIGH;
// MyPrintf("print_ntc=%d\r\n",print_ntc_adc_average_value);
Print_Data_Cache.PrintGoingAllFlag = false;
}
else if(print_ntc_adc_average_value>=Thermistor_ADC_Temp_Converter[Temperature38]){
State_Check_Para.State_PrintHeadTemp_Check = PRINT_HEAD_TEMP_NORMAL;
}
}
if(State_Check_Para.State_PrintHeadTemp_Check == PRINT_HEAD_TEMP_HIGH){
if(print_ntc_adc_average_value>=Thermistor_ADC_Temp_Converter[Temperature36]){
State_Check_Para.State_PrintHeadTemp_Check = PRINT_HEAD_TEMP_NORMAL;
}
}
//以下是开始降温的标志 43°
if((Thermistor_ADC_Temp_Converter[Temperature44]< print_ntc_adc_average_value)&&(print_ntc_adc_average_value<=Thermistor_ADC_Temp_Converter[Temperature42])){
State_Check_Para.ToCoolingOfFirstFlag = true ;
State_Check_Para.ToCoolingOfSecondFlag = false ;
State_Check_Para.ToCoolingOfThirdFlag = false ;
State_Check_Para.CoolingTime = 3;
// MyPrintf("pHT-1=%d\r\n",print_ntc_adc_average_value);
} //44°
else if((Thermistor_ADC_Temp_Converter[Temperature45]< print_ntc_adc_average_value)&&(print_ntc_adc_average_value<=Thermistor_ADC_Temp_Converter[Temperature43])){
State_Check_Para.ToCoolingOfFirstFlag = false ;
State_Check_Para.ToCoolingOfSecondFlag = true ;
State_Check_Para.ToCoolingOfThirdFlag = false ;
State_Check_Para.CoolingTime = 4;
// MyPrintf("pHT-222=%d\r\n",print_ntc_adc_average_value);
} //45°
else if((Thermistor_ADC_Temp_Converter[Temperature48]< print_ntc_adc_average_value)&&(print_ntc_adc_average_value<=Thermistor_ADC_Temp_Converter[Temperature44])){
State_Check_Para.ToCoolingOfFirstFlag = false ;
State_Check_Para.ToCoolingOfSecondFlag = false ;
State_Check_Para.ToCoolingOfThirdFlag = true ;
State_Check_Para.CoolingTime = 5;
// MyPrintf("pHT-333=%d\r\n",print_ntc_adc_average_value);
}
else{
State_Check_Para.ToCoolingOfFirstFlag = false ;
State_Check_Para.ToCoolingOfSecondFlag = false ;
State_Check_Para.ToCoolingOfThirdFlag = false ;
State_Check_Para.CoolingTime = 2;
// MyPrintf("PrintHeadTemp----0\r\n");
}
CurrentCnt = 0;
Sum_PrintHead_NTC_ADC =0;
}
}
//检测机器没纸或开盖------------------------------------------------------------------------
void NoPaper_And_Uncover_Check()
{
uint16_t ad_value_Check = 0 ;
static uint16_t Nopaper_Counter = 0; //缺纸次数计数
static unsigned char Uncover_counter=0; //开盖次数计数
switch(Store_Para.Print_Paper_Type_Para.PrintPaperType)
{
case PAPER_BLACKLABLE:
case PAPER_GAP:{
EnableSensor(PAPER_GAP,Store_CalibrationPara.SelectIndex);
// MyPrintf("SelectIndex=%02x\r\n",Store_CalibrationPara.SelectIndex);
ad_value_Check = StartSensorChannelADCValue();
break;
}
case PAPER_CONTINUE:{
EnableSensor(PAPER_CONTINUE,Store_CalibrationPara.SelectIndex);
ad_value_Check = StartSensorChannelADCValue();
break;
}
default:{
break;
}
}
// MyPrintf("PrintCopies_2 = %d\r\n",Print_Data_Cache.PrintCopies);
// MyPrintf("PrintCurrentNum_2 = %d\r\n",Print_Data_Cache.PrintCurrentNum);
// MyPrintf("ad_value_Check = %d\r\n",ad_value_Check);
// MyPrintf("PJSF = %d\t PGAF=%d\r\n",Print_Process_Para.Print_Job_Status_Flag,Print_Data_Cache.PrintGoingAllFlag);
if(Store_CalibrationPara.HavePaperRef>=1090){
Store_CalibrationPara.HavePaperRef = 1090 ;
}
if(ad_value_Check>=(Store_CalibrationPara.HavePaperRef+100)) //缺纸
{
if(supplies_info == PUTY_SUPPLIES){
Nopaper_Counter = 0;
Print_Gap_CheckInfo.No_Paper_Flag = false ;
}
else if((100<ad_value_Check)&&(900>ad_value_Check))
{
// MyPrintf("HavePaperRef = %d\r\n",Store_CalibrationPara.HavePaperRef);
Nopaper_Counter = 0;
Print_Gap_CheckInfo.No_Paper_Flag = false ;
}
else
{
// MyPrintf("ad_value_Check = %d\r\n",ad_value_Check);
Nopaper_Counter ++;
}
}
else if(40 >= ad_value_Check){
Uncover_counter++;
}
else{
Nopaper_Counter = 0;
Uncover_counter = 0;
Print_Gap_CheckInfo.Uncover_Flag = false ;
Print_Gap_CheckInfo.No_Paper_Flag = false ;
}
if(Nopaper_Counter>=100)
{
Print_Gap_CheckInfo.No_Paper_Flag = true ;
Print_Data_Cache.PrintGoingAllFlag = false;
Nopaper_Counter = 0;
// MyPrintf("nopaper_1111\r\n");
}
if(Uncover_counter>=60){
// MyPrintf("uncover_222222\r\n");
Print_Gap_CheckInfo.Uncover_Flag = true ;
Print_Data_Cache.PrintGoingAllFlag = false;
Uncover_counter = 0;
}
}
/******************************************************************************
版权所有： 深圳普实科技有限公司
文件名： api_state_check.h
作者： wangdy
创建日期： 2020/7/9
描述： 打印状态检测
其它：
修改历史： //修改历史记录列表，每条修改记录应包含修改日期、修改者及修改内容简述
序号 修改时间 修改人 修改内容
???? ????/??/?? ?????? 参考样式
******************************************************************************/
/*********************************防止多次编译*********************************/
#ifndef _API_STATE_CHECK_H
#define _API_STATE_CHECK_H
/************************************头文件************************************/
#include <stdint.h>
#include <stdbool.h>
#include "driver_timer.h"
#include "tools_fifo.h"
#include "api_data_analysis.h"
#include "api_sensorcheck.h"
/************************************宏定义************************************/
#define TAPE_USEUP_ADC_VALUE 1625 //ADC阈值平均值（有效的 目测计算 (3000+250)/2 用色带测出 ）
#define CUT_MOTOR_MIN_TIME 1500 //3S剪切配置
#define CUT_MOTOR_MAX_TIME 10000 //10S剪切配置 10S还未归位 认为有问题
#define THRESHOLD_CUT_OPEN 300 //剪切 ADC
#define TAPE_ALL_TYPES 3 //色带的总的种类信息
#define BATTERY_HIGH_TEMPERATURE_THRESHOLD 95 //电池高温阈值
#define PRINTING_BAT_HIGH_TEMPERATURE_THRESHOLD 40 //打印过程电池高温阈值
#define BATTERY_LOW_TEMPERATURE_THRESHOLD 475 //电池低温阈值
#define BAT_HIGH_TEMPERATURE_RECOVER_THRESHOLD 130 //电池高温恢复正常的阈值
#define BAT_LOW_TEMPERATURE_RECOVER_THRESHOLD 400 //电池低温恢复正常的阈值
#define BAT_TEMPERATURE_CHECK_TIMES 200 //电池温度状态检测次数（连续检测到这么多次才置状态）
//#define MAXIMUM_PTH_TEMP_INDEX 20 //打印头最高温度索引 45°时报高温
//#define TO_COOLING_PTH_TEMP_INDEX 15 //打印温度高到一定程度时开始去减小加热时间
/*************************************枚举*************************************/
typedef enum{
Temperature25 = 0, //0
Temperature26, //1
Temperature27, //2
Temperature28, //3
Temperature29, //4
Temperature30, //5
Temperature31, //6
Temperature32, //7
Temperature33, //8
Temperature34, //9
Temperature35, //10
Temperature36, //11
Temperature37, //12
Temperature38, //13
Temperature39, //14
Temperature40, //15
Temperature41, //16
Temperature42, //17
Temperature43, //18
Temperature44, //19
Temperature45, //20
Temperature46, //21
Temperature47, //22
Temperature48, //23
Temperature49, //24
Temperature50, //25
}_PRINT_HEAD_TEMP_INDEX_ENUM;
//电机当前状态
typedef enum
{
MOTOR_STATE_STOP,
MOTOR_STATE_PRINTING, //打印中
MOTOR_STATE_RUN_PAPER_POSITIVE, //走纸(正向)
MOTOR_STATE_RUN_PAPER_REVERSE, //走纸(反向)
MOTOR_STATE_FEED_PAPER, //找间隙
}_MOTOR_RUN_STATE;
/************************************结构体************************************/
typedef struct{
}MotorRunPaperParaTypeDef;
//电机状态信息
typedef struct
{
uint8_t PrintMotor_Speed; //打印头电机控制 占空比
_MOTOR_RUN_STATE PrintMotor_RunState; //电机当前工作状态
bool PrintMotor_ErrFlag; //电机出错标记 比如堵转 光耦坏了 则不允许再次启动它
uint32_t PrintMotor_Pix_Nums_Positive; //正向电机像素数据
uint32_t PrintMotor_Pix_Nums_Reverse; //反向电机像素数据
}_STATE_MOTOR_CHECK_PARA;
//电池温度检测
typedef enum{
BATTERY_TEMP_NORMAL = 0, //电池温度正常
BATTERY_TEMP_OVER_HIGH = 1, //电池温度过高
BATTERY_TEMP_OVER_LOW = 2, //电池温度过低
}BATTERY_TEMP_STATE;
//打印头温度检测
typedef enum{
PRINT_HEAD_TEMP_NORMAL = 0,
PRINT_HEAD_TEMP_HIGH = 1,
}PRINT_HEAD_TEMP_STATE;
//状态检测 参数信息
typedef struct
{
_STATE_MOTOR_CHECK_PARA State_MotorCheck;//电机状态信息
BATTERY_TEMP_STATE State_BatteryTemp_Check; //电池温度检测
PRINT_HEAD_TEMP_STATE State_PrintHeadTemp_Check; //打印头温度检测
bool ToCoolingOfFirstFlag; //降温标志1
bool ToCoolingOfSecondFlag; //降温标志2
bool ToCoolingOfThirdFlag; //降温标志3
uint16_t CheckSuppliesFlag; //耗材消耗开始计数标志
bool BlackPatchPrintFlag; //黑块打印标志
uint8_t CoolingTime; //冷却时间
}_STATE_CHECK_PARA;
//蜂鸣器控制
typedef struct
{
uint16_t Beep_Current_Count; //蜂鸣器当前计数信息
uint16_t Beep_Current_Times; //蜂鸣器当前的已响的次数的信息
uint16_t Beep_Duty; //蜂鸣器持续多久
uint16_t Beep_Period; //蜂鸣器响的次数信息
uint16_t Beep_Times; //蜂鸣器响的次数信息
bool Beep_Control_Enable; //蜂鸣器控制使能
}_BEEP_CONTROL_PARA;
/**********************************可导出变量**********************************/
extern _TRANSFER_ERROR_STATE Transfer_Error_Flag; //传输错误信息
extern _STATE_CHECK_PARA State_Check_Para; //状态检测信息
extern PaperStateInfoTypeDef PaperStateInfo; //纸张当前的状态信息
extern bool ErrorFlag ; //错误打印
/***********************************函数实现***********************************/
//电机
void PrintMotor_Speed_Init(void); //打印电机 初始化
void PrintMotor_Positive_Start(void); //启动电机
void PrintMotor_Inverse_Start(void); //打印电机 倒转
void PrintMotor_Positive_Start_Steps(uint32_t pix); //正转N pix
void PrintMotor_Inverse_Start_Steps(uint32_t pix); //倒转N pix
void PrintMotor_Stop(void); //打印电机 停止
void Machine_State_Check(void); //机器状态检测
void PTH_NTC_Check(); //打印头温度检测
void NoPaper_And_Uncover_Check(); //没纸或开盖检测
//光耦
void OptState_Check(); //光耦状态检测
void Get_Gap_Current_Locate_Kalman() ;
void Get_Gap_Current_Locate(SensorPaperPositionEnum current_state); //获取当前的状态信息
void Beep_Control_State(uint16_t period,uint16_t duty,uint16_t beep_times); //蜂鸣器控制
//中断
void IRQ_Beep_Control_Process(void); //蜂鸣器控制
void IRQ_Motor_Positive_RunSteps(); //电机正转固定长度
void IRQ_Motor_Reverse_RunSteps(); //电机反转固定长度
void PaperGap_GotoGap(void); //走到间隙纸位置
void Key_Feed_Paper(void); //单击按键走纸
//电池温度
void Battery_Voltage_Check(); //电池温度检测
#endif
/******************************************************************************
版权所有： 深圳市科技有限公司
文件名： api_test.c
作者： wangdy
创建日期： 2020/07/9
描述： 测试接口函数
其它：
修改历史： //修改历史记录列表，每条修改记录应包含修改日期、修改者及修改内容简述
序号 修改时间 修改人 修改内容
???? ????/??/?? ?????? 参考样式
******************************************************************************/
/************************************头文件************************************/
#include "api_test.h"
#include <string.h>
#include "driver_adc.h"
#include "api_state_check.h"
#include "api_power_control.h"
#include "bsp_print_control.h"
#include "bsp_motor_control.h"
#include "bsp_led_control.h"
#include "api_para_set.h"
#include "tools_calc_heattime.h"
#include "tools_fifo.h"
#include "bsp_motor_control.h"
#include "api_print.h"
/*************************************变量*************************************/
bool TestMode_Error_Flag = false; //错误标记
volatile _TESTMODE_EMC_PRINT TestMode_EMC_Print; //EMC打印
//打印状态测试
_TESTMODE_PRINT_TEST TestMode_Print_Test;
_TESTMODE_CURRENT_PRINT_PARA TestMode_Current_Print_Para = {0}; //当前打印参数
_TESTMODE_MOTOR_LIFE_FLAG TestMode_Motor_Life_Flag = {0}; //电机测试 参数信息
_TESTMODE_GAP_PRINT_CALIBRATION TestMode_GapPrint_Calibration_Test = {0}; //间隙纸定标信息
_TESTMODE_CUTTTER_PARA TestMode_Cutter_Para = {0}; //当前剪切状态
//全黑数据打印
const uint8_t Print_Test_Dot_Byte[8] = {0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA,0xAA};
//全黑数据打印
const uint8_t Print_Test_AllBlack_Byte[8] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
//全白数据打印
const uint8_t Print_Test_AllWhite_Byte[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
//结构体赋初值
_TESTMODE_GAP_CALIBRATION_VALUE TestMode_Gap_Calibration_Value =
{
//比较值恢复为默认
.ADC_Value_Min = 0xFFFF,
.ADC_Value_Max = 0,
.ADC_Avaliable_Value_Min = 0xFFFF,
.ADC_Pre_Differ_Value = 0,
.ADC_Min_Checked_Flag = false,
.ADC_Min_Checked_Count = 0,
.ADC_Differ_CheckSuccessFlag = false,
.ADC_Value_Min_Index = 0, //最小索引值
.ADC_Value_Max_Index = 0, //最大索引值
.ADC_Calibrate_First_Run_Count = 0, //先跑一段时间 再检测
.ADC_Calibrate_First_Run_Flag = false, //先跑一段时间 再检测
};
/*************************************函数*************************************/
/*******************************************************************************
* 名称: TestMode_PrintMotor_Life_Fun
* 描述: 电机寿命测试
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void TestMode_PrintMotor_Life_Fun(bool state)
{
static bool pre_state = false; //上一次测试的状态信息
Machine_State = MACHINE_TEST; //当前工作 状态
if(pre_state != state)
{
if(state)
{
TestMode_Motor_Life_Flag.TestMode_Motor_Run_Flag = true;
PrintMotor_Positive_Start();
}
else
{
TestMode_Motor_Life_Flag.TestMode_Motor_Run_Flag = false;
PrintMotor_Stop();
}
}
pre_state = state;
}
/*******************************************************************************
* 名称: TestMode_Printer_StopHeat_PowerOff_Fun
* 描述: 停止加热并关电
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void TestMode_Printer_StopHeat_PowerOff_Fun(void)
{
//打印头停止加热
Print_Line_Stop_Write_Heat(); //超过加热时间 则停止加热
//打印头停止供电
//Print_VH_Power_OnOff(false);
}
/*******************************************************************************
* 名称: TestMode_Print_AllBlack_Fun
* 描述: 全黑打印测试
* 输入参数: 无
* 输出参数: false - 未测试完成 true - 测试完成
* 其它: 无
*******************************************************************************/
bool TestMode_Print_Start_Fun( _TESTMODE_PRINT_TEST_ENUM test_type,
uint8_t state,
uint16_t print_length,
uint16_t print_copies,
PrintPaperTypeEnum paper_type)
{
Machine_State = MACHINE_TEST; //当前工作 状态
if(1 == state) //启动打印信息
{
//有故障并且不是没色带的故障 不允许打印
if(TestMode_Error_Flag)
{
TestMode_Print_Test.TestMode_Print_Finish_Protocol_State = true;
return true;
}
//Print_VH_Power_OnOff(true); //打开当前供电
//先开电机 间隙纸需要倒转
if(paper_type == PAPER_GAP)
{
TestMode_Print_Test.TestMode_Print_Gap_Inverse_Count = 0;
TestMode_Print_Test.TestMode_Print_Gap_Inverse_Flag = true;
PrintMotor_Inverse_Start();
}
else
{
TestMode_Print_Test.TestMode_Print_Gap_Inverse_Count = 0;
TestMode_Print_Test.TestMode_Print_Gap_Inverse_Flag = false;
PrintMotor_Positive_Start();
}
//刚开始 打印完成标记则置为无效
TestMode_Print_Test.TestMode_Print_Finish = false;
TestMode_Print_Test.TestMode_Print_Start = true; //当前在打印状态时
//打印上传协议 置为false
TestMode_Print_Test.TestMode_Print_Finish_Protocol_State = false;
//打印信息 变量挂接
TestMode_Print_Test.TestMode_Print_Test_Enum = test_type; //测试打印哪一项
TestMode_Print_Test.TestMode_Print_Length = print_length; //打印长度
TestMode_Print_Test.TestMode_Print_Dot_Sum = print_length*709/100; //Nmm对应的像素点的长度(1mm打印头距离约等于7.09像素)
TestMode_Print_Test.TestMode_Print_Copies = print_copies; //打印份数
TestMode_Print_Test.TestMode_Print_TypeInfo = paper_type; //纸张类型
//只有间隙纸 才做运算处理(从哪个像素点开始)
TestMode_Print_Test.TestMode_Print_Ready_Detect_Gap_Flag = false;
if(TestMode_Print_Test.TestMode_Print_Dot_Sum > TESTMODE_PRINTHEAD_OPTICALCOUPLER_START_CHECK_PIX)
{
TestMode_Print_Test.TestMode_Print_Detect_Gap_Pix = TestMode_Print_Test.TestMode_Print_Dot_Sum - TESTMODE_PRINTHEAD_OPTICALCOUPLER_START_CHECK_PIX;
}
else
{
TestMode_Print_Test.TestMode_Print_Detect_Gap_Pix = 0;
}
//对应计数清0 如果为普通的打印 则进行一定的处理信息
if(TESTMODE_PRINT_NORMAL == test_type)
{
TestMode_Current_Print_Para.TestMode_Current_Normal_Count = 0;
}
//打印 总像素计数清0
TestMode_Current_Print_Para.TestMode_Print_Current_Pix = 0;
//要关闭充电电源
TestMode_Print_Test.TestMode_Printing = true; //开始打印了
}
else if(2 == state)
{
//自动上传状态
}
return TestMode_Print_Test.TestMode_Print_Finish_Protocol_State;
}
/*******************************************************************************
* 名称: TestMode_Print_Process
* 描述: 测试模式进程
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void TestMode_Print_Process(void)
{
//出错时进行处理
if(TestMode_Error_Flag)
{
if(TestMode_Print_Test.TestMode_Print_Start)
{
TestMode_Print_Test.TestMode_Print_Test_Enum = TESTMODE_PRINT_NONE; //转回非打印模式
Print_Line_Stop_Write_Heat(); //停止加热
//Print_VH_Power_OnOff(false); //关闭打印头供电
TestMode_Current_Print_Para.TestMode_Print_Current_Pix = 0; //当前已打印的长度
TestMode_Current_Print_Para.TestMode_Current_Print_Copies = 0; //当前已打印的份数
TestMode_Current_Print_Para.TestMode_StopHeat_Count_Flag = false;//停止加热 计时
TestMode_Current_Print_Para.TestMode_HeatTime_Current_Count = 0; //当前加热时间
TestMode_Current_Print_Para.TestMode_HeatTime_Current = 0; //当前加热时间
TestMode_Print_Test.TestMode_Print_Finish_Protocol_State = true; //打印上传状态 完成
TestMode_Print_Test.TestMode_Print_Finish = false;
TestMode_Print_Test.TestMode_Print_Start = false;
TestMode_Print_Test.TestMode_Print_Ready_Detect_Gap_Flag = false; //准备找位置 标记置为无效
TestMode_Print_Test.TestMode_Print_Finish_Detect_Gap_Flag = false; //找到位置了 标记置为无效
TestMode_Print_Test.TestMode_Print_Detect_Gap_Pix = 0;
TestMode_Print_Test.TestMode_Print_AfeterDetect_Gap_Goto_Pix = 0; //像素信息清0
PrintMotor_Stop(); //停止电机
//打印完了 重新启动充电
TestMode_Print_Test.TestMode_Printing = false;
//恢复充电接管
Charge_Control_Flag.ChargeTakeOver_Flag = false; //打印出错，恢复默认充电控制
}
else if(TestMode_Cutter_Para.TestMode_Cutter_Start)
{
TestMode_Cutter_Para.TestMode_Cutter_Start = false;
PrintMotor_Stop(); //停止电机
}
return;
}
//未在打印状态 则停止掉电机 统一到该接口(全打完了)
if(TestMode_Print_Test.TestMode_Print_Finish)
{
TestMode_Print_Test.TestMode_Print_Test_Enum = TESTMODE_PRINT_NONE; //转回非打印模式
Print_Line_Stop_Write_Heat(); //停止加热
//Print_VH_Power_OnOff(false); //关闭打印头供电
TestMode_Current_Print_Para.TestMode_Print_Current_Pix = 0; //当前已打印的长度
TestMode_Current_Print_Para.TestMode_Current_Print_Copies = 0; //当前已打印的份数
TestMode_Current_Print_Para.TestMode_StopHeat_Count_Flag = false;//停止加热 计时
TestMode_Current_Print_Para.TestMode_HeatTime_Current_Count = 0; //当前加热时间
TestMode_Current_Print_Para.TestMode_HeatTime_Current = 0; //当前加热时间
TestMode_Print_Test.TestMode_Print_Finish_Protocol_State = true; //打印上传状态 完成
TestMode_Print_Test.TestMode_Print_Finish = false;
TestMode_Print_Test.TestMode_Print_Start = false;
TestMode_Print_Test.TestMode_Print_Ready_Detect_Gap_Flag = false; //准备找位置 标记置为无效
TestMode_Print_Test.TestMode_Print_Finish_Detect_Gap_Flag = false; //找到位置了 标记置为无效
TestMode_Print_Test.TestMode_Print_Detect_Gap_Pix = 0;
TestMode_Print_Test.TestMode_Print_AfeterDetect_Gap_Goto_Pix = 0; //像素信息清0
PrintMotor_Stop(); //停止电机
//总计数清0
TestMode_Current_Print_Para.TestMode_Print_Current_Pix = 0;
//打印完了 重新启动充电
TestMode_Print_Test.TestMode_Printing = false;
//恢复充电接管
Charge_Control_Flag.ChargeTakeOver_Flag = false; //打印出错，恢复默认充电控制
}
//测试模式 - 切刀测试
if(TestMode_Cutter_Para.TestMode_Cutter_Start)
{
//存储
if(TestMode_Cutter_Para.TestMode_Enable_To_Flash)
{
TestMode_Cutter_Para.TestMode_Enable_To_Flash = false;
Test_Store_CutterTime_Write(); //存flash
}
}
}
/*******************************************************************************
* 名称: TestMode_ContinuePaper_Print_Test
* 描述: 连续纸打印
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void TestMode_ContinuePaper_Print_Test(void)
{
static bool Gap_Print_Choice = false;
static uint8_t Current_Print_Buf[8]; //当前打印缓存
//判断是哪种打印类型
switch(TestMode_Print_Test.TestMode_Print_Test_Enum)
{
case TESTMODE_PRINT_ALLBLACK:
{
//打印信息
if(TestMode_Current_Print_Para.TestMode_Print_Current_Pix < TestMode_Print_Test.TestMode_Print_Dot_Sum)
{
//计算加热时间
TestMode_Current_Print_Para.TestMode_HeatTime_Current = Calc_Heattime(0,64,8);
//打印一行数据
Print_Line_Start_Write_Heat((uint8_t *)(&Print_Test_AllBlack_Byte[0]),false);
//动态改变加热时间
TestMode_Current_Print_Para.TestMode_StopHeat_Count_Flag = true;
TestMode_Current_Print_Para.TestMode_HeatTime_Current_Count = 0;
}
break;
}
case TESTMODE_PRINT_GAP: //间隙打印
{
//打印信息
if(TestMode_Current_Print_Para.TestMode_Print_Current_Pix < TestMode_Print_Test.TestMode_Print_Dot_Sum)
{
//打印一行数据(间隔打印 )
if(Gap_Print_Choice == false)
{
Gap_Print_Choice = true;
TestMode_Current_Print_Para.TestMode_HeatTime_Current = Calc_Heattime(0,64,8);
Print_Line_Start_Write_Heat((uint8_t *)(&Print_Test_AllBlack_Byte[0]),false);
}
else if(Gap_Print_Choice == true)
{
Gap_Print_Choice = false;
TestMode_Current_Print_Para.TestMode_HeatTime_Current = 0;
Print_Line_Start_Write_Heat((uint8_t *)(&Print_Test_AllWhite_Byte[0]),false);
}
//动态改变加热时间
TestMode_Current_Print_Para.TestMode_StopHeat_Count_Flag = true;
TestMode_Current_Print_Para.TestMode_HeatTime_Current_Count = 0;
}
break;
}
case TESTMODE_PRINT_NORMAL: //固定打印
{
if(TestMode_Current_Print_Para.TestMode_Print_Current_Pix < TestMode_Print_Test.TestMode_Print_Dot_Sum)
{
//计算出来打印缓存
TestMode_Normal_Print_Byte(TestMode_Current_Print_Para.TestMode_Current_Normal_Count,Current_Print_Buf);
TestMode_Current_Print_Para.TestMode_Current_Normal_Count++;
if(TestMode_Current_Print_Para.TestMode_Current_Normal_Count >= 1000)
{
TestMode_Current_Print_Para.TestMode_Current_Normal_Count = 0;
}
//计算加热时间
if(0x00 == Current_Print_Buf[0])
{
TestMode_Current_Print_Para.TestMode_HeatTime_Current = Calc_Heattime(0,0,8);
}
else if(0xFF == Current_Print_Buf[0])
{
TestMode_Current_Print_Para.TestMode_HeatTime_Current = Calc_Heattime(0,64,8);
}
Print_Line_Start_Write_Heat((uint8_t *)(&Current_Print_Buf[0]),false);
//动态改变加热时间
TestMode_Current_Print_Para.TestMode_StopHeat_Count_Flag = true;
TestMode_Current_Print_Para.TestMode_HeatTime_Current_Count = 0;
}
break;
}
default:
{
break;
}
}
//停止加热控制
if(TestMode_Current_Print_Para.TestMode_Print_Current_Pix == TestMode_Print_Test.TestMode_Print_Dot_Sum)
{
Print_Line_Stop_Write_Heat(); //停止加热
if(TestMode_Current_Print_Para.TestMode_Current_Print_Copies >= TestMode_Print_Test.TestMode_Print_Copies)
{
//Print_VH_Power_OnOff(false); //关闭打印头供电
}
}
//超过距离 则停止
TestMode_Current_Print_Para.TestMode_Print_Current_Pix++;
if(TestMode_Current_Print_Para.TestMode_Print_Current_Pix >
(TestMode_Print_Test.TestMode_Print_Dot_Sum + TESTMODE_PRINTHEAD_CUTTUR_PIX) )
{
TestMode_Current_Print_Para.TestMode_Print_Current_Pix = 0;
TestMode_Current_Print_Para.TestMode_Current_Print_Copies++; //当前已打印的份数
//如果份数一样 表示打印完成了
if(TestMode_Current_Print_Para.TestMode_Current_Print_Copies >= TestMode_Print_Test.TestMode_Print_Copies)
{
TestMode_Print_Test.TestMode_Print_Finish = true;
}
}
}
/*******************************************************************************
* 名称: TestMode_GapPaper_Print_Test
* 描述: 间隙纸打印
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void TestMode_GapPaper_Print_Test(void)
{
static bool Gap_Print_Choice = false;
static uint8_t Current_Print_Buf[8]; //当前打印缓存
//判断是哪种打印类型
switch(TestMode_Print_Test.TestMode_Print_Test_Enum)
{
case TESTMODE_PRINT_ALLBLACK:
{
//打印信息
if(TestMode_Current_Print_Para.TestMode_Print_Current_Pix < TestMode_Print_Test.TestMode_Print_Dot_Sum)
{
//到该位置，则开始检测色带
if(TestMode_Current_Print_Para.TestMode_Print_Current_Pix ==
TestMode_Print_Test.TestMode_Print_Detect_Gap_Pix)
{
TestMode_Print_Test.TestMode_Print_Ready_Detect_Gap_Flag = true;
}
//计算加热时间
TestMode_Current_Print_Para.TestMode_HeatTime_Current = Calc_Heattime(0,64,8);
//打印一行数据
Print_Line_Start_Write_Heat((uint8_t *)(&Print_Test_AllBlack_Byte[0]),false);
//动态改变加热时间
TestMode_Current_Print_Para.TestMode_StopHeat_Count_Flag = true;
TestMode_Current_Print_Para.TestMode_HeatTime_Current_Count = 0;
}
break;
}
case TESTMODE_PRINT_GAP: //间隙打印
{
//打印信息
if(TestMode_Current_Print_Para.TestMode_Print_Current_Pix < TestMode_Print_Test.TestMode_Print_Dot_Sum)
{
//到该位置，则开始检测色带
if(TestMode_Current_Print_Para.TestMode_Print_Current_Pix ==
TestMode_Print_Test.TestMode_Print_Detect_Gap_Pix)
{
TestMode_Print_Test.TestMode_Print_Ready_Detect_Gap_Flag = true;
}
//打印一行数据(间隔打印 )
if(Gap_Print_Choice == false)
{
Gap_Print_Choice = true;
TestMode_Current_Print_Para.TestMode_HeatTime_Current = Calc_Heattime(0,64,8);
Print_Line_Start_Write_Heat((uint8_t *)(&Print_Test_AllBlack_Byte[0]),false);
}
else if(Gap_Print_Choice == true)
{
Gap_Print_Choice = false;
TestMode_Current_Print_Para.TestMode_HeatTime_Current = 0;
Print_Line_Start_Write_Heat((uint8_t *)(&Print_Test_AllWhite_Byte[0]),false);
}
//动态改变加热时间
TestMode_Current_Print_Para.TestMode_StopHeat_Count_Flag = true;
TestMode_Current_Print_Para.TestMode_HeatTime_Current_Count = 0;
}
break;
}
case TESTMODE_PRINT_NORMAL: //固定打印
{
//打印信息
if(TestMode_Current_Print_Para.TestMode_Print_Current_Pix < TestMode_Print_Test.TestMode_Print_Dot_Sum)
{
//到该位置，则开始检测色带
if(TestMode_Current_Print_Para.TestMode_Print_Current_Pix ==
TestMode_Print_Test.TestMode_Print_Detect_Gap_Pix)
{
TestMode_Print_Test.TestMode_Print_Ready_Detect_Gap_Flag = true;
}
//计算出来打印缓存
TestMode_Normal_Print_Byte(TestMode_Current_Print_Para.TestMode_Current_Normal_Count,Current_Print_Buf);
TestMode_Current_Print_Para.TestMode_Current_Normal_Count++;
if(TestMode_Current_Print_Para.TestMode_Current_Normal_Count >= 1000)
{
TestMode_Current_Print_Para.TestMode_Current_Normal_Count = 0;
}
//计算加热时间
if(0x00 == Current_Print_Buf[0])
{
TestMode_Current_Print_Para.TestMode_HeatTime_Current = Calc_Heattime(0,0,8);
}
else if(0xFF == Current_Print_Buf[0])
{
TestMode_Current_Print_Para.TestMode_HeatTime_Current = Calc_Heattime(0,64,8);
}
Print_Line_Start_Write_Heat((uint8_t *)(&Current_Print_Buf[0]),false);
//动态改变加热时间
TestMode_Current_Print_Para.TestMode_StopHeat_Count_Flag = true;
TestMode_Current_Print_Para.TestMode_HeatTime_Current_Count = 0;
}
break;
}
default:
{
break;
}
}
//停止加热控制
if(TestMode_Current_Print_Para.TestMode_Print_Current_Pix == TestMode_Print_Test.TestMode_Print_Dot_Sum)
{
Print_Line_Stop_Write_Heat(); //停止加热
if(TestMode_Current_Print_Para.TestMode_Current_Print_Copies >= TestMode_Print_Test.TestMode_Print_Copies)
{
//Print_VH_Power_OnOff(false); //关闭打印头供电
}
}
//看看是否超长溢出 ，这样认为是有问题的
TestMode_Current_Print_Para.TestMode_Print_Current_Pix++;
if(TestMode_Current_Print_Para.TestMode_Print_Current_Pix >=
( TestMode_Print_Test.TestMode_Print_Dot_Sum
+ TESTMODE_PAPER_CALIBRATION_MAX_PIX) )
{
TestMode_Current_Print_Para.TestMode_Print_Current_Pix = 0;
TestMode_Current_Print_Para.TestMode_Current_Print_Copies = 0;
TestMode_Print_Test.TestMode_Print_Finish = true;
}
}
/*******************************************************************************
* 名称: IRQ_TestMode_Print_Test
* 描述: 打印测试(包含全黑打印测试，间隙打印测试、固定图案打印测试)
* 输入参数: 无
* 输出参数: 无
* 其它: 定时器测试
*******************************************************************************/
void IRQ_TestMode_Print_Test(void)
{
static uint32_t Current_Cut_Times = 0; //临时计数 清0
//打印中状态 则进行打印过程操作
if(true == TestMode_Print_Test.TestMode_Print_Start)
{
//看是否倒传有效
if(true == TestMode_Print_Test.TestMode_Print_Gap_Inverse_Flag)
{
TestMode_Print_Test.TestMode_Print_Gap_Inverse_Count++;
if(TestMode_Print_Test.TestMode_Print_Gap_Inverse_Count >= PRINTHEAD_INVERSE_PIX)
{
TestMode_Print_Test.TestMode_Print_Gap_Inverse_Count = 0;
TestMode_Print_Test.TestMode_Print_Gap_Inverse_Flag = false;
PrintMotor_Stop(); //先停止倒转
PrintMotor_Positive_Start(); //恢复正转
}
}
else
{
//连续纸
if(PAPER_CONTINUE == TestMode_Print_Test.TestMode_Print_TypeInfo)
{
TestMode_ContinuePaper_Print_Test();
}
//间隙纸
else if(PAPER_GAP == TestMode_Print_Test.TestMode_Print_TypeInfo)
{
TestMode_GapPaper_Print_Test();
}
}
}
//跑切刀测试标记有效 则进行跑切刀测试信息
if(true == TestMode_Cutter_Para.TestMode_Cutter_Start)
{
TestMode_Cutter_Para.TestMode_Cutter_Enable_Pulse_Count++; //步数计数清0
//启停电机
if(1 == TestMode_Cutter_Para.TestMode_Cutter_Enable_Pulse_Count)
{
PrintMotor_Positive_Start(); //启动打印电机 使打印电机动作
}
else if(TestMode_Cutter_Para.TestMode_Cutter_Dot_Sum ==
TestMode_Cutter_Para.TestMode_Cutter_Enable_Pulse_Count)
{
PrintMotor_Stop(); //停止打印电机 使其停止
}
else if(TestMode_Cutter_Para.TestMode_Cutter_Enable_Pulse_Count >
(TestMode_Cutter_Para.TestMode_Cutter_Dot_Sum + TESTMODE_CUTTER_STOP_TIME))
{
TestMode_Cutter_Para.TestMode_Cutter_Enable_Pulse_Count = 0;
Store_Test.Cutter_Test_Data.Cutter_Test_Sum++;
//多久存一次flash
Current_Cut_Times++;
if(Current_Cut_Times >= TESTMODE_CUTTER_TIMES_TO_FLASH)
{
Current_Cut_Times = 0;
TestMode_Cutter_Para.TestMode_Enable_To_Flash = true;
}
}
}
}
/*******************************************************************************
* 名称: IRQ_TestMode_GapTape_Test
* 描述: 色带间隙位停止控制
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void IRQ_TestMode_GapTape_Test(void)
{
static uint32_t Current_Temp_Count = 0;
if(PAPER_GAP != TestMode_Print_Test.TestMode_Print_TypeInfo)
{
return;
}
//到了检测间隙的位置信息
if(true == TestMode_Print_Test.TestMode_Print_Finish_Detect_Gap_Flag)
{
//变量处理信息
Current_Temp_Count++;
if(Current_Temp_Count >= TestMode_Print_Test.TestMode_Print_AfeterDetect_Gap_Goto_Pix)
{
Current_Temp_Count = 0;
TestMode_Print_Test.TestMode_Print_Finish_Detect_Gap_Flag = false;
TestMode_Print_Test.TestMode_Print_AfeterDetect_Gap_Goto_Pix = 0;
TestMode_Current_Print_Para.TestMode_Current_Print_Copies++;
TestMode_Current_Print_Para.TestMode_Print_Current_Pix = 0;
if(TestMode_Current_Print_Para.TestMode_Current_Print_Copies >=
(TestMode_Print_Test.TestMode_Print_Copies))
{
TestMode_Current_Print_Para.TestMode_Current_Print_Copies = 0;
TestMode_Print_Test.TestMode_Print_Finish = true;
}
}
}
}
/*******************************************************************************
* 名称: TestMode_Get_Gap_Current_Pix
* 描述: 获取当前的像素的信息（光耦对应的间隙的位置）
* 输入参数: 无
* 输出参数:
* 其它: 无
*******************************************************************************/
void TestMode_Get_Gap_Current_Pix(SensorPaperPositionEnum gap_state)
{
static uint8_t retry_times = 0;
static bool gap_check_finish = false;
if(PAPER_GAP != TestMode_Print_Test.TestMode_Print_TypeInfo)
{
return;
}
//判断其是否持续一段时间的间隙
if(gap_state == POSITION_ON_GAP)
{
retry_times++;
if(retry_times >= 5)
{
retry_times = 0;
gap_check_finish = true;
}
}
else{
//满足了上述条件后，有效
if(true == gap_check_finish)
{
//如果准备检测 则更新标记 走下一步
if(true == TestMode_Print_Test.TestMode_Print_Ready_Detect_Gap_Flag)
{
TestMode_Print_Test.TestMode_Print_Ready_Detect_Gap_Flag = false; //准备找位置 标记置为无效
TestMode_Print_Test.TestMode_Print_Finish_Detect_Gap_Flag = true; //找到位置了 标记置为有效
//查看走多长的距离信息
if(TestMode_Current_Print_Para.TestMode_Current_Print_Copies >= (TestMode_Print_Test.TestMode_Print_Copies - 1))
{
TestMode_Print_Test.TestMode_Print_AfeterDetect_Gap_Goto_Pix = TESTMODE_PRINTHEAD_OPTICALCOUPLER_CUTTER;
}
else
{
TestMode_Print_Test.TestMode_Print_AfeterDetect_Gap_Goto_Pix = TESTMODE_PRINTHEAD_OPTICALCOUPLER_PIX;
}
}
//如果选择了不后退的话 则第一张纸直接走过去就OK了
#if PAPER_BACKAWAY_ENABLE
#else
#endif
}
//非累积计数 计数清0
retry_times = 0;
gap_check_finish = false;
}
}
/*******************************************************************************
* 名称: TestMode_PaperGap_Calibration
* 描述: 色带 定标功能 测试模式下
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void TestMode_PaperGap_Calibration(void)
{
//色带计数 处理
if(false == TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Flag)
{
Machine_State = MACHINE_TEST; //当前工作 状态
//间隙纸信息
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Count = 0; //定标计数清0
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Flag = true; //准备定标标记
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_CheckLocation_Finish_Flag = true; //找到位置的标记信息
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_DestCount = TESTMODE_PAPER_CALIBRATION_MAX_PIX; //目标数
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_ErrorFlag = false; //定标错误 置为无效
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Success_Flag = false; //定标完成标记 置为无效
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Finish = false; //定标完成标记置为无效
//启动电机
PrintMotor_Positive_Start();
}
}
/*******************************************************************************
* 名称: IRQ_TestMode_Tape_Gap_Calibration_Judge
* 描述: 色带定标 adc值控制
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void IRQ_TestMode_Tape_Gap_Calibration_Judge(uint16_t adc_value)
{
static uint16_t MinOfADCValue = 0xFFFF;
static uint16_t ADCValueCount = 0; //计数信息
uint16_t Differ_ADC_Value = 0;
//间隙纸信息查看
if(TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_CheckLocation_Finish_Flag)
{
if(false == TestMode_Gap_Calibration_Value.ADC_Calibrate_First_Run_Flag)
{
TestMode_Gap_Calibration_Value.ADC_Calibrate_First_Run_Count++;
if(TestMode_Gap_Calibration_Value.ADC_Calibrate_First_Run_Count >= TESTMODE_CALIBRATION_FIRST_RUN_COUNT)
{
TestMode_Gap_Calibration_Value.ADC_Calibrate_First_Run_Count = 0;
TestMode_Gap_Calibration_Value.ADC_Calibrate_First_Run_Flag = true;
}
}
}
//前段跑完了 再检测
if(true == TestMode_Gap_Calibration_Value.ADC_Calibrate_First_Run_Flag)
{
//找最大值和最小值
if(adc_value > TestMode_Gap_Calibration_Value.ADC_Value_Max)
{
TestMode_Gap_Calibration_Value.ADC_Value_Max = adc_value;
TestMode_Gap_Calibration_Value.ADC_Value_Max_Index = ADCValueCount; //更新最大索引值位置
}
if(adc_value < TestMode_Gap_Calibration_Value.ADC_Value_Min)
{
TestMode_Gap_Calibration_Value.ADC_Value_Min = adc_value;
TestMode_Gap_Calibration_Value.ADC_Value_Min_Index = ADCValueCount; //更新最大索引值位置
}
//计数信息
ADCValueCount++;
//找该阶段的最小值
if(adc_value < MinOfADCValue)
{
MinOfADCValue = adc_value;
}
if(ADCValueCount >= 40)
{
//最大最小差值
Differ_ADC_Value = TestMode_Gap_Calibration_Value.ADC_Value_Max - TestMode_Gap_Calibration_Value.ADC_Value_Min;
//最大值 最小值 恢复
TestMode_Gap_Calibration_Value.ADC_Value_Min = 0xFFFF;
TestMode_Gap_Calibration_Value.ADC_Value_Max = 0;
ADCValueCount = 0; //最小值信息
//找到某阶段的阈值信息
//最小值索引 大于最大值索引（下降）
if( (Differ_ADC_Value >= 400)
&&(TestMode_Gap_Calibration_Value.ADC_Value_Min_Index > TestMode_Gap_Calibration_Value.ADC_Value_Max_Index))
{
TestMode_Gap_Calibration_Value.ADC_Avaliable_Value_Min = MinOfADCValue;
TestMode_Gap_Calibration_Value.ADC_Min_Checked_Count = 0;
TestMode_Gap_Calibration_Value.ADC_Differ_CheckSuccessFlag = true;
}
else
{
if(TestMode_Gap_Calibration_Value.ADC_Differ_CheckSuccessFlag)
{
if((MinOfADCValue + 50) <= (TestMode_Gap_Calibration_Value.ADC_Avaliable_Value_Min))
{
TestMode_Gap_Calibration_Value.ADC_Min_Checked_Count = 0;
TestMode_Gap_Calibration_Value.ADC_Avaliable_Value_Min = MinOfADCValue;
}
else
{
TestMode_Gap_Calibration_Value.ADC_Min_Checked_Count++;
if(TestMode_Gap_Calibration_Value.ADC_Min_Checked_Count >= 5)
{
TestMode_Gap_Calibration_Value.ADC_Min_Checked_Count = 0;
TestMode_PaperGap_Calibration_Location_Finish();
}
}
}
else
{
TestMode_Gap_Calibration_Value.ADC_Min_Checked_Count = 0;
}
}
}
}
}
/*******************************************************************************
* 名称: TestMode_Calibration_Value_Reset
* 描述: 相关变量 复位
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void TestMode_Calibration_Value_Reset(void)
{
TestMode_Gap_Calibration_Value.ADC_Value_Min = 0xFFFF; //ADC最小值
TestMode_Gap_Calibration_Value.ADC_Value_Max = 0; //ADC最大值
TestMode_Gap_Calibration_Value.ADC_Avaliable_Value_Min = 0xFFFF;
TestMode_Gap_Calibration_Value.ADC_Pre_Differ_Value = 0;
TestMode_Gap_Calibration_Value.ADC_Min_Checked_Flag = false;
TestMode_Gap_Calibration_Value.ADC_Min_Checked_Count = 0;
TestMode_Gap_Calibration_Value.ADC_Differ_CheckSuccessFlag = false;
TestMode_Gap_Calibration_Value.ADC_Value_Min_Index = 0, //最小索引值
TestMode_Gap_Calibration_Value.ADC_Value_Max_Index = 0, //最大索引值
TestMode_Gap_Calibration_Value.ADC_Calibrate_First_Run_Count = 0; //跑完了 计数
TestMode_Gap_Calibration_Value.ADC_Calibrate_First_Run_Flag = false; //跑完了 计数
}
/*******************************************************************************
* 名称: TestMode_PaperGap_Calibration_Location_Finish
* 描述: 走到光耦位置成功 则提醒机器定标完成 走空纸
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void TestMode_PaperGap_Calibration_Location_Finish(void)
{
// Store_Process_Flag.PrintGap_Threshold_Value = (TestMode_Gap_Calibration_Value.ADC_Avaliable_Value_Min + 600);
TestMode_Calibration_Value_Reset(); //值信息复位
//取到当前的目标距离值(如果找到了最小的距离值 则整个做更新处理)
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_DestCount =
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Count + TESTMODE_PRINTHEAD_OPTICALCOUPLER_CALIBRATION_CUTTER;
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Success_Flag = true;
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_CheckLocation_Finish_Flag = false;
}
/*******************************************************************************
* 名称: IRQ_TestMode_Tape_Gap_Calibration_Test
* 描述: 测试模式 色带定标 控制
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void IRQ_TestMode_Tape_Gap_Calibration_Test(void)
{
//间隙纸信息查看
//发了定标命令 则电机开始转动
if(TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Flag)
{
//计数信息
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Count++;
//如果找到了 则OK
if(TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Success_Flag)
{
if(TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Count >=
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_DestCount)
{
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Count = 0;
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Flag = false;
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_DestCount = 0;
//更改状态信息为打印完成（即定标完成的状态信息）
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_ErrorFlag = false; //未出错
//定标完成
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Finish = true; //定标完成
//充电接管状态
Charge_Control_Flag.ChargeTakeOver_Flag = false; //定标完成，恢复默认充电控制
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_CheckLocation_Finish_Flag = false; //找到位置标记 置为无效
TestMode_Calibration_Value_Reset(); //值信息复位
PrintMotor_Stop();
//存储定标数据至flash
// Store_Process_Flag.Print_Calibration_Write_Flag = true;
return;
}
}
//超过最大值 则清0
if(TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Count >= TESTMODE_PAPER_CALIBRATION_MAX_PIX)
{
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Count = 0;
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Flag = false;
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Success_Flag = false; //失败掉了
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_DestCount = 0;
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Finish = true; //定标完成
//更改状态信息为打印完成（即定标完成的状态信息）
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_ErrorFlag = true; //出错掉了
//充电接管状态
Charge_Control_Flag.ChargeTakeOver_Flag = false; //定标完成，恢复默认充电控制
TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_CheckLocation_Finish_Flag = false; //找到位置标记 置为无效
TestMode_Calibration_Value_Reset(); //值信息复位
PrintMotor_Stop();
return;
}
}
}
/*******************************************************************************
* 名称: TestMode_Cutter_Times_Fun
* 描述: 切刀测试次数
* 输入参数: 无
* 输出参数: false - 未测试完成 true - 测试完成
* 其它: 无
*******************************************************************************/
bool TestMode_Cutter_Times_Fun(_TESTMODE_CUTTER_TEST_ENUM TestInfo,uint16_t StepMM,uint32_t *cut_times)
{
uint32_t temp_print_length;
Machine_State = MACHINE_TEST; //当前工作 状态
switch(TestInfo)
{
case TESTMODE_CUTTER_START: //启动切刀测试
{
//变更启动状态为 测试状态
TestMode_Cutter_Para.TestMode_Cutter_Start = true; //当前在切刀测试状态时
temp_print_length = StepMM;
TestMode_Cutter_Para.TestMode_Cutter_Dot_Sum = temp_print_length*709/100; //Nmm对应的像素点的长度
*cut_times = Store_Test.Cutter_Test_Data.Cutter_Test_Sum;
break;
}
case TESTMODE_CUTTER_STOP: //停止切刀测试
{
//先停止电机
PrintMotor_Stop();
//变更启动状态为 测试状态
TestMode_Cutter_Para.TestMode_Cutter_Start = false; //当前在切刀测试状态时
TestMode_Cutter_Para.TestMode_Cutter_Dot_Sum = 0; //计数清0
*cut_times = Store_Test.Cutter_Test_Data.Cutter_Test_Sum;
break;
}
case TESTMODE_CUTTER_TOZERO: //清零切刀测试
{
Store_Test.Cutter_Test_Data.Cutter_Test_Sum = 0;
*cut_times = Store_Test.Cutter_Test_Data.Cutter_Test_Sum;
Test_Store_CutterTime_Write(); //存储数据至flash
break;
}
case TESTMODE_CUTTER_GET: //获取切刀测试
{
*cut_times = Store_Test.Cutter_Test_Data.Cutter_Test_Sum;
break;
}
default:
{
break;
}
}
return true;
}
/*******************************************************************************
* 名称: IRQ_TestMode_HeatTime_Test
* 描述: 打印测试(配合加热时间)(包含全黑打印测试，间隙打印测试、固定图案打印测试)
* 输入参数: 无
* 输出参数: 无
* 其它: 100us定时器
*******************************************************************************/
void IRQ_TestMode_HeatTime_Test(void)
{
//允许加热控制 则启动加热
if(true == TestMode_Current_Print_Para.TestMode_StopHeat_Count_Flag)
{
TestMode_Current_Print_Para.TestMode_HeatTime_Current_Count++;
if(TestMode_Current_Print_Para.TestMode_HeatTime_Current_Count >= (TestMode_Current_Print_Para.TestMode_HeatTime_Current/100))
{
TestMode_Current_Print_Para.TestMode_HeatTime_Current_Count = 0; //从0开始
TestMode_Current_Print_Para.TestMode_StopHeat_Count_Flag = false; //超过时间 则不再计算加热时间 不做处理
Print_Line_Stop_Write_Heat(); //超过加热时间 则停止加热
}
}
}
/*******************************************************************************
* 名称: TestMode_Normal_Print_Byte
* 描述: 普通测试 打印数据
* 输入参数: 无
* 输出参数: 无
* 其它: 暂时未用
*******************************************************************************/
void TestMode_Normal_Print_Byte(uint32_t cnt,uint8_t* byteBuf)
{
//前32部分
if(cnt < 32)
{
memset(byteBuf, ((cnt % 8) >= 4)?0x00:0xFF, 8);
}
else if((cnt >= 32)&&(cnt < 80))
{
memset(byteBuf, ((cnt % 8) >= 4)?0x00:0xFF, 8);
}
else if((cnt >= 80)&&(cnt < 100))
{
memset(byteBuf, 0x00, 8);
}
else if((cnt >= 100)&&(cnt < 310))
{
memset(byteBuf, 0xFF, 8);
}
else if((cnt >= 310)&&(cnt < 330))
{
memset(byteBuf, 0x00, 8);
}
else if((cnt >= 330)&&(cnt < 1000))
{
memset(byteBuf, ((cnt % 8) >= 4)?0x00:0xFF, 8);
}
}
/*******************************************************************************
* 名称: TestMode_Normal_Print_Test
* 描述: 常规测试，用于EMC,临时版本
* 输入参数: 无
* 输出参数: 无
* 其它: 2S执行1次
*******************************************************************************/
void IRQ_TestMode_EMC_Print_Test(void)
{
//Print_VH_Power_OnOff(true); //打开当前供电
//打印一行数据
Print_Line_Start_Write_Heat((uint8_t *)(&Print_Test_Dot_Byte[0]),false);
//计算加热时间
TestMode_EMC_Print.TestMode_EMC_Print_Count = 80;
TestMode_EMC_Print.TestMode_EMC_Print_Flag = true;
}
/*******************************************************************************
* 名称: IRQ_TestMode_EMC_HeatTime_Test
* 描述: 加热时间控制
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void IRQ_TestMode_EMC_HeatTime_Test(void)
{
if(TestMode_EMC_Print.TestMode_EMC_Print_Flag)
{
if(TestMode_EMC_Print.TestMode_EMC_Print_Count > 0)
{
TestMode_EMC_Print.TestMode_EMC_Print_Count--;
if(0 == TestMode_EMC_Print.TestMode_EMC_Print_Count)
{
TestMode_EMC_Print.TestMode_EMC_Print_Flag = false;
Print_Line_Stop_Write_Heat();
}
}
}
}
/*******************************************************************************
* 名称: Debug_Info_Print
* 描述: 调试信息打印
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void Debug_Info_Print(void)
{
// usb_data_send_str("T=%d,e=%d,g=%d,p=%d,g_e=%d,g_g=%d,g_p=%d\r\n"
// ,Store_Para.Print_Paper_Type_Para.PrintPaperType
// ,Store_Para.Print_Calibration_Para.Threshold_Paper_Continue.Threshold_Empty
// ,Store_Para.Print_Calibration_Para.Threshold_Paper_Continue.Threshold_Gap
// ,Store_Para.Print_Calibration_Para.Threshold_Paper_Continue.Threshold_Paper
// ,Store_Para.Print_Calibration_Para.Threshold_Paper_Gap.Threshold_Empty
// ,Store_Para.Print_Calibration_Para.Threshold_Paper_Gap.Threshold_Gap
// ,Store_Para.Print_Calibration_Para.Threshold_Paper_Gap.Threshold_Paper
// );
// usb_data_send_str("charging: %d,chargefill: %d\r\n",Charge_Control_Flag.ChargeFinish_Flag,Charge_Control_Flag.ChargeFinish_Flag);
// usb_data_send_str("switch = %d\r\n",State_Check_Para.State_TapeCheck.BackCover_State);
// usb_data_send_str("bat = %d\r\n",adc_channel_average_value.Power_Bat_Value);
// usb_data_send_str("the cap = %d\r\n",Adc_Channel_Value.adc_data.Paper_Tape_Value);
// usb_data_send_str("gap = %d,paper = %d\r\n",Store_Para.Print_Calibration_Para.Threshold_Paper_Gap.Threshold_Gap,Store_Para.Print_Calibration_Para.Threshold_Paper_Gap.Threshold_Paper);
}
/*******************************************************************************
* 名称: Test_Printer_Pin
* 描述: 打印头引脚测试控制
* 输入参数: 无
* 输出参数: 无
* 其它: 无
*******************************************************************************/
void Test_Printer_Pin(void)
{
static bool current_state = false;
if(false == current_state)
{
current_state = true;
Printer_Clk_Low();
Printer_DataIn_Low();
Printer_Lat_Low();
Printer_Stb_Low();
}
else
{
current_state = false;
Printer_Clk_High();
Printer_DataIn_High();
Printer_Lat_High();
Printer_Stb_High();
}
}
#include "api_supplies.h"
#include "type.h"
#include "yc_wdt.h"
#include "hal_SuppliesAuth.h"
#include "api_sensorcheck.h"
//黑名單觸發條件是 最後紀錄長度和當前讀取到的長度比超過300mm時會觸發加入黑名單
uint8_t stopFlag = 0;
ST_APP_STATUS appStatus = {0};
INT32 SuppliesDecLength = 0;
void api_supplies_process()
{
static BYTE failCount = 0;
PaperStateInfoTypeDef noPaperFlag;
// static uint16_t _suppliesCheckFlag = 1000;
// static uint16_t Supplies_Check_Time = 0 ;
// Supplies_Check_Time ++;
uint32_t LastLen = 0;
// noPaperFlag = 0;
appStatus.SuppliesIsChecking = 1;
appStatus.NotYetDecLength = SuppliesDecLength / 8;
// MyPrintf("NotYetDecLength=%d\r\n",appStatus.NotYetDecLength);
// if(Supplies_Check_Time>=5)
{
if(SuppliseAuth_Check(appStatus.NotYetDecLength, &LastLen)) //检查是否是u20机器-----并获取剩余长度---------------------
{
SuppliesDecLength = SuppliesDecLength - appStatus.NotYetDecLength*8 ;
appStatus.NotYetDecLength = 0;
// SuppliesDecLength = 0;
failCount = 0;
appStatus.LastSuppliesLength = LastLen;
// MyPrintf("Lsl=%d\r\n", appStatus.LastSuppliesLength); //芯片写200米打印多张之后Lsl=199386，重写芯片为30米，则Lsl=30000
}
else
{
// MyPrintf("SC:error\r\n");
if(failCount < 5)
{
failCount++;
}
if(failCount >= 5)
{
appStatus.LastSuppliesLength = 0;
}
}
appStatus.SuppliesIsChecking = 0;
// _suppliesCheckFlag = 0;
// Supplies_Check_Time = 0;
}
#ifdef Encryption_ENABLE //加密使能
// if(((SuppliesDecLength / 8) + appStatus.NotYetDecLength) > appStatus.LastSuppliesLength) //标签用完
if(100>appStatus.LastSuppliesLength)
{
appStatus.Lable_Or_Not_Flag = 1;
// MyPrintf("SC:error----22222\r\n");
}
else
{
appStatus.Lable_Or_Not_Flag = 0;
// MyPrintf("SC:error----33333\r\n");
}
#else
f_error_tape_error = 0;
#endif
}
#ifndef __APP_H__
#define __APP_H__
#define DEBUG_MSG_ENABLE
#define Encryption_ENABLE
//#define Encryption_ENABLE //q21要求不加密
#include "type.h"
typedef struct
{
uint32_t LastSuppliesLength;
uint32_t NotYetDecLength;
uint32_t UID;
BOOL SuppliesIsChecking;
BOOL Lable_Or_Not_Flag; //是否检测到标签的标志NoLabel
BOOL PaperTypeHasBeenSetFlag; //设置纸张类型标志
}ST_APP_STATUS;
extern ST_APP_STATUS appStatus;
enum
{
APPEVENT_DEC_SUPPLIES_LENGTH,
};
typedef BYTE ENUM_APPEVENT;
typedef struct
{
ENUM_APPEVENT EventID;
BYTE Param[8];
}ST_APPEVENT;
typedef struct
{
uint32_t DecLength;
BYTE Reserve[4];
}ST_APPEVENT_DEC_SUPPLIES_LEN_PARAM;
extern void api_supplies_process();
extern ST_APP_STATUS appStatus ;
extern INT32 SuppliesDecLength ;
#endif
api差异文件
最新推荐文章于 2024-10-01 10:59:04 发布
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
