Arduino + EEPROM i2c

[tr3s]

Hi,

E que tal falar sobre EEPROMs?

Ora bem, quase todos devem saber o que são e o jeitão que dão quando começamos a ficar sem espaço no nosso microcontrolador e temos a necessidade migrar dados, ou então quando queremos fazer muitos registos e os míseros bytes de memória que o nosso micro tem não são suficientes.

Datasheet: http://www.sparkfun.com/datasheets/IC/24LC256.pdf
Sparkfun: http://www.sparkfun.com/commerce/product_info.php?products_id=525

Pois bem as EEPROMs são mesmo nossas amigas e então as i2c são tão fáceis de implementar que ao fim de algum tempo nem nos lembramos que as temos na breadboard. Estas ocupam apenas os pinos 4 e 5 analógicos do Arduino, ocupando um endereço no BUS, ou seja, podemos continuar com todos os outros dispositivos i2c que lá tinhamos ligados anteriormente.

A eeprom que vou usar neste tutorial é uma 24lc256 da Microchip. Esta eeprom tem 32K endereços a 8 bits  fazendo dela uma eeprom com 256 Kbits memória. OH yeah!
Eu gosto de comparar esta capacidade de armazenamento com quanto precisaria para guardar um bitmap a fullscreen para o meu LCD da Nokia com o controlador OM6206. Ora bem um bitmap ocupa 864 bytes, se tenho 32k bytes, quer dizer 0x7FFF bytes disponíveis na eeprom isto dá...  37,9 imagens! "Ya é bué" memória.
A Atmel, assim como outras marcas, também têm estas eeproms. Na Atmel é 24C256, mas as da Microchip são bem melhores! As da Microchip aguentam os dados por mais de 200 anos, na Atmel é só 40; As da Microchip dão para mais de um milhão de ciclos escrita, as da Atmel só dão para 100 mil. A Microchip dá 3 pinos para endereço, a Atmel só dá dois. Bom e continua...

As ligações são estas:



Os pinos A0 a A2 servem para indicar o endereço da eeprom no bus i2c, se estiverem todos ligados a GND o endereço no Arduino é 0x50. Assim, conseguimos ter até 8 eeproms no mesmo bus fazendo 2Mbit de memória!
O pino WP é o pino que indica se a eeprom está protegida contra escita, se ligarem este pino a vcc não podem escrever na eeprom e se o ligarem a GND já podem, é como o botão nos cartões de memória.

Depois de ligarem isto tudo vamos lá testar tudo! Para o teste ligem o WP a GND.

Código: [Seleccione]

#include <Wire.h>         // Para a EEPROM 24LC256, assim chamamos as bibliotecas i2c
#define eeprom 0x50    // endereço da eeprom já shiftado

void setup(void){
  Wire.begin();           // Iniciar ligações i2c
  Serial.begin(9600); // Assim podemos ver qualquer coisa na consola serial

  unsigned int address = 0;  //endereçamento a 2 bytes
  Serial.println("A escrever o melhor numero de sempre nos 10 primeiros bytes!");
  for(address = 0; address<10; address++) writeEEPROM(eeprom, address, '3');   // Va pub a mim! Encher os 10 primeiros bytes com o número 3
  Serial.println("Vamos ler se esta tudo ok, deves ver 33, 33, 33, 33... Vá 10x 33");

  for(address = 0; address<10; address++) {
     Serial.print(readEEPROM(eeprom, address), HEX);
     Serial.print(", ");
  }
}

void loop(){
}

//-------Rotinas para EEPROMS i2c por Daniel Gonçalves a.k.a. Tr3s------
// Podem usar estas rotinas à vontade para projectos particulares.
// Para fins comerciais entrar em contacto com we_real_cool@hotmail.com
// Partilhem com apenas com o meu concentimento.
// Se virem este código noutro sitio sem ser [url=http://www.lusorobotica.com]www.lusorobotica.com[/url] avisem de imediato para we_real_cool@hotmail.com!

void writeEEPROM(int deviceaddress, unsigned int eeaddress, byte data ) {
  Wire.beginTransmission(deviceaddress);
  Wire.send((int)(eeaddress >> 8));   // MSB
  Wire.send((int)(eeaddress & 0xFF)); // LSB
  Wire.send(data);
  Wire.endTransmission();
}

byte readEEPROM(int deviceaddress, unsigned int eeaddress ) {
  byte rdata = 0xFF;
  Wire.beginTransmission(deviceaddress);
  Wire.send((int)(eeaddress >> 8));   // MSB
  Wire.send((int)(eeaddress & 0xFF)); // LSB
  Wire.endTransmission();
  Wire.requestFrom(deviceaddress,1);
  if (Wire.available()) rdata = Wire.receive();
  return rdata;
}

// Por Daniel Gonçalves a.k.a. (t.c.p.) Tr3s, para [url=http://www.lusorobotica.com]www.lusorobotica.com[/url]

Bom e acho que é tudo... Alguma coisa é só dizer.

Vejam também o post onde ensino a brincar com a eeprom duma maneira mais gira!
http://lusorobotica.com/index.php/topic,460.msg2733.html (use Arduino to program eeprom)

NOTA: Não se esqueçam das resistências de pullup do bus I2C, para mais informação sobre o protocolo I2C visitem o link:
http://lusorobotica.com/index.php/topic,33.0.html

Exemplo de uma imagem lida de uma eeprom por um arduino e escrita num lcd nokia:

[TigPT]

Muito interessante, adicionado como artigo

[Fifas]

oh yeah!!!

muito obrigado tr3s!!!! por acaso tenho aqui uma eprom da microchip...so nao sei qual é nunca a usei muito por isso nao sei bem o potencial disto...

vou por um exemplo de uma coisita que tou a fazer...imagina que o arduino recebe um determinado dado por serie e eu quero que ele escreva esse dado num lcd (por exemplo do 3310) mas em forma de grafico.....se programar a eprom  para os dados do grafico fico com mais espaço livre no arduino, certo?


ps: acho que foi desta que queimei o meu arduino

[tr3s]

oh yeah!!!

muito obrigado tr3s!!!! por acaso tenho aqui uma eprom da microchip...so nao sei qual é nunca a usei muito por isso nao sei bem o potencial disto...

vou por um exemplo de uma coisita que tou a fazer...imagina que o arduino recebe um determinado dado por serie e eu quero que ele escreva esse dado num lcd (por exemplo do 3310) mas em forma de grafico.....se programar a eprom  para os dados do grafico fico com mais espaço livre no arduino, certo?


ps: acho que foi desta que queimei o meu arduino

Queimaste porquê? :S

Sim ficas, eu estuo a supor que tens um determinado sensor e estás a registar dados de x em x tempo. Sim se os guardares para a eeprom em vez de os guardares numa zona reservada para isso no Arduino (Atmega168), ficas sem dúvida com mais espaço no Arduino. Imagina que queres guardar 5000 medições, imagina de temperatura, supondo que não passas dos 255 ºC , cada medição ocupa um byte, ou seja, no Arduino tinhas de reservar 5000 bytes. Isso é demais para ele, fica logo marado (embora teoricamente pudesse guardar isso). 5000 bytes na eeprom não são nada e facilmente guardas lá 32000 medições. Sem preocupações. Como dou o exemplo de medições posso dar o exemplo de pontos (GPS), caracteres, imagens duma webcam, etc. ...
Portanto, sim, pouparias imensa memória e preocupações, já que, uma vez lá guardados só se escreveres por cima é que os perdes!

[metRo_]

Bastante interessante
 Só não percebi muito bem esta parte "Os pinos A0 a A2 servem para indicar o endereço da eeprom no bus i2c, se estiverem todos ligados a GND o endereço no Arduino é 0x50. Assim, conseguimos ter até 8 eeproms no mesmo bus fazendo 2Mbit de memória!" A verdade é que ainda não estive a ver muito bem a comunicação I2C, se calhar é por isso.

[tr3s]

Bastante interessante
 Só não percebi muito bem esta parte "Os pinos A0 a A2 servem para indicar o endereço da eeprom no bus i2c, se estiverem todos ligados a GND o endereço no Arduino é 0x50. Assim, conseguimos ter até 8 eeproms no mesmo bus fazendo 2Mbit de memória!" A verdade é que ainda não estive a ver muito bem a comunicação I2C, se calhar é por isso.

Vamos então analisar a imagem de cima:

Primeiro ignora o primeiro bit (Start Bit) e o último (Acknowledge Bit) uma vez que são bits da comunicação e não fazem parte do endereçamento que queremos estudar. Ficamos com:

| 1 | 0 | 1 | 0 | A2 | A1 | A0 | R/~W |

Supondo que temos os pinos A2, A1 e A0 ligados a GND ficamos com:

| 1 | 0 | 1 | 0 | 0 | 0 | 0 | R/~W |
Isto em hexadecimal é  0xA0 ou 0xA1 consoanto o valor de R/~W

Como a biblioteca serial do Arduino "empurra" tudo para a esquerda quando faz comunicação i2c, temos de garantir que quando vem tudo para a esquerda ficamos com os valores correctos, então "empurramos" tudo para a direita antes! Perdemos R/~W (que no fundo não nos interessa porque o pino actua de qualquer maneira)

->| 0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 |
                           A2  A1  A0
e assim temos 0x50 em hexadecimal.

Bom este exemplo é com os pinos a 0, isto é ligados a GND. Como tens 3 pinos, tens 3 bits de combinações, ou seja ligando estes 3 pinos a VCC ou GND consegues fazer 8 endereços diferentes, são eles:
                           A2  A1  A0
| 0 | 1 | 0 | 1 | 0 | 0 | 0 | 0 | = 0x50
| 0 | 1 | 0 | 1 | 0 | 0 | 0 | 1 | = 0x51
| 0 | 1 | 0 | 1 | 0 | 0 | 1 | 0 | = 0x52
| 0 | 1 | 0 | 1 | 0 | 0 | 1 | 1 | = 0x53
| 0 | 1 | 0 | 1 | 0 | 1 | 0 | 0 | = 0x54
| 0 | 1 | 0 | 1 | 0 | 1 | 0 | 1 | = 0x55
| 0 | 1 | 0 | 1 | 0 | 1 | 1 | 0 | = 0x56
| 0 | 1 | 0 | 1 | 0 | 1 | 1 | 1 | = 0x57


Agora, imagina que tens 3 eeproms na breadboard e queres so com 2 fios controlá-las todas. Dando diferentes valores nestes pinos consegues fazer que que as 3 tenham diferentes endereços. Assim consegues aceder independentemente a cada uma!

Aconcelho-te, de qualquer maneira, a ler mais sobre o protocolo i2c


Espero que tenhas percebido

[metRo_]

Percebi perfeitamente, a explicação foi bastante boa Obrigado

[TigPT]

Muito bem explicado.

Tens aqui um artigo meu sobre I2C que te pode ajudar a perceber melhor o protocolo, contudo consulta o manual da Philips

[metRo_]

Só para concluir então, quando se utilizam sensores ou outros componentes que comuniquem utilizando I2C convem que tenham 3 bits para indicar o endereço, certo?

[Fifas]

o tr3s vai dar professor

boa explicaçao

[TigPT]

Nem todos os sensores têm, alguns vêm só com um endereço, mas podemos jogar com os outros que são de endereços configuráveis para evitar que os endereços fiquem sobrepostos.

Nunca tentei meter dois sensores de mesmo endereço no mesmo bus para ver qual o resultado, mas certamente informação incorrecta no bus para não dizer que até pode danificar algum. (acho que não danifica mas quando tiver dinheiro para gastar em sensores que se possam danificar faço um tutorial e posto )

[TigPT]

Adicionado datasheet e página do produto na sparkfun

[metRo_]

Essa eeprom só tem 256k se não estiveres mais nada a utilizar o I2C do arduino, correcto?

[TigPT]

Não interessa se tens mais coisas a utiliar i2c no arduino, sim ela tem essa capacidade interna que podes utiliza-la com qualquer microcontrolador. Essa é a quantidade de bytes que ela pode armazenar no seu interior, o arduino pode ter muitas ou poucas coisas ligadas que não vai interferir com a estrutura física da eeprom, logo não altera o seu tamanho.

[metRo_]

Então não percebo isto "Esta eeprom tem 32K endereços a 8 bits  fazendo dela uma eeprom com 256 Kbits memória." 

Eu pensei que fosse, em cada endereço da eeprom, aqueles a0 a1 a2, tivesse 32k