AVR Freaks

Well when I write
while(!(TWCR&(1<<TWINT)))
Then it gets struck inside the loop and don't comes out of it and when i read TWCR for TWINT bit it always read 0.
That is what i wrote in #1 that we have to wait till TWINT becomes 0 and it should come out if the loop when it is 0 and stays in loop when it is 1 . But on writing this statement it is happening opposite .

[/

Just a minute ....by this u mean that when i read TWINT bit in TWCR it shows me the status of TWINT flag and not TWINT bit ... That is when i it shows 0 it means that it is showing me the status of flag ( which is cleared that is why showing 0) and not of the TWINT bit ( which is in actually 1 as flag is cleared) . Similar when it shows 1 it means that my TWINT flag is set and showing the status of the flag and not of the TWINT bit ( which is in actually 0 as flag is set) .
?????

well yes and i found one interesting thing 

my function is now returning 2  

in the given code 

bit1()- prints the binary value of the register mentioned in its bracket

printstring1() - prints the string written in its bracket on the screen

^{/*
uint8_t I2C_start(uint8_t address)
This function needs to be called any time a connection to a new slave device should be established. 
The function returns 1 if an error has occurred, otherwise it returns 0.}

^{The syntax to start a operation write to a device is either: I2C_start(SLAVE_ADDRESS+I2C_WRITE); or 
I2C_start(SLAVE_WRITE_ADDRESS);}

^{The syntax to start a read operation from a device is either: I2C_start(SLAVE_ADDRESS+I2C_READ); or
 I2C_start(SLAVE_READ_ADDRESS);
 */}

 

 ^{uint8_t i2cstart( uint8_t address)
 {   
     //transmission start condition
    TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
    //wait for end of transmission
    while ((TWCR & (1<<TWINT))==0);          
    
    //check if the start condition was successfully transmitted
  
    if ((TWSR & 0xF8)!= 0x08)
    {
        //bit1(TWSR);
        return 1;
    }
  
    //load slave address into data register
    TWDR=address;         
    //start transmission of address           
    TWCR= (1<<TWINT)|(1<<TWEN);     
    //wait for end of transmission 
    
    while(!(TWCR&(1<<TWINT))) ;   
   
    // check if the device has acknowledged the READ / WRITE mode
    uint8_t twst = TWSR & 0xF8;
    if ( (twst != 0x18) || (twst != 0x40) ) 
    {
        
        return 2;
        }
    
    return 0;    
}}

 

^/*

^{function for debugging start function} 

^*/

  ^{void teststart(uint8_t address)
  {      a=i2cstart(address);
             switch(a)
      {
           case 1 : printString1(" start condition fail  \n");
                   
            
                    break;
           case 0:  printString1(" succefull \n");
                    break;
           case 2:  printString1("device has not acknowledged the READ / WRITE mode \n");
                    break;
      }
      
      
  }
  /*
  void I2C_stop(void)
  This function disables the TWI peripheral completely and therefore disconnects
  the device from the bus.
   */
  void i2cstop()
  { 
     
      TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWSTO);
      bit0(TWCR);
      printString0("\n");
      while(!(TWCR &(1<<TWINT))==0); //checks whether stop is send or not.
      //bit1(TWCR);
      //printString1("\n");
  }}

^{// for master receiver- data send with the address is SLA+R(1)
 //for master transmitter - data send with address is SLA+W(0)
 /*
 uint8_t I2C_write(uint8_t data)
 This function is used to write data to the currently active device. The only parameter
 this function takes is the 8 bit unsigned integer to be sent. 
 The function returns 1 if an error has occurred, otherwise it returns 0.
 */
 uint8_t i2cwrite(char  data)
 {   
     // load data into data register
     TWDR = data;
     // start transmission of data
     TWCR = (1<<TWINT) | (1<<TWEN);
    // printString1("nkjk \n ");
    // bit1(TWCR);
     // wait for end of transmission
     while( (TWCR & (1<<TWINT))==0);
    // printString1("kol \n");
     // check if the device has transmitted the data byte
     if( (TWSR & 0xF8) != 0x28 ){ return 1; }
     
     return 0;
     
}
void testwrite( char data )
{     b=i2cwrite( data);
    switch(b)
    {
        
        case 0:  printString1(" write ack received \n");
        break;
        case 1:  printString1(" write ack not received \n ");
        break;
        
    }
    
}}

^{int main(void)
{   UART_Init1(); 
    printString1("*******************Welcome to i2c ********************* \n");
    char array[10]="kunal";
    i2cinit();
  
    while (1) 
    {
        teststart(11110010);
        _delay_ms(1000);
        //testwrite(11111111);
        i2cstop();
    }
}}
 

Now interesting thing is that  my stop function gets struck inside the while loop when i write  ^{while(!(TWCR &(1<<TWINT)))} and it gets struck inside the stop function only  and doesnt come out of it.

and When i write ^{while(!(TWCR &(1<<TWINT))==0);}  my function is now returning 2 as u can see in image attached () on returning 2 it is showing ^{device has not acknowledged the READ / WRITE mode}    AND value which is shown in figure is the status of the TWSR register which is -0x20. though my function comes out of the while loop and from stop function but on printing the status of  TWINT it always shows 0 which means that my flag is cleared and not setting .

So their is problem in my stop event of the i2c . So any suggestions why so happening , is their any mistake in the choronolgy of the code or functions are wrong defined??????