Displayanzeige für verschiedene Zustände

[Silvio Meißner (Gast)]

Hallo,

ich möchte eine variable Displayanzeige erstellen. Das Gerüst ist 
hierbei immer gleich und nur einige Werte sollen abhängig von 
verschiedenen Zuständen angezeigt werden. Diese Zustände werden vom 
Benutzer natürlich beeinflusst.

Nehmen wir an die Zustände sind zustand1, zustand2, zustand3, zustand4, 
zustand5, die miteinander teilweise auch kombiniert werden.

Ich möchte jetzt vermeiden jeden Zustand einzeln abzufragen, also dieses 
hier nicht:

void anzeige_Display()
{
if(zustand1 && zusatnd2 && !zustand3 && !zustand4 && zustand5)
...
if(!zustand1 && zusatnd2 && !zustand3 && zustand4 && !zustand5)
// usw.
}

sondern ich möchte viel mehr bei Eingabe des Benutzers von Zustandx ein 
Flag in einer Zustandsvariable setzen, die dann nachher in der Anzeige 
abgefragt wird.

Mir ist bewußt, dass meine Ausführungen schwammig sind, weil ich das 
Problem noch nicht richtig greifen kann. Vielleicht versteht es ja 
trotzdem der ein oder andere und kann mir ein Minimalbeispiel oder 
Anregungen geben, wie man so etwas realisiert.

Besten Dank

[HildeK (Gast)]

Vielleicht meinst du ja das:

Angenommen, du hast max. 8 Zustände, die jeweils mit 0 oder 1 bestimmt 
werden.
Dann definiere z.B.
#define Z0 0
#define Z1 1
#define Z2 2
usw.

Dann definiere eine Bytevariable (z.B. uint8_t beim µC) "gesamtzustand".

Jetzt kannst du unabhängig jeden einzelnen Zustand setzen mit
gesamtzustand |= (1 << Z0)  für Zustand 0 oder
gesamtzustand |= (1 << Z2)  für Zustand 2
bzw.. löschen von Bit 3 mit
gesamtzustand &= ~(1 << Z3)
oder invertieren von Z2
gesamtzustand ^= (1 << Z2)

Du kannst dann an anderer Stelle wieder jedes einzelne Bit abfragen, 
z.B. mit
if ( gesamtzustand & (1 << Z2) )
{
  // wird ausgeführt wenn der Zustand 2 auf HIGH ist
}

Meintest du so was oder vielleicht doch nicht?

[Karl H. (kbuchegg)]

Da du wenig greifbares lieferst, ist es jetzt schwer, da eine Methodik 
vorzuschlagen.

In Ermangelung von Details schlag ich einfach mal vor, die ganze Sache 
umzudrehen. Du sagst, du hättest einige Werte die abhängig von 
irgendwelchen Zustäden anzuzeigen sind.

Na da würde ich doch glatt vorschlagen, die Werte zusammen mit einer 
Beschreibung abzuspeichern, aus der hervorgeht, wann der jeweilige Wert 
anzuzeigen ist. Auf Anhieb würde ich da mal vorschlagen, 2 Masken zu 
haben: die eine legt fest, welche Zustände vorliegen müssen, damit eine 
Anzeige erfolgt. Die andere legt fest, welche Zustände eine Anzeige 
verhindern.
Die Zustände selbst sind bitcodiert in einem uint8_t Wert. Der 
Einfachheit halber nehme ich jetzt mal an, dass es sich bei dem Wert 
immer um einen int16_t handelt. Falls das nicht so sein sollte, könnte 
man immer noch über ein Typflag und eine union da mehrere 
unterschiedliche Datentypen übereinander legen.

typedef struct displayValue_
{
  int16_t Wert;

  uint8_t showMask;
  uint8_t suppressMask;
} displayValue_t;

#define NO_STATE  0x00
#define STATE_1   0x01
#define STATE_2   0x02
#define STATE_3   0x04
#define STATE_4   0x08
#define STATE_5   0x10

// Die geschwindigkeit wird angezeigt, wenn Zustand 1 oder Zustand 2 vorliegen
// aber nicht, wenn gleichzeitig Zustand 4 vorliegt
displayValue_t Speed =    { 0,  STATE_1 | STATE_2, STATE_4 };

// Der Öldruck wird angezeigt, wenn Zustand 3 gesetzt ist
// und es gibt keinen Ausschlussgrund
displayValue_t OilPressure = { 0,  STATE_3, NO_STATE );

// und hier ist dann noch der aktuell im Programm vorhandene zustand
// der durch Benutzereingaben manipuliert wird.
uint8_t currentState;

man könnte die entsprechenden Variablen auch in einem Array 
zusammenfassen, was insbesondere die Anzeigeroutine dann vereinfachen 
würde. Aber es wird auch so gehen, indem man sich erst mal eine Funktion 
schreibt, die die Bewertung einer derartigen Variablen macht und die 
dann für alle Variablen aufruft.

void showRestrictedValue( displayValue_t * dispVal )
{
  if( dispVal->showMask & currentState )    // irgendeiner der geforderten
                                            // Zustände reicht für eine Anzeige
  {
    if( ( dispVal->suppressMask & currentState ) == 0 )  // aber es darf kein Ausschlussgrund
                                                // gegeben sein
    {
       .... Voraussetzungen erfüllt. Der Wert kann angezeigt werden
    }
  }
}

void showValues()
{
  showRestrictedValue( &Speed );
  showRestrictedValue( &OilPressure );
}

ob du jetzt die Bits in den 'Erlaubt' bzw. 'Verboten' Masken als eine 
Und-Verknüpfung ansehen willst (alle Zustände müssen gegeben sein), oder 
als eine Oder Verknüpfung (einer der angegebenen Zustände reicht), 
bleibt dir überlassen bzw. hängt von den Gegebenheiten ab. Eine 
umfangreiche allumfassende Lösung ist hier nicht so trivial zu 
implementieren, so dass man sich auf das beschränken wird, was 
tatsächlich im konkreten Projekt gebraucht wird. Das Problem ist 
nämlich, dass derartige 'Bedingungen' im allgemeinen Fall recht komplex 
werden können: Ein Wert wird angezeigt wenn etweder Zustand 1 oder 
Zustand 2 vorliegen, aber nicht beide gleichzeitig, oder aber wenn 
sowohl Zustand4 als auch Zustand 5 vorliegt, aber wenn nur Zustand 5 
alleine vorliegt, dann kommt es zu keiner Anzeige. Da kommt man dann mit 
so einer einfachen Masken-Sache nicht mehr weit und man könnte zum 
Beispiel anleihen an 'regular Expressions' nehmen, um sich eine 
Beschreibungssyntax für den Sachverhalt auszudenken.



Wäre mal ein Vorschlag.

[Silvio Meißner (Gast)]

SUPER!!!!

Tausend Dank, das hilt mir sehr. Ich werde einmal versuchen dies alles 
umzusetzen und gebe dann nochmal Feedback.

Danke sehr