module.c

Keil平台

//        break;
//    case 2:
//        timestr(alm->time1, buf);
//        break;
//    case 3:
//        timestr(alm->time2, buf);
//        break;
//    }
//    return buf;
}
/****************************************************************************/
int DcAvg(int *buf, int count)
{
    int i, itemp;
    for (i = 0; i < count; i++)
    {
        itemp = ad2i(buf[i]);
        Temp_Buf[i] = itemp;
    }
    Filter_Midst(&Temp_Buf[0], count, 3);
    return Filter_Avg(&Temp_Buf[0], count-2);
}

int AdFilter(int *buf, int count)
{
    int i;
    long ltemp;
    for (i = 0; i < count; i++)
    {
        Temp_Buf[i] = buf[i];
    }
    Filter_Midst(&Temp_Buf[0], count, 3);
    return Filter_Avg(&Temp_Buf[0], count-2);
}
/****************************************************************************/
int AcRms(int *buf, int count)
{
    int j;
    int prev_itemp, itemp, wave_point, wave_count;
    long square_sum, RMS_value;
    wave_point = 0;
    wave_count = 0;
    square_sum = 0;

    for (j = 0; j < count; j++)
    {
        Temp_Buf[j] = buf[j];
    }
    for (j = 0; j < count; j++)
    {
        itemp = ad2i(Temp_Buf[j]);
        prev_itemp = itemp;
        /* find zero */
        for (; j < count; j++)
        {
            itemp = ad2i(Temp_Buf[j]);
            RMS_value = prev_itemp * itemp;
            if ( (prev_itemp | itemp) <= 0 )
            {
                break;
            }
            prev_itemp = itemp;
        }
        square_sum = 0;
        wave_point = 0;
        /* compute RMS */
        for (; j < count; j++)
        {
            itemp = ad2i(Temp_Buf[j]);
            square_sum += (long)itemp * (long)itemp;
            wave_point++;
            if (wave_point > SAMPLE_POINT)
            {
                square_sum /= SAMPLE_POINT;
                RMS_value = CalcSqrt(square_sum);
                RMS_Buf[wave_count] = RMS_value;
                wave_count++;
                wave_point = 0;
                square_sum = 0;
            }
        }
    }   /*for j*/
    /* compute RMS avg */
    RMS_value = 0;
    for (j = 0; j < wave_count; j++)
    {
        RMS_value += (long)RMS_Buf[j];
    }
    if (wave_count == 0)
    {
        wave_count = 1;
    }
    RMS_value /= wave_count;
    return RMS_value;
}

/****************************************************************************/
void DataRead(void)
{
    DiFormat();
    AdRead();
    AdFormat();
}
/****************************************************************************/
void AdRead(void)
{
}
/****************************************************************************/
void AdFormat(void)
{
}
/* adv 是显示值*/
int GetHigh2(int high)
{
    long int temp;
    temp = Jkmk.mk_cfg[42];
    temp *= (long int)high;
    temp /= 100;
    return (int)temp;
}

int GetLow2(int low)
{
    long int temp;
    temp = Jkmk.mk_cfg[43];
    temp *= (long int)low;
    temp /= 100;
    return (int)temp;
}
void AdLimit(void)
{
    int i, flag;
    int ac_flag[3];
    /* 两路限值相等*/
    /* 输出电压*/
    Jkmk.ai_cfg[8*3+1] =  Jkmk.ai_cfg[6*3+1];
    Jkmk.ai_cfg[8*3+1] =  Jkmk.ai_cfg[6*3+2];
    /*合母电压*/
    Jkmk.ai_cfg[13*3+1] =  Jkmk.ai_cfg[10*3+1];
    Jkmk.ai_cfg[13*3+2] =  Jkmk.ai_cfg[10*3+2];
    /* 控母电压*/
    Jkmk.ai_cfg[14*3+1] =  Jkmk.ai_cfg[11*3+1];
    Jkmk.ai_cfg[14*3+2] =  Jkmk.ai_cfg[11*3+2];
    /* 电池电压*/
    Jkmk.ai_cfg[18*3+2] =  Jkmk.ai_cfg[16*3+1];
    Jkmk.ai_cfg[18*3+2] =  Jkmk.ai_cfg[16*3+2];

    for (i = 6; i < 24; i++)
    {
        Ad_Cfg.adv   = Jkmk.ai_v[i];
        Ad_Cfg.high  = Jkmk.ai_cfg[i*3+1];
        Ad_Cfg.low   = Jkmk.ai_cfg[i*3+2];
        flag = ALM_NONE;
        if (Ad_Cfg.adv > Ad_Cfg.high)       /* 过上限*/
            flag = ALM_HIGH;
        if (Ad_Cfg.adv < Ad_Cfg.low)        /* 过下限*/
            flag = ALM_LOW;

        if (Ad_Alarm_Flag[i] != flag)
        {
             Ad_Alarm_Flag[i] = flag;
        }
        else
        {
            if (Jkmk.alm_v[i] != flag )
            {
                Jkmk.alm_v[i] = flag;
                SetNewAlarmFlag();
            }
        }
    }
    /*
    Jkmk.alm_v[8] = ALM_NONE;
    Jkmk.alm_v[9] = ALM_NONE;
    Jkmk.alm_v[10] = ALM_NONE;

    Jkmk.alm_v[16] = ALM_NONE;
    Jkmk.alm_v[17] = ALM_NONE;
    */
    //判断母线是否分段不分段则取消2段告警
    if (Jkmk.mk_cfg[50] == 0)
    {

        Jkmk.alm_v[13] = ALM_NONE;
        Jkmk.alm_v[14] = ALM_NONE;
        Jkmk.alm_v[15] = ALM_NONE;

        Jkmk.alm_v[18] = ALM_NONE;
        Jkmk.alm_v[19] = ALM_NONE;
    }
    //2路输出不告警
    Jkmk.alm_v[8] = ALM_NONE;
    Jkmk.alm_v[9] = ALM_NONE;
//有否降压单元

    //硅堆故障母线压差达到 40V 认为硅堆断
    //先判断母线是否有降压单元 再判断压差 合母电压要超过160V
    if ( 0 == Jkmk.mk_cfg[47])
    {//有降压单元
        if ((Jkmk.ai_v[10] - Jkmk.ai_v[11] > 400) && (Jkmk.ai_v[10] > 1600)) 
        {
            Jkmk.alm_v[46] = ALM_ALM;
        }
        else
        {
            Jkmk.alm_v[46] = ALM_NONE;
        }
    }
    else
    {
        //没有降压单元 控母和合母合成一个
        //没有控母告警
        Jkmk.alm_v[46] = ALM_NONE;  //
        Jkmk.alm_v[11] = ALM_NONE;  //1段控母
        Jkmk.alm_v[14] = ALM_NONE;  //2段控母
    }
}
/****************************************************************************/
void AcLimit(void)
{
    int i, flag;
    int ac_flag[3];
    int ac_phase_count = 0;
    /* ac alarm*/
    Ad_Cfg.high = Jkmk.ai_cfg[1];
    Ad_Cfg.low  = Jkmk.ai_cfg[2];
    Ad_Cfg.low2 = Jkmk.ai_cfg[1*3+2];
    /* ac alarm*/
    /*"1路交流\n过压\n欠压\n缺相\n停电"*/
    ac_phase_count = 0;
    flag = 0;
    for (i = 0; i < 3; i++)
    {
        ac_flag[i] = ALM_NONE;
        if (Jkmk.ai_v[i] > Ad_Cfg.high)
        {
            ac_flag[i] = ALM_HIGH;
        }
        if (Jkmk.ai_v[i] < Ad_Cfg.low)
        {
            ac_flag[i] = ALM_LOW;
        }
        if (Jkmk.ai_v[i] < Ad_Cfg.low2)
        {
            ac_flag[i] = ALM_PHASE;
            ac_phase_count++;
        }
        if (ac_flag[i] != 0)
        {
            flag = ac_flag[i];
        }
    }

    if ((ac_phase_count == 1) || (ac_phase_count == 2))
    {
        flag = ALM_PHASE;
    }
    if (ac_phase_count == 3)
    {
        flag = ALM_ACCUT;
    }
    

    if (Ad_Alarm_Flag[0] != flag)
    {
        Ad_Alarm_Flag[0] = flag;
    }
    else
    {
        if (Jkmk.alm_v[0] != flag)
        {
            Jkmk.alm_v[0] = flag;
            /*
            if (flag)
                Jkmk.alm_v[1] = ALM_ALM;
            else
                Jkmk.alm_v[1] = ALM_NONE;
            */
            SetNewAlarmFlag();
        }
        
    }

    /*"2路交流\n过压\n欠压\n缺相\n停电"*/
    ac_phase_count = 0;
    flag = 0;
    for (i = 0; i < 3; i++)
    {
        ac_flag[i] = ALM_NONE;
        if (Jkmk.ai_v[i+3] > Ad_Cfg.high)
        {
            ac_flag[i] = ALM_HIGH;
        }
        if (Jkmk.ai_v[i+3] < Ad_Cfg.low)
        {
            ac_flag[i] = ALM_LOW;
        }
        if (Jkmk.ai_v[i+3] < Ad_Cfg.low2)
        {
            ac_flag[i] = ALM_PHASE;
            ac_phase_count++;
        }
        if (ac_flag[i] != 0)
        {
            flag = ac_flag[i];
        }
    }
    if ((ac_phase_count == 1) || (ac_phase_count == 2))
    {
        flag = ALM_PHASE;
    }
    if (ac_phase_count == 3)
    {
        flag = ALM_ACCUT;
    }
    
    if (Ad_Alarm_Flag[3] != flag)
    {
        Ad_Alarm_Flag[3] = flag;
    }
    else
    {
        if (Jkmk.alm_v[3] != flag)
        {
            Jkmk.alm_v[3] = flag;
            /*
            if (flag)
                Jkmk.alm_v[1] = ALM_ALM;
            else
                Jkmk.alm_v[1] = ALM_NONE;
            */
            SetNewAlarmFlag();
        }
        
    }
}
/****************************************************************************/
void AlarmProc(void)
{
    int value, index;
    int module;
        
    AdLimit();
    AcLimit();

    if (GetNewAlarmFlag() == 0)
    {
        if (NewAlarmCount == 0)
        {
             AlarmSort(-1);
             return;
        }
    }
    /* 交流*/
    /*0 交流停电      */
    AlarmWork(0, MODULE_JKMK|DATA_ALM, 0, 0, ALM_ACCUT);
    AlarmWork(0, MODULE_JKMK|DATA_ALM, 3, 0, ALM_ACCUT);
    /*1 交流空开跳    */
    AlarmWork(1, MODULE_JKMK|DATA_ALM, 30, 0, ALM_ALM);
    /*2 交流过压      */
    AlarmWork(2, MODULE_JKMK|DATA_ALM, 0, 0, ALM_HIGH);
    AlarmWork(2, MODULE_JKMK|DATA_ALM, 3, 0, ALM_HIGH);
    /*3 交流欠压      */
    AlarmWork(3, MODULE_JKMK|DATA_ALM, 0, 0, ALM_LOW);
    AlarmWork(3, MODULE_JKMK|DATA_ALM, 3, 0, ALM_LOW);
  /*4 交流缺相      */
    AlarmWork(4, MODULE_JKMK|DATA_ALM, 0, 0, ALM_PHASE);
    AlarmWork(4, MODULE_JKMK|DATA_ALM, 3, 0, ALM_PHASE);
    /*5 市电切换失败*/
//    AlarmWork(5, MODULE_JKMK|DATA_ALM, ??, 0, ALM_ALM);
  /*6 防雷故障      */
    AlarmWork(6, MODULE_JKMK|DATA_ALM, 34, 0, ALM_ALM);
    /*7 电池支路断    */
    AlarmWork(7, MODULE_JKMK|DATA_ALM, 33, 0, ALM_ALM);
  /*8 电池组过压    */
    AlarmWork(8, MODULE_JKMK|DATA_ALM, 16, 0, ALM_HIGH);
//    AlarmWork(8, MODULE_JKMK|DATA_ALM,  18, 0, ALM_HIGH);
  /*9 电池组欠压    */
    AlarmWork(8, MODULE_JKMK|DATA_ALM, 16, 0, ALM_LOW);
//    AlarmWork(8, MODULE_JKMK|DATA_ALM,  18, 0, ALM_LOW);

    /*10 电池组充电过流*/
    AlarmWork(10, MODULE_JKMK|DATA_ALM, 17, 0, ALM_HIGH);
//    AlarmWork(10, MODULE_JKMK|DATA_ALM, 19, 0, ALM_HIGH);

    /*11 电池房过温    */
    AlarmWork(11, MODULE_JKMK|DATA_ALM, 24, 0, ALM_LOW);
    /*12 1点过温       */
    AlarmWork(12, MODULE_JKMK|DATA_ALM, 24, 0, ALM_LOW);
    /*13 2点过温       */
    AlarmWork(13, MODULE_JKMK|DATA_ALM, 25, 0, ALM_LOW);
    /*14 母线过压      */
    AlarmWork(14, MODULE_JKMK|DATA_ALM,  6, 0, ALM_HIGH);
    AlarmWork(14, MODULE_JKMK|DATA_ALM,  8, 0, ALM_HIGH);

    AlarmWork(14, MODULE_JKMK|DATA_ALM, 10, 0, ALM_HIGH);//1合母
    AlarmWork(14, MODULE_JKMK|DATA_ALM, 11, 0, ALM_HIGH);//1控母
    AlarmWork(14, MODULE_JKMK|DATA_ALM, 13, 0, ALM_HIGH);//2合母
    AlarmWork(14, MODULE_JKMK|DATA_ALM, 14, 0, ALM_HIGH);//2控母
    /*15 母线欠压      */
    AlarmWork(15, MODULE_JKMK|DATA_ALM,  6, 0, ALM_LOW);
    AlarmWork(15, MODULE_JKMK|DATA_ALM,  8, 0, ALM_LOW);

    AlarmWork(15, MODULE_JKMK|DATA_ALM, 10, 0, ALM_LOW);//1合母
    AlarmWork(15, MODULE_JKMK|DATA_ALM, 11, 0, ALM_LOW);//1控母
    AlarmWork(15, MODULE_JKMK|DATA_ALM, 13, 0, ALM_LOW);//2合母
    AlarmWork(15, MODULE_JKMK|DATA_ALM, 14, 0, ALM_LOW);//2控母
    /*16 硅堆故障      */
    AlarmWork(16, MODULE_JKMK|DATA_ALM, 26, 0, ALM_ALM);
    /*17  母线过负荷 1段母线 2段母线 1路输出 2路输出  */
    AlarmWork(17, MODULE_JKMK|DATA_ALM, 12,  0, ALM_HIGH);
    AlarmWork(17, MODULE_JKMK|DATA_ALM, 15,  0, ALM_HIGH);

    AlarmWork(17, MODULE_JKMK|DATA_ALM, 7,  0, ALM_HIGH);
    AlarmWork(17, MODULE_JKMK|DATA_ALM, 9,  0, ALM_HIGH);
    /*18直流输出跳闸*/
    AlarmWork(18, MODULE_JKMK|DATA_ALM, 35, 0, ALM_ALM);
    AlarmWork(18, MODULE_JKMK|DATA_ALM, 36, 0, ALM_ALM);
    /*19 通讯模块电压异常*/
    AlarmWork(19, MODULE_JKMK|DATA_ALM, 20,  0, ALM_HIGH);
    AlarmWork(19, MODULE_JKMK|DATA_ALM, 20,  0, ALM_LOW);
    for (module = 0; module < GetModuleCount(MODULE_CDMK); module++)
    {
    /*20 充电模块通讯  */
        AlarmWork(20, MODULE_CDMK|DATA_ALM, 0, module, ALM_ALM);
    /*21 充电模块故障  */
        AlarmWork(21, MODULE_CDMK|DATA_ALM, 1, module, ALM_ALM);
    /*22 充电模块保护  */
        AlarmWork(22, MODULE_CDMK|DATA_ALM, 2, module, ALM_ALM);
    }
    /*24 绝缘继电器故障*/
    AlarmWork(24, MODULE_JKMK|DATA_ALM, 41, 0, ALM_ALM);

    /*25 绝缘仪通讯故障*/
    AlarmWork(25, MODULE_JYMK|DATA_ALM, 0, 0, ALM_ALM);
    /*26 绝缘仪主机故障*/
    AlarmWork(26, MODULE_JYMK|DATA_ALM, 0, 1, ALM_ALM);
    /*27 绝缘仪从机故