base.c

电力系统中的保护装置全部代码

                *p++ = j >> 8;
                *p++ = j >> 16;
                *p++ = j >> 24;
            }
            
            DS1302BurstWrite(0xfe, PulseData, 4*PULSENUM);        
        };break;
    
        case SAVE_TIME:                                                    //存时间
        {
            pDS = &DS1302Time;
            DS1302BurstWrite(0xbe, (UNSIGNED *)pDS, sizeof(Clock));
        };break;
        
        case SAVE_SUBADDRESS:
        {
            uSubAddress.value = subAddress_backup;
            SaveUSET((UNSIGNED *)&uSubAddress,(UNSIGNED *)&uSubAddressEEP);
        };break;
        
        case SAVE_PASSWORD:                                                //存口令
        {
            uPassword.value = password_backup;
            SaveUSET((UNSIGNED *)&uPassword,(UNSIGNED *)&uPasswordEEP);
        };break;
        
        case SAVE_SETZONE:                                                 //存定值区号
        {
            uSetZone.value = iLONC_SetZoneNum;
            SaveUSET((UNSIGNED *)&uSetZone,(UNSIGNED *)&uSetZoneEEP);
        };break;
        
        case SAVE_PTRATE:                                                  //存PT变比
        {
            uPTRate.value = PT_backup;
            SaveUSET((UNSIGNED *)&uPTRate,(UNSIGNED *)&uPTRateEEP);
        };break;
        
        case SAVE_CTRATE:                                                  //存CT变比
        {
            uCTRate.value = CT_backup;
            SaveUSET((UNSIGNED *)&uCTRate,(UNSIGNED *)&uCTRateEEP);
        };break;
        
        case SAVE_JUMPER:                                                  //存压板
        {
            p = uSaveBuffer;
            protect = PRO_Created_Protect_List;
            for (i = 0; i < PRO_Total_Protect; i++, protect = protect->pro_link_next)
            *p++ = (protect->pro_jumper)->jum_status;
            WriteEEP(uSaveBuffer, uJumperEEP, i);   
        };break;
        
        case SAVE_SETTING:                                                 //存定值
        {
            j = uSaveSetZone;
            p = uSaveBuffer;
            protect = PRO_Created_Protect_List;
            for (i = 0; i < PRO_Total_Protect; i++, protect = protect->pro_link_next)
            {
            pSets = protect->pro_setting;
            for (k = 0; k < protect->pro_setting_number; k++)
            {
                fvar = pSets->set_value_zone[j];
                l = *((UNSIGNED *)&fvar);
                *p++ = l;
                *p++ = l >> 8;
                *p++ = l >> 16;
                *p++ = l >> 24;
                pSets++;
            }
            }
    
            WriteEEP(uSaveBuffer, uSettingEEP[j], p - uSaveBuffer); 
        };break;
        
        case SAVE_SCALE:                                                   //存矫正刻度
        {
            pChl = AIChn;
            p = uSaveBuffer;
            for(i = 0; i < CHL_Number; i++)
            {
                j = *(UNSIGNED *)&pChl->chl_scale;
                *p++ = j;
                *p++ = j >> 8;
                *p++ = j >> 16;
                *p++ = j >> 24;
                pChl++;
            }
    
            WriteEEP(uSaveBuffer, (UNSIGNED *)uAmendCoeff, p - uSaveBuffer);    
        };break;
        
        case SAVE_ANGLE:                                                   //存矫正角度
        {
            pChl = AIChn;
            p = uSaveBuffer;
            for(i = 0; i < CHL_Number; i++)
            {
                j = *(UNSIGNED *)&pChl->chl_angle_compensate;
                *p++ = j;       
                *p++ = j >> 8;      
                *p++ = j >> 16;     
                *p++ = j >> 24;     
                pChl++;         
            }
    
            WriteEEP(uSaveBuffer, (UNSIGNED *)uAmendAngle, p - uSaveBuffer);
        };break;
        
        case CLR_EEP_REPORT:                                               //清事件报告
        {
            uSaveBuffer[0] = 0xff;
            uSaveBuffer[1] = 0xff;
            for (i = 0; i < EEP_REPORTNUM; i++)
            {
                WriteEEP(uSaveBuffer, (UNSIGNED *)&uReportEEP[i], 2);
            }
    
            pEEP_REPORT = uReportEEP;
            uReportNum = 0;
        };break;
        
        case SAVE_REPORT:                                                  //存报告
        {
            while(pReportSave != pReportIN)
            {
                pEEP_RPT = (EEP_REPORT *)uSaveBuffer;
                pRPT = pReportSave;
                if (++pReportSave > &ReportRAM[REPORTRAM - 1]) pReportSave = ReportRAM;
                                    
                pEEP_RPT->uReportEEPNumL = ++uReportNum;
                pEEP_RPT->uReportEEPNumH = uReportNum >> 8;
            
                pSOE = &pRPT->pro_report_soe;
                p = (UNSIGNED *)pEEP_RPT->SOE_name;
                p1 = (UNSIGNED *)pSOE->SOE_name;
                for (i = 0; i < SOE_NAME; i++)
                {
                    if (*p1 == '\0') break;
                    *p++ = *p1++;
                }
            
                for (; i < SOE_NAME; i++) *p++ = '\0';
                
                pEEP_RPT->SOE_Inf = pSOE->SOE_Inf;
                pEEP_RPT->DPI = pSOE->DPI;
                pEEP_RPT->Relative_TimeL = pSOE->Relative_Time;
                pEEP_RPT->Relative_TimeH = pSOE->Relative_Time >> 8;
                pEEP_RPT->Fault_Number = pSOE->Fault_Number;
                pEEP_RPT->Year = pSOE->Year;
                pEEP_RPT->Month = pSOE->Month;
                pEEP_RPT->Day = pSOE->Day;
                pEEP_RPT->Hour = pSOE->Hour;
                pEEP_RPT->Minute = pSOE->Minute;
                pEEP_RPT->MillionsecondL = pSOE->Millionsecond;
                pEEP_RPT->MillionsecondH = pSOE->Millionsecond >> 8;
                pEEP_RPT->SIN = pSOE->SIN;
                pEEP_RPT->pro_report_data_number = pRPT->pro_report_data_number;
                
                pEEPV = pEEP_RPT->Value;
                pVAL = pRPT -> pro_report_data;
                
                for (i = 0; i < pRPT->pro_report_data_number; i++, pEEPV++, pVAL++)
                {
                    p = (UNSIGNED *)pEEPV->value_name;
                    p1 = (UNSIGNED *)pVAL->pvalue_name;
                    for (j = 0; j < VALUE_NAME; j++) *p++ = *p1++;
                    
                    p = (UNSIGNED *)pEEPV->value_alias;
                    p1 = (UNSIGNED *)pVAL->pvalue_alias;
                    for (j = 0; j < ALIAS_NAME; j++) *p++ = *p1++;
                    
                    pEEPV->value_index_number = i + 1;
                    
                    pEEPV->value_calculate_style = pVAL->value_calculate_style;
                    
                    p = (UNSIGNED *)pEEPV->value_dimension;
                    p1 = (UNSIGNED *)pVAL->pvalue_dimension;
                    for (j = 0; j < DIMENSION; j++) *p++ = *p1++;
                    
                    k = *(UNSIGNED *)&pVAL->value_calculate_coefficient;
                    pEEPV->value_calculate_coefficient1 = k;
                    pEEPV->value_calculate_coefficient2 = k >> 8;
                    pEEPV->value_calculate_coefficient3 = k >> 16;
                    pEEPV->value_calculate_coefficient4 = k >> 24;
                    
                    k = *(UNSIGNED *)&pVAL->value_measure;
                    pEEPV->value_measure1 = k;
                    pEEPV->value_measure2 = k >> 8;
                    pEEPV->value_measure3 = k >> 16;
                    pEEPV->value_measure4 = k >> 24;
                    
                    k = *(UNSIGNED *)&pVAL->value_real;
                    pEEPV->value_real1 = k;
                    pEEPV->value_real2 = k >> 8;
                    pEEPV->value_real3 = k >> 16;
                    pEEPV->value_real4 = k >> 24;
                    
                    k = *(UNSIGNED *)&pVAL->value_imaginary;
                    pEEPV->value_imaginary1 = k;
                    pEEPV->value_imaginary2 = k >> 8;
                    pEEPV->value_imaginary3 = k >> 16;
                    pEEPV->value_imaginary4 = k >> 24;
                }
                
                WriteEEP(uSaveBuffer, (UNSIGNED *)pEEP_REPORT, sizeof(EEP_REPORT)); 
                
                pEEP_RPT = pEEP_REPORT;
                pEEP_REPORT = (++pEEP_RPT > &uReportEEP[EEP_REPORTNUM - 1] ? uReportEEP : pEEP_RPT);
            }
        };break;
        
        default: break;
    }
}
    
/***********************************************************************************/
/*    函数名: VOID SaveUSET(UNSIGNED *pSRC, UNSIGNED *pDST)                        */ 
/*    功能: 保存正数设置                                                           */ 
/***********************************************************************************/
VOID SaveUSET(UNSIGNED *pSRC, UNSIGNED *pDST)
{
    register UNSIGNED    i;
    register UNSIGNED    *p = uSaveBuffer;
    for (i = 0; i < sizeof(RUN_USET); i++)
    {
        *p++ = *pSRC;
        *p++ = *pSRC >> 8;
        *p++ = *pSRC >> 16;
        *p++ = *pSRC >> 24;
        pSRC++;
    }
    WriteEEP(uSaveBuffer, pDST, sizeof(EEP_SET));   
}

/***********************************************************************************/
/*    函数名: UNSIGNED LoadUSET(UNSIGNED *pSRC, UNSIGNED *pDST)                    */ 
/*    功能: 读正数设置                                                             */ 
/***********************************************************************************/
UNSIGNED    LoadUSET(UNSIGNED *pSRC, UNSIGNED *pDST)
{
    register UNSIGNED    i,j;
    register RUN_USET    *p = (RUN_USET *)pDST;
    register UNSIGNED    *pSRC1 = pSRC, *pDST1 = pDST;
    
    for (i = 0; i < sizeof(RUN_USET); i++)
    {
        j = *pSRC1++ & 0xff;
        j |= (*pSRC1++ & 0xff) << 8;
        j |= (*pSRC1++ & 0xff) << 16;
        j |= (*pSRC1++ & 0xff) << 24;
        *pDST1++ = j;
    }
    
    return(p->value);
}

/***********************************************************************************/
/*  信号复归子程序                                                                 */ 
/***********************************************************************************/
UNSIGNED    RevertDISP_Flag;
VOID Revert(VOID)
{
    register PROTECT     *protect;
    register REPORT      *pRPT;

    if (Revert_Flag)
    {
        Revert_Flag = 0;
        Qdj();
        Fgj();
    
        RevertDISP_Flag = 1;
    }
}