Falsche Anzeige nach Spannungsverlust

[Stefan O. (oele22)]

Guten Tag alle zusammen,

ich benutze das Board AVR-MT-128 von ATmel und den GPS-Empfänger 
EM-406A. Der GPS-Empfänger übermittelt die Daten (NMEA 1083 Protokoll) 
über serielle Schnittstelle RS232 an das Board. Hier wird dann z.B. die 
UTC und die aktuelle Position auf dem LCD-Display angezeigt.

Ich programmiere mit AVR Studio 5.1 in C.

Die übermittelten Zeichen werden sequentiell an das Board geschickt. 
Dieses liest das aktuelle Zeichen ein. Wenn das Zeichen '$' detektiert 
wird, werden die nachfolgenden Zeichen in einen String gespeichert, bis 
erneut ein '$' detektiert wird. Das Zeichen '$' markiert den Start eines 
vollständigen Datensatzes des Protokolls. Der String wird dann mit einem 
bestimmten Teilstring verglichen. Ist dieser vorhanden, werden bestimmte 
Werte aus dem String dann auf dem Display angezeigt (z.B. aktuelle 
Position).

Nun zu meinem Problem:

Nach Spannungsverlust beim Board werden nicht mehr die richtigen Daten 
angezeigt. Ein erneutes Aufspielen meines Programmes auf das Board 
beseitigt den Fehler nicht. Erst wenn ich von ATmel ein Demo-Code auf 
das Board spiele und dann meinen Code, dann werden wieder korrekte Daten 
angezeigt.

Demo-Code:
http://www.watterott.com/de/AVR-MT-128

Woran könnte das liegen?

Gruß Stefan

[Georg G. (df2au)]

Da die Glaskugel gerade zum Polieren weg ist, kannst du vielleicht noch 
einige Zusatzinfos geben: Was bedeutet "falsche Anzeige"? Chinesische 
Schrift? Oder Uhrzeit falsch?

Der Fehler deutet auf eine fehlende oder falsche Initialisierung eines 
der Bauteile hin. Speziell zum Thema "LCD" geistern hier diverse 
optimistische (um es höflich auszudrücken) Beispiele durch das Forum. 
Wobei mir unverständlich ist, warum alles immer wieder neu erfunden 
werden muss.

[Karl H. (kbuchegg)]

Ins Blaue geraten:

Da wird halt dein Code irtgendeine Initialisierung nicht machen, die der 
Demo-Code schon macht.

Um dem auf die Spur zu kommen, würde ich mir als erstes mal die 
Datensätze ansehen, so wie sie vom GPS kommen, nachdem dein Board 
stromlos war. Die dann vergleichen mit dem was daherkommt, nachdem das 
Demo-Programm die Initialisierung vervollständigt hat. Vielleicht führt 
das zu was, vielleicht auch nicht - aber einen Versuch ist es erst mal 
wert rauszufinden, wo da die Unterschiede liegen.

[Stefan O. (oele22)]

Vielen Dank für eure Antworten. In letzter Zeit hatte ich viel zu tun 
und bin dementsprechend noch nicht weiter gekommen.

Hier erstmal mein Code:

#include "avr/io.h"      // IO Definitionen für den Microcontroller
#include "iom128.h"      // Definitionen für den ATmega128
#include "string.h"         // Funktionen für Zeichenketten 

#include "system.h"// Beinhaltet grundlegende Definitionen  und Funktionen
#include "bits.h"  // Definiert die einzelnen Bits
#include "lcd.h"   // Funktionen für das LCD-Display
#include "delay.h" // Funktionen zur Zeitverzögerung 

/*
** Definitionen
*/
#define    B1        (PINA&BIT0)  // Buttons
#define    B2        (PINA&BIT1)
#define    B3        (PINA&BIT2)
#define    B4        (PINA&BIT3)
#define    B5        (PINA&BIT4)

/*
** Hauptprogramm
*/
int main()
{  
  // Deklarationen
  unsigned char  Ch=0;  // Aktuell eingelesenes Zeichen
  char    Str [100]; // NMEA-Protokoll besteht aus Datensätzen mit maximal 82 Zeichen
  int        k=0;        // Laufvariable zum Durchlaufen des Strings
  int        m=0;        // Laufvariable
  
  int        bed=0;        // Bedingung für String
  int        len=0;
  int        auswahl=1;
  char      str2[]="$GPGGA";  // Teilstring zum Auslesen der GPS-Daten
  char      *pointer;      // Pointer zur Markierung des gefundenden Strings
  int        beg=0;        // Zähle die Kommas, Beginnendes Komma
  int        end=0;        // Zähle die Kommas, Nachfolgendes Komma
  
/*
** Initialisierungen
*/
  PORT_Init();
  UART_Init(4800);    // Baudrate des GPS-Empfängers: 4800
  delay_ms(100);
  LCD_Init();
  delay_ms(10);
  
/*
** Welcome
*/
  SEND_CMD(DISP_ON);
  delay_ms(10);              
  SEND_CMD(CLR_DISP); 
   delay_ms(10);  
  SEND_CMD(DD_RAM_ADDR);
  delay_ms(10);
  SEND_STR("Willkommen!");
  delay_ms(500); 
  SEND_CMD(CLR_DISP);

/*
** Endless loop
*/    
  while (1)
  {  
/*
**********************************************************************************************************************
** Einlesen der ankommenden GPS-Daten und Darstellung auf dem LCD-Display                      **
**********************************************************************************************************************
*/
    // Lösche Display-Anzeige
    if (B2 == 0)
    {
      SEND_CMD(CLR_DISP);
    }
    
    // Wähle aktuelle Anzeige aus    
    if (B3 == 0)
    {
      delay_ms(50); // Verzögerung, damit der Button geklickt werden kann
      auswahl++;
      if (auswahl == 5)
      {
        auswahl = 1;
      }
    }
    
    Ch = UART_Receive(); // Aktuelles Zeichen einlesen                
      
    // Zeichen zwischen Anfang und Ende einlesen
    if (bed == 1 && Ch != '$' && Ch)                  
    {
      Str[k] = Ch;  
      k = k + 1;      
    }
    
    // Letztes Zeichen einlesen
    if (bed == 1 && Ch == '$')
    {          
      pointer = strstr(Str,str2); // Pointer zeigt auf den Anfang der Stelle, wo die Zeichenkette gefunden wurde                      
      len = strlen(Str);          
                    
      if (pointer) 
      {            
        switch(auswahl)
        {
          // Anzeige der Uhrzeit
          case 1 :
          SEND_CMD(CLR_DISP);
          SEND_STR("UTC: ");
          beg = Str_Komma(Str,1); // Uhrzeit: Zwischen Komma 1 und 2
          end = Str_Komma(Str,2);
          for(m=beg;m<beg+6;m++)  // +6, um die 6 Ziffern der Uhrzeit zu erhalten 
          {
            SEND_CHAR(Str[m]); 
            if (m == beg+1 || m == beg+3)
            {
              SEND_CHAR(':');
            }
          }
          break;
          
          // Anzeige der verfügbaren Satelliten
          case 2:
          SEND_CMD(CLR_DISP);
          SEND_STR("Satelliten: ");
          beg = Str_Komma(Str,7); // Satelliten: Zwischen Komma 7 und 8
          end = Str_Komma(Str,8);
          for(m=beg;m<end-1;m++)
          {
            SEND_CHAR(Str[m]); 
          }
          break;
            
          // Anzeige Breitengrad
          case 3:
          SEND_CMD(CLR_DISP);
          SEND_STR("LAT: ");
          beg = Str_Komma(Str,2); // Breitengrad: Zwischen Komma 2 und 3
          end = Str_Komma(Str,3);
          for(m=beg;m<end-1;m++)
          {
            SEND_CHAR(Str[m]); 
          }
          break;
            
          // Anzeige Längengrad
          case 4:
          SEND_CMD(CLR_DISP);
          SEND_STR("LON: ");
          beg = Str_Komma(Str,4); // Längengrad: Zwischen Komma 4 und 5
          end = Str_Komma(Str,5);
          for(m=beg;m<end-1;m++)
          {
            SEND_CHAR(Str[m]); 
          }
          break;
        }        
      }            
      k = 0;        // Laufvariable zurücksetzen
      bed = 0;      // Bedingung zurücksetzen  
    }
    
    // Start zum Einlesen des Strings
    if (bed == 0 && Ch == '$')  // Zeichen $ leitet Datensatz ein
    {              
      Str_Init(Str,'0');    // String Inhalt mit '0' initialisieren
      bed = 1;
      Str[k] = Ch;      // Schreibe $ an erster Stelle des Strings
      k = k + 1;    
    }  
  }
  return 0;
}

und die verwendeten Funktionen:

// Hilfsfunktion zum Initialiseren des LCD-Displays
void _E (void)
{
  E_HIGH;
  delay_us(5);  // Gebe dem LCD-Display Zeit zum Ausführen des Befehls.
  E_LOW;
}

// Initialisiere das LCD-Display
void LCD_Init()
{
  RS_LOW;
  delay_ms(110);

  PORTC = 0b00110000;          // Setze D4, D5 Port zu 1
  _E();                // High->Low zu E Port (Puls)
  delay_ms(80);
  PORTC = 0b00110000;          // Setze D4, D5 Port zu 1
  _E();                // High->Low zu E Port (Puls)
  delay_ms(80);
  PORTC = 0b00110000;          // Setze D4, D5 Port zu 1
  _E();                // High->Low zu E Port (Puls)
  delay_ms(80);
  PORTC = 0b00100000;          // Setze D4 zu 0, D5 Port zu 1. Wechsel in den 4 Bit Modus.
  _E();                // High->Low zu E Port (Puls)
}  
    
// Sende ein Char zum LCD-Display
void SEND_CHAR (unsigned char c)
{   
  data = 0b00001111 | c;            // Nehme oberes Nibble
  PORTC = (PORTC | 0b11110000) & data;    // Setze D4-D7
  RS_HIGH;                    // Setze LCD-Display in Datenmodus
  _E();
  data = c << 4;                // Nehme unteres Nibble
  PORTC = (PORTC & 0b00001111) | data;  // Setze D4-D7 (nur PORTC4-PORTC7)
  RS_HIGH;                     // Setze LCD-Display in Datenmodus
  _E();
}               
    
// Sende ein Kommando zum LCD-Display
void SEND_CMD (unsigned char c)
{    
  delay_ms(LCD_CHAR_SPEED);                // Delay für LCD Char
  data = 0b00001111 | c;            // Nehme oberes Nibble
  PORTC = (PORTC | 0b11110000) & data;    // Setze D4-D7
  RS_LOW;                    // Setze LCD-Display in Datenmodus
  _E();    
  data = c << 4;                //Nehme unteres Nibble
  PORTC = (PORTC & 0b00001111) | data;  // Setze D4-D7 (nur PORTC4-PORTC7)
  RS_LOW;                    // Setze LCD-Display in Datenmodus
  _E();
}  
                  
// Sende einen String zum LCD-Display
void SEND_STR(unsigned char* str)
{
  unsigned int i = 0;
  unsigned int k = 1;
  unsigned int l = 2;

  SEND_CMD(DD_RAM_ADDR);  // DD_RAM_ADDR: 1. Zeile vom Display

  while(str[i]!='\0')    // Schleife bis zum Ende des Strings
  {    
    SEND_CHAR(str[i]);  
        
    if (i == k*15)    // Wenn die 1. Zeile gefüllt ist, gehe in die 2-te
    {
      SEND_CMD(DD_RAM_ADDR2);  // DD_RAM_ADDR2: 2. Zeile vom Display
      k = k + 2;
    }
    if (i == l*15)    // Wenn die 2. Zeile gefüllt ist, gehe in die 1-te
    {
      SEND_CMD(DD_RAM_ADDR);
      l = l + 2;
    }

    i++;
  }
}

// Sende einen Integer zum LCD-Display
// Stellt nur runde Zahlen dar. Kommastellen werden abgeschnitten/ignoriert
void SEND_INT(long a)
{
  int C[20];
  unsigned char Temp=0, NumLen = 0;
  if (a < 0)            // Darstellung negativer Zahlen
  {
    SEND_CHAR('-');
    a = -a;
  }
  do
  {  
    Temp++;
    C[Temp] = a % 10;      // Integer durch 10 und modulo 10 rechnen, um jede einzelne Ziffer/Stelle der Zahl zu erhalten
    a = a/10;          // z.B. 124 -> Berechnung von 4 2 1
  }
  while (a);
  NumLen = Temp;
  for (Temp = NumLen; Temp>0; Temp--) 
  {
    SEND_CHAR(C[Temp] + 48);   // + 48 dez = + 30 hex = 0 in ASCII
  }
}
// Initialisiere die Ports
void PORT_Init()
{
 // Ports          Data direction register
  PORTA = 0b00000000;    DDRA = 0b01000000;  // Setze Relay/LED als Ausgang
  PORTB = 0b00000000;    DDRB = 0b00000000;
  PORTC = 0b00000000;    DDRC = 0b11110111;  // LCD-Display
  PORTD = 0b00000000;    DDRD = 0b00000000;  
  PORTE = 0b00000000;    DDRE = 0b00110000;  // Setze Buzzer als Ausgang (Bit4 = 1, Bit5 = 1)
  PORTF = 0b00000000;    DDRF = 0b00000000;  
  PORTG = 0b00000000;    DDRG = 0b00000000;  
}
/*
** Funktionen für die UART-Schnittstelle
*/

// Initialisiere den UART
void UART_Init(uint32_t Baud)
{
  unsigned int BaudRate = OSCSPEED / (16 * Baud) - 1;  // Asynchroner Modus, siehe Seite 173 im Handbuch

  UBRR1H = (unsigned char) (BaudRate>>8);    // Setze die BaudRate der Register UBRR1H und UBRR1L
  UBRR1L = (unsigned char) BaudRate;      // Wichtig: UBRRH muss vor UBRRL beschrieben werden.
  
  UCSR1A = 0b00000000;
  UCSR1B = (1<<TXEN1)|(1<<RXEN1);    // Senden und Empfangen
  UCSR1C = (1<<UCSZ11)|(1<<UCSZ10);  

//  UCSR1B = UCSR1B | 0b00011000;   // Ermögliche Empfangen und Senden (Bit3 = 1, Bit4 = 1)
//  UCSR1C = UCSR1C | 0b10000110;  // Setze Frame Format: 8 data (Bit1 = 1, Bit2 = 1), 1 stop bit (Bit3 = 0)
}

// Empfange Daten über UART nonstop
unsigned char UART_Receive(void)
{
  //   while(!(UCSR1A & (1<<RXC1)));
  if (UCSR1A & (1<<RXC1))  
    return UDR1;      
  else            
    return 0;
}

// Sende Daten über UART
void UART_Transmit(unsigned char data)
{
  while (!(UCSR1A & (1<<UDRE1)));  // Warte, bis Buffer bereit ist zum Empfangen

  UDR1 = data;          // Sende Daten
}

/*
** Funktionen zur Stringverarbeitung
*/


// Initialisiere Strings 
void Str_Init(char* str, char init)
{
  int j = 0;
  while (j<strlen(str))
  {
    str[j] = init;
    j++;
  }
}

// Zähle Kommas in String
int Str_Komma(char* str, int n) // n: Anzahl der Kommas entspricht dem Wert, der angezeigt werden soll z.B. Uhrzeit
{
  int summe = 0;
  int i = 0;
  for (i=0;i<strlen(str);i++)
  {
    if (str[i] == ',')
    {
      summe++;  // Anzahl der Kommas
    }
    if (summe == n)
    {
      return i+1; // Gebe die 1. Stelle nach dem Komma zurück
    }
  }
}

// Buzzer
void Buzzer(void)
{ 
  BUZZ1_LOW;      
  BUZZ2_HIGH;
  delay_us(125);
    BUZZ2_LOW;
  BUZZ1_HIGH;
  delay_us(125);
}

Es werden falsche Daten aus dem String gezeigt. Vorher wird zum Beispiel 
UTC: hh:mm:ss auf dem Display sekündlich aktualisiert und angezeigt. 
Nach dem Spannungsverlust wird auch weiterhin UTC:   :  :   dargestellt. 
Allerdings wird zwischen den Doppelpunkten nun nicht mehr die korrekte 
Uhrzeit angezeigt, sondern ein Schwall von Daten aus dem String.

Woran kann es liegen? Was verändert sich dadurch, wenn ich zunächst ein 
Demo-Code aufspiele und dann meinen Code? Ich bin ziemlich ratlos und 
wäre dankbar über jedigliche Hilfe.

Gruß Stefan

[Udo S. (urschmitt)]

Kommen denn nach dem Stromausfall noch korrekte Datensätze aus dem GPS 
Modul?
Wenn nein, dann stimmt die Initialisierung des GPS Moduls nicht.
Prüfen indem man die Daten zum PC sendet (Terminalprogramm)

[Michael (Gast)]

Ohne das jetzt durchzulesen: So lange Codes hängt man als Dateianhänge 
an und füllt nicht gleich mehrere Bildschirmseiten damit!

Netiquette -> Äußere Form -> Punkt 3

http://www.mikrocontroller.net/articles/Netiquette#.C3.84u.C3.9Fere_Form

[Karl H. (kbuchegg)]

Puh.
Du hast da ein ganz schönes Durcheinander in der Stringbearbeitung 
veranstaltet.

Dein
char Str[100];

ist zuallererst mal uninitialisiert.
Und daran ändert sich auch in weiterer Folge nichts. Du hast nirgends in 
deinem Code die Gewissheit, dass du es mit einem gültigen, sauberen 
String zu tun hast.

Wenn ich dir einen Vorschlag machen darf: Vergiss solche Funktionen wie 
Str_Init. Die wiegen dich nur fälschlich in Sicherheit, machen aber 
nicht das was du erwartest.

Kümmere dich bei der Stringverarbeiteung immer selbst darum, dass du am 
Ende eines Strings ein \0 Zeichen hast, welches den String terminiert. 
Solange dieses \0 Zeichen nicht an der richtigen Stelle ist, kannst du 
keine Funktionen wie strlen, strstr, etc. aufrufen!

zb hier

   Ch = UART_Receive(); // Aktuelles Zeichen einlesen                
      
    // Zeichen zwischen Anfang und Ende einlesen
    if (bed == 1 && Ch != '$' && Ch)                  
    {
      Str[k] = Ch;  
      k = k + 1;      
    }
    
    // Letztes Zeichen einlesen
    if (bed == 1 && Ch == '$')
    {

mach hinten an den String EXPLIZIT das \0 Zeichen rein und du hast es 
mit einem gültigen String zu tun, den du mit strstr untersuchen kannst

    // Letztes Zeichen einlesen
    if (bed == 1 && Ch == '$')
    {          
      Str[k] = '\0';
      ...

Genauso hier

    // Start zum Einlesen des Strings
    if (bed == 0 && Ch == '$')  // Zeichen $ leitet Datensatz ein
    {
      Str_Init(Str,'0');    // String Inhalt mit '0' initialisieren
[/C]
welches offenbar benutzt wird, um das erste mal auf den '$' zu 
synchronisieren. Du kannst hier nicht Str_Init aufrufen! Du hast noch 
keinen gültigen String in Str. Ganz abgesehen davon, was soll das 
bringen, da überall ein '0' reinzuschreiben? Das braucht kein Mensch.

    // Start zum Einlesen des Strings
    if (bed == 0 && Ch == '$')  // Zeichen $ leitet Datensatz ein
    {              
      Str[0] = '$';
      Str[1] = '\0';
      k = 1;    
    }

Im übrigen ist dein Code ziemlich unübersichtlich. Was soll 'bed' 
bedeuten? Offensichtlich ist das eine Variable, mit der du festhalten 
willst, ob sich dein Programm mit den GPS Daten synchronisiert hat. Dann 
nenn die Variable auch so und mach dir 2 große Blöcke in die Schleife:
* was soll mit dem Zeichen passieren, solange noch nicht synchronisiert 
wurde
* was soll mit dem Zeichen passieren, wenn sich das Programm auf den 
Anfang des NMEA Datensatzes synchronisiert hat.

Es gibt keinen Grund, dass du da 25 if hast, in denen du ständig bed 
abfrägst. Die erste Frage nach erhalt eines Zeichens lautet: Sind wir 
synchronisiert, ja oder nein.

  Synchronized = FALSE;

  while( 1 ) {

     ....

    Ch = UART_Receive();

    if( !Synchronized ) {

      if( ch == '$' ) {
        Str[0] = '$';
        Str[1] = '\0';
        k = 1;
        Synchronized = TRUE;
      }
    }

    else {
      if( Ch != '$' ) {
        Str[k++] = Ch;

      else {
        Str[k] = '\0';

        .... Diesen Datensatz auswerten

        .... und neuen anfangen
        Str[0] = '$';
        Str[1] = '\0';
        k = 1;
      }
    }
  }

(und wenn man sich das mal im Detail überlegt, benötigt eigentlich kein 
Mensch das '$' an der ersten Position im String. Denn dieses '$' steht 
sowieso IMMER String. Und wenn es sowieso IMMER vorhanden ist, dann 
braucht das auch keiner. Denn ob du "$GPGGA" in diesem String suchst, 
oder nur "GPGGA" macht auch keinen wirklichen unterschied mehr. Zumal du 
weißt, dass dieses GPGGA sowieso am Stringanfang vorkommen muss. D.h. du 
wirst da nicht strstr benutzen, sondern strncmp um abzutesten, ob die 
ersten 4 Buchstaben im String "GPGGA" lauten. In der traditionellen 
Kette "Eingabe - Verarbeitung - Ausgabe" gibt es 3(!) Stellen, an denen 
die Dinge schief gehen können. Ja, da gehört auch die Eingabe mit dazu. 
Also muss man das kontrollieren!



Soweit so gut. Du hast nämlich noch ein weiteres Problem: Deine 
Auswertung bzw. das Hinschreiben auf das LCD kostet alles Zeit. In 
dieser Zeit kann aber das GPS schon beginnen, den nächsten NMEA 
Datensatz rauszuschicken. Sobald du das erste Zeichen nicht richtig 
mitbekommst, ist deine ganze Auswertung gefährdet. D.h. der ganze Ansatz 
mit Polling der UART ist schon mal nicht der Schlaueste. Wenn du eine 
UART Gegenstelle nicht am Senden hindern kannst, dann brauchst du eine 
Interrupt-getriebene UART Empfangsroutine mit einer FIFO, welche die 
Zeichen mal kurz zwischenspeichert, solange dein Programm noch mit der 
Auswertung beschäftigt ist.

Und dann: ehe du dich an die Auswertung machst, SIEH DIR DEN STRING AN, 
DEN DEIN PROGRAMM EMPFANGEN HAT. Ich hab dir das damals schon ans Herz 
gelegt und ich tu es heute wieder! Wenn dein String, den du aus den 
Daten vom GPS empfängst schon nicht der ist, den du erwartest, dann 
kannst du auswerten bis du schwarz wirst - da kommt nichts gescheites 
raus! Also muss man das als allererstes kontrollieren! Was genau 
empfängt dein Programm vom GPS? Das ist die Frage, der du dich stellen 
musst. Ehe du das nicht weißt, brauchst du dich gar nicht daran 
versuchen mit den Daten (von denen du nicht weißt wie sie aussehen) 
irgendwas anzufangen.

[Stefan O. (oele22)]

Vielen Dank erst einmal für eure hilfreichen Kommentare!

@  Karl Heinz Buchegger

Was wäre denn die einfachste Möglichkeit sich den Inhalt des Strings 
anzeigen zu lassen?

Gruß Stefan

[Karl H. (kbuchegg)]

Stefan O. schrieb:

> Was wäre denn die einfachste Möglichkeit sich den Inhalt des Strings
> anzeigen zu lassen?

?
Du hast doch ein LCD, oder nicht?

[Stefan O. (oele22)]

Ich wollte eigentlich fragen, ob ich mir den Inhalt des Strings am PC 
anzeigen lassen kann. Ich würde den Inhalt des Strings gerne als ganzes 
sehen. Auf dem Display kann ich ja nur 16 Zeichen pro Zeile anzeigen 
lassen (Display hat 2 Zeilen).

[Karl H. (kbuchegg)]

Stefan O. schrieb:
> Ich wollte eigentlich fragen, ob ich mir den Inhalt des Strings am PC
> anzeigen lassen kann.

Tja.
Wenn du nicht noch eine UART hast oder einen Debugger, mit dem du den µC 
online debuggen kannst, dann ... gar nicht

> Ich würde den Inhalt des Strings gerne als ganzes
> sehen. Auf dem Display kann ich ja nur 16 Zeichen pro Zeile anzeigen
> lassen (Display hat 2 Zeilen).

Tja. Damit wirst du leben müssen, dass du nicht mehr Möglichkeiten hast. 
Du kannst nur das Beste daraus machen. (Aber wenn die ersten 10 Zeichen 
des Strings gut aussehen und die letzten 10 Zeichen, dann ist die 
Wahrscheinlichkeit schon sehr gross, dass der Rest dazwischen auch 
stimmt. Und bei 2 Zeilen a 16 Character, kannst du dir in den beiden 
Zeilen ja diese 'Stellvertreter' ausgeben lassen)

[Stefan O. (oele22)]

@ Karl Heinz Buchegger

Das Anzeigen des Strings auf dem LCD-Display habe ich getestet und es 
funktioniert gut. Der String wird mit dem richtigen Inhalt beschrieben. 
Ich habe es in HTerm verglichen.

Mein Programm habe ich so wie du es mir vorgeschlagen hast 
umstrukturiert. Der Initialisierungsfehler ist nun behoben :-).

Mein Problem ist nun, dass auf dem LCD-Display z.B. die Uhrzeit nun 4 
Sekunden lang kontinuierlich anzeigt wird und dann für 6 Sekunden stehen 
bleibt. Danach erst wird wieder die richtige Uhrzeit für weitere 4 
Sekunden kontinuierlich angezeigt, dann wieder Stillstand, usw..

Könnte dies daran liegen, wie du schon vermutet hast, dass ich keine 
Interrupt-getriebene UART Empfangsroutine benutze, sondern nur über 
Polling des UARTs? Oder könnte es auch noch ein anderer Grund sein?

Anbei der Code.

[Bonzo (Gast)]

Und dann ist noch alles blockierend geschrieben - uaaaaahhhhhhhhhhh

[Stefan O. (oele22)]

@ Bonzo:

Was meinst du mit "blockierend geschrieben"?

[Uwe (de0508)]

Stefan,

gemeint ist mit "blockierend" die vielen Delay.

Auf einem µC arbeitet man anderes -- eventorientiert, d.h.

Liegt ein RS232-Zeichen im Empfangspuffer vor, dann..

Wurde eine Taste gedrückt, losgelassen, lange gedrückt, usw.

Ist eine Zykluszeit, z.B. 1ms, abgelaufen, dann update das LCD und 
bearbeite Prozess 1, 2 ...

Schreibe ein Einfach zulese des Programm, verwende Funktionen zur 
Modularisierung und einfache zu lesende Programmanweisungen..

Kurz um Warten ist sehr schlecht.

[Bonzo (Gast)]

Blockierend bedeutet, es wird ueberall gewartet bis etwas beendet ist. 
Zum einen ist das schade fuer die Zeit, zum anderen kann ja etwas worauf 
man wartet nicht eintreten. Sowas ist dann extrem schwierig zu debuggen, 
der Prozessor wartet irgend wo.
Besser ist mit einer oder mehreren Zustandsmaschinen zu arbeiten. Und 
dann wird genau an einem Ort im ganzen Code gewartet, das waere dann der 
schnelle Poll-Loop im Main, der die verschiedenen Zustaende prueft und 
abarbeitet. Am Ende dieses Loops kann man dann, falls gewuenscht auch in 
den Sleep gehen.
Die Zusatndsmaschine ist viel einfacher zu debuggen, denn man kann ja 
den Zustand zB per serieller Schnittstelle oder per LED 
abfragen/aufgeben lassen.
Die einzelnen Interrupts machen nur was minimal zu tun ist, setzten eine 
Boolean und lassen den Prozessor im Main Lop das Passende erledigen.

[Stefan O. (oele22)]

Die delays werden in meinem Programm hauptsächlich nur bei der 
Initialisierung und dem Willkommensgruß verwendet. Was hat das damit zu 
tun, dass auf dem LCD-Display z.B. die Uhrzeit nun 4
Sekunden lang kontinuierlich anzeigt wird und dann für 6 Sekunden stehen
bleibt? Dies wiederholt sich dann periodisch...

[Karl H. (kbuchegg)]

>    Ch = UART_Receive(); // Aktuelles Zeichen einlesen

Das blockiert bis vom GPS das nächste Zeichen kommt

Und solange nicht ein kompletter Datensatz korrekt empfangen wird, gibt 
es auch keine Updates.

Ich sagte doch schon: lass dir endlich mal anzeigen, was du eigentlich 
empfängst. Du glaubst es ja nicht, dass man mit Stochern im Nebel nicht 
weiter kommt. Dann musst du es eben auf die harte Tour lernen.

Das wichtigste ist ja immer, dass es eine Wilkommensnachricht gibt :-)