logo elektroda
logo elektroda
X
logo elektroda
Adblock/uBlockOrigin/AdGuard mogą powodować znikanie niektórych postów z powodu nowej reguły.

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

5657jz 22 Maj 2011 18:45 3081 14
  • #1 9533455
    5657jz
    Poziom 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.
    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 ?.
  • #2 9538143
    5657jz
    Poziom 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:
      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
    }
  • #4 9538561
    5657jz
    Poziom 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 9538736
    michalko12
    Specjalista - Mikrokontrolery
    Kod: C / C++
    Zaloguj się, aby zobaczyć kod

    Domniemam że adresEE() to funkcja wysyłająca adres do EEPROMU, to jesli tak to chyba powinno to być w odwrotnej kolejności?
  • #6 9538789
    5657jz
    Poziom 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.
  • #8 9538867
    michalko12
    Specjalista - Mikrokontrolery
    5657jz napisał:
    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 napisał:
    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 9539064
    5657jz
    Poziom 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:
    /* 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



    /* 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
    

    /*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 9539131
    zumek
    Poziom 39  
    5657jz napisał:
    ... 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 9539230
    5657jz
    Poziom 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 9539308
    zumek
    Poziom 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 9539318
    5657jz
    Poziom 14  
    A jak zaadresujesz 511 komórkę ?? W nocie napisane jest adresowanie 9-bitów.
    Czytaj dokładniej.
  • Pomocny post
    #14 9539345
    zumek
    Poziom 39  
    5657jz napisał:
    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 napisał:

    Czytaj dokładniej.

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