I2C Problem wahrscheinlich Code fehler!?

[Tobias N. (silberkristall)]

Ich habe einen ATMega128A mit einem EDIPTFT Touch Display via I2C 
verbunden. 2 Pullup widerstände von 4,7k pullen die I2C Leitungen.

Für das Display habe ich mir zwei funktionen erstellt. Das Senden 
funktioniert. Das Lesen nicht.

display.h

unsigned char SendDisplayData(char *buf);
unsigned char ReadDisplayData(void);
void DisplayReset(void);
unsigned char ReadDisplayBufferStatus(void);
void DisplayInit(void);

unsigned char *buf;

display.c

#include <stdint.h>
#include <string.h>
#include <i2c.h>
#include <util/delay.h>
#include <stdlib.h>
#include <display.h>
#include <avr/io.h>

void DisplayInit(void)
{
  // Reset Pin
  DDRD |= (1<<PD3);
  PORTD &= ~(1<<PD3);
  // SBUF Pin
  DDRD &= ~(1<<PD2);
  PORTD &= ~(1<<PD2);
}

unsigned char SendDisplayData(char *buf)
{
    unsigned int len = strlen(buf);
    unsigned char i, bcc, ret;
  int daten = 0;
    ret = i2c_start(DISPLAY_I2C_ADDR+I2C_WRITE);       // set device address and write mode
    if ( ret ) {
        /* failed to issue start condition, possibly no device found */
        i2c_stop();
        /* do some error reporting.. led or whatever */
    } else {
        /* issuing start condition ok, device accessible */
        i2c_write(0x11);                            // send DC1
        bcc = 0x11;
        i2c_write(len);
        bcc = bcc + len;
        for(i=0; i < len; i++) // Send buf
        {
            i2c_write(buf[i]);
            bcc = bcc + buf[i];
        }
        i2c_write(bcc); // Send checksum                      
        i2c_start(DISPLAY_I2C_ADDR+I2C_READ);       // set device address and read mode
        ret = i2c_readNak();                        // read one byte
        if (ret == DISPLAY_I2C_ACK)
        {
            daten = 1;
        } else {
            daten = 0;
        }
        i2c_stop();
    }
  return daten;
}



    unsigned char ReadDisplayData(void)
    {
        unsigned char bcc, ret, rettemp;
        unsigned char len = 2;
        ret = i2c_start(DISPLAY_I2C_ADDR+I2C_WRITE);      // set device address and write mode
        if ( ret ) {
            /* failed to issue start condition, possibly no device found */
            i2c_stop();
            /* do some error reporting.. led or whatever */
        } else {
            /* issuing start condition ok, device accessible */
            i2c_write(DISPLAY_I2C_DC2); // send DC2
            i2c_write(0x01);            // send 1
            i2c_write(0x53);            // send S
            bcc = DISPLAY_I2C_DC2 + 0x01 + 0x53;                // Set checksum
            i2c_write(bcc);            // Send checksum 
            bcc = 0;
            i2c_start(DISPLAY_I2C_ADDR+I2C_READ);      // set device address and read mode
            ret = i2c_readAck();                        // read ack byte
            if (ret == DISPLAY_I2C_ACK)
            {
                rettemp = i2c_readAck();
                bcc = bcc + rettemp;
                ret = i2c_readAck();            // read len
                bcc = bcc+ret;
                unsigned char *buf = malloc(ret * sizeof(char));
                len += ret;
                for (int i = 0; i < ret; i++)
                {
                    buf[i] = i2c_readAck(); // read data bytes
                    bcc = bcc + buf[i];
                }
                ret = i2c_readNak();    // read len
                if (ret != len) {
                    // Checksum not matching
                }
                return buf;
            } else {
                // No Ack
            }
            i2c_stop();
           
        }
        return 0;
    }

void DisplayReset(void)
  {
    PORTD &= ~(1<<PD3);
    PORTD &= ~(1<<PD3);
    PORTD &= ~(1<<PD3);
    PORTD |= (1<<PD3);
    
  }

unsigned char ReadDisplayBufferStatus(void)
  {
    int DisplayBufferStatus;
    if ( !(PIND & (1<<PIND2)) )
      {
        DisplayBufferStatus = 1;
      }
      else
      {
        DisplayBufferStatus = 0;
      }
      
    return DisplayBufferStatus;
  }

Das Display bekommt die Daten

SendDisplayData("#DL,");

in diesem format übermittelt.

Bei Touch eingaben legt das Display bei Daten im Sendebuffer einen PIN 
auf LOW. Diese abfrage funktioniert ebenfalls.

Sobald ich allerdings nun daten lesen will:

 readdata = ReadDisplayData();

stürzt nun entweder der µC ab oder aber ich bekomme zwar daten, mit 
denen sich allerdings nichts anfangen kann.

Ich erhalte dann z.b. Daten wie folgt: 217 1 255 1 193 1 141 1 ....

Immer eine 1 zwischen den Zahlen. Jedoch passen die Zahlen auch nicht. 
Also das Display würde ebenfalls wie man sendet antworten. Also z.b. mit

#TB1,0 oder halt mit den Dezimalzahlen 23 (für Escape, #) allerdings ist 
das erste zeichen eine völlig andere Zahl.

Ich verzweifel.

Kann mir da jemand weiter helfen?

[Tobias N. (silberkristall)]

Keiner eine Idee?

[Sascha W. (sascha-w)]

Hallo,

ich bin zwar nicht gerade der C-Programmierer, aber dein malloc und die 
Übergabe des Puffers scheint mir etwas zweifelhaft.
Gib doch die empfangenen Werte erst mal direkt aus der Schleife z.B. per 
UART aus. Da die Länge der Daten die das Display maximal zurückliefern 
kann doch sicher bekannt ist ist es besser gleich einen festen Puffer zu 
definieren.

Sascha

[jo (Gast)]

>unsigned char *buf = malloc(ret * sizeof(char));

warum dynamisch? und warum gibst du den speicher nicht wieder frei?

Gruß Jonas

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Und warum beachtest Du nicht die Warnungen, die Dir der Compiler um die 
Ohren haut? Oder hast Du die etwa deaktiviert?

Der ganze Code sieht so aus, als hättest Du ihn irgendwo kopiert und 
beim Zusammenpfuschen überhaupt nicht verstanden, wie er funktioniert.

[Tobias N. (silberkristall)]

Beide, also Send und Read wurden mir geschrieben, daher verstehe ich das 
ganze generell nicht.

Das Send geht wie gesagt. Ich kann halt nur so das nötigste in C.

Es ging mal, dann wurde aber das ack im read nicht genommen. Dann hat er 
den code nochmal für mich abgeändert, seither klappt das nicht mehr.

Da ja das Send geht und das Read auch (also der Buffer ist dann wieder 
leer im Display) muss es am Code liegen.

[Tobias N. (silberkristall)]

So,

ich habe jetzt mal ein wenig rumprobiert. Keine Chance. Wenn ich dich 
speicher hinterher mit free wieder lösche stürzt der µC direkt ab. Keine 
Chance was zu bewirken.

Und sonst bekomme ich halt nur utopische Daten.

Ich verzweifel :( Senden geht, empfangen naja, nur teilweise.

[Karl H. (kbuchegg)]

Das

unsigned char ReadDisplayData(void)
{
...
                unsigned char *buf = malloc(ret * sizeof(char));

...
                return buf;

hast du so nie und nimmer durch den Compiler gebracht.
Ein Pointer auf unsigned char ist kein unsigned char. Die Funktion will 
aber einen unsigned char zurückgeben und keinen Pointer.

[Tobias N. (silberkristall)]

Problem gelöst. Zwischen jedem lesenden Byte 6us warten und es klappt 1A