Geschwindigkeit einer Schleife

Stef wrote:

> Nun schließe ich daraus, dass die Schnittstelle mit dem Schreiben der
> Daten nicht mehr nachkommt

Auf einem µC hat die Serielle Schnittstelle ja normalerweise
eine Form von 'Ich arbeite noch'-Status. Wenn du also vor dem
Schreibvorgang diesen Status überprüfst, und solange wartest
bis die Schnitstelle 'frei' meldet, kann dieser Fall nicht
auftreten.

@ Stef (Gast)

>So, der Versuch mit meiner Schleife ist gescheitert, nun werde ich den
>Uart-Status abfragen müssen.

Wohl wahr.

>Ich weiß nicht, welches dieser Register den Status enthält.

Schon mal das Datenblatt gelesen?

MFg
Falk

When the transmitter is enabled (UTXEx = 1), data should not be written 
to
UxTXBUF unless it is ready for new data indicated by UTXIFGx = 1. 
Violation
can result in an erroneous transmission if data in UxTXBUF is modified 
as it
is being moved into the TX shift register.

Stef wrote:
> Ich hab das nun so probiert, jedoch ohne Erfolg
> ( ja, wahrscheinlich ist es lächerlich, wie ich es probiert habe, aber
> ich
> kenne mich noch nicht aus)
>
>  if(UTXE0=1)
>      {
>           UTXIFG0=0;
>           else
>           UTXIFG0=1;
>      }
>

Du sollst nicht UTXIFG setzen, sondern abfragen ob es 0 oder 1
ist! Nur dann wenn es 1 ist, darfst du einen neuen Wert zur
Schnittstelle geben.

Irgendwas in der Art

1

   //

2

   // Warte in einer Schleife solange, bis UTXIFG0 zu 1 wird

3

   //

4

   while( UTXIFG0 != 1 )

5

     ;

Was ich jetzt nicht weiss ist, ob UTXIFG0 ein komplettes Register
oder nur ein Bit in einem Register ist.

@ Stef (Gast)

>Doch muss ersten bei If ein modifable value her, zweitens muss auch
>UTXIFG0 ein modifable value sein, und bei else erwartet mein Compiler
>ein Statement.

Du solltest dir schnellstens eine gutes Buch über C besorgen.

>Kann mir nicht jemand ein Beispiel geben??

void putc(char data) {
    while(UTXIFG0 != 1);       // warte auf UART Transmitter
    U0TXBUF = data;            // Daten senden
}

MfG
Falk

Stef wrote:
> Danke für die zahlreiche Hilfe, aber es funktioniert immer noch nicht:
>
> Hier ist ein Teil von meinem Code:
>
>
>  while(i < 20 )   /* Schleife, um unsigned char auszugeben */
>             {
>               {
>                 while(UTXIFG0 == 1);  //warten bis Schnittstelle fertig

Denkst du eigentlich auch selber mit?

Falk hat weiter oben einen Ausschnitt aus dem Datenblatt
gepostet. Darin steht eindeutig, dass UTXIFG0 erst dann zu 1
wird, wenn die Schnittstelle fertig ist. Das heist aber auch
im Umkehrschluss, dass solange gewartet werden muss, solange
UTXIFG0 nicht 1 ist!

   while( UTXIFG0 != 1 )
     ;

UTXIFG0 kann man nicht einfach so abfragen. Das ist nur eine numerische 
Konstante, die den Wert eines Bits in einem Register beschreibt.

Es muss geprüft werden, ob dieses Bit im zugehörigen Register IFG1 
gesetzt ist.

Eine korrekte Abfrage davon sieht so aus:

    while (!(IFG1 & UTXIFG0));   // USART0 TX buffer ready?

bzw. so für die zweite UART:

    while (!(IFG2 & UTXIFG1));   // USART1 TX buffer ready?


Im Gegensatz zur hier im Forum und bei AVRs sehr verbreiteten 
Bitshift-Schreibweise ist es bei der MSP430-Programmierung üblich, daß 
eine ein Bit beschreibende Konstante wie UTXIFG0 nicht die Bitnummer, 
sondern den Bitwert enthält.

Wäre es die Bitnummer, würde die Abfrage so aussehen:

    while (!(IFG1 & (1 << UTXIFG0)));

Aber das ist bei den üblichen MSP430-Compilern und den damit gelieferten 
Headerdateien definitiv nicht so realisiert.


Auszug aus msp430x14x.h von Rowley Crossworks:

#define UTXIFG0             (0x80)

Auszug aus io430x14x.h von IAR Embedded Workbench

enum {
  ...
  UTXIFG0             = 0x0080,
  ...
};

@ MockUp (Gast)

>@Falk Brunner (falk)
>Sag mal hast du den ein gutes Buch parat.

Nein, aber schau dir mal die Buchempfehlungen an. Der Klassiker 
Kernigham und Ritchi sowie die diversen Ableger sind ganz OK. Ich hab 
hier "Programmieren in C" rumliegen, das reicht schon SEHR weit.

>Habe auch grad angefangen mit c.
>VHDL war meine erste sprache. geht schon ganz gut

VHDL ist aber was anderes.

Mfg
Falk

Stef wrote:
> So, es würde nun so weit funktionieren, nur noch , dass die einzelnen
> Zeichen meines Charakters einzeln vervielfacht werden:
>
>

1

 ggggeeeeeeewwwwwaaaaaaaeeeeeeeehhhllllltttttee

2

> eeerrrrrr    Kaannnnnnnaaaaaaall::0

>
>
>
> So sieht mein Code jetzt aus, vielleicht erkennt jemand von euch den
> Feher:
>
>
>

1

 while (i < 20)

2

>             {

3

>             do

4

>                 {

5

>                   TXBUF0 = answer1[i];

6

> 

7

>                 }

8

>                   while (!(IFG1 & UTXIFG0));

9

> 

10

>               i++;

11

>             }

12

>             TXBUF0 = '0';

13

> 

14

>

>
>
> Es müsste doch schon laufen, oder habe ich wieder einen Bock
> abgeschossen?

Hast du.
Was ist eigentlich so schwer daran zu verstehen, dass man zuerst
abfragt, ob die Schnittstelle frei ist, und erst dann das Zeichen
auf den Weg bringt. Das sollte doch eigentlich klar wie
Klossbrühe sein.

Und wenn du dir endlich ein vernünftiges Einrückschema angewöhnen
würdest, dann würdest du auch sehen, dass du umgangssprachklich
ausgedrückt, folgendes programmiert hast:

  Sende ein Zeichen, solange die Schnittstelle nicht frei ist.

So schreibst Du immer und immer wieder den auszugebenden Wert in das 
TXBUF-Register ... und gibst diesen Wert dadurch auch immer wieder auf 
der seriellen Schnittstelle aus. Daß das UTXIFG-Bit überhaupt mal 
gesetzt wird, ist eher Zufall.

Du solltest ZUERST warten, bis das UTXIFG-Bit gesetzt wird und DANN erst 
das Zeichen ausgeben:

1

  while (!(IFG1 & UTXIFG0));

2

  TXBUF0 = c;

Baue Dir am besten eine putc-Routine und rufe die von den entsprechenden 
Stellen auf:

1

void putc(char c)

2

{

3

  while (!(IFG1 & UTXIFG0));

4

  TXBUF0 = c;

5

}

Deine Ausgabeschleife ließe sich dann so formulieren:

1

i = 0;

2

while (i < 20)

3

{

4

  putc(answer1[i++]);

5

}

6

putc('0');

@ Stef (Gast)

Versuchs mal damit

1

for (i=0; i<20; i++) {

2

    while (!(IFG1 & UTXIFG0));

3

    TXBUF0 = answer1[i];

4

}

Erkennst du die Schönheit? Und vor allem dass es so funktioniert?

MFG
Falk

Ich wäre ja für das hier:

1

#define until(x) while(!(x))

2

3

for (i=0; i<20; i++) {

4

  until (IFG1 & UTXIFG0);

5

  TXBUF0 = answer1[i];

6

}

Stef wrote:
> Danke für die Hilfe, habe meinen Fehler aber entdeckt:
> Und zwar so müsste es nun endgültig richtig lauten:
>
>
>

1

> while (i < 20)

2

>             {

3

> 

4

>               TXBUF0 = answer1[i];

5

>             while (!(IFG1 & UTXIFG0));

6

> 

7

>               i++;

8

>             }

9

>             TXBUF0 = '0';

10

>

>
>

Nein. Das ist immer noch falsch. Liest du eigentlich, was
wir hier so von uns geben?

>
> Die Reihenfolge von TXBUF0= ...
> und der while-Schleife ist ausschlaggebend!!

Das ist richtig.
Aber du musst zuerst abfragen, ob die Schnittstelle bereit
ist und erst dann das Zeichen senden!

Oder benutzt du zunächst mal das Auto deines Vaters und fragst
erst danach um Erlaubnis?

Abfragen ob die Schnittstelle frei ist:

1

     while (!(IFG1 & UTXIFG0))

2

       ;

Zeichen auf den Weg bringen:

1

     TXBUF0 = answer1[i];

Im Verbund:

1

   // zuerst abfragen, ob die Schnittstelle für die

2

   // Uebertragung des naechsten Zeichens frei ist,

3

   // und solange zuwarten, bis sie es ist

4

   while (!(IFG1 & UTXIFG0))

5

     ;

6

7

   // und dann das Zeichen ausgeben

8

   TXBUF0 = answer1[i];

Stef wrote:
> Ok, ist ein viel besserer Programmierstil.

Das hat nichts mit besserem Programmierstil zu tun.
Das ist eine Frage der Logik

> Aber im Moment bin ich froh, dass es nun läuft.
Bis es dann übermorgen, nach der 120-ten Programmergänzung
plötzlich nicht mehr läuft, weil du dich nicht an die einfachste
Sache der Welt halten kannst:
  * Zuerst nachfragen, ob ein Gerät bereit ist einen
    Befehl auszuführen und gegebenenfalls darauf warten,
    dass es bereit wird.
  * Dann dem Gerät den Befehl geben

> Wenn ich aber so schreibe:
>

1

> while (!(IFG1 & UTXIFG0)); 

2

> TXBUF0 = answer1[i];                          

3

> i++;

4

>

> hänge ich bei meiner while Schleife endlos drinnen.
> Deshalb habe ich veruschweise die while-Schleife hinter den TXBUF0
> gestellt und es hat danach funktioniert!!


Was soll die völlig nutzlose Einrückung des auf die while-Schleife 
folgenden Codes? Lass sowas sein, das fördert nicht die Lesbarkeit des 
Codes.

Wenn es sich tatsächlich so verhält, wie Du beschreibst, dann lässt das 
darauf schließen, daß Du möglicherweise die UART nicht korrekt 
initialisierst.

Wie genau machst Du das?

Was soll das hier?

1

IFG1 &= ~UTXIFG0;

Wie sieht Dein Interrupthandler aus?

Stef wrote:
> Mhm, kann glaube ich auch nur das einzige sein
>
>
> Hier, so hab ich das initialisiert:
>
>

1

> P3SEL = 0x30;  // P3.4 und P3.5 als USART0 TXD/RXD

2

> ME1 |= UTXE0 + URXE0;

3

> .....

4

> UCTL0 &= ~SWRST´

5

> IE1 |= URXIE0 + UTXIE0;

6

> IFG1 &= ~UTXIFG0;

7

>

Du löscht hier das UTXIFG0 Flag explizit.
Dadurch ist es natürlich nicht gesetzt, wenn du es das erste
mal abfrägst.