EEPROM 24C04 nie mogę sie z nim dogadać. Co nie tak w kodzie ?.

Question

Na kilku stronach pamieci chcę zapisac po kilka danych.Walcze 4 dni i nie wiem o co chodzi. Otóż zapisuje swoje dane na pierwszej stronie w kółko.O...

zumek · Accepted Answer

Nie rozumiem Cię - chcesz rozwiązać problem, czy udawać ... "mądralę"

5657jz · Answer

5 dzień. I nic. 7 dnia chyba pogryzę ten uklad. Niby wszystko OK a jednak jest Ľle.
Jak się resetuje ten uklad ? czy w ten sposób:

Code:

  void resetEE(void)

{



       TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);

          while(!(TWCR & (1<<TWINT)));            // start



       TWDR = 0xFF;

      TWCR = (1<<TWINT) | (1<<TWEN);               // ??



       TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);

         while(!(TWCR & (1<<TWINT)));            // start



       TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);

      while(TWCR & (1<<TWSTO));                   // stop

}

dondu · Answer

Pokaż schemat Twojego układu.

5657jz · Answer

To wycinek schematu:
https://obrazki.elektroda.pl/9544476000_1306225333.jpg linie podciagniete rezystorami 4K7 , bez kondensatorów.
Z PCFem komunikuje sie OK. PS. Jak testuje program poprzez JTAG, adresy urzadzenia, adresy komórek przekazywane s± prawidłowo. Jednak zapisy /odczyty
s± tylko na pierwszej stronie pamieci.
-chyba nie udaje mi sie wkleić obrazka.

michalko12 · Answer

Code: cLog in, to see the codeDomniemam że adresEE() to funkcja wysyłająca adres do EEPROMU, to jesli tak to chyba powinno to być w odwrotnej kolejności?

5657jz · Answer

FLAGA_ZAP_EE to zaadresowanie komórki pamieci.
Nastepnie przejscie do trybu READ . OK?
dalej sprawdzam czy twi_readNak()==1 ,jesli TAK, to STOP i koniec funkcji

ELSE (twi_readNak()==0) to STOP. Dalej START i ustawiam adres komórki na pierwszy bajt drugiej str. pamieci -już w petli DO.

JarekC · Answer

Witam,

Pokaż funkcje:
adresEE
twi_start
twi_stop
twi_write
twi_readNak

oraz definicję stałych
EEPROM
TWI_READ
TWI_WRITE
FLAGA_ZAP_EE

Pokazany fragment kodu to za mało aby znaleĽć przyczynę problemów.

Pozdrawiam
JarekC

michalko12 · Answer

Dlaczego sprawdzasz adres 0x00 skoro alarmy zapisujesz od 0x10?Chyba że znowu coś przeoczyłem.

5657jz · Answer

W skrócie oco chodzi:
Po pierwszym podlaczeniu uC zapisywane s± wertosci domyslne w EEPROMie i ustawiana jest flaga "1" pod adresem 0x01(czyli po resecie uC sprawdzam flagę i zapisuje EEprom lub nie)
Jesli flaga "0" to EE_init() zapisuje EEproma.

Dalej- alarmy_DEV() -przeglad zapisów "alarmów", po wyboże klawisza- EDYCJA wybranego -alarm_edit()-zapis- dalszy przeglad alarmów- i mozliwo¶c opuszczenia funkcji

W kodach jest nie porzadek, ale juz kombinuje we wszystkie strony i nic.
utkn±łem przy zapisie i nie moge sie wygrzebac.
Kody:

Code:

/* EEprom.h*/

#define FLAGA_ZAP_EE               0x0001  // adres -Flaga zapisu EEpromu

#define ALARMY_POCZ                     0x0010  // adres -Pierwsza strona alarmów

#define ALARMY_KONIEC                   0x00D0  // adres -Ostatnia strona alarmów

#define EEPROM   0xA4    // adres kosci EEPROM

#define TWI_READ    1

#define TWI_WRITE   0

Code:

/* EEPROM.c*/



#include <avr/io.h>

#include <util/delay.h>

#include <stdlib.h> 

#include <stdint.h>

#include <avr/pgmspace.h>

#include "bool.h"

#include "menu.h"

#include "lcd.h"

#include "EEprom.h"



static uint16_t addr;//=ALARMY_POCZ;

unsigned char temp_addr;



 unsigned char ret;

extern unsigned char alarmy[10];

extern unsigned char addr_MASTER;

 char bufor[3];//unsigned

 bool zatwierdz;//=false;

 bool koniec;

static unsigned char nr_alarm=0;

   



void EE_init(void);

void alarmy_dev(void);

void wykonaj_ALARM(unsigned char x,unsigned char *slave,unsigned char *urz);

void alarm_edit(uint16_t addr,unsigned char  alarm);

void czysc_LCD(void);







  void resetEE(void)

{



       TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);

          while(!(TWCR & (1<<TWINT)));            // start



       TWDR = 0xFF;

      TWCR = (1<<TWINT) | (1<<TWEN);               // ??



       TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);

         while(!(TWCR & (1<<TWINT)));            // start



       TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);

      while(TWCR & (1<<TWSTO));                   // stop

}





void adresEE(uint16_t adress) // wyslij adres cz.H, cz. L

{



   temp_addr=adress>>8;

   twi_write(temp_addr);

   temp_addr=adress&0x00FF;

   twi_write(temp_addr);

}







void alarm_na_LCD(char cyfra) 

{

                  if (cyfra<10)

                     for(int i=0;i<1;i++){lcd_write((unsigned char )bufor[i],1);}

                  else if (cyfra>=10)

                     for(int i=0;i<2;i++){lcd_write(bufor[i],1);}



}



/****************************************************************

   Inicjacja pamieci EEPROM - wpisanie wartosci poczatkowych i adresów pamieci

****************************************************************/









void EE_init(void)

{

    addr=ALARMY_POCZ;             // =0x10  to poczatek 2-giej  strony pamieci gdzie chcę zapisac liczby

   

   ret=twi_start(EEPROM+TWI_WRITE);              // czy wykonano START

      if (ret)

      {

         //Bład połaczenia

         return 0;}



      else

      {   

         adresEE(FLAGA_ZAP_EE);               // (0x01) pod tym adresem odczytuje flagę

                  

         twi_start(EEPROM+TWI_READ); 



         if(twi_readNak()==1)

         {   // eeprom ZAPISANY WARTOSCIAMI DOMYSNYMI

            twi_stop();

             // to wychodze z funkcji 

         }

         else 

         {

            twi_stop();

                        

            do                        //  teraz na 13 stronach chcę zapisac wertosci domyslne.

            {

            twi_start(EEPROM+TWI_WRITE);

            adresEE(addr); // j/w 0x0010 

            

               twi_write(nr_alarm+1);   // nrumer alarmu  

               twi_write(0x00);   // Flaga start

               twi_write(0x00);   // Flaga stop

               twi_write(0x01);    // Dot.  SLAVE 1-99

               twi_write(0x00);    // Dot. urzadzenia: 1-3 przekaĽniki 4-sygnał

               twi_write(0x00);    // Godz. Startu

               twi_write(0x00);    // Min. Startu

               twi_write(0x07);    // Dzień Startu

               twi_write(0x00);    // Godz. zatrzymania

               twi_write(0x00);    // Min. zatrzymaia

               twi_write(0x07);    // Dzień zatrzymania.



               twi_stop();

               _delay_ms(15);      // wg. noty max 5ms. wydłzyłem do 55

               nr_alarm++;         // 

               addr+=16;           // przejdz do nastepnej strony EEPROM 

               

            

            }while (!(addr>ALARMY_KONIEC));  // ALARMY_KONIEC  to 208 (0xD0)

            nr_alarm=0;

            addr=0;

         }//end if

      }//end if ret

            twi_start(EEPROM+TWI_WRITE);

            adresEE(FLAGA_ZAP_EE);

            twi_write(0x01);

            twi_stop(); _delay_ms(5);

} // end EE-init   

   





/****************************************************************************************

   Przygotowanie danych do wysyłki przez RS485

*****************************************************************************************/

void wykonaj_ALARM(unsigned char x,unsigned char *slave,unsigned char *urz)

{

       komenda_na_RS(':',*slave,addr_MASTER,1,x,*urz);    // funkcja-1(wl±cz/wylacz), parametr ON-wlacz,OFF wyłacz.



}//end wykonaj_ALARM  */





/*******************************************************************************

  EDYCJA ALARMU

*******************************************************************************/

void alarm_edit(uint16_t addr,unsigned char alarm)    // ta funkcja zapisuje ale pod adresem 0x0000

{



   bool zatwierdz=false;

   //int ad_start;

   //unsigned int x=addr;

   static unsigned char f_start=0;

   static unsigned char g_start=0;

   static unsigned char m_start=0;

   static unsigned char dey_start=7;

   static unsigned char f_stop=0;

   static unsigned char g_stop=0;

   static unsigned char m_stop=0;

   static unsigned char dey_stop=7;

   static unsigned char dev=0;

   static unsigned char pk=0;



   itoa(alarm,bufor,10); // nr alarmu

   lcd_gotoxy(7, 0);

   alarm_na_LCD(alarm);

   

   LCD_DISP_ON_CURSOR;

         //do

         //for(int i=0;i<3;i++)

         //{

            f_start=ustaw_cyfre(f_start,4,1,1,0);

            _delay_ms(40);

            g_start=ustaw_cyfre(g_start,7,1,23,0);

            _delay_ms(40);

            m_start=ustaw_cyfre( m_start, 10,1,59,0);

            _delay_ms(40);

            dey_start=ustaw_cyfre( dey_start, 15,1,7,0);

         //}

         //}while(!zatwierdz);



         //do

         //for(int i=0;i<3;i++)

         //{

            f_stop=ustaw_cyfre(f_stop,4,2,1,0);

            _delay_ms(40);

            g_stop=ustaw_cyfre(g_stop,7,2,23,0);

            _delay_ms(40);

            m_stop=ustaw_cyfre( m_stop, 10,2,59,0);

            _delay_ms(40);

            dey_stop=ustaw_cyfre( dey_stop, 15,2,7,0);

         //}

         //}while(!zatwierdz);



         //do

         //for(int i=0;i<2;i++)

         //{

            dev=ustaw_cyfre(dev,6,3,99,1);

            _delay_ms(40);

            pk=ustaw_cyfre(pk,12,3,4,1);

            _delay_ms(40);

         //}

         //}while(!zatwierdz);



   

   lcd_gotoxy(10, 0);

   lcd_puts_p(PSTR("ZAPIS "));



         //TU ZAPIS

                    twi_start(EEPROM+TWI_WRITE);

                  adresEE(addr+1);

                  //twi_write(0x00);

                  //twi_write(addr+1);



                  twi_write(f_start);

                  twi_write(f_stop);

                  twi_write(dev);

                  twi_write(pk);

                  twi_write(g_start);

                  twi_write(m_start);

                  twi_write(dey_start);

                  twi_write(g_stop);

                  twi_write(m_stop);

                  twi_write(dey_stop);

                  twi_stop();

                  _delay_ms(100);

               lcd_command(LCD_DISP_ON);

}//end alarm_edit







/******************************************************************************

   Czy¶ć LCD

******************************************************************************/

void czysc_LCD(void)

{



lcd_gotoxy(6, 0);

write_znak(' ',3);

lcd_gotoxy(4, 1);

write_znak(' ',2);

lcd_gotoxy(7, 1);

write_znak(' ',2);

lcd_gotoxy(10, 1);

write_znak(' ',2);

lcd_gotoxy(15, 1);

write_znak(' ',1);

lcd_gotoxy(4, 2);

write_znak(' ',2);

lcd_gotoxy(7, 2);

write_znak(' ',2);

lcd_gotoxy(10, 2);

write_znak(' ',2);

lcd_gotoxy(15, 2);

write_znak(' ',1);

lcd_gotoxy(6, 3);

write_znak(' ',2);

lcd_gotoxy(11,3);

write_znak(' ',2);

}



/******************************************************************************

   Ustawienie 15 czasów alarmów załacz/wyłacz

*******************************************************************************/

void alarmy_dev(void)

{

   static unsigned char cyfra=0;

   addr=ALARMY_POCZ; 

   //char buf[3];

   //static unsigned char nr_alarm;

   bool koniec=false;

   

   



   //lcd_clrscr();

   lcd_home();

   lcd_gotoxy(1, 0);

   lcd_puts_p(PSTR("ALARM    Y-edit")); //lcd 7,0

   lcd_gotoxy(0, 1);

   lcd_puts_p(PSTR("STR   g  m  dey")); // lcd 4,1, lcd 7,1, lcd 10,1 lcd 15,1

   lcd_gotoxy(0, 2);

   lcd_puts_p(PSTR("STP   g  m  dey")); // lcd 4,2, lcd 7,2  lcd 10,2  lcd 15,2

   lcd_gotoxy(0, 3);

   lcd_puts_p(PSTR("SLAVE    PK-"));    // lcd 6,3  lcd 12,3

       ret=twi_start(EEPROM+TWI_WRITE);

            if(ret) // Bład

         {   //twi_write(0x00);

            //twi_write(0x00);

            //twi_stop();

            return 0;

            }



         else

         {   

                    adresEE(0); 

               twi_write(0);

               twi_stop();

               _delay_ms(5);



               while(1)

               {

                  

                  twi_start(EEPROM+TWI_WRITE);

                  adresEE(addr);

                  //twi_write(0x00);

                  //twi_write(addr);

                  //twi_stop();

                  



                    twi_start(EEPROM+TWI_READ); 

                         

                           cyfra=twi_readAck();

                           nr_alarm=cyfra;

                           itoa((int)cyfra,bufor,10);

                           lcd_gotoxy(7,0);      // nr alarmu

                           alarm_na_LCD(cyfra);

                              

                           cyfra=twi_readAck();

                           itoa((int)cyfra,bufor,10);

                           lcd_gotoxy(4,1);      // flaga start

                           alarm_na_LCD(cyfra);



                           cyfra=twi_readAck();

                           itoa((int)cyfra,bufor,10);

                           lcd_gotoxy(4,2);      //flaga stop

                           alarm_na_LCD(cyfra);



                           cyfra=twi_readAck();

                           itoa((int)cyfra,bufor,10);

                           lcd_gotoxy(6,3);      // Dev

                           alarm_na_LCD(cyfra);



                           cyfra=twi_readAck();

                           itoa((int)cyfra,bufor,10);

                           lcd_gotoxy(12,3);      // urzadzenie

                           alarm_na_LCD(cyfra);



                           cyfra=twi_readAck();

                           itoa((int)cyfra,bufor,10);

                           lcd_gotoxy(7,1);      // godzi start

                           alarm_na_LCD(cyfra);



                           cyfra=twi_readAck();

                           itoa((int)cyfra,bufor,10);

                           lcd_gotoxy(10,1);      // min. start

                           alarm_na_LCD(cyfra);



                           cyfra=twi_readAck();

                           itoa((int)cyfra,bufor,10);

                           lcd_gotoxy(15,1);      // dey start

                           alarm_na_LCD(cyfra);



                           cyfra=twi_readAck();

                           itoa((int)cyfra,bufor,10);

                           lcd_gotoxy(7,2);      // godz stop

                           alarm_na_LCD(cyfra);



                           cyfra=twi_readAck();

                           itoa((int)cyfra,bufor,10);

                           lcd_gotoxy(10,2);      //min stop

                           alarm_na_LCD(cyfra);



                           cyfra=twi_readNak();

                           itoa((int)cyfra,bufor,10);

                           lcd_gotoxy(15,2);      //dey stop

                           alarm_na_LCD(cyfra);

                           cyfra=0;

                           twi_stop();

                           



                           

                  

                        do

                         {



                               if(bit_is_clear(PIN(MENU_PORT),PLUS))  // pokaz nastepny

                              {      lcd_home();

                                    czysc_LCD();

                                    lcd_home();

                                    addr+=16;

                                    if (addr>ALARMY_KONIEC)

                                    {   addr=ALARMY_KONIEC; continue;

                                    }

                                    break;

                              }

                              if(bit_is_clear(PIN(MENU_PORT),MINUS))

                              {      lcd_home();

                                    czysc_LCD();

                                    lcd_home();

                                    addr-=16;

                                    if (addr<ALARMY_POCZ)

                                    {   addr=ALARMY_POCZ; continue;

                                    }

                                    break;

                              }

                              if(bit_is_clear(PIN(MENU_PORT),Y_MENU))  // edytuj

                              {   lcd_home();

                                 czysc_LCD();

                                 lcd_home();

                                 

                                     alarm_edit(addr,nr_alarm);      // edytuj bierzacy alarm

                                 

                                 lcd_home();

                                 lcd_gotoxy(10, 0);

                                 lcd_puts_p(PSTR("Y-EDIT"));

                                 czysc_LCD();

                                 lcd_home();

                                 break;

                              }





                              if(bit_is_clear(PIN(MENU_PORT),POWROT))  // koniec przegladania

                              {   koniec=true;

                                    break;

                              }

                         

                         }while(!(koniec));//end while

                  if (koniec)

                  {   lcd_clrscr();

                     _delay_ms(2);

                     break;}

               

                               

               }//while (!(addr==ALARMY_KONIEC));

               nr_alarm=0;

               addr=0;

         }// end else





}//end alarmy_dev

Code:

/*twi.c*/





#include <avr/io.h>

#include "twi_master.h"

#include <avr/sfr_defs.h>

#include <avr/pgmspace.h>

#include <util/delay.h>

#define ACK 1

#define NOACK 0

#define TW_STATUS   TWSR

//#define twi_read(ack)  (ack) ? i2c_readAck() : i2c_readNak(); 

extern unsigned char addr_MASTER;





void twi_init(void)

{

  /* initialize TWI clock: 100 kHz clock, TWPS = 0 => prescaler = 1 */

  

  TWSR = 0;                         /* no prescaler */

  TWBR = ((F_CPU/SCL_CLOCK)-16)/2;  /* must be > 10 for stable operation */

  TWAR = addr_MASTER;            /* Adres MASTER bierzacego urzadzenia(7bit)+1(odpowiada na wezwania)*/

  

}/* i2c_init */

  

  

/***************************************************************/





unsigned char twi_start(unsigned char address)

{

    uint8_t   twst;



   // send START condition

   TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);



   // wait until transmission completed

   while(!(TWCR & (1<<TWINT)));



   // check value of TWI Status Register. Mask prescaler bits.

   twst = TW_STATUS & 0xF8;



   if ( (twst != TWI_START) && (twst != TWI_REP_START)) return 1;



   // send device address

   TWDR = address;

   TWCR = (1<<TWINT) | (1<<TWEN);



   // wail until transmission completed and ACK/NACK has been received

   while(!(TWCR & (1<<TWINT)));



   // check value of TWI Status Register. Mask prescaler bits.

   twst = TW_STATUS & 0xF8;



   if ( (twst != TWI_MTX_ADR_ACK) && (twst != TWI_MRX_ADR_ACK ) ) return 1;



   return 0;



}/* i2c_start */







/**********************************************************/



void twi_stop(void)

{

    /* send stop condition */

   TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);

   

   // wait until stop condition is executed and bus released

   while(TWCR & (1<<TWSTO));



}/* i2c_stop */



/**********************************************************/



unsigned char twi_write( unsigned char data )

{   

    uint8_t   twst;

    

   // send data to the previously addressed device

   TWDR = data;

   TWCR = (1<<TWINT) | (1<<TWEN);



   // wait until transmission completed

   while(!(TWCR & (1<<TWINT)));



   // check value of TWI Status Register. Mask prescaler bits

   twst = TW_STATUS & 0xF8;



   if( twst != TWI_MTX_DATA_ACK) return 1;

   return 0;



}/* i2c_write */



      



void twi_start_wait(unsigned char address)

{

    uint8_t   twst;





    while ( 1 )

    {

       // send START condition

       TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);

    

       // wait until transmission completed

       while(!(TWCR & (1<<TWINT)));

    

       // check value of TWI Status Register. Mask prescaler bits.

       twst = TW_STATUS & 0xF8;



          if ( (twst != TWI_START) && (twst != TWI_REP_START)) continue;

    

       // send device address

       TWDR = address;

       TWCR = (1<<TWINT) | (1<<TWEN);

    

       // wail until transmission completed

       while(!(TWCR & (1<<TWINT)));

    

       // check value of TWI Status Register. Mask prescaler bits.

       twst = TW_STATUS & 0xF8;



       if ( (twst == TWI_MTX_ADR_NACK )||(twst ==TWI_MRX_DATA_NACK ) ) 

       {           

           /* device busy, send stop condition to terminate write operation */

           TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);

           

           // wait until stop condition is executed and bus released

           while(TWCR & (1<<TWSTO));

           

           continue;

       }

       //if( twst == TWI_MTX_ADR_ACK) return ;

       break;

     }



}/* i2c_start_wait */





/***************************************************************************/

unsigned char twi_rep_start(unsigned char address)

{

    return twi_start( address );



}/* i2c_rep_start */







/*************************************************************************

  Przeczytaj jeden bajt z urz±dzenia I2C, poczym następuje stan zatrzymania ack=1

 Return:  byte read from I2C device

*************************************************************************/

unsigned char twi_readNak(void)

{

   TWCR = (1<<TWINT) | (1<<TWEN);

   while(!(TWCR & (1<<TWINT)));

   

    return TWDR;



}/* i2c_readNak */









/*************************************************************************

  Przeczytaj jeden bajt z urz±dzenia I2C, ż±danie większej ilo¶ci danych z urz±dzenia ack=0

 Return:  byte read from I2C device

*************************************************************************/

unsigned char twi_readAck(void)

{

   TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWEA);

   while(!(TWCR & (1<<TWINT)));    



    return TWDR;



}/* i2c_readAck */

PS. O ile dobrze przeczytalem i zrozumiałem note katalogowa- mozliwym jest zablokowanie EEproma resetami itp. Nie przyjmuje wtedy rozkazów.Dlatego pytałem o reset. Ewentualnie prosze o sprostowanie.

zumek · Answer

Chyba nie bardzo Skąd Ty wytrzasnąłeś 16-bitowe adresowanie tej pamięci Czyżby zmyliło Cię słówko WORD ADDRESS

5657jz · Answer

Nie pisz "skad" .Jak uwazasz ze to bład to napisz jak byc powinno. Nie zakładałem tego tematu po to że mam duza wiedze. Tylko aby uzyskac pomoc.

zumek · Answer

Piszesz, że czytałeś notę katalogową więc pytam: dlaczego w Twoim kodzie adresowanie jest 16-bitowe, skoro w tejże nocie jest napisane, że adresowanie komórek pamięci jest 8-bitowe

5657jz · Answer

A jak zaadresujesz 511 komórkę ?? W nocie napisane jest adresowanie 9-bitów.Czytaj dokładniej.

5657jz · Answer

Myśle, że adres urzadzenia to 7-bitów+R/W.Czy tak ?OK. Przepraszam. Własnie doczytałem sie, że PO-9-bit należy do adresowania  pamieci powyżej 255Wieczorem pozmieniam kod i powinno się wszystko rozwiazać. Dzieki za pomoc. Okazuje sie że, JA czytam nie dokładnie.