Einrichtung I2C-Bus mit dcPIC30F4011

[Olli (Gast)]

Hallo!

Ich versuche zur Zeit das interne I2C-Modul des dcPIC30F4011 zu nutzen 
um mit diesem als Master ein kleines I2C-Bussystem aufzubauen. Um dieses 
zu testen verwende ich einen pcf8574p (Remote 8-bit I/O expander for
I2C-bus) als Slave. Mit der Funktion void i2c_transmit_test() möchte ich 
von µC den Slave ansprechen und daraufhin einmal 8 Bit Daten an diesen 
Senden (Write). Die Variable "test" wird bei jedem Interrupt des 
MI2C-Interrupts um eins hochgezählt. So wollte ich realisieren, dass die 
Funktion zum Schreiben auf den Bus erst fortgesetzt wird, wenn dieser 
Interrupt ausgelöst wird. Weiterhin habe ich im Programm habe ich ab und 
zu mal den einen oder anderen Pin gesetzt/gelöscht (bei mir heißen diese 
E0,E1,E2,....) um mir anzeigen zu lassen, ob der µC diese Stelle des 
Codes durchläuft.

Meinen Quellcode könnt ihr hier sehen:

main.c:

/****************************************************************************
  INCLUDE FILES
*****************************************************************************/
#include <p30f4011.h>
#include "init.h"


/****************************************************************************
  CONFIGURATION BITS
*****************************************************************************/
// DSPIC30F4011 Configuration Bit Settings

#include <xc.h>

// FOSC
#pragma config FPR = XT_PLL8          // Primary Oscillator Mode (XT w/PLL 16x)

#pragma config FOS = PRI               // Oscillator Source (Primary Oscillator)
#pragma config FCKSMEN = CSW_FSCM_OFF  // Clock Switching and Monitor (Sw Disabled, Mon Disabled)

// FWDT
#pragma config WDT = WDT_OFF            // Watchdog Timer (Disabled)

// FGS
#pragma config GWRP = GWRP_OFF          // General Code Segment Write Protect (Disabled)
#pragma config GCP = CODE_PROT_OFF      // General Segment Code Protection (Disabled)

/****************************************************************************
  Funktionsdeklarationen
*****************************************************************************/
void short_pause(void);
void long_pause(void);
void test_rb(void);
void pic_init(void);
void Timer_init(void);
void i2c_init(void);
void i2c_transmit_test(void);
void counter(void);


int main(void) {

    long_pause();
    i2c_transmit_test();


    while(1)
    {
    }
    return 0;

}

/****************************************************************************
  Interrupt Capture MI2C
*****************************************************************************/

 void __attribute__((__interrupt__,__no_auto_psv__)) _MI2CInterrupt(void)
  {
        counter();

        IFS0bits.MI2CIF=0;
    return;
  }

 /****************************************************************************
  Interrupt Capture SI2C
*****************************************************************************/

 void __attribute__((__interrupt__,__no_auto_psv__)) _SI2CInterrupt(void)
  {

  IFS0bits.SI2CIF=0;
    return;
  }

init.h:

#include <p30f4011.h>

#define E0      LATEbits.LATE0
#define E1      LATEbits.LATE1
#define E2      LATEbits.LATE2
#define E3      LATEbits.LATE3
#define E4      LATEbits.LATE4
#define E5      LATEbits.LATE5

#define B0      LATBbits.LATB0
#define B1      LATBbits.LATB1
#define B2      LATBbits.LATB2

myfunctions.c:

/****************************************************************************
 Globale Variablen deklarieren
*****************************************************************************/

unsigned int test;

//-----------------------------------------------------------------------------------------------------------//
//***** Funktion zum kurzen Pausieren des Programmablaufs
//-----------------------------------------------------------------------------------------------------------//
void short_pause()
{
    unsigned long i;
    for(i=0; i<1000; i++);
}

//-----------------------------------------------------------------------------------------------------------//
//***** Funktion zum längeren Pausieren des Programmablaufs
//-----------------------------------------------------------------------------------------------------------//
void long_pause()
{
    unsigned long i;
    for(i=0; i<50000; i++);
}

//-----------------------------------------------------------------------------------------------------------//
//***** Funktion zum Test des I2C-Bus durch Senden von 8 Bit Daten an I/O-Expander mit Adresse 0100000
//-----------------------------------------------------------------------------------------------------------//

void i2c_transmit_test()
{
    E0 = 1;
    E0 = 0;
    if(I2CSTATbits.P==0)                                                            //Bus in idle-Zustand?
    {
        unsigned long timeout = 0;
        unsigned long t_tot = 50000;
        test = 0;
        E0 = 1;
        E0 = 0;

        I2CCONbits.SEN = 1;                                                         //Generate start condition by setting the Start ENable bit (SSPCON2)

        while(test < 1 && timeout < t_tot)timeout++;                    //wait until MSSP module genrerated the interrupt at the end of the ninth clock cycle
        if(timeout < t_tot)
        {
            E0 = 1;
            E0 = 0;
            timeout = 0;
            I2CTRN = 0b01000000;                                                    //Adresse von slave und write bit (lsb) in register schreiben

            while(test < 2 && timeout < t_tot)timeout++;                //wait until MSSP module genrerated the interrupt at the end of the ninth clock cycle
            if(timeout < t_tot)
            {
                if(I2CSTATbits.TRSTAT == 0)
                {
                    E0 = 1;
                    E0 = 0;
                    timeout = 0;
                    I2CTRN = 0b10101010;

                    while(test < 3 && timeout < t_tot)timeout++;
                    if (timeout < t_tot)
                    {
                        if(I2CSTATbits.ACKSTAT == 0)
                        {
                            E0 = 1;
                            E0 = 0;
                            I2CCONbits.SEN = 1;
                        }
                    }
                }
            }
        }
        E0 = 1;
        E0 = 0;
        if (timeout == 50000)
        {
            E0 = 1;
            E0 = 0;
        }
    }
}

void counter()
{
    test++;
}

void i2c_init()
{
    //I2C-Bus-Initialisierung
    I2CBRG = 0x024;                                 //Setting Baud Rate to 400kHz (I2CBRG = ((F_CY/F_SCL) - (F_CY/1111111)) - 1) mit F_SCL ) = 400kHz und F_CY = 4MHz
    I2CCONbits.I2CEN = 1;                           //Enable I2C
    I2CCONbits.I2CSIDL = 0;                         //Continue Module Operation in Idle Mode
    I2CCONbits.SCLREL = 0;                          //SCL Release Control Bit (when operating as I2C-Slave): Release SCL clock
    I2CCONbits.IPMIEN = 0;                          //IPMI mode not enabled
    I2CCONbits.A10M = 0;                            //7-bit slave address
    I2CCONbits.DISSLW = 0;                          //Slew Rate control enabled
    I2CCONbits.SMEN = 0;                            //Disable SMBus input threshold
    I2CCONbits.GCEN = 0;                            //General call address disabled
    I2CCONbits.STREN = 0;                           //Disable SOftware or release clock stretching
    

    //I2C Interrupts
    IFS0bits.MI2CIF=0;                            //I2C Bus collision flag clearen
    IFS0bits.SI2CIF=0;                            //I2C transfer complete Interrupt flag clearen

    IPC3bits.MI2CIP=1;                            //I2C Bus collision Interrupt priority
    IPC3bits.SI2CIP=1;                            //I2C transfer complete interrupt priority

    IEC0bits.MI2CIE=1;                            //I2C Bus collision interrupt enable bit
    IEC0bits.SI2CIE=1;                            //I2C transfer complete interrupt enable bit

}


void pic_init()
{
    ADPCFG = 0xffff;                            //Port B digital
    TRISEbits.TRISE0 = 0;
    TRISEbits.TRISE1 = 0;
    TRISEbits.TRISE2 = 0;
    TRISEbits.TRISE3 = 0;
    TRISEbits.TRISE4 = 0;
    TRISEbits.TRISE5 = 0;
    LATEbits.LATE0 = 0;
    LATEbits.LATE1 = 0;
    LATEbits.LATE2 = 0;
    LATEbits.LATE3 = 0;
    LATEbits.LATE4 = 0;
    LATEbits.LATE5 = 0;

    TRISBbits.TRISB0 = 0;
    TRISBbits.TRISB1 = 0;
    TRISBbits.TRISB2 = 0;
    LATBbits.LATB0 = 0;
    LATBbits.LATB1 = 0;
    LATBbits.LATB2 = 0;
}

Das ist jetzt nur der Teil des Quellcodes, den ich für mein Problem als 
relevant betrachte. D.h. z.B. weitere Timer- und 
Interruptinitialisierungen sind vorhanden, aber nicht hier mit drinnen.

Mein Problem kann ich leider dabei noch gar nicht so genau definieren. 
Ich weiß, dass der µC auf jeden Fall noch nichts so wirklich auf den Bus 
legt. Ich kann mit dem Oszi nicht erkennen, dass die Startbedingung 
korrekt ausgeführt wird. Ich sehe nur, dass beim Funktionsaufruf SDA auf 
low-Pegel gezogen wird und dort bleibt. SCL bleibt dauerhaft auf 
High-Pegel. Es wird also auch nicht die Slave-Adresse auf den Bus 
geschoben. Vor dem Funktionsaufruf haben SDA und SCL beide High-Pegel.

Ich denke mein Schaltungsaufbau wird nicht großartig relevant sein. Ich 
habe außer dem Bus bis jetzt keine zusätzliche Peripherie angeschlossen 
(außer PICkit 2). Der Bus wird mit zwei 5kOhm Pullups hochgezogen. Die 
Stromversorgung erfolgt mit einem Labornetzgerät.

Funktionen wie z.B. Timer und Interrupts wurden bereits getestet und 
funktionieren.

Wäre nett, wenn mal jmd. über meinen Code drüberschauen könnte. Vllt. 
findet ihr ja nen kleinen Fehler in der Initialisierung oder der 
Testfunktion des I2C-Buses, der mir einfach nicht auffällt.

Falls ich für eine AUskunft relevante Infos zu meinem Projekt vergessen 
habe, möchte ich mich im Voraus dafür entschuldigen. Bitte gebt mir dann 
Bescheid und ich werden alles nachliefern!


Besten Dank im Voraus.

Gruß Olli

[Frank M. (frank_m35)]

Also ich habe mir deinen Code nicht genau angeschaut, aber ich würde dir 
Vorschlagen es auch anders zu lösen, und zwar strukturierter.

Momentant hast du alles in eine Funktion gepackt, das mag am Anfang 
vielleicht noch einigermaßen funktionieren (oder eben auch nicht) 
spätestens wenn du ein zweites I2C Gerät ansprechen willst musst du 
alles nochmal von Grund auf programmieren, da du nichts vom bisherigen 
verwenden kannst.

Also packe Start, Stop, Send, Read, ... in seperate Funktionen.

Du du eh dein Programm mit einer while Schleife blockst, verstehe ich 
auch den Umweg über den Interrupt nicht. Stattdessen kannst du auch 
direkt das benötigte Flag in einer While Schleife pollen und nach einer 
bestimmten Zeit abbrechen.

das würde ich aber eh erst gegen Ende versuchen zu implementieren, da es 
das debuggen deutlich erschwert. Am Anfang wird es vermutlich oft 
vorkommen, dass der Bus hängt, dann ist es immer sehr schön per debugger 
zu sehen wo er nun hing.

Ich fand dieses Tutorial sehr hilfreich zum implementieren eigener I2C 
Routinen, es ist gut erklärt und der Code gut struktuiert. Zudem siehst 
du dort welche Flags du überhaupt überprüfen musst um zu sehen ob die 
Übertragung, ... erfolgreich war oder nicht.
http://www.engscope.com/pic24-tutorial/10-2-i2c-basic-functions/

[Olli (Gast)]

Danke für die Tips! Ich werd mal mit dem Erstellen separater Funktionen 
für Start, Stop, usw. anfangen und dann das ganze nochmal Testen.

Den Umweg über den Interrupt habe ich aus folgendem Grund gemacht:
Ich wollte Testen, wie "tief" der µC in der I2C_transmit_test()-Funktion 
geht. Das hätte ich mir dann an Hand des Wertes der Variable "test" 
angeschaut. So weit bin ich allerdings noch gar nicht gekommen. Du hast 
natürlich auf jeden Fall recht, dass es ein Umweg ist. Ich sollte 
möglicherweise auch mehr mit dem Debugger arbeiten, leider kenn ich mich 
mit dem bein PIC-µC (bzw. MPLAB X IDE) noch nicht so gut damit aus, aber 
ich werd mich mal damit befassen.

Danke auch für den Tutorial-Link, werd ich mir auch mal ansehen.

Gruß Olli

[Atlas (Gast)]

Geschwindigkeit vom I2C-Bus von 400kHz auf 100kHz reduzieren.

Siehe Datenblatt PCF8574P: 100 kHz I²C‑bus interface (Standard-mode 
I²C-bus)

[Olli (Gast)]

Atlas schrieb:
> Geschwindigkeit vom I2C-Bus von 400kHz auf 100kHz reduzieren.
>
> Siehe Datenblatt PCF8574P: 100 kHz I²C‑bus interface (Standard-mode
> I²C-bus)

Habe die Geschwindigkeit beriets auf 100 kHz festgelegt. Habe an dieser 
Stelle nur den Kommentar noch nicht geändert, mein Fehler.

Allerdings war/ist mein Problem ja mehr, dass die Bussteuerung an sich 
schon nicht funktioniert hat.

Habe meinen Quellcode jetzt mal geändert, wie Frank M. vorgeschlagen 
hat. Leider bin ich noch nicht dazu gekommen, ihn zu testen, da mein µC 
sich gestern mit meinem PICkit 2 nicht mehr programmieren lassen wollte. 
Heute wird aber ein neuer Versuch gestartet. Vielleicht hat jmd. von 
euch Lust, sich den Code (nur die I2C-Funktionen) mal anzuschauen, 
deswegen poste ich ihn jetzt einfach mal noch dazu:

#define T_MAX 50000


int i2c_start()
{
        unsigned int timeout = T_MAX;

        I2CCONbits.SEN = 1;                                                         //Generate start condition by setting the Start Enable bit (SSPCON2)
        while( I2CCONbits.SEN && timeout > 0)  timeout--;
        return(timeout);
}

int i2c_restart()
{
        unsigned int timeout = T_MAX;

        I2CCONbits.RSEN = 1;                                                         //Generate start condition by setting the Start Enable bit (SSPCON2)
        while( I2CCONbits.RSEN && timeout > 0)  timeout--;

        return(timeout);
}

int i2c_reset()
{
        unsigned int timeout = T_MAX;

        I2CCONbits.PEN = 1;
        while( I2CCONbits.RSEN && timeout > 0)  timeout--;

        I2CCONbits.RCEN = 0;
        IFS0bits.MI2CIF = 0;
        I2CSTATbits.IWCOL = 0;
        I2CSTATbits.BCL = 0;

        return(timeout);
}

int i2c_send_byte(int data)
{
    unsigned int timeout = T_MAX;

    I2CTRN = data;
    while(I2CSTATbits.TRSTAT && timeout > 0) timeout--;
    if(I2CSTATbits.ACKSTAT)
    {
        i2c_reset();
        return(-1);
    }
    return(timeout);
}

//-----------------------------------------------------------------------------------------------------------//
//***** Funktion zum Test des I2C-Bus durch Senden von 8 Bit Daten an Slave
//-----------------------------------------------------------------------------------------------------------//

int i2c_write(int add, int data)
{
    int error = 0;

    if(i2c_start() < 1) error++;
    if(i2c_send_byte(add) < 1) error++;
    if(i2c_send_byte(data) < 1) error++;
    if(i2c_reset() < 1) error++;

    return(error);
}

Gruß Olli

[Frank M. (frank_m35)]

sieht soweit ganz gut aus.

Reset würde ich in Stop umbenennen, ganz einfach weil so der Befehl auch 
in den Datenblättern genannt wird.

Dein Timeout ist etwas 'unsicher', da du ja nach keiner Zeit gehst es 
sei denn du hast T_MAX zuvor auf deinen Prozessor, Taktfrequenz und 
Operation hin berechnet, dass du weißt welche Zeit er wartet. Alternativ 
kannst du Timer und eine globale Variable verwenden um Zeit zu messen.

Deine Überprüfung auf Erfolg oder Nichterfolg würde ich auch eher 
geschachtelt machen anstatt einfach error hoch zu zählen, denn wenn 
Start schon nicht erfolgreich ist, dann muss man ja auch nicht versuchen 
was zu senden.