Datenstruktur bei vielen Ein/Ausgängen

[Tobi T. (teletrabi)]

Moin ihrs,

vorweg - ich bin bislang doch eher ein noob, was das Mikrocontroller 
betrifft. Mal ein paar C/C++-Basics auf 'nem PC geproggt, aber das war 
doch recht oberflächlich. Hab in der letzten Zeit mal ein bisschen mit 
'nem Atmega16 gespielt, aber auch da eher im Stadium "kann mittels Timer 
blinken, kann Drehencoder lesen und mit Tastern was anfangen". aber das 
soll sich ja wenn möglich ändern ;o) Eine gewisse technische Kreativität 
attestiere ich mir da einmal, ebenso grundlegendes Verständnis von 
Digital- und Analogtechnik. Was hingegen fehlt ist die Erfahrung in 
hardwarenaher Programmierung und diverse Programmierkniffe.

Ziel des Ganzen soll es sein, ein Stellpult für eine Modellbahn etwas 
intelligenter erscheinen zu lassen. Statt ellenlanger Doppelknopfreihe 
halt Taster in einem kleinen Gleisplan angeordnet, mit Rückmeldung der 
Schaltzustände, ein wenig Verriegelung sich gegenseitig störender 
Funktionen usw. Erstmal nicht sooo anspruchsvoll, allerdings 'ne recht 
große Anzahl zu berücksichtigender Ein- und Ausgänge.

Und gerade die Vielzahl der Ein- und Ausgänge bringen mich etwas in 
Grübeln, wie man da am besten ansetzt. Hardwaremäßig kein Problem, 
diverse Schieberegisterchen und gut, Zeit hat man für die Anwendung ja 
erstmal massig. Nur wie setzt man das am besten in der SOftware um? Mir 
schwebt da zunächst einmal ein Ein- und Ausgangs-Abbild vor, um die 
Operationen mit den externen Schieberegistern zu bündeln.

Aus dem Eingangsabbild werden dann die Tastendrücke erkannt und 
dementsprechend die Ausgänge gesetzt, sofern keine 
Verriegelungsbedingung es untersagt. Und schon sind wir mit dem 
Eingangsabbild bei meiner ersten großen Frage - wie realisiert man am 
geschicktesten die Entprellung und Zustandsänderungserkennung der (mit 
reichlich Reserven) 128 Eingangstaster?

Lieber x für sich vollständige Abbilder als 128er Bitfeld-Structures 
nehmen, wo dann Abbild x-1 (x-2) das Abbild des (vor)vorherigen 
Schleifendurchlaufs enthält und zusätzlich Abbilder vor 1 und 2 
Sekunden, um lange Tastendrücke zu erkennen?

Oder statt 'nem zusammenhängenden Abbild aller Taster lieber für jeden 
Taster ein Statusbyte ansetzen, wo dann einzelne Bits den aktuellen, 
(vor)vorherigen Zustand usw. repräsentieren? Was ist bei solch vielen 
Eingängen die geschicktere Variante?

Unten sind mal meine bisherigen Überlegungen zu benötigten Ein- und 
Ausgängen aufgeführt.


Und mit der Frage der Eingänge verknüpft - wie am vorteilhaftesten 
entprellen? Es werden ja kaum mehr als zwei Taster zugleich gedrückt 
werden. Über mehrere Abbilder vergleichen, und wenn meinetwegen die 
letzten drei übereinstimmen den Zustand als endgültig ansehen? Oder 
lieber sobald man an einem geänderten Zustand ankommt, mehrfach einlesen 
und schauen, ob noch Änderungen auftreten? Mehrfach einlesen ist zwar in 
der eigentlichen verarebitung recht knapp, muss dafür aber ettliche Male 
einen ganz bestimmten Taster aus der langen Schieberegisterkette 
einlesen. Dritte Variante wäre, einfach bei nem geänderten Zustand ne 
kurze Pause einzulegen. Fragt sich nur, ob man die so bemessen kann, 
dass alle kurzen Tatendrücke noch erkannt werdn, aber sicher kein 
Prellen mehr wahrgnommen wird.


Schönen Gruß,
Tobi

Speicherbedarf Modellbahn:

Eingangsabbild = 1 Bit pro Taster
Ausgangsabbild = 2 Bit pro Magnetischem Aktor/Signal + 2 Bit für Rückmeldung, 
Entkuppler und Schalter 1 bit + ggf. 1 bit Rückmeldung.

Eingänge:
20 Weichenfunktionen => 32 bit
10 Signale =>16 bit (32 bit)
8 Kuppler => 16 bit
x Licht => 16 bit 
10 Fahrspannungschaltungen => 16 bit
-------------------------------------------------------
112 Bit => 128 Bit = 16 Byte
Hardwareansatz: 16 x 8er PISO


Ausgänge (benötigt => Bedarf inkl. Reserve):  Ausgangsbelegung pro Funktion
20 weichenfunktionen x 2 = 40 => 64 bit    Spule A, Spule B
10 Signale = 40 bit => 64 bit      Hp0/rot, Hp1/grün, Hp2/gelb, Fahrstrom, 
8 Entkuppler = 8 => 16 bit      Spule
0 Licht => 16 bit        Relais
20 Fahrspannung = 20bit => 32 bit    Relais
----------------------------------------------------------
144 bit => 256 Bit = 32 Byte
Hardwareansatz: zunächst reduziert 16x8er SIPO, 
optional zweiter Satz mit 16x 8 SIPOs in weiterem Ausbau.


Rückmeldung
20 Weichenfunktionen x 2 = 40 => 64 bit    LED Stellung A, LED Stellung B
10 Signale = 20 bit => 48 bit      LED rot, LED grün, 
10 Fahrspannung = 10bit => 16 bit    LED
----------------------------------------------------------
128 Bit => 16 Byte 
Hardware Zunächst als 8x8 SIPO. 




Verarbeitung:
Status_Taster:
Z_aktuell, Z_-1, Z_-2, Z_-3, Z_-1000ms, Z_-2000ms, Reserve, Reserve  
=> 1 Byte   128 Taster => 128 Byte

Status_Signal:      (Zh, Zl = 2 Bit für vier Zustände (Hp0, Hp1, Hp2, Dunkel))
Z_akt_h, Z_akt_l; Z_neu_h, Z_neu_l ; Vormerkung_Z_h, Vormerkung_Z_l; Z_-1_h, Z_-1_l;
Blockiert, Freigabe, Blinkmerker, Reserve,  Reserve, Reserve,  Reserve, Reserve 
= 16bit => 2 Byte => 16 Signale = 32 Byte

Status_Weiche:
Lage, blockiert, Freigabe, Vormerk, Z_-1, Z_-2, Reserve, Reserve 
= 1 Byte => 32 Byte
-----------------------------------------------------------------
192 Byte 




Funktionsschema als Pseudocode:

Tastendruck erkennen
Tastendruck speichern
if (neu_gedrückt)
{  
  if  (Schaltkritieren erfüllt)  //längere Abfrage diverser gegenseitiger Verriegelungen

    Ausgang in Ausgangsabbild setzen/toggeln;
  else 
  {
    vormerken;
    blinkmerker aktivieren;
  }
if (schon lange gedrückt)
  trotz Sperrkriterium Ausgang setzen;

[Klaus W. (mfgkw)]

Willst du dann nicht vielleicht erstmal
a) halbwegs ordentlich C lernen (geht auf PC viel einfacher
   und nervenschonender)
b) dann hier das AVR-gcc-Tutorial durcharbeiten?

Dann macht es eher Sinn, etwas Konkretes auf dem AVR in Angriff zu 
nehmen.