Elektroda.pl
Elektroda.pl
X

Search our partners

Find the latest content on electronic components. Datasheets.com
Elektroda.pl
Please add exception to AdBlock for elektroda.pl.
If you watch the ads, you support portal and users.

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

5657jz 22 May 2011 18:45 2988 14
Computer Controls
  • #1
    5657jz
    Level 14  
    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 ile rozumiem to: 24C04 ma 32 strony po 16 bajtów, mogę zapisac dane skwencyjnie, nie wychodząc poza strone - bo przewinie sie do poczatku strony i dane nadpisze.
    Wiec, jesli wpisuje 11 bajtów na danej stronie, to po STOPie- EEPROM je zapisuje w ciagu max 5 ms. I dalej, rozumiem, że mogę zaadresować strone nastepną i zapisać nastepną paczke danych. Jeżeli dobrze kombinuje to wypociłem to co poniżej i dane zapisywane są w kółko na pierwszej stronie, ponieważ nr_alarm po odczycie ma wartość 13 (pod adresem 0x0000). Gdzie bład.
    Code:
    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);   // 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(55);      // 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   
       

    addr,nr_alarm -to plikowe STATIC Co robie żle ?.
  • Computer Controls
  • #2
    5657jz
    Level 14  
    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
    }
  • Computer Controls
  • #4
    5657jz
    Level 14  
    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.
  • #5
    michalko12
    MCUs specialist
    Code: c
    Log 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?
  • #6
    5657jz
    Level 14  
    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.
  • #7
    JarekC
    Level 31  
    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
  • #8
    michalko12
    MCUs specialist
    5657jz wrote:
    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.


    Wszystko Ok, źle spojrzałem w DS.

    Jeszcze jedno:

    5657jz wrote:
    ponieważ nr_alarm po odczycie ma wartość 13 (pod adresem 0x0000).


    Dlaczego sprawdzasz adres 0x00 skoro alarmy zapisujesz od 0x10?
    Chyba że znowu coś przeoczyłem.
  • #9
    5657jz
    Level 14  
    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.
  • #10
    zumek
    Level 39  
    5657jz wrote:
    ... O ile dobrze przeczytalem i zrozumiałem note katalogowa-...

    Chyba nie bardzo :D
    Skąd Ty wytrzasnąłeś 16-bitowe adresowanie tej pamięci :?:
    Czyżby zmyliło Cię słówko WORD ADDRESS :?:
  • #11
    5657jz
    Level 14  
    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.
  • #12
    zumek
    Level 39  
    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 :?:
  • #13
    5657jz
    Level 14  
    A jak zaadresujesz 511 komórkę ?? W nocie napisane jest adresowanie 9-bitów.
    Czytaj dokładniej.
  • Helpful post
    #14
    zumek
    Level 39  
    5657jz wrote:
    A jak zaadresujesz 511 komórkę ?? W nocie napisane jest adresowanie 9-bitów.
    Owszem, tylko że 9-ty bit znajduje się w adresie urządzenia, a nie w adresie komórki pamięci.
    5657jz wrote:

    Czytaj dokładniej.

    Nie rozumiem Cię - chcesz rozwiązać problem, czy udawać ... "mądralę" :?:
  • #15
    5657jz
    Level 14  
    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.