Zbernica i2c: EEPROM: Rozdiel medzi revíziami

Aktuálna revízia z 07:08, 26. apríl 2024

Obsah

1 Oboznámenie so zbernicou i2c

Oboznámenie so zbernicou i2c

Úlohy:

Pripojte k procesoru pamäť podľa schémy zapojenia
Schému upravte tak, aby adresa zariadenia bola ?? - určí cvičiaci
Zapíšte na prvé pamäťové miesto (adresa 0x00) znak 'A'
Prečítajte, či je znak správne zapísaný
Prečítajte obsah celej pamäte a vypíšte ho na terminál PC
Zapíšte do pamäte 10 bytov nejakej informácie a zistite, ako dlho trvá zápis jedného byte, t.j. aká veľká musí byť prestávka medzi jednotlivými zápismi.

Literatúra

Official I2C Specification Version 6 http://www.nxp.com/documents/user_manual/UM10204.pdf
Official List of assigned NXP / Philips I2C addresses http://www.diolan.com/downloads/i2c-address-allocation-table.pdf
Mitchell Kahn: Programming the i2c interface. Dr. Dobb's Journal, June 1992.
Example using the two-wire interface (TWI). AVRlibc demo projects.

Datasheets

1. Schéma zapojenia

Správnosť zapojenia si môžete vyskúšať programom Médiá:i2c_scan.ino - nájde všetky obvody pripojené na zbernici. Nachádza sa aj priamo vo vývojovom prostredí Arduino, pozri Examples -> Wire -> i2c_scan.

2. Device address

3. Inicializácia

Pri tvorbe programu pre modul budeme využívať už hotovú knižnicu i2cmaster dostupnú odtiaľto http://senzor.robotika.sk/mmp/src/i2c/

Najprv je potrebné zbernicu inicializovať:

         i2c_init();                                       // initialize I2C library

4. Zápis

Zápis je jednoduchší, preto ním začneme:

       // zapis hodnotu  0x41 ('A') to EEPROM address 00 (Byte Write) 

     i2c_start_wait( (EEPROM_ADDR << 1) | I2C_WRITE);     // 1: set device address and write mode
     i2c_write(0x00);                                     // 2: write address = 0
     i2c_write(0x41);                                     // 3: write value 0x41 to EEPROM
     i2c_stop();                                          // 4: set stop conditon = release bus

Postupnosť pre zápis hodnoty z EEPROM pamäte.

5. Čítanie

Čítanie vyžaduje trocha viac krokov, pretože najprv musíme smerom do EEPROM nastaviť adresu, z ktorej chceme čítať a potom obrátime smer komunikácie a počkáme na data z pamäti.

  /*  Precitame hodnotu zapisanu v predchadzajucom kroku z EEPROM addresy 0   */

     i2c_start_wait( (EEPROM_ADDR << 1) | I2C_WRITE);      // 1: set device address and write mode
     i2c_write(0x00);                                      // 2: write address = 0

     i2c_rep_start( (EEPROM_ADDR << 1) | I2C_READ );       // 3: set device address and read mode

     val = i2c_readNak();                                  // 4: read one byte from EEPROM
     i2c_stop();                                           // 5: stop

Program je samozrejme vhodné doplniť o zobrazenie prečítanej hodnoty v termináli cez sériové rozhranie.

Postupnosť pre čítanie hodnoty z EEPROM pamäte.

Jednoduchý program na prečítanie 1 byte z pamäte pre Arduino s využitím knižnice I2C_EEPROM je tu:

#include <I2C_eeprom.h>

#define MAXBYTES 2048/8         // it's only 2Kbit
#define DEVICEADDRESS (0x50)   // the address of your EEPROM

I2C_eeprom eeprom(DEVICEADDRESS,MAXBYTES);

byte value;
byte adresa = 0x00;

void setup()
{
  Serial.begin(9600);
  Serial.println("*** Reading memory content: ***");
  
  Wire.begin();
  eeprom.begin();
  
  value = eeprom.readByte(adresa);
  Serial.print((char)value); 
 
  Serial.println("\nDone...");
}

void loop()
{
  // Nothing to do during loop
}

@@ Riadok 6: / Riadok 6: @@
 # Pripojte k procesoru pamäť podľa schémy zapojenia
-# Schému upravte tak, aby adresa zariadenia bola ??
+# Schému upravte tak, aby adresa zariadenia bola ?? - určí cvičiaci
 # Zapíšte na prvé pamäťové miesto (adresa 0x00) znak 'A'
 # Prečítajte, či je znak správne zapísaný
-# Prečítajte obsah celej pamäte a vypíšte ho na terminál.
+# Prečítajte obsah celej pamäte a vypíšte ho na terminál PC
 # Zapíšte do pamäte  10 bytov nejakej informácie a zistite, ako dlho trvá zápis jedného byte, t.j. aká veľká musí byť prestávka medzi jednotlivými zápismi.
@@ Riadok 17: / Riadok 17: @@
 * Official I2C Specification Version 6 http://www.nxp.com/documents/user_manual/UM10204.pdf
 * Official List of assigned NXP / Philips I2C addresses http://www.diolan.com/downloads/i2c-address-allocation-table.pdf
-* ---
+* Mitchell Kahn: ''[http://ap.urpi.fei.stuba.sk/mmp/doc/prog_i2c.pdf Programming the i2c interface].'' Dr. Dobb's Journal, June 1992.
-* [ht-ps://www.arduino.cc/en/Reference/Wire Wire Library] Reference
+* [http://www.nongnu.org/avr-libc/user-manual/group__twi__demo.html Example using the two-wire interface (TWI)]. AVRlibc demo projects.
-* [https://www.arduino.cc/en/Serial/Print Serial Library - Print] Reference
 === Datasheets ===
 * [http://www.atmel.com/images/doc0180.pdf AT24C02 EEPROM memory]
+* [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/DATASHEET/CD00001163.pdf M24C02 Datasheet]
+[[Obrázok:i2c_M24C02.jpg]] [[Obrázok:i2c_M24C02_pinout.jpg]]
-[[Obrázok:i2c_M24C02.jpg]] [[Obrázok:i2c_M24C02_pinout.jpg]]
 === 1. Schéma zapojenia ===
-[[Súbor:i2c_schematic.png|400px|center]]
+[[Súbor:i2c_schematic.png|400px|center]][[Súbor:i2c_breadboard.png|400px|center]]
-[[Súbor:i2c_breadboard.png|400px|center]]
 Správnosť zapojenia si môžete vyskúšať programom [[Médiá:i2c_scan.ino]] - nájde všetky obvody pripojené na zbernici.
+Nachádza sa aj priamo vo vývojovom prostredí Arduino, pozri Examples -> Wire -> i2c_scan.
 === 2. Device address ===
@@ Riadok 42: / Riadok 45: @@
 [[Súbor:i2c_address.png|400px|center]]
-=== 3. Zápis ===
-[[Súbor:i2c_write.png|600px|center]]
-=== 4. Čítanie ===
-[[Súbor:i2c_read.png|600px|center]]
-[[Súbor:i2c_readRandom.png|400px|center]]
+=== 3. Inicializácia ===
-=== 5. Pomôcka k Serial Print ===
-[[Súbor:TerminalScreenshot01.png|right]]
+Pri tvorbe programu pre modul budeme využívať už hotovú knižnicu <code>i2cmaster</code> dostupnú odtiaľto http://senzor.robotika.sk/mmp/src/i2c/
-<source lang="cpp">
-void setup()
-{
-  byte c = 78;
-  Serial.begin(9600);
+Najprv je potrebné zbernicu inicializovať:
+<source lang="c">
-  Serial.print("Hello, World!");
+         i2c_init();                                       // initialize I2C library
-  Serial.println("Hello, World!");
-  Serial.println(78);
-  Serial.println(c);
-  Serial.println('c');
-  Serial.println(1.23456);
-  Serial.println();
-}
-void loop()
-{
-  Serial.println("Hello, World!");
-}
 </source>
-[[Súbor:TerminalScreenshot02.png|right]]
-<source lang="cpp">
-void setup()
-{
-  byte c = 85;      // c = 'U';
-  Serial.begin(9600);
-  Serial.println(c);
+=== 4. Zápis ===
-  Serial.println(c, BIN);
-  Serial.println(c, DEC);
-  Serial.println(c, HEX);
-  Serial.println((char)c);
-  Serial.println();
-  Serial.println(1.23456, 0);
+Zápis je jednoduchší, preto ním začneme:
-  Serial.println(1.23456, 2);
-  Serial.println(1.23456, 4);
-  Serial.println();
+<source lang="c">
-  Serial.print("Temperature = ");
+       // zapis hodnotu  0x41 ('A') to EEPROM address 00 (Byte Write)
-  Serial.print(c);
-  Serial.print(' ');
-  Serial.write(176);
-  Serial.println("C [OK]");
-}
-void setup()
+     i2c_start_wait( (EEPROM_ADDR << 1) | I2C_WRITE);     // 1: set device address and write mode
-{
+     i2c_write(0x00);                                     // 2: write address = 0
-}
+     i2c_write(0x41);                                     // 3: write value 0x41 to EEPROM
+     i2c_stop();                                          // 4: set stop conditon = release bus
 </source>
-[[MEMS inteligentné senzory a aktuátory#Cvi.C4.8Denia|Návrat na zoznam cvičení...]]
+<div style='text-align: center;'>
+  [[Súbor:i2c_write.png|600px|center]]<br>
-[[Category:MEMS]][[Category:I2C]]
+''Postupnosť pre zápis hodnoty z EEPROM pamäte.''
+</div>
-Prečítajte obsah predloženej pamäti EEPROM a zobrazte na PC.
-[[Obrázok:i2c_M24C02.jpg]]
-'''Literatúra:'''
-* [http://www.st.com/internet/com/TECHNICAL_RESOURCES/TECHNICAL_LITERATURE/DATASHEET/CD00001163.pdf M24C02 Datasheet]
-* Mitchell Kahn: ''[http://ap.urpi.fei.stuba.sk/mmp/doc/prog_i2c.pdf Programming the i2c interface].'' Dr. Dobb's Journal, June 1992.
-* [http://www.nongnu.org/avr-libc/user-manual/group__twi__demo.html Example using the two-wire interface (TWI)]. AVRlibc demo projects.
+=== 5. Čítanie ===
+Čítanie vyžaduje trocha viac krokov, pretože najprv musíme smerom do EEPROM nastaviť adresu, z ktorej chceme čítať a potom obrátime smer komunikácie a počkáme na data z pamäti.
 <source lang="c">
-#include <avr/interrupt.h>
+  /*  Precitame hodnotu zapisanu v predchadzajucom kroku z EEPROM addresy 0   */
-#include <stdlib.h>
-#include <avr/io.h>
-#include <util/delay.h>
-#include <util/twi.h>
-#include <stdio.h>
-//#include "lcd.h"
+     i2c_start_wait( (EEPROM_ADDR << 1) | I2C_WRITE);      // 1: set device address and write mode
-#include "Uart_ch.h"
+     i2c_write(0x00);                                      // 2: write address = 0
-unsigned char RD_EEprom(unsigned char adr_RAM);
+     i2c_rep_start( (EEPROM_ADDR << 1) | I2C_READ );       // 3: set device address and read mode
-void WR_EEprom(unsigned char adr_IC,unsigned char adr_pocitadlo);
-void obsluha_Stav_Aut_I2C(void);
+     val = i2c_readNak();                                  // 4: read one byte from EEPROM
+     i2c_stop();                                           // 5: stop
+</source>
-#define ADR_IC_WR		0xA0   	// EEPROM Adresa IC+WR
+Program je samozrejme vhodné doplniť o zobrazenie prečítanej hodnoty v termináli cez sériové rozhranie.
-#define ADR_IC_RD		0xA1   	// EEPROM Adresa IC+RD
+<div style='text-align: center;'>
+  [[Súbor:i2c_read.png|600px|center]]<br>
+''Postupnosť pre čítanie hodnoty z EEPROM pamäte.''
+</div>
+Jednoduchý program na prečítanie 1 byte z pamäte pre Arduino s využitím knižnice [https://www.arduino.cc/reference/en/libraries/i2c_eeprom/ I2C_EEPROM] je tu:
-volatile  unsigned char	buffer_I2C[10];	// buffer pre obsluhu I2C
+<source lang="c">
+#include <I2C_eeprom.h>
+#define MAXBYTES 2048/8         // it's only 2Kbit
+#define DEVICEADDRESS (0x50)   // the address of your EEPROM
+I2C_eeprom eeprom(DEVICEADDRESS,MAXBYTES);
+byte value;
+byte adresa = 0x00;
-FILE mystdout_Uart = FDEV_SETUP_STREAM(sendchar, NULL, _FDEV_SETUP_WRITE);
+void setup()
+{
+  Serial.begin(9600);
-void WR_EEprom(unsigned char adr_IC,unsigned char adr_pocitadlo)
+  Serial.println("*** Reading memory content: ***");
-{ 	// nastavenie globalnych premennych
+  Wire.begin();
-	buffer_I2C[0]=adr_IC;	// Adr obvodu + wr
+  eeprom.begin();
-	buffer_I2C[1]=adr_pocitadlo;	    // Nastavenie Adresneho citaca 24LC04 , Adresa (z ktorej citam)/(do ktorej zapisujem)
-//	buffer_I2C[1]=<obsah>;			// zapisovane data, byte,-ty
+  value = eeprom.readByte(adresa);
+  Serial.print((char)value);
-	TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN); // send start condition
-	// a odovzdanie riadenia "preruseniu od I2C"
+  Serial.println("\nDone...");
-	obsluha_Stav_Aut_I2C();
 }
+void loop()
+{
-unsigned char RD_EEprom(unsigned char adr_RAM)
+  // Nothing to do during loop
-{
-	// nastavenie globalnych premennych
-	buffer_I2C[0]=ADR_IC_RD;	// Adr obvodu + rd
-	buffer_I2C[1]=adr_RAM;		    // Sem vrati obsah z nastavenej adresy 24LC04
-	TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN); // send start condition
-	// a odovzdanie riadenia "preruseniu od I2C"
-	obsluha_Stav_Aut_I2C();
-	return(buffer_I2C[1]);
 }
-// tato funkcia vyuziva globalne premenne
+</source>
-// buffer_I2C[x]
-// Wr_data - tato premenna nadobuda vyznam az pri komunikacii s konkretnou premennou
-//           vid. "instrukcny subor" I2C periferie
-// implementovany instrukcny subor pre seriovu EEPROM max 256 byte
-// S|adr_IO+wr|<AC>|P                -- nastavenie adresneho citaca pamate EEPROM
-// {nie je implementova} S|adr_IO+wr|<AC>|data|P           -- zapisanie dat na nastavenu adresu pamate EEPROM
-// S|adr_IO+rd|data|P                -- precitanie jedneho bytu z aktualne nastavenej adresy pamate EEPROM
-//                                      obsah adresneho citaca sa inkrementne
-void obsluha_Stav_Aut_I2C(void)
-{ unsigned char pom_St_Aut=0;
-nav:while ((TWCR & _BV(TWINT)) == 0);  /* wait for transmission */
-    {   pom_St_Aut=TWSR & 0xf8;		// precitaj stav
-	    printf(" %02x",pom_St_Aut);
-	 	switch(pom_St_Aut)
-	 	{ case TW_START:// = 0x08 // odvysielany start
-		  case TW_REP_START:// = 0x10 // odvysielany repeated start
-		                 	TWDR = buffer_I2C[0];// Adr+wr/rd, adresa IO
-	  						TWCR = _BV(TWINT) | _BV(TWEN); /* clear interrupt to start transmission */
-		  break;
-		  case TW_MT_SLA_ACK:	//        0x18   Data byte has been tramsmitted and ACK received
-		                 	TWDR = buffer_I2C[1]; // tu konkretne, nastavenie Adreseho citaca pamate.
-	  						TWCR = _BV(TWINT) | _BV(TWEN); /* clear interrupt to start transmission */
-		  break;
-		  case TW_MT_DATA_ACK:	//        0x28   Data byte has been tramsmitted and ACK received
-		   					TWCR = _BV(TWINT) | _BV(TWSTO) | _BV(TWEN); /* send stop condition */
-							return; //  tento riadok v preruseni vypadne
-		  break;
-		  case TW_MR_SLA_ACK:	//   0x40  // Data byte has been tramsmitted and NACK received
-		   					TWCR = _BV(TWINT) | _BV(TWEN) ; // clear interrupt to start transmission
-		  break;
-		  case TW_MR_DATA_NACK:	// 0x58  // Data byte has been tramsmitted and ACK received
-		  				    buffer_I2C[1]= TWDR;	    // Vycitaj jeden byte z  24LC04.  Adresny citac sa posunie
-				      		TWCR = _BV(TWINT) | _BV(TWSTO) | _BV(TWEN); // send stop condition
-							return; // tento riadok v preruseni vypadne
-		  break;
-		  default:
-		  					TWCR = _BV(TWINT) | _BV(TWSTO) | _BV(TWEN); /* send stop condition */
-							return; // tento riadok v preruseni vypadne
-		  break;
-	 	}
-	}
-	goto nav; // toto v preruseni vypadne
-}
-int main(void)
-{ 	unsigned char znak;
-unsigned int i=0;
-unsigned char poc_adresa_EEPROM=0;
-	inituart();								// inicializacia UARTU                       // inicializacia v 4-bitovom rezime
-//  sei();                    // Enable ALL interrupts
-// ini I2C
-{
-   TWCR =  _BV(TWEN); /* send start condition */
-   TWBR = 72; // fi2c= fosc/(16 +2(preddelic=00=> 1)(<TWBR>)) = 100kHz
-   TWSR=1;
-}
-// TODO: to USART
-/* ************************************************************	*/
-stdout = &mystdout_Uart;
-printf("Nastavenie adresy EEPROM = %02x \n\r",poc_adresa_EEPROM);
-WR_EEprom(ADR_IC_WR,poc_adresa_EEPROM);
-printf("\n\r\rVypis EEPROM: \n\r");
-	// vypisme prvych 10 znakov
-    while (i<10) //256)// kapacita pamate 256 znakov, bytov,
-	{
-		znak = RD_EEprom(ADR_IC_RD); // obsah adresneho citaca EEPROM sa automaticky inkrementuje
-		if(znak==0xff)i=256; // vymazane pametove miesto
-		{
-			printf("   %02d %02x %c\r",i++,znak,znak);
-		}
-	}
- for(;;);  // a cakam napr. na  "RESET"
-}
-</source>
-[[Category:DVPS]][[Category:AVR]][[Category:MMP]][[Category:I2C]][[Category:MEMS]]
+[[Category:DVPS]][[Category:AVR]][[Category:MMP]][[Category:I2C]][[Category:MIPS]]