roadsimulate.c

汽车测功机源肛码.单片机用的是LPC2104. 实现测速,对涡流机的控制,马达的控制.

/****************************************Copyright (c)**************************************************
**                                 温州江兴汽车检测设备厂
**                                     研  发  中  心
**                                        
**
**                                 http://www.JiangXingAuto.com
**
**--------------文件信息--------------------------------------------------------------------------------
**文   件   名: 
**创   建   人: 周川福
**最后修改日期: 
**描        述: 
**              
**--------------历史版本信息----------------------------------------------------------------------------
** 创建人: 
** 版  本: v1.0
** 日　期: 
** 描　述: 
**
**------------------------------------------------------------------------------------------------------
** 修改人: 
** 版  本: v1.1
** 日　期: 
** 描　述: 
**
**--------------当前版本修订-----------------------------------------------------------------------------
** 修改人: 
** 日　期: 
** 描　述: 
**
**------------------------------------------------------------------------------------------------------
********************************************************************************************************/
#include "CGJ.H"                // 包含项目头文件
#include <math.h>               // 包含算术运算头文件
#include "control.h"            // 包含控制任务所共有的头文件
#include "DataBuffer.h"

#define     SIMUL_TABLE_SIZE    22

typedef struct {
    INT16U      Weight;         // 车辆基准质量
    INT16U      Inertia;        // 当量惯量
    FP32        Power;          // 加载功率
    INT16U      N;              // 加载扭距
    FP32        a;              // 系数a
    FP32        b;              // 系数b
}SIMULATE_LOAD_RECORD;

static const   SIMULATE_LOAD_RECORD    SimulateLoadTbl[SIMUL_TABLE_SIZE] = {
                                        {480, 455, 3.8, 171, 3.8, 0.0261},
                                        {540, 510, 4.1, 185, 4.2, 0.0282},
                                        {595, 570, 4.3, 194, 4.4, 0.0296},
                                        {650, 625, 4.5, 203, 4.6, 0.0309},
                                        {710, 680, 4.7, 212, 4.8, 0.0323},
                                        {765, 740, 4.9, 221, 5.0, 0.0337},
                                        {850, 800, 5.1, 230, 5.2, 0.0351},
                                        {965, 910, 5.6, 252, 5.7, 0.0385},
                                        {1080, 1020, 6.0, 270, 6.1, 0.0412},
                                        {1190, 1130, 6.3, 284, 6.4, 0.0433},
                                        {1305, 1250, 6.7, 302, 6.8, 0.0460},
                                        {1420, 1360, 7.0, 315, 7.1, 0.0481},
                                        {1530, 1470, 7.3, 329, 7.4, 0.0502},
                                        {1640, 1590, 7.5, 338, 7.6, 0.0515},
                                        {1760, 1700, 7.8, 351, 7.9, 0.0536},
                                        {1870, 1810, 8.1, 365, 8.2, 0.0557},
                                        {1980, 1930, 8.4, 378, 8.5, 0.0577},
                                        {2100, 2040, 8.6, 387, 8.7, 0.0591},
                                        {2210, 2150, 8.8, 396, 8.9, 0.0605},
                                        {2380, 2290, 9.0, 405, 9.1, 0.0619},
                                        {2610, 2490, 9.4, 423, 9.5, 0.0646},
                                        {2611, 2490, 9.8, 441, 9.9, 0.0674}
                                                                    };

/*********************************************************************************************************
** 函数名称: RoadSimulTask()
** 功能描述: 道路模拟阻力控制任务，道路模拟阻力根据VMAS控制的要求，在测功机上根据速度的变化实时加载！
**           
** 输　入  : 无
** 输　出  : 无
** 全局变量: 无
** 调用模块: 无
** 
** 作　者: 周川福
** 日　期: 2006-04-20
**-------------------------------------------------------------------------------------------------------
** 修　改: 
** 日　期: 
**-------------------------------------------------------------------------------------------------------
********************************************************************************************************/
void    RoadSimulTask(void *pdata)
{
    INT8U       err, i, j, l;                                               //
    INT8U       time;
    OS_FLAGS    flag;                                                       // 事件标志组变量
    BOOLEAN     begin, over;                                                // 
    INT32U      weight, force_real_value;                                   //
    FP32        ForceOut, a, b, speed_real_value, Aver_Speed;               //
    FP32        ControlForce;                                               //

    FP32        FirstSpeed, CurrSpeed;
    INT32U      AccelTick;
    
    
    while(TRUE) {

        begin = FALSE;
        over   = FALSE;

        while(TRUE) {
            flag = OSFlagPend(task_status,
                              SIMULATE_FLAG,
                              OS_FLAG_WAIT_SET_ANY + OS_FLAG_CONSUME,
                              0,
                              &err);
            switch (flag) {
                case START_SIMULATE:
                    IGBT_SetPeriodCount(0);

                    OS_ENTER_CRITICAL();

                    OSTaskSuspend(WAIT_TASK_PRIO);                          // 删除空闲等待任务
                    OSTaskSuspend(POWER_TASK_PRIO);                         // 删除恒功率任务
                    OSTaskSuspend(SPEED_TASK_PRIO);                         // 删除恒速度任务
                    OSTaskSuspend(DEMA_TASK_PRIO);                          // 删除标定任务
                    OSTaskSuspend(FORCE_TASK_PRIO);                         // 删除恒扭距任务

                    OS_EXIT_CRITICAL();

                    begin = TRUE;
                    SendProgramRunStatus(ENTER_ROAD_SIMULATE);
                    break;
                case SET_SIMULATE:

                    weight = set_control_value;
                    SendProgramRunStatus(SIMULATE_SET_SUCCESS);
                    break;
                default:
                    break;
            }
                                
            if(begin == TRUE) break;
        }

        l        = 0;
        ForceOut = 0;
        time     = 0;

        weight = 0;
        speed_real_value = 0;
        force_real_value = 0;

        FirstSpeed = 0;
        CurrSpeed  = 0;

        AccelTick  = 0;
        

        while(TRUE) {
            flag = OSFlagAccept(task_status,                                // 调用无等待获得事件标志组中的事件标志函数 
                                SIMULATE_FLAG,
                                OS_FLAG_WAIT_SET_ANY + OS_FLAG_CONSUME,
                                &err);

            switch(flag) {
                case SET_SIMULATE: {
                    weight = set_control_value;
                    SendProgramRunStatus(SIMULATE_SET_SUCCESS);
                    break;
                }
                case STOP_SIMULATE: {
                    over = TRUE;                                            // 结束
                    IGBT_SetPeriodCount(0);
                    IGBT_Disable();
                    
                    OSTaskResume(FORCE_TASK_PRIO);                          // 唤醒恒力任务
                    OSTaskResume(SPEED_TASK_PRIO);                          // 唤醒恒数任务
                    OSTaskResume(DEMA_TASK_PRIO);                           // 唤醒标定任务
                    OSTaskResume(POWER_TASK_PRIO);                          // 唤醒恒功率任务
                    OSTaskResume(WAIT_TASK_PRIO);                           // 唤醒等待任务

                    SendProgramRunStatus(EXIT_ROAD_SIMULATE);

                    OS_ENTER_CRITICAL();
                        task_status->OSFlagFlags = 0;                       // 在退出速度控制前,清除事件标志组
                    OS_EXIT_CRITICAL();

                    break;
                }
                default:
                    break;
            }

            if(over == TRUE) {
             break;
            }


            j = 0;
            for(i = 0; i < SIMUL_TABLE_SIZE; i++) {
                j = i;
                if(weight <= SimulateLoadTbl[i].Weight) {
                    break;
                }
                
            }

            if(speed_real_value > 10){
                CountSpeed();
                time = 0;
            }else if(++time >= COUNT_SPEED_TIME){
                time = 0;
                CountSpeed();                                               // 计算速度
            }

            CountForce();
            

            force_real_value = parameter[FORCE];
            speed_real_value = parameter[SPEED];

            a = SimulateLoadTbl[j].a;
            b = SimulateLoadTbl[j].b;

            //公式：a + b*v*v
            ControlForce = a + b * Aver_Speed * Aver_Speed;
          //  ControlForce = a + b * speed_real_value * speed_real_value;
          

            if(Aver_Speed > 10) {
                
                ForceOut = PidCalc(force_real_value, ControlForce);

                IGBT_Enable();
                IGBT_SetPeriodCount((INT32U)ForceOut);
                    
            }else {
                ForceOut = 0;
                IGBT_SetPeriodCount(0);
                IGBT_Disable();

                PidValueReset();
            }

            // 将当前速度值与力值插入缓冲区
            InsertSpeedPoint(parameter[SPEED]);
            InsertForcePoint(parameter[FORCE]);
            
            // 判断是否到了向上位机送数时间
            if(++l == SEND_DELAY_TIME){                                     // 向上位机送出检测到的数据
                l = 0;                                                      // 向上位机送数据计时器清0
                
                OS_ENTER_CRITICAL();
                parameter[SPEED] = GetAdverOfSpeed();                       // 得到速度的平均值
                parameter[FORCE] = GetAdverOfForce();                       // 得到力的平均值
                                
                parameter[POWER] = parameter[SPEED] * parameter[FORCE] / 360 / 10;

                Aver_Speed = parameter[SPEED];

                // 计算加速度
                CurrSpeed = parameter[SPEED];

                OS_EXIT_CRITICAL();
                
                SendRealParaToComputer();
            }

            if(++AccelTick == 100) {
                AccelTick = 0;

                OS_ENTER_CRITICAL();

                if(CurrSpeed > 5) {
                    parameter[JSD] = (CurrSpeed - FirstSpeed) * 1000 / 3600;
                }else {
                    parameter[JSD] = 0;
                }

                OS_EXIT_CRITICAL();

                FirstSpeed = CurrSpeed;

            }

            OSTimeDly(TASK_DELAY_TIME);                                     // 将任务挂起2个节拍

        }

    }
}