i2cs.c

ST7 Mcu I2C slave mode code for learning

    if(FirstByte)
    {
        FirstByte = FALSE;
        if (!MaxSize)    
        {   //add brace                      
            Temp = I2CDR; /* temporary register to neglect the byte          */
        }    
        else
        {   //add brace                      
            *(I2Cs_GlobalBuff + I2Cs_IntrCounter ) = I2CDR;
        }    
        I2Cs_IntrCounter++;                                                   
    }
    /* Enable the interrupt                                                  */     
    I2CCR |= I2Cs_ITE; 

}
#endif


/*-----------------------------------------------------------------------------
ROUTINE NAME : I2Cs_IsReceptionCompleted
INPUT        : None 
OUTPUT       : Returns the reception status
DESCRIPTION  : Returns the reception status and checks the pending request.
COMMENTS     : Must be called after reception function in Interrupt driven 
               mode.In polling mode this function is called only after 
               I2Cs_GetByte.
-----------------------------------------------------------------------------*/
I2Cs_ErrCode_t I2Cs_IsReceptionCompleted(void)
{
    unsigned char Temp1, Temp2;
    Temp1 = I2CSR1;
    Temp2 =(unsigned char)(I2CSR2 | I2CST2); 
    /* Check error condition                                                 */
    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 )   
        {
            I2Cs_Reception = FALSE;
            #if (defined I2C_ITDRV_WITHOUTBUF_RX ||defined I2C_ITDRV_WITHOUTBUF_TX )
            I2CCR |= I2Cs_ITE;
            #endif
            if( I2Cs_IntrCounter == 0 ) 
	    {//added braces
                return I2Cs_STOP_DETECTED;   /* Single Byte or no byte       */
	    }
            else
            {    
                if ( I2Cs_IntrCounter <= I2Cs_MaxSize )
		{//added braces
                    return I2Cs_RX_DATA_OK;    /* Buffer Tx                  */
		}
                else
		{//added braces
                    return I2Cs_OVERFLOW_RX; 
		}   
            }        
        }            
        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) )
    else if ((Temp1 &  I2Cs_ADSL) && (!(Temp2 & I2Cs_BRR)) )      
    {
        I2Cs_IntrCounter = I2Cs_MaxSize = 0;
        if ( Temp2 & I2Cs_GCAL )   
	{//added braces                         
            return I2Cs_GENERAL_CALL;
	}
        else   
	{//added braces 
            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_RX 
    /* Only for I2Cs_PutByte and detecting start, stop condition             */
    else if ((Temp1 & I2Cs_BTF) && (!(Temp1 & I2Cs_TRA)))//right operand put in parantheses
	{//added braces
        return I2Cs_RX_DATA_OK;
	}
    #endif 
   
    #ifdef I2C_ITDRV_WITHOUTBUF_RX
    else if ( I2Cs_Reception )
    {
        if(!FirstByte)
        {   //add brace                      
            I2Cs_Reception = FALSE;    
        }    
        if( FirstByte == TRUE )
        {   //add brace                      
            return I2Cs_RX_DATA_OK;                          
        }    
         /* Check whether Single Byte or Buffer reception                    */    
        if((I2Cs_MaxSize == 1 ) && ( I2Cs_IntrCounter == 0 ))
        {   //add brace                      
            return I2Cs_RX_DATA_OK;
        }    
        else                                 
        {   //add brace                      
            return I2Cs_BUFF_RX_ONGOING;     
        }    
                 
    }
    #endif         
    else if (( I2Cs_IntrCounter == 0) && ( I2Cs_MaxSize == 0 ))
	{//added braces
        return I2Cs_EMPTY;    
	}    
    else
	{//added braces
        return I2Cs_DEFAULT_STATUS; 
	}       
   
}    


/*-----------------------------------------------------------------------------
ROUTINE NAME : I2Cs_ErrorClear
INPUT        : None
OUTPUT       : None
DESCRIPTION  : Data transmission and reception takes place in interrupt 
               subroutine for Interrupt driven without buffer mode. 
COMMENTS     : None
-----------------------------------------------------------------------------*/
void I2Cs_ErrorClear(void )
{
    unsigned char Temp;
    Temp = I2CSR1;
    Temp = I2CSR2;
    I2CST2 = I2CST1 = 0;
}


/*-----------------------------------------------------------------------------
ROUTINE NAME : I2Cs_ITFunction
INPUT        : None
OUTPUT       : None
DESCRIPTION  : Data transmission and reception takes place in interrupt 
               subroutine for Interrupt driven without buffer mode. 
COMMENTS     : None
-----------------------------------------------------------------------------*/
void I2Cs_ITFunction(void)
{
    #if (defined I2C_ITDRV_WITHOUTBUF_RX ||defined I2C_ITDRV_WITHOUTBUF_TX )

    unsigned char Temp;   
    I2CST1 = I2CSR1; 
    /* Copy the error variable                                               */  
    I2CST2 = I2CSR2; 
    /* Below will be the code for communication and also the control for this
       has been given                                                        */    
     
    /* Check whether it should be done in ISR or in main                     */
    if ( I2CST2 & I2Cs_ERR) 
    {
        if((I2CST2 & I2Cs_STOPF) || (I2CST2 & I2Cs_BRR))
        {   //add brace                      
            I2Cs_Com_Mode = I2Cs_DEFAULT;    
        }          
        I2CCR &= (unsigned char)(~(unsigned char)(I2Cs_ITE));/* Disable interrupt             */    
    }    
    else if ( I2CST1 & I2Cs_ADSL ) /* EV1 address detected                   */
    {
        I2CCR &= (unsigned char)(~(unsigned char)(I2Cs_ITE));/* Disable interrupt             */            
        I2Cs_Com_Mode = I2Cs_DEFAULT;  
        I2Cs_StartStatus = TRUE;                                                    
        
    }    
    else if ((I2CST1 & I2Cs_BTF) && (!( I2CST2 & I2Cs_AF )))
    {                  
        if ( I2Cs_Com_Mode == I2Cs_DEFAULT )
        {
            if ( I2CST1 & I2Cs_TRA )
            { 
                /* Slave is in transmitter mode                              */
                I2Cs_Com_Mode = I2Cs_TX_MODE;                                          
                /* Disable the interrupt                                     */    
                I2CCR &= (unsigned char)(~(unsigned char)(I2Cs_ITE));

            }
            else
            {   /* Slave is in receiver mode                                 */
                I2Cs_Com_Mode = I2Cs_RX_MODE;                
                FirstByte = TRUE;
                I2Cs_Reception = TRUE;
                I2CCR &= (unsigned char)(~(unsigned char)(I2Cs_ITE));
                /* Disable the interrupt                                     */    
            }
        }   
        #ifdef I2C_ITDRV_WITHOUTBUF_TX
        else if ( I2Cs_Com_Mode == I2Cs_TX_MODE)
        {
            /*  Confirming for right communication mode                      */
            if ( I2CST1 & I2Cs_TRA ) 
            {   
                I2Cs_Transmission = TRUE;                                
                /* Check whether Single byte or Buffer transmission          */       
                if ((I2Cs_MaxSize == 1) && (I2Cs_IntrCounter == 0))
                {   //add brace                      
                    I2CCR &= (unsigned char )(~(unsigned char)(I2Cs_ITE));
                }    
                else
                {
                    if ( I2Cs_IntrCounter < I2Cs_MaxSize)
                    {   //add brace                      
                        I2CDR = *(I2Cs_GlobalBuff + I2Cs_IntrCounter );
                    }    
                    else
                    {   //add brace                      
                        I2CDR = 0xFF; /* Dummy byte                          */ 
                    }    
                    I2Cs_IntrCounter++;
                }     
            }        
           
        }  
        #endif
           
        #ifdef I2C_ITDRV_WITHOUTBUF_RX
        else if ( I2Cs_Com_Mode == I2Cs_RX_MODE )
        {                                                                      
            /*  Confirming for right communication mode                      */
            if (!(I2CST1 & I2Cs_TRA))
            {   
                I2Cs_Reception = TRUE;                       
                /* Check whether Single byte or Buffer reception             */                       
                if ((I2Cs_MaxSize == 1) && (I2Cs_IntrCounter == 0))
                {   //add brace                      
                    I2CCR &= (unsigned char)(~(unsigned char)(I2Cs_ITE));
                }    
                else 
                {
                    if ( I2Cs_IntrCounter < I2Cs_MaxSize)
                    {   //add brace                      
                        *(I2Cs_GlobalBuff + I2Cs_IntrCounter ) = I2CDR;
                    }    
                    else
                    {   //add brace                      
                        Temp = I2CDR; /* Dummy byte                          */ 
                    }    
                    I2Cs_IntrCounter++;
                }     
            }        
        }  /* End 'I2Cs_RX_MODE' if loop                                     */
        #endif
    }  /* End 'BTF' if loop                                                  */
    #endif
} /* End 'Interrupt'  loop                                                   */