sys_main.c

NEC527多功能电表完整源代码,包括LCD驱动,显示,计量,存储,整个527驱动程序!

#pragma  interrupt INTWT MD_INTWT
#pragma interrupt INTKR MD_INTKR
#include "includes.h"

unsigned short SystemIndication = 0;

const unsigned char _version[] =
{
    0x04,0x03,0x08, 
    0x06,0x11,0x07, 
    DEVICE_OK
};

const unsigned char _Lcd_Disp_HGLLT[] =
{
    LCD_CODE_INFO_H,
    LCD_CODE_INFO_G,
    LCD_CODE_INFO_L,
    LCD_CODE_INFO_L,
    LCD_CODE_INFO_t,
};

const unsigned char _Data_Flash_ERROR[] =
{
    LCD_CODE_INFO_d,
    LCD_CODE_INFO_F,
    LCD_CODE_INFO__,
    LCD_CODE_INFO_E,
    LCD_CODE_INFO_r,
    LCD_CODE_INFO_r
};

__interrupt void MD_INTWT( void )
{
    static unsigned char _half_seconds;
   
    if( _half_seconds++ >= REFRESH_TIME ) 
    {
        _half_seconds = 0;
        SYS_EVT_ADD( EVT_TIMER_SEC );    //加一个秒事件
    }
}

__interrupt void MD_INTKR() 
{
    if( !( USERKEY1_IN & USERKEY1 ) )
    {     
	 UserKeyDownNum = DISPLAY_PAGE_DOWN;
    } 
    else if( !( USERKEY0_IN & USERKEY0 ) )
    {
        UserKeyDownNum = DISPLAY_PGAE_UP;
    }
    else if( !( PROG_EN_IN & PROG_EN ) )
    {
        UserKeyDownNum = ACTIVE_PROGRAM;
    } 
    SYS_EVT_ADD(EVT_KEY_PRESS);	
}

void McuClockInit(void)
{
    unsigned char i;
    unsigned char temp_stabset, temp_stabwait;
	
    SetIORBit( PM12, 0x06 );
    ClrIORBit( OSCCTL, 0x80 );//EXCLK  清空
    SetIORBit( OSCCTL, 0x40 );//OSCSEL 置上X1 X2都用来做振荡
    ClrIORBit( MOC, 0x80 );    	
	
    temp_stabset = CG_X1STAB_STA;
    do
    {
        ClrWdt();
        temp_stabwait = OSTC;
        temp_stabwait &= temp_stabset;
    }while( temp_stabwait != temp_stabset );
    OSTS = CG_X1STAB_SEL;

    for( i = 0; i <= 50; i++ )	NOP();
    ClrIORBit( OSCCTL, 0x01 );//选择时钟在10M以下
    SetIORBit( MCM, 0x05 );//使用高速系统时钟
    SetIORBit( PM12, 0x18 );
    ClrIORBit( OSCCTL, 0x20 );
    SetIORBit( OSCCTL, 0x10 );	
    SetIORBit( RCM, 0x01 );	//内部高速振荡停止
    PCC = CG_CPU_CLOCKSEL;	

}

void McuIoInit(void)
{
    if(IsPowerOn())
    {
        PM0 = P0DIR_VAL;
        P0 = P0OUT_VAL;

        PM1 = P1DIR_VAL;
        P1 = P1OUT_VAL;


        PM2 = P2DIR_VAL;
        P2 = P2OUT_VAL;

        PM3 = P3DIR_VAL;
        P3 = P3OUT_VAL;

        PM4 = P4DIR_VAL;
        P4 = P4OUT_VAL;	

        PM5 = P5DIR_VAL;
        P5 = P5OUT_VAL;

        PM6 = P6DIR_VAL;
        P6 = P6OUT_VAL;

        PM7 = P7DIR_VAL;	
        P7 = P7OUT_VAL;

        P13 = BIT0;
        PM14 = P14DIR_VAL;
        P14 = P14OUT_VAL;
        _sys_evt_add(EVT_INIT_COMM);
    }
    else 
    {
        PM0 = LP_P0DIR_VAL;
        P0 = LP_P0OUT_VAL;

        PM1 = LP_P1DIR_VAL;
        P1   = LP_P1OUT_VAL;


        PM2 = LP_P2DIR_VAL;
        P2   = LP_P2OUT_VAL;

        PM3 = LP_P3DIR_VAL;
        P3 = LP_P3OUT_VAL;


        PM4 = LP_P4DIR_VAL;
        P4   = LP_P4OUT_VAL;	

        PM5 = LP_P5DIR_VAL;
        P5   = LP_P5OUT_VAL;

        PM6 = LP_P6DIR_VAL;
        P6  =  LP_P6OUT_VAL;

        PM7 = LP_P7DIR_VAL;	
        P7  = LP_P7OUT_VAL;

        P13 = 0;
        PM14 = LP_P14DIR_VAL;
        P14 = LP_P14OUT_VAL;
    }

    SetIORBit(KRM,BIT4|BIT2|BIT3);
    SetIORBit(PU7,BIT4|BIT2|BIT3);
    KRMK=0;//开按键中断	
    ClrWdt();
}

void McuInit()
{
    _disable_interrupt();
    McuClockInit(); 
    IMS=0xcc;
    IXS=0x00;
    ClrIORBit( ADM, 0x81 );
    SetIORBit( ADPC, 0x08 );
    McuIoInit();
    BasicTimerInit();
    TM50Init();
    WtInit();
    INTP0Init();
    INTP4Init();
    _enable_interrupt();
}

const unsigned char _rtc_init_addr[]={0xE0,0xF0};
const unsigned char _rtc_init_val[]={0x23,0x20};
const unsigned char _temp_init_val[]={0x55,0x00,0x65,0x00};

void DeviceInit(void)
{
    unsigned char i;
    
#ifdef _TEMPERATURE 
    TemperatureWriteDone(0x02);
#endif
    for(i=0;i<2;i++)
    {
        RtcOperation(_rtc_init_addr[i],(unsigned char *)&_rtc_init_val[i],1);
#ifdef _TEMPERATURE 
        TemperatureWrite(i+2,(unsigned char *)&_temp_init_val[i*2],2);
#endif
    }
#ifdef _TEMPERATURE 
    TemperatureWriteDone(0x03);
#endif	
}

void SystemInit(void)
{ 
    unsigned char data[7], ii;  
    
    for( ii = 0; ii < 3; ii++ )
    {    	
        FramRead( ADDR_OF_SOFTWARE_VERSION, &data[0], 7 );
        if( IsEqual( (unsigned char *)&data[0], (unsigned char *)&_version[0], 7 ) == OK ) break;
    }

    if( ii == 3 )
    { 
        FramWrite( ADDR_OF_SOFTWARE_VERSION, (unsigned char *)&_version[0], 7 ); 
        RelayerState = 0;
        FramWrite( ADDR_OF_RELAYER_STATE, &RelayerState, 1 );

        _SysPotInfo.att702x_info[111] = 0xA5;
        _SysPotInfo.att702x_info[112] = 0xA5;
        _SysPotInfo.att702x_info[113] = 0xA5;
        FramWrite( ADDR_OF_ADE_BASE+111, (unsigned char *)&_SysPotInfo.att702x_info[111], 3 );

        data[0] = DEFAULT_BAUD_RATE;
        FramWrite( ADDR_OF_BAUD_RATE, (unsigned char *)&data[0], 1 );
    }

    FramRead( ADDR_OF_BAUD_RATE, (unsigned char *)&_baud_rate, 1 );
    if( ( _baud_rate != 0x02 ) && ( _baud_rate != 0x04 ) && ( _baud_rate != 0x08 ) && ( _baud_rate != 0x10 ) && ( _baud_rate != 0x20 ) && ( _baud_rate != 0x40 ) )
    {
        _baud_rate = DEFAULT_BAUD_RATE;
    }		
    _on_uart_init();
	
    DataflashReadByBuffer1( DATAFLASH_FLAG_BASE, &data[0], 1 );
    if( DataflashModelFlag & DATA_FLASH_MODEL_ERR )
    {
        memcpy( &LCDMEM[LCD_CODE_ADDR_06],_Data_Flash_ERROR, 6 );
        while(1)
        {
            ClrWdt();
        }
    }
    if( data[0] != DEVICE_OK )
    {
        data[0] = DEVICE_OK;
        DataflashWriteByBuffer1( DATAFLASH_FLAG_BASE, &data[0], 1 );
    }

    FramRead( ADDR_OF_SUM_LOAD_PAGE_PTR, (unsigned char *)&SumLoadCurvePagePointer, 4 );
    FramRead( ADDR_OF_LOAD_CURVE_PAGE_PTR, (unsigned char *)&LoadCurvePagePointer, 2 );
    if( LoadCurvePagePointer >= MAX_PAGE_POINTER )
    {
        LoadCurvePagePointer = 0;
        FramWrite( ADDR_OF_LOAD_CURVE_PAGE_PTR, (unsigned char *)&LoadCurvePagePointer, 2 );
    }

    FramRead( ADDR_OF_LOAD_CURVE_COUNT, &LoadCurvePointer, 1 );
    if( LoadCurvePointer >= LOAD_CURVE_CNT_PER_PAGE )
    {
        LoadCurvePointer = 0;
        FramWrite( ADDR_OF_LOAD_CURVE_COUNT, &LoadCurvePointer, 1 );
    }	

    FramRead( ADDR_OF_PWR_IN_FRAM_COUNT_START, &MinPwrInE2prom, 1 );
    if( MinPwrInE2prom > 60 )
    {
        MinPwrInE2prom = 0;
        FramWrite( ADDR_OF_PWR_IN_FRAM_COUNT_START, &MinPwrInE2prom, 1 );
    }

    for( ii = 0; ii < 4; ii++ )
    {
        LoadEnergy( (unsigned char *)&_SysDisplayRam.ActivePosPwr[ii], 0xFF, _disp_power_item[ii] );
    }

    LoadEnergy( (unsigned char *)&_SysDisplayRam.ReActivePhase1Pwr, 0xFF, 30 );
    LoadEnergy( (unsigned char *)&_SysDisplayRam.ReActivePhase4Pwr, 0xFF, 35 );
    LoadMaxDemandInfo( (unsigned char *)&_SysDisplayRam.ActivePosSumReq, 0x01, 55 );
    FramRead( ADDR_OF_METER_NUM, (unsigned char *)&_SysDisplayRam.PmNum[0], 6 );
    MemSetZero( (unsigned char *)&_SysDisplayRam.TimePot[0], 42 );
    _SysDisplayRam.Csum = SysDoCheckSum( (unsigned char *)&_SysDisplayRam.ActivePosPwr[0], sizeof(_disp_ram)-4 );
	     
    GetSystemTime();
     
    ValidateSystime();

#ifdef _TEMPERATURE
    GetTemperature();
#endif

    EnsurePeriodOfTime();
 
    DisplayReinit();       
	
    FramRead(ADDR_OF_TODAY_PWR_START,(unsigned char *)&_energy.csum,sizeof(_energy_s));        
    if(_energy.csum != SysDoCheckSum((unsigned char *)&_energy.totalA[0],sizeof(_energy_s)-4))
    {
        MemSetZero((unsigned char *)&_energy.csum,sizeof(_energy_s));
        FramWrite(ADDR_OF_TODAY_PWR_START,(unsigned char *)&_energy.csum,sizeof(_energy_s));
    }
	
    FramRead( ADDR_OF_RAM,(unsigned char *)&PwrData.chksum,sizeof(_sys_wat_data) );
    if( PwrData.chksum != SysDoCheckSum( (unsigned char *)&PwrData.WattHourLeft[0], sizeof(_sys_wat_data)-4) )
    {
        MemSetZero( (unsigned char *)&PwrData.chksum, sizeof(_sys_wat_data) );
        FramWrite( ADDR_OF_RAM, (unsigned char *)&PwrData.chksum,sizeof(_sys_wat_data) );
    }  			

    FramRead( ADDR_OF_LINEPWR_START, (unsigned char *)&TempLinePower[0], 36 );
    if( TempLinePower[0] != SysDoCheckSum( (unsigned char *)&TempLinePower[1], 32 ) )
    {
        MemSetZero( (unsigned char *)&TempLinePower[0], 36 );
        FramWrite( ADDR_OF_LINEPWR_START, (unsigned char *)&TempLinePower[0], 36 );
    }
	
    FramRead( ADDR_OF_PHASEINSTPWR_START, (unsigned char *)&CurrentPhaseInstPower[0], 52 );
    if( CurrentPhaseInstPower[0] != SysDoCheckSum((unsigned char *)&CurrentPhaseInstPower[1], 48 ) )
    {
        MemSetZero( (unsigned char *)&CurrentPhaseInstPower[0], 52 );
        FramWrite( ADDR_OF_PHASEINSTPWR_START, (unsigned char *)&CurrentPhaseInstPower[0], 52 );
    }		

    FramRead( ADDR_OF_PHASEPWR_START, (unsigned char *)&CurrentPhasePower[0], 52 );
    if( CurrentPhasePower[0] != SysDoCheckSum((unsigned char *)&CurrentPhasePower[1], 48 ) )
    {
        MemSetZero( (unsigned char *)&CurrentPhasePower[0], 52 );
        FramWrite( ADDR_OF_PHASEPWR_START, (unsigned char *)&CurrentPhasePower[0], 52 );
    }		
	    	
    TariffDetect();	
    FramRead( ADDR_OF_METER_RUN_STATUS, &MeterRunningState, 1 );
    FramRead( ADDR_OF_OVISW, &OverVIStateWord, 1 );
    FramRead( ADDR_OF_VSW, &VStateWord, 1 );
    FramRead( ADDR_OF_LVISW, &LowVIStateWord, 1 );
    FramRead( ADDR_OF_COVER, &AlarmOpenCoverBoard, 1 );
    FramRead( ADDR_OF_BREAK_POWER_FLAG, &PowerStateFlag, 1 );
	 
    if( IsPowerOn() )
    {
        FramRead( ADDR_OF_RELAYER_STATE, &RelayerState, 1 );
        ResetRelayerState();	
    }	
    
    LcdPcf8576Init();
    MemSetZero( (unsigned char *)&LCDMEM[0], 20 );
    ClearLcd();
    memcpy(&LCDMEM[LCD_CODE_ADDR_05],_Lcd_Disp_HGLLT,5);
    LcdPcf8576Operation(0,0,20);

    //刷新显示数据
    _sys_evt_add(EVT_TIMER_SEC);
}

/* table of event handler
*/
const PROC_FUNC _sys_evt_proc[] =
{
    _on_tick,
    _on_read_power1,
    _on_read_power2,
    _on_comm,        
    _on_uart_init,    
    _on_seconds,
    _on_minute,
    _on_15_minutes,
    _on_view_page,
    _on_break_power,
    _on_init_att702x,
    _on_remote_control,
    _on_clr_reqdata
};

/*=================================================
 * Function:       void WtInit( void )
 * Description:    系统时钟单片机内部当系统睡眠时启动
 * Called By:       McuClockPowerDown
 * ModifyAuthor: SWS  Date: 2007-8月28日11时32分
====================================================*/
void WtInit( void )
{
    WTM = 0;
    WTPR = 1;		/* low priority level */
    WTMK = 0;
    WTM.7 = 1;		/* watch timer clock: fw = fsub */
    ClrIORBit(WTM, 0x0c);	/* watch time: 2^14/fw (0.5s at 32.768Kz) */
    SetIORBit(WTM, 0x70);	/* interval time: 2^11/fw */
}

void  WtStart( void )
{	
    /* Enable watch timer operation */
    WTM1 = 1;
    /* Start the 5-bit counter */
    WTM0 = 1;
    WTMK = 0;	/* INTWT enable */
}

void  WtStop( void )
{
    WTMK = 1;		/* INTWT disable */
    /* stop the 5-bit counter */
    WTM1 = 0;
    /* stop watch timer operation */
    WTM0 = 0;
}

/*==================================================
 * Function:       McuClockPowerDown()
 * Description:    让CPU进入休眠状态
 * Return:         
 * ModifyAuthor: sws  Date: 2007-8月27日18时32分
====================================================*/
void McuClockPowerDown(void)
 {  
    _disable_interrupt();
    McuIoInit();
    TickEventStop();
    MK0L = 0xFF;
    MK0H = 0xFF;
    MK1H = 0xFF;
    MK1L = (0xCF);//enable WTMK and KRMK 
    SetIORBit( PCC, 0x10 );       
    do{
           ClrWdt();
           Delay(5);	   
       }while( !CLS );
    SetIORBit( MOC, 0x80 );	
    ClrIORBit( OSCCTL, 0x40 );	
    RCM = 0x01;
    _enable_interrupt();
 }

/*=================================================
 * Function:       void McuWakeUp(void)
 * Description:    wake up the cpu
 * ModifyAuthor: SWS  Date: 2007-8月27日18时37分
====================================================*/
void McuWakeUp(void)
{
    _disable_interrupt();
    McuClockInit();
    McuIoInit();
    TickEventStart();
    _enable_interrupt();
}

/******************************************
* Main
******************************************/
void main(void)// @ "CSYSMAIN"
{
    unsigned short event_mask;
    unsigned char pos;

    McuInit();
    DeviceInit();
    SystemInit();

Again_event:
	
    pos=SYS_EVENT_MAX;

    while(SystemIndication)
    {

        if(pos>=(SYS_EVENT_MAX))
        {
            pos=0;
            event_mask=0x0001;
        }
        
        if(SystemIndication&event_mask)
        {
        
          if( _SysPotInfo.chksum != SysDoCheckSum((unsigned char *)&_SysPotInfo.regv_con[0],sizeof(_sys_potinfo_s)-4))
           {
               EnsurePeriodOfTime();
           }
            _sys_evt_proc[pos]();           
            _sys_evt_del(event_mask);
        }
        ClrWdt();
        pos++;
        event_mask<<=1;          
    }

    if( ( PowerStateFlag & PS_BREAKPOWER_FLAG ) && ( !TimerCounter[TIMER_PROC_LCD_RESET] ) ) 
    {
        if( SystemIndication == 0 )
        {
            Delay(500);
            McuClockPowerDown();
            WtStart();
            do
            {
                HALT();
                if( SystemIndication & ( EVT_KEY_PRESS|EVT_TIMER_SEC ) ) break;
                ClrWdt();
            }while( !IsPowerOn());
            WtStop();
            McuWakeUp();
        }	
    }
    goto Again_event;	
}