Anzeige verschiedener Inhalte auf LCD

[Jörg D. (misterbf)]

Hallo zusammen,

Ich habe mal wieder ne kleine Hirnblockade, und brauchte von euch einen 
kleinen Wink mit dem Zaunpfahl.

Ich gebe den Inhalt des PIN C und B Register auf einem LCD aus, bzw 
möchte zwischen den den PINs hin und herschalten über eine binäre 
Auswertung.
Also drücke eine Taste und das LCD schaltet von PINC auf PINB und 
umgekehrt.

also die Anzeige eines PIN funktioniert, allerdings bereitet mit das 
löschen der Anzeige via lcd_clear() etwas Probleme weil die Anzeige 
anfängt zu flackern. das ist der Grundcode :

#include <avr/io.h>
#include "lcd-routines.h"
#include <util/delay.h> 

int main(void)
{
  
  lcd_init();            // Initialisierung des LCD
                  
                  //Beispiele für die LCD Ausgabe    
                  /*                    
                    Beispiel für die Ausgabe auf dem LCD Display 
 
                    lcd_setcursor(0, 1 );
                    lcd_string("Hello World");
                    lcd_setcursor(0, 2 );
                    lcd_string("Hello World");
                    lcd_setcursor(0, 3 );
                    lcd_string("Hello World");
                    lcd_setcursor(0, 4 );
                    lcd_string("Hello World");
                    
                    Text in einzelnen Zeichen ausgeben
                    
                    lcd_data( 'T' );
                    lcd_data( 'e' );
                    lcd_data( 's' );
                    lcd_data( 't' );
                  
                  */
DDRB=0x00;
PORTB=0xff;
DDRC=0x00;
PORTC=0xff;
 
  while(1)
  {
  if(!(PINC&0x01))
  {ausgabe_b();
  if(!(PINC&0x02))
  {ausgabe_c();}
    
  
  }
 
  return 0;
}
void ausgabe_b(void)
{
  int i = 0;
  char Buffer[20];
  
lcd_setcursor(0, 1 );      //PB0

lcd_string("PB0 = ");
if(!(PINB&(1<<PB0)))
{i=0;}
else
{i=1;}
itoa( i, Buffer, 10 );
lcd_string( Buffer );

lcd_setcursor(8, 1 );      //PB4

lcd_string("PB4 = ");
if(!(PINB&(1<<PB4)))
{i=0;}
else
{i=1;}
itoa( i, Buffer, 10 );
lcd_string( Buffer );

lcd_setcursor( 0, 2 );      //PB1

lcd_string("PB1 = ");
if(!(PINB&(1<<PB1)))
{i=0;}
else
{i=1;}
itoa( i, Buffer, 10 );
lcd_string( Buffer );

lcd_setcursor(8, 2 );      //PB5

lcd_string("PB5 = ");
if(!(PINB&(1<<PB5)))
{i=0;}
else
{i=1;}
itoa( i, Buffer, 10 );
lcd_string( Buffer );

lcd_setcursor( 0, 3 );      //PB2

lcd_string("PB2 = ");
if(!(PINB&(1<<PB2)))
{i=0;}
else
{i=1;}
itoa( i, Buffer, 10 );
lcd_string( Buffer );

lcd_setcursor(8, 3 );      //PB6

lcd_string("PB6 = ");
if(!(PINB&(1<<PB6)))
{i=0;}
else
{i=1;}
itoa( i, Buffer, 10 );
lcd_string( Buffer );

lcd_setcursor( 0, 4 );      //PB3

lcd_string("PB3 = ");
if(!(PINB&(1<<PB3)))
{i=0;}
else
{i=1;}
itoa( i, Buffer, 10 );
lcd_string( Buffer );

lcd_setcursor(8, 4 );      //PB7

lcd_string("PB7 = ");
if(!(PINB&(1<<PB7)))
{i=0;}
else
{i=1;}
itoa( i, Buffer, 10 );
lcd_string( Buffer );  

}
void ausgabe_c(void)
{
int j = 0;
char Buffer_1[20];

lcd_setcursor(0, 1 );      //PC0

lcd_string("PB0 = ");
if(!(PINC&(1<<PC0)))
{j=0;}
else
{j=1;}
itoa( j, Buffer_1, 10 );
lcd_string( Buffer_1 );

lcd_setcursor(8, 1 );      //PC4

lcd_string("PB4 = ");
if(!(PINC&(1<<PC4)))
{j=0;}
else
{j=1;}
itoa( j, Buffer_1, 10 );
lcd_string( Buffer_1 );

lcd_setcursor( 0, 2 );      //PC1

lcd_string("PB1 = ");
if(!(PINC&(1<<PC1)))
{j=0;}
else
{j=1;}
itoa( j, Buffer_1, 10 );
lcd_string( Buffer_1 );

lcd_setcursor(8, 2 );      //PC5

lcd_string("PB5 = ");
if(!(PINC&(1<<PC5)))
{j=0;}
else
{j=1;}
itoa( j, Buffer_1, 10 );
lcd_string( Buffer_1 );

lcd_setcursor( 0, 3 );      //PC2

lcd_string("PC2 = ");
if(!(PINC&(1<<PC2)))
{j=0;}
else
{j=1;}
itoa( j, Buffer_1, 10 );
lcd_string( Buffer_1 );

lcd_setcursor( 0, 4 );      //PC3

lcd_string("PC3 = ");
if(!(PINC&(1<<PC3)))
{j=0;}
else
{j=1;}
itoa( j, Buffer_1, 10 );
lcd_string( Buffer_1 );

}

So wenn ich jetzt am Ende der Unterprogramme ein lcd_clear setze dann 
fängt die Anzeige an zu flimmern.
Ich bin leider noch sehr unerfahren das das programmieren angeht, daher 
meine  kleine Blockade.
Wie kann ich sowas an sinnvollsten lösen ?

[Karl H. (kbuchegg)]

Jörg Drösser schrieb:

> So wenn ich jetzt am Ende der Unterprogramme ein lcd_clear setze dann
> fängt die Anzeige an zu flimmern.
> Ich bin leider noch sehr unerfahren das das programmieren angeht, daher
> meine  kleine Blockade.
> Wie kann ich sowas an sinnvollsten lösen ?

indem du lcd_clear nur dann benutzt, wenn sich die komplette Anzeige 
deines LCD ändert. In allen anderen Fällen willst du möglichst mittels 
Überschreiben auskommen bzw. Teile die sich nicht geändert haben auch 
nicht neu schreiben.

Du machst dir also ein Flag, welche der beiden PINB oder PINC gerade 
angezeigt wird. Und nur dann, wenn das anzuzeigende von dem was 
angezeigt wird unterscheidet, nur dann löscht du das LCD (wenn 
überhaupt: PINB und PINC sind gleich lange Texte, wenn man den einen mit 
dem anderen überschreibt, dann wird vollständig berschrieben).

lcd_clear ist eine Funktion, die du nicht verwenden willst. Es sei denn, 
das generelle Layout deiner Anzeige ändert sich radikal. Aber ansonsten 
willst du immer nur nach möglichkeit einen bereits angezeigten Wert 
(oder Text) mit einem neuen überschreiben. Aber bitte so, dass auch 
vollständig überschrieben wird und danach keine Artefakte sichtbar 
bleiben.

Und formatier deinen Code besser. Da kriegt man ja Augenkrebs!

[foo (Gast)]

Der Code ist so absolut nicht zu lesen, weil sämtliche Einrückung fehlt. 
Das hilft einem übrigens auch gerade als Anfänger selbst weiter. Wenn 
man sich mangels Einrückung in seinem eigenen Code nicht mehr 
zurechtfindet, fängt man irgendwann an, Code an zufällige Stellen 
einzufügen bis es irgendwann klappt.

Im Übrigen fehlt dir wahrscheinlich bei "{ausgabe_b();" die schließende 
geschweifte Klammer.

Jörg Drösser schrieb:
> So wenn ich jetzt am Ende der Unterprogramme ein lcd_clear setze dann
> fängt die Anzeige an zu flimmern.

Ich würde sagen, das liegt daran, dass das von der Hauptschleife aus 
ohne jegliche Verzögerung immer wieder aufgerufen wird ohne irgendeine 
Art von Delay dazwischen.

D.h. du siehst die Anzeige nur für die kurze Zeit, in der sie bereits 
geschrieben, aber noch nicht gecleart wurde, und das liegt bestenfalls 
im Millisekundenbereich.

Auf jeden Fall würde ich die Anzeige clearen, bevor du den Text 
ausgibst, und nicht direkt nach der Ausgabe den Text wieder löschen.

> Wie kann ich sowas an sinnvollsten lösen ?

Ich würde außerdem irgendwo ein Delay o.ä. einbauen, da du den Text 
ständig neu ausgibst solange du deinen Taster o.ä. gedrückt hältst 
(wodurch auch ständig das Display gecleart werden muss, was sich in 
Flackern äußern kann). Würde in der main nach den Aufrufen von 
ausgabe_b/c ein _delay_ms(1) o.ä. einbauen.

[Karl H. (kbuchegg)]

Das hier

if(!(PINB&(1<<PB5)))
{i=0;}
else
{i=1;}
itoa( i, Buffer, 10 );
lcd_string( Buffer );

ist ja wohl an kompliziertheit kaum noch zu überbieten.

Was ist falsch an

  if(!(PINB&(1<<PB5)))
    lcd_string( "0" );
  else
    lcd_string( "1" );

oder aber, wenn man realisiert, dass das eigentlich für alle Pins 
ohnehin immer gleich ist: was ist falsch daran eine Funktion zu machen, 
der man übergibt: einen Text, einen Wert der entweder 0 oder nicht 0 
sein kann und eine Position an der das ganze anfangen soll.

void showValue( uint8_t zeile, uint8_t spalte, char* txt, uint8_t wert )
{
  lcd_setcursor( zeile, spalte );
  lcd_string( txt );

  if( wert )
    lcd_string( "1" );
  else
    lcd_string( "0" );
}

und das ganze wird dann benutzt

void ausgabe_b(void)
{
  showValue( 0, 1, "PB0 = ", PINB&(1<<PB0) );
  showValue( 8, 1, "PB4 = ", PINB&(1<<PB4) );
  showValue( 0, 2, "PB1 = ", PINB&(1<<PB1) );
  showValue( 0, 2, "PB5 = ", PINB&(1<<PB5) );
  showValue( 0, 3, "PB2 = ", PINB&(1<<PB2) );
  showValue( 8, 3, "PB6 = ", PINB&(1<<PB6) );
  showValue( 0, 4, "PB3 = ", PINB&(1<<PB3) );
  showValue( 8, 4, "PB7 = ", PINB&(1<<PB7) );
}

80% Code eingespart. Übersichtlichkeit trotzdem (oder gerade deswegen?) 
drastisch erhöht.


Wenn du Code schreibst, dann lehn dich immer wieder auch mal zurück und 
frag dich: kann ich das ganze nicht einfacher formulieren?
Speziell wenn du Code immer einfach nur weiter kopierst und Einzelteile 
durch andere ersetzt, dann solltest du dich fragen, ob es nicht 
angebracht wäre das ganze in eine Funktion zu verpacken. Wie man sieht 
kann das drastische Unterschiede ausmachen.

[Jörg D. (misterbf)]

Danke schon mal für die Antworten.

Das mit der geschweiften Klammer habe ich auch gerade gemerkt. :-)

Im Bezug aufs Formatieren habe ich keinerlei Vorgaben wie man das 
sinnvoll oder optisch besser gestaltet. bitte mal beispiele geben damit 
ich weiss wie Ihr das meint dann ändere Ich gerne den Code ab.

@ Karl Heinz: Was meinst du mit Flag ( sorry für die Frage, aber das 
sagt mir so jetzt nicht direkt was) Bin wie gesagt in der Thematik nicht 
zuhause und stehe noch am Anfang.

@ Foo : Die Anzeige soll ja ständig aktuell sein. heisst ändert sich was 
am PIN soll das direkt angezeigt werden, daher lasse ich das LCD 
zyklisch schreiben. Das mit dem Delay habe ich schon versucht und das 
flackert ebenfalls. Auch mit einem Delay von 100 ms

[Karl H. (kbuchegg)]

Jörg Drösser schrieb:
> Danke schon mal für die Antworten.
>
> Das mit der geschweiften Klammer habe ich auch gerade gemerkt. :-)
>
> Im Bezug aufs Formatieren habe ich keinerlei Vorgaben wie man das
> sinnvoll oder optisch besser gestaltet. bitte mal beispiele geben damit
> ich weiss wie Ihr das meint dann ändere Ich gerne den Code ab.

Sieh dir einfach mal an, wie andere das machen.

Eine simple Regel
nach einer { wird grundsätzlich nicht in derselben Zeile 
aweitergeschrieben. Jede Anweisung (auch wenn { jetzt in dem Sinn keine 
'Anweisung' ist) kommt auf eine neue Zeile

nach einer { wird das im {} Block eingeschlossene eingerückt. Ob das 
jetzt 2 oder 4 Zeichen sind, ist erst mal nicht so wichtig. Wichtig ist, 
das eingerückt wird!

Die Einrückung wird bei der schliessenden } wieder aufgehoben. Die } 
selber kommt wieder um die Einrückungstiefe weiter nach links.

Enthält ein {}-Block selbst wieder weitere {, dann wird 
selbstverständlich auch weiter eingerückt.

Ob man bei if und lediglich einer einzigen abhängigen Anweisung 
{}-Klammern macht oder nicht, ist in weiten Grenzen Geschmackssache. Ich 
mach sie nicht oder selten, andere machen das generell.
Wichtig ist aber: die abhängige Anweisung kommt auf ihre eigene Zeile 
und wird eingerückt.

Die Einrückung zeigt dir optisch an, welche Programmteile von anderen 
Programmteilen abhängig sind. In

  if( wert )
    lcd_string( "1" );
  else
    lcd_string( "0" );

kann man aus 3 Meter Entfernung sehen (selbst wenn man es nicht lesen 
kann), dass da 2 Anweisungen offenbar von irgendetwas abhängen.

> @ Karl Heinz: Was meinst du mit Flag ( sorry für die Frage, aber das
> sagt mir so jetzt nicht direkt was) Bin wie gesagt in der Thematik nicht
> zuhause und stehe noch am Anfang.

uint8_t momentaneAnzeige;   // 0 = jetzt wird gerade PINB angezeigt
                            // 1 = jetzt wird gerade PINC angezeigt

int main()
{
  uint8_t anzuzeigenIst = 0;   // selbe Bedeutung wie momentane Anzeige

  ....

  while( 1 )
  {

    if( !(PINC&0x01) )
      anzuzeigenIst = 0;   // PINB soll angezeigt werden

    if( !(PINC&0x02) )
      anzuzeigenIst = 1;  // PINC soll angezeigt werden

    if( momentanteAnzeige != anzuzeigenIst )
      lcd_clear();
     
    if( anzuzeigenIst == 0 )
      ausgabe_b();
    else
      ausgabe_c();

    momentaneAnzeige = anzuzeigenIst;
  }
}

Der lcd_clear wird nur dann ausgeführt, wenn die Anzeige (auf 
Benutzerwunsch) von B auf C wechselt oder umgekehrt.

Ein FLag ist einfach nur eine Variable, die mit ihrem Wert etwas über 
eienn Zustand ausdrückt. So wie hier: die Bits welches PINx werden 
gerade angezeigt.

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

>> Das mit der geschweiften Klammer habe ich auch gerade gemerkt. :-)

Sowas

  while(1)
  {
  if(!(PINC&0x01))
  {ausgabe_b();
  if(!(PINC&0x02))
  {ausgabe_c();}
    
  
  }

geht gar nicht.
Wenn man das mal nach simplen FOrmatierregeln formatiert, dann erhält 
man

...
  while(1)
  {
    if(!(PINC&0x01))
    {
      ausgabe_b();

      if(!(PINC&0x02))
      {
        ausgabe_c();
      }
    }

    return 0;
  }

da die Funktion main() nach dem return zu Ende sein soll, die letzte 
schliesende } aber nicht am linken Rand landet, muss daher irgendwo ein 
Klammerfehler vorliegen.

Formatiert man das nach der (erkennbaren) Absicht

...
  while(1)
  {
    if(!(PINC&0x01))
    {
      ausgabe_b();

    if(!(PINC&0x02))
    {
      ausgabe_c();
    }
  }

  return 0;
}

dann landet die letzte } der Funktion zwar dort wo sie hingehört, aber 
man sieht sofort, dass hier

    if(!(PINC&0x01))
    {
      ausgabe_b();

    if(!(PINC&0x02))

offenbar eine schliessende } Klammer fehlt. Denn das zweite if kann 
nicht um 2 Zeichen ausgerückt sein, ohne das vorher eine schliessende } 
kommt, wenn die Einrückung wegen einer { erfolgt ist. Auch sieht man, 
indem man in derselben Spalte wie die öffnende { die Zeilen darunter 
absucht, dass es die zugehörige } nicht gibt. Öffnende { und 
schliessende } stehen immer in derselben Spalte und dazwischen kann es 
keine Zeile geben, die in derselben Spalte anfängt.
D.h. man hat 2 optische Indizien für denselben Sachverhalt: du hast eine 
} vergessen.


DAS ist der Wert einer ordentlichen Formatierung. Sie hilft dir Fehler 
zu finden. Und zwar rein nur dadurch, dass die Optik 'nicht stimmt'.
Daher ist auch die oft gehörte Aussage "Formatierung mach ich nachher, 
jetzt such ich erst mal den Fehler" Unsinn. Denn viele Fehler kann man 
ganz einfach vermeiden, INDEM man ordentlich formatiert.

[foo (Gast)]

Jörg Drösser schrieb:
> @ Foo : Die Anzeige soll ja ständig aktuell sein.

"Ständig aktuell" gibt es nicht, es wird mit Sicherheit immer einige 
CPU-Takte hinterher hängen ;)

Immer aktuell (im Rahmen des technisch möglichen) und ohne überflüssige 
Neuanzeigen würdest du mit der Lösung von Karl-Heinz (erste Antwort) 
erreichen.

Der Vorschlag mit dem Delay war als Idee gedacht, falls eine leichte 
Verzögerung ggf auch ausreicht, dann wäre das nämlich noch einfacher zu 
implementieren gewesen.

> Das mit dem Delay habe ich schon versucht und das
> flackert ebenfalls. Auch mit einem Delay von 100 ms

Entweder du hast das Delay nach dem Clear (dann hast du 100ms lang 
nichts auf dem Display stehen -> flackert) oder du meinst das 
Restflackern, welches bei einem Clear immer auftritt und sich nicht 
vermeiden lässt, egal wie schnell das Display wieder neu beschrieben 
wird. In letzterem Fall hilft dir auch wieder die erste Antwort von 
Karl-Heinz: überschreibe den existierenden Inhalt nur.

[Jörg D. (misterbf)]

ok ,

Ich danke schon mal für die Vielen hilfreichen Tipps.
Ich werde in den nächsten Zwei wochen im Urlaub nicht sonderlich oft 
dazu kommen was auszuprobieren aber wenn doch bekommt Ihr natürlich 
bescheid.

Danke schon mal


LG