Ajuda i2c em pic16f628a

Micael77 · 8 de janeiro de 2010

ola novamente

eu estou com m pequeno problema

eu estou usando o pic citado no tiulo do topico e preciso fazer ele comicar com uma eeprom por i2c

mas o mesmo nao possui suporte a isso

mas pelo que me disseram da pra fazer com algumas linhas a mais de codigo

eu então fiz uma miniboblioeca com essas funcoes

mas alguma coisa deu errada e ele nao esta comunicando com a memoria

alguem pode me ajudar??

aqui esta a biblioteca que eu fiz

#define SCL PIN_B3
#define SDA PIN_B4

void i2cWrite(int8 cmd)
{
   int8 i;
   int8 send;
   short ack;
   send = cmd;
   do
   {
      for(i=0;i<=7;++i)
      {
         output_bit(SDA, shift_right(&send,1,0) );
         output_high(SCL);
         output_low(SCL);
      }
      output_high(SCL);
      ack = input(SDA);
      output_low(SCL);
   }while (ack == 0);
}

int8 i2cRead(short cmd)
{
   int8 i,data;

   for(i=0;i<=7;++i) {
      shift_right(&data,1,input(SDA));
      output_high(SCL);
      delay_us(2);
      output_low(SCL);
      delay_us(2);
   }
   i2cWrite(cmd);
   return(data);
}

void i2cStart()
{
   output_high(SCL);
   output_low(SDA);
   output_low(SCL);
}

void i2cStop()
{
   output_low(SDA);
   output_high(SCL);
   output_high(SDA);
   output_float(SCL);
   output_float(SDA);
}

Obrigado

vtrx · 8 de janeiro de 2010

Como voce está chamando a eeprom?Digo,voce conhece o protocolo I2C?

Tem que seguir uma ordem para ler/escrever.

Felipe Electronic · 8 de janeiro de 2010

Amigo vtrx, veja se concorda com minha análise, parece que nosso amigo declarou as funções e seu funcionamento, mas não esta chamando elas, dentro de um void main(), desse modo acho que não haverá comunicação mesmo...

Amigo Micael, faça dentro do void main que é obrigatório , a chamada das funções na ordem do protocolo I2C que creio que ira pelo menos acontecer algo.

abs.

Micael77 · 8 de janeiro de 2010

eu sei disso

eu postei apenas as funções da parte da comunicacao

elas estão sendo chamadas dentro de um vaid main

mas o que eu gostaria de saber é se elas estão corretas

e se quando eu as chamar vai haver comunicacao

do modo que eu as escrevi

mas agora já fiz um teste e ele não comunicou

o que pode estar errado?

Felipe Electronic · 8 de janeiro de 2010

Poste o void main().

abs.

vtrx · 8 de janeiro de 2010

Não programo µcontroladores em C,mas acho que posso ajudar.

Qual a memória esta usando?

Como esta procedendo para ler ou gravar um endereço?

Analisando o código acima,lembrando que não programo em C,me parece que faltam algumas rotinas.

Vamos por exemplo usar a EEPROM 24C65.

Para ler esta EEPROM,voce tem que:

1-Definir Byte de controle no modo escrita(B'10100000').

2-Definir a parte alta do endereço a ler.

3-Definir a parte baixa do endereço a ler.

4-Definir Byte de controle no modo leitura(B'10100001').

Felipe Electronic · 8 de janeiro de 2010

Vtrx,

ele falou que fez o void main com o processo de leitura, ele falou que vai postar, creio que dali encontraremos o que acontece.

abs.

maskador · 9 de janeiro de 2010

Ja fiz isso uma vez, você quer fazer 2 pinos de I/O simularem o que um hardware dedicado para comunicacao I2C faz.

Eu usei um 18f4550, eu sei q ele tem hardware dedicado para i2c, mas fiz esse codigo para finalidade de aprendizado mesmo, e funcionou bem comunicando em um barramento com uma eeprom e um sensor de temperatura da microchip com interface i2c.

Basta você editar os defines abaixo conforme os enderecos dos registradores para o seu PIC (628A) e sair usando as funcoes. Mas nao basta apenas ter enter este codigo, você deve saber como se faz uma escrita e uma leitura em um dispositivo i2c, é so olhar no datasheet


//DEFINES
#BIT I2C_SDA=0x0F82.0               //0x0F82.0 = PORTC.0 = I2C Data Line (SDA)  
#BIT I2C_SCL=0x0F82.1               //0x0F82.1 = PORTC.1 = I2C Clock Line (SCL)
#BIT I2C_SDA_DIRECTION=0x0F94.0     //0x0F94.0 = TRISC.0 = Configura o SDA como I/O 
#BIT I2C_SCL_DIRECTION=0x0F94.1     //0x0F94.1 = TRISC.1 = Configura o SCL como I/O



//***************************************************************************************************************
//***************************************************************************************************************
//***************************************************************************************************************
//I2C Driver (Only for Single Master I2C Bus) 
//***************************************************************************************************************
//***************************************************************************************************************
//***************************************************************************************************************



//----------------------------FUNCAO i2c_start_bit();---------------------------
//
//Gera uma condicao de start bit no barramento I2C, ou seja, gera 
//uma borda de descida em SDA estando SCL em nivel '1'.
//
//------------------------------------------------------------------------------



//--------------------------FUNCAO i2c_restart_bit();---------------------------
//
//Gera uma condicao de restart bit (ou re-start) no barramento I2C
//
//------------------------------------------------------------------------------



//----------------------------FUNCAO i2c_stop_bit();----------------------------
//
//Gera uma condicao de stop bit no barramento I2C, ou seja, gera uma borda de 
//subida em SDA estando SCL em nivel '1'.
//
//------------------------------------------------------------------------------



//---------------FUNCAO i2c_data_write(int8 i2c_data_w, int1 rw);---------------
//
//Escreve um byte no barramento I2C. O byte a ser escrito deve ser inserido no 
//campo i2c_data_w. rw indica se a proxima instrucao será de leitura o escrita 
//no barramento I2C.
//
//O exemplo abaixo mostra um caso onde rw=0: (rw = 0 significa que a proxima instrucao será de escrita)
//i2c_start_bit();  
//i2c_data_write(0xA0,0);  
//i2c_data_write(0x0A,0);  
//i2c_data_write(0x0A,0);      
//i2c_data_write(0x24,0);
//i2c_stop_bit();
//
//O exemplo abaixo mostra um caso onde rw=1:
//i2c_start_bit();  
//i2c_data_write(0xA0,0);  
//i2c_data_write(0x0A,0);  
//i2c_data_write(0x0A,0);  
//i2c_restart_bit();      
//i2c_data_write(0xA1,1); (rw = 1 significa que a proxima instrucao será de escrita)
//dado=i2c_data_read(1);
//i2c_stop_bit();
//
//rw = 1 se a proxima instrucao sera para leitura de um byte no barramento I2C.
//rw = 0 se a proxima instrucao sera para escrita de um byte no barramento I2C.
//
//IMPORTANTE: rw = 0 antes de StopBits e ReStartBits 
//IMPORTANTE: rw = 1 somente se a proxima instrucao for de leitura no barramento I2C 
//
//Esta funcao de escrita também pode ser utilizada da seguinte forma:
//i2c_data_write(0x24,NEXT_DATA_WILL_BE_WRITE);
//i2c_data_write(0x24,NEXT_DATA_WILL_BE_READ);
//i2c_data_write(0x24,NEXT_DATA_WILL_BE_STOP);
//i2c_data_write(0x24,NEXT_DATA_WILL_BE_RESTART);
//
//EXEMPLO DO QUE FOI CITADO ACIMA:
//i2c_start_bit();  
//i2c_data_write(0xA0,NEXT_DATA_WILL_BE_WRITE);  
//i2c_data_write(0x0A,NEXT_DATA_WILL_BE_WRITE);  
//i2c_data_write(0x0A,NEXT_DATA_WILL_BE_RESTART);  
//i2c_restart_bit();      
//i2c_data_write(0xA1,NEXT_DATA_WILL_BE_READ);
//dado=i2c_data_read(NOACK);
//i2c_stop_bit();
//
//------------------------------------------------------------------------------




//----------------------FUNCAO i2c_data_read(int1 ack);---------------------
//
//Le um byte no barramento I2C.
//
//ack determina se o mestre deve gerar um bit de ACK ou NOACK após receber  
//um byte do escravo.
//
//Se ack = 1, o mestre responde com NOACK apos receber um byte de um escravo, 
//o que é feito colocando a linha SDA em '1' durante o tempo do nono bit)
//
//Se ack = 0, o mestre responde com ACK apos receber um byte de um escravo,
//o que é feito colocando a linha SDA em '0' durante o tempo do nono bit)
//
//EXEMPLOS;
//dado=i2c_data_read(0); - le um byte do escravo e responde com ACK
//dado=i2c_data_read(1); - le um byte do escravo e responde com NOACK
//dado=i2c_data_read(ACK); - le um byte do escravo e responde com ACK
//dado=i2c_data_read(NOACK); - le um byte do escravo e responde com NOACK
//
//------------------------------------------------------------------------------




//***************************************************************************************************************
//Adicionar na inicializacao
//***************************************************************************************************************
   //i2c_init();
   //Nao esquecer dos resistores de pull-up (~4.7K omhs ou calculá-los caso necessário) nas linhas SCL e SDA
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////   




//***************************************************************************************************************
//DEFINES
//***************************************************************************************************************
#BIT I2C_SDA=0x0F82.0               //0x0F82.0 = PORTC.0 = I2C Data Line (SDA)  
#BIT I2C_SCL=0x0F82.1               //0x0F82.1 = PORTC.1 = I2C Clock Line (SCL)
#BIT I2C_SDA_DIRECTION=0x0F94.0     //0x0F94.0 = TRISC.0 = Configura o SDA como I/O 
#BIT I2C_SCL_DIRECTION=0x0F94.1     //0x0F94.1 = TRISC.1 = Configura o SCL como I/O 

#DEFINE ACK                         0
#DEFINE NOACK                       1

#DEFINE NEXT_DATA_WILL_BE_WRITE     0         
#DEFINE NEXT_DATA_WILL_BE_READ      1
#DEFINE NEXT_DATA_WILL_BE_STOP      0
#DEFINE NEXT_DATA_WILL_BE_RESTART   0
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////



//***************************************************************************************************************
//FUNCOES E VARIAVEIS
//***************************************************************************************************************
//void i2c_init();
//void i2c_start_bit();
//void i2c_restart_bit();
//void i2c_stop_bit();
//void i2c_data_write(int8 i2c_data_w, int1 rw)
//int8 i2c_data_read(int1 ack) 
void i2c_clock_delay1();
void i2c_clock_delay2();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////



//***************************************************************************************************************
//INICIALIZA A I2C (Pinos SCL e SDA)
//***************************************************************************************************************
void i2c_init()
{
   I2C_SDA=1;           //Pino SDA = nivel 1
   I2C_SCL=1;           //Pino SCL = nivel 1
   I2C_SDA_DIRECTION=0; //Configura o pino SDA como saida
   I2C_SDA=1;           //Pino SDA = nivel 1
   I2C_SCL_DIRECTION=0; //Configura o pino SCL como saida
   I2C_SCL=1;           //Pino SCL = nivel 1
}   
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////



//***************************************************************************************************************
//I2C StarBit Generator
//***************************************************************************************************************
void i2c_start_bit()
{ 
   i2c_clock_delay2();    //Aguarda
   I2C_SDA=0;             //Coloca SDA em '0' - Condicao de start é gerada neste momento (borda de descida em SDA com SCL em '1')
   i2c_clock_delay2();    //Delay para garantia de estabilizacao de SDA em '0'
   I2C_SCL=0;             //Coloca SCL em '0'
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////



//***************************************************************************************************************
//I2C ReStarBit Generator
//***************************************************************************************************************
void i2c_restart_bit()
{ 
   i2c_clock_delay1();     //Aguarda
   I2C_SCL=1;              //Coloca SCL em '1'
   i2c_clock_delay2();     //Aguarda estabilizacao de SCL 
   I2C_SDA=0;              //Coloca SDA em '0' - Condicao de start é gerada neste momento (borda de descida em SDA com SCL em '1')
   i2c_clock_delay2();     //Delay para garantia de estabilizacao de SDA em '0'
   I2C_SCL=0;              //Coloca SCL em '0'
   i2c_clock_delay1();     //Aguarda
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////



//***************************************************************************************************************
//I2C StopBit Generator
//***************************************************************************************************************
void i2c_stop_bit()
{  
   i2c_clock_delay1();     //Delay para garantia de estabilizacao da linha SCL
   I2C_SDA_DIRECTION=0;    //Configura SDA como saida
   I2C_SDA=0;              //Coloca SDA em '0'
   i2c_clock_delay2();     //Delay para garantia de estabilizacao de SDA
   I2C_SCL=1;              //Coloca SCL em '1'
   i2c_clock_delay2();     //Delay para garantia de estabilizacao de SCL
   I2C_SDA=1;              //Coloca SDA em '1' - Condicao de stop é gerada neste momento (borda de subida em SDA com SCL em '1')  
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////



//***************************************************************************************************************
//I2C BYTE WRITE
//***************************************************************************************************************
void i2c_data_write(int8 i2c_data_w, int1 rw)
{
   signed int8 bit;

   for (bit=7; bit>=0; bit--)                 //Executa 8 vezes a lógica abaixo
   {
      i2c_clock_delay1();                                 //Delay para garantia de estabilizacao de SCL
      I2C_SDA=bit_test(i2c_data_w,bit);                   //Seta ou reseta a saida SDA conforme os bits do byte a ser escrito
      i2c_clock_delay1();                                 //Delay para garantia de estabilizacao de SDA   
      I2C_SCL=1;                                          //Coloca SCL em '1'
      i2c_clock_delay2();                                 //Delay para o clock SCL
      I2C_SCL=0;                                          //Coloca SCL em '0'
   }

   delay_us(1);                              //Aguarda 1us
   I2C_SDA_DIRECTION=1;                      //Configura SDA como entrada para recepcao do ACK ou NOACK do escravo
   i2c_clock_delay2();                       //Delay para estabilizacao da linha SDA, por parte do escravo
   I2C_SCL=1;                                //Coloca SCL em '1'
   i2c_clock_delay2();                       //Delay para o clock SCL
   I2C_SCL=0;                                //Coloca SCL em '0'   

   if (i2c_rw==0) { I2C_SDA_DIRECTION=0; I2C_SDA=1; }   //Se o proximo byte será escrito, configura SDA como saida e poe em nivel '1'
                                                        //Se o proximo byte será lido, mantém SDA como entrada
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////



//******************************************************************************************************
//I2C BYTE READ
//***************************************************************************************************************
int8 i2c_data_read(int1 ack)  
{
   int8 i2c_data_r;
   signed int8 bit;

      for (bit=7; bit>=0; bit--) //Executa 8 vezes a lógica abaixo
      {      
         i2c_clock_delay1();                       //Aguarda estabilizacao em SCL
         I2C_SCL=1;                                //Coloca SCL em '1'
         i2c_clock_delay1();                       //Aguarda estabilizacao em SDA, por parte do escravo
         if(I2C_SDA) { bit_set(i2c_data_r,bit); }  //Testa o nivel da entrada SDA e seta/reseta os bits do byte de recepcao
         else        { bit_clear(i2c_data_r,bit); }            
         I2C_SCL=0;                                //Coloca SCL em '0'
      }

      delay_us(1);                                 //Aguarda 1us
      I2C_SDA_DIRECTION=0;                         //Coloca SDA como saida para geração do ACK ou NOACK

      if (!i2c_ack) { I2C_SDA=0; }                 //Mestre responde com ACK apos receber um byte do escravo
      else          { I2C_SDA=1; }                 //Mestre responde com NOACK apos receber um byte do escravo

      i2c_clock_delay1();                          //Aguarda estabilizacao da linha SDA
      I2C_SCL=1;                                   //Coloca SCL em '1'
      i2c_clock_delay2();                          //delay para o clock
      I2C_SCL=0;                                   //Coloca SCL em '0' 
      I2C_SDA_DIRECTION=1;                         //Coloca SDA como entrada

      return i2c_data_r;                           //Retorna o byte lido no barramento I2C para alguma variavel
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////



//***************************************************************************************************************
//Delay1 para a geração da frequencia de clock da I2C
//***************************************************************************************************************
void i2c_clock_delay1()
{
   delay_us(4);                   
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////



//***************************************************************************************************************
//Delay para a geração da frequencia de clock da I2C
//***************************************************************************************************************
void i2c_clock_delay2()
{
   delay_us(8); //delay2 deve ser o dobro de delay1 para haver simetria no clock gerado.                 
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//OBSERVACAO IMPORTANTE: O DELAY2 DEVE TER SEMPRE O DOBRO DO TEMPO DO DELAY1,
//para que o clock gerado seja "simetrico" (parte baixa e alta com tempos iguais)
//Exemplo: Se delay1 = 3us, delay2 sera = 6us

//OBSERVACAO IMPORTANTE: A taxa de transferencia de dados no barramento I2C pode 
//ser calculada aproximadamente por 1/delay2*2
//Exemplo: se delay2=2us, FREQ ~= 1/2*2x10^-6 ~= 250Kbps (e delay1 devera ser 1us)
//Exemplo: se delay2=4us, FREQ ~= 1/2*4x10^-6 ~= 125Kbps (e delay1 devera ser 2us)
//Exemplo: se delay2=10us, FREQ ~= 1/2*10x10^-6 ~= 50Kbps (e delay1 devera ser 5us)

Micael77 · 12 de janeiro de 2010

bom a principo eu já sei como funciona a comunicação i2c

o meu problema é apenas que o pic citado naõ comunca com a memória

estou usando uma 24c64

segue abixo o meu void main

#include <16f628a.h>
#device ADC=10
#use delay (clock=8000000)
#define use_portb_lcd true
//#include <cuscostdio.h>

#use i2c(MASTER, SDA=PIN_B4, SCL=PIN_B3)//habilita comunicação i2c
#use RS232(baud=9600, parity=E, bits=8, xmit=PIN_B2,rcv=PIN_B1)//habilita comunicação serial RS-232

#define EEPROM_WRITE_ADDRESS 0xA4
#define EEPROM_READ_ADDRESS 0xA5

void main()
{
   int num, hora, min, seg, dia, mes, ano;
   long j = 0;
   int16 add = 0;
   printf ("\n\rMECTRON AUTOMACAO INDUSTRIAL\n\rwww.mectron.ind.br");
   while (1)
   {
      i2c_start();
      i2c_write(EEPROM_WRITE_ADDRESS);
      i2c_write(add >> 8);
      i2c_write(add);
      i2c_start();
      i2c_write(EEPROM_READ_ADDRESS);
      num = i2c_read();
      hora = i2c_read();
      min = i2c_read();
      seg = i2c_read();
      dia = i2c_read();
      mes = i2c_read();
      ano = i2c_read(0);
      i2c_stop();

      j++;
      if (((j % 4) == 0) && (j != 0))
      {
         add = 32 * (j / 4);
      }
      else
      {
         add += 7;
      }

      if ((num == 0xFF) && (hora == 0xFF))
      {
         add = 0;
         j = 0;
      }
      if ((add != 0) && (j != 0))
      {
         printf ("\n\r%d - hora: %02d: %02d: %02d - data: %02d/ %02d/ %02d", num, hora, min, seg, dia, mes, ano);
      }
      else
      {
         printf ("\n\rMECTRON AUTOMACAO INDUSTRIAL\n\rwww.mectron.ind.br");         
      }  
   }
}

Micael77 · 13 de janeiro de 2010

alguem ai pode dar uma ajuda por favor?

muito obrigado

vtrx · 13 de janeiro de 2010

Me parece que o valor 0x4A não corresponde a uma memoria eeprom I2C,acho que seria

#define EEPROM_WRITE_ADDRESS 0xA4/ #define EEPROM_WRITE_ADDRESS 0xA0

#define EEPROM_READ_ADDRESS 0xA5/ #define EEPROM_READ_ADDRESS 0xA1

O resto alguem pode confirmar pois não programo em C.

Micael77 · 15 de janeiro de 2010

você leu errado

é 0xA4

está certo

vtrx · 15 de janeiro de 2010

Leia o datasheet e verá que voce esta indentificando errado,voce esta invertendo a ordem,os bits mais significativos tem que ser enviado primeiro.

Não vai conseguir deste modo.

Se quiser,tenho uma ótima matéria de um engenheiro aposentado de outro forum que foi feito em 2007,está completo e testado,está em ASM,mas voce poderá compreender melhor os passos para leitura e gravação.

Micael77 · 15 de janeiro de 2010

então você explica q com outro pic que tem i2c esse mesmo codigo funciona?

já foi testado e aprovador pelo meu chefe, porém usando um pic de 40 pinos

eu necessito que a placa seja pequena então eu preciso usar um pic de 18 pinos

se possivel até mesmo um menor

Felipe Electronic · 15 de janeiro de 2010

O problema aqui não parece a rotina mas a compreensão do protocolo I2C, o problema me parece a linha scl que esta com as temporizações erradas.

abs.

maskador · 15 de janeiro de 2010

- você sabe se o clock da I2C que você esta usando nao esta superior ao clock suportado pelo escravo i2c que pretendes ler/escrever?

- Colocou os resistores de pull-up nas linhas SCL E SCK? pois o hardware da I2C funciona com saida em coletor aberto, necessitando então dos resistores para "puxar" o nivel logico das linhas para "1"

- configurou os pinos que sao utilizados pela I2C como entrada? Por exemplo, no PIC18F4550 o hardware dedicado da I2C usa os pinos RB0 e RB1, então na incializacao do codigo você deveria fazer set_tris_b(0bxxxxxx11);, isto está especificado no datasheet.

vtrx · 15 de janeiro de 2010

Se não me engano,pic de 40 pinos tem I2C implementado internamente via Hardware dedicado,e o 16F628 precisa de código programado via SOFTWARE,não funciona um código feito para um µc com Hardware dedicado com um que não tem essa função nativamente.

ja contatei o tal enegenheiro pra dar uma analisada.

Felipe Electronic · 16 de janeiro de 2010

Quer I2C com PIC de 18 pinos, então use o 16f819 ou o 16f88, eles possuem módulo dedicado.

So confirmando o amigo vtrx sim, os PIC 16f877a e 16f876 possuem i2c dedicado, são realtivamente simples de operar.

não funciona um código feito para um µc com Hardware dedicado com um que não tem essa função nativamente.
ja contatei o tal enegenheiro pra dar uma analisada.

Vtrx, não entendi, ou entendi mal, pois uma solução feita por software que fiz para o 877A que TEM i2c por hardware funcionou muito bem em um 12f675 que não o possui, a unica coisa é que não fiz o codigo me baseando no hardware do 877a, mas sim como se ele não tivesse o modulo, lembro me, que devido a um erro de projeto os pinos que faziam o SCL e SDA fora usados para outra função nesse 877a, e por isso implantei a solução por software.

Posso ter entendido mal.

Micael77,

creio que pode estar cometendo o erro que muitos fazem ou elaborar um solução por software, que é manipular somente o registraddor de dados do port, não é assim que funciona, e como disse o maskador voce deve manipular tanto o tris_x quanto o port_x da seguinte forma:

inicialmente configure o tris como entrada.

para impor nivel 0 na linha, deves impor o tris como entrada e o port como 0,

para impor nivel 1 na linha, apenas deve impor o tris como 0 e port como 1 e deixar que o pull-up force a linha em 1

entendeu?

abs.

vtrx · 16 de janeiro de 2010

Vtrx, não entendi, ou entendi mal, pois uma solução feita por software que fiz para o 877A que TEM i2c por hardware funcionou muito bem em um 12f675 que não o possui, a unica coisa é que não fiz o codigo me baseando no hardware do 877a, mas sim como se ele não tivesse o modulo, lembro me, que devido a um erro de projeto os pinos que faziam o SCL e SDA fora usados para outra função nesse 877a, e por isso implantei a solução por software.

voce entendeu errado,disse isso com o código que ele postou,que parece que é para um que tem Hardware I2C dedicado,não com o seu,que parece que ele não usou...

então você explica q com outro pic que tem i2c esse mesmo codigo funciona?

voce esta certo,funciona assim,mas NÃO É PADRÃO pois só funciona porque o código esta fazendo um 'shift_right',isto é,esta enviando ao contrario,isso confunde qualquer um pois o Datasheet determina o endereçamento B'1010000X'

Micael77 · 19 de janeiro de 2010

bom eu nao sei ao certo o que está errado

mas se tiver um pic de 18 pinos com comunicacao serial e i2c já implementados

todos os meus problemas estão resolvidos, pois com o 16f877a que possui os 2 tudo funciona corretamente

o problema é que meu prazo estourou e eu acabei mandando o produto com um desses

ficou uma coisa ridiculamente grande, quando poderia ser pouco maior que um pendrive

mas como é apenas um prtotipo td bem, o problema é no produto final

e para completar meu chefe esta querendo usar USB e nao mais a comunicacao serial RS232

uma outra duvida

aquele codigo que o maskador postou funciona certo?

muito obrigado

Felipe Electronic · 19 de janeiro de 2010

e para completar meu chefe esta querendo usar USB e nao mais a comunicacao serial RS232

FT232 ou equivalente.

mas se tiver um pic de 18 pinos com comunicacao serial e i2c já implementados
todos os meus problemas estão resolvidos

PIC16F88 ou 819 ambos possuem i2c por hardware, atente se somente que o modo master dele é controlado via software mas os controles como start e stop bit, ack e nack ja estão disponiveis por software.