Richtungsbestimmung mit 2 Lichtschranken

>Ist doch einfach nur ein bissl speichern von Werten und die Auswertung
>mit ein paar ifs

Das wird Spaghetticode! Mach ne Schrittkette mit CASE.

Versuch es mal mit ein paar Threads zu Drehencodern. Die machen meißt 
auch eine Richtungsbestimmung.

>nur zwei Ifs.

Das wird nicht reichen. Machs mal richtig. Da wirst du sehen, das sich 
das schnell aufbläst. Du musst ja auch beachten, dass man zwischen 
beiden Lichtschranken umdrehen kann bzw entsprechende Timeouts 
miteinbauen...

Die vom OP nachgefragte Logik ist von der Programmiersprache unabhängig 
und man kann in jeder Programmiersprache übersichtliche Programme oder 
Spaghetti-Code schreiben ... Ich würde das Problem mit einer Art 
Zustandsautomat lösen.

- Ich würde zunächst in einer Schleife darauf warten, dass eine der 
Lichtschranken unterbrochen wird.
- wenn eine unterbrochen wird, dann merken welche und gleichzeitig einen 
Timer starten
- Timer dient dem Timeout. Wenn jemand in der Schranke stehen bleibt 
oder umkehrt, die ganze Aktion nach einer Weile abbrechen und in die 
Schleife zu Anfang zurückkehren
- wenn innerhalb der erlaubten Zeit die zweite Schranke unterbrochen 
wird, ist die Richtung schon mal fast klar
- nun muss man noch darauf warten, ob, wann und in welcher Reihenfolge 
die Lichtschranken wieder frei gegeben werden, erst dann ist ein 
Messvorgang eindeutig

Zum Schluss muss man sich noch überlegen, was man mit den nicht 
eindeutigen Unterbrechungen macht: verwerfen und vergessen oder neben 
Rein und Raus als "nicht eindeutig" getrennt speichern ...

Frank

das mit mittendrin stehenbleiben leuchtet mir nicht ein.
Die können doch in cm-Abstand angebracht werden, oder?

>das mit mittendrin stehenbleiben leuchtet mir nicht ein.
>Die können doch in cm-Abstand angebracht werden, oder?

Trotzdem ist sowas zu beachten. Sonst ist die Lösung nicht sauber.

Hallo, ich hole das Thema mal wieder hoch, denn ich stehe genau vor der 
selben Aufgabe. Es gilt die Richtung mit Hilfe zweier Lichtschranken zu 
bestimmen.

Ich habe folgendes entworfen:

Die Lichtschranken sind bei Unterbrechung High (1).
Der Abstand der Lichtschranken beträgt null, d.h. sie sind direkt 
nebeneinander angeordnet.

Als Beispiel für die Richtung "Out" ergibt sich theoretisch folgender 
Ablauf:
----->
L1  L2
0   0
1   0
1   1
0   1
0   0

Im Programm frage ich mittels Timer alle X ms den Zustand der 
Lichtschranken ab:

1

#define L2  ((PINC & 1<<PC5)>>PC5)

2

#define L1  ((PINC & 1<<PC6)>>PC6)

3

#define L1L2    ((PINC & ((1<<PC5)|(1<<PC6)))>>PC5)

4

5

#define OUT    1

6

#define IN    2

7

#define INVALID    3

8

9

//global deklarierte Variablen

10

volatile uint8_t out=5, in=8;

11

volatile uint8_t l1_flag=0, l2_flag=0, direction=INVALID;

12

13

ISR( TIMER0_COMP_vect )

14

{

15

... //hier wird noch anderer Kram erledigt

16

17

    switch (L1L2)

18

    {

19

      case 2:  if( l2_flag )

20

                 direction = IN;

21

               else 

22

                 l1_flag = 1;

23

               break;

24

25

      case 1: if( l1_flag )

26

                direction = OUT;

27

              else

28

                l2_flag = 1;

29

              break;

30

31

      case 0: if( l1_flag && direction == OUT )

32

              {

33

                out++;

34

                in--;

35

                direction = INVALID;

36

              }

37

              else if( l2_flag && direction == IN )

38

              {

39

                out--;

40

                in++;

41

                direction = INVALID;

42

              }

43

              break;

44

45

      case 3:  break;

46

      default:break;

47

    }

48

}

Aber so einfach scheint es nicht zu funktionieren. :-( Es ändert sich 
der Zustand von out und in nicht, wenn ich die Lichtschranken teste. Ich 
stehe z.Z. auf dem Schlauch.
Danke!
Ist das Konzept zu schlecht?
Was habe ich übersehen?
Gibt es bessere Lösungsansätze, wenn ja welche? Die Abfrage mittels 
Timer ISR sollte schon als Basis dienen.

@Karl heinz

Sorry, dass ich den alten Thread hoch geholt habe. Aber ich dachte mir 
da er relativ klein ist, haben die Leute die vor ähnlichem Problem 
stehen, einen einfachen Überblick. OK, nächstes mal immer einen Neuen 
aufmachen. :-)

Also ich zähle keine Menschen. Der Testaufbau der Lichtschranken sieht 
wie im Foto aus. Ich schiebe dort einfach einen einen kleinen Gegenstand 
durch. Die Lichtschranken sind ausgerichtet und funktionieren.

Karl heinz Buchegger schrieb:
> den Wert von L1L2 anzusehen. Die Tatsache, dass du die höherwertigen
> Bits nicht wegmaskierst
>
> #define L1L2    ((PINC & ((1<<PC5)|(1<<PC6)))>>PC5)

Hm, werden die höherwertigen Bits nicht schon durch die &-Verknüpfung 
maskiert? Ist ja quasi eine Pinabfrage wie z.B. PINC & (1<<PC5), nur 
dass ich das mit zwei Eingängen gleichzeitig mache und das Ergebnis 
nochmal linksbündig schiebe.

Rudi Ratlos schrieb:
> Ist ja quasi eine Pinabfrage wie z.B. PINC & (1<<PC5), nur
> dass ich das mit zwei Eingängen gleichzeitig mache und das Ergebnis
> nochmal linksbündig schiebe.

Ich meine natürlich rechtsbündig

Ich habe zwei Fehler gefunden: Lichtschranken sind an Pin 6 und 7 
angeschlossen. Flags müssen zurück gesetzt werden.

Jetzt zählt er schon mal. :-)
Ich werde natürlich noch testen wie fehleranfällig die Methode ist.