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
1 | +-------+------+------+------+--------+--------+--------+--------+
|
2 | | 0 | 0 | 0 | 0 | D_IN_4 | D_IN_3 | D_IN_2 | D_IN_1 |
|
3 | +-------+------+------+------+--------+--------+--------+--------+
|
d.h. 4 Bits sollen 0 sein und in den restlichen 4 Bits sollen sich die
Eingänge wiederfinden. Wie machst du das
1 | uint8_t Inputs;
|
2 |
|
3 |
|
4 | Inputs = 0x00; // damit sind erst mal alle Bits auf 0
|
5 | // und jetzt fragen wir uns, welche der 4 D_IN_x
|
6 | // Bits auf 1 gesetzt sind und tragen das in Input ein
|
7 |
|
8 | if( PINA & ( 1 << PA4 ) ) // D_IN_1
|
9 | Inputs |= ( 1 << 0 );
|
10 |
|
11 | if( PINB & ( 1 << PB6 ) ) // D_IN_2
|
12 | Inputs |= ( 1 << 1 );
|
13 |
|
14 | if( PINB & ( 1 << PB3 ) ) // D_IN_3
|
15 | Inputs |= ( 1 << 2 );
|
16 |
|
17 | if( PIND & ( 1 << PB4 ) ) // D_IN_3
|
18 | 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.
eingangsbeschaltung.png
(2,5 KB)
