Problemas con I2C y C18

[bondadoso]

Hola:
estoy intentando mandar un byte por i2c es un pequeño programa de prueba, porque despues voy a hacer la comunicacion con un display motorola c115, pero en proteus no hay comunicacion con i2c debugger.

#include <p18f2525.h>
#include <i2c.h>
#pragma config OSC = XT

void main(void)
{
OpenI2C(MASTER, SLEW_ON);// Initialize I2C module
SSPADD = 9;

StartI2C(); //start i2c
IdleI2C(); // i2c is available?
WriteI2C(0x3e); //send byte
StopI2C(); //close i2c
}

adjunto la simulacion y el codigo.

 

[nitsuga2585]

El conexionado está bien ya que logro mandar datos del maestro al esclavo.
Este es el código que uso:

Codigo Maestro

/** I N C L U D E S **********************************************************/
#include <p18cxxx.h>
#include <i2c.h>
#include <delays.h>
#include <string.h>
#include <stdlib.h>    //Libreria para conversiones a string
#include <stdio.h>

        #pragma config PLLDIV   = 5         // (20 MHz crystal on PICDEM FS USB board)
        #pragma config CPUDIV   = OSC1_PLL2   
        #pragma config USBDIV   = 2         // Clock source from 96MHz PLL/2
        #pragma config FOSC     = HSPLL_HS
        #pragma config FCMEN    = OFF
        #pragma config IESO     = OFF
        #pragma config PWRT     = OFF
        #pragma config BOR      = ON
        #pragma config BORV     = 3
        #pragma config VREGEN   = ON      //USB Voltage Regulator
        #pragma config WDT      = OFF
        #pragma config WDTPS    = 32768
        #pragma config MCLRE    = ON
        #pragma config LPT1OSC  = OFF
        #pragma config PBADEN   = OFF
//      #pragma config CCP2MX   = ON
        #pragma config STVREN   = ON
        #pragma config LVP      = OFF
//      #pragma config ICPRT    = OFF       // Dedicated In-Circuit Debug/Programming
        #pragma config XINST    = OFF       // Extended Instruction Set
        #pragma config CP0      = OFF
        #pragma config CP1      = OFF
//      #pragma config CP2      = OFF
//      #pragma config CP3      = OFF
        #pragma config CPB      = OFF
//      #pragma config CPD      = OFF
        #pragma config WRT0     = OFF
        #pragma config WRT1     = OFF
//      #pragma config WRT2     = OFF
//      #pragma config WRT3     = OFF
        #pragma config WRTB     = ON       // Boot Block Write Protection
        #pragma config WRTC     = OFF
//      #pragma config WRTD     = OFF
        #pragma config EBTR0    = OFF
        #pragma config EBTR1    = OFF
//      #pragma config EBTR2    = OFF
//      #pragma config EBTR3    = OFF
        #pragma config EBTRB    = OFF


/** V A R I A B L E S ********************************************************/
#pragma udata
unsigned char ENVIO_I2C[10];
#pragma udata

unsigned char DATO;

/** P R I V A T E  P R O T O T Y P E S ***************************************/
void YourHighPriorityISRCode();
void YourLowPriorityISRCode();
unsigned char escribirI2C(unsigned char DIRECCION);
unsigned char leerI2C(unsigned char slave_addr, unsigned char direcc);

/** V E C T O R  R E M A P P I N G *******************************************/

#pragma code HIGH_INTERRUPT_VECTOR = 0x08
void High_ISR (void)    {
    _asm goto YourHighPriorityISRCode _endasm
}
#pragma code LOW_INTERRUPT_VECTOR = 0x18
void Low_ISR (void){
    _asm goto YourLowPriorityISRCode _endasm
}
    
#pragma code


#pragma interrupt YourHighPriorityISRCode
void YourHighPriorityISRCode(){
    #if defined(USB_INTERRUPT)
        USBDeviceTasks();
    #endif
}

#pragma interruptlow YourLowPriorityISRCode
void YourLowPriorityISRCode(){
    
}

/** D E C L A R A T I O N S **************************************************/
#pragma code
/******************************************************************************
 * Function:        void main(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Main program entry point.
 *
 * Note:            None
 *****************************************************************************/
/** L E D ***********************************************************/
void main(void)
{
    TRISD=0x00;    
    
    CloseI2C();

    //Iniciamos I2C
    OpenI2C(MASTER, SLEW_ON); //MASTER, 400KHZ
    SSPADD = 119; // I2C_clock = FOSC/(4 * (SSPADD + 1)) => FOSC = 20MHz y Scl=100KHz  //119


    escribirI2C(0xA2);

    //ESPERO UN TIEMPO GRANDE ANTES DE LLER
    Delay10KTCYx(200);

    DATO = leerI2C(0xA2, 40);

    while(1){
    PORTD = DATO;
}
}

unsigned char escribirI2C(unsigned char DIRECCION) {
    //slave_addr => Direccion de Escritura del dispositivo I2C
    IdleI2C(); // Esperar a que el periferico esté disponible
    StartI2C(); // Generar condicion Start
    while (SSPCON2bits.SEN); // Espera a que se inicie la condicion START en los pines SDA y SCL
    WriteI2C(DIRECCION); // Slave address to SSPBUF (Write)
    WriteI2C(30); // Write Data to SSPBUF
    WriteI2C(1);
    WriteI2C(3);
    WriteI2C(7);
    WriteI2C(15);
    StopI2C(); // Generar condicion Stop
    while (SSPCON2bits.PEN); // Espera a que se inicie la condicion STOP en los pines SDA y SCL
    //while (EEAckPolling(slave_addr_w));  //Espera que se complete escritura.
}

// Secuencia de Lectura de Memoria I2C

unsigned char leerI2C(unsigned char slave_addr, unsigned char direcc) {
    //slave_addr => Direccion de Escritura del dispositivo I2C
    unsigned char reg;
    IdleI2C(); // Esperar a que el periferico esté disponible
    StartI2C(); // Generar condicion Start
    while (SSPCON2bits.SEN); // Espera a que se inicie la condicion START en los pines SDA y SCL
    WriteI2C(slave_addr); // Slave address to SSPBUF (Dummy Write)
    WriteI2C(direcc); // Word address to SSPBUF
    RestartI2C(); // Generar condicion Restart
    while (SSPCON2bits.RSEN); // Espera a que se inicie la condicion RESTART en los pines SDA y SCL
    WriteI2C(slave_addr | 0x01); // Slave address to SSPBUF (Read)
    reg = ReadI2C(); // Leer dato de Memoria I2C
    NotAckI2C(); // Generar condicion NACK
    while (SSPCON2bits.ACKEN); // Espera a que se inicie la condicion NACK en los pines SDA y SCL
    StopI2C(); // Generar condicion STOP
    while (SSPCON2bits.PEN); // Espera a que se inicie la condicion STOP en los pines SDA y SCL
    Delay1KTCYx(25);
    return (reg);
}

y el Codigo Slave

#include <p18f4620.h>
#include <delays.h>
#include <usart.h>
#include <stdio.h>
#include <string.h>
#include <i2c.h>

#pragma config OSC=HSPLL
#pragma config IESO=OFF
#pragma config PWRT=ON
#pragma config WDT=OFF
#pragma config MCLRE=ON
#pragma config XINST=OFF
#pragma config DEBUG=ON
#pragma config FCMEN = OFF
#pragma config LVP=OFF
#pragma config BOREN=OFF

/** V A R I A B L E S ********************************************************/
unsigned int DATO,ACCION,KBIT;
unsigned int i,j,k;

#pragma udata
unsigned char ENVIO_I2C[10];
#pragma udata

/** P R I V A T E  P R O T O T Y P E S ***************************************/
void low_isr(void);
void high_isr(void);
unsigned char escribirI2C ( unsigned char slave_addr, unsigned char direcc, unsigned char reg_dato);
unsigned char leerI2C ( unsigned char slave_addr, unsigned char direcc);

/** V E C T O R  R E M A P P I N G *******************************************/
//Vector de interrupcion de baja prioridad
#pragma code low_vector=0x18
void interrupt_at_low_vector(void)
{
 _asm GOTO low_isr _endasm
}
#pragma code /* Regresa al lugar de donde dio el salto */
#pragma interruptlow low_isr
void low_isr (void)
{
 //En esta secccion se coloca las lineas de codigo
 //con grado de baja prioridad
}
 
 
//Vector de interrupcion de alta prioridad
#pragma code high_vector=0x08
void interrupt_at_high_vector(void)
{
 _asm GOTO high_isr _endasm
}
#pragma code /* Regresa al lugar de donde dio el salto */
#pragma interrupt high_isr
void high_isr (void)
{
       if(PIR1bits.SSPIF==1){
        DATO = ReadI2C();
    }
    KBIT = 1;
    PIR1bits.SSPIF=0;    // Borramos bandera.-
}


/** D E C L A R A T I O N S **************************************************/
#pragma code
/******************************************************************************
 * Function:        void main(void)
 *
 * PreCondition:    None
 *
 * Input:           None
 *
 * Output:          None
 *
 * Side Effects:    None
 *
 * Overview:        Main program entry point.
 *
 * Note:            None
 *****************************************************************************/
/************************************************************************************************/
/*************************************************************************************************************/
//PROGRAMA PRINCIPAL
void main(void)
{
    TRISD=0x00;    

    ADCON1 = 0xFF;  //DESHABILITA ENTRADAS ANALOGICAS

    RCONbits.IPEN = 1;    // habilitamos Prioridades
    IPR1bits.SSPIP = 1;    //PRIORIDAD ALTA AL I2C
    // Configuracion de las interrupciones.
    PIE1bits.SSPIE = 1;    // Habilita la interrupcion del modulo SSP
    INTCONbits.PEIE = 1; // Habilita las interrupciones de los perifericos
    INTCONbits.GIE = 1;    // Habilita las interrupciones globales!

    PIR1bits.SSPIF = 0;    // BORRO LA BANDERA DE LA INTERRUPCION        

    //Iniciamos I2C
    OpenI2C(SLAVE_7,SLEW_ON);//MASTER, 400KHZ
    SSPADD = 0xA2;

//CONDICIONES INICIALES
    i = j = KBIT = 0;
    k = 1;

while(1){
    
    if(DATO == 30){
        i = 1;
    }
    if(DATO == 40){
        j = 1;
    }
    if((i == 1)&&(DATO != 30)&&(KBIT == 1)){
        ENVIO_I2C[k] = DATO;
        k = k+1;
        KBIT = 0;
        if(k<4){
            i=0;
            k=0;
        }
    }

    if((i == 1)&&(DATO != 40)&&(KBIT == 1)){
            WriteI2C(5);
    }

    PORTD = ENVIO_I2C[1];
    Delay10TCYx(1);
    PORTD = ENVIO_I2C[2];
    Delay10TCYx(1);
    PORTD = ENVIO_I2C[3];     

}
}

El código del maestro es un poco obvio, y el código del esclavo lo que hace es, después de mandar la direccion del esclavo, leo, si llega el 30 leo los datos del maestro y si le envia el 40 le responde con un mensaje.



Esta es una foto de la simulacion en proteus, figura los datos enviados por el maestro pero no los enviados por el esclavoVer el archivo adjunto 123866