dviic.c

一个调整ADC gain offset 的程序

#include "mtv415.h"
#include "dvIIC.h"
#include "extData.h"
#include "intrins.h"
// ---------------------------------------------------------------------------
//     G L O B A L   D E F I N I T I O N S                                  
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//     L O C A L   S Y M B O L   D E C L A R A T I O N S                    
// ---------------------------------------------------------------------------

BOOL   g_bIICError;

static BOOL   m_bNoAck;
static BYTE   m_cIICTimer;

#define  SendBits(cData)  MBUF = cData

#define	SendIICStart()  	{                              \
	                                         IICCTR = 0x00;\
                                          	 IICCTR = 0x01;\
                            }

#define  SendIICStop()       {                                \
                                                IICCTR = 0x00;\
                                                IICCTR = 0x02;\
                                                INTFLG1 =  0x00;\
                             }


// ---------------------------------------------------------------------------
//     L O C A L   F U N C T I O N S   P R O T O T Y P E S                  
// ---------------------------------------------------------------------------

static  void   IICAckWait(void);
void  IICWrite(
               BYTE	cDeviceAddress,
               WORD		wRegisterAddress,
               PBYTE	       pacBuffer,
               WORD            wBufferCount,
               BOOL       bFlag)
		
{
	data WORD i;
	data BYTE cCount = 0;
	g_bIICError = FALSE;
	do
    {
    		cCount ++;
            SendIICStop();
            SendBits(cDeviceAddress);
            SendIICStart();
            IICAckWait();

           if (m_bNoAck)
                  continue;

           if (bFlag)
           {
                   SendBits((BYTE)((wRegisterAddress & 0xFF00) >> 8));
                   IICAckWait();
                   if (m_bNoAck)
                        continue;
            }

  
         	SendBits((BYTE)(wRegisterAddress & 0x00FF));
             	IICAckWait();
              if (m_bNoAck)
              continue;
          
           i = 0;
          
          
         	 for(; i < wBufferCount; i++)
          	{
            	   SendBits(pacBuffer[i]);
       	           IICAckWait();
          		if (m_bNoAck)
                break;

         	 }
    }while (IIC_PROCESS_MAX > cCount && m_bNoAck );
    SendIICStop();
   	if (m_bNoAck)
    	 g_bIICError = TRUE;
}

#if 0
void 	IICByteWrite(BYTE  cDeviceAddress,
                                          BYTE		cRegisterAddress,
                                          BYTE	            cBuffer)
{
	data BYTE cCount = 0;
	g_bIICError = FALSE;
	do
    {
    		cCount ++;
            SendIICStop();
            SendBits(cDeviceAddress);
            SendIICStart();
            IICAckWait();

           if (m_bNoAck)
                  continue;
       
         	SendBits(cRegisterAddress );
         	IICAckWait();
              if (m_bNoAck)
                    continue;
          
            	 SendBits(cBuffer);
               IICAckWait();
          	if (m_bNoAck)
                    continue;

    }while (IIC_PROCESS_MAX > cCount && m_bNoAck );
    SendIICStop();
    
        if(m_bNoAck)
    	 g_bIICError = TRUE;
}
#endif

BOOL	   IICRead(BYTE		cDeviceAddress,
                 		     WORD		wRegisterAddress,
                 		     BYTE*	      pacBuffer,
                             BYTE		cBufferCount,
                             BOOL     bFlag)

{
	
	data BYTE i;
	data BYTE cCount =0;
	g_bIICError = FALSE;
	do
    {
             cCount ++;
             SendIICStop();
             SendBits(cDeviceAddress);
             SendIICStart();
             IICAckWait();
             if (m_bNoAck)
                     continue;
             
             if (bFlag)
             {
                     SendBits((BYTE)((wRegisterAddress & 0xFF00) >> 8));
                     IICAckWait();
         		 if (m_bNoAck)
                         continue;
              }
         	     SendBits((BYTE)(wRegisterAddress & 0x00FF));
         	      IICAckWait();
         	       if (m_bNoAck)
                     continue;
       
         	    SendIICStop();
		    cDeviceAddress = cDeviceAddress | 0x01;
		    SendBits(cDeviceAddress);
		    SendIICStart();
         	    IICAckWait();
         	    if (m_bNoAck)
                  continue;
         	    
            pacBuffer[0]= MBUF;

         	 for(i = 0; i < cBufferCount - 1; i++)
          	{
          	    
                   IICAckWait();
                   if (m_bNoAck)
                   break;
                   pacBuffer[i]= MBUF;
         	 }
         	 
                   if (m_bNoAck)
                   continue;
             
                      IICCTR = 0x05;
			 IICAckWait();
                      if (m_bNoAck)
	               continue;
             
	      pacBuffer[i]= MBUF;

    }while (IIC_PROCESS_MAX > cCount && m_bNoAck );
       SendIICStop();
    
       if(m_bNoAck)
    	 g_bIICError = TRUE;
       return  g_bIICError;
}


static void IICAckWait(void)
{
    _nop_ ();
    _nop_ ();
    _nop_ ();
    _nop_ ();
    
    m_cIICTimer = IIC_WAIT_ACK_TIME;
    while((m_cIICTimer > 0) && ((INTFLG1 & 0x1) == 0));
      
    if (( IICSTUS1 & 0x01 ) == 0)
            m_bNoAck = 0;
    else
            m_bNoAck = 1; 

    INTFLG1 = 0;
}

void IICTimerProcess(void)
{
	if (m_cIICTimer)
    m_cIICTimer --;
}

//HM added,06/07/14
// ---------------------------------------------------------------------------
//Write register value
//
// Params:
//  cSlaveAddr: Slave Address
//  cRegAddr: Register addr
// cRegValue: Register value
//
// Return:
//  None
// ---------------------------------------------------------------------------
void dvRegisterWrite(BYTE cSlaveAddr,BYTE cRegAddr,BYTE cRegValue)
{
   IICWrite(cSlaveAddr,cRegAddr,&cRegValue,1,0);
}
#ifdef IIC
// ---------------------------------------------------------------------------
//Read register value
//
// Params:
//  cSlaveAddr: Slave Address
//  cRegAddr: Register addr
// pcRegValue: Register value
//
// Return:
//  None
// ---------------------------------------------------------------------------
void dvRegisterRead(BYTE cSlaveAddr,BYTE cRegAddr,BYTE *pcRegValue)
{
     IICRead(cSlaveAddr,cRegAddr,pcRegValue,1,0);
   
}
#endif
// ---------------------------------------------------------------------------
// Write some bits of the register
//
// Params:
//  cSlaveAddr : Slave Address
//  cRegAddr: Register addr
// cMaskValue:Mask value
// cRegValue: Value for mask bits
//
// Return:
//  None
// ---------------------------------------------------------------------------
void dvRegisterMaskWrite (BYTE cSlaveAddr,BYTE cRegAddr, BYTE cMaskValue,BYTE cRegValue)
{
     BYTE cValue,cMask;
      cMask = cMaskValue;
     IICRead(cSlaveAddr,cRegAddr,&cValue,1,0);
      cValue &=(~cMaskValue);
       while(!(cMask&0x01))
       	{
       	    cMask = cMask>>1;
       	    cRegValue = cRegValue<<1;
       	}
         cValue |= (cRegValue&cMaskValue);
       IICWrite(cSlaveAddr,cRegAddr,&cValue,1,0);
      
}
#if 0
// ---------------------------------------------------------------------------
// Read some bits of the register
//
// Params:
//  cSlaveAddr : Slave Address
//  cRegAddr: Register addr
// cMaskValue:Mask value
// pcRegValue: Value for mask bits
//
// Return:
//  None
// ---------------------------------------------------------------------------
void dvRegisterMaskRead (BYTE cSlaveAddr,BYTE cRegAddr, BYTE  cMaskValue,BYTE *pcRegValue)
{
    BYTE cValue,cMask;
    IICRead(cSlaveAddr,cRegAddr,&cValue,1,0);
  
      cMask = cMaskValue;
      cValue = cValue&cMaskValue;
       while(!(cMask&0x01))
       	{
       	    cMask = cMask>>1;
       	    cValue = cValue>>1;
       	}
         *pcRegValue = cValue;               
}

#endif