自己写的流量波动检测函数

/*******************************************************************************
* Function Name  : powerdownA_task(void)
* Description    : 记录A路断电的数据
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
#include "state_task.h"
#include "task_control.h"
#include "24cxx.h"
#include "data.h"
#include "delay.h"
#include "iwdg.h"

//20190525
#include     "GUI_task.h"

OS_EVENT *mutex_eeprom;
/*******************************************************************************
* Function Name  : state_task
* Description    : 计算流量的状态  得到流量的变化趋势
* Input          : None
* Output         : None
* Return         : None
* Author         : Aision
* Attention      : 
//  时间轴  T1  T2  T3
*******************************************************************************/

//gf_QrT[X]  x越大代表当前数据越新  数组存储的为第[X]秒的流量

float gf_QrT[C_QrT]=0.0f;

//求当前最新的流量和dRange-x次时间前的流量的差值  
/*
              gf_dQrsec[0]  = gf_QrT[dRange]   -  gf_QrT[dRange-1];//6-5    第6s和第5s的流量变化
              gf_dQrsec[1]  = gf_QrT[dRange]   -  gf_QrT[dRange-2];//6-4    第6s和第4s的流量变化
              gf_dQrsec[2]  = gf_QrT[dRange]   -  gf_QrT[dRange-3];//6-3    
              gf_dQrsec[3]  = gf_QrT[dRange]   -  gf_QrT[dRange-4];//6-2        
                gf_dQrsec[4]  = gf_QrT[dRange]   -  gf_QrT[dRange-5];//6-1        
*/
extern pid_TypeDef pid;
float gf_dQrsec[C_QrT] = 0.0f;
float gf_PwmT[C_QrT]   = 0.0f;
//20190601 更改低级错误 定义时  x【6】 索引最大到5
float gf_DragRank[dRange+1] = 0.0f;
//20190604 每秒的相对于设定流量的偏差值
float gf_dQrsecErr[C_QrT] = 0.0f;



//状态位：  
//1：  当前流量为0  
u16  gu16_FlagQrZero =0;
//空载  =0： 非空载   =1：空载
u8   gu8A_FlagEmptyDrag = 0;
//反应系统状态的标志位  0：无波动  1：波动幅度超过上下限阈值的波动 2：只在超上限区域波动  3：只在超下限区域波动
u8  gu8_StatesQrWave = 0;  



u8 gu8_FlagQrWaveHigh = 0;
u8 gu8_FlagQrWaveLow  = 0;
//Flag index
int16_t gi16_FlagQrWaveTsec = 0;

u8 gu8_StatusQrLast = 0;

u8 gu8_QrWavePeriod =0;

u8 gu8_StatusQrWave= 0;

u8 gu8_CntQrWave= 0;

//20190525  timer
u16  gu16_Cnt = 0;

u8 gu8_FlagQrStabliz=0;
void state_task(void *pdata)
{
    
    u8 err;    
    u8 lu8_Cnt=0;
    u8 lu8_CntStab=0;
    u8 l_i=0;

    
    for(;;)
    {        
                //流量稳定性判断AB-1
              //A
                gf_QrT[C_QrT-1]  = Instru_Data.QT;
                gf_PwmT[C_QrT-1] = pid.OutputValue;
                gf_dQrsecErr[C_QrT-1] = pid.Err;    

                // 第6s和第4s的 流量之差   除以  PWM  之差
                if( (( (u16)gf_PwmT[C_QrT-1] - (u16)gf_PwmT[C_QrT-2] )) > 1  )
                {
                        gf_DragRank[0] = (gf_QrT[C_QrT-1] - gf_QrT[C_QrT-2]) / ( (u16)gf_PwmT[C_QrT-1] - (u16)gf_PwmT[C_QrT-2] ) ;
                }
                else{}
//                     gf_DragRank[0] = (gf_QrT[dRange] - gf_QrT[dRange-2]) / ( (u16)gf_PwmT[dRange] - (u16)gf_PwmT[dRange-2] ) ;

                //C_Qrt =13
                // 此处一共记录C_QrT秒的瞬时流量值 那么gf_dQrsec 最大记录C_QrT-1个数据  因为是从【0】开始的 所以角标最大到C_Qrt-2
                for(l_i=0;l_i<=C_QrT-2;l_i++)    
                        gf_dQrsec[l_i] = gf_QrT[C_QrT-1] - gf_QrT[C_QrT-l_i-2];
                
//               gf_dQrsec[0]  = gf_QrT[C_QrT-1]   -  gf_QrT[C_QrT-2];//12-11  
//               gf_dQrsec[1]  = gf_QrT[dRange]   -  gf_QrT[dRange-2]; //6-4
//               gf_dQrsec[2]  = gf_QrT[dRange]   -  gf_QrT[dRange-3]; //6-3    
//               gf_dQrsec[3]  = gf_QrT[dRange]   -  gf_QrT[dRange-4]; //6-2        
//                 gf_dQrsec[4]  = gf_QrT[dRange]   -  gf_QrT[dRange-5]; //6-1        
             //B
                for(lu8_Cnt=0;lu8_Cnt<4;lu8_Cnt++)
                {
                    if ( (gf_dQrsec[lu8_Cnt]<0.1f)&&(gf_dQrsec[lu8_Cnt]>-0.1f) )
                    {
                            lu8_CntStab++;
                    }
                    else
                    {
                            lu8_CntStab = 0;
                    }
                    if(lu8_CntStab>3)
                    {
                            gu8_FlagQrStabliz = 1;
                    }
                    else
                    {
                            gu8_FlagQrStabliz = 0;                            
                    }
                    
                }

                //20190525C-1 
                //流量为0判断  当前一秒的流量为0 且前一秒也为0 
                if( (gf_QrT[C_QrT-1]>-0.01f) && (gf_QrT[C_QrT-1]<0.01f) && (gf_QrT[C_QrT-2]>-0.01f ) &&( gf_QrT[C_QrT-2]<0.01f )   )
                {
                        gu16_FlagQrZero = 1;
                }
                else
                {
                        gu16_FlagQrZero = 0;
                }
                //\\\\流量为0判断                
                
                for(l_i=C_QrT ;l_i>1; l_i--)    
                    gf_QrT[C_QrT - l_i]   =gf_QrT[C_QrT- l_i + 1];  // 0=1  -> 11=12
//                     gf_QrT[C_QrT-i]   =gf_QrT[C_QrT-i+1];// 1=2
//                     gf_QrT[dRange-4]  =gf_QrT[dRange-3];// 2=3    
//                     gf_QrT[dRange-3]  =gf_QrT[dRange-2];// 3=4    
//                     gf_QrT[dRange-2]  =gf_QrT[dRange-1];// 4=5        
//                     gf_QrT[dRange-1]  =gf_QrT[dRange];  // 5=6    
                
                for(l_i=C_QrT ;l_i>1; l_i--)    
                    gf_PwmT[C_QrT-l_i]   =gf_PwmT[C_QrT-l_i+1];    // 0=1    -> 11=12
//                 gf_PwmT[dRange-5]  =gf_PwmT[dRange-4];// 1=2
//                 gf_PwmT[dRange-4]  =gf_PwmT[dRange-3];// 2=3    
//                 gf_PwmT[dRange-3]  =gf_PwmT[dRange-2];// 3=4    
//                 gf_PwmT[dRange-2]  =gf_PwmT[dRange-1];// 4=5        
//                 gf_PwmT[dRange-1]  =gf_PwmT[dRange];  // 5=6    
                    
                for(l_i=C_QrT ;l_i>1; l_i--)    
                    gf_dQrsecErr[C_QrT-l_i]   =gf_dQrsecErr[C_QrT-l_i+1];    // 0=1    -> 11=12                
                
                //流量稳定性判断AB-1 OVER            
                

                
                //20190525B-1 
                //START 滤膜阻力判断 D-START
                if(gu16_Cnt == 1)
                {
                        gu16_Cnt=0;
                        
                        if( (Instru_Data.LiuYaT>5.0f) & ( Instru_Data.PrT >-0.01f ) & (Instru_Data.QT >BIAO.SetQT)  )  //是空载
                        {
                                gu8A_FlagEmptyDrag = 1;
                            
                        }
                        else
                        {
                                gu8A_FlagEmptyDrag = 0;
                        }
                        


                        
                        if(gu8_StatusQrLast == 1)  //上次检测到太小了
                        {
//                                 gu8_QrWavePeriod = gi16_FlagQrWaveTsec;
                                if(pid.Err< (-BIAO.SetQT*0.02f) ) //此时流量太大
                                {
                                        gu8_StatusQrWave = 1; //置位流量波动标志位 表示发生了波动            
                                        gu8_QrWavePeriod = gu8_CntQrWave;
                                        gu8_CntQrWave =0; //清零技术位 以备下一次计数
                                        gu8_StatusQrLast = 0;
                                        //break;
                                }    
                                gu8_CntQrWave++;    
                                if(gu8_CntQrWave>(C_QrT-2)) //未发现有大波动 gu8_CntQrWave 最大为C_QrT-1
                                    gu8_CntQrWave = 0;
                        }    
                        else if(gu8_StatusQrLast == 2)
                        {
                                if( pid.Err>(BIAO.SetQT*0.02f) ) //此时流量太小
                                {
                                        gu8_StatusQrWave = 1;
                                        gu8_QrWavePeriod = gu8_CntQrWave;
                                        gu8_CntQrWave =0; //清零技术位 以备下一次计数                                    
                                      gu8_StatusQrLast = 0;
                                        //break;
                                }
                                gu8_CntQrWave++;    
                                if(gu8_CntQrWave>(C_QrT-2)) //未发现有大波动 gu8_CntQrWave 最大为C_QrT-1
                                    gu8_CntQrWave = 0;
                        }
                        else
                        {
                                if( pid.Err>(BIAO.SetQT*0.02f) ) //此时流量太小
                                {
                                        gu8_StatusQrLast = 1; 
                                        gu8_CntQrWave++;
                                }
                                else if(pid.Err< (-BIAO.SetQT*0.02f) ) //此时流量太大
                                {
                                        gu8_StatusQrLast = 2; 
                                        gu8_CntQrWave++;                                    
                                }
                                else
                                {
                                        gu8_CntQrWave = 0;
                                }
                        }
                        if(gu8_CntQrWave>(C_QrT-2)) //未发现有大波动 gu8_CntQrWave 最大为C_QrT-1
                            gu8_CntQrWave = 0;
                        
                
                //OVER  当前流量是否震荡判断 E-OVER
                
                
                //START        E-START

                //OVER  当前流量是否震荡判断 E-OVER                
                
                
                //计数变量 时间片轮询
                gu16_Cnt ++;
                
            OSTimeDly(OS_TICKS_PER_SEC);     
    }             
}