Display Anzeige aktualisieren

[Isildur (Gast)]

Servus,

ich versuche einmal mein Problem verständlich zu schildern:
ich habe eine Funktion realisiert, die 30 Stellen auf einem Display 
ausgeben kann. Nennen wir diese Funktion meinetwegen sendedisplay(). In 
dieser Funktion werden jetzt die jeweiligen Stellen auf dem Display 
abgefahren.

sendedisplay()
{
sende(stelle1);
sende(stelle2);
sende(stelle3);
...
}

Diese sende Funktion würde ich am liebsten immer aktualisieren lassen, 
beispielsweise in der while-Schleife und nur die Variablen stelle1, 
stelle2, stelle3 ... aktualisieren.

Ich hoffe das Problem einigermaßen verständlich erläutert zu haben. Wie 
lässt sich das realisieren. Ich verlange keine Komplettlösungen, sondern 
nur einige Anregungen und Links.

Besten Dank

[Conny G. (conny_g)]

Na, so: :-)

sendedisplay()
{
   sende(stelle1);
   sende(stelle2);
   sende(stelle3);
...
}

main 
{
   while(1) {
      sendedisplay();
   }
}

Das ist natürlich nur ein Scherz, Du hast die Frage sicher anders 
gemeint. Und zwar, wie Du das PLUS weitere Aktionen auf dem 
Mikrocontroller unterbekommen kannst.

Das geht z.B. ungefähr so:
- über einen Interrupt passieren irgendwelche Dinge, sagen wir mal es 
werden Taster abgefragt
- dieser Interrupt setzt dann eine Variable, sagen wir ein "keyUp"-Flag
- in der Hauptschleife fragst Du das keyUp ab und erhöhst dann eine 
Variable, die dann wieder auf das Display ausgegeben werden soll

Dann sieht das ganze so aus:

volatile uint8_t keyUp;
volatile uint8_t counter;

_ISR(INT0_vect)
{
   if (pin = HIGH) {
      keyUp = 1;
   }
}

sendedisplay()
{
   sende(stelle1);
   sende(stelle2);
   sende(stelle3);
}

main 
{
   while(1) {
      if (keyUp) {
         counter++;
      }
      sendedisplay();
   }
}

ACHTUNG: das ist nur mal schnell runtergekippt und nicht 
notwendigerweise compilierbar!

Als wird in der Hauptschleife einerseits auf Ereignisse reagiert, 
andererseits immer das Display ausgegeben.
Das kannst jetzt auch noch erweitern und z.B. das Display nur jede 
Sekunde aktualisieren, indem ein Timer-Interrupt jede Sekunde ein Flag 
setzt, das Deiner Hauptschleife sagt, es soll das Display aktualisieren:

volatile uint16_t ticks;
volatile uint8_t sekunde;
volatile uint8_t keyUp;
volatile uint8_t counter;

_ISR(TIMER0_OVF)
{
    ticks++;
    if (ticks > 1000) {
      sekunde = 1;
    }
}

_ISR(INT0_vect)
{
   if (pin = HIGH) {
      keyUp = 1;
   }
}

sendedisplay()
{
   sende(stelle1);
   sende(stelle2);
   sende(stelle3);
}

main 
{
   while(1) {
      if (keyUp) {
         counter++;
      }
      if (sekunde) {
         sendedisplay();
         sekunde = 0;
      }
   }
}

(Btw, nachlesen, was das volatile bedeutet und wie man in der 
Hauptschleife "atomic" auf die Variablen zugreift!)

[Karl H. (kbuchegg)]

Isildur schrieb:

> Diese sende Funktion würde ich am liebsten immer aktualisieren lassen,
> beispielsweise in der while-Schleife und nur die Variablen stelle1,
> stelle2, stelle3 ... aktualisieren.

Ja, dann mach das doch!
WO drückt denn jetzt der Schuh?

>
> Ich hoffe das Problem einigermaßen verständlich erläutert zu haben.

Nicht wirklich. Aber meine Glaskugel sagt, dass du wahrscheinlich haben 
willst, dass eine Stelle nur dann aktualisiert werden soll, wenn sich 
ihr anzuzeigender Wert auch tatsächlich verändert hat.
Na, dann musst du dir eben in Variablen speichern, was an der jeweiligen 
Stelle momentan gerade angezeigt wird und nur dann, wenn die neue 
Information davon abweicht, dann wird die Anzeige aktualisiert.

zb in C

void sendedisplay()
{
  static int aktuellStelle1 = -1;
  static int aktuellStelle2 = -1;

  if( stelle1 != aktuellStelle1  ) {
    sende( stelle1 );
    aktuellStelle1 = stelle1;
  }

  if( stelle2 != aktuellStelle2 ) {
    sende( stelle2 );
    aktuellStelle2 = stelle2;
  }

  ....

durch den Einsatz von Arrays kannst du dir übrigens noch eine Menge 
Tipparbeit ersparen.

[Bernd K. (prof7bit)]

Conny G. schrieb:
> _ISR(INT0_vect)
> {
>    if (pin = HIGH) {
>       keyUp = 1;
>    }
> }

Dafür setzt man lieber ein Bit in nem GPIOR, da spart man sich im 
Interrupt ein Register (und das zugehörige push/pop) und ein STS und in 
der main spart man ebenfalls und im obigen Fall könnte man die ISR dann 
sogar naked machen.

[Conny G. (conny_g)]

Bernd K. schrieb:
> Conny G. schrieb:
>> _ISR(INT0_vect)
>> {
>>    if (pin = HIGH) {
>>       keyUp = 1;
>>    }
>> }
>
> Dafür setzt man lieber ein Bit in nem GPIOR, da spart man sich im
> Interrupt ein Register (und das zugehörige push/pop) und ein STS und in
> der main spart man ebenfalls und im obigen Fall könnte man die ISR dann
> sogar naked machen.

Und das ist hilfreich für einen Anfänger? :-)

[Bernd K. (prof7bit)]

Conny G. schrieb:
> Und das ist hilfreich für einen Anfänger? :-)

Naja, er könnte es sich frühzeitig angewöhnen diese GPIOR Register für 
sinnvolle Zwecke zu nutzen, das hat auch den Vorteil dass er wieder was 
neues gelernt hat, nämlich die Existenz derselben von der er bis vor ein 
paar Stunden vermutlich noch gar nichts ahnte ;-)

@Isildur: Der Vorteil eben dieser Register gegenüber einer volatile 
uint8_t ist der daß für erstere genau wie bei IO-Pins nur ein einziger 
Taktzyklus erforderlich ist um ein bit zu setzen, zu löschen oder zu 
prüfen während eine globale volatile Variable im RAM mindestens zwei 
Zyklen zum Lesen, 2 weitere zum Schreiben und ein oder zwei um ihren 
Wert zu prüfen oder zu ändern, also 5 oder 6 Zyklen mindestens und auch 
um den selben Faktor mehr Programmspeicher (Flash) benötigt. Wenn Du Dir 
den vom Compiler erzeugten Assemblercode anschaust wird Dir schwindlig 
werden von all der Verschwendung ;-)

[Karl H. (kbuchegg)]

Bernd K. schrieb:
> Conny G. schrieb:
>> Und das ist hilfreich für einen Anfänger? :-)
>
> Naja, er könnte es sich frühzeitig angewöhnen diese GPIOR Register für
> sinnvolle Zwecke zu nutzen, das hat auch den Vorteil dass er wieder was
> neues gelernt hat

Das hat Zeit, bis er aus dem Stadium '0-Wissen' rausgekommen ist.
Ehe das Thema GPIOR relevant wird, gibt es tausende andere Dinge, die 
erst mal wichtiger sind.

[Isildur (Gast)]

WOW,
super schon mal vielen Dank für den ganzen Input, werde das heute Abend 
alles mal ausprobieren.

Eine Frage noch vorab, ich habe hier auch nen paar Taster rumfliegen. 
Idee ist wirklich über die Tasten jeweils verschiedene Menüs anzuzeigen 
(vermutlich auch verschachtelt).

Fragt man die Taster standardmäßig übers Polling oder über Interrupts 
ab. Ziel ist in einiger Zeit (nach Einarbeitung natürlich) schon einige 
verschachtelte Menüführung mit dem Display zu realisieren.

Vielen Dank für die ganzen Antworten!

[Conny G. (conny_g)]

Hi Isildur,

Tasten abfragen und Entprellen ist ein ganzes Thema für sich.
Genau genommen sollte man Taster nicht per pin change oder Flanken 
Interrupt abfragen (Gründe: such mal im Forum nach Taster und Interrupt, 
da kommen bestimmt wilde Diskussionen zutage), da war mein Beispiel oben 
ungeschickt.

Für die Entprellung von Tasten gibt es einen riesigen Artikel.
Als Methode kann ich diese empfehlen:

http://www.mikrocontroller.net/articles/Entprellung#Timer-Verfahren_.28nach_Peter_Dannegger.29

vg,
Conny

[Isildur (Gast)]

ich habe versucht das Display Problem wie folgt zu lösen:

static unsigned char displaystelle1;
static unsigned char displaystelle2;
static unsigned char displaystelle3;
...

In einer Funktion setzevar() setze ich dann die zugehörigen 
Displaystellen, in etwa so:

void setzevar()
{
 displaystelle1 = H;
 displaystelle2 = a;
 displaystelle3 = l;
 ...

}

Wenn ich jetzt in der Funktion sendeDisplay() die zugehörigen Variablen 
ausgeben möchte funktioniert es nicht wie gewünscht:

void sendeDisplay()
{
sende(displaystelle1);
sende(displaystelle1);
sende(displaystelle1);
int main()
{
setzevar();
sendeDisplay();
}
}

Wenn ich jedoch direkt die Stellen über

sende(H);
sende(a);
sende(l);

ausgeben möchte funktioniert es in meinen Augen seltsamerweise.

Was mache ich falsch?

[Karl H. (kbuchegg)]

Isildur schrieb:

> Wenn ich jedoch direkt die Stellen über
>

> sende(H);
> sende(a);
> sende(l);
>

Das funktioniert gan z sicher nicht, es sei denn du hast einen Haufen 
Variablen, für jeden Buchstaben einen. Das allerdings wäre komplett 
dämlich.


Zeige dein ganzes Programm. Aus den Schnipseln kann keiner was ableiten. 
Sehr wahrscheinlich sitzt das Problem ganz woanders.

[Isildur (Gast)]

Display.h

#define A_buch         0b10101000
#define B_buch         0b10011011
#define C_buch         0b00100011
#define D_buch         0b00011011



Programm.h
static unsigned char displaystelle1;
static unsigned char displaystelle2;
static unsigned char displaystelle3;
static unsigned char displaystelle4;

menu.c
#include "Display.h"
#include "Programm.h"
#include "menu.h"

void senddisplay_menu1()
{
displaystelle1 = A_buch;
displaystelle1 = B_buch;
displaystelle1 = B_buch;
displaystelle1 = B_buch;
}

main.c
#include "Display.h"
#include "Programm.h"
#include "menu.h"

void sende()
{
sendekommando(displaystelle1);
sendekommando(displaystelle2);
sendekommando(displaystelle3);
sendekommando(displaystelle4);
}

int main()
{
senddisplay_menu1();
sende()
;
}

Die sendekommando() Funktion funktioniert dabei definitv. Wie gesagt, 
wenn ich direkrt ausgebe und nicht über die Funktionen dann funktioniert 
es

[Bitflüsterer (Gast)]

Das ist wieder mal so eine Frage, bei der man dann antworten möchte: 
Lies ein C-Buch!

Da Du die Variablen static deklariert hast und sie über eine 
Header-Datei in zwei verschiedene C-Dateien einfügst, erhälst Du zwei 
Sätze gleichnamiger Variablen die jeweils "lokal" zu der entsprechenden 
C-Datei sind.
Dadurch initialisierst Du zwar die eine der beiden Modullkokalen 
Variablensätze mit senddisplay_menu1(), liest aber einen dritten Satz 
aus, denn ich vermute, Du includest die Header-Datei mit den 
Variablendefinition ein drittesmal.

Was mich zu noch einem Hinweis bringt: Poste komplette Programme. Die 
Meinung von Anfängern, dass das nicht gepostete schon korrekt sei, 
erweist sich in den meisten Fällen als falsch.

[Isildur (Gast)]

Top,

vielen Dank!
einfach static weglassen und schon funzt es. Werde versuchen mich da 
etwas einzulesen!

[Peter D. (peda)]

Isildur schrieb:
> sendekommando(displaystelle1);
> sendekommando(displaystelle2);
> sendekommando(displaystelle3);
> sendekommando(displaystelle4);

Das ist Copy&Paste-Code der übelsten Sorte.
Sowas kann man für die allerersten Schritte mal probieren.

Aber ein richtiges Programm kann man so nicht schreiben.
Das wird unübersichtlich, unwartbar, unverstehbar, fehlerträchtig und 
riesig.

Sachen, die mehr als einmal ähnlich benötigt werden, macht man mit 
Arrays und Schleifen.
Dann muß man sie nur einmal hinschreiben und einmal testen und kann sie 
beliebig erweitern.