Forum: Mikrocontroller und Digitale Elektronik EDIPTFT70 I2C, ich kriege es einfach nicht hin


von Tobias N. (silberkristall)


Lesenswert?

Hallo,

ich habe ein EDIPTFT70 ATP, hier mal das Datenblatt:

http://www.lcd-module.de/fileadmin/pdf/grafik/ediptft70-a.pdf

Auf Seite 10 ist das übertragungsprotokoll beschrieben. Ich kapiere es 
aber einfach nicht. Kann mir da mal jemand helfen?

Als Code müsste z.b. gesendet werden: #DL

Das würde den Displayinhalt löschen.

Die Adresse zum schreiben lautet $DE und zum lesen $DF (Datenblatt Seite 
7, alle PINs offen)

Ich bekomme einfach keine komunikation hin.

Hier mal mein I2C Code.
1
// I2C
2
3
void i2c_start(void)
4
{
5
  TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN);
6
  while ((TWCR & _BV(TWINT)) == 0);
7
}
8
9
void i2c_stop(void)
10
{
11
  TWCR = _BV(TWINT) | _BV(TWSTO) | _BV(TWEN);
12
}
13
14
void i2c_send(uint8_t DataByte)
15
{
16
  TWDR = DataByte;
17
  TWCR = _BV(TWINT) | _BV(TWEN);
18
  while ((TWCR & _BV(TWINT)) == 0);
19
}
20
21
uint8_t i2c_recive(uint8_t ack)
22
{
23
  if (ack == 1)
24
    TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN);
25
  else
26
    TWCR = _BV(TWINT) | _BV(TWEN);
27
  while ((TWCR & _BV(TWINT)) == 0);
28
  return TWDR;
29
}
30
31
// I2C Ende

Ich danke euch.

: Verschoben durch User
von Tobias N. (silberkristall)


Lesenswert?

Keiner eine Idee?

Ich werde daraus einfach nicht schlau. :(

von Michael R. (Firma: Brainit GmbH) (fisa)


Lesenswert?

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

von Tobias N. (silberkristall)


Lesenswert?

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?

von Michael R. (Firma: Brainit GmbH) (fisa)


Lesenswert?

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...

von Coder (Gast)


Lesenswert?

$de ist wohl eine hex-Zahl.

von Tobias N. (silberkristall)


Lesenswert?

$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.

von Michael R. (Firma: Brainit GmbH) (fisa)


Lesenswert?

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

von Coder (Gast)


Lesenswert?

Dein c Kung fu ist noch nicht stark genug.

von Sebastian H. (technik_freak)


Lesenswert?

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.

von Tobias N. (silberkristall)


Lesenswert?

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.

von Peter Z. (hangloose)


Lesenswert?

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

von Sebastian H. (technik_freak)


Lesenswert?

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

von Tobias N. (silberkristall)


Lesenswert?

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.

: Bearbeitet durch User
von Simon K. (simon) Benutzerseite


Lesenswert?

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?

von Hermann U. (Firma: www.pcb-devboards.de) (gera82)


Lesenswert?

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
}

: Bearbeitet durch User
von Tobias N. (silberkristall)


Lesenswert?

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.

: Bearbeitet durch User
von Flohzirkus (Gast)


Lesenswert?

Wird es aber nicht.


Tobias N. schrieb:
> i2c_send(11011110); // Addr + write

Es sei denn, du willst wirklich eine Zahl um die elf Mio (dezimal) 
senden.

von Bernd B. (behbeh)


Lesenswert?

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

von spontan (Gast)


Lesenswert?

Hallo Tobias,

was ist eigentlich Deine Frage?
Daß Du "es" nicht hinbekommst, hab ich verstanden, aber sonst?

Hast Du schon mal eine I2C-Kommunikation aufgebaut, oder ist es die 
erste?
Welche Hardware verwendest Du? Ist die wenigstens in Ordnung?
Deine C-Kenntnisse, gehen die über zusammenkopieren von anderen 
Programmteilen hinaus?
Hast Du schon selbsständig lauffähige C-Programme geschrieben?

Drehen sich die Fragen von Dir nur um das Protokoll? Oder uach um C?

Ich blick noch nicht so ganz.

von Tobias N. (silberkristall)


Lesenswert?

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.

von ich (Gast)


Lesenswert?

Du hast also "so ein kleines C-Programm" bekommen. Toll.
Und das "gibt dir" diese Ausgabe. Schön. Und jetzt?

von Tobias N. (silberkristall)


Lesenswert?

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?

von Karl H. (kbuchegg)


Lesenswert?

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.

von Karl H. (kbuchegg)


Lesenswert?

>
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.

: Bearbeitet durch User
von Tobias N. (silberkristall)


Lesenswert?

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!?

von Tobias N. (silberkristall)


Lesenswert?

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

von Karl H. (kbuchegg)


Lesenswert?

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.

: Bearbeitet durch User
von Hermann U. (Firma: www.pcb-devboards.de) (gera82)


Lesenswert?

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
}

von Tobias N. (silberkristall)


Lesenswert?

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.

von Tobias N. (silberkristall)


Lesenswert?

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.

von Tobias N. (silberkristall)


Lesenswert?

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?

von Karl H. (kbuchegg)


Lesenswert?

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.

: Bearbeitet durch User
von Karl H. (kbuchegg)


Lesenswert?

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.

: Bearbeitet durch User
von Tobias N. (silberkristall)


Lesenswert?

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.

von Tobias N. (silberkristall)


Lesenswert?

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.

von Karl H. (kbuchegg)


Lesenswert?

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.

: Bearbeitet durch User
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.