att702x.c

珠海炬力计量芯片ATT702x驱动程序

#include "includes.h"

const unsigned char _att702x_wr[]=
{
    ATT_ADDR_IREGION1,
    ATT_ADDR_IREGION2,
    ATT_ADDR_IREGION3,
    ATT_ADDR_IREGION4,
    ATT_ADDR_PGAINA0, 
    ATT_ADDR_PGAINB0, 
    ATT_ADDR_PGAINC0, 
    ATT_ADDR_PGAINA1, 
    ATT_ADDR_PGAINB1, 
    ATT_ADDR_PGAINC1, 
    ATT_ADDR_PHSREGA0,
    ATT_ADDR_PHSREGA1,
    ATT_ADDR_PHSREGA2,
    ATT_ADDR_PHSREGA3,
    ATT_ADDR_PHSREGA4,

    ATT_ADDR_PHSREGB0,
    ATT_ADDR_PHSREGB1,
    ATT_ADDR_PHSREGB2,
    ATT_ADDR_PHSREGB3,
    ATT_ADDR_PHSREGB4,

    ATT_ADDR_PHSREGC0,
    ATT_ADDR_PHSREGC1,
    ATT_ADDR_PHSREGC2, 
    ATT_ADDR_PHSREGC3, 
    ATT_ADDR_PHSREGC4, 

    ATT_ADDR_UGAINA,   
    ATT_ADDR_UGAINB,   
    ATT_ADDR_UGAINC,   

    ATT_ADDR_IRECHG,   
    ATT_ADDR_ISTARTUP, 

    ATT_ADDR_HFCONST,  
    ATT_ADDR_LFCONST,    

    ATT_ADDR_IGAINA,     
    ATT_ADDR_IGAINB,     
    ATT_ADDR_IGAINC,     

    ATT_ADDR_FAILVOLTAGE,
    ATT_ADDR_EADDMODE,   
    ATT_ADDR_ENDTIORDER, 

    ATT_ADDR_HFDOUBLE,   
    ATT_ADDR_UADCPGA,

    ATT_ADDR_ENLINEFREQ,
    ATT_ADDR_ENHARMONIC,
    ERROR
};

unsigned short DeltaWattActiveZ[4] = {0,0,0,0};
unsigned short DeltaWattActiveF[4] = {0,0,0,0};
unsigned short DeltaWattReactiveZ[4] = {0,0,0,0};
unsigned short DeltaWattReactiveF[4] = {0,0,0,0};
unsigned short DeltaWattLActive[4] = {0,0,0,0};
unsigned short DeltaWattLReactive[4] = {0,0,0,0};

void Att702xSeqErrDet(void)
{
    unsigned char  irq[3];
    
    Att702xRead( ATT_ADDR_SFLAG, irq );
    if( !( irq[0] & ATT_SFLAG_MASK_ISEQERR ) )
    {
        if(  EvtTimerCounterflag & BIT0 )
        {
            EvtTimerCounterflag &=~ BIT0;
            EvtTimerCounter[0] = 0;
        }
		
        if( AlarmCtlWord1 & ALARM_OF_ISEQERR )
        {
            if( EvtTimerCounter[0]++ > _SysPotInfo.timer_count[EVT_TC_CURSEQERR] )
            {
                EvtTimerCounter[0] = 0;
                AlarmCtlWord1 &=~ ALARM_OF_ISEQERR;
                MeterRunningState &=~ PS_DIR;			
                SaveEvtStopInfo(1);				
            }
        }        
    }
    else
    {
        if( !(EvtTimerCounterflag & BIT0 ) )
        {
            EvtTimerCounterflag |= BIT0;
            EvtTimerCounter[0] = 0;
        }
    
        if( !( AlarmCtlWord1 & ALARM_OF_ISEQERR ) )
        {
            if( EvtTimerCounter[0]++ > _SysPotInfo.timer_count[EVT_TC_CURSEQERR] )
            {
                EvtTimerCounter[0] = 0;        
                AlarmCtlWord1 |= ALARM_OF_ISEQERR;
                MeterRunningState |= PS_DIR;			
                SaveEvtStartInfo(1);
            }				
        }        
    }

    if( !( irq[0] & ATT_SFLAG_MASK_VSEQERR ) )
    {
        if(  EvtTimerCounterflag & BIT4 )
        {
            EvtTimerCounterflag &=~ BIT4;
            EvtTimerCounter[4] = 0;
        }
		
        if( AlarmCtlWord2 & ALARM_OF_VSEQERR )
        {
            if( EvtTimerCounter[4]++ > _SysPotInfo.timer_count[EVT_TC_VOLSEQERR] )
            {
                EvtTimerCounter[4] = 0;
                AlarmCtlWord2 &=~ ALARM_OF_VSEQERR;	
                SaveEvtStopInfo(0);				
            }
        }            
    }
    else
    {
        if( !(EvtTimerCounterflag & BIT4 ) )
        {
            EvtTimerCounterflag |= BIT4;
            EvtTimerCounter[4] = 0;
        }
    
        if( !( AlarmCtlWord2 & ALARM_OF_VSEQERR ) )
        {
            if( EvtTimerCounter[4]++ > _SysPotInfo.timer_count[EVT_TC_VOLSEQERR] )
            {
                EvtTimerCounter[4] = 0; 
                AlarmCtlWord2 |= ALARM_OF_VSEQERR;			
                SaveEvtStartInfo(0);
            }				
        }            
    }
}

void Att702xReinit(void)
{
    unsigned char i, data1[ATT_REGISTER_LEN];
    
    if( !IsPowerOn() ) return;
	
    memset( &data1[0], 0, ATT_REGISTER_LEN );    
    Att702xWrite( ATT_COMMAND_ADDR_RESET, &data1[0] );
    Delay(2000);
    
    for( i = 0; i < ATT_REGISTER_CAL_NUMBER; i++ )
    {
        Att702xWrite( _att702x_wr[i], (unsigned char *)&_SysPotInfo.att702x_info[i*ATT_REGISTER_LEN] );
    }
}

void Att702xValidityCheck(void)
{
    unsigned char  i;
    unsigned char  item=0,data[3];

    if( IsPowerOn() )
    {
        SpiWriteOrder( 0xc6, 0x5A );        
        for( i = 0; i < ATT_REGISTER_CAL_NUMBER; i++ )
        {
            Att702xRead( _att702x_wr[i], data );            
            if( IsEqual( data, (unsigned char *)&_SysPotInfo.att702x_info[item], ATT_REGISTER_LEN ) != OK )
            {
                goto INIT_ATT702X;
            }
            
            item += ATT_REGISTER_LEN;
        }
        SpiWriteOrder( 0xc6, 0x55 );
    }    
    _sys_evt_del( EVT_INIT_ATT702X );
    AlarmCtlWord3 &=~ ALARM_OF_SPI;
    return;
    
INIT_ATT702X:
    AlarmCtlWord3 |= ALARM_OF_SPI;
    _sys_evt_add( EVT_INIT_ATT702X );
}


/******************************************
从ATT7026中读基波谐波电能
******************************************/
void ReadLinePowerFromAtt7022B(void)
{
    unsigned long LPowerData1, LPowerData2;
    unsigned char i;
    
    if( !IsPowerOn())
    {
        return;
    }
	
    for( i = 0; i<8; i++ )
    {
        Att702xRead( ATT_ADDR_LINE_EPA+i, (unsigned char *)&LPowerData1 );    
        LPowerData1 &= 0xFFFF;                
        Att702xRead( ATT_ADDR_RSPIDATA, (unsigned char *)&LPowerData2 );               
        LPowerData2 &= 0xFFFF;

        if( LPowerData1 != LPowerData2 )
        {
            continue;
        } 
        
        if( i < 4 )
        {
            DeltaWattLActive[i] += LPowerData1;
        }
        else
        {
            DeltaWattLReactive[i-4] += LPowerData1;
        }
    }    
}

void ReadPowerFromAtt702x(void)
{    
    unsigned long ucPowerData1, ucPowerData2;
    unsigned char ucPFlag1[3],ucPFlag2[3];
    unsigned char i,temp;    

    if( !IsPowerOn()) return;
	
    Att702xRead( ATT_ADDR_PFLAG, (unsigned char *)&ucPFlag1[0] );
    Att702xRead( ATT_ADDR_RSPIDATA, (unsigned char *)&ucPFlag2[0] );    
    if( OK != IsEqual(&ucPFlag1[0], &ucPFlag2[0], 3 ) ) return;
	
    for( i = 0; i < 8; i++ )
    {
        if( !IsPowerOn() ) return;
        temp = 0;      
        Att702xRead( ATT_ADDR_EPA2 + i, (unsigned char *)&ucPowerData1 );        
        ucPowerData1 &= 0xFFFF;                
        Att702xRead( ATT_ADDR_RSPIDATA, (unsigned char *)&ucPowerData2 );               
        ucPowerData2 &= 0xFFFF;
        
        if( ucPowerData1 != ucPowerData2 )
        {
            continue;
        }        
        if( ucPFlag1[0] & ( ATT_PFLAG_MASK_BIT << i ) )
        {
            temp=0x55;
        }
                                    
        if( i < 4 )
        {
            if( temp == 0x55 )
            {
                MeterRunningStateWord |= 0x10;
                DeltaWattActiveF[i] += ucPowerData1;              
            }
            else
            {
                MeterRunningStateWord &=~ (0x10);
                DeltaWattActiveZ[i] += ucPowerData1;
            }
        }
        else if(i < 8 )
        {
            if( temp == 0x55 )
            {
                DeltaWattReactiveF[i-4] += ucPowerData1;
                MeterRunningStateWord |= 0x20;
            }
            else
            {
                MeterRunningStateWord &=~ (0x20);
                DeltaWattReactiveZ[i-4] += ucPowerData1;
            }
        }
    }
}

void SpiWriteByte(unsigned char wdata)
{
    unsigned char i;

    for( i = 0; i < 8; i++)
    {        
        if( wdata & 0x80 )
        {
             ATT7022DIN_IN |= ATT7022DIN;
        }
        else
        {
            ATT7022DIN_IN &=~ ATT7022DIN;
        }
        wdata <<= 1;
        ATT7022CLK_OUT |= ATT7022CLK;
        Delay( 60);		
        ATT7022CLK_OUT &=~ ATT7022CLK;       
        Delay( 60);		
    }
}

void SpiWriteOrder(unsigned char addr,unsigned char wdata)
{
    if( IsPowerOn() )
    {
        addr |= 0xC0;    
        ATT7022CS_OUT &=~ ATT7022CS;  
        ATT7022CLK_OUT &=~ ATT7022CLK; 
        Delay(500);
        SpiWriteByte(addr);
        SpiWriteByte(0);
        SpiWriteByte(0);
        SpiWriteByte(wdata);
        ATT7022CLK_OUT |= ATT7022CLK;   
        ATT7022CS_OUT |= ATT7022CS;      
        ATT7022DIN_IN |= ATT7022DIN;
        Delay(500);
    }
}

void Att702xWrite( unsigned char addr, unsigned char *data )
{
    unsigned char i;
    
    if( IsPowerOn() )
    {
        addr |= SPI_WRITE_OPER;
        
        SpiWriteOrder(0xC9, 0x00); 
        ATT7022CS_OUT &=~ ATT7022CS;       
        ATT7022CLK_OUT &=~ ATT7022CLK;
        Delay(500);                
        SpiWriteByte(addr);
        for( i = 0; i < 3; i++)
        {
            SpiWriteByte( *(2+data--) );
        }
        ATT7022CS_OUT |= ATT7022CS;	              
        ATT7022CLK_OUT |= ATT7022CLK;
        ATT7022DIN_IN |= ATT7022DIN;
        Delay(1000);		
        SpiWriteOrder( 0xC9, 0x01 ); 
        Delay(1000);		
    }
}

void Att702xRead( unsigned char  addr, unsigned char *data )
{
    unsigned char i; 

    if( IsPowerOn() )
    {
        ATT7022CS_OUT &=~ ATT7022CS;       
        ATT7022CLK_OUT &=~ ATT7022CLK;
        
        addr = addr & SPI_Read_OPER;
        data += 3;        
        Delay(500);
        SpiWriteByte(addr);        
        for( i = 0; i < 24; i++)
        {
            if( i % 8 == 0 ) data--;
            *data <<= 1;
            ATT7022CLK_OUT &=~ ATT7022CLK;
            Delay( 60 );			
            ATT7022CLK_OUT |= ATT7022CLK;
            Delay( 60 );			
            if( !(ATT7022DOUT_OUT & ATT7022DOUT))
            {
                *data |= 0x01;
            }            
        }
        ATT7022CLK_OUT &=~ ATT7022CLK;
        ATT7022CS_OUT |= ATT7022CS;
        ATT7022CLK_OUT |= ATT7022CLK;
        ATT7022DIN_IN |= ATT7022DIN;
        Delay(1000);
    }
    else
    {
        for( i = 0; i < 3; i++ )
        {
            *( data+i ) = 0;
        }
    }
}