load_curve.c

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

    _load_curve_proc20,    
    _load_curve_proc21,    
    _load_curve_proc22,
    _load_curve_proc23
};

void SaveLoadCurveToFlash(void)
{
    unsigned short page,ii;

    page = (unsigned short)( BASE_LOAD_CURVE/DF_PAGE_LEN + LoadCurvePagePointer );
    if( DataflashMainToBuffer1( page ) == OK )
    {
        for( ii = 0; ii < LOAD_CURVE_CNT_PER_PAGE; ii++)
        {
            FramRead( ADDR_OF_LOAD_CURVE_SAVE+ii*OFFSET_LOAD_CURVE_SAVE, (unsigned char *)&pub_data.pub_data_buff3[0], OFFSET_LOAD_CURVE_SAVE );
            DataflashBuffer1Write( ii*OFFSET_LOAD_CURVE_SAVE, (unsigned char *)&pub_data.pub_data_buff3[0], OFFSET_LOAD_CURVE_SAVE );
        }		
        DataflashBuffer1ToMain(page);
    }
	
    MemSetZero( (unsigned char *)&pub_data.pub_data_buff3[0], OFFSET_LOAD_CURVE_SAVE );
    for( ii = 0; ii < LOAD_CURVE_CNT_PER_PAGE; ii++)
    {
        FramWrite( ADDR_OF_LOAD_CURVE_SAVE+ii*OFFSET_LOAD_CURVE_SAVE, (unsigned char *)&pub_data.pub_data_buff3[0], OFFSET_LOAD_CURVE_SAVE );
    }
}

unsigned char FindTimePosition(unsigned char *data)
{
    unsigned short top, bot, mid;	
    unsigned char find_flag, compare_result;
    unsigned char temptime[5], count = 0;

    if( ( LoadCurvePointer == 0 ) && ( LoadCurvePagePointer >= 1 ) )
    {
        goto find_time_next;
    }
	
    for( bot = 0; bot < LOAD_CURVE_CNT_PER_PAGE; bot++ )
    {
        FramRead( ADDR_OF_LOAD_CURVE_SAVE+OFFSET_LOAD_CURVE_SAVE*bot, (unsigned char *)&pub_data.pub_data_buff3[bot*LOAD_CURVE_TIME_LEN], LOAD_CURVE_TIME_LEN );
        compare_result = TimeCompare( (unsigned char *)&data[0], (unsigned char *)&pub_data.pub_data_buff3[bot*LOAD_CURVE_TIME_LEN], LOAD_CURVE_TIME_LEN );
        if( compare_result == TIME_EQUAL )
        {
            DI1DI0 = ADDR_OF_LOAD_CURVE_SAVE+OFFSET_LOAD_CURVE_SAVE*bot;
            return 1;
        }		
    }

    if( TimeCompare( (unsigned char *)&data[0], (unsigned char *)&pub_data.pub_data_buff3[0], LOAD_CURVE_TIME_LEN ) == TIME_LITTER ) 
    {
        DataflashReadByBuffer1( BASE_LOAD_CURVE, (unsigned char *)&temptime[0], LOAD_CURVE_TIME_LEN );
        if( IsEqualSpecialData( &temptime[0], 0, LOAD_CURVE_TIME_LEN ) == OK )
        {
            DI1DI0 = ADDR_OF_LOAD_CURVE_SAVE;
            return 1;		
        }			
    }

    for( bot = 0; bot < LOAD_CURVE_CNT_PER_PAGE-1; bot++ )
    {
        if( ( TimeCompare( (unsigned char *)&data[0], (unsigned char *)&pub_data.pub_data_buff3[bot*LOAD_CURVE_TIME_LEN], LOAD_CURVE_TIME_LEN ) == TIME_LARGER ) && 
             ( TimeCompare( (unsigned char *)&data[0], (unsigned char *)&pub_data.pub_data_buff3[(bot+1)*LOAD_CURVE_TIME_LEN], LOAD_CURVE_TIME_LEN )	== TIME_LITTER ) )
        {
            DI1DI0 = ADDR_OF_LOAD_CURVE_SAVE+OFFSET_LOAD_CURVE_SAVE*(bot+1);
            return 1;
        }
    }

find_time_next:
    if( LoadCurvePagePointer != 0 )
    {
        DI1DI0 = BASE_LOAD_CURVE+(ulong)(LoadCurvePagePointer-1)*DF_PAGE_LEN+OFFSET_LOAD_CURVE_SAVE*(LOAD_CURVE_CNT_PER_PAGE-1);
        DataflashReadByBuffer1( DI1DI0, (unsigned char *)&pub_data.pub_data_buff3[0], LOAD_CURVE_TIME_LEN );
        compare_result = TimeCompare( (unsigned char *)&data[0], (unsigned char *)&pub_data.pub_data_buff3[0], LOAD_CURVE_TIME_LEN );
        if( compare_result == TIME_LARGER )
        {
            return ERROR;
        }
        else if( compare_result == TIME_EQUAL )
        {
            return 2;
        }
    }
	
    if( SumLoadCurvePagePointer < MAX_PAGE_POINTER )
    {
        DI1DI0 = BASE_LOAD_CURVE;
        DataflashReadByBuffer1( DI1DI0, (unsigned char *)&pub_data.pub_data_buff3[0], LOAD_CURVE_TIME_LEN );
        compare_result = TimeCompare( (unsigned char *)&data[0], (unsigned char *)&pub_data.pub_data_buff3[0], LOAD_CURVE_TIME_LEN );
        if( compare_result <= TIME_EQUAL )
        {
            return 2;	
        }

        top = 0;	
        bot = (LoadCurvePagePointer + MAX_PAGE_POINTER-1)%MAX_PAGE_POINTER;
        find_flag = 0;
    }
    else
    {
        DI1DI0 = BASE_LOAD_CURVE+(ulong)LoadCurvePagePointer*DF_PAGE_LEN;
        DataflashReadByBuffer1( DI1DI0, (unsigned char *)&pub_data.pub_data_buff3[0], LOAD_CURVE_TIME_LEN );
        compare_result = TimeCompare( (unsigned char *)&data[0], (unsigned char *)&pub_data.pub_data_buff3[0], LOAD_CURVE_TIME_LEN );
        if( compare_result <= TIME_EQUAL )
        {
            return 2;
        }
        		
        top = LoadCurvePagePointer;
        bot = (LoadCurvePagePointer + MAX_PAGE_POINTER-1)%MAX_PAGE_POINTER;
        find_flag = 0;
    }

    do
    {
        if( count++ > 30 )
        {
            find_flag = 3;
            break;			
        }
	
        if( bot >= top )
        {
            mid = (bot - top)/2 + top;
        }
        else
        {
            mid = ( MAX_PAGE_POINTER + bot - top )/2 + top;
        }

        if( mid  >= MAX_PAGE_POINTER )
        {
            mid %= MAX_PAGE_POINTER;
        }
		
        if( ( mid == bot ) ||( mid == top ) )
        {
            find_flag = 2;
            break;
        }		 
		
        DI1DI0 = BASE_LOAD_CURVE+DF_PAGE_LEN*mid;
        DataflashReadByBuffer1( DI1DI0, (unsigned char *)&pub_data.pub_data_buff3[0], LOAD_CURVE_TIME_LEN );
        compare_result = TimeCompare( (unsigned char *)&data[0], (unsigned char *)&pub_data.pub_data_buff3[0], LOAD_CURVE_TIME_LEN );
        if( compare_result == TIME_LITTER )
        {
            bot = mid;
        }
        else if( compare_result == TIME_LARGER )
        {
            top = mid;
        }
        else
        {
            find_flag = 1;
            break;
        }
    }while( 1 );
						
    if( find_flag == 1 )
    {
        return 2;	
    }

    if( find_flag == 3 )
    {
        return ERROR;	
    }	

    for( mid = 0; mid < LOAD_CURVE_CNT_PER_PAGE; mid++ )
    {
        DI1DI0 = BASE_LOAD_CURVE + DF_PAGE_LEN*top + OFFSET_LOAD_CURVE_SAVE*mid;
        DataflashReadByBuffer1( DI1DI0, (unsigned char *)&pub_data.pub_data_buff3[mid*LOAD_CURVE_TIME_LEN], LOAD_CURVE_TIME_LEN );
	 compare_result = TimeCompare( (unsigned char *)&data[0], (unsigned char *)&pub_data.pub_data_buff3[mid*LOAD_CURVE_TIME_LEN], LOAD_CURVE_TIME_LEN );
        if( compare_result <= TIME_EQUAL )
        {
            return 2;           
        }
    }

    for( mid = 0; mid < LOAD_CURVE_CNT_PER_PAGE; mid++ )
    {
        DI1DI0 = BASE_LOAD_CURVE + DF_PAGE_LEN*bot + OFFSET_LOAD_CURVE_SAVE*mid;
        DataflashReadByBuffer1( DI1DI0, (unsigned char *)&pub_data.pub_data_buff3[mid*LOAD_CURVE_TIME_LEN], LOAD_CURVE_TIME_LEN );  
	 compare_result = TimeCompare( (unsigned char *)&data[0], (unsigned char *)&pub_data.pub_data_buff3[mid*LOAD_CURVE_TIME_LEN], LOAD_CURVE_TIME_LEN );
        if( compare_result <= TIME_EQUAL )
        {
            return 2;   
        }
    }

    return 2;     	
}

const unsigned char load_curve_flag_len[] = { 8, 8, 7 };
void SysRecLoadCurve(void)
{
    unsigned char i,j,flag = 0;
    unsigned char rec[9],seq,temp[LOAD_CURVE_TIME_LEN];

    FramRead( ADDR_OF_LOAD_CURVE_INTERVAL_START, (unsigned char *)&pub_data.pub_data_buff1[0], 34 );
    FramRead( ADDR_OF_LOAD_CURVE_INTERVAL_START+OFFSET_LOAD_CURVE_INTERVAL*17, (unsigned char *)&pub_data.pub_data_buff1[20], 2 );
    FramRead( ADDR_OF_LOAD_CURVE_INTERVAL_START+OFFSET_LOAD_CURVE_INTERVAL*18, (unsigned char *)&pub_data.pub_data_buff1[17], 6 );
    FramRead ( ADDR_OF_LOAD_CURVE_INTERVAL_START+OFFSET_LOAD_CURVE_INTERVAL*21, (unsigned char *)&pub_data.pub_data_buff1[21], 4 );
    FramRead( ADDR_OF_LOAD_CURVE_INTERVAL_COUNT, (unsigned char *)&pub_data.pub_data_buff1[LOAD_CURVE_TOTAL_ITEM], LOAD_CURVE_TOTAL_ITEM*2 );
	
    MemSetZero( (unsigned char *)&rec[0], 9 );
    DI1DI0 = ADDR_OF_LOAD_CURVE_SAVE+(ushort)LoadCurvePointer*OFFSET_LOAD_CURVE_SAVE;
	
    for( i = 0; i < 3; i++ )
    {   
        for( j = 0; j < load_curve_flag_len[i]; j++ )
        {
            ClrWdt();
            seq = 8*i+j;
            if( ( pub_data.pub_data_buff1[seq] != 0 ) && ( pub_data.pub_data_buff1[seq] <= 1440 ) )
            {
                pub_data.pub_data_buff1[seq+LOAD_CURVE_TOTAL_ITEM]++;
                if( pub_data.pub_data_buff1[seq+LOAD_CURVE_TOTAL_ITEM] >= pub_data.pub_data_buff1[seq] )
                {
                    flag = 1;            
                    pub_data.pub_data_buff1[seq+LOAD_CURVE_TOTAL_ITEM] = 0;  
                    rec[5+i] |= (uchar)( BIT0 << j );
                    load_curve_proc[seq]();
                }
                FramWrite( ADDR_OF_LOAD_CURVE_INTERVAL_COUNT+seq*2, (unsigned char *)&pub_data.pub_data_buff1[seq+LOAD_CURVE_TOTAL_ITEM], 2 );	
            }            
        }		
    }
	
    if( flag != 0 )
    {
        rec[0] = Bcd2HexChar( SystemTime[SPACE_OF_YEAR] );
        rec[1] = Bcd2HexChar( SystemTime[SPACE_OF_MONTH] );
        rec[2] = Bcd2HexChar( SystemTime[SPACE_OF_DAY] );
        rec[3] = Bcd2HexChar( SystemTime[SPACE_OF_HOUR] );
        rec[4] = Bcd2HexChar( SystemTime[SPACE_OF_MINUTE] );
        if( LoadCurvePointer == 0 )
        {            
            if( LoadCurvePagePointer != 0 )
            {
                DI1DI0 = ( BASE_LOAD_CURVE +  (ulong)( LoadCurvePagePointer - 1 )*DF_PAGE_LEN + OFFSET_LOAD_CURVE_SAVE * ( LOAD_CURVE_CNT_PER_PAGE - 1 ) );
            }
            else
            {
                DI1DI0 = ( BASE_LOAD_CURVE + OFFSET_LOAD_CURVE_SAVE * ( LOAD_CURVE_CNT_PER_PAGE-1 ) );
            }
            DataflashReadByBuffer1( DI1DI0, (unsigned char *)&temp[0], LOAD_CURVE_TIME_LEN );	
        }
        else
        {
            FramRead( ADDR_OF_LOAD_CURVE_SAVE+(ushort)(LoadCurvePointer-1)*OFFSET_LOAD_CURVE_SAVE, &temp[0], LOAD_CURVE_TIME_LEN );
        }
		
        if( TimeCompare( &rec[0], &temp[0], LOAD_CURVE_TIME_LEN ) == TIME_LARGER )
        {		
            FramWrite( ADDR_OF_LOAD_CURVE_SAVE+(ushort)LoadCurvePointer*OFFSET_LOAD_CURVE_SAVE, &rec[0], 9 );
            LoadCurvePointer++;
            if( LoadCurvePointer >= LOAD_CURVE_CNT_PER_PAGE )
            {
                LoadCurvePointer = 0;
                SaveLoadCurveToFlash();
                LoadCurvePagePointer++;
                SumLoadCurvePagePointer++;
                if( LoadCurvePagePointer >= MAX_PAGE_POINTER )
                {
                    LoadCurvePagePointer = 0;
                }
                FramWrite( ADDR_OF_LOAD_CURVE_PAGE_PTR, (unsigned char *)&LoadCurvePagePointer, 2 );
                FramWrite( ADDR_OF_SUM_LOAD_PAGE_PTR, (unsigned char *)&SumLoadCurvePagePointer, 4 );
            }
            FramWrite( ADDR_OF_LOAD_CURVE_COUNT, (unsigned char *)&LoadCurvePointer, 1 );
        }
        else
        {                    
            seq = FindTimePosition( &rec[0] );
            if( seq == 2 )
            {
                LoadCurvePagePointer = (ushort)((DI1DI0-BASE_LOAD_CURVE)/DF_PAGE_LEN);
                if( LoadCurvePagePointer == 0 )
                {
                    LoadCurvePagePointer = 1;
                }
            }
            else if( seq == ERROR )
            {
                LoadCurvePagePointer = 1;
            }
			
            FramRead(ADDR_OF_LOAD_CURVE_SAVE+(ushort)LoadCurvePointer*OFFSET_LOAD_CURVE_SAVE, &FrameBuffer[0], OFFSET_LOAD_CURVE_SAVE );
            LoadCurvePointer = 1;			
            memcpy( &FrameBuffer[0], &rec[0], 9 );
            FramWrite( ADDR_OF_LOAD_CURVE_SAVE, &FrameBuffer[0], OFFSET_LOAD_CURVE_SAVE );            
            for( i = 1; i < LOAD_CURVE_CNT_PER_PAGE; i++ )
            {
                MemSetoWriteE2prom( ADDR_OF_LOAD_CURVE_SAVE+OFFSET_LOAD_CURVE_SAVE*i, OFFSET_LOAD_CURVE_SAVE );
            }						
            FramWrite( ADDR_OF_LOAD_CURVE_COUNT, (unsigned char *)&LoadCurvePointer, 1 );
            FramWrite( ADDR_OF_LOAD_CURVE_PAGE_PTR, (unsigned char *)&LoadCurvePagePointer, 2 );
        }        
    }	
}