i2cs.c

ST7 Mcu I2C slave mode code for learning

void  I2Cs_PutBuffer(unsigned char *PtrToBuffer,unsigned char MaxSize )
{
    I2Cs_IntrCounter = 0;
    I2Cs_GlobalBuff = PtrToBuffer;
    I2Cs_MaxSize = MaxSize;
 
    if (MaxSize) 
    {   // add braces
        I2CDR =*(I2Cs_GlobalBuff + I2Cs_IntrCounter ); /*Transmit first byte */
    }    
    else             
    {   // add braces
        I2CDR = 0xFF; /* Dummy Bytes                                         */  
    }    
    I2Cs_IntrCounter++;
    /* Enable the interrupt                                                  */
    I2CCR |= I2Cs_ITE; 
}
#endif


/*-----------------------------------------------------------------------------
ROUTINE NAME : I2Cs_IsTransmitCompleted
INPUT        : None
OUTPUT       : Returns the transmission status
DESCRIPTION  : Returns the transmission status and checks the pending request.
COMMENTS     : Must be called after transmission function in Interrupt driven 
               mode.
               In polling mode this function is called only after I2Cs_PutByte.
-----------------------------------------------------------------------------*/
I2Cs_ErrCode_t I2Cs_IsTransmitCompleted(void)
{
    unsigned char Temp1, Temp2;
       
    /* If no data has been transmitted                                       */    
    Temp1 = I2CSR1;
    Temp2 =(unsigned char)(I2CSR2 | I2CST2); 
           
    /* Here are start and stop condition are checked to make sure they are 
       checked even if no bytes are transfered                               */ 
    
    /* To detect the error                                                   */
    if ( Temp2 & I2Cs_ERR )    
    {
        /* Clear the error bits to protect any false detection               */ 
        I2CST2 = 0; 

        if ( Temp2 & I2Cs_BRR )
        {
            #if (defined I2C_ITDRV_WITHOUTBUF_RX ||defined I2C_ITDRV_WITHOUTBUF_TX )
            I2CCR |= I2Cs_ITE;
            #endif
            return I2Cs_BERR;
        }    
        else if ( Temp2 & I2Cs_STOPF )                                                       
        {                                                                          
            #if (defined I2C_ITDRV_WITHOUTBUF_RX ||defined I2C_ITDRV_WITHOUTBUF_TX )
            I2CCR |= I2Cs_ITE;
            #endif
            if( I2Cs_IntrCounter == 0) 
		{//add brace
                return I2Cs_STOP_DETECTED;   /* Single Byte  or no byte      */
		}
            else
            {    
                if ( I2Cs_IntrCounter <= I2Cs_MaxSize )
		    {//add brace
                    return I2Cs_TX_DATA_OK;    /* Buffer Tx                  */
		    }
                else
		    {//add brace
                    return I2Cs_OVERFLOW_TX;   
		    } 
            }        
        }            
        else if( Temp2 & I2Cs_AF) /* The Acknowledge failure error           */
        {
            I2CDR = 0xFF;
            #ifdef I2C_ITDRV_WITHOUTBUF_TX
            I2CCR |= I2Cs_ITE;
            #endif
            return I2Cs_TX_AF;                                                             
            
        }    
        else
        {
            #if (defined I2C_ITDRV_WITHOUTBUF_RX ||defined I2C_ITDRV_WITHOUTBUF_TX )
            I2CCR |= I2Cs_ITE;
            #endif
            return I2Cs_DEFAULT_STATUS;                
        }    
    }                           
    #if (defined I2C_POLLING_RX ||defined I2C_POLLING_TX )    
    /* Here both macro is enabled as Start condition is independent of Mod   */
    else if ((Temp1 &  I2Cs_ADSL) && (!(Temp2 & I2Cs_BRR)) )//right side operand put in parantheses     
    {
        I2Cs_IntrCounter = 0;
        I2Cs_MaxSize = 0;          
        if ( Temp2 & I2Cs_GCAL )      
	    {//add brace                      
            return I2Cs_GENERAL_CALL;
	    }
        else    
	    {//add brace
            return I2Cs_ADDRESS_DETECTED;  
	    }            
    }
    #endif
    #if (defined I2C_ITDRV_WITHOUTBUF_RX ||defined I2C_ITDRV_WITHOUTBUF_TX )
    else if ( I2Cs_StartStatus )
    {                   
        I2Cs_StartStatus = FALSE;
        I2Cs_IntrCounter = I2Cs_MaxSize = 0;
        I2CCR |= I2Cs_ITE;
        if ( Temp2 & I2Cs_GCAL )                            
        {   //add brace                      
            return I2Cs_GENERAL_CALL;
        }
        else                                 
        {   //add brace                      
            return I2Cs_ADDRESS_DETECTED;    
        }              
    }    
    #endif
    #ifdef I2C_POLLING_TX 
    /* Only for I2Cs_PutByte and detecting start, stop condition             */
    else if ((Temp1 & I2Cs_BTF) && (Temp1 & I2Cs_TRA))
	{//add brace
        return I2Cs_TX_DATA_OK;
	}

    #endif 
    #ifdef I2C_ITDRV_WITHOUTBUF_TX                                            
    else if ( I2Cs_Transmission)               
    {
        I2Cs_Transmission = FALSE;                             
        /*Single Byte  Transmission                                          */
        if(( I2Cs_MaxSize == 1 ) && ( I2Cs_IntrCounter == 0) ) 
        {   //add brace                      
            return I2Cs_TX_DATA_OK; 
        }    
        else /* Buffer Transmission                                          */
        {   //add brace                      
            return I2Cs_BUFF_TX_ONGOING;     
        }    
    }  
    #endif      
    else 
	{//add brace
        return I2Cs_DEFAULT_STATUS;    
	}               
            
}


/*-----------------------------------------------------------------------------
ROUTINE NAME : I2Cs_GetByte
INPUT        : None
OUTPUT       : Received data byte 
DESCRIPTION  : Reads the data from i2csDR register and return the received 
               data byte.
COMMENTS     : I2Cs_IsReceptionCompleted is called to check whether data byte
               is received.
-----------------------------------------------------------------------------*/
unsigned char I2Cs_GetByte(void)
{
    unsigned char Temp;
    I2Cs_MaxSize = 1;
    #ifdef I2C_ITDRV_WITHOUTBUF_RX  
    I2Cs_IntrCounter = 0;
    FirstByte = FALSE;
    Temp =  I2CDR;    
    I2CCR |=I2Cs_ITE;          
    return Temp; 
    #endif  
    
    #ifdef I2C_POLLING_RX
    Temp =  I2CDR;
    return Temp;                      
    #endif
}

                                                              
#ifdef I2C_POLLING_RX 
/*-----------------------------------------------------------------------------
ROUTINE NAME : I2Cs_GetBuffer
INPUT 1      : *PtrToBuffer - Starting address of the user buffer
INPUT 2      : NbOfBytes - Number of data bytes to be received
OUTPUT       : Returns the reception status
DESCRIPTION  : In polling mode, Receives data bytes continuously and store them 
               in user buffer. Also returns the reception status.	
COMMENTS     : None
-----------------------------------------------------------------------------*/ 
I2Cs_ErrCode_t I2Cs_GetBuffer(unsigned char *PtrToBuffer, unsigned 
char MaxSize )
{
    unsigned char Temp, Temp1, Temp2, counter = 0;
     /* Check whether BTF is set or not                                      */
    while (!(I2CSR1 & I2Cs_BTF));   
    if (!MaxSize )
	{//add brace
        Temp = I2CDR; /* temporary register                                  */
	}          
    else
	{//add brace
        *(PtrToBuffer + counter) = I2CDR;
	}


    counter++;             
  
    while(1)
    {
        /* Wait for an event to occured                                      */
        Temp1 = I2CSR1;
        while (!( Temp1 & I2Cs_EVF) ) 
        {
            Temp1 = I2CSR1;
        }
         
        Temp2 = I2CSR2;
        /* check for the error                                               */
        if ( Temp2 &  I2Cs_ERR ) 
        {
            if ( Temp2 & I2Cs_BRR)
		{//add brace
                return I2Cs_BERR;
		}
            else if ( Temp2 & I2Cs_STOPF ) 
            {
                if ( counter <= MaxSize ) 
		    {//add brace
                    return I2Cs_RX_DATA_OK;
		    }
                else
		    {//add brace
                    return I2Cs_OVERFLOW_RX;  
		    }                      
            } 
        }
        else if ( Temp1 & I2Cs_ADSL ) 
        {
            /* Check for start or repeated start condtion                    */             
            if ( Temp2 & I2Cs_GCAL )   
		{//add brace                         
                return I2Cs_GENERAL_CALL;
		}
            else 
		{//add brace   
                return I2Cs_ADDRESS_DETECTED;
		}
        }        
        else if ( (Temp1 & I2Cs_BTF) && (!( Temp1 & I2Cs_TRA)) )//right side operand put in parantheses 
        {
            if ( counter < MaxSize)
		{//add brace
                *(PtrToBuffer + counter)  = I2CDR;
		}
            else
		{//add brace
                Temp = I2CDR;    
		}
            counter++;    
        }     
    } /* End while                                                           */

}  
#endif     


#ifdef I2C_ITDRV_WITHOUTBUF_RX		
/*-----------------------------------------------------------------------------
ROUTINE NAME : I2Cs_GetBuffer
INPUT 1      : *PtrToBuffer - Starting address of the user buffer
INPUT 2      : NbOfBytes - Number of data bytes to be received
OUTPUT       : None
DESCRIPTION  : In interrupt driven mode, starts data bytes reception in ISR 
COMMENTS     : None
-----------------------------------------------------------------------------*/ 
void I2Cs_GetBuffer(unsigned char *PtrToBuffer,unsigned char MaxSize )
{
    unsigned char Temp;
    I2Cs_IntrCounter = 0;

    I2Cs_GlobalBuff = PtrToBuffer;
     
    I2Cs_MaxSize =  MaxSize;