data_flash.c

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

#include "includes.h"

unsigned char DataflashModelFlag = 0;

void DFClock( unsigned char cnt )
{
    DATA_FLASH_SI_OUT &= (unsigned char)(~DATA_FLASH_SI );
    do{
        DATA_FLASH_SCL_OUT &=~ ( DATA_FLASH_SCL );
        DATA_FLASH_SCL_OUT |= DATA_FLASH_SCL;
    }while( --cnt );
}

void DataflashWriteByte( unsigned char wrbyte )
{
    unsigned char BitCounter = 8;

    do{
        DATA_FLASH_SCL_OUT &=~ ( DATA_FLASH_SCL );
        
        if( wrbyte & 0x80 ) 
        {   
            DATA_FLASH_SI_OUT |= DATA_FLASH_SI;
        }
        else 
        {
            DATA_FLASH_SI_OUT &=  (uchar)(~( DATA_FLASH_SI ));
        }
        
        DATA_FLASH_SCL_OUT |= DATA_FLASH_SCL;
        wrbyte <<= 1;
    }while( --BitCounter );
}

unsigned char DataflashReadByte(void)
{
    unsigned char rdbyte = 0, BitCounter = 8;

    do{
        DATA_FLASH_SCL_OUT &=~ ( DATA_FLASH_SCL );
        rdbyte <<= 1;
        
        DATA_FLASH_SCL_OUT |= DATA_FLASH_SCL;
        
        if( DATA_FLASH_SO_IN & DATA_FLASH_SO ) 
        {
            rdbyte++;
        }
    }while( --BitCounter );
    
    return( rdbyte );
}

const unsigned char _df_cmd_mode[] =
{
    DF_ENTER_SLEEP,
    DF_ENTER_ACTIVE
};

void DataflashEnterMode(unsigned char sel)
{
    DATA_FLASH_CS_OUT &=~ ( DATA_FLASH_CS );
    DataflashWriteByte( _df_cmd_mode[sel] );
    DATA_FLASH_CS_OUT |= ( DATA_FLASH_CS );
    Delay(100);	
}

unsigned char DataflashStatusRead( unsigned char sta_sel )
{
    unsigned char sta,times = 0;

    do{
        DATA_FLASH_CS_OUT &=~ ( DATA_FLASH_CS );
        DataflashWriteByte( sta_sel );
        sta = DataflashReadByte();
        DATA_FLASH_CS_OUT |= DATA_FLASH_CS;
        DATA_FLASH_SI_OUT |= DATA_FLASH_SI;
        DATA_FLASH_SCL_OUT |= DATA_FLASH_SCL;
        ClrWdt();
        if( sta & 0x80 ) 
        {
            AlarmCtlWord1 &=~ ALARM_OF_DATA_FLASH;
            if( ( sta & DATA_FLASH_MODEL_16 ) == DATA_FLASH_MODEL_16 )
            {
                DataflashModelFlag &=~ DATA_FLASH_MODEL_ERR;
                return OK;		  		
            }
        }
    }while( times++ < 100 );
	
    AlarmCtlWord1 |= ALARM_OF_DATA_FLASH;
    DataflashModelFlag |= DATA_FLASH_MODEL_ERR;	
    return ERROR;
}

const unsigned char _df_cmd_rbuff[]=
{
    DF_READ_BUFFER1,
    DF_READ_BUFFER2
};

void DataflashBufferRead( unsigned char buff, unsigned short addr, unsigned char *data, unsigned short len )
{
    DATA_FLASH_CS_OUT &=~ ( DATA_FLASH_CS );
    DataflashWriteByte( _df_cmd_rbuff[buff] );
    DFClock(8);
    DataflashWriteByte( ( unsigned char )( addr >> 8 ) );
    DataflashWriteByte( ( unsigned char )addr );
    DFClock(8);
    do{
        *data = DataflashReadByte();
        data++;
    }while( --len );
    
    DATA_FLASH_CS_OUT |= DATA_FLASH_CS;
    DATA_FLASH_SI_OUT |= DATA_FLASH_SI;
    DATA_FLASH_SCL_OUT |= DATA_FLASH_SCL;
}

const unsigned char _df_cmd_wbuff[]=
{
    DF_WRITE_BUFFER1,
    DF_WRITE_BUFFER2
};

const unsigned char _df_cmd_sta[]=
{
    DF_READ_STATUS1,
    DF_READ_STATUS2
};

void DataflashBufferWrite( unsigned char sel, unsigned short addr, unsigned char *data, unsigned short len )
{
    DATA_FLASH_CS_OUT &=~ ( DATA_FLASH_CS );
    DataflashWriteByte(_df_cmd_wbuff[sel]);
    DFClock(8);
    DataflashWriteByte( ( unsigned char )( addr >> 8 ) );
    DataflashWriteByte( ( unsigned char )addr );
    do{
        DataflashWriteByte( *data );
        data++;
    }while( --len );
    DATA_FLASH_CS_OUT |= DATA_FLASH_CS;
    DATA_FLASH_SI_OUT |= DATA_FLASH_SI;
    DATA_FLASH_SCL_OUT |= DATA_FLASH_SCL;
    DataflashStatusRead( _df_cmd_sta[sel] );
}

const unsigned char _df_cmd_mtb[]=
{
    DF_MAIN_TO_BUFFER1,
    DF_MAIN_TO_BUFFER2
};
unsigned char DataflashMainToBuffer( unsigned char sel, unsigned short page )
{
    DataflashEnterMode( DF_ACTIVE );
    page <<= 2;
    DATA_FLASH_CS_OUT &=~ ( DATA_FLASH_CS );
    DataflashWriteByte( _df_cmd_mtb[sel] );
    DataflashWriteByte( (unsigned char)( page >> 8 ) );
    DataflashWriteByte( (unsigned char)page );
    DFClock(8);
    DATA_FLASH_CS_OUT |= DATA_FLASH_CS;
    DATA_FLASH_SI_OUT |= DATA_FLASH_SI;
    DATA_FLASH_SCL_OUT |= DATA_FLASH_SCL;
    return( DataflashStatusRead(_df_cmd_sta[sel] ) );
}

const unsigned char _df_cmd_btm[]=
{
    DF_WMM_WBIE_BUF1,
    DF_WMM_WBIE_BUF2
};
unsigned char DataflashBufferToMainProg( unsigned long * cnt, unsigned char sel, unsigned short page )
{
    unsigned char times = 0;

    (*cnt)++;
    DataflashBufferWrite( sel, DF_PAGE_LEN, ( unsigned char * )cnt, 4 );
	
    page <<= 2; 
    do{
        DATA_FLASH_WP_OUT |= DATA_FLASH_WP;
        _NOP();
        _NOP();
        DATA_FLASH_CS_OUT &=~ ( DATA_FLASH_CS );
        DataflashWriteByte(_df_cmd_btm[sel]);
        DataflashWriteByte( ( unsigned char )( page >> 8 ) );
        DataflashWriteByte( ( unsigned char )page );
        DFClock(8);
        DATA_FLASH_CS_OUT |= DATA_FLASH_CS;
        Delay(250);
        if( DataflashStatusRead( _df_cmd_sta[sel] ) == OK )
        {
            DATA_FLASH_WP_OUT &=~ DATA_FLASH_WP;
            return OK;
        }
    }while( ++times < 3 );
    DATA_FLASH_WP_OUT &=~ DATA_FLASH_WP;
    return ERROR;
}

const unsigned short _df_sector_page_sta[]=
{
    8,256,512,512*2,512*3,512*4,512*5,512*6,512*7,512*8,
};
const unsigned short _df_sector_page_cnt[]=
{
    8,248,256,512,512,512,512,512,512,512,
};

void DataflashBufferToMain( unsigned char sel, unsigned short page )
{
    unsigned long data_flash_sector_wr_cnt;
    unsigned long sub_cnt;
    unsigned char data_flash_sector_item;
    unsigned short rfrshpt;

    for( data_flash_sector_item = 0; data_flash_sector_item < DATA_FLASH_SECTOR_CNT; data_flash_sector_item++ )
    {
        if( page < _df_sector_page_sta[data_flash_sector_item] )
        {
            data_flash_sector_wr_cnt = 0;
            FramRead( ADDR_OF_DF_CNT_START + data_flash_sector_item * DF_CNT_REC_SIZE, (unsigned char *)&data_flash_sector_wr_cnt, SECTOR_WRT_CNT_SIZE );
            goto DATA_FLASH_BUFFER_TO_MAIN_STA;
        }
    }
    
    return;
    
DATA_FLASH_BUFFER_TO_MAIN_STA:

    DataflashBufferToMainProg( &data_flash_sector_wr_cnt, sel, page );
    
    FramRead( ( ADDR_OF_DF_CNT_START + data_flash_sector_item * DF_CNT_REC_SIZE + OFFSET_SECTOR_RFRSH_PT), (unsigned char *)&rfrshpt, SECTOR_RFRSH_PT_SIZE );

    DataflashMainToBuffer1( _df_sector_page_sta[data_flash_sector_item-1] + rfrshpt );

    DataflashBuffer1Read( DF_PAGE_LEN, (unsigned char*)(&sub_cnt), 4 );
    
    if( ( unsigned long )( data_flash_sector_wr_cnt - sub_cnt ) >= DATA_FLASH_REFRESH_CNT )
    {
        DataflashBuffer1Write( DF_PAGE_LEN, ( unsigned char* )( &data_flash_sector_wr_cnt ), 4 );
        DataflashBuffer1ToMain( _df_sector_page_sta[data_flash_sector_item-1] + rfrshpt );
    }
    DataflashEnterMode( DF_SLEEP );
    rfrshpt++;            
    rfrshpt = rfrshpt % _df_sector_page_cnt[data_flash_sector_item];    
    FramWrite( ADDR_OF_DF_CNT_START + data_flash_sector_item * DF_CNT_REC_SIZE, (unsigned char *)&data_flash_sector_wr_cnt, SECTOR_WRT_CNT_SIZE );
    FramWrite( ADDR_OF_DF_CNT_START + data_flash_sector_item * DF_CNT_REC_SIZE + OFFSET_SECTOR_RFRSH_PT, (unsigned char *)&rfrshpt, SECTOR_RFRSH_PT_SIZE );
}

void DataflashClearBuffer( unsigned char sel, unsigned char sta, unsigned short len )
{
    unsigned short ii = 0;
    
    DATA_FLASH_CS_OUT &=~ ( DATA_FLASH_CS );
    DataflashWriteByte( _df_cmd_wbuff[sel] );
    DFClock(16);
    DataflashWriteByte(sta);
    do{
        DataflashWriteByte(0);
    }while( ii++ < len );
    DATA_FLASH_CS_OUT |= DATA_FLASH_CS;
    DATA_FLASH_SI_OUT |= DATA_FLASH_SI;
    DATA_FLASH_SCL_OUT |= DATA_FLASH_SCL;
    
    DataflashStatusRead( _df_cmd_sta[sel] );
}

void DataflashClearPages( unsigned long addr, unsigned char sta, unsigned short len, unsigned char pages )
{
    unsigned char ii;

    addr /= DF_PAGE_LEN;
    for( ii = 0; ii < pages; ii++ )
    {
        if( !IsPowerOn() ) break;
        DataflashMainToBuffer1(addr);
        DataflashClearBuffer(0,sta,len);
        DataflashBuffer1ToMain(addr);
        addr++;
    }
}

void DataflashReadByBuffer1( unsigned long addr, unsigned char *data, unsigned short len )
{
    unsigned short ofst = (ushort)(addr % DF_PAGE_LEN);
    unsigned short page = (ushort)(addr / DF_PAGE_LEN);
    
    if( DataflashMainToBuffer1(page) == OK )
    {
        DataflashBuffer1Read( ofst, data, len );
    }
    DataflashEnterMode( DF_SLEEP );    
}

void DataflashWriteByBuffer1( unsigned long addr, unsigned char *data, unsigned short len )
{
    unsigned short ofst = (ushort)(addr % DF_PAGE_LEN);
    unsigned short usPage = (ushort)(addr / DF_PAGE_LEN);

    if( DataflashMainToBuffer1(usPage) == OK )
    {
        DataflashBuffer1Write( ofst, data, len );
        DataflashBuffer1ToMain( usPage );
    }
    DataflashEnterMode( DF_SLEEP );
}