ATNEL tech-forum

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-11-25T21:52:16+01:00

steter napisał(a):

Aż się boję co napisze Mirek

Ale czego się bać - jakby się okazało, że masz rację - to ja tam honorowo wszedłbym pod stół i odszczekał to co mówiłem bez krępacji i żadnego problemu - ciesząc się z takiego wynalazku i jeszcze bym ci podziękował za dodatkowe i to kilo bajty

Ale na razie niestety nie mam czasu tego sprawdzić i dlatego na razie nie wchodzę pod stół - ale może ktoś w międzyczasie sprawdzi ?

i da znać ?

Statystyki: Napisane przez mirekk36 — 25 lis 2020, o 21:52

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-11-25T20:55:15+01:00

mirekk36 napisał(a):

Toż masz UART i możesz sobie wypluć wynik - całą zawartość pamięci w HEX na terminal i porównać. Jak podejdziesz do tego w ten sposób - to jeszcze więcej się nauczysz jeśli chodzi o te pamięci

dzięki Mirek

Nie wiem czemu tak się męczyłem na lcd ,
W każdym razie poszedłem za radą Mirka i zacząłem testować pamięć, używając PuTTY

Zapisałem na raty do 24C04A Atmela 4 tablice z tekstem (ok. 2000 bajtów) w prost z noty Atmegi32 aby ładnie porównać zawartość tablic z wyświetlonym tekstem w PuTTY i okazuje się że cały zapisany text w eeprom-ie Atmela24C04A został poprawnie wyświetlony

Aż się boję co napisze Mirek

A po niżej kod wypluwający zawartość pamięci(do 2200bajtów) do PuTTY.
[syntax=c]int main(void) {
lcd_init(); // inicjalizacja lcd
inicjalizacja_USART();
i2cSetBitrate(100); // ustalam prędkosc magistrali I2C na 100 kHz
DDRC |= (1<led_OFF;
uint16_t Adres_eeprom=0; // wybieram adres w pamięci od 0 do 8191

/*char tablica1[]="1-tablica 341 bajtow. --- Program Flash memory space is divided in two sections, the Boot program section and the\r\n"
"Application Program section. Both sections have dedicated Lock bits for write and read/write\r\n"
"protection. The SPM instruction that writes into the Application Flash memory section must\r\n"
"reside in the Boot Program section.\r\n\r\n";

char tablica2[]="2-tablica 588 bajtow. --- During interrupts and subroutine calls, the return address Program Counter (PC) is stored on the\r\n"
"Stack. The Stack is effectively allocated in the general data SRAM, and consequently the Stack\r\n"
"size is only limited by the total SRAM size and the usage of the SRAM. All user programs must\r\n"
"initialize the SP in the reset routine (before subroutines or interrupts are executed). The Stack\r\n"
"Pointer SP is read/write accessible in the I/O space. The data SRAM can easily be accessed"
"\r\nthrough the five different addressing modes supported in the AVR architecture\r\n\r\n";

char tablica3[]="3-tablica 480 batow. --- The memory spaces in the AVR architecture are all linear and regular memory maps.\r\n"
"A flexible interrupt module has its control registers in the I/O space with an additional global\r\n"
"interrupt enable bit in the Status Register. All interrupts have a separate interrupt vector in the\r\n"
"interrupt vector table. The interrupts have priority in accordance with their interrupt vector posi-\r\n"
"tion. The lower the interrupt vector address, the higher the priority.";

char tablica4[]="\r\n\r\n4-tablica 597 bajtow. --- The high-performance Atmel *AVR* ALU operates in direct connection with all the 32 general\r\n"
"purpose working registers. Within a single clock cycle, arithmetic operations between general\r\n"
"purpose registers or between a register and an immediate are executed. The ALU operations\r\n"
"are divided into three main categories – arithmetic, logical, and bit-functions. Some implementa-\r\n"
"tions of the architecture also provide a powerful multiplier supporting both signed/unsigned\r\n"
"multiplication and fractional format. See the “Instruction Set” section for a detailed description.\r\n";
*/
//EEPROM_24C04A_write_tab(_24C04_ADR, 0, sizeof(tablica1), tablica1);
//EEPROM_24C04A_write_tab(_24C04_ADR, 340, sizeof(tablica2), tablica2);
//EEPROM_24C04A_write_tab(_24C04_ADR, 930, sizeof(tablica3), tablica3);
//EEPROM_24C04A_write_tab(_24C04_ADR, 1430, sizeof(tablica4), tablica4);

/* // do czyszczenia całego eeprom-mu
while(1){
EEPROM_24C04A_write(_24C04_ADR, Adres_eeprom, 0); // zpelniam eepromm zerami
Adres_eeprom++;
if(Adres_eeprom>8191)while(1)led_ON; // zaswiecam led jak koniec kasowania, chwilę trwa kasowanie.
}
// */

//uart_putint(sizeof(tablica4), 10);

while(1){
uint8_t a=EEPROM_24C04A_read(_24C04_ADR, Adres_eeprom); // do zmiennej "a" zapisuję bajt z eepromu
//uart_putint(Adres_eeprom,10);
//uart_puts(" komurka = ");
uart_putc(a);
//uart_transmit(0x0D);
//uart_transmit(0x0A);
Adres_eeprom++; // zwiększam adres do sprawdzenia.
if(Adres_eeprom>2200)while(1);// gdy przekroczę wartość pamięci ztrzymuje proram
}
}[/syntax]

jeszcze funkcja do zapisywania tablicy do pamięci 24C04A Atmela oczywiście napisana niechlujnie ale do testowania wystarczy.
[syntax=c]void EEPROM_24C04A_write_tab(uint8_t device, uint16_t subAddr,uint16_t len, char *tab){
while(len){
I2C_start();
I2C_write(device);
I2C_write(subAddr / 256); // ustalam stronę
I2C_write(subAddr % 256); // ustalam nr.bajtu na stronie
I2C_write(*(tab++));
I2C_stop();
_delay_ms(5);
subAddr++;
len--;
}
}[/syntax]

Pozdrawiam.

Statystyki: Napisane przez steter — 25 lis 2020, o 20:55

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-11-24T22:17:01+01:00

steter napisał(a):

według mnie kostce ATMEL718 24C04A fabryka dała 8192 bajty pamięci.

Oooo Panie no to teraz zaszalałeś albo popłynąłeś .... tu piszesz że 8192 bajty a za chwilę

steter napisał(a):

Tak Adam12 nie dość że mogę potwierdzić że Twoja Atmel24C04A ma 1024 bajty,

to zdecyduj się ... a pamięć jak pamięć ma - czy tego chcesz czy nie - jedynie 512 bajtów ... tylko ty jeszcze musisz dostrzec w swoim kodzie, że zjadasz własny ogon ... a jak się rozpędzisz to może dojdziesz do 16 kB ?

steter napisał(a):

I tak w ogóle, to bardzo się cieszę, że dostała mi się własnie ta dziwna pamięć Atmela24C04A dzięki temu przypadkowi bardzo dużo się nauczyłem o transmisji I2C, oraz zacząłem bardziej rozumieć noty katalogowe z układami pracującymi z transmisją I2C.

No a tu to się z tobą zgadzam w 100% ... że warto rozgryzać takie przypadki, tego nikt ci nie odbierze tylko nie szalej proszę z tymi odkryciami.

Musisz zrozumieć, że te pamięci zapisywane są stronami - i dlatego zjadasz własny ogon licząc sobie adres do 8192 Zamiast robić tak przedziwne testy - zapisz lepiej do tej pamięci albo inaczej, spróbuj zapisać więcej niż 512 bajtów - chociażby 513 i później spróbuj je odczytać wszystkie naraz. Toż masz UART i możesz sobie wypluć wynik - całą zawartość pamięci w HEX na terminal i porównać. Jak podejdziesz do tego w ten sposób - to jeszcze więcej się nauczysz jeśli chodzi o te pamięci

Statystyki: Napisane przez mirekk36 — 24 lis 2020, o 22:17

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-11-24T19:35:33+01:00

Dotyczy tylko pamięci EEPROM firmy Atmel 24C04A !

mirekk36 napisał(a):

KOLOSALNA RÓŻNICA jest - i nie działa tu nic na krzyż

Mirek, chylę czoła

mirekk36 napisał(a):

No ale dobrze ci się wydaje, że to niemożliwe - bo nie jest możliwe pamięci jest tyle ile stwórca czyli fabryka dała ...

według mnie kostce ATMEL718 24C04A fabryka dała 8192 bajty pamięci.

A kto jest w posiadaniu takiej własnie kostki może sprawdzić, ja sprawdziłem na dwóch egzemplarzach.
[syntax=c]// Funkcja do zapisu pojedynczego bajtu do pamięci
void EEPROM_24C04A_write(uint8_t device, uint16_t subAddr, uint8_t data){
I2C_start();
I2C_write(device);
I2C_write(subAddr / 256); // ustalam stronę
I2C_write(subAddr % 256); // ustalam nr.bajtu na stronie
I2C_write(data);
I2C_stop();
_delay_ms(5);
}
// Funkcja do odczytu pojedynczego bajtu z pamięci
uint8_t EEPROM_24C04A_read(uint8_t device, uint16_t subAddr){
I2C_start();
I2C_write(device);
I2C_write(subAddr / 256); // ustalam stronę
I2C_write(subAddr % 256); // ustalam nr.bajtu na stronie
I2C_start();
I2C_write(device+1);
uint8_t data=I2C_read(NACK);
I2C_stop();
return data;
}[/syntax]

i krótki programik do testowania.
[syntax=c]#define led_ON PORTC &=~(1<#define led_OFF PORTC |=(1<
int main(void) {
lcd_init(); // inicjalizacja lcd
i2cSetBitrate(100); // ustalam prędkość magistrali I2C na 100 kHz
DDRC |= (1<led_OFF;

uint16_t Adres_eeprom=4879; // wybieram adres w pamięci od 0 do 8191
uint8_t DATA=13; // zmienna do zapisania w pamięci

EEPROM_24C04A_write(_24C04_ADR, Adres_eeprom, DATA); // zapisuję do pojedynczej komórki eeprom
Adres_eeprom=0; // do testowania zeruję adres komórki aby sprawdzać od początku

/* // do czyszczenia całego eeprom-mu
while(1){
EEPROM_24C04A_write(_24C04_ADR, Adres_eeprom, 0); // zapełniam eepromm zerami
Adres_eeprom++;
if(Adres_eeprom>8191)while(1)led_ON; // zaświecam led jak koniec kasowania, chwilę trwa kasowanie.
}
// */
while(1){
uint8_t a=0;
a=EEPROM_24C04A_read(_24C04_ADR, Adres_eeprom); // do zmiennej "a" zapisuję bajt z eepromu

lcd_locate(0, 0);
lcd_str("Adres = ");
lcd_str(" ");
lcd_locate(0, 8);
lcd_long_int(Adres_eeprom);

lcd_locate(2, 0);
lcd_str("Data = ");
lcd_str(" ");
lcd_locate(2, 8);
lcd_long_int(a);

Adres_eeprom++; // zwiększam adres do sprawdzenia.

if(a==DATA)while(1)led_ON; // gdy pobrany bajt jest równy wcześniej zapisanemu, zatrzymaj program i załącz led
if(Adres_eeprom>8191)while(1);// gdy przekroczę wartość pamięci zatrzymuję program
}
}[/syntax]

Adam12 napisał(a):

Przy okazji wyszło mi, że pamięć ma organizację 32 strony x 32 bity z czego z kolei wynika, że ma pojemność 1024 bajty czyli dwa razy więcej niż powinna mieć (8kb zamiast 4kb). Robiłem testy zapisując całą pamięć różnymi wartościami i rzeczywiście udało mi się taką pojemność zapisać i odczytać. Sam już nic z tego nie rozumiem. Może uda Wam się to też potwierdzić.

Tak Adam12 nie dość że mogę potwierdzić że Twoja Atmel24C04A ma 1024 bajty, to jeszcze zapytać Cię czy sprawdzałeś możliwość zapisania większego obszaru pamięci w tej kostce?

I tak w ogóle, to bardzo się cieszę, że dostała mi się własnie ta dziwna pamięć Atmela24C04A dzięki temu przypadkowi bardzo dużo się nauczyłem o transmisji I2C, oraz zacząłem bardziej rozumieć noty katalogowe z układami pracującymi z transmisją I2C.

Pozdrawiam.

Statystyki: Napisane przez steter — 24 lis 2020, o 19:35

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-11-21T21:55:48+01:00

steter napisał(a):

A może kostki nie problematyczne można adresować jak z końcówką A, (czyli strona, i nr.bajtu) ktoś sprawdzał?

Jak myślisz - skąd by wyniknął taki wątek ? gdyby działały tak samo. Toż dostęp do nich jest CAŁKOWICIE INNY, nie tam że coś troszkę ... że jakaś mała różnica - KOLOSALNA RÓŻNICA jest - i nie działa tu nic na krzyż ... czyli jednym sposobem nie obsłużysz tej drugiej poprawnie. Kolega Adam zrobił niezły investigejszyn i jego kod działa bez pudła i na 10000% dobrze, można ślicznie tę pamięć nim zapisywać i odczytywać

Statystyki: Napisane przez mirekk36 — 21 lis 2020, o 21:55

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-11-21T21:32:33+01:00

xentis napisał(a):

chym... posiadam dwa różne programatory do pamięci i w jednym nie ma rozróżnienia na 24C04 i 24C04A, ale jest on stary i powiedzmy że może nie mieć.
Natomiast drugi jest nowszy i faktycznie ma rozróżnienie. Co prawda nie znalazłem problematycznej pamięci, ale zapakowałem do programatora tę standardową bez literki na końcu. I dziwna sprawa, ale programator odczytuje poprawnie jej zawartość przy wybraniu obu pozycji... Więc albo jest "użytkownikoodporny" i sam wybiera właściwą komunikację, albo opcja z literką A została dodana na podstawie dostępnej w necie noty bez testowania fizycznego egzemplarza pamięci

A może kostki nie problematyczne można adresować jak z końcówką A, (czyli strona, i nr.bajtu) ktoś sprawdzał?

Statystyki: Napisane przez steter — 21 lis 2020, o 21:32

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-11-21T21:03:24+01:00

Statystyki: Napisane przez xentis — 21 lis 2020, o 21:03

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-11-21T20:15:33+01:00

xentis napisał(a):

24C04 i 24C04A od microchipa

nie dość że jest rozróżnienie to jeszcze na dodatek ciężko albo w ogóle nie można wpaść na notę do tej Atmelowskiej 24c04A niestety. Dlatego podałem wyżej link do postu gdzie jeden z kolegów ładnie rozgryzł tą kostkę. Ja sprawdzałem i jest idealnie tak jak to ten kolega pokazał - a pojemność pamięci jak najbardziej się zgadza. Więc nie ma co kombinować - tylko sprawdzić właściwymi źródłami z postu wcześniej - w których można zobaczyć sposób dostępu.

Statystyki: Napisane przez mirekk36 — 21 lis 2020, o 20:15

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-11-21T15:27:22+01:00

Fakt nie spojrzałem na dużo wcześniejsze posty. Dziwna sprawa, poszukam w szpargałach tej konkretnej kości. Będe miał na czym testować. Ale trochę to dziwne i wręcz nie do pomyślenia bo przecież są programatory do tych pamięci i tam nie ma rozróżnienia na 24C04 i 24C04A od microchipa

Statystyki: Napisane przez xentis — 21 lis 2020, o 15:27

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-11-21T15:07:58+01:00

Witaj xentis , dziękuję za zainteresowanie się tym nieco dziwnym tematem.
Wygląda na to, że nie przeczytałeś tego tematu od początku, gdy zastosuję się do noty, to po prostu komunikacja z tą właśnie kostką nie działa jak należy.

Adam12 napisał(a):

Ale tu nie chodzi o adres pamięci. Chodzi o to, że ta akurat AT24C04A ma całkiem odmienny sposób adresowania poszczególnych komórek do odczytu i zapisu. Najpierw trzeba podać stronę, a następnie bajt na tej stronie. Taki sposób nie jest opisany w żadnej nocie katalogowej dotyczącej tej pamięci. W przypadku zwykłej pamięci 24C04 podaje się po prostu adres kolejnego bajtu.

Pozdrawiam.

Statystyki: Napisane przez steter — 21 lis 2020, o 15:07

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-11-21T14:41:30+01:00

Jak na moje oko to namieszałeś. W tych pamięciach nie ma czegoś takiego jak numer strony, tak jak to próbujesz wysyłać w funkcji, no chyba że coś mi umknęło bo w funkcjach masz raz I2C_cośtam() a raz TWI_cośtam(), tak jakbyś poskładał tę funkcję z dwóch różnych źródeł...
Według noty strona to poprostu wielkość bufora ram w tej pamięci,(nota microchipa do kości 24C04A http://ww1.microchip.com/downloads/en/DeviceDoc/11183F.pdf):

steter napisał(a):

A skoro w żadnej nocie, nie ma poprawnej informacji o zapisie i odczycie tego eepromu, to również info o pojemności może być błędne.

Jak nie ma jak jest:

Masz nawet rozrysowane przebiegi całego zapisu stronicowego.
Aby zapisać stronę danych wysyłasz start, następnie bajt kontrolny składający się z 4 bitów identyfikujących typ, 2 bitów adresowych (zgodnie z podłączanymi nogami adresowymi pamięci), 1 bitu bloku oraz zerowy bit zapisu, następnie bajt adresujący - czyli od jakiego miejsca ma być zapisywana strona, następnie osiem bajtów danych zakończone stopem. Po tej sekwencji trzeba odczekać czas podany w nocie typowo 0.4*N[ms] gdzie N to liczba wysłanych bajtów, bo można wysłać mniej niż 8, ale nie więcej. Nota podaje jeszcze max. wartość krytyczną czasu jako 1*N[ms], jest to czas potrzebny na przepisanie danych z pamięci ram do eeprom, w tym czasie pamięć nie odpowie na próby komunikacji.
Wysłanie więcej niż 8 bajtów spowoduje nadpisanie pierwszych wysłanych danych czyli jeśli wyślesz 9 bajtów danych ostatni dziewiąty zapisze się w pierwszym bajcie bufora i zostanie zapisany do eeprom jako pierwszy, czyli niejako pierwszy bajt danych zostanie utracony.
Jest jeszcze jedna rzecz, mianowicie nota podaje że pamięć jest podzielona na 2 bloki (każdy po 256 bajtów), nie jest możliwy zapis inkrementacyjny na granicy bloku, tzn jeśli chcesz zapisać 8 bajtową stronę to nie możesz jako adres podać np 250 bo 250+8=258 czyli wyjdziesz poza blok a to spowoduje że dwa ostatnie bajty zostaną zapisane na adresie 1 i 2.

Powyższe wywnioskowane z noty microchipa do kostki 24C04A, nie testowałem, bo nie posiadam akurat pamięci 24C04A, ale z tego co kiedyś się bawiłem kostką innego producenta to tamta pamięć miała jakby zależność typu wielkość strony = wielkość bloku, czyli przy zapisie stronicowym trzeba było dokładnie wyliczyć początek strony bo inaczej podczas zapisu ta została "zrolowana".
Wygląda że pamięci 04A od microchipa produkowane są bez konwencji podziału na typowe strony jak wcześniej to miało miejsce, co zresztą piszą na końcu noty:

Statystyki: Napisane przez xentis — 21 lis 2020, o 14:41

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-11-21T12:22:39+01:00

Hmm,
Zapisuję zmienną o wartości 10 na stronę 1 do 250 bajtu
Sprawdzam każde 16 bajtów na 32 stronach i nie znajduję wcześniej zapisanej zmiennej z wartością 10
sprawdzam więc 32 bajty na 32 stronach i dalej nic
sprawdzam więc 256 bajtów na 32 stronach i znajduję na 1 stronie w 250 bajcie wcześniej zapisaną zmienną o wartości 10.?

o co chodzi?

funkcje z których korzystam.
[syntax=c]void TWI_write_EEPROM(uint8_t device, uint8_t strona, uint8_t nr_bajtu, uint8_t data ){
I2C_start();
I2C_write(device);
TWI_write(strona);
I2C_write(nr_bajtu);
I2C_write(data);
I2C_stop();
_delay_ms(5);

}
uint8_t TWI_read_EEPROM(uint8_t device, uint8_t strona, uint8_t nr_bajtu){
uint8_t data;
I2C_start();
I2C_write(device);
TWI_write(strona);
I2C_write(nr_bajtu);
I2C_start();
I2C_write(device+1);
data=I2C_read(NACK);
I2C_stop();
return data;
}[/syntax]

A tu kod do testowania.
[syntax=c]#define led_ON PORTC &=~(1<#define led_OFF PORTC |=(1<
#define zakres_sprawdzania_adresu_bajtu 253
// ustawiamy zakres sprawdzania adresu bajtu na stronach

int main(void) {
lcd_init(); // inicjalizacja lcd
inicjalizacja_I2C(); // inicjalizacja I2C
DDRC |= (1<led_OFF;

uint8_t DATA=10;
uint8_t a=0;
uint8_t strona=0;
uint8_t nr_bajtu=0;

//TWI_write_EEPROM(eeprom, 1, 250, DATA); // na stronę 1 do bajtu 250 zapisuję licbę 10

while(1) {
/* // do czyszczenia całego eeprom-mu
while(1){
TWI_write_EEPROM(eeprom, strona, nr_bajtu, 0);
nr_bajtu++;
if(!nr_bajtu){
strona++;
if(strona>31){
strona=0;
while(1)led_ON;
}
}
}
*/
a=TWI_read_EEPROM(eeprom, strona, nr_bajtu); // czytam z eepromu do zmiennej

lcd_locate(0, 0); //
lcd_str(" "); //
lcd_locate(0, 0); //
lcd_long_int(strona); //
//
lcd_locate(2, 0); //
lcd_str(" "); // tu poprostu wyświetlam na lcd nr strony, nr bajtu i zmienną pobraną z pamięci
lcd_locate(2, 0); //
lcd_long_int(nr_bajtu); //
//
lcd_locate(2,13); //
lcd_str(" "); //
lcd_locate(2,13); //
lcd_long_int(a); //

if(a==DATA)while(1)led_ON;// gdy pobrany bajt jest równy wcześniej zapisanemu, zatrzymaj program i załącz led

nr_bajtu++; // kolejny adres bajtu do sprawdzenia

if(nr_bajtu > zakres_sprawdzania_adresu_bajtu || !nr_bajtu){ // jak adres bajtu przekroczył limit to wyzeruj i następna strona
nr_bajtu=0;
strona++;
if(strona>31)while(1);// jak sprawdzone wszystkie strony to stoimy
}
}
}[/syntax]

Oczywiście nie ma co głowy zawracać, bo pamięć działa w zakresie deklarowanym przez producenta, ale jak by ktoś był w posiadaniu akurat tej pamięci Atmel718 24C04A i przy ciepłej herbatce się nudził to może wyprowadzi mnie na prostą.

Statystyki: Napisane przez steter — 21 lis 2020, o 12:22

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-11-21T10:30:48+01:00

Quote:

A mi wychodzi że ma 32 strony x 256 bitów.( co wydaje się nie możliwe )

No ale dobrze ci się wydaje, że to niemożliwe - bo nie jest możliwe pamięci jest tyle ile stwórca czyli fabryka dała ...

Coś tam musiałeś pomyliś jednak w kodzie

Statystyki: Napisane przez mirekk36 — 21 lis 2020, o 10:30

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-11-21T09:51:11+01:00

Wszystko działa jak należy, jako tylko Ciekawostkę, chciałem dociec jaką pojemność ma ten typ pamięci,

Adam12 napisał(a):

Przy okazji wyszło mi, że pamięć ma organizację 32 strony x 32 bity z czego z kolei wynika, że ma pojemność 1024

A mi wychodzi że ma 32 strony x 256 bitów.( co wydaje się nie możliwe )
A skoro w żadnej nocie, nie ma poprawnej informacji o zapisie i odczycie tego eepromu, to również info o pojemności może być błędne.

To po prostu ciekawe, jak ktoś nie ma czasu, lub po prostu ochoty, to luz, obawiałem się tylko że błędnie testuję tego eeproma.

Więc żadnego problemu Mirku niema:)
Pozdrawiam.

Statystyki: Napisane przez steter — 21 lis 2020, o 09:51

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-11-21T06:29:16+01:00

Przecież masz w tym wątku pełny poprawny kod źródłowy do obsługi tej pamięci

post226636.html#p226636

więc nie wiem za bardzo w czym problem?

a jeśli chodzi o pin WP to zaglądaj do not PDF, wtedy zawsze lepiej zrozumiesz o co chodzi i dlaczego może wisieć spokojnie w powietrzu, oto info wprost z noty pdf

Statystyki: Napisane przez mirekk36 — 21 lis 2020, o 06:29

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-11-20T22:50:19+01:00

Witam,

Dawno mnie na forum nie było, akurat miałem taki sam problem jak koledzy wyżej, dlatego postanowiłem napisać o swoich spostrzeżeniach.
Zacząłem się bawić i testować tą samą dziwną pamięć eeprom (ATMEL718 24C04A), i u mnie wygląda to tak jak by miała ona 32 strony, a na każdej stronie 255 bajtów. Napisałem krótki program według zaleceń (j.w) wydaje się wręcz nie możliwe, żeby było tak dużo pamięci, proszę wyprowadźcie mnie z błędnego myślenia jeśli się mylę, a jak macie chwilkę czasu, to przetestujcie, oczywiście sprawa dotyczy tylko tej dziwnej pamięci ATMEL718 24C04A.
Dziwię się również dlaczego w zestawie noga "WP" wisi w powietrzu? czy nie powinna być ściągnięta do GND, Układ oczywiście działa.
[syntax=c]#include
#include
#include
#include "I2C/I2C.h"
#include "LCD/lcd.h"

int main(void) {

lcd_init(); // inicjalizacja lcd
inicjalizacja_I2C(); // inicjalizacja I2C
DDRC |= (1<
//uint8_t dana=7;
TWI_write_EEPROM(eeprom, 0, 255, 2); // TWI_write_EEPROM(adres_kostki, strona, adres, DATA);
TWI_write_EEPROM(eeprom, 1, 254, 3);
TWI_write_EEPROM(eeprom, 2, 253, 4);
TWI_write_EEPROM(eeprom, 2, 252, 5);
TWI_write_EEPROM(eeprom, 5, 222, 6);
TWI_write_EEPROM(eeprom, 5, 122, 7);
TWI_write_EEPROM(eeprom, 25, 122, 8);

uint8_t a=0;
uint8_t strona=0;
uint8_t adres=0;
uint16_t suma=0;

while(1) {

/* // do czyszczenia całego eeprom-mu
while(1){

TWI_write_EEPROM(eeprom, strona, adres, 0);

adres++;
if(!adres){
strona++;
if(strona>31){
strona=0;
while(1){
PORTC &=~(1<}
}
}
}
*/
a=TWI_read_EEPROM(eeprom, strona, adres);

lcd_locate(0, 0);
lcd_str(" ");
lcd_locate(0, 0);
lcd_long_int(strona);

lcd_locate(2, 0);
lcd_str(" ");
lcd_locate(2, 0);
lcd_long_int(adres);

lcd_locate(2,13);
lcd_str(" ");
lcd_locate(2,13);
lcd_long_int(a);

suma = suma + a;

lcd_locate(0,13);
lcd_str(" ");
lcd_locate(0,13);
lcd_long_int(suma);

adres++;

if(!adres){
strona++;
if(strona>31){
strona=0;
PORTC &=~(1<while(1);
}
}
}
}[/syntax]

Statystyki: Napisane przez steter — 20 lis 2020, o 22:50

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-04-26T16:43:51+01:00

Adam12 napisał(a):

No właśnie jakby nie wszyscy to dostrzegają ... a wkurzające jest jakby trochę że kostka ma symbol niestety mylący nieco bo jak standardowa 24c04 wszystkich innych producentów

Statystyki: Napisane przez mirekk36 — 26 kwi 2020, o 16:43

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-04-26T15:59:33+01:00

Statystyki: Napisane przez Adam12 — 26 kwi 2020, o 15:59

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-04-26T13:46:49+01:00

wszytko śmiga jeszcze wczoraj wieczorem próbowałem , wszystko jest tak jak powinno być także dziękuje za pomoc wszystkim, życzę miłego dnia

Statystyki: Napisane przez wojtas14136 — 26 kwi 2020, o 13:46

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-04-26T12:07:59+01:00

wojtas14136 napisał(a):

a odnośnie tych adresów to wpisałem i dalej nic tylko prostokąty z LCD zniknęły , dlatego pewnie że to zły adres

ok to dzięki koledze Adam12 problem rozwiązany o tyle, że możesz sobie dodać do swojego kodu takie dwie funkcje, zastąpić w zasadzie te z Bluebooka

zamiast tych:

[syntax=c]void EI2C_read_buf(u08 device, u16 subAddr, u16 len, u08 *buf);
void EI2C_write_buf(u08 device, u16 subAddr, u16 len, u08 *buf);[/syntax]

daj właśnie takie:

[syntax=c]// odczyt danych z pamięci EEPROM
void AT24c04A_read_buf(u08 device, u16 subAddr, u16 len, u08 *buf) {

while (len) {
TWI_start();
TWI_write(device);
TWI_write(subAddr >> 5); // w pierwszym bajcie przesyłamy stronę
TWI_write(subAddr & 0x1F); // w drugim bajcie przesyłamy adres bajtu do zaprogramowania na wybranej stronie
TWI_start();
TWI_write(device + 1);

do {
subAddr++; // zwiększenie adresu
len--; // zmniejszenie długości danych do odczytu
*buf++ = TWI_read((( subAddr & 0x1F ) && len) ? ACK : NACK ); // wyślij NACK dla ostatniego bajtu
} while (( subAddr & 0x1F ) && len); // powtarzaj dopóki subAddr <32 i len>0

TWI_stop();
}
}

// zapis danych do pamięci EEPROM
void AT24c04A_write_buf(u08 device, u16 subAddr, u16 len, u08 *buf) {

while (len) {
TWI_start();
TWI_write(device);
TWI_write(subAddr >> 5); // w pierwszym bajcie przesyłamy stronę
TWI_write(subAddr & 0x1F); // w drugim bajcie przesyłamy adres bajtu do zaprogramowania na wybranej stronie

do {
subAddr++; //zwiększenie adresu
len--; //zmniejszenie długości danych do odczytu
TWI_write(*buf++);
} while (( subAddr & 0x1F ) && len); //powtarzaj dopóki subAddr <32 i len>0

TWI_stop();
_delay_ms(5); // oczekiwanie na zapis
}
}[/syntax]

I pamięć AT24c04A będzie śmigała w zestawie ATB, nie jest wadliwa. Jeszcze raz podziękowania dla kolegi Adam12, że wpadł na trop i akurat tutaj zajrzał. Zatem kliknij Adamowi przycisk "POMÓGŁ" - bo naprawdę pomógł !

Statystyki: Napisane przez mirekk36 — 26 kwi 2020, o 12:07

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-04-25T22:35:43+01:00

W PDFie w Memory Organization jest napisane:
"AT24C02A, 2K SERIAL EEPROM: The 2K is internally organized with 32 pages of 8bytes each. Random word addressing requires an 8-bit data word address.
AT24C04A, 4K SERIAL EEPROM: The 4K is internally organized with 32 pages of 16bytes each. Random word addressing requires a 9-bit data word address."

Statystyki: Napisane przez micky — 25 kwi 2020, o 22:35

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-04-25T20:50:25+01:00

Dobre - muszę przetestować w poniedziałek ... ale jednak to odstępstwo od normy na ATB no i wkurzające właśnie, że noty dla AT24C04A nie mówią o tych szczegółach. Fajnie że udało ci się do tego dojść.

Statystyki: Napisane przez mirekk36 — 25 kwi 2020, o 20:50

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-04-25T20:46:15+01:00

Mam też 24C04A i miałem ten sam problem. Układ nie jest wadliwy, ale rzeczywiście ma inny rodzaj transmisji, podobny jak dla układów o większej pojemności. Co ciekawe nie udało mi się tego znaleźć w żadnej nocie, nawet innego producenta. Ale znalazłem ten temat: https://forum.elportal.pl/viewtopic.php?f=83&t=2709, który wszystko wyjaśnił. Na podstawie tego opisu napisałem swoje funkcje i wszystko działa jak należy. Przy okazji wyszło mi, że pamięć ma organizację 32 strony x 32 bity z czego z kolei wynika, że ma pojemność 1024 bajty czyli dwa razy więcej niż powinna mieć (8kb zamiast 4kb). Robiłem testy zapisując całą pamięć różnymi wartościami i rzeczywiście udało mi się taką pojemność zapisać i odczytać. Sam już nic z tego nie rozumiem. Może uda Wam się to też potwierdzić.

Moje funkcje:
[syntax=c]#define _24C04_ADDR 0xA8

// utworzenie typu u08, odpowiednika uint8_t aby kod był bardziej czytelny
typedef unsigned char u08;
typedef unsigned short u16;

uint8_t AT24Cxx_read_byte(u08 device, u16 subAddr);
void AT24Cxx_write_byte(u08 device, u16 subAddr, u08 byte);
void AT24Cxx_fill_all(u08 device, u08 byte);
void AT24Cxx_erase_all(u08 device);
void AT24Cxx_read_buf(u08 device, u16 subAddr, u16 len, u08 *buf);
void AT24Cxx_write_buf(u08 device, u16 subAddr, u16 len, u08 *buf);
void AT24Cxx_read(u08 device, u16 subAddr, u16 len, u08 *buf);
void AT24Cxx_write(u08 device, u16 subAddr, u16 len, u08 *buf);

// odczyt bajtu z pamięci EEPROM
uint8_t AT24Cxx_read_byte(u08 device, u16 subAddr) {
TWI_start();
TWI_write(device);
TWI_write(subAddr >> 5);//page0-31
TWI_write(subAddr & 0x1F); //byte0-31
TWI_start();
TWI_write(device + 1);
u08 byte = TWI_read( NACK );
TWI_stop();
return byte;
}

// zapis bajtu do pamięci EEPROM
void AT24Cxx_write_byte(u08 device, u16 subAddr, u08 byte) {
TWI_start();
TWI_write(device);
TWI_write(subAddr >> 5);//page0-31
TWI_write(subAddr & 0x1F); //byte0-31
TWI_write(byte);
TWI_stop();
_delay_ms(3);
}

//wypełnienie całej zawartości pamięci EEPROM wartością bajt
void AT24Cxx_fill_all(u08 device, u08 byte) {
for (uint16_t i = 0; i < 32; i++) {
TWI_start();
TWI_write(device);
TWI_write(i);//page
TWI_write(0);//byte
for (uint16_t j = 0; j < 32; j++) TWI_write(byte);
TWI_stop();
_delay_ms(3);
}
}

//kasowanie całej zawartości pamięci EEPROM czyli zapis 0xFF do każdej komórki
void AT24Cxx_erase_all(u08 device) {
AT24Cxx_fill_all(device, 0xFF);
}

// odczyt danych z pamięci EEPROM po jednym bajcie
void AT24Cxx_read_buf(u08 device, u16 subAddr, u16 len, u08 *buf) {
while (len--) {
*buf++ = AT24Cxx_read_byte(device, subAddr);
subAddr++;
}
}

// zapis danych do pamięci EEPROM po jednym bajcie
void AT24Cxx_write_buf(u08 device, u16 subAddr, u16 len, u08 *buf) {
while (len--) {
AT24Cxx_write_byte(device, subAddr, *buf++);
subAddr++;
}
}

// odczyt danych z pamięci EEPROM całymi stronami
void AT24Cxx_read(u08 device, u16 subAddr, u16 len, u08 *buf) {
while (len) {
TWI_start();
TWI_write(device);
TWI_write(subAddr >> 5);//page0-31
TWI_write(subAddr & 0x1F); //byte0-31
TWI_start();
TWI_write(device + 1);
do {
subAddr++;//zwiększenie adresu
len--;//zmniejszenie długości danych do odczytu
*buf++ = TWI_read((( subAddr & 0x1F ) && len) ? ACK : NACK ); //wyślij NACK dla ostatniego bajtu
} while (( subAddr & 0x1F ) && len); //powtarzaj dopóki subAddr <32 i len>0
TWI_stop();
}
}

// zapis danych do pamięci EEPROM całymi stronami
void AT24Cxx_write(u08 device, u16 subAddr, u16 len, u08 *buf) {
while (len) {
TWI_start();
TWI_write(device);
TWI_write(subAddr >> 5);//page0-31
TWI_write(subAddr & 0x1F); //byte0-31
do {
subAddr++;//zwiększenie adresu
len--;//zmniejszenie długości danych do odczytu
TWI_write(*buf++);
} while (( subAddr & 0x1F ) && len); //powtarzaj dopóki subAddr <32 i len>0
TWI_stop();
_delay_ms(3);
}
}[/syntax]

Statystyki: Napisane przez Adam12 — 25 kwi 2020, o 20:46

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-04-25T19:57:59+01:00

chi.cygni napisał(a):

W jednym zestawie ATB mam 24C04, a w drugim 24C04BN.

No właśnie czyli nie masz tej wersji 24c04A i dlatego działa i będzie działać w każdej konfiguracji - nie wiem dlaczego producent do niektórych scalaków włożył nam te 24c04A ... tyle że one też powinny działać ale coś mi śmierdzi, że chyba są wadliwe ... jeszcze w poniedziałek sprawdzę na zewnętrznym programatorze pamięci EEPROM żeby się upewnić

Statystyki: Napisane przez mirekk36 — 25 kwi 2020, o 19:57

Re: Problem z połączeniem magistrala I2C RTC i EEPROM

2020-04-25T19:21:52+01:00

mirekk36 napisał(a):

A czytałeś wyżej o modelu scalaka ? Sprawdziłeś jaki masz ? czy 24c04A ? jak nie to sprawdź

W jednym zestawie ATB mam 24C04, a w drugim 24C04BN.

Statystyki: Napisane przez chi.cygni — 25 kwi 2020, o 19:21