api文件之api_data_analysis.c

/******************************************************************************
版权所有:  深圳市**科技有限公司 
文件名:    api_data_analysis.c
作者:      wangdy
创建日期:  2020/07/8
描述:      蓝牙模块协议解析及处理 
其它:      
修改历史:  //修改历史记录列表,每条修改记录应包含修改日期、修改者及修改内容简述
            序号    修改时间    修改人  修改内容
            ????    ????/??/??  ??????  参考样式       
******************************************************************************/

/************************************头文件************************************/

#include "api_data_analysis.h"
#include "api_print.h"
#include "usb_main.h"
#include "bsp_charge_control.h"
#include "var_global.h"
#include "tools_function.h"
#include "api_state_check.h"
#include "api_power_control.h"
#include "usb_main.h"
#include "bsp_bt.h"
#include "api_para_set.h"
#include "api_test.h"
#include "version.h"

#include "ymodem.h"
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include "yc3121.h"

#include "api_sensorcheck.h"

/*************************************变量*************************************/

_DATA_ANALYSIS_UNI        Data_Analysis_Tx;        //数据发送接口 
_DATA_ANALYSIS_UNI        Data_Analysis_Rx;        //数据接收接口 

PrintNormalDataTypeDef  PrintNormalData;        //正常解析数据  

uint8_t                 Recv_Buf_All[RECV_BUF_ALL];        //接收字节 
bool                    Second_Update_Confirm_Flag = false;        //二次升级  确认标志 

/*************************************函数*************************************/


/*******************************************************************************
* 名称:        PrintData_Send      
* 描述:        协议打印数据  应答  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void PrintData_Send(uint8_t *buf,uint16_t len)
{
    //判断接收长度  
    if(len == 0)
    {
        return;
    }
    
    //如果在测试模式 
    if(MACHINE_TEST == Machine_State)
    {
        USB_Printer_Send(buf,len);
    }
    else     //未处于测试模式 
    {
        //蓝牙 数据发送 
        if(BtRxTxVar.BtBleConnectStateFlag == true)
        {
            BT_DataSend(buf,len);
        }
        //USB 数据发送
        else 
        {
            USB_Printer_Send(buf,len);
        }
    }

#if 0    
    MyPrintf("tx:");
    for(int i = 0; i<len; i++){
        MyPrintf("%02x ",buf[i]);
    }
    MyPrintf("\n");
#endif 
}

/*******************************************************************************
* 名称:        PrintData_Send      
* 描述:        协议打印数据  应答  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void PrintData_Send_Str(char *format,...)
{
    uint32_t temp_len = 0;
    uint8_t  temp_str[SEND_RECV_SIZE];

    va_list vArgList;
    
    va_start(vArgList, format);
    temp_len = vsnprintf((char *)temp_str, SEND_RECV_SIZE, (char *)format, vArgList);
    va_end(vArgList);
    
    //如果在测试模式 
    if(MACHINE_TEST == Machine_State)
    {
        USB_Printer_Send(temp_str,temp_len);
    }
    else 
    {
        //蓝牙 数据发送 
        if(BtRxTxVar.BtBleConnectStateFlag == true)
        {
            BT_DataSend(temp_str,temp_len);
        }
        //USB 数据发送
        else 
        {
            USB_Printer_Send(temp_str,temp_len);
        }
    }
}

/*******************************************************************************
* 名称:        Print_Data_Unpack_Pack       
* 描述:        打印传输协议   解包
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Print_Data_Unpack_Pack(uint8_t byte){
    static uint32_t recv_pos = 0;
    uint16_t i = 0;
    bool isReadyAnalysis = false;
    //其它变量  
    static int8_t command_0x18_cur_byte_len = 0;        //0x18长度信息 
    static uint16_t commad_0x1d_0x28_len = 0;        //1d 28 长度 
    static uint16_t command_0x54_len = 0;            //0x54 长度 
    
    //
    static uint32_t test_count = 0;
        
    switch(recv_pos){
        case 0:{                                //byte 1 
            switch(byte){
                case 0x15:{            //打印空格  
                    PrintNormalData.cmd = byte;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    break;
                }
                case 0x17:{            //设置打印参数  
                //    MyPrintf("aaa\n");
                    PrintNormalData.cmd = byte;
                    PrintNormalData.length = 13;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    break;
                }
                case 0x1D:{            //设置参数 
                    PrintNormalData.cmd = byte;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    break;
                }
                case 0x16:{  //打印行数据    0x16指令第一个字节
                //    MyPrintf("bbb\n");
                    PrintNormalData.cmd = byte;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    break;
                }
                case 0x18:    //打印压缩数据  解包 
                {
                    PrintNormalData.cmd = byte;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    break;
                }
                case 0x1B:    //ESC指令 
                {
                    PrintNormalData.cmd = byte;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    break;
                }
                case 0x0C:    //转到空隙处 
                {
                    PrintNormalData.cmd = byte;
                    PrintNormalData.length = 1;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    isReadyAnalysis = true;        //准备解析数据  
                    break;
                }
                case 0x10:    //打印状态返回  
                {
                    PrintNormalData.cmd = byte;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    break;
                }
                case 0x55:    //升级第二次确认 
                {
                    PrintNormalData.cmd = byte;
                    PrintNormalData.length = 1;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    isReadyAnalysis = true;        //准备解析数据  
                    break;
                }
                case 0x31:    //二次升级确认完成后  则当上位机下发指令时,准备开始升级了 
                {
                    PrintNormalData.cmd = byte;
                    PrintNormalData.length = 1;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    isReadyAnalysis = true;        //准备解析数据  
                    break;
                }
                case 0x54:    //测试指令
                {
                    PrintNormalData.cmd = byte;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    break;
                }                        
                default:{
                    PrintNormalData.cmd = 0x00;
                    PrintNormalData.length = 0;
                    recv_pos = 0;
                    break;
                }
            }
            if(PrintNormalData.cmd != 0x00){
                recv_pos++;
            }else {
                recv_pos=0;
            }
            break;
        }
        case 1:                //byte 2 
        {
            switch(PrintNormalData.cmd){
                case 0x15:{
                    PrintNormalData.length = 2;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    isReadyAnalysis = true;        //准备解析数据  
                    break;
                }
                case 0x1D:{
                    switch(byte){
                        case 0x49:{
                            PrintNormalData.dataInfo[recv_pos] = byte;
                            recv_pos++;
                            break;
                        }
                        case 0x56:{
                            PrintNormalData.dataInfo[recv_pos] = byte;
                            recv_pos++;
                            break;
                        }
                        case 0x28:{
                            PrintNormalData.dataInfo[recv_pos] = byte;
                            recv_pos++;
                            break;
                        }
                        case 0x3C:{            //定标 
                            PrintNormalData.length = 2;
                            PrintNormalData.dataInfo[recv_pos] = byte;
                            isReadyAnalysis = true;            //准备解析数据  
                            break;
                        }
                        default:{
                            PrintNormalData.cmd = 0;
                            PrintNormalData.length = 0;
                            recv_pos = 0;
                            break;
                        }
                    }
                    break;
                }
                case 0x16:    {
                    if(0 != byte){
//                        MyPrintf("byte2= %d\r\n",byte);   // 0x16指令第二个字节
                        PrintNormalData.length = byte + 2;  //10 LEN XX XXX
                        PrintNormalData.dataInfo[recv_pos] = byte;
                        recv_pos++;
                    }else {
                    //    MyPrintf("bbb33\n");
                        PrintNormalData.length = 0;
                        recv_pos = 0;
                    }
                    break;
                }
                case 0x18:{
                    if(byte == 0){
                        PrintNormalData.length = 0;
                        recv_pos = 0;
                    }else {
                        if((byte & 0x80) == 0x80){
                            command_0x18_cur_byte_len = 1;                //0x18长度 
                        }else {
                            command_0x18_cur_byte_len = byte & 0x7F;        //0x18长度 
                        }    
                        PrintNormalData.dataInfo[recv_pos] = byte;
                        recv_pos++;
                    }        

                    break;
                }
                case 0x1B:{
                    if(0x40 == byte){
                        PrintNormalData.length = 2;
                        PrintNormalData.dataInfo[recv_pos] = byte;
                        isReadyAnalysis = true;        //准备解析数据  
                    }else if(0x64 == byte){
                        PrintNormalData.dataInfo[recv_pos] = byte;
                        recv_pos++;
                    }
                    else {
                        PrintNormalData.cmd = 0;
                        PrintNormalData.length = 0;
                        recv_pos = 0;
                    }
                    break;
                }
                case 0x10:{
                    if((0x06 == byte) || (0x04 == byte)){
                        PrintNormalData.dataInfo[recv_pos] = byte;
                        recv_pos++;
                    }else {
                        PrintNormalData.cmd = 0;
                        PrintNormalData.length = 0;
                        recv_pos = 0;
                    }
                    break;
                }
                case 0x54:{
                    command_0x54_len = byte;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    recv_pos++;
                    break;
                }
                case 0x17:{
                //    MyPrintf("aaa22\n");  //0x17指令第二个字节
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    recv_pos++;
                    break;
                }
                default:{
                    PrintNormalData.cmd = 0;
                    PrintNormalData.length = 0;
                    recv_pos = 0;
                    break;
                }
            }
            break;
        }
        case 2:        //byte 3
        {
            switch(PrintNormalData.cmd){
                case 0x1D:{
                    switch(PrintNormalData.dataInfo[1]){
                        case 0x49:{
                            PrintNormalData.length = 3;
                            PrintNormalData.dataInfo[recv_pos] = byte;
                            isReadyAnalysis = true;        //准备解析数据  
                            break;
                        }
                        case 0x56:{
                            PrintNormalData.length = 3;
                            PrintNormalData.dataInfo[recv_pos] = byte;
                            isReadyAnalysis = true;        //准备解析数据  
                            break;
                        }
                        case 0x28:{ 
                            switch(byte){
                                case 0x4B:
                                case 0x48:
                                case 0x4C:
                                case 0x49:{
                                    PrintNormalData.dataInfo[recv_pos] = byte;
                                    recv_pos++;
                                    break;
                                }
                                default:{
                                    PrintNormalData.cmd = 0;
                                    PrintNormalData.length = 0;
                                    recv_pos = 0;
                                    break;
                                }
                            }
                            break;
                        }
                        default:{
                            PrintNormalData.cmd = 0;
                            PrintNormalData.length = 0;
                            recv_pos = 0;
                            break;
                        }
                    }
                    break;
                }
                case 0x16:{
                    if(recv_pos < PrintNormalData.length){        
                    //    MyPrintf("bbb44\n");     //0x16指令第三个字节
                    //    MyPrintf("byte3= %02x\r\n",byte);
                        PrintNormalData.dataInfo[recv_pos] = byte;
                        recv_pos++;
                    }else {
                        //MyPrintf("bbb55\n");
                        PrintNormalData.cmd = 0;
                        PrintNormalData.length = 0;
                        recv_pos=0;
                    }
                    break;
                }
                case 0x18:{        //第3个字节  必为数据信息  否则表示整个数据都存在问题  
                    if(command_0x18_cur_byte_len > 0){
                        PrintNormalData.dataInfo[recv_pos] = byte;
                        recv_pos++;
                        //判断当前是否读完了 
                        command_0x18_cur_byte_len--;
                    }else {
                        PrintNormalData.cmd = 0x00;
                        PrintNormalData.length = 0;
                        recv_pos=0;
                    }
                    break;
                }
                case 0x1B:{            
                    if(0x64 == PrintNormalData.dataInfo[1]){
                        PrintNormalData.length = 3;
                        PrintNormalData.dataInfo[recv_pos] = byte;
                        isReadyAnalysis = true;        //准备解析数据  
                    }else {
                        PrintNormalData.cmd = 0x00;
                        PrintNormalData.length = 0;
                        recv_pos = 0;
                    }
                    break;
                }
                case 0x10:{
                    PrintNormalData.length = 3;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    isReadyAnalysis = true;        //准备解析数据  
                    break;
                }
                case 0x54:{
                    PrintNormalData.length = command_0x54_len + byte*256;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    recv_pos++;
                    break;
                }
                case 0x17:{
                //    MyPrintf("aaa33\n");
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    recv_pos++;
                    break;
                }
            }
            break;
        }
        case 3:{   //第四个字节 
            if((0x1D == PrintNormalData.cmd) && (0x28 == PrintNormalData.dataInfo[1])){
                commad_0x1d_0x28_len = byte;
                PrintNormalData.dataInfo[recv_pos] = byte;
                recv_pos++;
            }else if(0x18 == PrintNormalData.cmd){
                if(command_0x18_cur_byte_len == 0){
                    if(0 == byte){
                        command_0x18_cur_byte_len = 0;
                        PrintNormalData.dataInfo[recv_pos] = byte;
                        PrintNormalData.length = recv_pos + 1;
                        recv_pos = 0;    
                        isReadyAnalysis    = true;                    
                    }else {
                        if((byte & 0x80) == 0x80){
                            command_0x18_cur_byte_len = 1;                //0x18长度 
                        }else {
                            command_0x18_cur_byte_len = byte & 0x7F;        //0x18长度 
                        }
                        PrintNormalData.dataInfo[recv_pos] = byte;
                        recv_pos++;
                    }    
                }else{
                    command_0x18_cur_byte_len--;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    recv_pos++;    
                }
            }
            else {
                //MyPrintf("ccccc\n");  //0x17和0x16指令第四个字节
            //    MyPrintf("byte4= %02x\r\n",byte);
                PrintNormalData.dataInfo[recv_pos] = byte;
                recv_pos++;    
                if(recv_pos >= PrintNormalData.length){
                    isReadyAnalysis = true;        //准备解析数据 
                    break;
                }
            }
            break;
        }
        case 4:{   //第五个字节 
            if((0x1D == PrintNormalData.cmd) && (0x28 == PrintNormalData.dataInfo[1])){
                commad_0x1d_0x28_len += (byte*256);
                PrintNormalData.length = commad_0x1d_0x28_len + 5;
                PrintNormalData.dataInfo[recv_pos] = byte;
                recv_pos++;
            }else if(0x18 == PrintNormalData.cmd){
                if(command_0x18_cur_byte_len <= 0){
                    if(0 == byte){
                        command_0x18_cur_byte_len = 0;
                        PrintNormalData.dataInfo[recv_pos] = byte;
                        PrintNormalData.length = recv_pos + 1;
                        recv_pos = 0;
                        isReadyAnalysis    = true;                                
                    }else {
                        if((byte & 0x80) == 0x80){
                            command_0x18_cur_byte_len = 1;                //0x18长度 
                        }else {
                            command_0x18_cur_byte_len = byte & 0x7F;        //0x18长度 
                        }
                        PrintNormalData.dataInfo[recv_pos] = byte;
                        recv_pos++;
                    }    
                }else{
                    command_0x18_cur_byte_len--;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    recv_pos++;    
                }
            }else {
                //MyPrintf("ddddd\n");   //0x17和0x16指令第五个字节
            //    MyPrintf("byte5= %02x\r\n",byte);
                PrintNormalData.dataInfo[recv_pos] = byte;
                recv_pos++;    
                if(recv_pos >= PrintNormalData.length){
                    isReadyAnalysis = true;        //准备解析数据 
                    break;
                }
            }
            break;
        }
        default:{            //除了0x18不知长度外 其它指令到第3个字节 都知道其长度了  
            if(0x18 == PrintNormalData.cmd){
                if(command_0x18_cur_byte_len <= 0){
                    if(0 == byte){
                        command_0x18_cur_byte_len = 0;
                        PrintNormalData.dataInfo[recv_pos] = byte;
                        PrintNormalData.length = recv_pos + 1;
                        recv_pos = 0;
                        isReadyAnalysis    = true;                                
                    }else {
                        if((byte & 0x80) == 0x80){
                            command_0x18_cur_byte_len = 1;                //0x18长度 
                        }else {
                            command_0x18_cur_byte_len = byte & 0x7F;        //0x18长度 
                        }
                        PrintNormalData.dataInfo[recv_pos] = byte;
                        recv_pos++;
                    }    
                }else{
                    command_0x18_cur_byte_len--;
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    recv_pos++;    
                }
            }
            else {
                if(false == isReadyAnalysis){
                    //MyPrintf("1111111\n");              //安卓打印的时候执行0x17指令之后会进来这里执行几次(8次左右)等待执行0x16指令
                //    MyPrintf("byte_= %02x\r\n",byte);
                    PrintNormalData.dataInfo[recv_pos] = byte;
                    recv_pos++;
                    
                    if(recv_pos >= PrintNormalData.length){
                        isReadyAnalysis = true;        //准备解析数据 
                        break;
                    }
                }
            }
            break;
        }
    }  //switch 
    
    if(isReadyAnalysis){
        isReadyAnalysis = false;        //解析  
        recv_pos = 0;
        
        #if 0
            if(0x16 == PrintNormalData.cmd){
                test_count++;
                MyPrintf("\ncount:%d\n",test_count);
            }else if(0x15 == PrintNormalData.cmd){
                test_count += PrintNormalData.dataInfo[1];
                MyPrintf("\ncount:%d\n",test_count);
            }
        #endif 
        
        #if 0
            if(0x18 == PrintNormalData.cmd){
                test_count++;
                //MyPrintf("\ncount:%d\n",test_count);
                for(int k = 0; k<PrintNormalData.length; k++){
                    MyPrintf("%02x ",PrintNormalData.dataInfo[k]);
                }
                MyPrintf("\n");
            }else if(0x15 == PrintNormalData.cmd){
                //test_count += PrintNormalData.dataInfo[1];
                //MyPrintf("\ncount:%d\n",test_count);
            }
        #endif 
        
        #if 0
            MyPrintf("\n");
            for(int k = 0; k<PrintNormalData.length; k++){
                MyPrintf("%02x ",PrintNormalData.dataInfo[k]);
            }
            //MyPrintf("\n");
        #endif 
        
        Print_Data_Analysis(PrintNormalData.dataInfo,PrintNormalData.length);
    }
}

/*******************************************************************************
* 名称:        Print_Data_Analysis       
* 描述:        数据解析工作   解析打印数据 
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Print_Data_Analysis(uint8_t *buf,uint16_t len)
{
    //无效数据  回0 
    if(len == 0)
    {
        return;
    }
    
    //强转协议格式  
    memcpy((char *)(&Data_Analysis_Rx.buf[0]),buf,len);    
    
    //根据功能码进行协议解析 
    switch(Data_Analysis_Rx.buf[0])
    {
        case 0x1D : 
        {
            if(0x28 == Data_Analysis_Rx.buf[1])
            {
                if(0x4B == Data_Analysis_Rx.buf[2])
                {
                    if(Data_Analysis_Rx.Cmd_Set_Print_Density.Length + 5 == len)
                    {
                        switch(Data_Analysis_Rx.buf[5])        //设置信息     
                        {
                            case 0x30:                        //设置打印浓度 
                            {
                                Cmd_Ack_Density_Fun();         
                                
                                break;
                            }
                            case 0x31:                        //设置打印速度 
                            {
                                Cmd_Ack_Speed_Fun();    
                                break;
                            }
                            case 0x33:                        //设置纸张类型 
                            {
                                Cmd_Ack_PaperType_Fun();    
                                break;
                            }
                            case 0x34:                        //设置打印模式 
                            {
                                Cmd_Ack_Set_Print_Type_Fun();    
                                break;
                            }
                            case 0x35:                        //设置标签尺寸 
                            {
                                Cmd_Ack_Set_Tape_Size_Fun();
                                break;
                            }
                            case 0x39:                        //设置作余白距离 
                            {
                                Cmd_Ack_Set_Blank_Length_Fun();
                                break;
                            }
                            case 0x3A:                        //设置剪切模式 
                            {
                                Cmd_Ack_Set_Cut_Mode_Fun();    
                                break;
                            }
                            default:
                            {
                                break;
                            }
                        }
                    }
                }
                else if(0x4C == Data_Analysis_Rx.buf[2])    //设置信息 
                {
                    switch(Data_Analysis_Rx.buf[5])        
                    {
                        case 0x32:            //设置NFC校验密码 
                        {
                            Cmd_Ack_Set_NFC_Passwd_Fun();
                            break;
                        }
                        case 0x33:            //设置碳带长度  
                        {
                            Cmd_Ack_Set_TTR_Length_Fun();    
                            break;
                        }
                        case 0x55:
                        {
                            if(0x48 == Data_Analysis_Rx.buf[6])    //写RFID(高频)标签(按块写)
                            {
                                Cmd_Ack_Write_RDID_Block_Fun();
                            }
                            if(0x49 == Data_Analysis_Rx.buf[6])    //写RFID(超高频) EPC标签 
                            {
                                Cmd_Ack_Write_RDID_Fun();    
                            }
                            
                            break;
                        }
                        case 0x34:            //设置确定是否升级  
                        {
                            Cmd_Ack_Guid_IAP_Update();
                            break;
                        }
                        default:
                        {
                            break;
                        }
                    }
                }
                else if(0x48 == Data_Analysis_Rx.buf[2])        //读取信息 
                {
                    switch(Data_Analysis_Rx.buf[5])        
                    {
                        case 0x31:            //读取色带使用状态 
                        {
                            Cmd_Ack_Get_Tape_State_Fun();
                            break;
                        }
                        case 0x32:            //读取电池电量状态  
                        {
                            Cmd_Ack_Get_Battery_Power_Fun();
                            break;
                        }
                        case 0x33:            //读取蓝牙和wifi状态 
                        {
                            Cmd_Ack_BT_WIFI_Connect_State_Fun();
                            break;
                        }
                        case 0x35:            //获取打印机有效打印宽度  
                        {
                            Cmd_Ack_Get_Print_Valid_Width_Fun();
                            break;
                        }
                        case 0x36:            //获取当前打印机的缓存 
                        {
                            Cmd_Ack_Get_Print_Buffer_Lines_Fun();
                            break;
                        }
                        default:
                        {
                            break;
                        }
                    }
                }
            }
            else if(0x49 == Data_Analysis_Rx.buf[1])
            {
                Cmd_Ack_Get_Print_ID_Info_Fun();
            }
            else if(0x56 == Data_Analysis_Rx.buf[1]) //1D 56 XX
            {
                Cmd_Ack_Set_After_Print_Flag_Fun();    //判断打 印完成后  是否剪切  
            }
            break;
        }
        case 0x10:
        {
            Cmd_Ack_Get_Realtime_State_Fun();        //打印机参数 应答 
            break;
        }
        case 0x17:
        {
            Cmd_Ack_Set_Tape_Para_Fun();            //设置打印参数     
            break;
        }
        case 0x16:
        {
            Cmd_Ack_Set_Write_Line_Print();            //打印一点行数据  
            break;
        }
        case 0x18:
        {
            Cmd_Ack_Set_Write_Line_Compress_Print(len);    //打印一点行压缩数据        
            break;
        }
        case 0x1B:        //ESC命令
        {
            if(0x40 == Data_Analysis_Rx.buf[1])
            {
                Cmd_Ack_Set_ESC_Command();                    //ESC命令 类似于复位命令 
            }
            else if(0x64 == Data_Analysis_Rx.buf[1]) 
            {
                Cmd_Ack_Go_With_Paper_Fun();                //空走纸命令 
            }
            break;
        }
        case 0x15:
        {
            Cmd_Ack_Set_Blank_N_Print();                //走纸N点行 
            break;
        }
        case 0x0C:                                        //走到缝隙处
        {
            Cmd_Ack_Set_Goto_Gap_Locate();
            break;
        }
        case 0x55:                                        //二次升级确认 
        {
            Cmd_Ack_Guid_IAP_Second_Request();    
            break;
        }
        case 0x31:                                        //准备升级  
        {
            Cmd_Ack_Guid_IAP_Prepare_Update();        
            break;
        }
        case 0x54:                                        //生产测试 
        {
            Cmd_Ack_TestMode_Analysis();
            break;
        }
        default:
        {
            break;
        }
    }
}

/*******************************************************************************
* 名称:        Cmd_Ack_Density_Fun       
* 描述:        设置打印浓度  解析及应答  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Density_Fun(void)
{
    Print_Data_Cache.PrintDensity = Data_Analysis_Rx.Cmd_Set_Print_Density.PrintDensity;
    
    //应答信息 
//    PrintData_Send_Str("ok");
//    usb_data_send_str("Density = %d\r\n",Print_Data_Cache.PrintDensity);
}

/*******************************************************************************
* 名称:        Cmd_Ack_Speed_Fun       
* 描述:        设置打印速度  解析及应答  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Speed_Fun(void)
{
    Print_Data_Cache.PrintSpeed = Data_Analysis_Rx.Cmd_Set_Print_Speed.PrintSpeed;
    
    //应答信息 
//    PrintData_Send_Str("ok");
}

/*******************************************************************************
* 名称:        Cmd_Ack_PaperType_Fun       
* 描述:        设置纸张类型  解析及应答  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_PaperType_Fun(void)
{
    PrintPaperTypeEnum   Paper_Type;
    
    Paper_Type = (PrintPaperTypeEnum)(Data_Analysis_Rx.Cmd_Set_Paper_Type.PrintPaperType);
    
    //看纸张类型有没有发生变化 ,如果发生变化了,则更新纸张类型至flash
    if(Paper_Type != Store_Para.Print_Paper_Type_Para.PrintPaperType){
        Store_Para.Print_Paper_Type_Para.PrintPaperType = Paper_Type;
        Para_Store_PrintPaper_Type_Write();
    }
}

/*******************************************************************************
* 名称:        Cmd_Ack_Set_Print_Type_Fun       
* 描述:        设置打印模式 
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Set_Print_Type_Fun(void)
{
    Print_Data_Cache.PrintMode = Data_Analysis_Rx.Cmd_Set_Print_Mode.PrintMode;
}

/*******************************************************************************
* 名称:        Cmd_Ack_Set_Blank_Length_Fun       
* 描述:        设置余白长度 
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Set_Blank_Length_Fun(void)
{
    Print_Data_Cache.PrintBlank = Data_Analysis_Rx.Cmd_Set_Blank_Length.Blank_Length;        //偏移多少个像素点 
    MyPrintf("blank:%d\n",Print_Data_Cache.PrintBlank);
}

/*******************************************************************************
* 名称:        Cmd_Set_Cut_Mode_Fun       
* 描述:        设置剪切模式  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Set_Cut_Mode_Fun(void)
{
    Print_Data_Cache.PrintCutMode =  Data_Analysis_Rx.Cmd_Set_Cut_Mode.Cut_State;    //剪切 
}

/*******************************************************************************
* 名称:        Cmd_Ack_Set_Tape_Size_Fun       
* 描述:        设置标签尺寸 
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Set_Tape_Size_Fun(void)
{
    Print_Data_Cache.TabWidthMM = Data_Analysis_Rx.Cmd_Set_Tab_Size.TabWidthMM;
    Print_Data_Cache.TabHightPix = Data_Analysis_Rx.Cmd_Set_Tab_Size.TabHightPix;
}

/*******************************************************************************
* 名称:        Cmd_Ack_Set_NFC_Passwd_Fun       
* 描述:        设置NFC校验密码 
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Set_NFC_Passwd_Fun()
{
    memcpy(Print_Par.NFCPassWd,Data_Analysis_Rx.Cmd_Set_NFC_Passwd.NFCPassWd,6);
}

/*******************************************************************************
* 名称:        Cmd_Ack_Set_TTR_Length_Fun       
* 描述:        设置碳带长度  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Set_TTR_Length_Fun(void)
{
    Print_Data_Cache.TTRLength = Char2LongBigEndian(&Data_Analysis_Rx.Cmd_Set_TTR_Length.TTRLength[0]);
}

/*******************************************************************************
* 名称:        Cmd_Ack_Get_Print_ID_Info_Fun       
* 描述:        查询打印机ID号  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Get_Print_ID_Info_Fun(void)
{
    switch(Data_Analysis_Rx.Cmd_Get_Print_ID_Info.PrintIDInfo)
    {
        case Enum_Get_Bt_State:        //获取蓝牙版本状态  
        {
            PrintData_Send_Str("_BV1.02");
            break;
        }
        case Enum_Firmware_ID:        //打印机ID 
        {
            PrintData_Send_Str(VERSION);
                
            break;
        }
        case Enum_Productor:        //厂商 
        {
            break;
        }
        case Enum_PrinteName:        //打印机名称  
        {
            break;
        }
        case Enum_PrinteID:            //打印机序列号 
        {
            break;
        }
        case Enum_PrinteWordType:    //支持汉字地址 
        {
            break;
        }
        case Enum_BtMacAddr:        //蓝牙物理地址 
        {    
            PrintData_Send_Str("_%d:%d:%d:%d:%d:%d",BtRxTxVar.BtMacAddr[0],
                                                    BtRxTxVar.BtMacAddr[1],
                                                    BtRxTxVar.BtMacAddr[2],
                                                    BtRxTxVar.BtMacAddr[3],
                                                    BtRxTxVar.BtMacAddr[4],
                                                    BtRxTxVar.BtMacAddr[5]);
            
            break;
        }
        default:
        {
            break;
        }
    }
}

/*******************************************************************************
* 名称:        Cmd_Ack_Write_RDID_Block_Fun       
* 描述:        rfid 按块写   
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Write_RDID_Block_Fun(void)
{
    //应答信息 
//    PrintData_Send_Str("ok");
}

/*******************************************************************************
* 名称:        Cmd_Ack_Write_RDID_Fun       
* 描述:        rfid EPC标签写入 
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Write_RDID_Fun(void)
{
    //应答信息 
//    PrintData_Send_Str("ok");
}

/*******************************************************************************
* 名称:        Cmd_Ack_Gete_Tape_State_Fun       
* 描述:        读取色带使用状态  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Get_Tape_State_Fun(void)
{
    Data_Analysis_Tx.Cmd_Ack_Get_Tape_State.TapeUsedLength = Print_Data_Cache.TapeUsedLength;
    Data_Analysis_Tx.Cmd_Ack_Get_Tape_State.TapeRemainLength = Print_Data_Cache.TapeRemainLength;
    
    PrintData_Send(Data_Analysis_Tx.buf,sizeof(_CMD_ACK_GET_TAPE_STATE));
}

/*******************************************************************************
* 名称:        Cmd_Ack_Get_Battery_Power       
* 描述:        读取电池电量 
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Get_Battery_Power_Fun(void)
{
    Data_Analysis_Tx.Cmd_Ack_Get_Battery_Power.BatteryPowerInterge = adc_channel_average_value.Power_Bat_Value / 1000;
    Data_Analysis_Tx.Cmd_Ack_Get_Battery_Power.BatteryPowerDigits = adc_channel_average_value.Power_Bat_Value % 1000 / 100;
    
    PrintData_Send(Data_Analysis_Tx.buf,sizeof(_CMD_ACK_GET_BATTERY_POWER));
}

/*******************************************************************************
* 名称:        Cmd_Ack_BT_WIFI_Connect_State_Fun       
* 描述:        获取蓝牙和wifi的连接状态 
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_BT_WIFI_Connect_State_Fun(void)
{
    Data_Analysis_Tx.Cmd_Ack_BT_WIFI_Connect_State.BtState = BtRxTxVar.BtBleConnectStateFlag;
    Data_Analysis_Tx.Cmd_Ack_BT_WIFI_Connect_State.WifiSate = 0;    //未装wifi  所以表示未连接 
    
    PrintData_Send(Data_Analysis_Tx.buf,sizeof(_CMD_ACK_BT_WIFI_CONNECT_STATE));
}

/*******************************************************************************
* 名称:        Cmd_Ack_Get_Print_Valid_Width_Fun       
* 描述:        获取有效打印宽度  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Get_Print_Valid_Width_Fun(void)
{
    uint16_t  temp_length = 0;
    
    temp_length = 0;
    PrintData_Send((uint8_t *)(&temp_length),2);
}


/*******************************************************************************
* 名称:        Cmd_Ack_Get_Print_Buffer_Lines       
* 描述:        获取有效打印宽度  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Get_Print_Buffer_Lines_Fun(void)
{
    uint16_t buffer_avaliable = 0;
    
    buffer_avaliable =   FIFO_PrintLineList_Get_BufferSize();
    //MyPrintf("b_sssssssss:%d\n",buffer_avaliable);
    
    Data_Analysis_Tx.Cmd_Ack_Get_Print_Buffer_Lines.PrintBufferAvaliable = buffer_avaliable;
    
    PrintData_Send(Data_Analysis_Tx.buf,sizeof(_CMD_ACK_GET_PRINT_BUFFER_LINES));
}

/*******************************************************************************
* 名称:        Cmd_Ack_Guid_IAP_Update       
* 描述:        获取iap升级状态信息 
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Guid_IAP_Update(void)
{
    //字符串对比  看看发的对不对 
    if(strstr((char *)(&Data_Analysis_Rx.Cmd_Guid_IAP_Update.UpdateStr[0]), "40upgrade"))
    {
        if((false == Print_Data_Cache.PrintGoingAllFlag) && (false == Charge_Control_Flag.Power_Bat_Low_Flag))
        {
            PrintData_Send_Str("OK");                //允许升级 
            return;
        }
    }

    //如果正在打印 或者出错了  返回不能升级 
    PrintData_Send_Str("ERROR");        //不允许升级 
}

/*******************************************************************************
* 名称:        Cmd_Ack_Guid_IAP_Second_Request       
* 描述:        升级二次确认 
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Guid_IAP_Second_Request(void)
{
    uint8_t buf[1] = {0xAA};

    PrintData_Send(buf,1);                //二次确认  发送0xAA 
    
    //二次确认  发送如下字符串  
//    PrintData_Send_Str("===================================================================\r\n");
//    PrintData_Send_Str("=              (C) COPYRIGHT 2010 SPIRIT                          =\r\n");
//    PrintData_Send_Str("=                                                                 =\r\n");
//    PrintData_Send_Str("=     In-Application Programming Application  (Version 1.00)      =\r\n");
//    PrintData_Send_Str("=                                                                 =\r\n");
//    PrintData_Send_Str("=                             By SPIRIT R&D Team                  =\r\n");
//    PrintData_Send_Str("===================================================================\r\n");
//    PrintData_Send_Str("\r\n");
//    PrintData_Send_Str("\r\n");
//    PrintData_Send_Str("================== Main Menu ============================\r\n");
//    PrintData_Send_Str("\r\n");
//    PrintData_Send_Str("  Download Image To the STM32F10x Internal Flash ------- 1\r\n");
//    PrintData_Send_Str("\r\n");
//    PrintData_Send_Str("  Execute The New Program ------------------------------ 2\r\n");
//    PrintData_Send_Str("\r\n");
//    PrintData_Send_Str("==========================================================\r\n");
    
    Second_Update_Confirm_Flag = true;            //二次升级确认标记 置为有效 
}

/*******************************************************************************
* 名称:        Cmd_Ack_Guid_IAP_Prepare_Update       
* 描述:        准备升级  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Guid_IAP_Prepare_Update(void)
{
    if(Second_Update_Confirm_Flag)
    {
        Second_Update_Confirm_Flag = false;        //置假 
        
        Machine_State = MACHINE_UPDATE;            //处于固件升级 状态  
        Ymodem_Start_Trans();                    //发送确认帧   让模块确认发送数据
    }
}


/*******************************************************************************
* 名称:        Cmd_Ack_Get_Realtime_State_Fun       
* 描述:        获取打印机实时状态  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Get_Realtime_State_Fun(void)
{
    switch(Data_Analysis_Rx.Cmd_Get_Realtime_State.PrintMsgType)
    {
        case 1:
        {
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Transfer_Print_State.Fixed_1 = 1;        //固定1 
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Transfer_Print_State.Fixed_0 = 0;        //固定0
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Transfer_Print_State.PrintRecv = Current_Print_State.PrintRecv;        //是否收到打印数据 
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Transfer_Print_State.PrintFinish = Current_Print_State.PrintFinish;    //是否打印完成  
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Transfer_Print_State.PrintError = Current_Print_State.PrintError;    //打印机错误 
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Transfer_Print_State.PrintPause = Current_Print_State.PrintPause;    //打印机暂停 
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Transfer_Print_State.PrintCancel = Current_Print_State.PrintCancel;    //打印内容取消         
            
            //打印错误     
            PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_TRANSFER_PRINT_STATE));
            
            break;
        }
        case 2:
        {
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Transfer_Error_State = Transfer_Error_Flag;                    
            
            PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_TRANSFER_ERROR_STATE));
            
            break;
        }
        case 4:
        {
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.BatteryPower = 1;                //电池电量 
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.PaperState = 1;
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.PrinterLock = 1;
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.ChargeState = 1;
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.BtState = BtRxTxVar.BtBleConnectStateFlag;
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.UsbState = 0;
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.PaperSkip = 1;
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.PaperGap = 1;
            Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.PrintGoState = 1;
            
            PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_PRINT_STATE));
            
            break;
        }
        default:
        {
            break;
        }
    }
}

/*******************************************************************************
* 名称:        Cmd_Ack_Set_Tape_Para_Fun       
* 描述:        设置标签参数   
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Set_Tape_Para_Fun(void)
{
    //更新打印参数信息 
    API_PrintData_UpdatePar(&Data_Analysis_Rx.Cmd_Set_Tape_Para);
}

/*******************************************************************************
* 名称:        Cmd_Ack_Set_Write_Line_Print       
* 描述:        打印机一点行数据 
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Set_Write_Line_Print(void)
{
    uint8_t CurrentBytes = 0;
    uint8_t i = 0;
    static _PRINT_LINE_BUF  PrintLineBuf;
    
    CurrentBytes = Data_Analysis_Rx.Cmd_Set_Write_Line_Print.ByteSums;    //包含起始字节 
    
    if(CurrentBytes >= PRINTER_LINE_BYTES)
    {
        //当前包数据  存储至缓存内部      
        API_PrintData_In(&Data_Analysis_Rx.Cmd_Set_Write_Line_Print.PrintData[0]);
    }
    else if((CurrentBytes < PRINTER_LINE_BYTES) && (CurrentBytes > 0))
    {
        memset(&PrintLineBuf.LineBuf[0],0x00,PRINTER_LINE_BYTES);        //空行赋值  
        
        for(i = 0; i< CurrentBytes; i++)
        {
            PrintLineBuf.LineBuf[i] = Data_Analysis_Rx.Cmd_Set_Write_Line_Print.PrintData[i];
        }
        
        //当前包数据  存储至缓存内部      
        API_PrintData_In(&PrintLineBuf.LineBuf[0]);
    }    
    //MyPrintf("size:%d\n",CurrentBytes);
}

/*******************************************************************************
* 名称:        Cmd_Ack_Set_Write_Line_Compress_Print       
* 描述:        打印一点行压缩数据  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Set_Write_Line_Compress_Print(uint8_t len)
{    
    _PRINT_LINE_BUF  PrintLineBuf = {0};        //打印数据信息
    uint8_t *tempData;            //指针  用于操作
    uint8_t tempValue = 0;        //当前值  
    uint8_t tempIndex = 0;        //当前位置  
    uint8_t tempSum = 0;        //当前数量 
    uint8_t i = 0;
    uint8_t j = 0;
    
    //取得地址  
    tempData = &Data_Analysis_Rx.Cmd_Set_Write_Line_Compress_Print.PrintCompressData[0];
    PrintLineBuf = PrintLineBuf;
    
    //数据解密  (rle格式)
    for(i = 0; i<200; i++)
    {
        //判断到帧尾有0  则已经完成  
        if((0 != i) && (0x00 == tempData[i]))
        {                //加上帧头 则需要多+1 
            break;
        }
        
        if(0x80 == (tempData[i] & 0x80))            //有压缩数据  
        {
            tempSum = (tempData[i] & 0x7F);            //得到有效数据 - 重复次数 
            tempValue = (tempData[i + 1]);            //重复的数据 - 有效数据 
            
            if(tempSum <= PRINTER_LINE_BYTES)                        //判断该行字长是否超过了最大要求 
            {
                for(j = 0; j < tempSum; j++)
                {
                    if(tempIndex < PRINTER_LINE_BYTES)                //防止数据越界  进入错误中断  
                    {
                        PrintLineBuf.LineBuf[tempIndex] = tempValue;
                        tempIndex++;                //索引偏移 
                    }
                    else
                    {
                        break;
                    }
                }
                
                i++;                                //由于有2字节  则跳过第2个字节  下一次进直接读第3个字节  
            }
        }
        else if(0x00 == (tempData[i] & 0x80))        //无压缩数据  
        {
            tempSum = (tempData[i] & 0x7F);            //得到当前的数据长度  
            
            if(tempSum <= PRINTER_LINE_BYTES)                        //数据长度不能超过  否则无效 
            {
                for(j = 0; j < tempSum; j++)
                {
                    if(tempIndex < PRINTER_LINE_BYTES)                //防止数据越界  进入错误中断  
                    {
                        PrintLineBuf.LineBuf[tempIndex] = tempData[i + j + 1];
                        tempIndex++;
                    }
                    else 
                    {
                        break;
                    }
                }
                
                i = i + tempSum;                    //数据偏移  包含数据  共x单位 每次进来i++ 则需要长度-1  
            }
        }
    }
    
    //当前包数据  存储至缓存内部(当前包长)
    API_PrintData_In(&PrintLineBuf.LineBuf[0]);
}


/*******************************************************************************
* 名称:        Cmd_Ack_Set_ESC_Command       
* 描述:        ESC命令  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Set_ESC_Command(void)
{
    //Data_Analysis_Rx.Cmd_Set_Write_Line_Compress_Print.PrintCompressData;
    
    //应答信息 
    //PrintData_Send_Str("ok");
}

/*******************************************************************************
* 名称:        Cmd_Ack_Go_With_Paper_Fun         0x1b指令
* 描述:        空走纸命令  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Go_With_Paper_Fun(void)
{
    PrintMotor_Positive_Start();            //启动打印电机 
}


/*******************************************************************************
* 名称:        Cmd_Ack_Set_Blank_N_Print       
* 描述:        走纸N点行  
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Set_Blank_N_Print(void)
{    
    uint8_t BlankCnt = 0;
    static _PRINT_LINE_BUF  PrintLineBuf;
    
    BlankCnt = Data_Analysis_Rx.Cmd_Set_Blank_N_Print.PrintBlankN;    //获取协议的空行的数量 
    memset(&PrintLineBuf.LineBuf[0],0x00,PRINTER_LINE_BYTES);        //空行赋值  
    
    if(BlankCnt > 0)
    {
        for(int i =0; i<BlankCnt; i++){
            API_PrintData_In(&PrintLineBuf.LineBuf[0]);
        }
    }
}

/*******************************************************************************
* 名称:        Cmd_Ack_Set_Goto_Gap_Locate       
* 描述:        打印并走到缝隙黑标   
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Set_Goto_Gap_Locate(void)
{
    //走到间隙 0x0C
    PaperGap_GotoGap();                //执行走位置信息 
}


/*******************************************************************************
* 名称:        Cmd_Send_Print_State_Fun       
* 描述:        打印机状态主动上报 
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Send_Print_State_Fun(void)
{
    Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.BatteryPower = 1;                //电池电量 
    Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.PaperState = 1;
    Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.PrinterLock = 1;
    Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.ChargeState = 1;
    Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.BtState = BtRxTxVar.BtBleConnectStateFlag;
    Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.UsbState = 0;
    Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.PaperSkip = 1;
    Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.PaperGap = 1;
    Data_Analysis_Tx.Cmd_Ack_Get_Realtime_State.Print_State.PrintGoState = 1;
    
    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_PRINT_STATE));
}

/*******************************************************************************
* 名称:        Cmd_Ack_Set_After_Print_Flag       
* 描述:        设置打印完成后  是否进行剪切   
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_Set_After_Print_Flag_Fun(void)
{
    Print_Data_Cache.PrintAfterCutFlag = Data_Analysis_Rx.Cmd_Set_After_Print_Flag.PrinteCutEnable;        //打印剪切的标记信息 
}      

//------------------------------测试信息---------------------------------------

/*******************************************************************************
* 名称:        Cmd_Ack_TestMode_Analysis       
* 描述:        协议解析 
* 输入参数:    无  
* 输出参数:    无   
* 其它:        无   
*******************************************************************************/
void Cmd_Ack_TestMode_Analysis(void)
{
    bool StoreState = false;
    bool RetFlag = false;            //返回信息 
    uint32_t TempUint32 = 0;        //临时变量 
    
    switch(Data_Analysis_Rx.buf[3])
    {
        case 0x11:            //读取电压参数信息 
        {                
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Voltage.FrameHead = 0x54;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Voltage.Length = sizeof(_CMD_TESTMODE_GET_VOLTAGE);
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Voltage.Test_MainCmd = 0x11;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Voltage.Test_SubCmd = 0x01;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Voltage.Test_BatVoltage = adc_channel_average_value.Power_Bat_Value;
                    
            PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_GET_VOLTAGE));    
            break;
        }
        case 0x12:            //读取当前状态信息 
        {
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Print_State.FrameHead = 0x54;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Print_State.Length = sizeof(_CMD_ACK_TESTMODE_GET_PRINT_STATE);
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Print_State.Test_MainCmd = 0x12;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Print_State.Test_SubCmd = 0x01;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Print_State.Error_Flag = Transfer_Error_Flag;    //出错信息 
                    
            PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_GET_PRINT_STATE));    
            
            //发送完  切刀和间隙问题故障后  该故障清0 
            Print_Gap_CheckInfo.PaperGap_ErrorFlag_Clear_Flag = true;        //清空间隙相关的错误标记信息 
            
            break;
        }
        case 0x13:            //读取当前色带的ADC值 
        {
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Tape_ADC.FrameHead = 0x54;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Tape_ADC.Length = sizeof(_CMD_ACK_TESTMODE_GET_TAPE_ADC);
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Tape_ADC.Test_MainCmd = 0x13;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Tape_ADC.Test_SubCmd = 0x01;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Tape_ADC.Tape_ADC_Value = PaperStateInfo.ADCValue;    //出错信息 
                    
            PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_GET_TAPE_ADC));    
            
            break;
        }
        case 0x14:            //获取版本号信息 
        {
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Version.FrameHead = 0x54;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Version.Length = sizeof(_CMD_ACK_TESTMODE_GET_VERSION);
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Version.Test_MainCmd = 0x14;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Version.Test_SubCmd = 0x01;
            memcpy( Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Version.Machine_Version,
                    VERSION,
                    sizeof(VERSION));
                    
            PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_GET_VERSION));
            
            break;
        }
        case 0x15:            //恢复出厂设置  
        {
            Data_Analysis_Tx.Cmd_Ack_TestMode_Factory_Setting.FrameHead = 0x54;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Factory_Setting.Length = sizeof(_CMD_ACK_TESTMODE_FACTORY_SETTING);
            Data_Analysis_Tx.Cmd_Ack_TestMode_Factory_Setting.Test_MainCmd = 0x15;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Factory_Setting.Test_SubCmd = 0x01;
            
            //恢复出厂设置 
            StoreState = Para_Store_Factory_Setting();
            Data_Analysis_Tx.Cmd_Ack_TestMode_Factory_Setting.Setting_Result = StoreState;
                    
            PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_FACTORY_SETTING));
            
            //等待数据发完 
            delay_ms(300);
            //复位 
            soft_reset();
            
            break;
        }
        case 0x17:            //获取定标ADC值 
        {
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Calibration_Value.FrameHead = 0x54;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Calibration_Value.Length = sizeof(_CMD_ACK_TESTMODE_GET_CALIBRATION_VALUE);
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Calibration_Value.Test_MainCmd = 0x17;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Calibration_Value.Test_SubCmd = 0x01;
//            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Calibration_Value.Threshold_Empty = Store_Para.Print_Calibration_Para.Threshold_Empty;
//            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Calibration_Value.Threshold_Paper_Gap.Threshold_Paper = 
//                                                Store_Para.Print_Calibration_Para.Threshold_Paper_Gap.Threshold_Paper;
//            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Calibration_Value.Threshold_Paper_Gap.Threshold_Gap = 
//                                                Store_Para.Print_Calibration_Para.Threshold_Paper_Gap.Threshold_Gap;
//                        
            PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_GET_CALIBRATION_VALUE));

            break;
        }
        case 0x21:            //配置蓝牙模块信息 
        {
            switch(Data_Analysis_Rx.buf[4])
            {
                case 0x00:    //设置蓝牙名
                {
                    //数据解析出来  
                    memcpy( Store_Para.BT_Name_Para.Bt_Name,
                            Data_Analysis_Rx.Cmd_TestMode_Set_Bt_Name_Serial.Bt_Name,
                            31);
                    
                    //写蓝牙名信息 
                    StoreState = Para_Store_BtName_Para_Write();
                    
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Set_Bt_Name_Serial.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Set_Bt_Name_Serial.Length = sizeof(_CMD_ACK_TESTMODE_SET_BT_NAME_SERIAL);
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Set_Bt_Name_Serial.Test_MainCmd = 0x21;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Set_Bt_Name_Serial.Test_SubCmd = 0x01;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Set_Bt_Name_Serial.Set_OK_Fail = StoreState;    

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_SET_BT_NAME_SERIAL));                    
                    
                    break;
                }
                case 0x02:    //读取蓝牙名 
                {
                    Data_Analysis_Tx.Cmd_TestMode_Set_Bt_Name_Serial.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_TestMode_Set_Bt_Name_Serial.Length = sizeof(_CMD_TESTMODE_SET_BT_NAME_SERIAL);
                    Data_Analysis_Tx.Cmd_TestMode_Set_Bt_Name_Serial.Test_MainCmd = 0x21;
                    Data_Analysis_Tx.Cmd_TestMode_Set_Bt_Name_Serial.Test_SubCmd = 0x03;
                    
                    memcpy( 
                            Data_Analysis_Tx.Cmd_TestMode_Set_Bt_Name_Serial.Bt_Name,
                            Store_Para.BT_Name_Para.Bt_Name,
                            31);

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_TESTMODE_SET_BT_NAME_SERIAL));
                    
                    break;
                }
            }    
            break;
        }
        case 0x22:        //设置/读取蓝牙密码     
        {
            switch(Data_Analysis_Rx.buf[4])
            {
                case 0x00:    //设置蓝牙密码 
                {
                    //数据解析出来  
                    memcpy( Store_Para.BT_Passwd_Para.Bt_PIN,
                            Data_Analysis_Rx.Cmd_TestMode_Set_Bt_Passwd.Bt_PassWd,
                            16);
                    
                    //写蓝牙名信息 
                    StoreState = Para_Store_BtPass_Para_Write();
                    
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Set_Bt_Passwd.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Set_Bt_Passwd.Length = sizeof(_CMD_ACK_TESTMODE_SET_BT_PASSWD);
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Set_Bt_Passwd.Test_MainCmd = 0x22;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Set_Bt_Passwd.Test_SubCmd = 0x01;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Set_Bt_Passwd.Set_OK_Fail = StoreState;    

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_SET_BT_PASSWD));                        
                    
                    break;
                }
                case 0x02:    //读取蓝牙密码 
                {
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Bt_Passwd.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Bt_Passwd.Length = sizeof(_CMD_TESTMODE_SET_BT_PASSWD);
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Bt_Passwd.Test_MainCmd = 0x22;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Bt_Passwd.Test_SubCmd = 0x03;
                    
                    memcpy( 
                            Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Bt_Passwd.Bt_PassWd,
                            Store_Para.BT_Passwd_Para.Bt_PIN,
                            16);

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_TESTMODE_SET_BT_PASSWD));
                    
                    break;
                }
            }    
            
            break;
        }
        case 0x23:        //设置/读取加热时间 
        {
            switch(Data_Analysis_Rx.buf[4])
            {
                case 0x00:    //设置加热时间 
                {
                    //数据显示  
                    Store_Para.Print_Heattime_Para.BasicHeatTime = Data_Analysis_Rx.Cmd_TestMode_Set_Heattime.Test_HeatTime;
                    
                    //存到flash
                    StoreState = Para_Store_HeatTime_Para_Write();
                    
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Set_Heattime.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Set_Heattime.Length = sizeof(_CMD_ACK_TESTMODE_SET_HEATTIME);
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Set_Heattime.Test_MainCmd = 0x23;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Set_Heattime.Test_SubCmd = 0x01;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Set_Heattime.Set_OK_Fail = StoreState;    

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_SET_HEATTIME));                        
                    
                    break;
                }
                case 0x02:    //读取加热时间 
                {
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Heattime.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Heattime.Length = sizeof(_CMD_TESTMODE_SET_HEATTIME);
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Heattime.Test_MainCmd = 0x23;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Heattime.Test_SubCmd = 0x03;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Heattime.Test_HeatTime = Store_Para.Print_Heattime_Para.BasicHeatTime;

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_TESTMODE_SET_HEATTIME));
                    
                    break;
                }
                default:
                {
                    break;
                }
            }    
            
            break;
        }
        case 0x25:        //接管/停止接管充电 
        {
            switch(Data_Analysis_Rx.buf[5])
            {
                case 0x01:    //设置接管充电   
                {        
                    Data_Analysis_Tx.Cmd_Ack_TestMode_TakeOver_Control_Charge_Test.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_TakeOver_Control_Charge_Test.Length = 
                                                    sizeof(_CMD_ACK_TESTMODE_TAKEOVER_CONTROL_CHARGE_TEST);
                    Data_Analysis_Tx.Cmd_Ack_TestMode_TakeOver_Control_Charge_Test.Test_MainCmd = 0x25;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_TakeOver_Control_Charge_Test.Test_SubCmd = 0x01;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_TakeOver_Control_Charge_Test.Test_Flag = 1;

                    //启动充电  
                    Charge_Control_Flag.ChargeTakeOver_Flag = true;        //接管充电 并且停止充电 
                    API_Bat_Charge_OnOff(false);                        //停止充电 

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_TAKEOVER_CONTROL_CHARGE_TEST));                        
                    
                    break;
                }
                case 0x00:    //设置停止接管充电 
                {
                    Data_Analysis_Tx.Cmd_Ack_TestMode_TakeOver_Control_Charge_Test.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_TakeOver_Control_Charge_Test.Length = sizeof(_CMD_ACK_TESTMODE_TAKEOVER_CONTROL_CHARGE_TEST);
                    Data_Analysis_Tx.Cmd_Ack_TestMode_TakeOver_Control_Charge_Test.Test_MainCmd = 0x24;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_TakeOver_Control_Charge_Test.Test_SubCmd = 0x03;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_TakeOver_Control_Charge_Test.Test_Flag = 0;
                    
                    //停止充电                 
                    Charge_Control_Flag.ChargeTakeOver_Flag = false;        //接管充电 

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_TAKEOVER_CONTROL_CHARGE_TEST));
                    
                    break;
                }
                default:
                {
                    break;
                }
            }     
            break;
        }
        case 0x34:        //全黑打印测试  
        {    
            //调用测试接口 
            RetFlag = TestMode_Print_Start_Fun(    TESTMODE_PRINT_ALLBLACK,
                                                    Data_Analysis_Rx.Cmd_TestMode_Print_AllBlack_Test.Control_Cmd_Type,
                                                    Data_Analysis_Rx.Cmd_TestMode_Print_AllBlack_Test.Print_Length,
                                                    Data_Analysis_Rx.Cmd_TestMode_Print_AllBlack_Test.Print_Copys,
                                                    (PrintPaperTypeEnum)(Data_Analysis_Rx.Cmd_TestMode_Print_AllBlack_Test.PrintPaper));
            
            //回发应答协议 
            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_AllBlack_Test.FrameHead = 0x54;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_AllBlack_Test.Length = sizeof(_CMD_ACK_TESTMODE_PRINT_ALLBLACK_TEST);
              Data_Analysis_Tx.Cmd_Ack_TestMode_Print_AllBlack_Test.Test_MainCmd = 0x34;
            if(0x00 == Data_Analysis_Rx.Cmd_TestMode_Print_AllBlack_Test.Test_SubCmd)
            {
                Data_Analysis_Tx.Cmd_Ack_TestMode_Print_AllBlack_Test.Test_SubCmd = 0x01;
            }
            else if(0x02 == Data_Analysis_Rx.Cmd_TestMode_Print_AllBlack_Test.Test_SubCmd)
            {
                Data_Analysis_Tx.Cmd_Ack_TestMode_Print_AllBlack_Test.Test_SubCmd = 0x03;
            }
            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_AllBlack_Test.PrintFinish = RetFlag;            //打印完成 or 未打印完成  
            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_AllBlack_Test.PrintOptocouplerADC = 
                                PaperStateInfo.ADCValue;                                        //色带ADC值  
            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_AllBlack_Test.Error_Flag = Transfer_Error_Flag;    //出错信息 

            PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_PRINT_ALLBLACK_TEST));    

            //发送完  切刀和间隙问题故障后  该故障清0 
            Print_Gap_CheckInfo.PaperGap_ErrorFlag_Clear_Flag = true;        //清空间隙相关的错误标记信息 
            
            break;
        }
        case 0x35:        //间隙打印测试  
        {
            //调用测试接口 
            RetFlag = TestMode_Print_Start_Fun(    TESTMODE_PRINT_GAP,
                                                    Data_Analysis_Rx.Cmd_TestMode_Print_Gap_Test.Control_Cmd_Type,
                                                    Data_Analysis_Rx.Cmd_TestMode_Print_Gap_Test.Print_Length,
                                                    Data_Analysis_Rx.Cmd_TestMode_Print_Gap_Test.Print_Copys,
                                                    (PrintPaperTypeEnum)(Data_Analysis_Rx.Cmd_TestMode_Print_AllBlack_Test.PrintPaper));
            
            //回发应答协议 
            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_Gap_Test.FrameHead = 0x54;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_Gap_Test.Length = sizeof(_CMD_ACK_TESTMODE_PRINT_GAP_TEST);
            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_Gap_Test.Test_MainCmd = 0x35;
            if(0x00 == Data_Analysis_Rx.Cmd_Ack_TestMode_Print_Gap_Test.Test_SubCmd)
            {
                Data_Analysis_Tx.Cmd_Ack_TestMode_Print_Gap_Test.Test_SubCmd = 0x01;
            }
            else if(0x02 == Data_Analysis_Rx.Cmd_Ack_TestMode_Print_Gap_Test.Test_SubCmd)
            {
                Data_Analysis_Tx.Cmd_Ack_TestMode_Print_Gap_Test.Test_SubCmd = 0x03;
            }
            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_Gap_Test.PrintFinish = RetFlag;            //打印完成 or 未打印完成   
//            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_Gap_Test.PrintOptocouplerADC = 
//                                Tape_ADC_Value.Tape_Adc_Value;                    //色带ADC值  
            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_Gap_Test.Error_Flag = Transfer_Error_Flag;    //出错信息 

            PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_PRINT_GAP_TEST));    
            
            Print_Gap_CheckInfo.PaperGap_ErrorFlag_Clear_Flag = true;        //清空间隙相关的错误标记信息         
            
            break;
        }
        case 0x32:        //常规打印测试  
        {
            //调用测试接口 
            RetFlag = TestMode_Print_Start_Fun(    TESTMODE_PRINT_NORMAL,
                                                    Data_Analysis_Rx.Cmd_TestMode_Print_Test.Control_Cmd_Type,
                                                    Data_Analysis_Rx.Cmd_TestMode_Print_Test.Print_Length,
                                                    Data_Analysis_Rx.Cmd_TestMode_Print_Test.Print_Copys,
                                                    (PrintPaperTypeEnum)(Data_Analysis_Rx.Cmd_TestMode_Print_AllBlack_Test.PrintPaper));
            
            //回发应答协议 
            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_Test.FrameHead = 0x54;
            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_Test.Length = sizeof(_CMD_ACK_TESTMODE_PRINT_GAP_TEST);
            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_Test.Test_MainCmd = 0x32;
            if(0x00 == Data_Analysis_Rx.Cmd_Ack_TestMode_Print_Test.Test_SubCmd)
            {
                Data_Analysis_Tx.Cmd_Ack_TestMode_Print_Test.Test_SubCmd = 0x01;
            }
            else if(0x02 == Data_Analysis_Rx.Cmd_Ack_TestMode_Print_Test.Test_SubCmd)
            {
                Data_Analysis_Tx.Cmd_Ack_TestMode_Print_Test.Test_SubCmd = 0x03;
            }
            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_Test.PrintFinish = RetFlag;            //打印完成 or 未打印完成  
            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_Test.PrintOptocouplerADC = 
                                PaperStateInfo.ADCValue;                    //色带ADC值 
            Data_Analysis_Tx.Cmd_Ack_TestMode_Print_Test.Error_Flag = Transfer_Error_Flag;    //出错信息 

            PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_PRINT_TEST));        

            Print_Gap_CheckInfo.PaperGap_ErrorFlag_Clear_Flag = true;        //清空间隙相关的错误标记信息 
            
            break;
        }
        case 0x38:        //电机寿命测试  
        {
            switch(Data_Analysis_Rx.buf[4])
            {
                case 0x00:    //启动电机测试 
                {    
                    TestMode_PrintMotor_Life_Fun(true);
                    
                    Data_Analysis_Tx.Cmd_Ack_TestMode_PrintMotor_Life_Test.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_PrintMotor_Life_Test.Length = sizeof(_CMD_ACK_TESTMODE_PRINTMOTER_LIFE_TEST);
                    Data_Analysis_Tx.Cmd_Ack_TestMode_PrintMotor_Life_Test.Test_MainCmd = 0x38;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_PrintMotor_Life_Test.Test_SubCmd = 0x01;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_PrintMotor_Life_Test.PrintMotor_TestFlag = State_Check_Para.State_MotorCheck.PrintMotor_ErrFlag;    //电机堵转             Data_Analysis_Tx.Cmd_Ack_TestMode_PrintMotor_Life_Test.PrintMotor_State = State_Check_Para.State_MotorCheck.PrintMotor_ErrFlag;    //电机是否堵转或者出错 

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_PRINTMOTER_LIFE_TEST));                        
                    
                    break;
                }
                case 0x02:    //停止电机测试 
                {
                    TestMode_PrintMotor_Life_Fun(false);
                    
                    Data_Analysis_Tx.Cmd_Ack_TestMode_PrintMotor_Life_Test.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_PrintMotor_Life_Test.Length = sizeof(_CMD_ACK_TESTMODE_PRINTMOTER_LIFE_TEST);
                    Data_Analysis_Tx.Cmd_Ack_TestMode_PrintMotor_Life_Test.Test_MainCmd = 0x38;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_PrintMotor_Life_Test.Test_SubCmd = 0x03;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_PrintMotor_Life_Test.PrintMotor_TestFlag = State_Check_Para.State_MotorCheck.PrintMotor_ErrFlag;    //电机堵转             Data_Analysis_Tx.Cmd_Ack_TestMode_PrintMotor_Life_Test.PrintMotor_State = State_Check_Para.State_MotorCheck.PrintMotor_ErrFlag;    //电机是否堵转或者出错 

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_PRINTMOTER_LIFE_TEST));    
                    
                    break;
                }
            }    
            
            break;
        }
        case 0x40:        //定标功能测试  
        {
            switch(Data_Analysis_Rx.Cmd_TestMode_Gap_Calibration.Control_Cmd_Type)
            {
                case 0x01:    //启动定标功能 
                {    
                    TestMode_PaperGap_Calibration();
                    
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Gap_Calibration.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Gap_Calibration.Length = sizeof(_CMD_ACK_TESTMODE_GAP_CALIBRATION);
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Gap_Calibration.Test_MainCmd = 0x40;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Gap_Calibration.Test_SubCmd = 0x01;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Gap_Calibration.CalibrationFinish = 0;    //未完成  
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Gap_Calibration.Calibration_Result = 0x00;//定标正常 

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_GAP_CALIBRATION));                        
                    
                    break;
                }
                case 0x02:    //定标状态查询 
                {        
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Gap_Calibration.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Gap_Calibration.Length = sizeof(_CMD_ACK_TESTMODE_GAP_CALIBRATION);
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Gap_Calibration.Test_MainCmd = 0x40;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Gap_Calibration.Test_SubCmd = 0x01;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Gap_Calibration.CalibrationFinish = 
                                                TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_Finish;    //未完成  
                    if(TestMode_GapPrint_Calibration_Test.TestMode_PaperGap_Calibration_ErrorFlag)
                    {
                        Data_Analysis_Tx.Cmd_Ack_TestMode_Gap_Calibration.Calibration_Result = 0x01;//定标不正常 
                    }
                    else 
                    {
                        Data_Analysis_Tx.Cmd_Ack_TestMode_Gap_Calibration.Calibration_Result = 0x00;//定标正常 
                    }

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_GAP_CALIBRATION));    
                    
                    break;
                }
            }    
            break;
        }
        case 0x16:        //获取光耦ADC 
        {
            switch(Data_Analysis_Rx.buf[4])
            {
                case 0x00:    //获取ADC值 
                {    
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Tape_Optocoupler.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Tape_Optocoupler.Length = sizeof(_CMD_ACK_TESTMODE_GET_TAPE_OPTOCOUPLER);
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Tape_Optocoupler.Test_MainCmd = 0x16;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Tape_Optocoupler.Test_SubCmd = 0x01;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Get_Tape_Optocoupler.Optocoupler_ADC = PaperStateInfo.ADCValue;    //色带ADC值 

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_GET_TAPE_OPTOCOUPLER));                        
                    
                    break;
                }
            }    
            break;
        }
        case 0x41:        //切刀测试 
        {
            switch(Data_Analysis_Rx.buf[4])
            {
                case 0x00:        //启动切刀测试 
                {
                    //调用测试接口 
                    RetFlag = TestMode_Cutter_Times_Fun(    TESTMODE_CUTTER_START,
                                                            TESTMODE_CUTTER_TEST_ONE_MM,
                                                            &TempUint32
                                                        );
                    
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Length = sizeof(_CMD_ACK_TESTMODE_CUTTER_LIFE_TEST);
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Test_MainCmd = 0x41;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Test_SubCmd = 0x01;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Cutter_Times = TempUint32;    //已切次数  
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Error_Flag = Transfer_Error_Flag;    //报警信息 

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_CUTTER_LIFE_TEST));
                    
                    Print_Gap_CheckInfo.PaperGap_ErrorFlag_Clear_Flag = true;        //清空间隙相关的错误标记信息 
                    
                    break;
                }
                case 0x02:        //停止切刀测试 
                {
                    //调用测试接口 
                    RetFlag = TestMode_Cutter_Times_Fun(    TESTMODE_CUTTER_STOP,
                                                            TESTMODE_CUTTER_TEST_ONE_MM,
                                                            &TempUint32
                                                        );
                    
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Length = sizeof(_CMD_ACK_TESTMODE_CUTTER_LIFE_TEST);
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Test_MainCmd = 0x41;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Test_SubCmd = 0x03;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Cutter_Times = TempUint32;    //已切次数  
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Error_Flag = Transfer_Error_Flag;    //报警信息 

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_CUTTER_LIFE_TEST));
                    
                    Print_Gap_CheckInfo.PaperGap_ErrorFlag_Clear_Flag = true;        //清空间隙相关的错误标记信息 
                    
                    break;
                }
                case 0x04:        //清零测试 
                {
                    //调用测试接口 
                    RetFlag = TestMode_Cutter_Times_Fun(    TESTMODE_CUTTER_TOZERO,
                                                            TESTMODE_CUTTER_TEST_ONE_MM,
                                                            &TempUint32
                                                        );
                    
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Length = sizeof(_CMD_ACK_TESTMODE_CUTTER_LIFE_TEST);
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Test_MainCmd = 0x41;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Test_SubCmd = 0x05;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Cutter_Times = TempUint32;    //已切次数  
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Error_Flag = Transfer_Error_Flag;    //报警信息 

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_CUTTER_LIFE_TEST));
                    
                    Print_Gap_CheckInfo.PaperGap_ErrorFlag_Clear_Flag = true;        //清空间隙相关的错误标记信息 
                    
                    break;
                }
                case 0x06:        //获取切刀次数
                {
                    //调用测试接口 
                    RetFlag = TestMode_Cutter_Times_Fun(    TESTMODE_CUTTER_GET,
                                                            TESTMODE_CUTTER_TEST_ONE_MM,
                                                            &TempUint32
                                                        );
                    
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.FrameHead = 0x54;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Length = sizeof(_CMD_ACK_TESTMODE_CUTTER_LIFE_TEST);
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Test_MainCmd = 0x41;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Test_SubCmd = 0x07;
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Cutter_Times = TempUint32;    //已切次数  
                    Data_Analysis_Tx.Cmd_Ack_TestMode_Cutter_Life_Test.Error_Flag = Transfer_Error_Flag;    //报警信息 

                    PrintData_Send(&Data_Analysis_Tx.buf[0],sizeof(_CMD_ACK_TESTMODE_CUTTER_LIFE_TEST));
                    
                    Print_Gap_CheckInfo.PaperGap_ErrorFlag_Clear_Flag = true;        //清空间隙相关的错误标记信息 
                    
                    break;
                }
                default:
                {
                    break;
                }
            }                        
            
            break;
        }
        default:
        {
            break;
        }    
    }
}

以下为.h文件:

/******************************************************************************
版权所有:  深圳**科技有限公司  
文件名:    api_bt_analysis.h   
作者:      wangdy  
创建日期:  2020/7/8
描述:      蓝牙数据解析  
其它:      
修改历史:  //修改历史记录列表,每条修改记录应包含修改日期、修改者及修改内容简述
            序号    修改时间    修改人  修改内容
            ????    ????/??/??  ??????  参考样式       
******************************************************************************/

/*********************************防止多次编译*********************************/
#ifndef _API_DATA_ANALYSIS_H
#define _API_DATA_ANALYSIS_H

/************************************头文件************************************/
#include <stdint.h>
#include <stdbool.h>
#include "var_global.h"
#include "tools_fifo.h"

/************************************宏定义************************************/

#define  SEND_RECV_SIZE                300
#define  RECV_BUF_ALL                300            //接收,未拆包字节 

#define  COMBINE_BUF_SIZE            100                        //组包最长字节  

/************************************枚举**************************************/


/************************************结构体************************************/

#pragma pack(push)
#pragma pack(1)

//应答数据信息 
typedef struct 
{
    uint8_t  cmd;                 //命令字   1Byte
    uint16_t length;              //长度    2byte
    uint8_t     dataInfo[300];        //1k ram 
}PrintNormalDataTypeDef;

//------打印机状态查询指令  
typedef struct
{
    uint8_t      FrameHead[2];            //帧头 0x10   06 
    uint8_t      PrintMsgType;            //打印状态  
}_CMD_SEND_GET_REALTIME_STATE; 

//------打印机状态查询指令 - 应答  

//传输打印状态  
typedef struct
{
    uint8_t Fixed_1 : 1;            //固定为1
    uint8_t Fixed_0 : 1;            //固定为0
    uint8_t PrintRecv : 1;            //是否收到打印数据状态 
    uint8_t PrintFinish : 1;        //打印机内容是否打印完成  
    uint8_t PrintError : 1;            //打印机是否有错误  
    uint8_t PrintPause : 1;            //打印机是否暂停 
    uint8_t PrintCancel : 1;        //打印内容被取消 
    uint8_t NC3 : 1;                //预留 
}_TRANSFER_PRINT_STATE;

//传输错误状态  
typedef struct
{
    uint16_t Fixed_1 : 1;            //固定为1
    uint16_t PaperGap_NoCheckGapState : 1;    //间隙检测失败 
    uint16_t NoPapper : 1;            //打印机缺纸状态  
    uint16_t UpCoverState : 1;        //上盖状态  
    uint16_t MovementState: 1;        //机芯状态  
    uint16_t PrintHeadOverHeat : 1;    //打印头信息 
    uint16_t TTRrecognize : 1;        //插入碳带是否识别  
    uint16_t TTRspent : 1;            //插入碳带是否用完
    uint16_t RFIDWriteError: 1;        //RFID写入错误 
    uint16_t CutterState: 1;        //剪切状态  
    uint16_t CurrentPrintState: 1;    //打印状态  
    uint16_t BatLowPowerState: 1;    //电池电量状态 
    uint16_t NC: 4;                    //空字节  
}_TRANSFER_ERROR_STATE;

//打印机状态 
typedef struct
{
    uint32_t BatteryPower : 8;        //电池电量  
    uint32_t PaperState : 1;        //0-无纸  1-有纸 
    uint32_t PrinterLock : 1;        //0-打印头未锁紧  1-锁紧 
    uint32_t ChargeState: 1;        //充电状态  
    uint32_t BtState: 1;            //蓝牙是否连接  
    uint32_t UsbState: 1;            //USB是否连接  
    uint32_t PaperSkip: 1;            //是否在走纸 
    uint32_t PaperGap: 1;            //纸缝是否OK 
    uint32_t PrintGoState : 1;        //是否正在打印 
    uint32_t NC: 16;                //预留 
}_PRINT_STATE;


//打印机应答  
typedef union
{
    _TRANSFER_PRINT_STATE   Transfer_Print_State;
    _TRANSFER_ERROR_STATE    Transfer_Error_State;
    _PRINT_STATE            Print_State;
}_CMD_ACK_GET_REALTIME_STATE;

//------实时传输状态 - 上传
typedef struct
{
    uint8_t              FrameHead[2];            //帧头 0x10   
    uint8_t              PrintMsgType;            //打印状态 
    _PRINT_STATE    PrintState;                //打印状态  
}_CMD_SEND_PRINT_STATE;


//设置打印浓度 
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x4B 
    uint16_t    Length;                        //有效字节的长度  
    uint8_t     Cmd;                        //默认0x30 48 
    uint8_t     mByte;                        //默认0x30 48
    uint8_t     PrintDensity;                //打印浓度 
}_CMD_SET_PRINT_DENSITY;

//设置打印速度 
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x4B 
    uint16_t    Length;                        //有效字节的长度  
    uint8_t     Cmd;                        //默认0x31 49 
    uint8_t     mByte;                        //默认0x30 48
    uint8_t     PrintSpeed;                    //打印速度  
}_CMD_SET_PRINT_SPEED;

//设置纸张类型  
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x4B 
    uint16_t    Length;                        //有效字节的长度  
    uint8_t     Cmd;                        //默认0x33  51
    uint8_t     mByte;                        //默认0x30  48 
    uint8_t     PrintPaperType;                //n=0:连续纸 n=1:黑标纸 n=2:间隙纸  
}_CMD_SET_PAPER_TYPE;

//设置打印模式   
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x4B 
    uint16_t    Length;                        //有效字节的长度  
    uint8_t     Cmd;                        //默认0x34  52
    uint8_t     mByte;                        //默认0x30  48 
    uint8_t     PrintMode;                    //n=0:退出驱动模式   n=1:进入驱动模式 
}_CMD_SET_PRINT_MODE;

//设置标签尺寸 
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x4B 
    uint16_t    Length;                        //有效字节的长度  
    uint8_t     Cmd;                        //默认0x35  53
    uint8_t     mByte;                        //默认0x30  48 
    uint16_t     TabWidthMM;                    //xl    xh为标签横向的宽度,单位毫米 
    uint16_t    TabHightPix;                //yl    yh为标签纵向的高度,单位点(像素)
}_CMD_SET_TAB_SIZE;

//设置余白距离 
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x4B
    uint16_t    Length;                        //有效字节的长度  
    uint8_t     Cmd;                        //默认0x39  57
    uint8_t     mByte;                        //默认0x30  48 
    uint16_t     Blank_Length;                //余白距离 
}_CMD_SET_BLANK_LENGTH;

//设置剪切模式   
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x4B
    uint16_t    Length;                        //有效字节的长度  
    uint8_t     Cmd;                        //默认0x3A  58
    uint8_t     mByte;                        //默认0x30  48 
    uint8_t     Cut_State;                    //剪切状态  
}_CMD_SET_CUT_MODE;

//设置NFC校验码 
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x4C 
    uint16_t    Length;                        //有效字节的长度  
    uint8_t     Cmd;                        //默认0x32  50
    uint8_t     mByte;                        //默认0x30  48 
    uint8_t     NFCPassWd[6];                //NFC密码 
}_CMD_SET_NFC_PASSWD;

//设置碳带长度 
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x4C
    uint16_t    Length;                        //有效字节的长度  
    uint8_t     Cmd;                        //默认0x33  51
    uint8_t     mByte;                        //默认0x30  48 
    uint8_t     TTRLength[4];                //碳带长度  
}_CMD_SET_TTR_LENGTH;

//设置空走纸 
typedef struct
{
    uint8_t      FrameHead;                    //0x1B
    uint8_t     Cmd_Type;                    //0x64
    uint8_t        PaperPixLength;                //走纸的像素长度 
}_CMD_GO_WITH_PAPER;

//下载位图 

//查询打印机ID号 
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 56
    uint8_t     PrintIDInfo;                //要读的打印机的信息 
}_CMD_GET_PRINT_ID_INFO;

//设置打印完的走约剪切协议  
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 56
    uint8_t     PrinteCutEnable;            //打印后,是否要进行剪切处理 
}_CMD_SET_AFTER_PRINT_FLAG;

//查询打印机ID号 - 应答  
typedef struct
{
    uint8_t      FrameHead;                    //0x5F
    uint8_t     AckInfo[20];                //应答回的字符  
}_CMD_ACK_GET_PRINT_ID_INFO;

//查询色带状态  
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x48
    uint16_t    Length;                        //有效字节的长度  
    uint8_t     Cmd;                        //默认0x33  51
    uint8_t     mByte;                        //默认0x30  48 
}_CMD_GET_TAPE_STATE;

//查询色带状态  - 应答 
typedef struct
{
    uint16_t     TapeUsedLength;                //已使用色带长度  
    uint16_t    TapeRemainLength;            //剩余色带长度  
}_CMD_ACK_GET_TAPE_STATE;

//查询电池电量状态  
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x48
    uint16_t    Length;                        //有效字节的长度  
    uint8_t     Cmd;                        //默认0x32  50
    uint8_t     mByte;                        //默认0x30  48 
}_CMD_GET_BATTERY_POWER;

//查询电池电量状态 - 应答   
typedef struct
{
    uint8_t      BatteryPowerInterge;        //电压的整数部分 
    uint8_t     BatteryPowerDigits;            //电压的小数部分 
}_CMD_ACK_GET_BATTERY_POWER;

//读取蓝牙和wifi连接状态 
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x48
    uint16_t    Length;                        //有效字节的长度  
    uint8_t     Cmd;                        //默认0x33  51
    uint8_t     mByte;                        //默认0x30  48 
}_CMD_BT_WIFI_CONNECT_STATE;

//读取蓝牙和wifi连接状态 - 应答 
typedef struct
{
    uint8_t      BtState;                    //n1表示蓝牙连接状态:n=0表示未连接,n=1表示已连接
    uint8_t     WifiSate;                    //n2表示WiFi连接状态:n=0表示未连接,n=1表示已连接
}_CMD_ACK_BT_WIFI_CONNECT_STATE;

//读取打印机有效宽度  
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x48
    uint16_t    Length;                        //有效字节的长度  
    uint8_t     Cmd;                        //默认0x35  53
    uint8_t     mByte;                        //默认0x30  48 
}_CMD_GET_PRINT_VALID_WIDTH;

//读取当前打印机缓存    
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x48
    uint16_t    Length;                        //有效字节的长度  
    uint8_t     Cmd;                        //默认0x36  54
    uint8_t     mByte;                        //默认0x30  48 
}_CMD_GET_PRINT_BUFFER_LINES;

//读取当前打印机缓存    
typedef struct
{
    uint16_t    PrintBufferAvaliable;        //有效缓存长度  
}_CMD_ACK_GET_PRINT_BUFFER_LINES;

//读取打印机有效宽度 - 应答   
typedef struct
{
    uint16_t    PrintValidWidth;            //打印机有效宽度  
}_CMD_ACK_GET_PRINT_VALID_WIDTH;

//设置标签参数  
typedef struct
{
    uint8_t      FrameHead;                    //0x17
    uint16_t    PrintRealHight;                //表示本次打印标签的实际内容的总长度
                                            //为nL+nH*256个点(实际有效打印的高度)
    uint16_t    PrintStartOffset;            //表示本次打印标签纵向的起始偏移量
                                            //长度为sL+sH*256个点(标签的起始位置到                
                                            //有效打印内容之间的距离)
    uint8_t        PrintRealWidth;                //打印的实际的宽度  
    uint8_t        PrintDevice;                //表示打印设备是android还是iOS,m=0表示android,m=1表示iOS
    uint8_t        PrintCopies;                //打印的总份数 
    uint8_t        PrintCurrentNum;            //当前打印的是第几张 
    uint32_t    PrintTotalBytes;            //打印的总字节数 
}_CMD_SET_TAPE_PARA;

//打印一点行图形数据
typedef struct
{
    uint8_t      FrameHead;                    //0x17
    uint8_t        ByteSums;                    //当前字节数量  
    uint8_t        PrintData[PRINTER_LINE_BYTES];                //当前行传输的数据  
}_CMD_SET_WRITE_LINE_PRINT;

//打印一点行图形压缩数据
typedef struct
{
    uint8_t      FrameHead;                    //0x18 
    uint8_t        PrintCompressData[255];        //当前行传输的数据(带压缩功能)  
}_CMD_SET_WRITE_LINE_COMPRESS_PRINT;

//走纸N点行 
typedef struct
{
    uint8_t      FrameHead;                    //0x15 
    uint8_t        PrintBlankN;                //打印N个像素点 
}_CMD_SET_BLANK_N_PRINT;

//打印并走到缝隙/黑标处
typedef struct
{
    uint8_t      FrameHead;                    //0x0C 
}_CMD_SET_GOTO_GAP_LOCATE;

//写RFID(高频)标签(按块写)
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x4C
    uint16_t    Length;                        //有效字节的长度  
    uint8_t     Cmd;                        //默认0x37  55
    uint8_t     mByte;                        //默认0x30  48 
    _BLOCK_DATA_TYPE    BlockData[30];        //写入的数据信息 
}_CMD_WRITE_RFID_BLOCK;

//写RFID(超高频) EPC标签 写入 
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x4C
    uint16_t    Length;                        //有效字节的长度  
    uint8_t     Cmd;                        //默认0x37  55
    uint8_t     mByte;                        //默认0x31  49 
    uint8_t        WriteArea;                    //待写入的区域  
    uint8_t        WriteData[255];                //写入的数据 
}_CMD_WRITE_RFID;

//远程升级命令码 
typedef struct
{
    uint8_t      FrameHead[2];                //0x1D 0x28
    uint8_t     Cmd_Type;                    //0x4C
    uint16_t    Length;                        //有效字节的长度  
    uint8_t        UpdateStr[9];                //升级的提示字节信息 
}_CMD_GUID_IAP_UPDATE;

//远程升级 二次确认 
typedef struct
{
    uint8_t     Cmd_Type;                    //0x55
}_CMD_GUID_IAP_SECOND_REQUEST;

//远程升级 准备升级 
typedef struct
{
    uint8_t     Cmd_Type;                    //0x31 
}_CMD_GUID_IAP_PREPARE_UPDATE;

//打印机返回APP/USB 请求补打
typedef struct
{
    uint8_t      FrameHead[6];                //36 21 00 FF 00 FF
    uint8_t        WriteNRetry;                //第N份重打 
}_CMD_REQUEST_RETRY_PRINT;

//定标信息 
typedef  struct
{
    uint8_t      FrameHead;                    //0x1D
    uint8_t     Cmd_Type;                    //0x3C 
}_CMD_GAP_PAPER_CALIBRATION;

//读取状态信息
typedef struct
{
    uint8_t      FrameHead;                    //帧头(0x54)
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint8_t        Test_Flag;                    //无模式
}_CMD_TESTMODE_GET_PRINT_STATE;

//读取状态信息应答
typedef struct
{
    uint8_t      FrameHead;                    //帧头(0x54)
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    _TRANSFER_ERROR_STATE    Error_Flag;        //是否出错
}_CMD_ACK_TESTMODE_GET_PRINT_STATE;

//测试模式 - 读取电压值 
typedef struct
{
    uint8_t      FrameHead;                    //帧头  
    uint16_t    Length;                        //总包长 
    uint8_t     Test_MainCmd;                //主测试命令 
    uint8_t        Test_SubCmd;                //子测试命令 
    uint8_t        Test_Flag;                    //无模式 
}_CMD_TESTMODE_GET_VOLTAGE;

//测试模式 - 读取电压值应答  
typedef struct
{
    uint8_t      FrameHead;                    //帧头 
    uint16_t    Length;                        //总包长 
    uint8_t     Test_MainCmd;                //主测试命令 
    uint8_t        Test_SubCmd;                //子测试命令 
    uint32_t    Test_BatVoltage;            //电池电压值 
}_CMD_ACK_TESTMODE_GET_VOLTAGE;


//测试模式 - 读取色带ADC值
typedef struct
{
    uint8_t      FrameHead;                    //帧头(0x54)
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint8_t        Test_Flag;                    //无模式
}_CMD_TESTMODE_GET_TAPE_ADC;

//测试模式 - 读取色带ADC值 应答
typedef struct
{
    uint8_t      FrameHead;                    //帧头(0x54)
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint16_t    Tape_ADC_Value;             //色带ADC值
}_CMD_ACK_TESTMODE_GET_TAPE_ADC;

//测试模式 - 获取当前机器版本号信息
typedef struct
{
    uint8_t      FrameHead;                    //帧头
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint8_t        Test_Flag;                    //无模式
}_CMD_TESTMODE_GET_VERSION;

//测试模式 - 获取当前机器版本号信息  应答
typedef struct
{
    uint8_t      FrameHead;                    //帧头
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint8_t     Machine_Version[20];        //机器版本号信息
}_CMD_ACK_TESTMODE_GET_VERSION;

//测试模式 - 恢复出厂设置
typedef struct
{
    uint8_t      FrameHead;                    //帧头
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint8_t        Test_Flag;                    //无模式
}_CMD_TESTMODE_FACTORY_SETTING;

//测试模式 - 恢复出厂设置  应答
typedef struct
{
    uint8_t      FrameHead;                    //帧头
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint8_t     Setting_Result;                //恢复出厂设置  
}_CMD_ACK_TESTMODE_FACTORY_SETTING;

//测试模式 - 设置蓝牙名+序列号
typedef struct
{
    uint8_t      FrameHead;                    //帧头  
    uint16_t    Length;                        //总包长 
    uint8_t     Test_MainCmd;                //主测试命令 
    uint8_t        Test_SubCmd;                //子测试命令 
    uint8_t        Bt_Name[31];                //蓝牙名称 
}_CMD_TESTMODE_SET_BT_NAME_SERIAL;

//测试模式 - 设置蓝牙名+序列号 应答
typedef struct
{
    uint8_t      FrameHead;                    //帧头 
    uint16_t    Length;                        //总包长 
    uint8_t     Test_MainCmd;                //主测试命令 
    uint8_t        Test_SubCmd;                //子测试命令 
    uint8_t        Set_OK_Fail;                //蓝牙设置成功or失败 
}_CMD_ACK_TESTMODE_SET_BT_NAME_SERIAL;


//测试模式 - 设置蓝牙密码 
typedef struct
{
    uint8_t      FrameHead;                    //帧头 
    uint16_t    Length;                        //总包长 
    uint8_t     Test_MainCmd;                //主测试命令 
    uint8_t        Test_SubCmd;                //子测试命令 
    uint8_t        Bt_PassWd[16];                //蓝牙密码  
}_CMD_TESTMODE_SET_BT_PASSWD;

//测试模式 - 设置蓝牙密码 应答  
typedef struct
{
    uint8_t      FrameHead;                    //帧头 
    uint16_t    Length;                        //总包长 
    uint8_t     Test_MainCmd;                //主测试命令 
    uint8_t        Test_SubCmd;                //子测试命令 
    uint8_t        Set_OK_Fail;                //蓝牙设置成功or失败 
}_CMD_ACK_TESTMODE_SET_BT_PASSWD;

//测试模式 - 设置加热时间
typedef struct
{
    uint8_t      FrameHead;                    //帧头
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint32_t    Test_HeatTime;                //设置加热时间
}_CMD_TESTMODE_SET_HEATTIME;

//测试模式 - 设置加热时间 应答
typedef struct
{
    uint8_t      FrameHead;                    //帧头
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint8_t        Set_OK_Fail;                //设置加热时间  成功or失败
}_CMD_ACK_TESTMODE_SET_HEATTIME;

//测试模式 - 启动/关闭充电
typedef  struct
{
    uint8_t      FrameHead;                    //帧头(0x54)
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint8_t        StartStopCharge;            //启动/停止充电
}_CMD_TESTMODE_TAKEOVER_CONTROL_CHARGE_TEST;

//测试模式 - 启动/关闭充电 应答
typedef  struct
{
    uint8_t      FrameHead;                    //帧头(0x54)
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint8_t        Test_Flag;                    //无模式
}_CMD_ACK_TESTMODE_TAKEOVER_CONTROL_CHARGE_TEST;

//测试模式 - 打印马达测试  
typedef  struct
{
    uint8_t      FrameHead;                    //帧头 
    uint16_t    Length;                        //总包长 
    uint8_t     Test_MainCmd;                //主测试命令 
    uint8_t        Test_SubCmd;                //子测试命令 
    uint8_t        PrintMotor_State;            //启动、停止打印马达测试  
}_CMD_TESTMODE_PRINTMOTOR_TEST;

//测试模式 - 打印马达测试  应答  
typedef  struct
{
    uint8_t      FrameHead;                    //帧头  
    uint16_t    Length;                        //总包长 
    uint8_t     Test_MainCmd;                //主测试命令 
    uint8_t        Test_SubCmd;                //子测试命令 
    uint8_t        PrintMotor_State;            //当前电机状态  
    uint32_t    PrintMotor_RPM;                //当前打印电机转速 
}_CMD_ACK_TESTMODE_PRINTMOTOR_TEST;

//测试模式 - 启动、停止打印测试  
typedef  struct
{
    uint8_t      FrameHead;                    //帧头 
    uint16_t    Length;                        //总包长 
    uint8_t     Test_MainCmd;                //主测试命令 
    uint8_t        Test_SubCmd;                //子测试命令 
    uint8_t        Control_Cmd_Type;            //1-控制命令  2-查询 
    uint16_t    Print_Length;                //打印长度  
    uint16_t    Print_Copys;                //打印份数 
    uint8_t     IsCutEnable;                //是否允许剪切  
    uint8_t     PrintPaper;                 //纸张类型
}_CMD_TESTMODE_PRINT_TEST;

//测试模式 - 启动、停止打印测试  应答  
typedef struct
{
    uint8_t      FrameHead;                    //帧头  
    uint16_t    Length;                        //总包长 
    uint8_t     Test_MainCmd;                //主测试命令 
    uint8_t        Test_SubCmd;                //子测试命令 
    uint8_t        PrintFinish;                //打印完成  
    int16_t     PrintHead_Temp;                //打印头温度测试
    _TRANSFER_ERROR_STATE    Error_Flag;        //是否出错 
    uint16_t    PrintOptocouplerADC;        //打印色带光耦 ADC值
}_CMD_ACK_TESTMODE_PRINT_TEST;

//测试模式 - 全黑打印测试   
typedef struct
{
    uint8_t      FrameHead;                    //帧头 
    uint16_t    Length;                        //总包长 
    uint8_t     Test_MainCmd;                //主测试命令 
    uint8_t        Test_SubCmd;                //子测试命令 
    uint8_t        Control_Cmd_Type;            //1-控制命令  2-查询 
    uint16_t    Print_Length;                //打印长度  
    uint16_t    Print_Copys;                //打印份数 
    uint8_t     IsCutEnable;                //是否允许剪切  
    uint8_t     PrintPaper;                 //纸张类型
    uint8_t     Is_Auto_GotoGap;            //是否自动进入间隙位置
}_CMD_TESTMODE_PRINT_ALLBLACK_TEST;

//测试模式 - 全黑打印测试  应答  
typedef struct
{
    uint8_t      FrameHead;                    //帧头  
    uint16_t    Length;                        //总包长 
    uint8_t     Test_MainCmd;                //主测试命令 
    uint8_t        Test_SubCmd;                //子测试命令 
    uint8_t        PrintFinish;                //打印完成  
    int16_t     PrintHead_Temp;                //打印头温度测试
    _TRANSFER_ERROR_STATE    Error_Flag;        //是否出错 
    uint16_t    PrintOptocouplerADC;        //打印色带光耦 ADC值
}_CMD_ACK_TESTMODE_PRINT_ALLBLACK_TEST;


//测试模式 - 间隙打印测试   
typedef  struct
{
    uint8_t      FrameHead;                    //帧头 
    uint16_t    Length;                        //总包长 
    uint8_t     Test_MainCmd;                //主测试命令 
    uint8_t        Test_SubCmd;                //子测试命令 
    uint8_t        Control_Cmd_Type;            //1-控制命令  2-查询 
    uint16_t    Print_Length;                //打印长度  
    uint16_t    Print_Copys;                //打印份数 
    uint8_t     IsCutEnable;                //是否允许剪切 
    uint8_t     PrintPaper;                 //纸张类型    
    uint8_t     Is_Auto_GotoGap;            //是否自动进入间隙位置
}_CMD_TESTMODE_PRINT_GAP_TEST;

//测试模式 - 间隙打印测试  应答  
typedef struct
{
    uint8_t      FrameHead;                    //帧头  
    uint16_t    Length;                        //总包长 
    uint8_t     Test_MainCmd;                //主测试命令 
    uint8_t        Test_SubCmd;                //子测试命令 
    uint8_t        PrintFinish;                //打印完成  
    int16_t     PrintHead_Temp;                //打印头温度测试
    _TRANSFER_ERROR_STATE    Error_Flag;        //是否出错 
    uint16_t    PrintOptocouplerADC;        //打印色带光耦 ADC值
}_CMD_ACK_TESTMODE_PRINT_GAP_TEST;

//测试模式 - 偏位打印测试   
typedef struct
{
    uint8_t      FrameHead;                    //帧头
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint8_t     Tape_Width;                 //色带宽度
    int8_t      Pix_Offset;                 //像素偏移
}_CMD_TESTMODE_PRINT_OFFSET_TEST;

//测试模式 - 偏位打印测试  应答  
typedef struct
{
    uint8_t      FrameHead;                    //帧头
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint8_t     Tape_Width;                 //色带宽度 
}_CMD_ACK_TESTMODE_PRINT_OFFSET_TEST;


//测试模式 - 电机寿命测试  
typedef struct
{
    uint8_t      FrameHead;                    //帧头  
    uint16_t    Length;                        //总包长 
    uint8_t     Test_MainCmd;                //主测试命令 
    uint8_t        Test_SubCmd;                //子测试命令 
    uint8_t        PrintMotor_Life_State;        //启动、停止电机寿命测试 
}_CMD_TESTMODE_PRINTMOTER_LIFE_TEST;

//测试模式 - 电机寿命测试  应答  
typedef struct
{
    uint8_t      FrameHead;                    //帧头 
    uint16_t    Length;                        //总包长 
    uint8_t     Test_MainCmd;                //主测试命令 
    uint8_t        Test_SubCmd;                //子测试命令 
    uint8_t        PrintMotor_TestFlag;        //启动、停止电机寿命测试 结果应答 
}_CMD_ACK_TESTMODE_PRINTMOTER_LIFE_TEST;


//测试模式 - 间隙纸定标功能测试
typedef  struct
{
    uint8_t      FrameHead;                    //帧头
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint8_t        Control_Cmd_Type;            //1-控制命令  2-查询
}_CMD_TESTMODE_GAP_CALIBRATION;

//测试模式 - 间隙纸定标功能测试  应答
typedef  struct
{
    uint8_t      FrameHead;                    //帧头
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint8_t     CalibrationFinish;            //定标完成  0-未完成    1-定标完成
    uint8_t        Calibration_Result;            //定标结果  0-定标正常  1-定标失败
}_CMD_ACK_TESTMODE_GAP_CALIBRATION;

//测试模式 - 获取光耦数据
typedef  struct
{
    uint8_t      FrameHead;                    //帧头
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint8_t        Test_Flag;                    //无模式
}_CMD_TESTMODE_GET_TAPE_OPTOCOUPLER;

//测试模式 - 获取光耦数据  应答
typedef  struct
{
    uint8_t      FrameHead;                    //帧头
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint16_t    Optocoupler_ADC;            //光耦ADC值
}_CMD_ACK_TESTMODE_GET_TAPE_OPTOCOUPLER;

//测试模式 - 设置无纸色带ADC
typedef  struct
{
    uint8_t      FrameHead;                    //帧头
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint16_t    Tape_ADC_Value;                //设置无纸色带ADC
}_CMD_TESTMODE_SET_TAPE_NOPAPER_ADC_VALUE;

//测试模式 - 设置无纸色带ADC 应答
typedef  struct
{
    uint8_t      FrameHead;                    //帧头
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint8_t        Set_OK_Fail;                //设置无纸色带ADC  成功Or失败
}_CMD_ACK_TESTMODE_SET_TAPE_NOPAPER_ADC_VALUE;

//测试模式 - 切刀信息测试
typedef  struct
{
    uint8_t      FrameHead;                    //帧头
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    uint8_t     Test_Curr_State;            //当前的状态信息
}_CMD_TESTMODE_CUTTER_LIFE_TEST;

//测试模式 - 切刀信息测试  应答
typedef  struct
{
    uint8_t      FrameHead;                    //帧头
    uint16_t    Length;                        //总包长
    uint8_t     Test_MainCmd;                //主测试命令
    uint8_t        Test_SubCmd;                //子测试命令
    _TRANSFER_ERROR_STATE    Error_Flag;        //是否出错
    uint32_t    Cutter_Times;                //启动、停止、清零、获取切刀次数测试
}_CMD_ACK_TESTMODE_CUTTER_LIFE_TEST;

//测试模式 - 定标数据获取 
typedef  struct
{
    uint8_t              FrameHead;                    //帧头
    uint16_t            Length;                        //总包长
    uint8_t             Test_MainCmd;                //主测试命令
    uint8_t                Test_SubCmd;                //子测试命令
    uint8_t                Test_State;                    //当前的状态信息 该字节无效 用于凑字 
}_CMD_TESTMODE_GET_CALIBRATION_VALUE;

//测试模式 - 定标数据获取  应答 
typedef  struct
{
    uint8_t              FrameHead;                    //帧头
    uint16_t            Length;                        //总包长
    uint8_t             Test_MainCmd;                //主测试命令
    uint8_t                Test_SubCmd;                //子测试命令
    uint16_t            Threshold_Empty;            //空阈值 无纸 
    //_TAPE_THRESHOLD        Threshold_Paper_Gap;        //间隙纸的阈值信息 
}_CMD_ACK_TESTMODE_GET_CALIBRATION_VALUE;

//打印总缓存  
typedef union
{
    uint8_t  buf[SEND_RECV_SIZE];
    
    _CMD_SEND_GET_REALTIME_STATE                    Cmd_Get_Realtime_State;          //打印机状态查询指令
    _CMD_ACK_GET_REALTIME_STATE                        Cmd_Ack_Get_Realtime_State;        //打印机应答 
    _CMD_SEND_PRINT_STATE                            Cmd_Send_Print_State;            //打印状态  
    _CMD_SET_PRINT_DENSITY                            Cmd_Set_Print_Density;            //设置打印浓度
    _CMD_SET_PRINT_SPEED                            Cmd_Set_Print_Speed;            //设置打印速度 
    _CMD_SET_PAPER_TYPE                                Cmd_Set_Paper_Type;                //设置纸张类型
    _CMD_SET_PRINT_MODE                                Cmd_Set_Print_Mode;                //设置打印模式 
    _CMD_SET_TAB_SIZE                                Cmd_Set_Tab_Size;                //设置标签尺寸 
    _CMD_GO_WITH_PAPER                                Cmd_Go_With_Paper;                //设置走纸固定像素点 
    _CMD_SET_BLANK_LENGTH                            Cmd_Set_Blank_Length;            //设置余白长度  
    _CMD_SET_CUT_MODE                                Cmd_Set_Cut_Mode;                //设置剪切模式  
    _CMD_SET_NFC_PASSWD                                Cmd_Set_NFC_Passwd;                //设置NFC校验码
    _CMD_SET_TTR_LENGTH                                Cmd_Set_TTR_Length;                //设置碳带长度 
    _CMD_SET_AFTER_PRINT_FLAG                        Cmd_Set_After_Print_Flag;        //在打印完成后,是否剪切,需要进行设置  
    _CMD_GET_PRINT_ID_INFO                            Cmd_Get_Print_ID_Info;            //查询打印机ID号 
    _CMD_ACK_GET_PRINT_ID_INFO                        Cmd_Ack_Get_Print_ID_Info;        //查询打印机ID号 - 应答 
    _CMD_GET_TAPE_STATE                                Cmd_Get_Tape_State;                //查询色带状态 
    _CMD_ACK_GET_TAPE_STATE                            Cmd_Ack_Get_Tape_State;            //查询色带状态  - 应答
    _CMD_GET_PRINT_BUFFER_LINES                        Cmd_Get_Print_Buffer_Lines;        //获取到当前打印的缓存剩余空间 
    _CMD_ACK_GET_PRINT_BUFFER_LINES                    Cmd_Ack_Get_Print_Buffer_Lines;    //获取到当前打印的缓存剩余空间  - 应答 
    _CMD_GET_BATTERY_POWER                            Cmd_Get_Battery_Power;            //查询电池电量状态  
    _CMD_ACK_GET_BATTERY_POWER                        Cmd_Ack_Get_Battery_Power;        //查询电池电量状态 - 应答
    _CMD_BT_WIFI_CONNECT_STATE                        Cmd_BT_WIFI_Connect_State;        //读取蓝牙和wifi连接状态 
    _CMD_ACK_BT_WIFI_CONNECT_STATE                    Cmd_Ack_BT_WIFI_Connect_State;    //读取蓝牙和wifi连接状态 - 应答 
    _CMD_GET_PRINT_VALID_WIDTH                        Cmd_Ack_Print_Valid_Width;        //读取打印机有效宽度  
    _CMD_ACK_GET_PRINT_VALID_WIDTH                    Cmd_Ack_Get_Print_Valid_Width;    //读取打印机有效宽度 - 应答   
    _CMD_SET_TAPE_PARA                                Cmd_Set_Tape_Para;                //设置标签参数  
    _CMD_SET_WRITE_LINE_PRINT                        Cmd_Set_Write_Line_Print;        //打印一点行图形数据
    _CMD_SET_WRITE_LINE_COMPRESS_PRINT                Cmd_Set_Write_Line_Compress_Print;    //打印一点行图形压缩数据
    _CMD_SET_BLANK_N_PRINT                            Cmd_Set_Blank_N_Print;            //走纸N点行 
    _CMD_SET_GOTO_GAP_LOCATE                        Cmd_Set_Goto_Gap_Locate;        //打印并走到缝隙/黑标处
    _CMD_WRITE_RFID_BLOCK                            Cmd_Write_RDID_Block;            //写RFID(高频)标签(按块写)
    _CMD_WRITE_RFID                                    Cmd_Write_RDID;                    //写RFID(超高频) EPC标签 写入
    _CMD_GUID_IAP_UPDATE                            Cmd_Guid_IAP_Update;            //IAP远程升级指令  
    _CMD_GUID_IAP_SECOND_REQUEST                    Cmd_Guid_IAP_Second_Request;                    //IAP升级二次确认 
    _CMD_GUID_IAP_PREPARE_UPDATE                    Cmd_Guid_IAP_Prepare_Update;                    //IAP准备升级  
    _CMD_REQUEST_RETRY_PRINT                        Cmd_Request_Retry_Print;                        //打印机返回APP/USB 请求补打
    _CMD_GAP_PAPER_CALIBRATION                        Cmd_GapPaper_Calibration;                        //间隙色带定标功能  
    _CMD_TESTMODE_GET_PRINT_STATE                    Cmd_TestMode_Get_Print_State;                   //获取打印状态
    _CMD_ACK_TESTMODE_GET_PRINT_STATE                Cmd_Ack_TestMode_Get_Print_State;               //获取打印状态应答
    _CMD_TESTMODE_GET_VOLTAGE                        Cmd_TestMode_Get_Voltage;                        //获取电池供电电压  
    _CMD_ACK_TESTMODE_GET_VOLTAGE                    Cmd_Ack_TestMode_Get_Voltage;                    //获取电池供电电压 应答  
    _CMD_TESTMODE_GET_TAPE_ADC                      Cmd_TestMode_Get_Tape_ADC;                      //获取ADC值
    _CMD_ACK_TESTMODE_GET_TAPE_ADC                  Cmd_Ack_TestMode_Get_Tape_ADC;                  //获取ADC值  应答
    _CMD_TESTMODE_GET_VERSION                       Cmd_TestMode_Get_Version;                       //获取版本号信息
    _CMD_ACK_TESTMODE_GET_VERSION                   Cmd_Ack_TestMode_Get_Version;                   //获取版本号信息 应答
    _CMD_TESTMODE_FACTORY_SETTING                    Cmd_TestMode_Factory_Setting;                    //恢复出厂设置 
    _CMD_ACK_TESTMODE_FACTORY_SETTING                Cmd_Ack_TestMode_Factory_Setting;                //恢复出厂设置 应答  
    _CMD_TESTMODE_SET_BT_NAME_SERIAL                Cmd_TestMode_Set_Bt_Name_Serial;                //设置蓝牙序列号和名字 
    _CMD_ACK_TESTMODE_SET_BT_NAME_SERIAL            Cmd_Ack_TestMode_Set_Bt_Name_Serial;            //设置蓝牙序列号和名字  应答 
    _CMD_TESTMODE_SET_BT_PASSWD                        Cmd_TestMode_Set_Bt_Passwd;                        //设置蓝牙密码 
    _CMD_ACK_TESTMODE_SET_BT_PASSWD                    Cmd_Ack_TestMode_Set_Bt_Passwd;                    //设置蓝牙密码正确/错误  
    _CMD_ACK_TESTMODE_SET_BT_PASSWD                    Cmd_TestMode_Get_Bt_Passwd;                        //读取蓝牙密码
    _CMD_TESTMODE_SET_BT_PASSWD                        Cmd_Ack_TestMode_Get_Bt_Passwd;                    //读取蓝牙密码 应答 
    _CMD_TESTMODE_SET_HEATTIME                      Cmd_TestMode_Set_Heattime;                      //设置加热时间
    _CMD_ACK_TESTMODE_SET_HEATTIME                  Cmd_Ack_TestMode_Set_Heattime;                  //设置加热时间 应答
    _CMD_ACK_TESTMODE_SET_HEATTIME                  Cmd_TestMode_Get_Heattime;                      //读取加热时间
    _CMD_TESTMODE_SET_HEATTIME                      Cmd_Ack_TestMode_Get_Heattime;                  //读取加热时间 应答
    _CMD_TESTMODE_PRINT_TEST                        Cmd_TestMode_Print_Test;                        //启动、停止打印测试  
    _CMD_ACK_TESTMODE_PRINT_TEST                    Cmd_Ack_TestMode_Print_Test;                    //启动、停止打印测试  应答 
    _CMD_TESTMODE_PRINTMOTOR_TEST                    Cmd_TestMode_PrintMotor_Test;                    //启动、停止打印电机测试 
    _CMD_ACK_TESTMODE_PRINTMOTOR_TEST                Cmd_Ack_TestMode_PrintMotor_Test;                //启动、停止打印电机测试 应答
    _CMD_TESTMODE_PRINT_ALLBLACK_TEST                Cmd_TestMode_Print_AllBlack_Test;                //启动/停止全黑打印测试  
    _CMD_ACK_TESTMODE_PRINT_ALLBLACK_TEST            Cmd_Ack_TestMode_Print_AllBlack_Test;            //启动/停止全黑打印测试  应答 
    _CMD_TESTMODE_PRINT_GAP_TEST                    Cmd_TestMode_Print_Gap_Test;                    //启动、停止间隙打印测试  
    _CMD_ACK_TESTMODE_PRINT_GAP_TEST                Cmd_Ack_TestMode_Print_Gap_Test;                //启动、停止间隙打印测试  应答  
    _CMD_TESTMODE_TAKEOVER_CONTROL_CHARGE_TEST        Cmd_TestMode_TakeOver_Control_Charge_Test;        //启动/停止接管充电 
    _CMD_ACK_TESTMODE_TAKEOVER_CONTROL_CHARGE_TEST    Cmd_Ack_TestMode_TakeOver_Control_Charge_Test;    //启动/停止接管充电应答
    _CMD_TESTMODE_PRINTMOTER_LIFE_TEST                Cmd_TestMode_PrintMotor_Life_Test;                //打印电机寿命测试  
    _CMD_ACK_TESTMODE_PRINTMOTER_LIFE_TEST            Cmd_Ack_TestMode_PrintMotor_Life_Test;            //打印电机寿命测试  应答 
    _CMD_TESTMODE_GAP_CALIBRATION                   Cmd_TestMode_Gap_Calibration;                   //定标功能测试
    _CMD_ACK_TESTMODE_GAP_CALIBRATION               Cmd_Ack_TestMode_Gap_Calibration;               //定标功能测试 应答    
    _CMD_TESTMODE_GET_TAPE_OPTOCOUPLER              Cmd_TestMode_Get_Tape_Optocoupler;              //获取光耦值信息
    _CMD_ACK_TESTMODE_GET_TAPE_OPTOCOUPLER          Cmd_Ack_TestMode_Get_Tape_Optocoupler;          //获取光耦值信息 应答
    _CMD_TESTMODE_SET_TAPE_NOPAPER_ADC_VALUE        Cmd_TestMode_Set_Tape_Nopaper_ADC_Value;          //设置ADC值
    _CMD_ACK_TESTMODE_SET_TAPE_NOPAPER_ADC_VALUE    Cmd_Ack_TestMode_Set_Tape_Nopaper_ADC_Value;      //设置ADC值 应答
    _CMD_ACK_TESTMODE_SET_TAPE_NOPAPER_ADC_VALUE    Cmd_TestMode_Get_Tape_Nopaper_ADC_Value;          //读取ADC值
    _CMD_TESTMODE_SET_TAPE_NOPAPER_ADC_VALUE        Cmd_Ack_TestMode_Get_Tape_Nopaper_ADC_Value;      //读取ADC值 应答
    _CMD_TESTMODE_CUTTER_LIFE_TEST                  Cmd_TestMode_Cutter_Life_Test;                  //启动、停止、读取,清零切刀次数
    _CMD_ACK_TESTMODE_CUTTER_LIFE_TEST              Cmd_Ack_TestMode_Cutter_Life_Test;              //启动、停止、读取,清零切刀次数(应答)
    _CMD_TESTMODE_GET_CALIBRATION_VALUE                Cmd_TestMode_Get_Calibration_Value;                //获取定标数据  
    _CMD_ACK_TESTMODE_GET_CALIBRATION_VALUE            Cmd_Ack_TestMode_Get_Calibration_Value;            //获取定标数据 应答  
}_DATA_ANALYSIS_UNI;

#pragma pack(pop)

/**********************************可导出变量**********************************/

extern _DATA_ANALYSIS_UNI        Data_Analysis_Tx;        //数据发送接口 
extern _DATA_ANALYSIS_UNI        Data_Analysis_Rx;        //数据接收接口 

/***********************************函数实现***********************************/
void Print_Data_Unpack_Pack(uint8_t byte);    //拆包 
void Print_Data_Analysis(uint8_t *buf,uint16_t len);
void PrintData_Send(uint8_t *buf,uint16_t len);            //打印数据发送 
void PrintData_Send_Str(char *format,...);                //打印数据发送字符串 

void Print_Data_Combine_Pack(uint8_t buf);                //拼包 
bool Print_Data_Combine_Analysis(void);    //拼包后协议解析  
//-------应答-------
void Cmd_Ack_Density_Fun(void);        //设置打印浓度 
void Cmd_Ack_Speed_Fun(void);        //设置打印速度  
void Cmd_Ack_PaperType_Fun(void);    //设置纸张类型 
void Cmd_Ack_Set_Print_Type_Fun(void);//设置打印模式  
void Cmd_Ack_Set_Tape_Size_Fun(void);    //设置标签尺寸 
void Cmd_Ack_Go_With_Paper_Fun(void);        //空走纸命令 
void Cmd_Ack_Set_Blank_Length_Fun(void);    //设置余白长度 
void Cmd_Ack_Set_Cut_Mode_Fun(void);        //设置剪切模式  
void Cmd_Ack_Set_NFC_Passwd_Fun(void);    //设置NFC密码
void Cmd_Ack_Set_TTR_Length_Fun(void);    //设置碳带长度  
void Cmd_Ack_Get_Print_ID_Info_Fun(void);//查询打印机ID号 
void Cmd_Ack_Write_RDID_Block_Fun(void); //写RFID(高频)标签(按块写)
void Cmd_Ack_Write_RDID_Fun(void);        //写RFID(高频)标签
void Cmd_Ack_GapPaper_Calibration(void);//色带定标功能  
void Cmd_Ack_Get_Tape_State_Fun(void);    //读取角带使用状态
void Cmd_Ack_Get_Battery_Power_Fun(void);    //读取电池电量状态  
void Cmd_Ack_BT_WIFI_Connect_State_Fun(void);    //读取蓝牙和wifi的连接状态  
void Cmd_Ack_Get_Print_Valid_Width_Fun(void);    //获取打印机有效打印宽度 
void Cmd_Ack_Get_Realtime_State_Fun(void);        //打印机实时状态指令 
void Cmd_Ack_Get_Print_Buffer_Lines_Fun(void);        //获取打印机的缓存长度信息 
void Cmd_Ack_Set_After_Print_Flag_Fun(void);    //打印完成后,是否剪切配置  
void Cmd_Ack_Set_Tape_Para_Fun(void);            //设置标签参数 
void Cmd_Ack_Set_Write_Line_Print(void);        //打印一点行数据  
void Cmd_Ack_Set_Write_Line_Compress_Print(uint8_t len);//设置一点行压缩打印数据 
void Cmd_Ack_Set_Blank_N_Print(void);            //走纸N点行
void Cmd_Ack_Set_Goto_Gap_Locate(void);            //打印并走到缝隙黑标
void Cmd_Ack_Set_ESC_Command(void);                //ESC命令 
void Cmd_Ack_Guid_IAP_Update(void);                //IAP升级命令  
void Cmd_Ack_Guid_IAP_Second_Request(void);        //IAP升级二次确认 
void Cmd_Ack_Guid_IAP_Prepare_Update(void);        //IAP准备升级 

void Cmd_Ack_TestMode_Analysis(void);            //测试模式 协议解析  

//主动上报 
void Cmd_Send_Print_State_Fun(void);        //打印机状态发生变化   主动上报 
#endif

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值