Kommunikation zwischen PC und UART-MSP430

[Alain (Gast)]

Hallo,

ich versuche gerade ine Kommunikation zwischen meinem MSP430 und dem PC
herzustellen.

der PC soll ein String senden. der MSP430 soll das String (durch 
UART)empfangen und auf dem LCD anzeigen.

ich habe mir das so gedacht. ich schick erstmal ein zeichen zumbeispiel 
"S"
das soll bedeuten dass es ein String geschickt wird.

der UART bekommt erstmal die "S" und vorbereitet sich auf den String.
 der String wird empfange (durch RXBUF1) dann auf ein temp  speichern.

temp soll dann auf dem display gezeigt werden.

als bsp: der PC sendet  "hallo", diese Hallo so auf dem Display 
erscheinen.

hat jemand von euch eine detallierte Idee?? bitte schön erklären.


danke.

[Karl heinz B. (kbucheg)]

Fang damit an, dass du am MSP430 ein einfaches
Echo-Programm schreibst: MSP empfängt ein Zeichen
auf der UART und schickt es gleich wieder über die
UART zurück.

Wenn du das hast, dann hast du bereits wesentliche
Hürden gemeistert: Du hast die UART initialisiert und
empfangsfähig / sendefähig gemacht. Du hast ein Zeichen
empfangen / gesendet. Du hast die komplette Kommunikation
zwischen PC und MSP lauffähig und die funktioniert auch.

Auf dem, was du bei diesem einfacheren Beispiel lernst,
kannst du dann aufbauen.

Ebenso das Thema LCD: Beschäftige dich in einem Zwischen-
projekt nur mit der Ansteuerung des LCD.

Wenn du dann weist wie die einzelnen Teilbereiche funktionieren
und eine gewisse Sicherheit entwickelt hast, ist es wesentlich
einfacher dein eigentliches Vorhaben in Angriff zu nehmen.

Wie man bei einem MSP die UART aktiviert und benutzt
müsstest du eigentlich im Datenblatt zum MSP finden.

[Alain (Gast)]

@ KARL
zeichen senden und empfangen und auf dem LCD habe ich schon geschaft.
es ist so:

wenn RXBUF1 = " A" soll was führen Zb LED1 leuchten.
wenn RXBUF1 = " B " soll     LED2 leuchten

usw...

und wenn RXBUF1 = "S" soll ein Sting empfangen und auf LCD anzeigen

[Karl heinz B. (kbucheg)]

> zeichen senden und empfangen und auf dem LCD habe ich schon geschaft.
> es ist so:

Na super.
Über welche Programmiersprache reden wir eigentlich?
(Bitte sag jetzt C, bitte sage jetzt C, ... )

[Alain (Gast)]

klar C :)

[Karl heinz B. (kbucheg)]

Na dann.

In C wird ein String in einem char Array gespeichert.
Das char Array muss dabei gross genug sein um auch
wirklich alle Zeichen des Strings aufnehmen
zu können. Man muss also bereits im Vorfeld (bei der
Programmierung) wissen, wie lang der längste String
werden wird (*).

int main()
{
  char MeinStringBuffer[100];

In diesem Array 'MeinStringBuffer' kann also maximal ein
String mit 100 Zeichen abgelegt werden., wenn da nicht ...

Weiters gibt es eine Konvention in C. Da ja niemand sagt,
dass mein String da oben tatsächlich 100 Zeichen hat, wird
in C ein String immer mit einem  '\0' Zeichen abgeschlossen.
Alle in vorhandenen String-Funktion wissen das und berücksichtigen
das auch.

-> daher folgt, dass mein String da oben in MeinStringBuffer
keine 100 Zeichen lang sein kann, weil ich ja eine Array-Position
bruauche um darin das obligatorische, abschliessende '\0' Zeichen
unterzubringen. Der String kann also nur maximal 99 Zeichen
gross sein.

Ich gehe mal davon aus, dass du eine Funktion hast, die
ein einzelnes Zeichen auf dem LCD ausgibt. Daraus bauen
wir uns gleich mal eine Funktion, die einen String
ausgeben kann. Der Grund dafür ist einfach: Diese
Funktion kann ich leichter testen und fehlerfrei machen.
Diese Funktion brauche ich aber in einwandfreiem Zustand, wenn
ich einen String empfangen und anzeigen will. Wenn ich anders
rum anfange, habe ich das Problem, dass ich zwar die Funktion
zum empfangen eines Strings schreiben kann, ich kann sie
aber nicht testen, weil ich das Empfangene nirgends ausgeben
kann. Und wenn ich dann diese Funktion schreibe und nichts
erscheint, wo liegt dann der Fehler? In der Empfangsfunktion
oder in der Anzeigefunktion?

Also fange ich dort an, wo ich am wenigsten Voraussetzungen
habe und das ist nun mal die Anzeigefunktion

Die könnte zb so aussehen

void lcd_puts( char[] String )
{
  unsigned char i = 0;

  while( String[i] != '\0' ) {
    gib_einzelnes_zeichen_auf_LCD( String[i] );
    i++;
  }
}

Als geübter C Programmierer würde man das etwas anders
schreiben, aber fürs erste ist das gut so.

Dann teste ich diese Funktion

/*
** string.h braucht man für die stringverarbeitenden
** Funktionen wie strcpy, strlen, strcmp, strcat
*/
#include <string.h>

... hier dann deine lcd Funktionen

int main()
{
  char Buffer[200];

  strcpy( Buffer, "Mein String" );
  lcd_puts( Buffer );

  lcd_puts( "Noch ein String );
}

Das sollte schon mal die Strings ausgeben.

Soweit so gut.
Jetzt können wir uns dem Empfangen widmen.
Was muss passieren: Bei jedem empfangenen Zeichen muss
dieses Zeichen in Buffer geschrieben werden. Und zwar
Zeichen für Zeichen jeweils an die nächste freie Position.
Dazu vereinbaren wir gleich mal einen Zähler, der sagt uns
wo das nächste Zeichen zu speichern ist.

  char Buffer[200];
  unsigned char Next;

Wenn du also das ominöse 'S' empfängst setzt du den
Zähler auf 0
Beim nächsten empfangenen Zeichen, schreibst du dieses
einfach in Buffer[Next] und erhöhst Next um 1.

Halt!
Woher weist du eigentlich, dass der String jetzt zuende
ist? Der String könnte ja ewig so weitergehen. Du brauchst
also eine Möglichkeit wie du dem µC mitteilen kannst, dass
das jetzt alles für den String war und das das nächste
empfangene Zeichen wieder ein Kommando sein wird.
Im Prinzip kannst du jedes beliebige Zeichen dafür hernehmen.
Sei es ein '.' oder ein ',' oder ein ';' oder was auch
immer. Nur sollte natürlich sichergestellt sein, dass dieses
zeichen im zu Übertragenden Text nicht vorkommt. Dieses spezielle
Zeichen ist ja sowas wie ein 'Hier ist der String zuende'-Kommando.
Für solche Zwecke benutzt man gerne den Return. Jeder Computer-
Benutzer ist daran gewöhnt, dass Texteingaben mit Return abzuschliessen
sind. Also: warum was neues erfinden.
In C wird Return durch das Zeichen '\n' symbolisiert. Nun sind
wir aber auf einem µC ein ganzes Stück unter der normalen C
Schicht: Du kriegst die Zeichen direkt von der UART und die
C-Bibliotheken können da nichts mehr geradebügeln. Die Zeichen
werden vom UART so weitergereicht, wie sie am PC abgeschickt werden.
Und blöderweise gibt es da mehrere Standards: Bei Druck auf
Return, kann der PC schicken:
  einen '\n'
  einen '\r'
  oder aber beides hintereinander

'\n' ist eigentlich ein Line-Feed und '\r' ist das Return-zeichen.

Welches der Fall ist musst du ausprobieren. In den meisten Terminal-
programmen kann man das auch einstellen.

Wie auch immer: Nachdem den Pgm das Kommando 'S'
empfangen hat, setzt es Next auf 0 und wartet in
einer Schleife auf das nächste Zeichen. War dieses Zeichen
kein '\n' so wird das Zeichen in Buffer[Next] gespeichert,
Next um 1 erhöht und die Schleife geht wieder von vorne los.
War das Zeichen aber ein '\n', so ist der String zu Ende, es
wird noch das obligate '\0' Zeichen an den String angehängt
und mittels der bereits getesteten Funktion lcd_puts wird
der String ausgegeben.

....

  char Buffer[200];
  unnsigned char Next;
  char c;

....


  if( RXBUF1 == 'S' ) {

     Next = 0;
     
     // Hier: warte auf nächstes Zeichen, wie das
     // auf deinem MSP geht, weiss ich nicht. Musst du wissen

     // hole auf jeden Fall mal das Zeichen
     c = RXBUF1;

     while( c != '\n' ) {    // solange das kein '\n' war

                             // Zeichen erst mal speichern
       Buffer[Next] = c;
       Next++;
                             // und auf das nächste Zeichen warten

       // Hier: warte auf nächstes Zeichen ...

       // ... und dieses Zeichen abholen
       c = RXBUF1;
     }
     // aus der while Schleife da oben kommt man nur raus
     // wenn der Benutzer tatsächlich auf Return gedrückt hat

     // Den String komplett machen: '\0' anhängen
     Buffer[Next] = '\0';

     // Es ist Zeit das Empfangene auf dem LCD auszugeben

     lcd_puts( Buffer );

   }  // und das wars. Das Kommando 'S' ist abgearbeitet.

(*) Wenn man das nicht weiss oder nicht abschätzen kann, dann ...
* ... schätzt man einfach konservativ.
  Erwarte ich im Schnitt 20 Zeichen, dann dimensioniere ich
  das Array auf 200 Zeichen und hoffe mal, dass das für
  alle Zeiten reichen wird
* ... wirds richtig aufwendig, weil man auf dynamische
  Programmierung ausweichen muss.

[Karl heinz B. (kbucheg)]

> wenn RXBUF1 = " A"

Achte in C auf den Unterschied zwischen " und '

" schliesst einen kompletten String ein.
' schliesst ein einfaches Zeichen ein.

Ein String besteht aus Zeichen. Aber ein String ist
kein Zeichen. Wenn RXBUF1 also ein einzelnes Zeichen
ist, dann kannst du das nicht mit einem String vergleichen.

Wenn RXBUF1 aber einen String enthalten würde, dann würde
das auch nicht gehen, da man Arrays nicht vergleichen kann.
Allerdings gibt es eine Funktion dafür: strcmp()
strcmp() vergleicht 2 char Arrays und liefert 0 wenn beide
gleich sind.

   if( strcmp( Buffer, "Alain" ) == 0 ) {
     lcd_puts( "Hallo Alain" );
   }

[Alain (Gast)]

danke erstmal,

ich muss erstmal alles lesen was du geschrieben hast war echt zu viel. 
bin dir sehr danbar dafür.

> Achte in C auf den Unterschied zwischen " und '
wenn ich (") eingebe dann bekomme ich fehler gezeigt.
nur ist (') ist richtig.

[Alain (Gast)]

> Ich gehe mal davon aus, dass du eine Funktion hast, die
ein einzelnes Zeichen auf dem LCD ausgibt.

stimmt.

ich bin noch am lesen :) und verstehen

[Alain (Gast)]

ich fand es sehr gut, ich werde es am montag erst wenn ich an der FH bin 
nochmal schreiben und testen. dann sage ich bescheid.
bis montag

[Alain (Gast)]

guten morgen.

karl meinste hier:[void lcd_puts( char[] String )], doch [void lcd_puts( 
char String[]  )], oder?

[Alain (Gast)]

ich sende daten durch ein Funk an die UART. ich komme nicht raus von der 
folgende while schleife.

while( c != '\n' ) {    // solange das kein '\n' war
                       // Zeichen erst mal speichern
 Buffer[Next] = c;
 Next++;

ich denke es liegt darum dass der Funk immer am senden  ist.
 stimmt das??
danke

[Alain (Gast)]

hat jemand eine Idee?? ich wäre dankbar leute.

[Rufus Τ. F. (rufus)]

Eine Zuweisung weist dem links vom Zuweisungsoperator stehenden Objekt 
den Wert des rechts vom Zuweisungsoperator stehenden Ausdrucks zu.

Also solltest Du statt

while( c != '\n' ) 
{    // solange das kein '\n' war
  // Zeichen erst mal speichern
  Buffer[Next] = c;
  Next++;
}

besser

while( c != '\n' ) 
{    // solange das kein '\n' war
  // Zeichen erst mal speichern
  c = Buffer[Next];
  Next++;
}

schreiben.

Mit Deinem Code überschreibst Du Buffer mit dem Wert von c.

[ich&er (Gast)]

hast du denn mal überprüft, was genau ankommt, ob überhaupt '\n' jemals 
am msp ankommt? evtl mal anstatt '\n' den entsprechenden ascii-hex-wert 
im quellcode nutzen ?!

[Alain (Gast)]

ich habe ein programm mit VB geschrieben, der sendet ein String durch 
einen FUNK weiter an einen anderen Modul, dieser Modul empfängt diesen 
String und schreibt s auf dem LCD.

damit man das ende der String erkennt vergleicht man es mit "\n".
ich klicke aber nicht auf "ENTER" ich benutze da nur ein batten.

dh das Ende der String wird nicht erkannt und wird immer empfangen.

ich habe das Programm erstmal so verbessert.
 if ((IFG2 & URXIFG1))
  {
    Next = 0;
    while (c != '\n')
      {
       c = RXBUF1;
       Buffer[Next] = c;
       Next++;
      }
    Buffer[Next] = '\0';
    lcd_puts(Buffer);
  }

soll ich im visual basic dann ein string schreiben und am ende immer 
diesen befehl schreiben, zum beispiel:

frmX.MSComm3.Output = "hallo word" & vblf ??

oder wie schaut aus?

danke

[Rufus Τ. F. (rufus)]

OK, ich ziehe meinen Beitrag zurück. Habe da wohl was überlesen; geht ja 
wohl tatsächlich um das Befüllen des Puffers.

[Karl heinz B. (kbucheg)]

Alain wrote:
> guten morgen.
>
> karl meinste hier:[void lcd_puts( char[] String )], doch [void lcd_puts(
> char String[]  )], oder?

Ja.
Da ist mir C# in die Quere gekommen.

[Karl heinz B. (kbucheg)]

> damit man das ende der String erkennt vergleicht man es mit "\n".
> ich klicke aber nicht auf "ENTER" ich benutze da nur ein batten.

Dann nimm irgendein anderes Zeichen, dass du als 'Ende der Eingabe'
benutzen kannst. zb ein ';'

> ich habe das Programm erstmal so verbessert.
> if ((IFG2 & URXIFG1))
>  {
>    Next = 0;
>    while (c != '\n')
>      {
>       c = RXBUF1;
>       Buffer[Next] = c;
>       Next++;
>      }
>    Buffer[Next] = '\0';
>    lcd_puts(Buffer);
>  }

ver-schlimmbessert.

 if ((IFG2 & URXIFG1))
 {
    Next = 0;
    c = RXBUF1;

    while (c != ';')
    {
       Buffer[Next] = c;
       Next++;

Hier an dieser Stelle, hast du etwas gaaaaaaanz Wesentliches
unter den Tisch fallen lassen.
Im Originalcode war hier ein Kommentar:

       // Hier: warte auf nächstes Zeichen ...

An dieser Stelle, musst du natürlich warten, bis dir
die UART signalisiert, dass ein neues Zeichen eingetrudelt
ist. Wie das geht kann ich dir nicht sagen, weil ich den
Prozessor ncht kenne. Ich schätze aber mal, dass irgendwo
ein Bit in einem Register gesetzt wird. Ev. ist es sogar
das IFG2 & URXIFG1 das hier anschägt. Also irgendwas
in der Form
    while( !( IFG2 & URXIFG1 ) )
      ;

Das ist jetzt aber eine Vermutung von mir. Da du aber
gesagt hast, du könntest einzelne Zeichen empfangen bin
ich davon ausgegangen, dass du das schon ergänzen wirst
und habe es bei einem Kommentar belassen.

Erst dann, wenn die UART signalisiert hat, dass wieder etwas
angekommen ist, erst dann kannst du das angekommene Zeichen
abholen.

       c = RXBUF1;
    }

    Buffer[Next] = '\0';
    lcd_puts(Buffer);
  }

[Alain (Gast)]

while( !( IFG2 & URXIFG1 ) )
hier wird abgefragt ob neue zeichen empfangen ist.

das mit dem schreiben auf LCD (normale bsp) hat funk danke.

[Alain (Gast)]

 if ((IFG2 & URXIFG1))
   {
     c = RXBUF1;
    }
     if(c == 'S')
     {
        Next = 0;
        if ((IFG2 & URXIFG1))
        {
         c = RXBUF1;
         while(c != '.')
           {
             Buffer[Next] = c;
             Next++;
           }
         }

      }

so sieht der code aus, aber der liefert mir leider nicht. wo kann der 
fehler liegen? danke

[Karl heinz B. (kbucheg)]

Du passt nicht auf, was man dir schreibt.

Was soll das denn machen?:

        while(c != '.')
           {
             Buffer[Next] = c;
             Next++;
           }

wie soll denn c in dieser Schleife jemals '.'
werden?
Da ist keine einzige Anweisung, die c ändern würde.
Ich hab dir doch schon eine Lösung gepostet.

[Karl heinz B. (kbucheg)]

     if(c == 'S')
     {
        Next = 0;

        // warte auf Zeichen ...
        while( !((IFG2 & URXIFG1) )
          ;

        // ... und hole Zeichen
        c = RXBUF1;

        while(c != '.')
        {
          Buffer[Next] = c;
          Next++;

          // warte auf Zeichen ...
          while( !((IFG2 & URXIFG1) )
            ;

          // ... und hole Zeichen
          c = RXBUF1;
        }

        Buffer[Next] = '\0';
        lcd_puts(Buffer);
      }

Nochmal schreib ich den Code jetzt allerdings nicht mehr :-)

[Alain (Gast)]

:-)

[Alain (Gast)]

duu karl
das was du schreibst ist alles falsch.. wo hast du denn programmieren 
gelernt??? du musst  nochmal lernen... ciao


ich muss mich bei dir bedanken es hat endlich geklappt, aber bin noch 
fertig, dh ich brauch noch deine hilfe, ich melde mich
danke nochmal :))

[Alain (Gast)]

so ich möchte jetzt abfragen.
wenn "A" ankommt dann soll er was anders ausführen oder wenn "B" dann 
was anders.

soll ich einfach so machen?

if(c="S")
{
wie Oben;
}
else if (c=="A")
{
blabla;
}

else if(c=="C")
{
was anders;
}

soll das so gehen?

[Karl heinz B. (kbucheg)]

> if(c="S")
> {
> wie Oben;
> }
> else if (c=="A")
> {
> blabla;
> }
>
> else if(c=="C")
> {
> was anders;
< }

Nochmal:

"S" ist ein String, weil du " genommen hast. c ist aber kein String!
c ist ein einzelnes Zeichen, ein char!

Daher musst du ebenfalls mit einem character vergleichen!
Der schriebt sich aber mit '

  if( c == 'S' )
  {
    ...

Strings, also so was: "Alain", kann man in C nicht mit ==
vergleichen, da es sich im Prinzip dabei um Arrays handelt
und man kann Arrays nicht mit == vergleichen. Dazu gibt
es eine Hilfsfunktio: strcmp(). strcmp() macht nichts anderes
als die beiden zu vergleichenden Arrays Zeichen für Zeichen
durchzugehen und die einzelnen Zeichen miteinander zu vergleichen.

" und ' sind unterschiedliche Dinge! Das eine ist ein String
das andere ein einzelnes Zeichen.

[Alain (Gast)]

sorry ich meinte auch 'A' usw 'S'

habe ich nur mit Visual Basic verwechselt. weil ich sende ein String vom 
PC durch Visual Basic.

[Alain (Gast)]

> if(c='S')
> {
> wie Oben;
> }
> else if (c=='A')
> {
> blabla;
> }
>
> else if(c=='C')
> {
> was anders;
< }

soll das gehen ?

[Karl heinz B. (kbucheg)]

Prinzipiell ja.
Soweit man aus dem Ausschnitt überhaupt irgendwelche Schlüsse
ziehen kann.

[Christian R. (supachris)]

Wieso machst du das nicht bissl sinnvoller mit Interrupt? Dann in der 
ISR den kompletten Steuerstring in ein Array einsammeln, und am Ende 
(z.b. durch \0 oder \r\n gekennzeichnet) nachschauen, was das Kommando 
war, und entsprechend dann Aktion durchführen. Ist am Ende viel 
übersichtlicher als da ständig im Polling auf neue zeichen zu Warten.

[Alain (Gast)]

nehmen wir es gibt 2 funkmodule. und ich soll ein string an bestimmten 
funk senden.

wie kann ich das adressieren. ich gehe davon aus wenn ein kompletten 
string empfangen ist, dann wird abgefragt für welchen modul ist das 
gedacht oder? kann mir jemand tip geben?

danke viel mals

[Karl heinz B. (kbucheg)]

> wie kann ich das adressieren.

Denk dir was aus. Du musst ein Protokoll erfinden.
Du könntest zb vereinbaren, dass eine komplette
Kommunikation aus einem String besteht, der so
aufgebaut ist:

S1Testtext.
^^^       ^
|||       |
|||       +-- Das hier kennzeichnet, dass die Übertragung
|||           hier vollständig ist
|||
||+------- Hier beginnt der zu übertragende Text
||
|+-------- Diese 1 bedeutet, dass das Kommando für
|          Funkmodul 1 gedacht ist. Funkmodul 2 empfängt
|          zwar ebenfalls das Kommando, da im Kommando aber
|          steht, dass es für Modul 1 ist, ignoriert Funkmodul 2
|          ganz einfach das Kommando
|
+------ Dieses S bedeutet irgendwas. Zb. Das der nachfolgende Text
        in die Anzeige übernommen werden soll.


In Summ sagt obige Zeile also:
Anweisung an Funkmodul 1 (wegen der 1): Zeige den Text der folgt
in der Anzeige an (wegen dem S). Der Text der anzuzeigen ist, lautet:
Testtext (beginnt hinter der Empfängerangabe und endet beim ., weil
beim . das komplette Kommando zuende ist)

Denk dir was aus. Was immer du dir ausdenkst ist richtig,
solange es funktioniert.

Vielleicht solltest du dir mal am Papier überlegen, wie so
eine Nachricht aufgebaut sein könnte und welche Nachrichten
du überhaupt brauchst.

Ev ist es auch sinnvoll, die Nachricht mit einem ganz bestimmten
Zeichen beginnen zu lassen. Sagen wir mal mit einem '*'. Das
brauchst du deshalb, weil der Empfänger die ersten Zeichen
bz. beim Einschalten nicht mitbekommen hat. Er überliest dann
solange Zeichen, bis er auf ein '*' stoesst. Das sagt ihm dann
dass tatsächlich mit dem nächsten Zeichen ein neues Kommando
anfängt.

[Alain (Gast)]

danke dir karl,
ich werde versuchen das realisieren und klein Protokoll schreiben.

überigens statt ein '.', habe ich nach dem String noch ein '\n\ 
gesendet. weil der anwender soll nicht immer ein punkt am ende des 
strings schreiben. deshalb habe ich das in dem Code nach ende des 
strings gemacht:
und das ist im Visual basic.
ZB:


>frmX.MSComm3.Output = "meinString"

>frmX.MSComm3.Output = Chr(10)

Chr(10) ist gleich '\n'.

[Alain (Gast)]

kann ich dann erst hier die abfrage stellen?
...
...
.
.
>  // ... und hole Zeichen
>          c = RXBUF1;
>       }
>      Buffer[Next] = '\0';

 // hier kommt erst dann der abschnitt für adressieren:

 // für Modul_1: dies wird auf Modul1 geschrieben.
if(Buffer[0]=0 || Buffer[0]=1 )
lcd_puts(buffer);

 // für Modul_2: dies wird auf Modul2 geschriebn.
if(Buffer[0]=0 || Buffer[0] = 2)
lcd_puts(buffer);
>
>     // Buffer[0] = 0 heisst dass alles Module sind betroffen.
      // Buffer[0] = 1   "      "    Modul 1 ist betroffen.

ist so richtig ?? danke viel mals

[Alain (Gast)]

es hat geklappt mit adressieren.

ein fehler ist noch da.

wenn ich an beide Module ein 'B' sende dann steht auf dem LCD: "Beginn"
aber wird nur eins von beiden Module angesprochen, und soll zum beispiel 
"Ball" anzeigen. dann steht in den ersten LCD "Ball" und in den zweiten: 
"Beginn". wie kann ich das verhindern? dass der zweite Modul nix 
unternimmt.??

dankeeeeeeee

[Karl heinz B. (kbucheg)]

> wenn ich an beide Module ein 'B' sende dann steht auf dem LCD: "Beginn"
> aber wird nur eins von beiden Module angesprochen, und soll zum beispiel
> "Ball" anzeigen. dann steht in den ersten LCD "Ball" und in den zweiten:
> "Beginn". wie kann ich das verhindern? dass der zweite Modul nix
> unternimmt.??

Aus der Beschreibung werde ich nicht schlau.
Das liest sich doch so, als ob alles so funktioniert wie
es sein soll.
Adresse 0:  alle Modul sollen was tun
Adresse 1:  LCD 1 soll was tun
Adresse 2:  LCD 2 soll was tun

Im Zweifel gilt wie immer:
* Eine ordentliche Fehlerbeschreibung. Immer dran denken:
  Wir hier sitzen nicht vor dem Gerät.
* Source Code ersetzt ne Menge Schreibarebit

[Stefan (Gast)]

> if(Buffer[0]=0 || Buffer[0]=1 )

ist vermutlich nicht was du willst.

Hier wird Buffer[0] 0 zugewiesen und die Zuweisung hat die logische 
Aussage 0 (FALSCH).

Buffer[0] wird 1 zugewiesen mit der logischen Aussage 1 (Nicht FALSCH = 
WAHR).

Beide logischen Aussagen verODERt ergibt IMMER WAHR (sollte dein 
Compiler als Warnung melden).

Du möchtest vermutlich etwas abprüfen.

if( (Buffer[0] == 0) || (Buffer[0] == 1) )

Solche Schludrigkeitsfehler kann man per Schreibweise fangen...

if( (0 == Buffer[0]) || (1 == Buffer[0]) )

ist legaler Code. Beim folgenden Schlurifehler meckert der Compiler 
unüberlesbar:

if( (0 = Buffer[0]) || (1 = Buffer[0]) )

[Stefan (Gast)]

Achso... 0 ist die Zahl 0. Wenn du Buffer[0] auf die Ziffer 0 abprüfen 
willst, musst du schreiben: '0' == Buffer[0]

[Alain (Gast)]

danke Srefan, ich habe es geändert und hats geklappt. und funktioniert 
gut.

[Alain (Gast)]

nochmal zum dem Thema.

bis jetzt hat alles funktioniert. mein frage jetzt ist:

ich möchte ein (3 zeilen) String senden, zum beispiel:

 String =  >( " hallo
           >  "wie
           >  " geht es dir " )

 und das soll danach genauso auf einem LCD angezeigt werden.

ich feue mich sehr auf ihre Ideen und antworte.

[Stefan (Gast)]

Brücke an Capt. Kirk: "Nicht genügend Informationen vorhanden!"

Hast du ein mindestens dreizeiliges LCD auf dem man die drei Zeilen 
gleichzeitig anzeigen kann oder sollen die drei Zeilen zeitlich 
nacheinander angezeigt werden?

Beim Nacheinander-Fall: Soll jeweils nur eine Zeile angezeigt werden 
oder sollen die Zeilen scrollen? Wie lange soll eine Zeile mindestens 
lesbar sein?

Kannst du das Ausgeben einer einzelnen Zeile schon programmieren (ggf. 
mit den Beispielen oben)?

Ist der String ist fest vorgegeben (eine Konstante im Quellcode) oder 
ist der String eine Variable (z.B. Inhalt durch den PC an den µC 
gesendet)?

Hast du im String eigene Trennzeichen (z.B. \r\n oder selbstdefiniert) 
drin oder soll so zwischen den Worten so getrennt werden, dass maximal 
viele Worte in eine LCD-Zeile passen? Wieviele Zeichen gehen in diesem 
Fall maximal in eine Zeile - 8, 16, 20, 24, 40, mehr?

[Bernhard (Gast)]

Dann brauchst du ein Zeilentrennzeichen.
Wenn 0x0A (=Linefeed) schon vergeben ist, nimm z.B. 0x40 (= das 
@-Zeichen)

Das kannst du genauso abprüfen wie die Sonderzeichen davor, also noch 
eine if-Ebene dazu, oder halt mit switch/case:

while(was auch immer)
{
switch(buffer[Next])
{

case '@':
lcd_puts (linefeed);
break;

case 'Welches von dir auch immer definierte Sonderzeichen':
lcd_puts (Wofür auch immer das Sonderzeichen gut war)
break;

default: //Also alle normalen Zeichen
lcd_puts (bufer[Next];
break;
}
und hier vermutlich next++;

.
.
.

[Alain (Gast)]

ich habe ein dreizeiliges LCD auf dem man die drei Zeilen
gleichzeitig anzeigen kann.

am ende des Strings ist immer '\n'.

LCD: 128*64. jede Zeile kann 16 Zeichen geschrieben werden.

der String ist ein variable wie oben im bsp steht. und vom PC an den µC 
gesendet.

[Alain (Gast)]

sorry muss mich korrigieren.

20 zeichen passen in einer Zeile.

[Alain (Gast)]

hat da jemand kein Idee??
wäre euch dankbar

[Stefan (Gast)]

Brücke an Capt. Kirk: "Nicht genügend Informationen vorhanden!"

Kannst du das Ausgeben einer einzelnen Zeile schon programmieren (ggf.
mit den Beispielen oben)?

Hast du im String eigene Trennzeichen (z.B. \r\n oder selbstdefiniert)
drin oder soll so zwischen den Worten so getrennt werden, dass maximal
viele Worte in eine LCD-Zeile passen?

[Karl heinz B. (kbucheg)]

Schlimmstenfalls kannst du ja 3 Ausgabekommandos
definieren. Oder dein Protokoll so umändern, dass
bei einer Textausgabe (Kommando 'S') noch mit angegeben
werden muss, in welcher Zeile die Ausgabe erfolgen soll.

Dein Kommandostring könnte also zb so aussehen:

S11Testtext.
  ^
  |
  +---- Ausgabe soll in Zeile 1 erfolgen

oder

S12Testtext.
  ^
  |
  +---- Ausgabe soll in Zeile 2 erfolgen


Nicht umsonst habe ich dir geraten du sollst dir am
Papier mal Gedanken über das Protokoll machen.
Sei ein bischen kreativ!
Du willst eine Ausgabe an eine bestimmte Stelle - Dann
kann doch das Kommando die Stelle an der die Ausgabe zu
erfolgen hat beinhalten.

Du bist der Programmierer. Was immer du dir auf Protokoll-
ebene ausdenkst ist per Definition richtig. Wenn dein
Protokoll etwas nicht leisten kann, dann muss man halt
das Protokoll erweitern.

[Alain (Gast)]

es hat sich erledigt.
danke euch.