[AT91SAM7S] [AT91SAM7S][C] Konfiguracja rejestrów do uruchomienia TWI krok po kroku

// Global declarations 
#define AT91C_TWI_CLOCK            400000      //400kHz 
#define AT91C_FRAM_I2C_ADDRESS     (0xA0<<15)  //adresse fram 

void AT91F_TWI_Open(void); 
int AT91F_TWI_WriteByte (int, char *, int); 
int AT91F_TWI_ReadByte  (int, char *, int );

///*---------------------------------------------------------------------------- 
//* \fn    AT91F_TWI_ReadByte 
//* \brief Read a byte from a slave device 
//*---------------------------------------------------------------------------- 
int AT91F_TWI_ReadByte(int int_address, char *data, int nb) 
{ 
   unsigned int status,counter=0,error=0,mode; 
        AT91PS_TWI pTwi; 
        pTwi = AT91C_BASE_TWI; 
        mode = AT91C_FRAM_I2C_ADDRESS | AT91C_TWI_IADRSZ_2_BYTE; 

        // Set TWI Internal Address Register 
   if ((mode & AT91C_TWI_IADRSZ) != 0) pTwi->TWI_IADR = int_address; 

   // Set the TWI Master Mode Register 
   pTwi->TWI_MMR = mode | AT91C_TWI_MREAD; 

   // Start transfer 
   if (nb == 1){ 
      pTwi->TWI_CR = AT91C_TWI_START | AT91C_TWI_STOP; 
      status = pTwi->TWI_SR; 
          if ((status & ERROR) == ERROR) error++; 
      while (!(status & AT91C_TWI_TXCOMP)){ 
             status = pTwi->TWI_SR; 
              if ((status & ERROR) == ERROR) error++; 
          } 
      *(data) = pTwi->TWI_RHR; 
   } 
    else{ 
       pTwi->TWI_CR = AT91C_TWI_START | AT91C_TWI_MSEN; 
      status = pTwi->TWI_SR; 
      if ((status & ERROR) == ERROR) error++; 

   // Wait transfer is finished 
           while (!(status & AT91C_TWI_TXCOMP)){ 
         status = pTwi->TWI_SR; 
         if ((status & ERROR )== ERROR) error++; 
          if(status & AT91C_TWI_RXRDY){ 
         *(data+counter++) = pTwi->TWI_RHR; 
         if (counter == (nb - 1)) pTwi->TWI_CR = AT91C_TWI_STOP; 
      } 
      } 
   } 
   return 0; 
} 
//*---------------------------------------------------------------------------- 
//* \fn    AT91F_TWI_Open 
//* \brief Initializes TWI device 
//*---------------------------------------------------------------------------- 
void AT91F_TWI_Open(void) 
{ 
   // Configure TWI PIOs 
   AT91F_TWI_CfgPIO (); 
   // Configure PMC by enabling TWI clock 
   AT91F_TWI_CfgPMC (); 

        //disable the pull-up-resistor for twi-lines 
        *AT91C_PIOA_PPUDR = AT91C_PA4_TWCK | AT91C_PA3_TWD; 

   // Configure TWI in master mode 
   AT91F_TWI_Configure (AT91C_BASE_TWI); 

   // Set TWI Clock Waveform Generator Register 
   AT91F_SetTwiClock(); 
}

*** twi.c ****
#include <AT91SAM7S256.h>
#include <lib_AT91SAM7S256.h>

void twi_init(void)
{
  // PIOA-pin setup:
  AT91F_TWI_CfgPIO();
  // clk enable:
  AT91F_TWI_CfgPMC();
  // TWI setup:
  AT91F_TWI_Configure(AT91C_BASE_TWI);
  
  // set TWI clk:
  *AT91C_TWI_CWGR = (7<<16)|(255<<8)|(255); // CKDIV | CHDIV | CLDIV = 111 1111 1111
  // set dev.adr to 7-bits, adr.space to 16-bits:
  *AT91C_TWI_MMR = 0x550200;
  
  // and roll ...
} 
void i2cMasterSend(unsigned char dev_adr, unsigned short mem_adr, unsigned char data)
{
  unsigned int status;
  
  *AT91C_TWI_IADR = mem_adr;
  //
  *AT91C_TWI_MMR &= ( 0xFF00EFFF | (dev_adr<<16) );
  //
  *AT91C_TWI_CR = AT91C_TWI_START | AT91C_TWI_MSEN | AT91C_TWI_STOP;
  //
  *AT91C_TWI_THR = data;
  //
  status = *AT91C_TWI_SR;
  while ( !(status & AT91C_TWI_TXCOMP) )
  {
    status = *AT91C_TWI_SR;
  }
}
unsigned char i2cMasterReceive(unsigned char dev_adr, unsigned short mem_adr)
{
  unsigned int status;
  
  *AT91C_TWI_IADR = mem_adr;
  //
  *AT91C_TWI_MMR |= ( 0x00001000 | (dev_adr<<16) );
  //
  *AT91C_TWI_CR = AT91C_TWI_START | AT91C_TWI_MSEN | AT91C_TWI_STOP;
  //
  status = *AT91C_TWI_SR;
  while ( !(status & AT91C_TWI_TXCOMP) )
  {
    status = *AT91C_TWI_SR;
  }
  //
  return (unsigned char)*AT91C_TWI_RHR;
} 

*** main.c *** fragment

 while (1)
 {
    for (mem_addr=0; mem_addr<256; mem_addr++)
    {
      i2cMasterSend(EEPROM_DADR, mem_addr, i);
    }
   for (mem_addr=0; mem_addr<256; mem_addr++)
    {
      data = i2cMasterReceive(EEPROM_DADR, mem_addr);
   }
}

#include <targets\AT91SAM7.h>
#include <user\lcd.c>   //zawiera f-cje obslugi HD44780 i delay-a
#define LED 1<<9        //mapowanie diodki swiecacej
#define SDA 1<<3        //mapowanie SDA
#define SCL 1<<4        //mapowanie SCL

int main (void)
{
PIOA_OER = LED;         //zalaczamy wyjscie na LED-ke
PIOA_MDER = LED;        //open collector dla diodki
PIOA_SODR = LED;        //i gasimy LED-ka
delay(50000);           //oczekiwanie na ustabilizowanie sie zasilania
LcdInit();              //inicjalizacja LCD, czyszczenie wyswietlacza - zwrocic 
                        //uwage na mapowanie sygnalow w pliku lcd.c
LcdPrint(" Test dzialania ");   //sprawdzamy dzialanie LCD
LCD_xy (0, 1);          
LcdPrint(" magistrali I2C ") ;  //takie sobie wodotryski
delay(2000000);         //czekamy zanim zczyscimy ekran
LcdClear();             //i czyscimy ekran po tescie
LCD_xy (0, 1);          //ustawiam kursorek w drugim wierszu
PMC_PCER = 1<<9;        //ID dla TWI jest rowne 9, zalaczamy taktowanie TWI
TWI_CR = 0x80;          //reset dla TWI
PIOA_PDR = (SDA|SCL);   //wyłączam (dobrze myślę?) PIO dla linii magistrali
PIOA_MDER = (SDA|SCL);  //konfiguruję jako open collector
PIOA_PUDR = (SDA|SCL);  //wyłączam pullupy - mam zewnętrzne
PIOA_ASR = ((SDA|SCL)); //i wybieram peryferie A (TWI) dla tych pinów

/********************************************************/
//próbuję obsłużyć I2C - z miernym efektem...
//chociaż coś "drgnie" na liniach - sprawdzane oscyloskopem, gubi na chwilkę
//synchronizację, więc na moje oko nóżki są dobrze skonfigurowane
TWI_CR = (1<<7);        //znowu reset TWI
TWI_IDR = ((1<<8)|7);   //na wszelki wielki wyłączam IRQ
unsigned int SR = TWI_SR; //czytam status register, żeby nie pozostały śmieci
TWI_CR = 0x4;           //ustawiam bit MSEN
TWI_CWGR = (7<<16)|(0xFF<<8)|(0xFF);  //największe możliwe opóźnienia
TWI_MMR = ((0x50<<16)|(1<<12)|(1<<8));  //adres 24C04 - 1010000 (trzy piny 
                        //podałem na masę), ustawiam MREAD, rozmiar adresu - 1B
TWI_IADR = 0x2;         //pod 0x2 powinienem mieć literę "małe o"
TWI_CR = 0x5;           //zapisuję w command register START i MSEN
delay(5000);            //czekam chwilkę
while(!(TWI_SR&0x2));      //i czekam, dopóki nie ustawi się RXRDY
                          //cały wic polega na tym, że RXRDY się nie ustawia
                          //chociaż jak czekam na TXCOMP, to program leci dalej
                          //ale a RHR mam dokłądnie zero... W tej chwili nie
                          //mam komunikatu na LCD, ani zaświeconego LED-a
unsigned char var = TWI_RHR;  //tutaj chciałbym wyciągnąć z bufora daną
TWI_CR = 0x2;                 //i wysłać na magistralę STOP
LcdPrintChar (var + 0x30);    //wypisuję na LCD - to na pewno działa dobrze
PIOA_CODR = LED;              //dla pewności zaświecam diodkę
while(1);                     //THE END :-)
}
/********************************************************/

*AT91C_TWI_MMR &= ( 0xFF00EFFF | (dev_adr<<16) );

status = *AT91C_TWI_SR;
  while ( !(status & AT91C_TWI_TXCOMP) )
  {
    status = *AT91C_TWI_SR;
  } 

  while ( !(*AT91C_TWI_SR & AT91C_TWI_TXCOMP) );

pTwi->TWI_CR = AT91C_TWI_START | AT91C_TWI_STOP;

// TWI error definitions
#define TWI_WAIT_TIMEOUT	0x000FFFFF
#define TWIOVRUN			BIT(0)
#define TWIUNRUN			BIT(1)
#define TWINACK				BIT(2)
#define TWITIMEOUT			BIT(3)

// Master Clock Frequency
#define CLOCK_FREQ_SLCK		0
#define CLOCK_FREQ_18MHz	1
#define CLOCK_FREQ_48MHz	2

extern volatile char ClockFrequency;

void twi_init(void)
{
	AT91F_PIO_CfgOpendrain( AT91C_BASE_PIOA, AT91C_PA3_TWD | AT91C_PA4_TWCK );
	// peripheral A enable & disable pio on TWI sda + scl, PA3 + PA4
	AT91F_TWI_CfgPIO();
	// Enable TWI peripheral clock
	AT91F_TWI_CfgPMC();
	// Disable TWI interrupts, reset periph, set master mode
	AT91F_TWI_Configure( AT91C_BASE_TWI );
}


u08 twi_wait(u32 Mask)
{
	u32 Status;  
	u32 Timeout = TWI_WAIT_TIMEOUT;
    u08 TwiError = 0;
    Status = AT91C_BASE_TWI->TWI_SR;
    while (!(Status & Mask))           
    {
        Status = AT91C_BASE_TWI->TWI_SR;
        if (Status & AT91C_TWI_OVRE)
            TwiError |= TWIOVRUN;
        if (Status & AT91C_TWI_UNRE)
            TwiError |= TWIUNRUN;
        if (Status & AT91C_TWI_NACK)
		{
            TwiError |= TWINACK;
            AT91C_BASE_TWI->TWI_CR = AT91C_TWI_STOP | AT91C_TWI_MSEN;
        }

        if (--Timeout == 0)
		{
           return TWITIMEOUT;
		}
    }
	return TwiError;
}

u08 twi_eep_write_block(u16 blockAddr, u08 * pData, u16 length)
{
	u08 ret = 0;
	
	// make sure that there are no transfers active
	if ((ret = twi_wait( AT91C_TWI_TXCOMP )) & TWITIMEOUT)
		return ret;

	// setup clocks
	if (ClockFrequency == CLOCK_FREQ_18MHz)
	{
		// configure TWI clock - 400kHz for 18.432MHz MCK
		*AT91C_TWI_CWGR = (AT91C_TWI_CKDIV & (0 << 16)) | (AT91C_TWI_CHDIV & (16 << 8)) |
								(AT91C_TWI_CLDIV & (27 << 0));
		// CLDIV 27 & CHDIV 16 for 400kHz
	}
	else if (ClockFrequency == CLOCK_FREQ_48MHz)
	{
		// configure TWI clock - 400kHz for 48MHz MCK
		*AT91C_TWI_CWGR = (AT91C_TWI_CKDIV & (0 << 16)) | (AT91C_TWI_CHDIV & (45 << 8)) |
								(AT91C_TWI_CLDIV & (74 << 0));
		// CLDIV 74 & CHDIV 45 for 400kHz
	}
	
	// dummy read TWI Status Register to clear old or false events
	dummy = *AT91C_TWI_SR;
	dummy = dummy;
	
	// deviceadr + Master write + 1 Device address
	*AT91C_TWI_MMR = AT91C_TWI_IADRSZ_2_BYTE |
				(((unsigned long)TWI_ADDR_EEPROM) << 16);
	
	// handle writing to different pages
	u16 len, _blockAddr = blockAddr;
	do
	{
		// len - number of bytes that can be written to the current page
		len = (_blockAddr & 0xFFC0) + 0x40 - _blockAddr;
		// correct 'len' to not write more bytes than set in the 'length' variable
		if (_blockAddr + len - blockAddr > length)
			len = (blockAddr + length) - _blockAddr;
	
		// set device internal address (eep pData addr)
		*AT91C_TWI_IADR = _blockAddr;
		
		_blockAddr += len;
		
		// write the first byte to the Transmit Holding Register
		if (len--)
			*AT91C_TWI_THR = *(pData++);

		// start the transmission
	    *AT91C_TWI_CR = AT91C_TWI_START | (len ? 0 : AT91C_TWI_STOP) ;

    	while (len)
	    {
			// transmit complete?
    	    ret |= twi_wait( AT91C_TWI_TXRDY );
	        if (!ret)
    	    {
				// stop on last byte
        	    if (len-- == 1)
            	    *AT91C_TWI_CR = AT91C_TWI_STOP;
	            *AT91C_TWI_THR = *(pData++);
    	    }
			else // break on error
				return ret;
	    }
		
		// transmit complete?
		ret |= twi_wait( AT91C_TWI_TXRDY );
		// transfer complete?
		ret |= twi_wait( AT91C_TWI_TXCOMP );
		// break on error
		if (ret)
			return ret;
	}
	while (((blockAddr + length) & 0xFFC0) - ((_blockAddr) & 0xFFC0) > 0); // while different pages
    return ret;
}


u08 twi_eep_read_block(u16 blockAddr, u08 * pData, u16 length)
{
	u08 ret = 0;
	
	// make sure that there are no transfers active
	if ((ret = twi_wait( AT91C_TWI_TXCOMP )) & TWITIMEOUT)
		return ret;

	// setup clocks
	if (ClockFrequency == CLOCK_FREQ_18MHz)
	{
		// configure TWI clock - 400kHz for 18.432MHz MCK
		*AT91C_TWI_CWGR = (AT91C_TWI_CKDIV & (0 << 16)) | (AT91C_TWI_CHDIV & (16 << 8)) |
								(AT91C_TWI_CLDIV & (27 << 0));
		// CLDIV 27 & CHDIV 16 for 400kHz
	}
	else if (ClockFrequency == CLOCK_FREQ_48MHz)
	{
		// configure TWI clock - 400kHz for 48MHz MCK
		*AT91C_TWI_CWGR = (AT91C_TWI_CKDIV & (0 << 16)) | (AT91C_TWI_CHDIV & (45 << 8)) |
								(AT91C_TWI_CLDIV & (74 << 8));
		// CLDIV 74 & CHDIV 45 for 400kHz
	}
	
	// set internal block address for TWI device
    *AT91C_TWI_IADR = blockAddr;
	// master read + 2 byte internal address + device address
    *AT91C_TWI_MMR = AT91C_TWI_MREAD | AT91C_TWI_IADRSZ_2_BYTE |
						((unsigned long)TWI_ADDR_EEPROM) << 16;
	
	// dummy read TWI Status Register to clear old or false events
	dummy = *AT91C_TWI_SR;
	dummy = dummy;
	// dummy read the receive holding register
	dummy = *AT91C_TWI_RHR;
	dummy = dummy;
	// initiate the transmission
    *AT91C_TWI_CR = AT91C_TWI_START | AT91C_TWI_MSEN;

    while (length)
    {
		// receive complete?
        ret |= twi_wait( AT91C_TWI_RXRDY );
		device_red_led_toggle();
        *(pData++) = *AT91C_TWI_RHR;
		// last byte to transfer?
        if (length-- == 1)
			// set stop condition
            *AT91C_TWI_CR = AT91C_TWI_STOP | AT91C_TWI_MSEN;
    }
	
	// receive complete?
	ret |= twi_wait( AT91C_TWI_RXRDY );
	// dummy read the receive holding register
	dummy = *AT91C_TWI_RHR;
	dummy = dummy;
	// transfer complete?
    ret |= twi_wait( AT91C_TWI_TXCOMP );
    return ret;
}

void TWI_Open ( void )
{	
	AT91F_TWI_CfgPIO();
	AT91F_PIO_CfgOpendrain(AT91C_BASE_PIOA, ((unsigned int) AT91C_PA3_TWD ) | ((unsigned int) AT91C_PA4_TWCK )); 
	
	AT91C_BASE_PIOA->PIO_PPUDR = AT91C_PA3_TWD | AT91C_PA4_TWCK; //wylączenie pull-up
	
	AT91F_TWI_CfgPMC(); // wlączenie zegara dla bloku TWI
	
	//TWI Configure
	//Disable interrupts
	AT91C_BASE_TWI->TWI_IDR = (unsigned int) -1;
	AT91C_BASE_TWI->TWI_CR = AT91C_TWI_SWRST;
	AT91C_BASE_TWI->TWI_CR = AT91C_TWI_MSEN; 
	
	//AT91F_SetTwiClock();
	
	AT91C_BASE_TWI->TWI_CWGR = ( AT91C_TWI_CLDIV_5 | AT91C_TWI_CHDIV_5 | AT91C_TWI_CKDIV_4 ); // okolo 100kHz

	DBGU_AsyncWriteString("\n\rTWI_Open");
	DBGU_FlushWrite();
}

int TWI_ReadByte( void )
{
	int smieci;
	// oczekiwanie na zapelnienie bufora odczytu jednym bajtem
	while( !((AT91C_BASE_TWI->TWI_SR) & AT91C_TWI_RXRDY ))
	{
		// wyjście z pętli oczekiwania po 50ms
		if( PIT_ReadyToAnalize == 1 )
		{
			DBGU_AsyncWriteString("\n\r TWI ERROR !!!");	DBGU_FlushWrite(); 
			PIT_ReadyToAnalize = 0;
		 	return 0;
		}
	} // sprawdzaje czy nie minelo 50ms
	return( AT91C_BASE_TWI->TWI_RHR );
}

void TWI_Read ( int adres )
{
	int smieci, miernik_id ;
	static unsigned int otrzymany_bajt, pomiar_sharp, pomiar_sonar, pomiar_ir;
	unsigned char otrzymany_bajt_z_myszki_1;// otrzymany_bajt_z_myszki_2 ;
	// ustawienie adresu slave'a
	 AT91C_BASE_TWI->TWI_MMR = (AT91C_TWI_DADR & (adres << 15)) | AT91C_TWI_IADRSZ_NO  | AT91C_TWI_MREAD; 
	//AT91C_BASE_TWI->TWI_MMR = AT91C_TWI_IADRSZ_NO | AT91C_TWI_MREAD | adres<<16;
	
	smieci = AT91C_BASE_TWI->TWI_RHR;
	smieci = AT91C_BASE_TWI->TWI_SR;
	// start transmisji
	AT91C_BASE_TWI->TWI_CR = AT91C_TWI_START;
	cr_register = AT91C_BASE_TWI->TWI_CR;
	
	otrzymany_bajt_z_myszki_1 = TWI_ReadByte();

                                    LCD_Cls();
  			LCD_put_text("X=");
  			LCD_put_dec(otrzymany_bajt_z_myszki_1);
  			LCD_Update();

	AT91C_BASE_TWI->TWI_CR = AT91C_TWI_STOP; // bit stopu
	
	while( !((AT91C_BASE_TWI->TWI_SR) & AT91C_TWI_TXCOMP) ) {
		if( PIT_ReadyToAnalize == 1 ) break; // wyjście z pętli oczekiwania po 50ms
	} // oczekiwanie na koniec transmisji
}

BYTE TWI_MasterReceive( BYTE deviceAddr, ULONG internalAddr, BYTE *data, ULONG len )
{
     volatile ULONG status;

     // prepare read transmission
     AT91C_BASE_TWI->TWI_MMR = ( deviceAddr << 16 ) | AT91C_TWI_MREAD | AT91C_TWI_IADRSZ_2_BYTE;
     // dummy read the receive holding register
     AT91C_BASE_TWI->TWI_RHR;
     // set slave device internal address
     AT91C_BASE_TWI->TWI_IADR = internalAddr;
     // send start condition
     AT91C_BASE_TWI->TWI_CR = AT91C_TWI_START;

     // wait for complete (or no device)
     do
     {
    	 // check status
         status = AT91C_BASE_TWI->TWI_SR;
         // watch for address NACK
         if( status & AT91C_TWI_NACK )
        	 return TWI_ERROR_NODEV;
     }
     while(!( status & AT91C_TWI_RXRDY ));

     // receive data

while (!TxComp_flag) {}
TxComp_flag = 0;

void TWI_Init()
{
	AT91C_BASE_PMC->PMC_PCER = 1 << AT91C_ID_TWI;
	AT91C_BASE_PIOA->PIO_ASR = AT91C_PA3_TWD | AT91C_PA4_TWCK;
	AT91C_BASE_PIOA->PIO_PDR = AT91C_PA3_TWD | AT91C_PA4_TWCK;
	AT91C_BASE_PIOA->PIO_MDER = AT91C_PA3_TWD | AT91C_PA4_TWCK;
	AT91C_BASE_PIOA->PIO_PPUDR = AT91C_PA3_TWD | AT91C_PA4_TWCK;
	AT91C_BASE_TWI->TWI_CR = AT91C_TWI_SWRST;
	AT91C_BASE_TWI->TWI_CWGR = 	(2 << 16) |		// CKDIV
								(255 << 8) |	// CHDIV
								(255 << 0);		// CLDIV
	AT91C_BASE_TWI->TWI_CR = AT91C_TWI_MSEN;
	
	
}

void TWI_Transmit(char * datatosend, unsigned int datalength, unsigned int address, unsigned int intaddress)
{//transmit (datalength) bytes from slave at (address) writing to (datatoreceive)
 
 AT91C_BASE_TWI->TWI_CR = AT91C_TWI_START; //send start condition
 AT91C_BASE_TWI->TWI_IADR = intaddress; 
  AT91C_BASE_TWI->TWI_MMR = (AT91C_TWI_DADR & (address << 16))| AT91C_TWI_IADRSZ_1_BYTE; //set slave address and set data direction for transmit
  AT91C_BASE_TWI->TWI_THR = *datatosend++; //load in first byte and increment data pointer
  datalength--;
  
  while (datalength)
 {
    datalength--;
   while (!(AT91C_BASE_TWI->TWI_SR & AT91C_TWI_TXRDY)) ; //wait for last tx to finish
    AT91C_BASE_TWI->TWI_THR = *datatosend++; //load in new byte
  }
  while (!(AT91C_BASE_TWI->TWI_SR & AT91C_TWI_TXRDY)) ; //wait for last tx to finish
  AT91C_BASE_TWI->TWI_CR = AT91C_TWI_STOP; //send stop condition
 while (!(AT91C_BASE_TWI->TWI_SR & AT91C_TWI_TXCOMP)) ; //wait for TWI tx to finish
  
}

char adresWew[2];
adresWew[0] = 0x00;
adresWew[1] = 0x00;
odbior = odb(adres,2,adresWew);