Haz una pregunta
  Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos
Foros Registrarse ¿Olvidaste tu contraseña?

Temas similares

01/11/2011 #1

Avatar de bondadoso

Problemas con I2C y C18
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.
18/01/2015 #2


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

Codigo Maestro

Código:
/** 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)) =&gt; 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 =&gt; 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 =&gt; 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

Código:
#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.

---------- Actualizado después de 9 minutos ----------

Esta es una foto de la simulacion en proteus, figura los datos enviados por el maestro pero no los enviados por el esclavoArchivo Adjunto 123866
Respuesta
¿Tienes una mejor respuesta a este tema? ¿Quieres hacerle una pregunta a nuestra comunidad y sus expertos? Registrate

Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos

Powered by vBulletin® Version 3.8.4
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO ©2011, Crawlability, Inc.