EFTZ_PMU/user_src/soft_engine.c

#include "soft_engine.h"
#include "soft_crc.h"
#include "crc.h"
#include "string.h"
#include "usart_data_handle.h"

struct ENGINE_DATA engine_data;


//串口接收奥安发动机数据
AOAN_TYPE aoan_data = {0, .engin_warn = 0xffff};
Connect_check aoan_engine_Link;
//解析奥安油电混传感器数据
short decode_aoan_engine(uint8_t *pdata, uint16_t length)
{

    short rst = 0;

    if (pdata[0] == 0x5A && pdata[1] == 0xA5 && pdata[2] == 0x1A && pdata[3] == 0x02)
    {
        unsigned char dNum = pdata[2];

        //校验通过。
        if (Get_Crc16(pdata, dNum + 5) == 0)
        {
            rst = 1;

            aoan_engine_Link.connect_status = COMP_NORMAL;

            //赋值数据
            memcpy(&aoan_data, &pdata[3], dNum);

            aoan_engine_Link.recv_time = HAL_GetTick();

        }
    }

    return rst;
}

//串口接收VKV3发动机数据
VKV3_TYPE vkv3_data = {0, .engin_warn = 0xffff};
Connect_check vkv3_engine_link;

//解析V3协议油电混传感器数据
short  decode_vkv3_engine(uint8_t *pdata, uint16_t length)
{
    short rst = 0;

    if (pdata[0] == 0x5A && pdata[1] == 0xA5 && pdata[2] == 0X27 && pdata[4] == 0X03)
    {
        unsigned char dLEN = pdata[2];
        unsigned char comID = pdata[3];

        //校验通过。
        if (Get_Crc16(pdata, dLEN + 6) == 0)
        {
            rst = 1;

            switch (comID)
            {
            case 0X01:
                vkv3_engine_link.connect_status = COMP_NORMAL;
                //赋值数据
                memcpy(&vkv3_data, &pdata[4], dLEN);
                break;
            default:
                break;
            }
            vkv3_engine_link.recv_time = HAL_GetTick();
        }
    }

    return rst;
}







bool geely_set_tcd = false,geely_set_tcd_re = false, 
     geely_set_tlock = false, geely_set_tlock_re = false, geely_set_protect = false,
     geely_send_time = false, geely_get_sys = false,geely_get_version = false,geely_get_time = false;
GEELY2 geely_data2;
//解析吉利发动机
GEELY geely_data = {0};
GEELY_MONI geely_moni = {0};


Connect_check geely_engin_link;

void EngGeelyCanRecvHookFunction(uint32_t cellCanID, uint8_t data[], uint8_t len)
{
    if (cellCanID == 0x1c0)
    {
        memcpy(&geely_data.engine_ver, &data[0], len);
    }
    else if (cellCanID == 0x1c1)
    {
        //木牛防地雷达会异常进入发动机识别
        geely_engin_link.connect_status = COMP_NORMAL;
        
        memcpy(&geely_data.engine_rev, &data[0], len);
    }
    else if (cellCanID == 0x1c2)
    {
        memcpy(&geely_data.engine_vol, &data[0], len);
    }
    else if (cellCanID == 0x1c3)
    {
        uint8_t checkSum = 0;
        for (uint8_t i = 0; i < 8; i++)
        {
            checkSum += data[i];
        }

        geely_moni.recv_1c3++;

        if (checkSum == 0)
        {
            memcpy(&geely_data.engine_control, &data[0], len);

            if (geely_moni.msg1c3_last + 1 != geely_data.engine_counts)
            {
                geely_moni.msg1c3_indexerr++;
            }
            geely_moni.msg1c3_last = geely_data.engine_counts;
            
            
            if(geely_data.engine_set == 0x11)
            {
                //接收保养时间反馈
                if(geely_set_tcd == true)
                {
                    geely_set_tcd = false;
                    geely_set_counts = 0;
                    
                    geely_set_tcd_re = true;
                }
            }
            if(geely_data.engine_set == 0x12)
            {
                //接收保养时间复位反馈
                if(geely_set_tcd_re == true)
                {
                    geely_set_tcd_re = false;
                    geely_set_counts = 0;
                }
            }
            if(geely_data.engine_set == 0x14)
            {
                //接收锁机时间反馈
                if(geely_set_tlock == true)
                {
                    geely_set_tlock = false;
                    geely_set_counts = 0;
                    
                    geely_set_tlock_re = true;
                }
            }
            if(geely_data.engine_set == 0x15)
            {
                //接收锁机时间复位反馈
                if(geely_set_tlock_re == true)
                {
                    geely_set_tlock_re = false;
                    geely_set_counts = 0;
                }
            }
            if(geely_data.engine_set == 0x17)
            {

            }
        }
        else
        {
            geely_moni.msg1c3_sumerr++;
        }
    }
    else if (cellCanID == 0x1c4)
    {
        memcpy(&geely_data.engine_runtime, &data[0], len);
    }
    else
    {
        if(cellCanID >= 0x1E1 && cellCanID <= 0x1EF)
        {
            geely_engin_link.connect_status = COMP_NORMAL;
            if(geely_data2.version2_flag != true)
            {
             geely_data2.version2_flag = true;
            } //作为第二版协议标志
        }
        //第二版协议
        switch (cellCanID)
        {
        case 0x1E1:
            
            break;
        case 0x1E2:
            geely_get_version = true;
            geely_count = 10;
            memcpy(&geely_data2.engine_ver,&data[0],8);
            break;
        case 0x1E3:
            geely_get_time = true;
            //geely_count = 10;
            memcpy(&geely_data2.engine_runtime,&data[0],8);
            break;
        case 0x1E4:
            memcpy(&geely_data2.Bit1E4,&data[0],6);
            break;
        case 0x1E8:
            memcpy(&geely_data2.engine_time,&data[0],8);
            break;
        case 0x1E9:
            memcpy(&geely_data2.engine_rev,&data[0],8);
            break;
        case 0x1EA:
            memcpy(&geely_data2.Bit1EA,&data[0],8);
            break;
        case 0x1EB:
            memcpy(&geely_data2.FuelConsumption,&data[0],8);
            break;
        case 0x1ED:
            memcpy(&geely_data2.AlmST0,&data[0],8);
            break;
        case 0x1EE:
            memcpy(&geely_data2.Gear1Position,&data[0],7);
            break;    
        
        default:
            break;
        }
    }

    geely_engin_link.recv_time = HAL_GetTick();
}

short geely_set_counts = 0;
#pragma pack(1)
typedef struct
{
    uint32_t time;
    uint8_t nodecode:4;
    uint8_t message_conut0:4;
    int8_t check_sum0;

    uint8_t client_cmd;
    uint8_t syscontrol;
    uint8_t reserve0;
    uint8_t reserve1;
    uint32_t reserve2:20;
    uint8_t message_conut1:4;
    int8_t check_sum1;
}geely_info2;
geely_info2 geely_sendinfo2;
#pragma pack()

uint8_t geely_count = 15;
uint8_t start_engine = 1; // 0x80启动 0停止


#define SENDTO_GEELY_STATUS_ID  (0X1A0)

STO_GEELY sendto_geely = {.ExtenderControl = 0,
                          .ExtenderSetting = 0x10,
                          .SettingParameter = 0,
                          .ExtenderBak = 0,
                          .MessageCount = 0
                         };

uint32_t sendto_geely_lasttime = 0;



void send_msg_to_geely(void)
{
    if (geely_engin_link.connect_status == COMP_NORMAL && HAL_GetTick() - sendto_geely_lasttime > 100)
    {
        uint8_t geely[8] = {0};

        sendto_geely_lasttime = HAL_GetTick();

        //Geely_version2_init();
        if(geely_data2.version2_flag == true)
        {
            //Geely_version2_send_info(); 
        }
        else
        {
            sendto_geely.ExtenderBak = planep.thr_pwm;
            sendto_geely.DroneStatus = (uint8_t)planep.lock_status; //(thr_lock_status == LOCKED ? 0 : 1);
            sendto_geely.MessageCount++;

            if(geely_set_tcd == true)
            {
                geely_set_counts++;
                if(geely_set_counts > 5){
                    geely_set_tcd = false;
                    geely_set_counts = 0;
                }
                
                sendto_geely.ExtenderSetting = 0x11;
                //sendto_geely.SettingParameter = 0;
            }
            else if(geely_set_tcd_re == true)
            {
                geely_set_counts++;
                if(geely_set_counts > 5){
                    geely_set_tcd_re = false;
                    geely_set_counts = 0;
                }
                
                sendto_geely.ExtenderSetting = 0x12;
                sendto_geely.SettingParameter = 0;
            }
            else if(geely_set_tlock == true)
            {
                geely_set_counts++;
                if(geely_set_counts > 5){
                    geely_set_tlock = false;
                    geely_set_counts = 0;
                }
                
                sendto_geely.ExtenderSetting = 0x14;
                //sendto_geely.SettingParameter = 0;
            }
            else if(geely_set_tlock_re == true)
            {
                geely_set_counts++;
                if(geely_set_counts > 5){
                    geely_set_tlock_re = false;
                    geely_set_counts = 0;
                }
                
                sendto_geely.ExtenderSetting = 0x15;
                sendto_geely.SettingParameter = 0;
            }
            else if(geely_set_protect == true)
            {
                geely_set_counts++;
                if(geely_set_counts > 5){
                    geely_set_protect = false;
                    geely_set_counts = 0;
                }
                sendto_geely.ExtenderSetting = 0x17;
                sendto_geely.SettingParameter = 0;
            }
            else
            {
                sendto_geely.ExtenderSetting = 0x10;
                sendto_geely.SettingParameter = 0;
                
                geely_set_counts = 0;
            }
            
            memcpy(geely, (uint8_t *)&sendto_geely.ExtenderControl, 7);

            sendto_geely.CheckSum = 0;
            for (uint8_t i = 0; i < 7; i++)
            {
                sendto_geely.CheckSum += geely[i];
            }
            sendto_geely.CheckSum = -sendto_geely.CheckSum;

            //can_send_msg_normalstd(&sendto_geely.ExtenderControl, sizeof(sendto_geely), SENDTO_GEELY_STATUS_ID);

            geely_moni.send_1a0++;
        }
    }
}




comp_status engine_link_status = COMP_NOEXIST;

struct ENGINE_DATA engine_data = {0, 0};
/*
发动机类型	    uint8		1-瑞深 2-中飞
发动机转速	    uint16_t		RPM
发动机油门	    uint16_t
发动机电压	    uint16_t	0.1v
充电电流	    uint16_t	0.1A
发动机运行时间	uint32_t	Min	总运行时间不清零
剩余保养时间	uint16_t	Min	保养后清零
剩余锁机时间	uint16_t	Min	锁机倒计时
运行状态 	    uint8_t		0:停止，1:等待，2:运行, 3:锁机
报警信息	    uint16_t		按位来表示可同时容纳16种警报
剩余油量	    uint8_t	%	0%-100%
气缸1温度	    uint16_t	℃	0℃~300℃
气缸2温度	    uint16_t	℃	0℃~300℃
PCB温度	        uint8_t	℃	0℃~255℃
*/


/*
检查智能电池的连接及数据获取,主要解决兼容多厂家设备接入时的选用优先级问题。

更新速度至少要 5hz

缺少放电电流数据
*/
void update_engine_data(void)
{

    //监测中飞发动机
    Check_dev_link(&aoan_engine_Link,5000,(char *)&aoan_data,sizeof(AOAN_TYPE));
    //监测VKV3的发动机
    Check_dev_link(&vkv3_engine_link,5000,(char *)&vkv3_data,sizeof(VKV3_TYPE));
    //检测GEELY发动机
    Check_dev_link(&geely_engin_link,5000,(char *)&geely_data,sizeof(GEELY));

    if (aoan_engine_Link.connect_status == COMP_NORMAL)
    {
        engine_link_status = COMP_NORMAL;

        //数字显示,显示9位数
        engine_data.engine_type = 2;
        engine_data.engine_rev = aoan_data.engin_rev;
        engine_data.engine_thr = aoan_data.engin_thr;
        engine_data.engine_vol = aoan_data.engin_vol;
        engine_data.engine_elect = aoan_data.engin_elect;
        engine_data.engine_rtime = aoan_data.engin_rtime;
        engine_data.engine_tcd = aoan_data.engin_tcd;
        engine_data.engine_lcd = aoan_data.engin_lcd;
        engine_data.engine_rsta = aoan_data.engin_rsta;
        engine_data.engine_warn = aoan_data.engin_warn;
        engine_data.engine_roil = aoan_data.engin_roil;
        engine_data.engine_cyl1temp = aoan_data.engin_cyl1temp;
        engine_data.engine_cyl2temp = aoan_data.engin_cyl2temp;
        engine_data.engine_pcbtemp = aoan_data.engin_pcbtemp;
        memcpy(engine_data.engine_brand, "AOAN", 4);
    }
    else if (vkv3_engine_link.connect_status == COMP_NORMAL)
    {
        engine_link_status = COMP_NORMAL;

        //数字显示,显示9位数
        engine_data.engine_type = 3;
        engine_data.engine_rev = vkv3_data.engin_rev;
        engine_data.engine_thr = vkv3_data.engin_thr;
        engine_data.engine_vol = vkv3_data.engin_vol;
        engine_data.engine_elect = vkv3_data.engin_elect;
        engine_data.engine_rtime = vkv3_data.engin_rtime;
        engine_data.engine_tcd = vkv3_data.engin_tcd;
        engine_data.engine_lcd = vkv3_data.engin_lcd;
        engine_data.engine_rsta = vkv3_data.engin_rsta;
        engine_data.engine_warn = vkv3_data.engin_warn;
        engine_data.engine_roil = vkv3_data.engin_roil;
        engine_data.engine_cyl1temp = vkv3_data.engin_cyl1temp;
        engine_data.engine_cyl2temp = vkv3_data.engin_cyl2temp;
        engine_data.engine_pcbtemp = vkv3_data.engin_pcbtemp;
        engine_data.engine_sn = vkv3_data.engin_sn;
        memcpy(engine_data.engine_brand, vkv3_data.engin_brand, 8);
    }
    else if (geely_engin_link.connect_status == COMP_NORMAL)
    {
        engine_link_status = COMP_NORMAL;

        engine_data.engine_type = 4;

        //数字显示,显示9位数
        if(geely_data2.version2_flag != true)
        {
            engine_data.engine_rev = geely_data.engine_rev;
            engine_data.engine_thr = geely_data.engine_thrposition * 0.1f;
            engine_data.engine_vol = geely_data.engine_vol * 2;
            engine_data.engine_elect = (short)(geely_data.engine_elect - 1000) * 2;
            engine_data.engine_rtime = geely_data.engine_runtime;
            engine_data.engine_tcd = geely_data.engine_tcd;
            engine_data.engine_lcd = geely_data.engine_tlock;
            engine_data.engine_rsta = geely_data.engine_status;
            engine_data.engine_warn = geely_data.engine_warn & 0xffef;//屏蔽总线系统异常
            engine_data.engine_roil = geely_data.engine_fuelposition * 0.5f;
            engine_data.engine_cyl1temp = geely_data.engine_cyltemp - 40;
            engine_data.engine_cyl2temp = 0;
            engine_data.engine_pcbtemp = geely_data.engine_cooltemp - 40;
            memcpy(engine_data.engine_brand, geely_data.engine_brand, 3);
            memcpy(&engine_data.engine_brand[3],"-", 1);
            snprintf((char *)&engine_data.engine_brand[4],4,"%d",(int)geely_data.engine_ver);
            engine_data.engine_sn = geely_data.engine_sn[0] * 10000000 + geely_data.engine_sn[1] * 100000 +
                                    geely_data.engine_sn[2] * 1000 + geely_data.engine_sn[3];
            engine_data.engine_lockstatus = geely_data.engine_control;
        }
        else
        {
            engine_data.engine_rev = geely_data2.engine_rev;
            engine_data.engine_thr = geely_data2.Bit1EA.engine_ATP1 * 0.05f;
            engine_data.engine_vol = geely_data2.engine_vol * 0.1f;
            engine_data.engine_elect = (short)(geely_data2.engine_elect * 0.05f - 400) * 10;
            engine_data.engine_rtime = geely_data2.engine_runtime;
            engine_data.engine_tcd = geely_data2.engine_tcd;
            engine_data.engine_lcd = geely_data2.engine_tlock;
            engine_data.engine_rsta = geely_data2.engine_state;
            engine_data.engine_warn = geely_data2.ErrST0 +  geely_data2.EmgST1;
            engine_data.engine_roil = geely_data2.GPS * 0.5f;
            engine_data.engine_cyl1temp = geely_data2.engine_cooltemp - 40; 
            engine_data.engine_cyl2temp = geely_data2. engine_cooltemp1 - 40;
            engine_data.engine_pcbtemp = geely_data2.engine_GWT - 40;
            memcpy(engine_data.engine_brand, geely_data2.engine_brand, 3);
            memcpy(&engine_data.engine_brand[3],"-", 1);
            snprintf((char *)&engine_data.engine_brand[4],4,"%d",(int)geely_data2.engine_ver);
            engine_data.engine_sn = geely_data2.engine_sn[0] * 10000000 + geely_data2.engine_sn[1] * 100000 +
                                    geely_data2.engine_sn[2] * 1000 + geely_data2.engine_sn[3];
            engine_data.engine_lockstatus = geely_data2.engine_Mcontrol;

        }


        
    }
    else
    {
        if (engine_link_status == COMP_NORMAL)
        {
            engine_link_status = COMP_LOST;

            memset(&engine_data, 0, sizeof(engine_data));
            //状态未置异常
            engine_data.engine_type = 0xFF;
        }
    }
}


/******************void engine_function(void)********************
 * ****************发动机检测函数*********************************
 * **************************************************************/
void engine_function(void)
{
    static uint32_t engine_time = 0;

    if(Check_Timer_Ready(&engine_time,_10_HZ_))
	{
		update_engine_data();
	}

    //给吉利发动机发送信息
    send_msg_to_geely();
}