Keine GPS Datenanzeige auf GLCD Display (Navilock 552ettl)

[Alex (Gast)]

Hallo liebe Forengemeinde,

nachdem ich mich dank euch und den wirklich guten Tutorials auf dieser 
Seite in die µC-Technik eingearbeitet habe, stehe ich nun vor einer 
schier unüberwindbaren Hürde und hoffe das ihr mir helfen könnt. In der 
Suchfunktion finde ich leider nur Infos für nicht GLCD Displays.
Ich möchte über ein 128x64 Pixel GLCD Display die Daten, die ich vom 
Navilock 552ettl GPS-Empfänger erhalte, anzeigen. Der C-Code 
funktioniert fast unverändert bei einem 16x2 LCD Display. Lediglich die 
Funktion lcd_puts_p wird dort durch lcd_string ersetzt.
Ich hoffe ihr könnt mir helfen. Im Anhang das Mainprogramm, welches sehr 
stark an Tutorials bzw. Forenbeiträge angelehnt ist.

Vielen Dank schonmal.

#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>
#include <string.h>

#include "Nmea2Gps.h"
#include "mylcd.h"
#include "small_font.h"
#include "mega.h"
#include "Grafiken.h"
#include "big_font.h"
#include "font6x8.h"

static char testString[] =
"$GPGGA,094149.000,5008.5464,N,01114.9928,E,1,8,1.00,290.4,M,47.7,M,,*5E\
$GPGLL,5008.5464,N,01114.9928,E,094149.000,A,A*59\
$GPGSA,A,3,23,31,13,11,20,17,25,04,,,,,1.66,1.00,1.33*05\
$GPGSV,3,1,12,23,84,151,20,20,58,094,29,13,51,221,17,04,44,298,39*77\
$GPGSV,3,2,12,32,31,092,,33,27,213,,25,20,170,25,17,19,238,29*7E\
$GPGSV,3,3,12,31,17,038,35,11,12,163,17,02,10,316,,07,03,179,*7E\
$GPRMC,094149.000,A,5008.5464,N,01114.9928,E,0.08,165.51,070509,,,A*6B\
$GPVTG,165.51,T,,M,0.08,N,0.15,K,A*37";


static void uart_init(void){
  #undef BAUD            // avoid compiler warning
  #define BAUD 38400UL
  #include <util/setbaud.h>
  UBRRH = UBRRH_VALUE;
  UBRRL = UBRRL_VALUE;
  #if USE_2X
  UCSRA |= (1 << U2X);
  #else
  UCSRA &= ~(1 << U2X);
  #endif
  UCSRB |= (1<<TXEN)|(1<<RXEN);
  //UCSRB |= (1<<RXEN);
  
  UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);  // Asynchron 8N1
}

uint8_t uart_getc(void){
  while (!(UCSRA & (1<<RXC)))   // warten bis Zeichen verfuegbar
  ;
  return UDR;                   // Zeichen aus UDR an Aufrufer zurueckgeben
}

void uart_gets( char* Buffer, uint8_t MaxLen ){
  uint8_t NextChar;
  uint8_t StringLen = 0;
  
  do{
    NextChar = uart_getc();
  }while(NextChar != 0);    // Warte auf erstes Zeichen
  
  while(NextChar != '*' && StringLen < MaxLen - 1){
    *Buffer++ = NextChar;
    StringLen++;
    NextChar = uart_getc();
  }
  
  *Buffer = '\0';          // Noch ein '\0' anhängen um einen Standard C-String daraus zu machen
}

int main (void)
{
    
//LCD initialisieren
  lcd_init();
  uart_init();
  lcd_clear();
  char gps_data[128];
  
  
while(1){
    uart_gets(gps_data, sizeof(gps_data));  //Navilock 552ETTL auslesen
    
    //lcd_set_cursor(0,LINE0);
    //lcd_puts_p(small_font,gps_data);
    
    lcd_set_cursor(0,LINE2);
    lcd_puts(small_font,gps_data);
    _delay_ms(12500);
    
    lcd_set_cursor(0,LINE2);        //Überprüfung ob Schleife bis hierher gelangt, wenn ja, wird uart_gets abgearbeitet
    lcd_puts_p(small_font,PSTR("Line"));
    
    _delay_ms(12000);
    lcd_clear();
    _delay_ms(1500);
    }
  return 0;
  
}

[Oliver S. (oliverso)]

Nun ja, das Problem liegt nicht in dem gezeigten Code. Wenn lcd_puts 
nichts ausgibt, klemmt es zwischen GLCD-lib und dem GLCD.

LCD richtig angeschlossen? GLCD-Lib richtig parametriert? usw...

Oliver

[Quack (Gast)]

Schritt 1: Frage formulieren.
Schritt 2: Code auf's Minimum reduzieren.
Schritt 3: Hardware zeigen.

[Alex (Gast)]

Danke für die Antwort Oliver.
 Das GLCD ist richtig angeschlossen. Die Anzeige "Line" geht auch. Habs 
etliche Male geprüft. Den Funktionscode hänge ich heute abend mit dran.

[Dieter F. (Gast)]

Alex schrieb:
> while(NextChar != '*' && StringLen < MaxLen - 1)

Einige Klammern würden dem C-Compiler deutlich machen, was in welcher 
Reihenfolge womit verglichen werden soll ...

[dummy (Gast)]

do{
    NextChar = uart_getc();
  }while(NextChar != 0);    // Warte auf erstes Zeichen


Sicher das du da nicht in einer Endloschleife kleben bleibst?
NMEA schickt so weit ich weiss keine binäre 0.

[Alex P. (alex2203)]

Die Punkte von dummy und Dieter Frohnapfel hab ich nun umgesetzt. Nun 
steht

while(NextChar != '$');    // Warte auf erstes Zeichen

und

while((NextChar != '*') && (StringLen < MaxLen - 1)){

im Code.
Anbei nun noch die Funktion lcd_puts. Die Microcontrollerei find ich 
echt geil und spannend aber solche Fehler kosten auch den letzten Nerv.

// ---------------------------------
// put string to screen (from ram)
// ---------------------------------
void lcd_puts(uint8_t* font,char* string)
{while(*string)lcd_putc(font,*string++);}

und da sie mit aufgerufen wird die lcd_puts_p...

void lcd_putc(uint8_t* font,uint8_t chr)
{
  uint8_t x,page,bit,data,cnt=0;
  
  if (font_char_present(font,chr)==1)  // print only if letter is present in font
  {
    if ( ( (cursor_x + font_char_width(font,chr)) <128)  && ((cursor_y+font_char_height(font))<=64))  // only print leeter if it fits in screen
    {
      uint16_t offset= font_start_offset(font,chr);  // get the position of the first byte in font-array
      
      for(page=0;page<=(font_char_height(font)-1)/8;page++)  // write all pages(rows)
      {
        lcd_write_cmd(LCD_SET_PAGE|((cursor_y/8)+page),CHIP1|CHIP2);  // calc the current page

        if (cursor_x<64)  // set cursor to its poition (0 on the inactive controller so it can start directly on chip change)
        {
          lcd_write_cmd(LCD_SET_ADD|cursor_x,CHIP1);
          lcd_write_cmd(LCD_SET_ADD|0,CHIP2);
        }
        else
        {
          lcd_write_cmd(LCD_SET_ADD|(cursor_x-64),CHIP2);        
        }

        for (x=cursor_x;x<cursor_x + font_char_width(font,chr);x++)  //fill "pages"
        {
          data= pgm_read_byte(font+offset+cnt++);

          if ( page==font_char_height(font)/8)    
            data>>=8-(font_char_height(font)%8);  // if char height is bigger than 8 we have to remove some leading zeros
          
          #ifdef FASTTEXT                // this is much much faster than using set_pixel (see discription in header file)
          if (cursor_y%8==0 )
          {
            if (x<64)                
              lcd_write_data(data,CHIP1);            
            else                  
              lcd_write_data(data,CHIP2);          
          }
          else
          #endif
          {
            for (bit=0;bit<8;bit++)
            {
              if ((data&(1<<bit))!=0)
               lcd_set_pixel(x,cursor_y+page*8+bit,BLACK);
            }
          }
        }      
        
        #ifdef FASTTEXT
        if(cursor_y%8==0)
        {
          if (x<64)                
            lcd_write_data(0,CHIP1);            
          else                  
            lcd_write_data(0,CHIP2);        
        }
        #endif
      }      
      cursor_x += font_char_width(font,chr)+1;


    }
  }
}

[Dieter F. (Gast)]

Habe es mal auf die Empfangsroutine (in dieser Form funktionierend) 
reduziert:

In lcd_puts steht jetzt natürlich nur ein Platzhalter ...

Die Klammern im Ausdruck "while((NextChar != '\n') && (StringLen < 
(MaxLen - 1)))" müssen IN DIESEM FALL nicht sein, dienen aber (für mich) 
der Lesbarkeit. Ich setze IMMER Klammern, dann weiß ich auch sicher, wie 
verglichen etc. wird.

Die Abfrage auf "*" habe ich auf Line-Feed angepasst, da der NMEA-String 
immer durch CR/LF abgeschlossen wird. CR lese ich auch ein, überschreibe 
es aber dann mit dem String-Ende-Marker.

#define BAUD 38400UL
#define F_CPU 16000000UL

#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>
#include <string.h>
#include <util/setbaud.h>


static void uart_init(void)
{  
  UBRRH = UBRRH_VALUE;
  UBRRL = UBRRL_VALUE;
  
  UCSRB |= (1<<TXEN)|(1<<RXEN);
  UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);  // Asynchron 8N1
}

uint8_t uart_getc(void)
{
  while ((UCSRA & (1 << RXC)) == 0);
  return UDR;                  // Zeichen aus UDR an Aufrufer zurueckgeben
}

void uart_gets( char* Buffer, uint8_t MaxLen )
{
  uint8_t NextChar;
  uint8_t StringLen = 0;
  
  NextChar = uart_getc();
    
  while((NextChar != '\n') && (StringLen < (MaxLen - 1)))
  {
    *Buffer++ = NextChar;
    StringLen++;
    NextChar = uart_getc();
  }

  *--Buffer = '\0';                // Noch ein '\0' statt CR anhängen um einen Standard C-String daraus zu machen
}



// ---------------------------------
// put string to screen (from ram)
// ---------------------------------
void lcd_puts(uint8_t test)
{
  static uint8_t Test;
  
  Test++;
}


int main (void)
{
  uart_init();
  char gps_data[128];

  while(1)
  {
    uart_gets(gps_data, sizeof(gps_data));  //Navilock 552ETTL auslesen

    lcd_puts(1);
  }
  return 0;

}

[holger (Gast)]

Was soll uns dein neues Programm jetzt sagen?
Welchen Controller verwendest du eigentlich?

[Dieter F. (Gast)]

@holger: Meinst Du mich?

Alex soll es sagen, dass die "vorgestellte" Empfangsroutine sicher 
funktioniert und er seine LCD-Ausgaben Schritt für Schritt dazupacken 
kann.

Ich verwende den ATMEGA32, da mir die Register bekannt vorkamen und Alex 
vermutlich auch einen ATMEGAxx einsetzt.

[Alex P. (alex2203)]

Hallo Dieter,
danke für die Mühe. Leider ist das Ergebnis unverändert. Ich besitze ein 
KS0108 compatibles 128x64 Grafik LCD Display. Ich muss doch bei lcd_gets 
noch die Schriftart dazu reinschreiben oder? (sprich: 
lcd_gets(Schriftart, Char-Array).
Ich bin bald echt am verzweifeln. Das Ganze ist für ein Schulprojekt zum 
Elektrotechniker. Bin kurz davor ein 4x20 Zeilen Display zu nehmen, 
wobei man natürlich mit nem GLCD wesentlich mehr machen könnte. Ich 
hoffe euch fällt da noch was ein wie ihr mich auf die richtige Spur 
bringt. Habe Spaßeshalber mal nach Deklarierung des Char Arrays (somit 
vor Beginn der While(1) Schleife sowie nach der uart_gets(...) Zeile 
eine einfache Textzeile eingefügt. Der Text nach der uart_gets wird 
nicht angezeigt. Das bedeutet doch das er uart_gets nicht abarbeitet 
oder irre ich mich da?
Ich nutze übrigens einen Atmega16. Momentan noch mit 8Mhz internen Takt.

[Mike (Gast)]

Alexander Plöger schrieb:
> Der Text nach der uart_gets wird
> nicht angezeigt. Das bedeutet doch das er uart_gets nicht abarbeitet
> oder irre ich mich da?

Lass dir doch über irgendwelche freien Pins Signale ausgeben, anhand 
derer du auf einem Oszi oder LA verfolgen kannst, wo sich das Programm 
gerade rumtreibt. Textausgaben können das Timing des Programms ziemlich 
durcheinander bringen.

[Dieter F. (Gast)]

Alexander Plöger schrieb:
> Das bedeutet doch das er uart_gets nicht abarbeitet
> oder irre ich mich da?

Hallo Alexander,

ich bin sicher (mit HTERM als "GPS-Ersatz" ausprobiert), dass die 
USART-Routinen in meinem angepassten Beispiel funktionieren.

Mit der Lib, die Du verwendest, habe ich noch nicht gearbeitet. Ich 
vermute, Du nutzt die von

Author: Andre Fabricius  (mailto:[e-mail]) 
Date: 13.08.08 18:32

Ich habe nur diese, relativ alte, Version gefunden. Die Angabe der 
Schriftart ist bei LCD_PUT.. immer erforderlich, soweit ich sehe.

Nimm doch mal bitte die Definition

char gps_data[128];

aus main() raus und stelle diese im Anschluss die #include-Statements 
ein. Ich bin mir da nicht sicher, aber ggf. liegt es an der fehlenden 
globalen Definition dieser String-Variablen, dass LCD_PUT.. nichts damit 
macht.

Im Schlimmst-Fall kannst Du mir auch mal das komplette Programm (falls 
Du nicht "öffentlich" werden willst auch per PN) senden und ich debugge 
es mal (habe ein JTAGICE). Ich verfüge zwar nicht über das entsprechende 
Display, aber ich kann schauen, wie die Funktionen aufgerufen werden 
bzw. mit welchen Inhalten.

[Alex P. (alex2203)]

Also, ich habe nun das Char Array aus Main rausgenommen... keine 
Änderung. Danke für dein Angebot Dieter. Ich hab dir ne PN geschickt. 
Ich würd dir für die Lösung sogar mein Display zukommen lassen ;) 
(kleiner Spaß).

Danke schonmal für die Mühe. Auch allen anderen für die Antworten. Ein 
wirklich sehr gutes und kompetentes Forum :)

Gruß

[Karl H. (kbuchegg)]

Ich würd mir ja mal hier

uint8_t uart_getc(void)
{
  while ((UCSRA & (1 << RXC)) == 0);
  return UDR;                  // Zeichen aus UDR an Aufrufer zurueckgeben
}

eine zusätzliche Ausgabe des gerade empfangenen Zeichens einbauen.
Mitlesen zu können, was vom GPS kommt und ab wann es dann klemmt, könnte 
einigen Aufschluss darüber geben, was da im System los ist.

[Dieter F. (Gast)]

Alexander Plöger schrieb:
> Ich hab dir ne PN geschickt.

Hallo Alexander,

mache ich heute Abend. Ein virtuelles Weizenbier ist immer willkommen 
:-)

Gruß
Dieter

[Dieter F. (Gast)]

Hallo Alexander,

aus einem anderen Post hier habe ich:

In der wait_while_chip_is_busy() Funktion muss es statt

  LCD_CMD_PORT &= ~(1<<CD);
  LCD_CMD_PORT |=(1<<RW)|(1<<EN);
  _delay_us(1);

heissen:

  LCD_CMD_PORT &= ~(1<<CD);
  LCD_CMD_PORT |=(1<<RW);
  LCD_CMD_PORT |= (1<<EN);
  _delay_us(1);

Macht Sinn (und ist lt. Datenblatt auch erforderlich), dass zunächst 
Read/Write gewählt wird und etwas später (Tasu - ist zwar im Datenblatt 
gezeichnet aber nicht in ns angegeben) - ich würde mal mindestens 10 ns 
analog Tah nehmen - der Enable-Impuls kommt.
Die Ausführungszeit der Zuweisung LCD_CMD_PORT |=(1<<RW); reicht dafür 
dann (bei 8 MHz Takt) wahrscheinlich aus.

Die busy-Flag-Abfrage nutze ich eigentlich nie bei den LCD-Displays 
(weil ich auch mit SPI-Ansteuerung "herumspiele") und setze statt dessen 
immer auseichende _delay(..)-Statements ein. Wird im vorgenannten Post 
auch beschrieben.

Ist aber egal, wenn mit dieser Korrektur alles läuft kannst Du ja auch 
nicht meckern :-)

Falls ich keine Erfolgsmeldung von Dir lese debugge ich heute Abend ...

Gruß
Dieter

[Dietrich L. (dietrichl)]

Alexander Plöger schrieb:
> Ich nutze übrigens einen Atmega16. Momentan noch mit 8Mhz internen Takt.

Ist der Takt für die Baudrate vielleicht nicht genau genug?
Außerdem vermisse ich

#define F_CPU 8000000UL

am Programmanfang.

Gruß Dietrich

[Alex P. (alex2203)]

Also ich hab nun die Lösungsvorschläge eingearbeitet und ausprobiert. 
Alle ohne Erfolg. Ich komm einfach nicht drauf, wieso er in den Code 
geschriebene Texte und zB von Int nach String umgewandelte Variablen 
anzeigt aber das GPS Signal nicht....

[holger (Gast)]

>Also ich hab nun die Lösungsvorschläge eingearbeitet und ausprobiert.
>Alle ohne Erfolg. Ich komm einfach nicht drauf, wieso er in den Code
>geschriebene Texte und zB von Int nach String umgewandelte Variablen
>anzeigt aber das GPS Signal nicht....

Zeig dein komplettes Programm. Woher soll jemand wissen
welchen Bockmist du da jetzt schon wieder eingebaut hast?

[Alex (Gast)]

Niveau wird nicht in blauen Dosen verkauft Holger. Außer nicht 
konstruktiver Kritik kam von dir hier auch noch nichts! Spar sie dir für 
jemand anderen um dort dein Unwissen zu verbergen.

[holger (Gast)]

>Niveau wird nicht in blauen Dosen verkauft Holger. Außer nicht
>konstruktiver Kritik kam von dir hier auch noch nichts!

Doch, aber unter anderem Namen.

>Spar sie dir für
>jemand anderen um dort dein Unwissen zu verbergen.

Kein Sourcecode, keine Antworten.
Mal sehen wer länger durchhält.

[Alex P. (alex2203)]

Ja, schauen wir mal.
@ Dietrich. Danke für den Hinweis :) Im Code isses eingetragen, 
anscheinend hats das (hab ich es zwinker ) hierher aber nicht 
übertragen.

Gruß

Alex

[dummy (Gast)]

>Der Text nach der uart_gets wird
>nicht angezeigt. Das bedeutet doch das er uart_gets nicht abarbeitet
>oder irre ich mich da?

Richtig. Der bleibt scheinbar einfach hängen.

>Ich nutze übrigens einen Atmega16. Momentan noch mit 8Mhz internen Takt.

Hast du mal kontrolliert ob der auch mit 8MHz läuft?
Vieleicht läuft der ja nur mit 1MHz. Fuses?
Dann stimmt die Baudrate nicht. Oder es kommt gar kein
GPS Signal am ATMega an.

Das sind die Dinge die du kontrollieren musst.

[spess53 (Gast)]

Hi

>Dann stimmt die Baudrate nicht. Oder es kommt gar kein
>GPS Signal am ATMega an.

Mit dem internen RC-Oszillator ist die korrekte Baudrate eher 
Glückssache.

MfG Spess

[Alex (Gast)]

Ich danke Dieter auf diesem Wege auch nochmals für die Lösung meines 
Problems :)
Es lag an verschiedenen Kleinigkeiten. U.a. das die Schriftart static 
und nicht const war.

Danke dir. Prost :D


Alex