EDIPTFT70 I2C, ich kriege es einfach nicht hin

Keiner eine Idee?

Ich werde daraus einfach nicht schlau. :(

Aus dem Code kann auch keiner schlau werden... wichtig sind natürlich 
auch die Teile, wo du diese low-level-Funktionen tatsächlich aufrufst.

Nunja, das ist ja auch nur mein I2C Code also die funktionen Start, Stop 
usw.

Ich verstehe halt den Punkt von EA nicht. Ich muss das ja in dieses 
Protokoll verpacken aber da scheitert es dann.

$DE  <-- was ist das für eine Adresse? und dann mit diesem len und bcc, 
ich muss die länge bestimmen, die prüfsumme, das verstehe ich alles 
nicht

Also um die Adresse zusenden müsste es ja dann so sein:

i2c_start();
i2c_send($DE | TW_WRITE);

aber da fängt es dann schon an, $DE ist hier schon ein fehler. Und wie 
berechne ich die länge und die Prüfsumme? wie kriege ich aus dem 
SmartProtokoll daten, die immer mit einem # beginnen und dann der Code, 
also z.b. #DL nun das ich das senden kann, also die länge, die prüfsumme 
usw?

Autsch...

Du kannst aber C grundsätzlich? Weil mich die Frage "$DE ist hier schon 
ein fehler" verwirrt, weil

1

i2c_send($DE | TW_WRITE);

auch kein C ist...

$DE ist ja laut datenblatt die adresse des Displays zum senden und $DF 
die Adresse des Displays zum lesen, nunja, EA macht es da nicht gerade 
einfach.

Was heisst ich kann C grundsätzlich? Also sagen wir mal so, ich komme 
klar mit dem was ich bisher so brauchte.

Coder schrieb:
> $de ist wohl eine hex-Zahl.

Ich weiss das wohl, aber weiss das der Compiler?

Tobias N. schrieb:
> Was heisst ich kann C grundsätzlich? Also sagen wir mal so, ich komme
> klar mit dem was ich bisher so brauchte.

Nicht böse sein, aber: offensichtlich nicht.

eine hex-Konstante schreibt man 0xde, aber nicht $de

Hallo,

Bzgl. dem Small-Protokoll kann Ich Dir weiterhelfen. Ich habe mit diesem 
am Anfang auch meine Probleme gehabt. Die Prüfsumme "bcc" wird auf der 
Seite 10 erläutert. Dort wird zwar die Übertragung als Funktion 
aufgeführt. dein $ gibt ja an, wie bereits erwähnt, dass dieses ein 
HEX-Wert ist. Wenn Du das EDIPTFT mit der Demoplatine hast, dann kannst 
Du über einen Jumper das Small-Protokoll zu testzwecken abschalten und 
erst einmal die Übertragung probieren. Wenn dieses funktioniert, dann 
versuche das Protokoll zu verwenden.

Ich habe hier auch das 70'er Display und steuere dieses via UART an. 
Hier habe Ich auch als erstes das Protokoll abgeschaltet und nach 
erfolgreichen Ansprechen, dieses nach der Vorlage im Datenblatt 
eingepflegt.

nunja, ich habe halt das prob das ich es nicht hinbekomme die länge und 
die prüfsumme zu errechnen etc. pp.

$DE wäre ja 11011110, bzw 1101111 und die 0 als "write" $DF = 11011111 
bzw. 1101111 und die 1 also read, also wäre die 7 Bit Adresse des 
Displays 1101111 ok, soweit so gut aber es geht ja um das genaue Senden 
da EA ja auf seine Prüfsumme etc. besteht.

Auf der Seite von EA gibt es ein Code Beispiel...

Tobias N. schrieb:
> nunja, ich habe halt das prob das ich es nicht hinbekomme die
> länge und
> die prüfsumme zu errechnen etc. pp.
>
> $DE wäre ja 11011110, bzw 1101111 und die 0 als "write" $DF = 11011111
> bzw. 1101111 und die 1 also read, also wäre die 7 Bit Adresse des
> Displays 1101111 ok, soweit so gut aber es geht ja um das genaue Senden
> da EA ja auf seine Prüfsumme etc. besteht.

Bekonnst Du denn überhaupt eine Übertragung zum Display hin, denn Seite 
10 steht ja: "Für Tests kann das Protokoll durch L-Pegel an
Pin17(DPROT) abgeschaltet werden"

Für das Small-Protokoll wird dann folgendes gemacht:

<DC1> + Länge des gesendeten Befehls + Byte-Wert des jeweiligen 
ASCII-Zeichens modulo 256

Bedeutet für "#DL," (Mit Komma):

<DC1> = 11h = 17d
Länge des Befehls "#DL," = 4
# = 23h = 35d
D = 44h = 68d
L = 4Ch = 76d
, = 2Ch = 44d

Insgesamt: F4h = 244d

Wieso mit komma? In dem programm von ea für das Display schreibe ich es 
auch ohne komma.

Woran soll ich denn erkennen ob ich eine verbindung bekomme?

i2c_start();
i2c_send(11011110);

Nur ob das display nun antwortet, kA.

Tobias N. schrieb:
> Wieso mit komma? In dem programm von ea für das Display schreibe
> ich es
> auch ohne komma.
>
> Woran soll ich denn erkennen ob ich eine verbindung bekomme?
>
> i2c_start();
> i2c_send(11011110);

Indem du die Antwort ausliest?

Tobias N. schrieb:
> $DE  <-- was ist das für eine Adresse? und dann mit diesem len und bcc,
> ich muss die länge bestimmen, die prüfsumme, das verstehe ich alles
> nicht

Ist zwar kein I2C-Bus, sondern UART, vielleicht hilft dir das:

1

/********************************************************************************

2

* Interrupt S-BUF bei negativer Flanke, bei low Buffer auslesen

3

*********************************************************************************/

4

void __attribute__((__interrupt__,no_auto_psv)) _INT0Interrupt ()

5

 {   

6

    IFS0bits.INT0IF = 0;         // clear Interrupt flag 

7

8

    SYSTEM_FLAG.bits.buffer = VOLL;

9

10

11

12

}

13

14

/********************************************************************************

15

* U3RX Interrupt 

16

*********************************************************************************/

17

void __attribute__((__interrupt__,no_auto_psv)) _U3RXInterrupt(void)

18

{

19

20

  IFS5bits.U3RXIF = 0; // clear RX interrupt flag

21

22

/* Check for receive errors */

23

  if(U3STAbits.FERR == 1)

24

   {

25

    }

26

/* Must clear the overrun error to keep UART receiving */

27

  if(U3STAbits.OERR == 1)

28

    {

29

    U3STAbits.OERR = 0;

30

    }

31

   /* Get the data */

32

    if(U3STAbits.URXDA == 1)

33

     {

34

       ReceivedData[bytes] = U3RXREG;

35

       bytes++;

36

     }

37

38

39

}

1

//------- neue Daten werden abgefragt  -------------

2

if ( SYSTEM_FLAG.bits.buffer == VOLL )

3

{

4

     SYSTEM_FLAG.bits.buffer = LEEREN;

5

     SendeBuffer_anfordern();

6

}

1

/********************************************************************************

2

 *                                                                              *

3

 *  Funktion:      SendeBuffer_anfordern                                         * 

4

 *                                                                              *

5

 *------------------------------------------------------------------------------*

6

 *  Description: 

7

 ********************************************************************************/

8

void SendeBuffer_anfordern (void)

9

{

10

 unsigned char bcc;

11

 unsigned int j;

12

13

  U3TXREG = DC2; // Send DC2

14

  while(U3STAbits.UTXBF == 1);

15

16

  bcc = DC2;

17

18

  U3TXREG = 0x01; // Send 1

19

  while(U3STAbits.UTXBF == 1);

20

21

  bcc = bcc + 0x01;

22

23

  U3TXREG = 0x53; // Send S

24

  while(U3STAbits.UTXBF == 1);

25

26

  bcc = bcc + 0x53;

27

28

  U3TXREG = bcc; // Send bcc = checksumme

29

  while(U3STAbits.UTXBF == 1);

30

31

32

   delay_ms(10); //

33

34

35

         ack_edip = ReceivedData[0];

36

         paket_laenge_edip = ReceivedData[2]; 

37

         checksumme_edip = ReceivedData[paket_laenge_edip + 3];

38

39

40

41

         checksumme_edip_tmp = ReceivedData[1];

42

         checksumme_edip_tmp = checksumme_edip_tmp + ReceivedData[2];

43

44

45

         for(j=0; j < paket_laenge_edip; j++) //

46

            { 

47

              checksumme_edip_tmp = checksumme_edip_tmp + ReceivedData[j + 3];

48

            }

49

50

         if (checksumme_edip_tmp != checksumme_edip)

51

            {

52

             SYSTEM_FLAG.bits.paket_error = 1;

53

            } 

54

         else

55

            {

56

             SYSTEM_FLAG.bits.neues_comando = 1;

57

            }

58

59

         for (j=0; j< 10; j++)

60

           {

61

            ReceivedCommand[j] = 0; //mit 0 fuellen

62

           }

63

64

65

         for (j=0; j< paket_laenge_edip; j++)

66

           {

67

           ReceivedCommand[j] =  ReceivedData[j+3];

68

           }

69

70

 if (SYSTEM_FLAG.bits.neues_comando == 1)

71

  {

72

   touch_dekodieren();

73

   }

74

75

  bytes = 0;

76

77

}

1

#include <avr/stdio.h> 

2

#include <avr/string.h>

3

4

void SendDisplayData(unsigned char *buf) 

5

{ 

6

unsigned int len = strlen(buf); 

7

unsigned char i, bcc;

8

i2c_start();

9

i2c_send(11011110); // Addr + write

10

i2c_send(0x11); // Send DC1 

11

bcc = 0x11; 

12

i2c_send(len); // Send data length 

13

bcc = bcc + len; 

14

for(i=0; i < len; i++) // Send buf 

15

{ 

16

i2c_send(buf[i]); 

17

bcc = bcc + buf[i]; 

18

} 

19

i2c_send(bcc); // Send checksum 

20

I2c_stop();

21

} 

22

23

int main(void) 

24

{ 

25

SendDisplayData("#DL"); 

26

}

So sollte das jetzt eigentlich funktionieren. Hab es noch nicht 
getestet.

Hallo,
wie oben schon beschrieben #DL entspricht in C: 0x1B 0x44 0x4C.
Dann klappt es auch mit deinem Display. Ich habe es allerdings auch mit 
der seriellen Schnittstelle angesprochen, weil es einfacher ist.
Bernd

gcc -o test test.c && ./test
00010001- 0x11 - ''
00000011- 0x3 - ''
00100011- 0x23 - '#'
01000100- 0x44 - 'D'
01001100- 0x4c - 'L'
11000111- 0xc7 - '�'

Ich habe so ein kleines c programm bekommen das gibt mir diese ausgabe.

1

#include <stdio.h>

2

#include <string.h>

3

4

void show_binary(unsigned int u) {

5

    int n;

6

    for( n = 128; n > 0; n = n / 2 )

7

    if(u & n)

8

                printf("1");

9

    else

10

                printf("0");

11

}

12

13

void SendByte(unsigned char c)

14

{

15

        show_binary(c);

16

        printf("- 0x%x - '%c'", c, c);

17

        printf("\n");

18

}

19

20

void SendData(unsigned char *buf)

21

{

22

        unsigned int len = strlen(buf);

23

        unsigned char i, bcc;

24

        SendByte(0x11); // Send DC1

25

        bcc = 0x11;

26

        SendByte(len); // Send data length

27

        bcc = bcc + len;

28

        for(i=0; i < len; i++) // Send buf

29

        {

30

                SendByte(buf[i]);

31

                bcc = bcc + buf[i];

32

        }

33

        SendByte(bcc); // Send checksum

34

}

35

36

int main(void)

37

{

38

        SendData("Toll");

39

}

also das ist das ganze programm. das gibt mir halt das was ich da rein 
schreibe in binär hex etc aus.

was stimmt denn nun? was muss ich dem display nun senden?

Tobias N. schrieb:

> was stimmt denn nun? was muss ich dem display nun senden?

Das ist eigentlich die falsche Frage.
Die eigentliche Frage lautet doch "Wie sag ichs meinem C-Compiler"

Denn wenn du eine Binärzahl hast, dann schreibt sich das im gcc nun mal 
als

1

  i2c_send( 0b11011110 );

und nicht als

1

  i2c_send(11011110);

Aber:
warum schreibst du es denn nicht als

1

  i2c_send( 0xDE );

ist doch viel einfacher zu lesen und stimmt dann auch beiläufig auch 
noch mit dem $DE aus dem Datenblatt überein.

>

1

> 00010001- 0x11 - ''

2

> 00000011- 0x3 - ''

3

> 00100011- 0x23 - '#'

4

> 01000100- 0x44 - 'D'

5

> 01001100- 0x4c - 'L'

6

> 11000111- 0xc7 - '�'

1

  i2c_start();

2

3

  i2c_send( 0xDE );   // Adresse

4

5

// jetzt die Daten vom Small Protokoll

6

7

  i2c_send( 0x11 );   // DC1

8

  i2c_send( 0x03 );   // Länge der Daten

9

  i2c_send( 0x23 );   // #

10

  i2c_send( 0x44 );   // D

11

  i2c_send( 0x4c );   // L

12

  i2c_send( 0xC7 );   // und noch die Prüfsumme

13

14

// und aus

15

  i2c_stop();

Wenn deine I2C Routinen funktionieren und die Busanbindung korrekt ist, 
hast du soeben "#DL' zum DIsplay übertragen.
Natürlich wird man sich dann eine Funktion schreiben (bzw. aus dem 
Datenblatt übernehmen), die den Teil "String Ausgabe im Small Protokoll" 
übernimmt und dazu die Länge bzw. die Prüfsumme bestimmt und die dann 
aufrufen

1

  i2c_start();

2

3

  i2c_send( 0xDE );

4

  i2c_send_data( "#DL" );

5

6

  i2c_stop();

aber im Grunde passiert da auch nichts anderes. Nur das diesmal eben die 
i2c_send_data das DC1 einfügt, die Länge einfügt und die Prüfsumme 
bestimmt.

na wenn das geht ist das doch tutti :)

Also übergebe ich den Code dann halt nicht als Binärzahl sondern so wie 
mir das Programm das dann ausgibt mit den 0x ausgaben?

da ist ja dann die länge, die prüfsumme usw mit dabei!?

du meinst sowas in der art wie ich weiter oben schon gepostet habe, nur 
nicht mit den Binärzahlen sondern mit den 0x werten?

Tobias N. schrieb:
> du meinst sowas in der art wie ich weiter oben schon gepostet habe, nur
> nicht mit den Binärzahlen

Immer noch nicht.

Du hattest keine Binärzahlen.
Das hier

1

  i2c_send( 11011110 );

ist keine Binärzahl. Das ist eine Dezimalzahl, die zufällig nur aus 
lauter 1-en und 0-en aufgebaut ist. So wie eben 10 (zehn) aus einer 1 
und einer 0 besteht oder 11 (elf) aus 2 STück 1-ern oder ein tausend 
einhundert und elf sich als 1111 schreibt.

11011110 ist die Dezimalzahl 11 Millionen 11 Tausend und 1 Hundert Zehn.

Tobias N. schrieb:
> was stimmt denn nun? was muss ich dem display nun senden?

steht doch im Datenblatt, ist dir eigentlich bewusst das du diese 
EDIPTFT70 ohne Peripherie steuern kannst, es stehen ein Editor und 
Compiler zur Verfügung, damit kannst du Menüs, Touchbars, Bilder uvm 
aufbauen (es stehen glaube ich um 4MB zur Verfügung), und später über zB 
µC steuern.

Du kannst auch direkt an Computer anschließen (Pegelwandler nicht 
vergessen) und per UART ansprechen.

Hier mal Textausgabe für EDIPTTFT70:

1

/********************************************************************************

2

 *                                                                              *

3

 *  Funktion:      text_ausgeben                                                * 

4

 *                                                                              *

5

 *------------------------------------------------------------------------------*

6

 *  Description: 

7

 ********************************************************************************/

8

9

void text_ausgeben (int xPos, int yPos, char text_position, const char* text)

10

{

11

 unsigned char bcc;

12

 unsigned int j, i;

13

 unsigned char xPos_low, xPos_high, yPos_low, yPos_high, anzahl_zeichen;

14

15

 xPos_low = xPos;

16

 xPos_high = xPos >> 8; 

17

18

 yPos_low = yPos;

19

 yPos_high = yPos >> 8;

20

21

 anzahl_zeichen = strlen(text);

22

23

  U3TXREG = DC1;    // Send DC1

24

  while(U3STAbits.UTXBF == 1);

25

  bcc = DC1;

26

27

  U3TXREG = anzahl_zeichen + 8;      // 

28

  while(U3STAbits.UTXBF == 1);

29

  bcc = bcc + anzahl_zeichen + 8;

30

31

  U3TXREG = 0x1B;   //ESC senden

32

  while(U3STAbits.UTXBF == 1);

33

  bcc = bcc + 0x1B;

34

35

  U3TXREG = 'Z';   //Befehle zur Ausgabe von Zeichenketten

36

  while(U3STAbits.UTXBF == 1);

37

  bcc = bcc + 'Z';

38

39

  U3TXREG = text_position; // L: Linksbьndig, C: Zentriert, R: Rechtsbьndig

40

  while(U3STAbits.UTXBF == 1);

41

  bcc = bcc + text_position;

42

43

  U3TXREG = xPos_low; // xPosiotion low byte ausgeben

44

  while(U3STAbits.UTXBF == 1);

45

  bcc = bcc + xPos_low;

46

47

  U3TXREG = xPos_high; // xPosiotion high byte ausgeben

48

  while(U3STAbits.UTXBF == 1);

49

  bcc = bcc + xPos_high;

50

51

  U3TXREG = yPos_low; // yPosiotion low byte ausgeben

52

  while(U3STAbits.UTXBF == 1);

53

  bcc = bcc + yPos_low;

54

55

  U3TXREG = yPos_high; // yPosiotion high byte ausgeben

56

  while(U3STAbits.UTXBF == 1);

57

  bcc = bcc + yPos_high;

58

59

    for(i=0; i < anzahl_zeichen; i++) // Sende alle Zeichen

60

      { 

61

       U3TXREG = text[i]; // 

62

       while(U3STAbits.UTXBF == 1);

63

64

      bcc = bcc + text[i];

65

     }

66

67

  U3TXREG = 0; // Ende des Paketes NUL' ($00),

68

  while(U3STAbits.UTXBF == 1);

69

  bcc = bcc + 0;

70

71

  U3TXREG = bcc; // errechnete Checksumme senden

72

  while(U3STAbits.UTXBF == 1);

73

74

  delay_ms(1);

75

76

77

         for (j=0; j< 65000; j++)  // auf ACK warten

78

           {

79

            if ( ReceivedData[0] == ACK )

80

             {

81

              j=65000;

82

              ack_edip = ReceivedData[0];

83

              ReceivedData[0] = 0;

84

             }

85

            else

86

             {

87

              SYSTEM_FLAG.bits.ack_error = 1;

88

             } 

89

           }

90

91

  bytes = 0;

92

93

}

Ja, ich habe ja Menüs, Bargraphen usw. Ich will ja die Werte übergeben 
per UC und halt auch werte per Display ändern usw.

Das #DL will ich halt erstmal zum Testen senden um zu sehen ob überhaupt 
was geht. Wenn ich den COde so sende wie von Karl Heinz dann löscht sich 
das Display also muss ich jetzt halt nur noch eine Routine dafür haben.

1

void SendDisplayData(char *buf)

2

    {

3

            unsigned int len = strlen(buf);

4

            unsigned char i, bcc;

5

            i2c_start();

6

            i2c_send(0xDE); // Addr + write

7

            i2c_send(0x11); // Send DC1

8

            bcc = 0x11;

9

            i2c_send(len); // Send data length

10

            bcc = bcc + len;

11

            for(i=0; i < len; i++) // Send buf

12

            {

13

                    i2c_send(buf[i]);

14

                    bcc = bcc + buf[i];

15

            }

16

            i2c_send(bcc); // Send checksum

17

            i2c_stop();

18

    }

so läuft das ganze. Jetzt muss ich nur noch das mit dem ACK hinkriegen.

Also ich hänge da noch bei den variablen fest.

Also wenn ich

char[25] = Buffer;
itoa(fototrans,Buffer,10);

SendDisplayData("#ZF8,0,ADC-Wert: Buffer,");

sende dann schreibt der mir auf das Display "Buffer" aber nicht den wert 
von fototrans. fototrans ist der ADC Wert von einem Fotowiderstand.

Wie kriege ich denn nun einen variablen Wert darein?

Tobias N. schrieb:
> Also ich hänge da noch bei den variablen fest.
>
> Also wenn ich
>
> char[25] = Buffer;
> itoa(fototrans,Buffer,10);
>
> SendDisplayData("#ZF8,0,ADC-Wert: Buffer,");
>
> sende dann schreibt der mir auf das Display "Buffer"

Logisch.
Nur weil du einen String hast

1

   "#ZF8,0,ADC-Wert: Buffer,"

in dem ein Wort vorkommt, das gleichlautend mit einer deiner Variablen 
ist, wird ja nicht im String dieses Wort durch den Inhalt der Variablen 
ersetzt. String ist String und der Compiler vergreift sich nicht daran. 
Wenn du den Text "Buffer" aufs LCD schreiben willst, dann hindert dich 
nichts und niemand daran.

> aber nicht den wert
> von fototrans. fototrans ist der ADC Wert von einem Fotowiderstand.
>
> Wie kriege ich denn nun einen variablen Wert darein?

Du könntest zum Beispiel deine Ausgabe auf 2 oder 3 mal machen. Sagt ja 
keiner, dass du nicht mehrere Texte hintereinander ausgeben darfst.
Einmal schickst du per SendDisplayData den Fixtext und beim 2.ten Aufruf 
schiebst du den von dir ermittelten String vom Zahlenwert hinten nach

1

  itoa(fototrans,Buffer,10);

2

3

  SendDisplayData("#ZF8,0,ADC-Wert: ");

4

  SendDisplayData(Buffer);

5

  SendDisplayData(",");

du kannst auch alles in einem Aufwasch machen, indem du den String 
gleich komplett richtig erzeugst

1

  sprintf( Buffer, "#ZF8,0,ADC-Wert: %d,", fototrans );

2

  SendDisplayData( Buffer );

sprintf bietet sich zb dann an, wenn Speicherverbrauch keine Rolle 
spielt und man von den Formatiermöglichkeiten der printf Funktionen 
Gebrauch machen kann.

Karl Heinz schrieb:

> Du könntest zum Beispiel deine Ausgabe auf 2 oder 3 mal machen. Sagt ja
> keiner, dass du nicht mehrere Texte hintereinander ausgeben darfst.

(*)
wobei.
Da bin ich mir jetzt nicht sicher, wie das LCD die Sache da sieht, bzw. 
was die Bedeutung von #ZF8,0 ist.
Im schlimmsten Fall muss man dann eben tatsächlich 2 Textausgaben 
anleiern, wenn das LCD das nicht akzeptiert, dass es einen Text in 2 
Happen bekommt.

so wie das mit dem sprintf habe ich es gesucht. Mehrfach schieben geht 
nicht bzw nicht so da durch die funktion immer ein kompletter befehl 
gesendet werden muss da ja in der funktion i2c gestartet und gestopt 
wird. Würde ich das so schreiben, also das buffer versuchen 
nachzuschieben sendet das display mir einen nack dann müsste ich die 
funktion wohl umbasteln. Wiederrum könnte ich das sprintf ja in die 
funktion bauen, oder?

In wieweit ich speicher brauche weiss ich erst wenn alles fertig ist.

Karl Heinz schrieb:
> Karl Heinz schrieb:
>
>> Du könntest zum Beispiel deine Ausgabe auf 2 oder 3 mal machen. Sagt ja
>> keiner, dass du nicht mehrere Texte hintereinander ausgeben darfst.
>
> (*)
> wobei.
> Da bin ich mir jetzt nicht sicher, wie das LCD die Sache da sieht, bzw.
> was die Bedeutung von #ZF8,0 ist.
> Im schlimmsten Fall muss man dann eben tatsächlich 2 Textausgaben
> anleiern, wenn das LCD das nicht akzeptiert, dass es einen Text in 2
> Happen bekommt.

Max 256byte danach muss der string geteilt werden. Dem display kann man 
schieben und schieben (laut datenblatt). Nur schicke ich lieber befehl 
nach befehl und bin mir da auf der sicheren seite bei meinem derzeitigen 
kenntnis stand.

Tobias N. schrieb:

> nicht bzw nicht so da durch die funktion immer ein kompletter befehl
> gesendet werden muss

Das ist mir etwas zu spät geschwant :-)

Wenn du auf itoa stehst, dann kannst du natürlich auch vorher den String 
komplett zusammensetzen. strcat und strcpy sind deine Freunde.

1

  char buffer[15];

2

  char total[40];

3

4

  itoa( fototrans, Buffer, 10 );

5

6

  strcpy( total, "#ZF8,0,ADC-Wert: " );

7

  strcat( total, Buffer ),

8

  strcat( total, "," );

9

10

  SendDisplayData( total );

> funktion wohl umbasteln. Wiederrum könnte ich das sprintf ja in die
> funktion bauen, oder?

Wer oder was sollte dich daran hindern?
Du bist der Programmierer. Auf deinem µC bist du Gott und machst dir die 
Welt, so wie sie dir gefällt und du sie für richtig hältst.