I2C Signal wird nicht fertig gesendet

[Benjamin B. (benbu)]

Hallo Leute,
Ich nutze einen PIC24FJ128GB204 als Master und möchte eine I2C- 
Verbindung zu einem FT200XD (I2C zu USB) aufbauen.
Die Verbindung kann auch aufgebaut werden. aber nach einigen Malen 
"hängt" der Controller sich beim Senden der Adresse bzw. des 
Lese/schreib Bits auf. Manchmal fängt er sich wieder und manchmal nicht.
Ich habe hier mal zwei Bilder, die den Vorgang zeigen.
Im Bild "unvollstaendigeNachricht" seht ihr den Beginn der Nachricht und 
wie plötzlich beim letzten Bit SDA auf low bleibt und SCL auf high.
Das zweite Bild (RestDerNachricht) zeigt wie 54ms später der Rest der 
Nachricht kommt. Auch, dass danach eine komplette Nachricht ohne 
Probleme gesendet wird.
Ich muss dazu erwähnen, dass der Controller vor dem Fehler bereits über 
100 Mal die Nachricht korrekt gesendet hat und das so eine Sittuation 
immer zu einem anderen Zeitpunkt kommt. Leider rettet er sich immer nur 
maximal ein mal aus so einem Zustand. Danach bleibt er komplett mit SDA 
low und SCL high stehen.

Ich habe für die Programmierung den MCC im MPLAB genutzt und vermute, 
dass dort das problem liegt, da ich nicht alles verstehe was dort 
programmiert wird. Ich teile mal den Code, den ich nutze hier:

Die Funktion, die ich aufrufe um den den Inhalt des USB speichers 
abzufragen.

uint8_t USB_Read(  uint8_t *pData, uint16_t nCount)
    {
        I2C2_MESSAGE_STATUS status;
        //uint8_t     writeBuffer[3];
        uint16_t    retryTimeOut, slaveTimeOut;
        uint16_t    counter;
        uint8_t     *pD;

        pD = pData;

        for (counter = 0; counter < nCount; counter++)
        {
            // this portion will read the byte from the memory location.
            retryTimeOut = 0;
            slaveTimeOut = 0;

            while(status != I2C2_MESSAGE_FAIL)
            {
                // write one byte to EEPROM (2 is the count of bytes to write)
                I2C2_MasterRead(pD,3,USB_ADDRESS,&status);

                // wait for the message to be sent or status has changed.
                while(status == I2C2_MESSAGE_PENDING)
                {
                    // add some delay here
                    // timeout checking
                    // check for max retry and skip this byte
                    if (slaveTimeOut == USB_DEVICE_TIMEOUT)
                        return (0);
                    else
                        slaveTimeOut++;
                }

                if (status == I2C2_MESSAGE_COMPLETE)
                    break;

                // if status is  I2C2_MESSAGE_ADDRESS_NO_ACK,
                //               or I2C2_DATA_NO_ACK,
                // The device may be busy and needs more time for the last
                // write so we can retry writing the data, this is why we
                // use a while loop here

                // check for max retry and skip this byte
                if (retryTimeOut == USB_RETRY_MAX)
                    break;
                else
                    retryTimeOut++;
            }


            // exit if the last transaction failed
            if (status == I2C2_MESSAGE_FAIL)
            {
                return(0);
                break;

            }

            //pD++;
        }
        return(1);
    }

Die Funktion, die immer wieder aufgerufen wird. (in dieser Frage ich 
erst Taster ab und dann den USB Speicher)

void interruptProcedure(){
        switchStatus=checkSwitch(); // Übergebe die Variable an SwitchStatus, welcher Taster gedrückt ist, CheckSwitch() schaut in die LookUp arrSwitch)
        if (switchStatus!=-1){  // wenn ungleich -1 dann wurde Taster gedrückt 
            if (switchStatus<16){ // wenn Nummer kleiner 16 wurde ein INPUT angewählt
                actInputPort = switchStatus;   //Schreibe die Nummer des INPUT in die Variable: actInputPort 
            }
            else{
                actOutputPort = switchStatus; // wenn Nummer größer 16, wurde ein OUTPUT angewählt, schreibe die Nummer des Input in die Variable: actOutputPort
            }
             // Setze die einzelnen Muliplexerbausteine, je nach Configuration
            setGates();
            //errorHandling(errorNumber);
        }
        
        
        // Start der USB Abfrage 
        // es geht immer nur lesen oder schreiben in einem Intrrupt-Durchlauf
        // Prüfen ob etwas im Empfangsregister liegt
        
        switch (RecievedCommand[0]){
            case 0x01:                             //  Setze Ports
                actInputPort = (int)RecievedCommand[1] ;
                actOutputPort = (int)RecievedCommand[2] +16;
                setGates();
                Flag_R_W = false;
                break;
                
            case 0x02:                             // Versions Ausgabe
                SendArray[0] = RecievedCommand[0];
                SendArray[1] = RecievedCommand[1];
                SendArray[2] = RecievedCommand[2];
                SendArray[3] = 0x01;          // Befehel OK 
                SendArray[4] = 0x56;          // V
                SendArray[5] = 0x31;          // 1
                SendArray[6] = 0x2E;          // .
                SendArray[7] = 0x30;          // 0
                SendArray[8] = 0x30;          // 0
                Flag_R_W = false;
                break;
            case 0x03:                             // Status Abfrage
                SendArray[0] = RecievedCommand[0];
                SendArray[1] = RecievedCommand[1];
                SendArray[2] = RecievedCommand[2];
                SendArray[3] = 0x01;          // Befehel OK 
                SendArray[4] = 0x00;          // 0
                SendArray[5] = 0x01;          // 1
                SendArray[6] = 0x00;          // 0
                SendArray[7] = 0x00;          // 0
                SendArray[8] = 0x00;          // 0
                Flag_R_W = false;
                break;
            case 0x04:                             // Selbsttest
                SendArray[0] = RecievedCommand[0];
                SendArray[1] = RecievedCommand[1];
                SendArray[2] = RecievedCommand[2];
                SendArray[3] = 0x01;          // Befehel OK 
                SendArray[4] = 0x00;          // 0
                SendArray[5] = 0x01;          // 1
                SendArray[6] = 0x00;          // 0
                SendArray[7] = 0x00;          // 0
                SendArray[8] = 0x00;          // 0
                Flag_R_W = false;
                break;
            case 0x05:                          // Softreset
                Softreset = true;
                SendArray[0] = RecievedCommand[0];
                SendArray[1] = RecievedCommand[1];
                SendArray[2] = RecievedCommand[2];
                SendArray[3] = 0x01;          // Befehel OK 
                SendArray[4] = 0x00;          // 0
                SendArray[5] = 0x00;          // 1
                SendArray[6] = 0x00;          // 0
                SendArray[7] = 0x00;          // 0
                SendArray[8] = 0x00;          // 0
                break;
            default:
                SendArray [0] = 0x00;
                SendArray [1] = 0x00;
                SendArray [2] = 0x00;
                SendArray [3] = 0x02;       // Fehler Befehl nicht bekannt
                SendArray [4] = 0xFF;
                SendArray [5] = 0xFF;
                SendArray [6] = 0xFF;
                SendArray [7] = 0xFF;
                SendArray [8] = 0xFF;
                Flag_R_W = true;
                break;
        }
        if (Flag_R_W){
            ERROR = USB_Read( RecieveLink, 1);
            
        }
        if (!Flag_R_W)
        {
            ERROR = USB_Write(SendLink ,1);
            RecievedCommand[0] = 0x00;
            RecievedCommand[1] = 0x00;
            RecievedCommand[2] = 0x00;
            
            
        }
    }

Vielleicht kann mir jemand einen Hinweis geben, wo ich noch suchen kann, 
oder wo der Fehler ist.
Schon mal vielen Dank im Voraus.
Grüße

[M. K. (sylaina)]

Hab mir jetzt nur Bilder angeschaut aber es sieht so aus als würde da 
was den Clock stretchen. Im 8. Clockcycle bleibt der Clock high.
Hardware ist richtig verdrahtet mit passenden Pull-Ups usw.? An der 
Software, denke ich, liegts nicht. Die arbeitet idR nicht zufällig ;)

[Vanye R. (vanye_rijan)]

> Software, denke ich, liegts nicht. Die arbeitet idR nicht zufällig ;)

Manchmal haut einem natuerlich ein IRQ darein. Aber das sollte I2C
abkoennen. Aber wohl nicht jede I2C Implementation kommt mit 
Clockstrechning
klar und man sollte unbedingt auch mal die Errata lesen. Gerade bei
I2C kann man da oft wunderliches finden.

Vanye

[Benjamin B. (benbu)]

An ein Stretching habe ich auch schon gedacht. Aber die Hardware ist 
korrekt aufgebaut. Das habe ich mehrfach kontrolliert. (auch 
Widerstände) Wenn ich die Abfrage nur ein mal pro sekunde mache hält er 
auch (zeitlich) länger durch. daher sieht es für mich so aus, dass er 
mit irgendetwas im Code zufällig "kollidiert". Ich weiß nur nicht was es 
sein könnte. Ich habe keine weiteren Intrrups oder ähnliches eingebaut.

[Patrick C. (pcrom)]

Bist du sicher das de FT200XD als SLAVE zu benutzen ist ?
...Und ist er auch as SLAVE initialisiert ?

Weiter gibt es vielleicht noch Hinweise zu sehen wenn man die SDA und 
SCL analog messt ? Oft sieht man da am Spannungsniveau wann ob der SDA 
von Master oder Slave bedient wird.

[Vanye R. (vanye_rijan)]

> Ich habe hier mal zwei Bilder, die den Vorgang zeigen.

Das stimmt uebrigens nicht. Das sind Bilder von einem Logicanalyzer
dem Luegenstift der Programmierer. Bei so Lowlevelproblemen solltest
du ein Oszi nehmen um die Signale analog zu sehen.

Bei komplexen Problemen kann es hilfreich sein die GND beider ICs
ueber einen kleinen Widerstand zu verbinden an dem 0.2V oder sowas
abfaellt. Dann kannst du auf dem Oszi sehen wer wirklich deine
Leitung gerade nach unten zieht und entscheiden ob du das so erwartest.

Vanye

[Sebastian W. (wangnick)]

M. K. schrieb:
> Hab mir jetzt nur Bilder angeschaut aber es sieht so aus als würde da
> was den Clock stretchen.

Die I2C-Clock wird low gestretcht. Das ist es nicht.

Mir sieht es eher danach aus, als ob die I2C-Logik des PIC während einer 
noch andauernden Übertragung von den Pins getrennt würde.

Was genau macht setGates()?

LG, Sebastian

[Rainer W. (rawi)]

Patrick C. schrieb:
> Oft sieht man da am Spannungsniveau wann ob der SDA von Master oder
> Slave bedient wird.

Ganz sicher sieht man es, wenn man jeweils einen Widerstand in die SDA- 
und in die SCL-Leitung einschleift.

[Benjamin B. (benbu)]

Hallo Leute
Ich habe den Fehler gefunden.
Es lag an dem FT200XD dort gibt es einen Pin, der variabel genutzt 
werden kann. Diesen habe ich nach vorschlag der Dokumentation 
verdrahtet.
Ich habe ihn dann gestern mal umverdrahtet und ihm eine Funktion 
gegeben. Damit läuft es jetzt.
Im Anhang ist der Auzug aus dem Datenblatt.

Aber danke für die vielen Ideen. Durch diese habe ich an der richtigen 
Stelle gesucht.