collapse

* Posts Recentes

Problema em Impressora por almamater
[Hoje às 12:18]


Perfi aluminio por senso
[23 de Janeiro de 2020, 14:01]


OPAMPs - configuracoes inversora, nao inversora por jm_araujo
[23 de Janeiro de 2020, 13:42]


Aplicação de IC TP4056 - dissipador por SerraCabo
[22 de Janeiro de 2020, 10:26]


Ajuda atualizar hora NTP Verão/Inverno por vasco
[19 de Janeiro de 2020, 01:31]


Audio - Controlo Volume por SerraCabo
[17 de Janeiro de 2020, 21:20]


Mau condutor por vasco
[14 de Janeiro de 2020, 16:44]


Pequena impressora por jm_araujo
[13 de Janeiro de 2020, 10:34]


Martelo??? por Njay
[13 de Janeiro de 2020, 02:30]


Circuito de proteção para ferro de soldar. por vasco
[11 de Janeiro de 2020, 20:49]

Autor Tópico: Arduino + EEPROM i2c  (Lida 67864 vezes)

0 Membros e 1 Visitante estão a ver este tópico.

Offline TigPT

  • Administrator
  • Mini Robot
  • *****
  • Mensagens: 5.348
    • Tiago Rodrigues
Re:Arduino + EEPROM i2c
« Responder #45 em: 08 de Junho de 2009, 16:19 »
Claro tr3s... estava só a acrescentar ;)

Offline Reonarudo

  • Mini Robot
  • *
  • Mensagens: 114
  • Nano Soldering Master
Re:Arduino + EEPROM i2c
« Responder #46 em: 08 de Junho de 2009, 17:51 »
Hehe
Eu por acaso só tenho um 168 e o resto é 328 por isso não achei que fosse assim tanta ocupação.
Tiago se quiseres ajuda com isso é só dizer...
Leonardo Marques

Offline Njay

  • Mini Robot
  • *
  • Mensagens: 3.437
    • Tróniquices
Re:Arduino + EEPROM i2c
« Responder #47 em: 08 de Junho de 2009, 23:47 »
Até que não é muito dificil fazer uma interface básica com um SD card, especialmente quando já há código feito ;). Em tempo fiz um projecto com um AVR e um SD card, também é um logger, e era suposto logar periodicamente o estado de 8 entradas digitais. Não vou repetir aqui a ladaínha porque já o escrevi noutro fórum:

http://www.electronicapt.com/forum/empty-t2201.0.html

O programa todo (interface SD card + o resto) ocupa menos de 2KB.

Offline naf18

  • Mini Robot
  • *
  • Mensagens: 48
Re: Arduino + EEPROM i2c
« Responder #48 em: 27 de Março de 2010, 21:12 »
ola alguem me pode dar uma ajuda no i2c?
Estou a tentar ligar o arduino a um sensor da freescale e esta a dar um erro: o arduino fica bloqueado. o codigo que tenho é o seguinte:

Citar
#include <Wire.h>

#define Slave_adress (0x4D)

void setup()
{
   Serial.begin(9600);      // open the serial port at 9600 bps:   
   Wire.begin();   // start Wire library as I2C-Bus Master
}
void loop()
{
 Serial.println("vai escrever");
 Write_I2C(0x03, 0x11);
 Serial.println("escreveu");
}

void Write_I2C(int command, int data) {
  //  Send config register address
  Wire.beginTransmission((int)(Slave_adress));
  Wire.send((int)(command));
  Wire.send((int)(data));
  Wire.endTransmission();
}

Já fiz vários testes e verifiquei que ele blaqueia quando vai executar a linha wire.endTransmisson();

Se alguém souber como ajudar agradecia.

Offline dio123

  • Mini Robot
  • *
  • Mensagens: 946
Re: Arduino + EEPROM i2c
« Responder #49 em: 07 de Julho de 2012, 13:45 »
Bom dia,

Qual é a diferença entre usar #include <Wire.h>  ou a #include <eeprom.h>             

Para exprimentar umas eeproms que tinha aqui em casa usei o eeprom.h e funcionou bem, mas depois de uma pesquisa na net vejo que há muita pessoas a usar wire.h

Offline senso

  • Global Moderator
  • Mini Robot
  • *****
  • Mensagens: 9.637
  • Helpdesk do sitio
Re: Arduino + EEPROM i2c
« Responder #50 em: 07 de Julho de 2012, 14:12 »
Wire.h é a biblioteca para usar I2C, eeprom.h deve ter meia duzia de funções para ler as eeproms sem andar com o baixo nivel do i2c, mas a eeprom tem de incluir a biblioteca i2c se não, não funciona.
Avr fanboy

Offline dio123

  • Mini Robot
  • *
  • Mensagens: 946
Re: Arduino + EEPROM i2c
« Responder #51 em: 07 de Julho de 2012, 16:20 »
usei o exemplo daqui deste tópico.   E aparece assim:  33, FF, FF, FF, FF, FF, FF, FF, FF, FF,
Exprimentei um novo e acontece a mesma coisa.
Exprimentei um velho que tenho aqui e aparece 33, 22, 42, 65, 21, 77, 47,48,49, 11,

E depois exprimentei todos mas com resistencias 4k7 ligadas ao pinos 4 e 5 e 5v e acontece a mesma coisa.
Verifiquei os fios novamente, e está tudo correcto.

Offline senso

  • Global Moderator
  • Mini Robot
  • *****
  • Mensagens: 9.637
  • Helpdesk do sitio
Re: Arduino + EEPROM i2c
« Responder #52 em: 07 de Julho de 2012, 16:55 »
Então, mas o velho o mais certo é teres já metido para lá dados e o novo ainda está por meter lá dados dentro, uma eeprom "formatada" está cheia de FF's.
Avr fanboy

Offline dio123

  • Mini Robot
  • *
  • Mensagens: 946
Re: Arduino + EEPROM i2c
« Responder #53 em: 07 de Julho de 2012, 17:37 »
Mas o codigo que está no primeiro 1ºpost não devia preecher as 10 primeiras posições com 33. e depois devia aparece
33,33,33,33,33,33,33,33,33,33

é que a mim só preeche a 1º posição. Coloquei resistencias 4k7 e 10k nos pinos 4e 5  nao resolveu o problema

Offline iyahdub

  • Mini Robot
  • *
  • Mensagens: 280
Re: Arduino + EEPROM i2c
« Responder #54 em: 31 de Julho de 2012, 16:02 »
Parece mais que gravaste os 3 em ASCII so uma vez, e o resto nao deve ter recebido nada ja que esta ao maximo dos 256 ...Vazia ?!

usei o exemplo daqui deste tópico.   E aparece assim:  33, FF, FF, FF, FF, FF, FF, FF, FF, FF,
Exprimentei um novo e acontece a mesma coisa.
Exprimentei um velho que tenho aqui e aparece 33, 22, 42, 65, 21, 77, 47,48,49, 11,

E depois exprimentei todos mas com resistencias 4k7 ligadas ao pinos 4 e 5 e 5v e acontece a mesma coisa.
Verifiquei os fios novamente, e está tudo correcto.
ps-Desculpen a falta de pontuacao, mas vivo no estrangeiro e os teclados sao xenofobos !!

Offline dio123

  • Mini Robot
  • *
  • Mensagens: 946
Re: Arduino + EEPROM i2c
« Responder #55 em: 31 de Julho de 2012, 20:21 »
eu usei o codigo que está no 1º post do tutorial.

Offline rglove

  • Mini Robot
  • *
  • Mensagens: 527
Re: Arduino + EEPROM i2c
« Responder #56 em: 23 de Agosto de 2012, 15:55 »
Boas, estive a ler este tutorial com mais atenção e acho que percebi quase tudo, mas há uma coisa que não percebi no código. Pela datasheet vê-se que se tem de enviar o MSB seguido do LSB, o que não percebo é o significado das 2 "expressões" que convertem o endereço para MSB e LSB. Alguém me explica sff?

Código: [Seleccione]
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;
}

Cumprimentos

Offline senso

  • Global Moderator
  • Mini Robot
  • *****
  • Mensagens: 9.637
  • Helpdesk do sitio
Re: Arduino + EEPROM i2c
« Responder #57 em: 23 de Agosto de 2012, 22:18 »
O valor do endereço está guardado numa variavel de 16 bits, vamos supor arbitráriamente que o seu valor é de 0xABCD em hexadecimal.
A primeira operação:
Código: [Seleccione]
Wire.send((int)(eeaddress >> 8));   // MSBFica: 0xABCD >> 8 que dá 0xAB, pois é um shift right á direita de 8 bits, e como tal, os bits que representavam 0xCD foram mandados para fora da variavel e fica só 0xAB.

A segunda operação:
Código: [Seleccione]
Wire.send((int)(eeaddress & 0xFF)); // LSBFica 0xABCD & 0x00FF, o valor 0xFF é extendido a 16 bits, e como os 8 bits mais significantes não está definidos, são definidos como 0's, o & é o operador lógico AND, e qualquer coisa AND 0 dá sempre zero(é tipo como multiplicar por zero), e assim o valor fica 0xCD.

Assim o valor de 16 bits foi partido em dois valores de 8 bits, para serem enviados por i2c/twi que é um interface que opera ao nivel do byte, ou seja só podes enviar 1 byte em cada transação de dados efectuada.
Avr fanboy

Offline rglove

  • Mini Robot
  • *
  • Mensagens: 527
Re: Arduino + EEPROM i2c
« Responder #58 em: 23 de Agosto de 2012, 23:02 »
Percebi perfeitamente, obrigado  ;)

Offline miragempro

  • Mini Robot
  • *
  • Mensagens: 2
Re: Arduino + EEPROM i2c
« Responder #59 em: 09 de Setembro de 2012, 00:28 »
BOM NOITE AMIGO DE PORTUGAL, SOU O EDUARDO DO BRASIL/SP

BEM... sou estudante iniciante em programação,  e estou estudando arduino, mas eu tenho um projeto em que preciso fazer um porteiro eletronico.

Pensei em faze-lo em wi-fi, mas como automatizar a frequencia para que não preciso busca-la sempre?  sabes alguma coisa a respeito?

Obrigado

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! :D "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: