MSP430 UART Zeichenkette ausfiltern?

[Wolfgang (Gast)]

MSP430 UART Zeichenkette ausfiltern?
Von einer GPS-maus werden die Daten über UART ständig zum µC
übertragen.
Wenn die Maus die Zeichenkette $GPRMC  gesendet hat, soll ein
Unterprogramm angesprungen werden, um die jetzt folgenden Daten weiter
zu bearbeiten.
Zur Zeit werden bei mir alle eingehenden  Zeichen in einem [Feld]
gespeichert und wenn 512 Bytes angekommen sind, auf eine Speicherkarte
geschrieben.

Hier ein von mir verwendeter Programmausschnitt: (geschrieben mit IAR
für MSP430)

 #pragma vector=UART0RX_VECTOR
__interrupt void usart0_rx (void)
    {  GPS = RXBUF0;         // Register RXBUF0 wird gelesen,
                             // Inhalt von RXBUF0 der Variablen
                             // GPS zuordnen und RXBUF0 leeren
    zwischenspeichernGPS();
    }

void zwischenspeichernGPS(void)

  {
   Tabelle[t]=GPS;
 }

Und so sieht der z. B. der Datenstrom aus:
,05,300,33*49
$GPGSV,3,3,08,,,,,,,,,15,43,069,4*,,,*4D
$GPRMC,122905,A,5127.3760,N,01200.9286,E,0.00,323.02,080206,0.0,W*60
$GPGGA,122906,5127.3760,N,01200.9286,E,1,07,1.1,156.3,M,156.3,M,0.0,0000 
*50
$GPGSA
oder in Hexadezimaldarstellung:
00000140h: 35 2C 33 30 30 2C 33 33 2A 34 39 0D 0A 24 47 50   ;
5,300,33*49..$GP
00000150h: 47 53 56 2C 33 2C 33 2C 30 38 2C 2C 2C 2C 2C 2C   ;
GSV,3,3,08,,,,,,
00000160h: 2C 2C 2C 31 35 2C 34 33 2C 30 36 39 2C 34 2A 2C  ;
,,,15,43,069,4*,
00000170h: 2C 2C 2A 34 44 0D 0A 24 47 50 52 4D 43 2C 31 32   ;
,,*4D..$GPRMC,12
00000180h: 32 39 30 35 2C 41 2C 35 31 32 37 2E 33 37 36 30   ;
2905,A,5127.3760
00000190h: 2C 4E 2C 30 31 32 30 30 2E 39 32 38 36 2C 45 2C   ;
,N,01200.9286,E,
000001a0h: 30 2E 30 30 2C 33 32 33 2E 30 32 2C 30 38 30 32   ;
0.00,323.02,0802
000001b0h: 30 36 2C 30 2E 30 2C 57 2A 36 30 0D 0A 24 47 50   ;
06,0.0,W*60..$GP
000001c0h: 47 47 41 2C 31 32 32 39 30 36 2C 35 31 32 37 2E   ;
GGA,122906,5127.
000001d0h: 33 37 36 30 2C 4E 2C 30 31 32 30 30 2E 39 32 38   ;
3760,N,01200.928
000001e0h: 36 2C 45 2C 31 2C 30 37 2C 31 2E 31 2C 31 35 36   ;
6,E,1,07,1.1,156
000001f0h: 2E 33 2C 4D 2C 31 35 36 2E 33 2C 4D 2C 30 2E 30   ;
.3,M,156.3,M,0.0
00000200h: 2C 30 30 30 30 2A 35 30 0D 0A 24 47 50 47 53 41   ;
,0000*50..$GPGSA

Hat jemand einen Vorschlag, wie man den Anfang des Datensatzes $GPRMC,
…  (in HEX  24 47 50 52 4D 43 2C )  programmtechnisch erkennen kann?

MfG
Wolfgang

[SupaChris (Gast)]

In der ISR:

if ((RXBUF0 == 0x24) && (count ==0))count++;
if ((RXBUF0 == 0x47) && (count ==1))count++;
if ((RXBUF0 == 0x50) && (count ==2))count++;
if ((RXBUF0 == 0x52) && (count ==3))count++;
if ((RXBUF0 == 0x4D) && (count ==4))count++;
if ((RXBUF0 == 0x43) && (count ==5))count++;
if ((RXBUF0 == 0x2C) && (count ==6))count++;

if (count == 7) //Alle Buchstaben eingesammelt
{
  count =0;
  unterprogramm();
}

Beim Initialisieren des gesamten Programms musste natürlich count=0;
machen, damit das auch beim ersten mal schon klappt.

Ist zwar nich wirklich elegant, aber ich denke, das tuts.

[SupaChris (Gast)]

Ah, Moment: hinter jedes if... in der ISR da muss noch nen

else count =0;

Sonst kommt der ja durchnander bei den anderen GP...

[Mitleser02 (Gast)]

Du hast doch hier:
http://www.mikrocontroller.net/forum/read-1-298120.html#new
schon eine komplette Routine bekommen.

[Wolfgang (Gast)]

aber leider diesen Teil nicht verstanden.
MfG
Wolfgang

[Wolfgang (Gast)]

@SupaChris,
danke für Deine Anregung. Mit einigen Änderungen, aber Beibehaltung des
Prinzips, bin ich jetzt ein ganzes Stück weitergekommen. Wahrscheinlich
geht es einfacher mit Zeiger, aber davon habe ich zu noch zu wenig
Ahnung. Vielleicht hat noch jemand einen weiteren Tipp.
MfG
Wolfgang

[Axel R. (Gast)]

in 'C': (hier bin ich nicht der SuperUser...)

/******************************************************************************/
extern void MsgHandler(unsigned char newchar)
/*******************************************************************************
* ABSTRACT:  Processes the characters coming in from USART.  In this
case,
*        this is the port connected to the gps receiver.
*
* INPUT:    newchar  Next character from the serial port.
* OUTPUT:  None
* RETURN:  None
*/
{
  static unsigned char  commas;      // Number of commas for far in
sentence
  static unsigned char  index;      // Individual array index

  if (newchar == 0)              // A NULL character resets GPS decoding
  {
    commas = 25;              // Set to an outrageous value
    sentence_type = FALSE;        // Clear local parse variable
    return;
  }

  if (newchar == '$')            // Start of Sentence character, reset
  {
    commas = 0;                // No commas detected in sentence for far
    sentence_type = FALSE;        // Clear local parse variable
    return;
  }

  if (newchar == ',')            // If there is a comma
  {
    commas += 1;              // Increment the comma count
    index = 0;                // And reset the field index
    return;
  }

  if (commas == 0)
  {
    switch(newchar)
    {
      case ('C'):              // Only the GPRMC sentence contains a "C"
        sentence_type = GPRMC;    // Set local parse variable
        break;
      case ('S'):              // Take note if sentence contains an "S"
        sentence_type = 'S';      // ...because we don't want to parse it
        break;
      case ('A'):              // The GPGGA sentence ID contains "A"
        if (sentence_type != 'S')  // As does GPGSA, which we will ignore
          sentence_type = GPGGA;  // Set local parse variable
        break;
    }

    return;
  }

  if (sentence_type == GPGGA)      // GPGGA sentence  decode initiated
  {
    switch (commas)
    {
      case (1):                  // Time field, grab characters
        Time_Temp[index++] = newchar;
        return;
      case (2):                  // Latitude field, grab chars
        Latitude_Temp[index++] = newchar;
        return;
      case (4):                  // Longitude field, grab chars
        Longitude_Temp[index++] = newchar;
        return;
      case (7):                  // Satellite field, grab chars
        Satellites_Temp[index++] = newchar;
        return;
      case (9):                  // Altitude field, grab chars
        Altitude_Temp[index++] = newchar;
        return;
    }

    return;
  }    // end if (sentence_type == GPGGA)

  if (sentence_type == GPRMC)      // GPGGA sentence  decode initiated
  {
    switch (commas)
    {
      case (7):                  // Speed field, grab characters
        Speed_Temp[index++] = newchar;
        return;
      case (8):                  // Course field, grab characters
        Course_Temp[index++] = newchar;
        return;
    }

    return;
  }    // end if (sentence_type == GPRMC)

  return;

}    // End MsgHandler(unsigned char newchar)

kann man auch nochmal hier bei N4TXI im Kontext nachlessen:
http://www.knology.net/%7Egdion/whereavr.html

73
Axel
DG1RTO

(das hätte mal auch gut als attachment gepasst

[Axel R. (Gast)]

Du kannst Deine GPS Maus allerdings auch so konfigurieren, das diese nur
noch den RMC Strings sendet. Dann wartest Du aufs Dollar und zählst die
einfliegenden Zeichen. Ist aber Murks...