ASM51

Bom dia, colegas.

Desenvolvi um codigo para comunicação do pic com uma memória I2C (24C02) no mikroC. Creio que esta gravando correto na memória, só que quando vai ler a memória da vez de ler as letras (A – B - C – D – E – F – G – H – I – J – K – L – M – N – O – P). Lê duas vezes a seguinte seqüência: (I – J – K – L – M – N – O – P).

Será que algum dos colegas poderia me ajudar neste codigo


void main(){

PORTB = 0;
TRISB = 0;
PORTB = 255;
delay_ms(1000);
PORTB = 0;
USART_Init(19200);
I2C_Init(100000);

delay_ms(1000);
I2C_Start(); // issue I2C start signal
I2C_Wr(0xA0); // send byte via I2C (command to 24cO2)
I2C_Wr(0);
I2C_Wr(65); // send byte (address of EEPROM location)
I2C_Wr(66); // send byte (address of EEPROM location)
I2C_Wr(67); // send byte (address of EEPROM location)
I2C_Wr(68); // send byte (address of EEPROM location)
I2C_Wr(69); // send byte (address of EEPROM location)
I2C_Wr(70); // send byte (address of EEPROM location)
I2C_Wr(71); // send byte (address of EEPROM location)
I2C_Wr(72); // send byte (address of EEPROM location)
I2C_Wr(73); // send byte (address of EEPROM location)
I2C_Wr(74); // send byte (address of EEPROM location)
I2C_Wr(75); // send byte (address of EEPROM location)
I2C_Wr(76); // send byte (address of EEPROM location)
I2C_Wr(77); // send byte (address of EEPROM location)
I2C_Wr(78); // send byte (address of EEPROM location)
I2C_Wr(79); // send byte (address of EEPROM location)
I2C_Wr(80); // send byte (address of EEPROM location)
I2C_Stop();

Delay_ms(2000);
I2C_Start(); // issue I2C start signal
I2C_Wr(0xA0); // send byte via I2C (device address + W)
I2C_Wr(0); // send byte (data address)
I2C_Repeated_Start(); // issue I2C signal repeated start
I2C_Wr(0xA1); // send byte (device address + R)
USART_Write(I2C_Rd(1));
USART_Write(I2C_Rd(2));
USART_Write(I2C_Rd(3));
USART_Write(I2C_Rd(4));
USART_Write(I2C_Rd(5));
USART_Write(I2C_Rd(6));
USART_Write(I2C_Rd(7));
USART_Write(I2C_Rd(8));
USART_Write(I2C_Rd(9));
USART_Write(I2C_Rd(10));
USART_Write(I2C_Rd(11));
USART_Write(I2C_Rd(12));
USART_Write(I2C_Rd(13));
USART_Write(I2C_Rd(14));
USART_Write(I2C_Rd(15));
USART_Write(I2C_Rd(16));
I2C_Rd(0);
I2C_Stop();

}

Sds
Vanderley

Você está recebendo isto em algum terminal?
Curioso que recebe os 8 últimos caracteres.
Seu terminal tem algum set para ecoar os dados recebidos ou algo desse tipo?
Se for terminal, a velocidade está correta, nas duas pontas?

RobL escreveu:Você está recebendo isto em algum terminal?
Curioso que recebe os 8 últimos caracteres.
Seu terminal tem algum set para ecoar os dados recebidos ou algo desse tipo?
Se for terminal, a velocidade está correta, nas duas pontas?

Boa tarde.
Tanto utilizando o hiper terminal do windows, como o que acompanha o mikroC apresenta esta informação. A velocidade dos dois esta igual e a configuração é a padrão.

Sds
Vanderley

Por que vc esta colocando estes numeros dentro da função I2C_Rd()?

Código: Selecionar todos

USART_Write(I2C_Rd(1));
USART_Write(I2C_Rd(2));
USART_Write(I2C_Rd(3));


seria bom verificar se retorna zero tambem quando vc esta gravando

Sergio

Sergio38br escreveu:Por que vc esta colocando estes numeros dentro da função I2C_Rd()?

Código: Selecionar todos

USART_Write(I2C_Rd(1));
USART_Write(I2C_Rd(2));
USART_Write(I2C_Rd(3));


seria bom verificar se retorna zero tambem quando vc esta gravando

Sergio

Boa tarde, Sérgio.

Pelo que eu li e entendi seria o endereçamento do ponteiro da memória. Caso eu queira ler por exemplo da posição de memória 5 em diante, basta fazer esta referencia e pronto, no exemplo acima quis ler a partir da posição 1.

Sds
Vanderley

qual o fabricante da memoria que vc esta usando??? o buffer de escrita pode variar conforme o fabricante.

Sergio

qual tua versão, na que tenho a descrição do comando é diferente veja:
"
I2C_Rd
Prototype unsigned short I2C_Rd(unsigned short ack);

Returns Returns one byte from the slave.

Description Reads one byte from the slave, and sends not acknowledge signal if parameter ack is 0, otherwise it sends acknowledge.

"
Apenas perguntei por que vc define o endereço inicial de leitura depois o restart e por fim o comando de leitura ai é só chamar a função de leitura mandar um ack para ser incrementado internamente o end. e qdo for o ultimo mande com um "0" de ack.

Sergio

Este problema é devido a paginação na EEPROM.

Sua memória so aceita a gravação de até 8 bytes por vez, mais do que isso deverá reenviar o novo endereço senão acontece o efeito de roll-over.

Care must be taken to avoid address
counter ’roll-over’ which could result in data
being overwritten

Outro detalhe é que após um comando de escrita, seja ele 1 byte ou o tamanho da página, você deve aguardar o tempo de escrita interno da memória para enviar um novo comando. Normalmente este tempo é de 10ms. consulte o D.S.
O Ideal é fazer pooling de busy antes de cada comando.


A leitura não é problema, pode ler ela inteira.

Então entre a escrita do H e I, coloque:

Código: Selecionar todos

.....
I2C_Wr('H');
I2C_Start(); // issue I2C start signal
I2C_Wr(0xA0); // send byte via I2C (command to 24cO2)
I2C_Wr(8);
I2C_Wr('I');
.....

Sei que é chato e nem sempre faço, mas ler o Data Sheet faz bem.

Perfeito Barboza, notei a repetição dos 8 bytes (8 caracteres) mas não me veio isso à cabeça. Bom refresh para minha cabeça, valeu.

Muito obrigado, Barbosa.
Vou fazer o teste sugerido.

Mas agora me surgiu uma outra duvida. Estou com a intenção de desenvolver um datalogger que vai armazenar aproximadamente 1 Mbits (125kB) num intervalo de 1 segundo. Você comenta que a cada mudança de página tenho que esperar 10 ms.

Mas como conseguirei processar este volume de dados, se terei um delay tão grande?

Ou existe um outro processo. Me desculpe minha ignorancia, pois estou a pouco tempo trabalhando com micro controladores e comecei agora com memorias.

Sds
Vanderley

Considerando este volume de dados, o ideal seria uma memória flash SPI que são mais velozes, ou até mesmo paralela, se tiver pinagem pra isso claro.

Mas pensando em EEPROM I2C, teremos:

125Kbyte;

2 x 24C512;

Cada pagina dela tem 128 bytes, então temos 512 em cada.

1024 * 10ms = 10,24 segundos.

Complicou.

Mesmo que você faça pooling antes de cada envio, ao invês de esperar os 10ms, você não irá conseguir esse volume de dados com 1s. Isso sem contar o tempo de envio dos dados para ela.

Outro detalhe importante neste caso, é o tempo de vida delas, que no D.S. diz sobre 100K escritas.

Se você fizer uma por segundo, serão 100.000 segundos, pouco mais de 1 dia.

Acho melhor você pensar em uma memória própria para Datalog, estude as Flash SPI, SD card......