[单片机][FUSB302][PD1.0][PD2.0] PD协议 Demo 例子 代码

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

/* -----------------------------------------头文件-----------------------------------------*/
#include "main.h"

/* -----------------------------------------结构体定义-------------------------------------*/

/* -----------------------------------------全局变量定义-----------------------------------*/
uint8_t       CCx_PIN_Useful     = 0;   //0为没有 1为cc1 2为cc2 注意 为1的时候 不排除2有效
uint8_t       USB302_INT         = 0;   //0--无PD消息通知  1--PD消息通知

xdata uint8_t USB302_TX_Buff[20] = {0}; //存放消息内容——TX
xdata uint8_t USB302_RX_Buff[40] = {0}; //存放消息内容——RX
uint8_t       RX_Length          = 0;   //接收内容的长度

uint8_t       PD_STEP            = 0;   //0--PD协议未选择  1--PD协议已选择  2--收到数据消息  3--数据读取完毕并解析

uint8_t       PD_MSG_ID          = 0;   //消息ID号
uint8_t       PD_Version         = 0;   //器件版本号

uint8_t       PPS_State          = 0;   //pps的控制状态 0：不是pps档 1：在pps档非调整模式 2：pps档调整模式
uint16_t      PPS_VOL   = 50000 / 20;   //pps的电压 20mv档 默认5V

xdata PD_Source_Capabilities_TypeDef PD_Source_Capabilities_Inf[7] = {0};
uint8_t PD_Source_Capabilities_Inf_num = 0;

const uint8_t PD_Resq[14] =
{
    0x12, 0x12, 0x12, 0x13, 0x86,
    0x42, 0x14,
    0x00, 0x00, 0x00, 0x03,
    0xff, 0x14, 0xA1
};

/******************
笔记：
1、DelayTick = 2
2、ADDR:SD0==0==0x44 ; SD0==1==0x44  【写命令0x44  读命令0x44|1】
*******************/
code IIC_TYPE FUSB302_IIC = {2, 0x44};


uint8_t now_obj = 0;
uint8_t old_obj = 0;

xdata uint16_t Supporting_voltage[10] = {0};
xdata uint16_t Supporting_current[10] = {0};

uint16_t PPS_MAX_VOL = 0, PPS_MIN_VOL = 0; //当前挡位支持的最高最低电压
/* -----------------------------------------应用程序---------------------------------------*/
void USB302_Wite_Reg(uint8_t REG_ADDR, uint8_t DATA)
{
    IIC_Start();                     // 启动
    IIC_WriteByte(FUSB302_IIC.ADDR); // 设备地址
    IIC_Wait_ACK();                  // 等待数据响应
    IIC_WriteByte(REG_ADDR);         // 发送寄存器地址
    IIC_Wait_ACK();                  // 等待数据响应
    IIC_WriteByte(DATA);             // 发送数据
    IIC_Wait_ACK();                  // 等待数据响应
    IIC_Stop();                      // 停止
}
void USB302_Wite_FIFO(uint8_t *Data, uint8_t Length)
{
    uint8_t i = 0;
    IIC_Start();                     // 启动
    IIC_WriteByte(FUSB302_IIC.ADDR); // 设备地址
    IIC_Wait_ACK();                  // 等待数据响应
    IIC_WriteByte(0x43);             // 发送寄存器地址
    IIC_Wait_ACK();                  // 等待数据响应
    for (i = 0; i < Length; i++)
    {
        IIC_WriteByte(Data[i]);      // 发送数据
        IIC_Wait_ACK();              // 等待数据响应
    }
    IIC_Stop();                      // 停止
}
/*********************************************
函数名：USB302_Read_Same(部分)
功  能：读地址数据
形  参：REG_ADDR--寄存器地址
返回值：
备  注：
作  者：薛建强
时  间：2020/04/16
**********************************************/
void USB302_Read_Same(uint8_t REG_ADDR)
{
    IIC_Start();                   // 启动
    IIC_WriteByte(FUSB302_IIC.ADDR);   // 发送地址
    IIC_Wait_ACK();                // 等待数据响应
    IIC_WriteByte(REG_ADDR);           // 发送地址
    IIC_Wait_ACK();                // 等待数据响应

    IIC_Start();                   // 启动
    IIC_WriteByte(FUSB302_IIC.ADDR | 1); // 发送地址
    IIC_Wait_ACK();                // 等待数据响应
}
/*********************************************
函数名：USB302_Read_Reg
功  能：读地址数据
形  参：REG_ADDR--寄存器地址
返回值：
备  注：
作  者：薛建强
时  间：2020/04/16
**********************************************/
uint8_t USB302_Read_Reg(uint8_t REG_ADDR)
{
    uint8_t GET_DATA = 0;
    USB302_Read_Same(REG_ADDR);
    GET_DATA = IIC_ReadByte();     // 获取数据
    IIC_Wait_ACK();                // 等待数据响应
    IIC_Stop();                    // 停止
    return GET_DATA;
}
/*********************************************
函数名：USB302_Read_FIFO
功  能：读地址数据
形  参：Data--数据数组  Length--数据长度
返回值：
备  注：读取地址-->0x43
作  者：薛建强
时  间：2020/04/16
**********************************************/
void USB302_Read_FIFO(uint8_t *Data, uint8_t Length)
{
    uint8_t i = 0;
    USB302_Read_Same(0x43);//数据起始地址
    for (i = 0; i < Length; i++)
    {
        if (i == (Length - 1))
        {
            Data[i] =  IIC_ReceiveData(0);
        }
        else
        {
            Data[i] =  IIC_ReceiveData(1);
        }
    }
    IIC_Stop();            // 停止
}


/*********************************************
函数名：USB302_Chech_CCx
功  能：检测cc脚上是否有连接
形  参：
返回值：0--失败， 1--成功
备  注：[usb302器件手册.pdf]--21页
作  者：薛建强
时  间：2020/04/17
使  用：
**********************************************/
uint8_t USB302_Chech_CCx(void)
{
    uint8_t Read_State;
    USB302_Wite_Reg(0x0C, 0x02); // PD协议重置
    USB302_Wite_Reg(0x0C, 0x03); /* FUSB302器件寄存器复位*/
    os_wait(K_IVL, 5, 0);//5ms
    USB302_Wite_Reg(0x0B, 0x0F); /* 全电源启动-->PWR[0]：带备用和唤醒的电路。
                                                 PWR[1]：测量块区的接收器供电和电流基准。
                                                 PWR[2]：测量块区电源。
                                                 PWR[3]：启用内部振荡器。*/

    USB302_Wite_Reg(0x02, 0x07); // CC1/CC2设置为下拉电阻 且 开启MEAS_CC1(使用测量块区[监控或测量]CC1电压)
    os_wait(K_IVL, 2, 0);//2ms
    Read_State = USB302_Read_Reg(0x40); //读FUSB302状态寄存器
    USB302_Wite_Reg(0x02, 0x03);        //切换到初始状态 即只保留CC1/CC2设置为下拉电阻
    Read_State &= 0x03;                 //只看低2位 看CC1/CC2有没有电压   BC_LVL[1:0]==0->(<200mV)  1->[200,660]mV  2->[660,1230]mV 3->(>1230)mV
    if (Read_State > 0)                 //只要存在高电平，则代表CC1状态正常
    {
        CCx_PIN_Useful = 1;
        return 1;
    }
    USB302_Wite_Reg(0x02, 0x0B);        //CC1/CC2设置为下拉电阻 且 开启MEAS_CC2(使用测量块区[监控或测量]CC2电压)
    os_wait(K_IVL, 2, 0);//2ms
    Read_State = USB302_Read_Reg(0x40); //读FUSB302状态寄存器
    USB302_Wite_Reg(0x02, 0x03);        //切换到初始状态 即只保留CC1/CC2设置为下拉电阻
    Read_State &= 0x03;                 //只看低2位 看CC1/CC2有没有电压   BC_LVL[1:0]==0->(<200mV)  1->[200,660]mV  2->[660,1230]mV 3->(>1230)mV
    if (Read_State > 0)                 //只要存在高电平，则代表CC1状态正常
    {
        CCx_PIN_Useful = 2;
        return 1;
    }
    return 0;
}
/*********************************************
函数名：IIC_Init_Check_USB302
功  能：检测器件是否正常
形  参：
返回值：0--失败， 1--成功
备  注：[usb302器件手册.pdf]--21页
作  者：薛建强
时  间：2020/04/17
使  用：
**********************************************/
uint8_t IIC_Init_Check_USB302(void)
{
    uint8_t Read_Back;
    IIC_Init();
    Read_Back = USB302_Read_Reg(0x01);//读取器件ID
    if (Read_Back < 0x83 && Read_Back > 0x7F)//读到的ID只可能是0x80 0x81 0x82 中的一个 代表版本号
    {

    }
    else
    {
        return 0;
    }
    USB302_Wite_Reg(0x0C, 0x03); /*FUSB302器件寄存器复位*/
    return 1;
}

/*********************************************
函数名：USB302_Init
功  能：器件初始化
形  参：
返回值：0--失败， 1--成功
备  注：[usb302器件手册.pdf]--21页
作  者：薛建强
时  间：2020/04/17
使  用：
**********************************************/
uint8_t USB302_Init(void)
{
    if (USB302_Chech_CCx() == 0)//检测cc脚上是否有连接
    {
        return 0; //检查有没有接着设备
    }
    USB302_Wite_Reg(0x09, 0x40); //发送器件重置数据包(最高优先级)
    USB302_Wite_Reg(0x0C, 0x03); /* FUSB302器件寄存器复位*/

    os_wait(K_IVL, 5, 0);//5ms
    USB302_Wite_Reg(0x09, 0x07); //使能自动重试 3次自动重试
    USB302_Wite_Reg(0x0E, 0xFC); //使能各种中断

    USB302_Wite_Reg(0x0F, 0x01); //使能CRC校验成功中断
    USB302_Wite_Reg(0x0A, 0xEF); //屏蔽CRC校验
    USB302_Wite_Reg(0x06, 0x00); //清空各种状态
    USB302_Wite_Reg(0x0C, 0x02); //复位PD
    if (CCx_PIN_Useful == 1)
    {
        USB302_Wite_Reg(0x02, 0x05); //CC1设置为下拉电阻 开启CC1引脚的ADC检测
        USB302_Wite_Reg(0x03, 0x41); //将器件的PD协议设置为2.0.且在CC1引脚上启用BMC传输驱动程序。
    }
    else if (CCx_PIN_Useful == 2)
    {
        USB302_Wite_Reg(0x02, 0x0A); // CC2设置为下拉电阻 开启CC1引脚的ADC检测
        USB302_Wite_Reg(0x03, 0x42); // 将器件的PD协议设置为2.0.且在CC2引脚上启用BMC传输驱动程序。
    }
    USB302_Wite_Reg(0x0B, 0x0F);     /* 全电源启动-->PWR[0]：带备用和唤醒的电路。
                                                     PWR[1]：测量块区的接收器供电和电流基准。
                                                     PWR[2]：测量块区电源。
                                                     PWR[3]：启用内部振荡器。*/
    USB302_Read_Reg(0x3E); //读取中断标记寄存器1
    USB302_Read_Reg(0x3F); //读取中断标记寄存器2 只有GoodCRC中断
    USB302_Read_Reg(0x42); //读取中断标记寄存器2 主要是TX_FULL/RX_FULL
    RX_Length  = 0;
    USB302_INT = 0;
    PD_STEP    = 0;
    PD_Source_Capabilities_Inf_num = 0;
    /*  USB302_Wite_Reg(0x07, 0x04); // Flush RX*/
    return 1;
}

/*********************************************
函数名：USB302_Dis_Init
功  能：器件复位
形  参：
返回值：
备  注：
作  者：薛建强
时  间：2020/04/17
使  用：
**********************************************/
void USB302_Dis_Init(void)
{
    USB302_Wite_Reg(0x0C, 0x03); /* FUSB302器件寄存器复位*/
    USB302_INT     = 0;
    CCx_PIN_Useful = 0;
    PD_STEP        = 0;
    PD_MSG_ID      = 0;
}

/*********************************************
函数名：USB302_Read_Service
功  能：读取器件FIFO寄存器缓存数
形  参：
返回值：
备  注：
作  者：薛建强
时  间：2020/04/17
使  用：
**********************************************/
void USB302_Read_Service(void)
{
    uint8_t i = 0;
    USB302_Read_Reg(0x3E); //清中断
    USB302_Read_Reg(0x42); //清中断
    USB302_RX_Buff[0] = USB302_Read_Reg(0x43) & 0xe0;
    if (USB302_RX_Buff[0] > 0x40) //E0 C0 A0 80 60 都是允许的值
    {
        //小端 高8位后来
        USB302_Read_FIFO(USB302_RX_Buff + 1, 2);
        i = USB302_RX_Buff[2] & 0x70; //取数量位 报告了有几组电压的意思 每个电压报告组有4字节
        i >>= 2;
        i += 2; //获得要读的数量
        RX_Length = i + 3;
        USB302_Read_FIFO(USB302_RX_Buff + 3, i);
    }
    USB302_Wite_Reg(0x07, 0x04);//清空RX FIFO
}

/*********************************************
函数名：PD_Msg_ID_ADD
功  能：PD消息包计次(发送一次递增一次)
形  参：
返回值：
备  注：
作  者：薛建强
时  间：2020/04/17
使  用：
**********************************************/
void PD_Msg_ID_ADD(void)
{
    PD_MSG_ID++;
    if (PD_MSG_ID > 7)
    {
        PD_MSG_ID = 0;
    }
}

/*********************************************
函数名：USB302_Read_Data_State
功  能：读取数据状态
形  参：
返回值：
备  注：
作  者：薛建强
时  间：2020/04/10
使  用：
**********************************************/
void USB302_Read_Data_State(void)
{
    uint8_t i = 0;
    if (USB302_INT)
    {
        USB302_Read_Service();//读取器件FIFO寄存器缓存数
        USB302_INT = 0;
        if (RX_Length >= 5) //至少要读得5个包
        {
            PD_Msg_ID_ADD();//递增一次消息号
            i = USB302_RX_Buff[2] & 0x70;
            if (i == 0) //控制消息
            {
                i = (USB302_RX_Buff[1] & 0x07); //获取包类型
                switch (i)
                {
                    case 1://GoodCRC 表示通讯crc校验没问题
                        break;
                    case 3://Accept  表示充电器接受了用电器的请求
                        break;
                    case 4://Reject  表示充电器拒绝了用电器的请求  比如说电压 电流请求不合规格
                        break;
                    case 6://PS_RDY  表示请求的电压已就绪 一般是在Accept 后几百ms 由充电器发出 告诉用电器电压已经调整好了
                        break;
                    case 8://Get_Sink_Cap  必须回复点东西
                        os_wait(K_IVL, 1, 0);//1ms
                        break;
                    default:
                        break;
                }
            }
            else//数据消息
            {
                if ((USB302_RX_Buff[1] & 0x07) == 0x01) //充电头支持的功能
                {
                    if (PD_STEP == 0)
                    {
                        i = USB302_RX_Buff[1] & 0xC0;
                        PD_Version = i;
                        i >>= 1;
                        if (CCx_PIN_Useful == 1) //调整PD版本
                        {
                            i |= 0x05;
                        }
                        else if (CCx_PIN_Useful == 2)
                        {
                            i |= 0x06;
                        }
                        USB302_Wite_Reg(0x03, i);
                        os_wait(K_IVL, 1, 0);//1ms
                        USB302_Wite_Reg(0x0C, 0x02); // 复位PD协议
                        USB302_Wite_Reg(0x07, 0x04);
                        PD_STEP = 1;
                        USB302_INT = 0;
                        PD_MSG_ID = 0; //现在开始正式从0开始记录
                        return;
                    }
                    i = USB302_RX_Buff[2] & 0x70;
                    i >>= 4;
                    PD_Source_Capabilities_Inf_num = i;

                    for (i = 0; i < PD_Source_Capabilities_Inf_num; i++)
                    {
                        PD_Source_Capabilities_Inf[i].PDC_INF[0] = USB302_RX_Buff[4 * i + 3];
                        PD_Source_Capabilities_Inf[i].PDC_INF[1] = USB302_RX_Buff[4 * i + 4];
                        PD_Source_Capabilities_Inf[i].PDC_INF[2] = USB302_RX_Buff[4 * i + 5];
                        PD_Source_Capabilities_Inf[i].PDC_INF[3] = USB302_RX_Buff[4 * i + 6];
                    }
                    PD_STEP = 2;
                    PPS_State = 0; //恢复pps 挡位
                }
                //else if((USB302_RX_Buff[1]&0x07)==0x03)//Request Message
                //{}
            }
        }
    }
}


void Load_TX_Buff(void)//帮忙装填发送buff
{
    uint8_t i;
    for (i = 0; i < 14; i++)
    {
        USB302_TX_Buff[i] = PD_Resq[i];
    }
    USB302_TX_Buff[6] |= PD_MSG_ID << 1;
    USB302_TX_Buff[5] |= PD_Version;
}


/*********************************************
函数名：USB302_Send_Requse
功  能：发送请求 调整电压/电流
形  参：
返回值：
备  注：
作  者：薛建强
时  间：2020/04/17
使  用：
**********************************************/
void USB302_Send_Requse(uint8_t objects)
{
    uint8_t i = 0;
    uint16_t cachecur = 0;
    if (objects > PD_Source_Capabilities_Inf_num)
    {
        return;
    }
    //Load_Requse_TX_Buff();
    for (i = 0; i < 14; i++) //装填发送buff
    {
        USB302_TX_Buff[i] = PD_Resq[i];
    }
    USB302_TX_Buff[6] |= PD_MSG_ID << 1;
    USB302_TX_Buff[5] |= PD_Version;

    USB302_TX_Buff[10] |= (objects + 1) << 4;
    i = PD_Source_Capabilities_Inf[objects].PDC_INF[3] & 0xc0;
    if ((i == 0x00) || (i == 0x80)) // Fixed and Variable Request Data Object
    {
        USB302_TX_Buff[7] = PD_Source_Capabilities_Inf[objects].PDC_INF[0];
        USB302_TX_Buff[8] = PD_Source_Capabilities_Inf[objects].PDC_INF[1] & 0x03;
        USB302_TX_Buff[9] |= USB302_TX_Buff[8] << 2;
        USB302_TX_Buff[8] |= USB302_TX_Buff[7] << 2;
        USB302_TX_Buff[9] |= USB302_TX_Buff[7] >> 6;
        PPS_State = 0; //不是pps档
    }
    else
    {
        *((uint8_t *)&cachecur + 1) = PD_Source_Capabilities_Inf[i].PDC_INF[0]; //低位
        *(uint8_t *)&cachecur = PD_Source_Capabilities_Inf[i].PDC_INF[1] & 0x03; //高位
        if (i == 0xC0) //pps
        {
            if (PPS_State == 0)
            {
                PPS_State = 1; //记录为在pps上面了
                PPS_VOL = 5000 / 20; //恢复pps电压
            }
            cachecur /= 5;
            cachecur -= 1;
            USB302_TX_Buff[7] = cachecur; //吧电流存进去 50ma 进制
            USB302_TX_Buff[8] = PPS_VOL << 1;
            USB302_TX_Buff[9] |= PPS_VOL >> 7;
        }
        else//电池
        {
            PPS_State = 0; //不是pps档
        }
    }
    //USB302_Wite_Reg(0x0B, 0x0F);//全电源  感觉没必要
    USB302_Wite_Reg(0x06, 0x40);//清发送
    USB302_Wite_FIFO(USB302_TX_Buff, 14);
    USB302_Wite_Reg(0x06, 0x05);//开始发

    PD_Msg_ID_ADD();//加包
}


/*********************************************
函数名：USB302_Get_Data
功  能：读取FIFO缓冲器内容
形  参：
返回值：
备  注：
作  者：薛建强
时  间：2020/04/17
使  用：
**********************************************/
void USB302_Get_Data(void)
{
    uint8_t i = 0;
    uint16_t cachevol = 0, cachecur = 0;
    if (PD_STEP == 2)
    {
        USB302_Send_Requse(0);//进行一次1包请求
        for (i = 0; i < PD_Source_Capabilities_Inf_num; i++)
        {
            if ((PD_Source_Capabilities_Inf[i].PDC_INF[3] & 0xc0) == 0) //普通
            {
                /*****读取一组电流******/
                *((uint8_t *)&cachecur + 1) = PD_Source_Capabilities_Inf[i].PDC_INF[0];        //低位
                *(uint8_t *)&cachecur       = PD_Source_Capabilities_Inf[i].PDC_INF[1] & 0x03; //高位
                //cachecur*=10;
                /*****读取一组电压******/
                *((uint8_t *)&cachevol + 1) = PD_Source_Capabilities_Inf[i].PDC_INF[1] & 0xFC; //低位
                *(uint8_t *)&cachevol       = PD_Source_Capabilities_Inf[i].PDC_INF[2] & 0x0F; //高位
                cachevol >>= 2;
                cachevol *= 5;
                Supporting_voltage[i] = cachevol;
                Supporting_current[i] = cachecur;
            }
            else if ((PD_Source_Capabilities_Inf[i].PDC_INF[3] & 0xc0) == 0xc0) //pps可编程调整
            {
                cachecur = PD_Source_Capabilities_Inf[i].PDC_INF[0] & 0x7F; //电流
                cachecur >>= 1;
                *((uint8_t *)&cachevol + 1) = PD_Source_Capabilities_Inf[i].PDC_INF[1]; //低位 最小电压
                *(uint8_t *)&cachevol = PD_Source_Capabilities_Inf[i].PDC_INF[2] >> 1; //高位 最大电压
                if ((PD_Source_Capabilities_Inf[i].PDC_INF[2] & 0x01) == 1) //第24位 补上
                {
                    *(uint8_t *)&cachevol |= 0x80;
                }
                Supporting_voltage[i] = cachevol;
                Supporting_current[i] = cachecur;
            }
        }
        PD_STEP = 3;
    }
}

#ifndef _USB302_H
#define _USB302_H
/* -----------------------------------------宏定义-----------------------------------------*/
sbit USB302_EXIT = P1 ^ 2;

/* -----------------------------------------头文件-----------------------------------------*/
#include "main.h"

/* -----------------------------------------结构体定义-------------------------------------*/
typedef struct
{
    uint8_t PDC_INF[4];
} PD_Source_Capabilities_TypeDef;
/* -----------------------------------------全局变量定义-----------------------------------*/
extern uint8_t PPS_State;//pps的控制状态 0：不是pps档 1：在pps档非调整模式 2：pps档调整模式
extern uint16_t PPS_VOL;//pps的当前电压 20mv档 默认5V
extern uint8_t USB302_INT;
extern uint16_t PPS_MAX_VOL,PPS_MIN_VOL;//当前挡位支持的最高最低电压
extern uint8_t PD_STEP;
extern uint8_t now_obj;
extern uint8_t old_obj;
extern uint8_t PD_Source_Capabilities_Inf_num;
extern xdata PD_Source_Capabilities_TypeDef PD_Source_Capabilities_Inf[7];
/* -----------------------------------------应用程序---------------------------------------*/
uint8_t USB302_Init(void);
void USB302_Data_Service(void);//数据服务
void USB302_Read_Data_State(void);
void USB302_Send_Requse(uint8_t objects);
#endif

if (UsbCheck == 0)
        {
            if (SystemInit.USB302_Handshake == 0) //PD协议握手
            {
                SystemInit.USB302_Handshake = USB302_Init();
                /*清除QC协议*/
                SystemInit.QC_Handshake = 0;
                QC_Mode_Choice          = 1;
                QC20_Voltage_Choice     = 0;
                QC_Voltage_Switch();//选择充电协议
            }

            if (SystemInit.QC_Handshake == 0)//QC协议握手
            {
                USBDP_PWM(Voltage_06_PWM);//D+ 0.6V
                USBDM_PWM(0);//D- 0V
                if (time < 250 && ++time > 7)
                {
                    time = 0;
                    QC_Voltage_Switch();//选择充电协议
                    SystemInit.QC_Handshake = 1;
                }
            }
            /************PD协议************/
            if (SystemInit.USB302_Handshake == 1)
            {
                USB302_Read_Data_State();//读取PD消息状态
            }
        }
        else//USB被拔出，清除握手协议
        {
            SystemInit.USB302_Handshake = 0;
            SystemInit.QC_Handshake     = 0;
            SystemReg .RunningState     = 1;//关机
        }

/*********************************************
函数名：StartKeyTask
功  能：按键扫描
形  参：
返回值：
备  注：
作  者：薛建强
时  间：2019/06/06
**********************************************/
void StartKeyTask(void) _task_ 1
{
    uint8_t KEY_state = 0;
    uint16_t time = 0;
    uint8_t i = 0;
    os_wait(K_IVL, 30, 0);//0.01s==100ms
    for (;;)
    {
        KEY_state = Key_Scan(&Key1_Type, 1);
        switch (KEY_state)
        {
            case 1://短按
                /************PD协议************/
                if (SystemInit.USB302_Handshake == 1)
                {
                    if (PD_STEP == 3)//3--数据读取完毕并解析
                    {
                        if (PPS_State > 1)
                        {
                            if (PPS_State == 2) //调整单位：1v
                            {
                                if ((PPS_VOL + 50) <= PPS_MAX_VOL)
                                {
                                    PPS_VOL += 50;
                                }
                            }
                            else if (PPS_State == 3) //调整单位：100mv
                            {
                                if ((PPS_VOL + 5) <= PPS_MAX_VOL)
                                {
                                    PPS_VOL += 5;
                                }
                            }
                            else if (PPS_State == 4) //调整单位：20mv
                            {
                                if (PPS_VOL < PPS_MAX_VOL)
                                {
                                    PPS_VOL += 1;
                                }
                            }
                            USB302_Send_Requse(now_obj);
                        }
                        else
                        {
                            if (now_obj < PD_Source_Capabilities_Inf_num - 1)
                            {
                                now_obj++;
                                PPS_VOL = 5000 / 20; //恢复pps电压
                                USB302_Send_Requse(now_obj);
                            }
                        }
                    }
                }
                /************QC协议************/
                if (SystemInit.QC_Handshake == 1)
                {
                    if (QC_Mode_Choice == 1)
                    {
                        if (QC20_Voltage_Choice < 3 && ++QC20_Voltage_Choice > 2) QC20_Voltage_Choice = 0;
                        if (QC20_Voltage_Choice >= 3)
                        {
                            QC20_Voltage_Choice = 0;
                        }
                        QC_Voltage_Switch();//选择充电电压
                    }
                    else if (QC_Mode_Choice == 2)
                    {
                        QC30_Add_Voltage();
                    }
                }
                break;
            case 2://长按

                break;
            case 3://双击
                /************PD协议************/
                if (SystemInit.USB302_Handshake == 1)
                {
                    if (PPS_State > 1) //2调整1v 3调整100mv 4调整20mv
                    {
                        PPS_State++;
                        if (PPS_State > 4)PPS_State = 2;
                    }
                    else
                    {
                        PPS_State = 2;
                        //进入pps调节模式时，处理一次最高最低电压 报文是100mv级别的
                        PPS_MAX_VOL = PD_Source_Capabilities_Inf[now_obj].PDC_INF[2] >> 1; //高位 最大电压
                        PPS_MIN_VOL = PD_Source_Capabilities_Inf[now_obj].PDC_INF[1]; //低位 最小电压
                        if ((PD_Source_Capabilities_Inf[now_obj].PDC_INF[2] & 0x01) == 1) //第24位 补上
                        {
                            PPS_MAX_VOL |= 0x80;
                        }
                        PPS_MAX_VOL *= 5;
                        PPS_MIN_VOL *= 5; //处理到20mv级别
                    }
                }
                /************QC协议************/
                if (SystemInit.QC_Handshake == 1)
                {
                    if (QC_Mode_Choice < 3 && ++QC_Mode_Choice > 2) QC_Mode_Choice = 0;
                    if (QC_Mode_Choice >= 3)
                    {
                        QC_Mode_Choice = 0;
                    }
                    QC_Voltage_Switch();//选择充电电压
                }
                break;
            default:
                break;
        }
        KEY_state = Key_Scan(&Key2_Type, 2);
        switch (KEY_state)
        {
            case 1://短按
                /************PD协议************/
                if (SystemInit.USB302_Handshake == 1)
                {
                    if (PD_STEP == 3)
                    {
                        if (PPS_State > 1)//2调整1v 3调整100mv 4调整20mv
                        {
                            if (PPS_State == 2) //调整单位：1v
                            {
                                if ((PPS_VOL - 50) >= PPS_MIN_VOL)
                                {
                                    PPS_VOL -= 50;
                                }
                            }
                            else if (PPS_State == 3) //调整单位：100mv
                            {
                                if ((PPS_VOL - 5) >= PPS_MIN_VOL)
                                {
                                    PPS_VOL -= 5;
                                }
                            }
                            else if (PPS_State == 4) //调整单位：20mv
                            {
                                if (PPS_VOL > PPS_MIN_VOL)
                                {
                                    PPS_VOL -= 1;
                                }
                            }
                            USB302_Send_Requse(now_obj);
                        }
                        else
                        {
                            if (now_obj > 0)
                            {
                                now_obj--;
                                PPS_VOL = 5000 / 20; //恢复pps电压
                                USB302_Send_Requse(now_obj);
                            }
                        }
                    }
                }
                /************QC协议************/
                if (SystemInit.QC_Handshake == 1)
                {
                    if (QC_Mode_Choice == 1)
                    {
                        if (QC20_Voltage_Choice > 0)
                        {
                            --QC20_Voltage_Choice;
                        }
                        QC_Voltage_Switch();//选择充电电压
                    }
                    if (QC_Mode_Choice == 2)
                    {
                        QC30_Reduce_Voltage();
                    }
                }
                break;
            case 2://长按

                break;
            case 3://双击
                /************PD协议************/
                if (SystemInit.USB302_Handshake == 1)
                {
                    if (PPS_State > 2) //2调整1v 3调整100mv 4调整20mv
                    {
                        PPS_State--;
                    }
                }
                if (SystemInit.QC_Handshake == 1)
                {
                    if (QC_Mode_Choice < 3 && ++QC_Mode_Choice > 2) QC_Mode_Choice = 0;
                    if (QC_Mode_Choice >= 3)
                    {
                        QC_Mode_Choice = 0;
                    }
                    QC_Voltage_Switch();//选择充电电压
                }
                break;
            default:
                break;
        }

        os_wait(K_IVL, 10, 0);//0.01s==10ms
    }
}