AVR Freaks

Thanks David. So I assume that you are familiar with the chip. So the question is... when can the uC read the TWDR register? How does the uC know when the next byte is ready to read? Somewhere in my code I have to put in a line that says data=TWDR. I need to know how to time this so that I am getting the new data as it is being clocked in.

thanks

David,
Read the question, THEN try to answer it.

Stan,
Point well taken. My response was rude. But you probably shouldn't assume so much about the questioner.

Hello,
If you have experience with this chip, please take a moment to look at my code below. I am trying to read data from a serial eeprom AT24C512. All of the status codes indicate that my code is working properly. This is also true for my WRITE function. But when I try to read, I get a value of FF for every memory location. I have included my WRITE code and my READ code. Can someone please explain what I am missing in my READ code? Any help would be appreciated.

PS.. Thanks in advance, but I am not looking for a pre-made function to read and write serial eeprom. I am trying to understand how the chip interfaces with the microprocessor.

Here is my write code:

void write_to_memory(unsigned int byte_addr, unsigned char data)
{
unsigned char addrH,addrL;
addrH=(unsigned char)(byte_addr>>8);
addrL=(unsigned char)byte_addr;

line_fd(2);
printf("trying to send %i to address 0x%X",(int)test,(int)samples);
line_fd(1);
// Send start
TWCR=(1<<TWINT)|(1<<TWSTA)|(1<<TWEN);

while(!(TWCR & (1<<TWINT)))
;
printf("START acknowledge: TWSR code 0x%X",(int)TWSR);
line_fd(1);

// Send device address
TWDR=SLA_W;
TWCR=(1<<TWINT)|(1<<TWEN);
while(!(TWCR & (1<<TWINT)))
;
printf("Device address ack: TWSR code = 0x%X",(int)TWSR);
line_fd(1);

// Send address high byte
TWDR=addrH;
TWCR=(1<<TWINT)|(1<<TWEN);
while(!(TWCR & (1<<TWINT)))
;
printf("Address high byte: = 0x%X",(int)addrH);
line_fd(1);
printf("Address high byte ack: TWSR code = 0x%X",(int)TWSR);
line_fd(1);

// Send address low byte
TWDR=addrL;
TWCR=(1<<TWINT)|(1<<TWEN);
while(!(TWCR & (1<<TWINT)))
;
printf("Address low byte: = 0x%X",(int)addrL);
line_fd(1);
printf("Address low byte ack: TWSR code = 0x%X",(int)TWSR);
line_fd(1);

// Send data
TWDR=data;
TWCR=(1<<TWINT)|(1<<TWEN);
while(!(TWCR & (1<<TWINT)))
;
printf("Value to memory: = 0x%X",(int)data);
line_fd(1);
printf("Data recieved ack: TWSR code = 0x%X",(int)TWSR);
line_fd(1);

// Send stop
TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWSTO);
}

And here is my read code:

TWCR=(1<<TWINT)|(1<<TWSTA)|(1<<TWEN); // Send start condition to read
while(!(TWCR & (1<<TWINT))) // Wait for interrupt flag
;
printf("START acknowledge: TWSR code = 0x%X",(int)TWSR);
line_fd(1);

TWDR=SLA_W; // Send device address as slave write
TWCR=(1<<TWINT)|(1<<TWEN); // Set interrupt flag and TWI enable
while(!(TWCR & (1<<TWINT))) // Wait for interrupt flag
;
printf("Slave write ack: TWSR code = 0x%X",(int)TWSR);
line_fd(1);

TWDR=SLA_W; // Send device address as slave write
TWCR=(1<<TWINT)|(1<<TWEN); // Set interrupt flag and TWI enable
while(!(TWCR & (1<<TWINT))) // Wait for interrupt flag
;
printf("Slave write ack: TWSR code = 0x%X",(int)TWSR);
line_fd(1);

TWDR=addrH; // Send address high byte
TWCR=(1<<TWINT)|(1<<TWEN); // Set interrupt flag and TWI enable
while(!(TWCR & (1<<TWINT))) // Wait for interrupt flag
;
printf("data send ack: TWSR code = 0x%X",(int)TWSR);
line_fd(1);

TWDR=addrL; // Send address low byte
TWCR=(1<<TWINT)|(1<<TWEN); // Set interrupt flag and TWI enable
while(!(TWCR & (1<<TWINT))) // Wait for interrupt flag
;
printf("data send ack: TWSR code = 0x%X",(int)TWSR);
line_fd(1);

TWCR=(1<<TWINT)|(1<<TWSTA)|(1<<TWEN); // Send repeated start condition
while(!(TWCR & (1<<TWINT))) // Wait for interrupt flag
;
printf("Repeated START acknowledge: TWSR code = 0x%X",(int)TWSR);
line_fd(1);

TWDR=SLA_R; // Send device address as slave receive
TWCR=(1<<TWINT)|(1<<TWEN); // Set interrupt flag and TWI enable
while(!(TWCR & (1<<TWINT))) // Wait for interrupt flag
;
printf("Device slave-read ack: TWSR code = 0x%X",(int)TWSR);
line_fd(1);
*****NOTE - up to here, all status codes are correct***

for(k=1;k {
TWCR=(1<<TWINT)|(1<<TWEN); // Set interrupt flag and TWI enable
while(!(TWCR & (1<<TWINT))) // Wait for interrupt flag
;

printf("Device read ack: TWSR code = 0x%X",(int)TWSR);
line_fd(1);
printf("Memory value: %X:",(int)TWDR);
line_fd(1);
}
// Send stop
TWCR=(1<<TWINT)|(1<<TWEN)|(1<<TWSTO);[/code][code]

David,
I believe that I found the missing TWEA last night, but unfortunately I am still reading FF for all memory spaces. This might mean that I am not writing, or that I am not reading. I would think that the status codes would give me some indication. In case in comes up, I have check that the write protect is disabled on the chip.

I will post below all of the code relevant to my project. I have written out as I did because it is easier for me to see the current status of the TWSR register. Once I understand how this works, I will gladly write this out into smaller functions. FYI, I have tried downloading the AVRlib as recommended. Aside from the fact that I couldn't get anything to compile, I was unable to find any code which actually explained how the uC communicates with the eeprom.

As you will see below, the status codes as sent to the USART show that the eeprom interface is working properly. But apparently I am missing something.

Any assistance would be appreciated.

Code. The first chunk will be my initialization. The second chunk will be my write code, and the third chunk will be the USART debugging responses, as should be obvious by following the printf statements. For this example, I wrote the numbers 1, 2, and 3, to memory locations, 1, 2 and 3. Or at least I tried to.

Here is the write function, including debug statements to the USART.

And here is the read code. I am trying to do a sequential read for memory locations 1, 2 and 3.

And here is the USART output for this example.

Thanks for your help.

David,
Thanks. I will try this. I would much rather understand how the registers are working, but I think I am going to have to give up on this ideal and take the easy way out.

Again, thanks for your help. But it must be apparent by now that I have pretty much memorized the datasheet and the uC manual. My code is directly from table 75 in the atmega16 manual. And if the TWI were simple, someone would have answered my question by now without referring me to pre-made functions. But I do appreciate the help. And I will gladly use the pre-made functions.

David,
I tried to implement your code. I don't have the libraries for your functions. I know you think that it's simple to implement these functions, but I would have to load all the libraries and figure out how to use all the functions.

I have re-tried my code with a 20 ms delay after every command. Same results. All status codes say that there is nothing wrong. I tried changing my pullup resistors from 10k to 1k. I've replaced the chip. I'm out of ideas.

You have said that this is easy. Is this easy for you? If so then make my code work and I will pay you. Please let me know.

thanks again for your help.