Portzustände einlesen und Je nach Zustand etwas tun aber veränderbar

[Chris T. (chris0086)]

Hallo Leute,
ich habe ein kleines Problem bei der Ausführung einer Vorgabe .
Also worum es geht:
Ich habe 4 Eingänge und soll abhängig von deren Stellung etwas tun(was 
ist erstmal unerheblich).
Die Zuordnung bei welchem Eingang was geschiet soll aber änderbar sein( 
diese Information muss später im EEPROM liegen).
Jetzt hab ich mir gedacht man ahmt die Tabelle nach(wie im Anhang).
Man könnte jetzt einfach den Port einlesen und mit einer MAske 
vergleichen, das war meine erste Idee.
Wäre das eine gute Idee oder gehts besser?

Dann hab ich aber das Problem das sich die Eingänge an unterschiedlichen 
Ports befinden, also kann ich das mit der Maske wohl nicht machen oder 
doch?
Wie würdet ihr das machen?
Die Eingänge auf einen Port legen ginge in größter Not auch aber wäre 
riesen Aufwand.

[Timo N. (tnn85)]

>Dann hab ich aber das Problem das sich die Eingänge an unterschiedlichen
>Ports befinden, also kann ich das mit der Maske wohl nicht machen oder
>doch?

Wieso denn? Du kannst doch die entsprechenden Pins von jedem Port 
maskieren und gemeinsam mit OR verknüpfen und in eine Variable mit (z.b. 
8 Bit) speichern

[Purzel H. (hacky)]

Naja. Bei 4 Eingaengen wird man auch noch "4 * if" machen koennen.

[Timo N. (tnn85)]

 char LUT = ((PINC & (1<<PINC1))<<1 | (PIND & (1<<PIND2))<<2 | (PINA & (1<<PINA4))<<3 | (PINE & (1<<PINE2)))<<4

[Karl H. (kbuchegg)]

Chris tian schrieb:

> Jetzt hab ich mir gedacht man ahmt die Tabelle nach(wie im Anhang).

Ich hab zwar noch so gewisse Schwierigkeiten deiner Tabelle da einen 
Sinn zu entlicken, aber grundsätzlich .... ja, als Basisgrundlage ist 
das erst mal nicht so schlecht, auch wenn die Details noch nicht so 
richtig klar sind.

> Man könnte jetzt einfach den Port einlesen und mit einer MAske
> vergleichen, das war meine erste Idee.

Ja, klingt nicht so schlecht

> Dann hab ich aber das Problem das sich die Eingänge an unterschiedlichen
> Ports befinden,

Macht ja nichts.

> also kann ich das mit der Maske wohl nicht machen oder
> doch?

Kein Mensch sagt, dass du das was du vom Port liest sofort in die 
Maskengeschichte stecken musst.

Du kannst ja auch erst mal zb von 2 Ports einlesen, die jeweils 
richtigen Portbits aus den 2 Ports in einer dir genehmen Reihenfolge in 
ein einziges Bytes zusammenkopieren (muss auch nicht ein Byte sein) und 
erst dann die ganze Sache mit der Maske durchziehen.

> Wie würdet ihr das machen?
> Die Eingänge auf einen Port legen ginge in größter Not auch aber wäre
> riesen Aufwand.

Muss nicht sein. Das lässt sich ja auch in Software machen.

Um bei deinem Beispiel im POsting zu bleiben. Nehmen wir einfach mal an, 
D_IN_1 wäre am Port A und dort wäre es das Bit 4.
D_IN_2 ist das Bit 6 vom Port B
D_IN_3 ist das Bit 3 vom Port B
D_IN_4 hingegen wird vom Port D, Bit 4 abgegriffen.

Dann besteht dein erstes Ziel, diese Einzelinformationen in ein einziges 
Byte zusammenzuholen (wegen der Maskensache), so dass in diesem Byte die 
8 Bits sich so ergeben

   +-------+------+------+------+--------+--------+--------+--------+
   |  0    |  0   |  0   |  0   | D_IN_4 | D_IN_3 | D_IN_2 | D_IN_1 |
   +-------+------+------+------+--------+--------+--------+--------+

d.h. 4 Bits sollen 0 sein und in den restlichen 4 Bits sollen sich die 
Eingänge wiederfinden. Wie machst du das

  uint8_t Inputs;


  Inputs = 0x00;     // damit sind erst mal alle Bits auf 0
                     // und jetzt fragen wir uns, welche der 4 D_IN_x
                     // Bits auf 1 gesetzt sind und tragen das in Input ein

  if( PINA & ( 1 << PA4 ) )    // D_IN_1
    Inputs |= ( 1 << 0 );

  if( PINB & ( 1 << PB6 ) )    // D_IN_2
    Inputs |= ( 1 << 1 );

  if( PINB & ( 1 << PB3 ) )    // D_IN_3
    Inputs |= ( 1 << 2 );

  if( PIND & ( 1 << PB4 ) )    // D_IN_3
    Inputs |= ( 1 << 3 );

Dnach hast du ein Byte, nämlich Inputs, welches genau deine 4 Eingänge 
wiederspiegelt und welches du leicht durch deine Auswertungen, wie immer 
du die dann machst, schleusen kannst.


Man kann oft Hardware-'Probleme' mit Programmierung ausgleichen. Oft 
bedeutet das einfach nur, dass man eine Zwischenebene einzieht. Hier ist 
es eben das vorhergehende Zusammenführen der Einzelbits in ein Byte, mit 
dem man dann weiterarbeiten kann, so dass es für die weitere Auswertung 
so aussieht, als ob alle Eingänge an ein und demselbe Port liegen 
würden.

[Chris T. (chris0086)]

Danke für deine ausführliche Beschreibung der Sache Karl Heinz.
Dann mach ich mich erstmal ans Werk und schau mal das ich das so 
hinbekomme.
Dankeschön an alle