Rundenzähler Carrera

[biede1987 (Gast)]

Hallo ich hab ein Programm geschrieben mit dem man  mit  einer 7 
Segementanzeige von 0-9 hochzählt, dann will ich mit einem externen 
resettaster wieder auf 0 zurücksetzen. Soweit funktioniert es auch. Nur 
sobald ich dann wieder meine Lichtschranke betätige zählt die 
Segmentanzeige nicht mehr weiter.

Ich hab eine  arduino duemilanove

Kann mir jemand helfen?

[biede1987 (Gast)]

// Lichtschranke ist ein Taster und alle Segmente werden angesteuert, es wird gezaehlt von 1-9 Resettaster setzt zurueck auf 0

      int Lichtschranke = 11; // oder Taster
      int Lichtschrankeunterbrochen; // Variable für den Pin Zustand 
      int letzteRunde; // Variable für den letzten Schalterzustand letzte Runde
      int Runde = 0; // Wie oft ist der Schalter gedrückt   
    
      int reset = 12;
      int resetdruecken;
      //int resetgedrueckt;

      int a = 2; // a
      int b = 3;
      int c = 4;
      int d = 5;
      int e = 6;
      int f = 7;
      int g = 8;



    void setup(){
 
      Serial.begin(9600); // Start der seriellen Kommunikation mit 9600bps
      pinMode(Lichtschranke,INPUT);
      pinMode(reset,INPUT);
      pinMode(a,OUTPUT);
      pinMode(b,OUTPUT);
      pinMode(c,OUTPUT);
      pinMode(d,OUTPUT);
      pinMode(e,OUTPUT);
      pinMode(f,OUTPUT);
      pinMode(g,OUTPUT);
  
       letzteRunde = digitalRead(Lichtschranke); // Anfangszustand lesen
       resetdruecken = digitalRead(reset); // Anfangszustand lesen
        
      }
  
  void loop() 
  
      { 
      //Runden auf 0 zuruecksetzten
      
      
      resetdruecken = digitalRead(reset);  
      if (resetdruecken == LOW)
      
       
      {
     
      digitalWrite(a,0);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,0);
      digitalWrite(e,0);
      digitalWrite(f,0);
      digitalWrite(g,1);
      }
     
      
    
      
          Lichtschrankeunterbrochen = digitalRead(Lichtschranke);
              if (Lichtschrankeunterbrochen != letzteRunde) { // Der Zustand des Schalters hat sich verändert 

                  if (Lichtschrankeunterbrochen == HIGH) { // Ist der Schalter gedrückt? 

                      Runde++; // Inkrementieren der Variablen Runde 

                                
        Serial.print("Wir sind jetzt in der ");
        Serial.print(Runde);
        Serial.println(" Runde");
        
     
    
  
    

      if (Runde==1)
      {
      digitalWrite(a,1);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,1);
      digitalWrite(e,1);
      digitalWrite(f,1);
      digitalWrite(g,1);
      }
      
      if (Runde==2)
      {
      digitalWrite(a,0);
      digitalWrite(b,0);
      digitalWrite(c,1);
      digitalWrite(d,0);
      digitalWrite(e,0);
      digitalWrite(f,1);
      digitalWrite(g,0);
      }
      
      if (Runde==3)
      {
      digitalWrite(a,0);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,0);
      digitalWrite(e,1);
      digitalWrite(f,1);
      digitalWrite(g,0);
      }
      
      
      if (Runde==4)
      {
      digitalWrite(a,1);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,1);
      digitalWrite(e,1);
      digitalWrite(f,0);
      digitalWrite(g,0);
      }
      
      if (Runde==5)
      {
      digitalWrite(a,0);
      digitalWrite(b,1);
      digitalWrite(c,0);
      digitalWrite(d,0);
      digitalWrite(e,1);
      digitalWrite(f,0);
      digitalWrite(g,0);
      }
      
      if (Runde==6)
      {
      digitalWrite(a,0);
      digitalWrite(b,1);
      digitalWrite(c,0);
      digitalWrite(d,0);
      digitalWrite(e,0);
      digitalWrite(f,0);
      digitalWrite(g,0);
      }
      
      if (Runde==7)
      {
      digitalWrite(a,0);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,1);
      digitalWrite(e,1);
      digitalWrite(f,1);
      digitalWrite(g,1);
      }
      
      if (Runde==8)
      {
      digitalWrite(a,0);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,0);
      digitalWrite(e,0);
      digitalWrite(f,0);
      digitalWrite(g,0);
      }
      
      if (Runde==9)
      {
      digitalWrite(a,0);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,0);
      digitalWrite(e,1);
      digitalWrite(f,0);
      digitalWrite(g,0);
      }
      
        }
      }
      letzteRunde = Lichtschrankeunterbrochen; //Den Zustand merken

[PittyJ (Gast)]

Müßte in

      if (resetdruecken == LOW)


      {

nicht noch mehr passieren?

[biede1987 (Gast)]

Ja dann muss er hier wieder von vorne anfangen mit zählen

[Karl H. (kbuchegg)]

Mach dir als erstes mal eine Funktion, der du eine Ziffer von 0 bis 9 
übergibst, und die diese Ziffer dann auf der 7-Seg anzeigt.

Damit hast du dann diesen Teil aus der loop() draussen, so dass dir 
dieses 'Detail' nicht mehr in die Quere kommt, wenn du dich um die Logik 
kümmerst, wie sich der interne Zählerstand verändert, wenn irgendwas 
passiert. Wichtig: dies ist die einzige Funktion, die die Erlaubnis hat, 
an den Pins für die 7-Seg Anzeige rumzufummeln.

Dein Funktion loop() ist offensichtlich schon zu groß, so dass du die 
implementierte Logik nicht mehr überblicken kannst.

[Klaus I. (Gast)]

Nimm einen CD4026B
SCNR ;o)

[Karl H. (kbuchegg)]

biede1987 schrieb:
> Ja dann muss er hier wieder von vorne anfangen mit zählen

Genau das meine ich.
'Von vorne anfangen mit zählen' bedeutet in erster Linie, dass der 
Rundenzähler in Form der Variable 'Runde' auf 0 gesetzt wird. Es 
bedeutet nicht, dass du dich in der Behandlung des Reset-Tasters um die 
7-Seg Anzeige kümmern musst, in dem du die einzelnen Bits ansteuerst.

Deine loop sieht dann so aus

void loop()
{
  Logik, welche diverse Eingangsleitungen überwacht
  uns auswertet. Als Ergebnis dieser Auswertungen verändert sich
  der Wert in 'Runde'. Der kann sich erhöhen, der kann auch 0 gesetzt
  werden, der kann eine Rundenvorgabe für den Gegner kriegen. Egal was,
  spielt keine Rolle - manipuliert wird immer in 'Runde'. DAS ist dein
  Rundenzähler - diese Variable.

  writeTo7Seg( Runde );    // und hier, ganz zum Schluss wird dann dieser
                           // Wert, egal wie er jetzt ist, ausgegeben.
                           // Die Funktion writeToSeg weiß, wie das geht
}

void writeTo7Seg( uint8_t Ziffer )
{
  if( Ziffer == 0 )
  {
    ...
  }
  else if( Ziffer == 1 )
  {
    ...
  }
  ....
}

wenn du dann in deinem C++ Buch (oder C Buch) ein wenig geschmökert und 
gelernt hast, dann wird dir auch eine Möglichkeit einfallen, wie du zb 
mit Arrays dir die ganze Sache der Ausgabe auf die Anzeige massiv 
vereinfachen kannst.
Aber erst mal ist wichtig, dass du den Anzeigeteil aus der loop soweit 
raushältst, dass du dich dort Codemässig nur noch um die Manipulation 
der Variable 'Runde' kümmerst und nicht aufgrund der Codelänge den 
Überblick verlierst, wie deine Logik eigentlich aussieht.

[Karl H. (kbuchegg)]

Und bitte

      if (Runde==8)
      {
      digitalWrite(a,0);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,0);
      digitalWrite(e,0);
      digitalWrite(f,0);
      digitalWrite(g,0);
      }
      
      if (Runde==9)
...

wenn Runde den Wert 8 hat, dann KANN sie nicht den Wert 9 haben. Es ist 
völlig sinnlos das noch zu testen. Es ist schlicht und ergreifend nicht 
möglich.

  if( Runde == 0 )
  {
     ....
  }

  else if( Runde == 1 )
  {
    ....
  }

  else if( Runde == 2 )
  {
    ...
  }
...

oder einfacher

  switch( Runde )
  {
    case 0:
      .....
      break;

    case 1:
      .....
      break;

    case 2:
      .....
      break;

    default:
      ....
  }

konsultiere bitte dein C++ (oder C) Buch, welche Möglichkeiten die 
einfachen Basisdinge der Sprache dir bieten. Es gibt Grundlagen die 
müssen einfach sitzen, ehe man das erste mal was 'richtiges' 
programmiert. Wenn man von der Programmiersprache die man benutzt noch 
nicht einmal 10% des Sprachumfangs kennt, dann ist man blutigster 
Anfänger und sollte tunlichst noch ein paar Übungen durchspielen, ehe 
man sich in die reale Welt rauswagt.

[biede1987 (Gast)]

sagt sich so einfach nimm den,
ich hab jetzt schon mit dem angefangen!

Danke Karl Heinz, für die Info

dann mach ich einen neuen Tap auf und speicher dann meine Zahlen dort 
rein und schreib dann meine Logik weiter.

Aber eigentlich müsste ich doch jetzt nur in dem Prommgrann 
reinschreiben.

 wenn die Reset taster gedrückt dann fange wieder an von vorne oder?

[Karl H. (kbuchegg)]

biede1987 schrieb:
> sagt sich so einfach nimm den,
> ich hab jetzt schon mit dem angefangen!
>
> Danke Karl Heinz, für die Info
>
> dann mach ich einen neuen Tap

Hä?
Was ist ein Tap?

> Aber eigentlich müsste ich doch jetzt nur in dem Prommgrann
> reinschreiben.

Was ist so schwer an

...
void setup()
{
  ...
}

void loop()
{
  ...
}

void writeTo7Seg( uint8_t wert )
{
  ...
}

alles in einem 'Sketch'.

Es geht nur darum, dass du deine Funktion loop() ein wenig kürzer 
kriegst, damit du sie wieder überblicken kannst (und damit du in loop() 
auch nicht unmotiviert an irgendwelchen 7-Seg LEitungen rumfummelst, 
obwohl du das dort gar nicht tun darfst)

[Karl H. (kbuchegg)]

> wenn die Reset taster gedrückt dann fange wieder an von vorne oder?

wenn der Reset Taster gedrückt wird, dann wird der Zähler auf 0 gesetzt. 
Das ist es ja wohl, worauf es hinaus läuft, wenn du 'vor vorne anfangen' 
sagst. Oder?

Ergo

....
  if( digitalRead(reset) )
    Runde = 0;
....

fertig.

In einem Programm haben Variablen durchaus eine Bedeutung, eine 
Funktion.
In deinem Programm IST die Variable 'Runde' der Rundenzähler. Sie 
repräsentiert die gezählten Runden. Wenn du also deine Runden 
manipulierst, dann geschieht das, indem du die gwünschte Operation auf 
DIESE Variable anwendest.

Der Rest, die Sache mit der 7_seg - das ist nur die ANzeige. Das 
Sichtbarmachen des programminternen Rundenzählers. Hier in deinem 
Programm

      if (resetdruecken == LOW)
      
       
      {
     
      digitalWrite(a,0);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,0);
      digitalWrite(e,0);
      digitalWrite(f,0);
      digitalWrite(g,1);
      }

hast du das nicht berücksichtigt. Du hast zu kurz gedacht und deine 
7-Segment Anzeige mit dem Rundenzähler verwechselt. Du bist nach dem 
gegangen, was du siehst. Aber das ist Quatsch. Denn die 7_Seg Anzeige 
ist ja nicht dein Rundenzähler. Die ist nur ANzeigeelement. Der 
eigentliche Rundenzähler ist die Variable 'Runde'. Die wird manipuliert. 
Und natürlich irgendwann zur Anzeige gebracht. Aber der Vorgang des 
Anzeigens hat ja nichts mit dem Zählern von Runden bzw. der Verwaltung 
dieser Zählung zu tun. Das ist nur eine Anzeige und nicht mehr.

[Edgar F. (edgarfalke)]

Hallo Biede,

ich bin Modellbahner und habe das gleiche Problem.
Runden zählen und gleichzeitig die Geschwindigkeit zu ermitteln, um die 
Geschwindikkeiten der Loks ein zu justieren.
Dein Aufwand mit einem µC ist viel zu aufwendig.

Ein Logikbaustein CD 4017 tut es genauso, mit viel weniger Aufwand.
Dieser ist ein Dezimalzähler nut 10 decodierten Ausgängen, der auch noch 
kaskadieren kann.
Triggern kannst Du ihn mit einem Impuls von einem Reedkontakt oder einer 
Lichtscharanke.
An den 10 Ausgängen hängst Du entweder ein 10-fach LED-Array oder einen 
LCD-Dekoder zur Anzeige.
Das ganze hat den Vortei, das es viel weniger kostet als ein µC-Modul 
und auch sehr viel schneller realisiert ist.

Grüße
Edgar

[biede1987 (Gast)]

Stimmt du hattest recht, eigentlich ganz klar, ich muss ja meine Runde 
auf 0 zurücksetzen und nicht die 7 Segementanzeige. oh man danke

ich schreib aber nicht Runde = 0 sonder -1
damit die 7 Segmentanzeige 0 anzeigt und Sie schaltet nur wenn ich dann 
die Lichtschranke betätige. normaler weise muss doch dann die Anzeige 
sofort 0 Anzeigen wenn ich den Reset-Taster drücke, liegt das an

runde++

resetdruecken = digitalRead(reset);  
      if (resetdruecken == LOW)
      
      {Runde =-1;
       
      }
      
      
          Lichtschrankeunterbrochen = digitalRead(Lichtschranke);
              if (Lichtschrankeunterbrochen != letzteRunde) { // Der Zustand des Schalters hat sich verändert 

                  if (Lichtschrankeunterbrochen == HIGH) { // Ist der Schalter gedrückt? 

                      Runde++; // Inkrementieren der Variablen Runde

[biede1987 (Gast)]

Danke Edagar für die Antwort, ich übe gerade mit einer 7 Segement 
anzeige und will danach vier ansteuern, deswegen mach ich es so.

[Karl H. (kbuchegg)]

biede1987 schrieb:
> Stimmt du hattest recht, eigentlich ganz klar, ich muss ja meine Runde
> auf 0 zurücksetzen und nicht die 7 Segementanzeige. oh man danke
>
> ich schreib aber nicht Runde = 0 sonder -1
> damit die 7 Segmentanzeige 0 anzeigt und Sie schaltet nur wenn ich dann
> die Lichtschranke betätige. normaler weise muss doch dann die Anzeige
> sofort 0 Anzeigen wenn ich den Reset-Taster drücke, liegt das an


Was hast du sonst noch geändert?

Hast du dein Programm so umgeändert, wie ich es vorgeschlagen habe?

void loop() 
{ 
  if (digitalRead(reset) == LOW)
    Runde = 0;

  Lichtschrankeunterbrochen = digitalRead(Lichtschranke);
  if (Lichtschrankeunterbrochen != letzteRunde) { // Der Zustand des Schalters hat sich verändert 

    if (Lichtschrankeunterbrochen == HIGH) { // Ist der Schalter gedrückt? 
      Runde++; // Inkrementieren der Variablen Runde 

      Serial.print("Wir sind jetzt in der ");
      Serial.print(Runde);
      Serial.println(" Runde");
    }

    letzteRunde = Lichtschrankeunterbrochen;
  }

  writeTo7Seg( Runde );
}

void writeTo7Seg( uint8_t wert )
{
  if( wert == 0 )
  {
      digitalWrite(a,0);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,0);
      digitalWrite(e,0);
      digitalWrite(f,0);
      digitalWrite(g,1);
  }

  else if( wert == 1 )
  {
      digitalWrite(a,1);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,1);
      digitalWrite(e,1);
      digitalWrite(f,1);
      digitalWrite(g,1);
  }

  else if( wert == 2 )
  {
    ...
  }
  ...
}

Tu das bitte.
Denn jetzt können wir in loop() auch ohne seitenlanges Hin und Her 
scrollen überblicken, dass nach der Erkennung des Reset-Tasters (und dem 
damit verbundenen Rücksetzen von Runde auf 0) ganz zum Schluss die 
Ausgabe von Runde auf die Anzeige erfolgt.
Denn natürlich reicht das ja nicht, den Rundenzähler auf 0 zu setzen. Du 
willst das ja auch auf der Anzeige irgendwann mal sehen. Dazu muss aber 
die Ausgabe mal gemacht werden. Ein Aufruf der Funktion writeTo7Seg mit 
dem jeweils gültigen Wert von Runde leistet genau das.
Wird also der Reset Taster gedrückt vorgefunden dann wird Runde auf 0 
gesetzt und als Abschluss in loop() wird auf jeden Fall der Wert von 
Runde auf der Anzeige ausgegeben. loop() ist kurz genug, dass man das 
problemlos erkennen kann. .....
.... In der jetzigen Version (mit Auslagerung des Anzeigecodes in eine 
eigene Funktion). In der alten Version mit haufenweise Code in loop() 
hast du den Überblick verloren, was wo passiert. DIe Lehre die du daraus 
ziehen solltest: Es ist nicht egal, ob man sich eine Codewurscht 
hinschmiert oder nicht. Denn in dem einen Fall reichen deine Fähigkeiten 
den Code zu überblicken nicht aus. Im anderen Fall aber schon. Es ist 
beide male der gleiche Code. Nur anders organsiert. Nämlich so, dass 
deine Fähigkeiten reichen, mit dem Code zu arbeiten.

[Karl H. (kbuchegg)]

Du könntest ja zb auch sagen:
solange der Reset-Taster gedrückt ist, interessiert es mich gar nicht, 
was an der Lichtschranke vor sich geht

void loop() 
{ 
  if (digitalRead(reset) == LOW)
    Runde = 0;

  else {
    Lichtschrankeunterbrochen = digitalRead(Lichtschranke);
    if (Lichtschrankeunterbrochen != letzteRunde) { // Der Zustand des Schalters hat sich verändert 

      if (Lichtschrankeunterbrochen == HIGH) { // Ist der Schalter gedrückt? 
        Runde++; // Inkrementieren der Variablen Runde 

        Serial.print("Wir sind jetzt in der ");
        Serial.print(Runde);
        Serial.println(" Runde");
      }

      letzteRunde = Lichtschrankeunterbrochen;
    }
  }

  writeTo7Seg( Runde );
}

[biede1987 (Gast)]

ok ich habs jetzt umgeschrieben vielen dank, funktioniert

 // Lichtschranke ist ein Taster und alle Segmente werden angesteuert, es wird gezaehlt von 1-9 Resettaster setzt zurueck auf 0

      int Lichtschranke = 11; // oder Taster
      int Lichtschrankeunterbrochen; // Variable für den Pin Zustand 
      int letzteRunde; // Variable für den letzten Schalterzustand letzte Runde
      int Runde = 0; // Wie oft ist der Schalter gedrückt   
    
      int reset = 12;
      int resetdruecken;
      //int resetgedrueckt;

      int a = 2; // a
      int b = 3;
      int c = 4;
      int d = 5;
      int e = 6;
      int f = 7;
      int g = 8;



    void setup(){
 
      Serial.begin(9600); // Start der seriellen Kommunikation mit 9600bps
      pinMode(Lichtschranke,INPUT);
      pinMode(reset,INPUT);
      pinMode(a,OUTPUT);
      pinMode(b,OUTPUT);
      pinMode(c,OUTPUT);
      pinMode(d,OUTPUT);
      pinMode(e,OUTPUT);
      pinMode(f,OUTPUT);
      pinMode(g,OUTPUT);
  
       letzteRunde = digitalRead(Lichtschranke); // Anfangszustand lesen
       resetdruecken = digitalRead(reset); // Anfangszustand lesen
        
      }
  
  void loop() 
   
   { 
  if (digitalRead(reset) == LOW)
    Runde = 0;

  Lichtschrankeunterbrochen = digitalRead(Lichtschranke);
  if (Lichtschrankeunterbrochen != letzteRunde) { // Der Zustand des Schalters hat sich verändert 

    if (Lichtschrankeunterbrochen == HIGH) { // Ist der Schalter gedrückt? 
      Runde++; // Inkrementieren der Variablen Runde 

      Serial.print("Wir sind jetzt in der ");
      Serial.print(Runde);
      Serial.println(" Runde");
    }

    letzteRunde = Lichtschrankeunterbrochen;
  }

  writeTo7Seg( Runde );
}

void writeTo7Seg( uint8_t wert )
{
  if( wert == 0 )
  {
      digitalWrite(a,0);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,0);
      digitalWrite(e,0);
      digitalWrite(f,0);
      digitalWrite(g,1);
  }

  else if( wert == 1 )
  {
      digitalWrite(a,1);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,1);
      digitalWrite(e,1);
      digitalWrite(f,1);
      digitalWrite(g,1);
  }

  else if( wert == 2 )
  {
    digitalWrite(a,0);
      digitalWrite(b,0);
      digitalWrite(c,1);
      digitalWrite(d,0);
      digitalWrite(e,0);
      digitalWrite(f,1);
      digitalWrite(g,0);
  }
 else if( wert == 3 )
  {
      digitalWrite(a,0);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,0);
      digitalWrite(e,1);
      digitalWrite(f,1);
      digitalWrite(g,0);
  }
  else if( wert == 4 )
  {
      digitalWrite(a,1);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,1);
      digitalWrite(e,1);
      digitalWrite(f,0);
      digitalWrite(g,0);
  }
  else if( wert == 5 )
  {
      digitalWrite(a,0);
      digitalWrite(b,1);
      digitalWrite(c,0);
      digitalWrite(d,0);
      digitalWrite(e,1);
      digitalWrite(f,0);
      digitalWrite(g,0);
  }
  else if( wert == 6 )
  {
      digitalWrite(a,0);
      digitalWrite(b,1);
      digitalWrite(c,0);
      digitalWrite(d,0);
      digitalWrite(e,0);
      digitalWrite(f,0);
      digitalWrite(g,0);
  }
  else if( wert == 7 )
  {
      digitalWrite(a,0);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,1);
      digitalWrite(e,1);
      digitalWrite(f,1);
      digitalWrite(g,1);
  }
  else if( wert == 8 )
  {
      digitalWrite(a,0);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,0);
      digitalWrite(e,0);
      digitalWrite(f,0);
      digitalWrite(g,0);
  }
  else if( wert == 9 )
  {
      digitalWrite(a,0);
      digitalWrite(b,0);
      digitalWrite(c,0);
      digitalWrite(d,0);
      digitalWrite(e,1);
      digitalWrite(f,0);
      digitalWrite(g,0);
  }
}

[Karl H. (kbuchegg)]

biede1987 schrieb:
> ok ich habs jetzt umgeschrieben

Gut.
Du solltest alten Hasen ruhig etwas glauben, wenn sie Dinge ansprechen, 
die du für unnötig hältst.
Genauso wie dir die alten Hasen sagen werden, dass eine konsistente und 
saubere Code-Einrückung nicht einfach nur Selbstzweck ist, sondern 
durchaus ein Instrument um Code und Logikfehler zu finden bzw. gar nicht 
erst aufkommen zu lassen.

Es ist (auf lange Sicht) eben nicht egal, ob ....

...
  else if( wert == 2 )
  {
    digitalWrite(a,0);
      digitalWrite(b,0);
      digitalWrite(c,1);
      digitalWrite(d,0);
      digitalWrite(e,0);
      digitalWrite(f,1);
      digitalWrite(g,0);
  }
 else if( wert == 3 )
  {

das eine else nicht unter dem anderen steht, das eine abhängige 
digitalWrite um 4 Zeichen eingerückt ist und die anderen um 6. Ob du 
einmal die KLammern so anordnest

  if( ... ) {
    ...
  }

und das andere mal so

  if( ... )
  {
    ...
  }

Ob es dir egal ist, dass die schliessende } einer Funktion wieder am 
linken Rand steht, oder so wie hier

    void setup(){
 
      Serial.begin(9600); // Start der seriellen Kommunikation mit 9600bps
      pinMode(Lichtschranke,INPUT);
      pinMode(reset,INPUT);
      pinMode(a,OUTPUT);
      pinMode(b,OUTPUT);
      pinMode(c,OUTPUT);
      pinMode(d,OUTPUT);
      pinMode(e,OUTPUT);
      pinMode(f,OUTPUT);
      pinMode(g,OUTPUT);
  
       letzteRunde = digitalRead(Lichtschranke); // Anfangszustand lesen
       resetdruecken = digitalRead(reset); // Anfangszustand lesen
        
      }

nicht.

Das alles sind rein formale Dinge. Aber ... sie haben einen Einfluss ob 
ein Code leicht zu lesen ist, oder ob man zur Fehlersuche erst mal am 
liebsten den Code reformatiert um die falsch gesetzten oder fehlenden 
{-} Klammern zu finden.

[biede1987 (Gast)]

ja stimmt schon was du sagst, jetzt ist viel übersichtlichter danke 
nochmal

[Klaus I. (klauspi)]

biede1987 schrieb:
> sagt sich so einfach nimm den,
> ich hab jetzt schon mit dem angefangen!

Das ist ein Grund, aber kein Hindernis ;o)

Sorry, ich wollte Dir den Spaß an der lehrreichen Eigenentwicklung nicht 
nehmen. Der olle 4026 macht halt genau das: Bis Zehn zählen, evtl. Reset 
und hat gleich die Ausgänge speziell für Siebensegment-Anzeigen. Im 
Prinzip macht er genau das was Du im ersten Post umrissen hast. Evtl. 
müsste man noch eine Entprellung hinzufügen z.B. 555 monostabil.

Wenn bei Deinem Mikrocontroller mal die Pins knapp werden, kannst Du das 
vielleicht kombinieren.

Auf jeden Fall noch viel Spaß und Erfolg bei Deinem Projekt!
Klaus

[biede1987 (Gast)]

Guten Abend nochmal,

ich möchte jetzt als nächste 4 / Segmentanzeigen mit meinem Arduino 
ansteuern. Jeweils  2 Anzeigen nutzen um die Runden von 0 bis 99 zu 
zählen.

Ich habe als Eingänge 2 Lichtschranke die auch schon funktionieren und 
als Ausgang hab ich diese 7 Segment anzeige.

http://www.ebay.de/itm/Rot-0-56-7-Segment-4-Digit-Super-LED-Display-Common-Anode-Time-12-pins-Anzeige-/400580687232?pt=Bauteile&hash=item5d44783580


Als Mikrokontroller hab ich mir den Arduino Mega gekauft.

Beigefügt hab ich mal mein Blockschaltbild.

was meint ihr ?

ich denke das Programm von oben, mit der Logik kann ich bei meienm neuen 
anwenden?

[Karl H. (kbuchegg)]

Ich denke, du solltest jetzt den nächsten Schrittt machen und deine 
Ansteuerung der 7-Segment Anzeigen auf Multiplexbetrieb umstellen.

[biede1987 (Gast)]

ok dann versuchs jetzt mit dem arduinon mega und der 4x 7 
Segmentnanzeige.

[biede1987 (Gast)]

Hallo nochmal, ich hab jetzt mein 4/ 7 Segmentanzeigen angeschlossen!

http://www.ebay.de/itm/Rot-0-56-7-Segment-4-Digit-Super-LED-Display-Common-Anode-Time-12-pins-Anzeige-/400580687232?pt=Bauteile&hash=item5d44783580

Das Programm von oben hab ich auf meinen Arduino Mega aufgespielt, der 
Zähler funktionier auf der ersten Anzeige.

Wie kann ich jetzt programmieren das er nicht nur von 1 bi 9 zählt, 
sondern von 1 - 99! So dass ich die zweite auch ansteuer!

Es ist nämlich so wenn ich dann meine 2 Ausgänge, dig 1 und 2 ansteuer 
wird eine 11 , 22 usw. weiter angesteuert.

Würde es was bringen wenn ich mit einer libary arbeite?

Danke für die Anworten schonmal!

Gruß biede

[biede1987 (Gast)]

http://www.instructables.com/files/orig/FDF/W8AY/G1BBDO34/FDFW8AYG1BBDO34.txt

könnte mir dieses Programm helfen? So könnte ich doch meine Zahlen 
darstelln oder?

[Karl H. (kbuchegg)]

biede1987 schrieb:

> Wie kann ich jetzt programmieren das er nicht nur von 1 bi 9 zählt,
> sondern von 1 - 99!

Das ist die falsche Frage.
Die richtige Frage lautet: wie steuere ich mehrere 7-Segment Anzeigen im 
Multiplexverfahren an?

Denn dein Zähler für die Runden ist eine ganze normale uint8_t 
Variablre, die bis 255 zählen kann. Das ist aber losgelöst von der 
Fragestellung, wie man auf mehreren 7_Segment Anzeigen ausgibt. Der Weg 
dorthin führt über die Erkentniss, dass man mehrstellige Anzeigen so 
ansteuert, dass immer nur eine der Anzeigen angesteuert wird und kurz 
drauf die nächste. Wenn das schnell genug gemacht wird, dann kommt dein 
Auge bzw. Gehirn nicht mehr mit, dass du immer nur eine Anzeige 
leuchtet. Voila: du siehst beide gleichzeitig leuchten (natürlich mit 
anderem Inhalt)

> Würde es was bringen wenn ich mit einer libary arbeite?

Es würde was bringen, wenn du die Grundlagen lernen würdest.

[Karl H. (kbuchegg)]

biede1987 schrieb:
> http://www.instructables.com/files/orig/FDF/W8AY/G1BBDO34/FDFW8AYG1BBDO34.txt
>
> könnte mir dieses Programm helfen? So könnte ich doch meine Zahlen
> darstelln oder?

Das Programm ist Müll.
Selbst für einen Ardino ist das Müll.

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> Denn dein Zähler für die Runden ist eine ganze normale uint8_t
> Variablre, die bis 255 zählen kann. Das ist aber losgelöst von der
> Fragestellung, wie man auf mehreren 7_Segment Anzeigen ausgibt. Der Weg
> dorthin führt über die Erkentniss, dass man mehrstellige Anzeigen so
> ansteuert, dass immer nur eine der Anzeigen angesteuert wird und kurz
> drauf die nächste. Wenn das schnell genug gemacht wird, dann kommt dein
> Auge bzw. Gehirn nicht mehr mit, dass du immer nur eine Anzeige
> leuchtet. Voila: du siehst beide gleichzeitig leuchten (natürlich mit
> anderem Inhalt)

Die einfachst mögliche Version (wenn auch nicht die schönste oder beste 
oder einfach auch nur die Version wie man das normalerweise macht), 
könnte zb so aussehen

uint8_t Stelle;

void loop() 
{ 
  ...


  // ... alle Anzeigen abschalten
  ....
  // ... welches ist die nächste Stelle?
  Stelle++;
  if( Stelle == 1 )   // momentan sind es nur 2 Stellen
    Stelle = 0;

  // ... die jeweiligen Ausgangstreiber befüllen
  if( Stelle == 0 )
    writeTo7Seg( Runde % 10 );
  else if( Stelle == 1 )
    writeTo7Seg( Runde / 10 );

  // ... und die betreffende Anzeige einschalten
  if( Stelle == 0 )
    ....
  else if( Stelle == 1 )
    ....
}

Schön ist das nicht gerade. Normalerweise macht man so einen Multiplex 
mit einem Timer, der laufend und unabhähngig vom restlichen Programm die 
Bitmuster für die einzelnen Stellen jeweils reihum an den einzelnen 
Anzeigen ausgibt. Aber ich fürchte, das kriegst du noch nicht hin. D.h. 
dein nächstes Ziel lautet: den Umgang mit einem Timer lernen.

[biede1987 (Gast)]

Danke für die Antworten

das programm was ich gefunden hab ist müll weil es viel zu lang wird 
oder?

das was du geschrieben hast arbeitet mit der 7 Seg libary?

[Karl H. (kbuchegg)]

biede1987 schrieb:
> Danke für die Antworten
>
> das programm was ich gefunden hab ist müll weil es viel zu lang wird
> oder?

Das Programm ist deswegen Müll, weil derjenige der es geschrieben hat, 
selber nicht programmieren kann. Es ist auf genau dieselbe Art Müll, wie 
wenn ein Grundschüler im zweiten Jahr, der gerade mal im Zahlenraum bis 
100 addieren kann, dein Grundstück vermisst. Aus seiner Sicht mag es ihm 
nicht schlecht vorkommen, aber objektiv gesehen ist es der Versuch mit 
einem Sandkastenschäufelchen eine Baugrube auszuheben.

Du kannst es drehen und wenden wie du willst: Ehe man ein größeres 
Programm schreiben kann, muss man erst mal die Grundlagen lernen. Wenn 
man von seiner Programmiersprache noch nicht mal 10% des Umfangs 
beherrscht, dann hat das alles keinen Sinn.

[Jürgen S. (jurs)]

biede1987 schrieb:
> http://www.instructables.com/files/orig/FDF/W8AY/G1BBDO34/FDFW8AYG1BBDO34.txt
>
> könnte mir dieses Programm helfen? So könnte ich doch meine Zahlen
> darstelln oder?

Falls Du ein fertiges und alternatives Programm suchst, das auch mit 
anderer Hardware (aber auch mit Arduino!) arbeiten darf, hätte ich da 
was in der Schublade liegen.

Für:
- Arduino UNO oder kompatibles Board
- Anzeige: LCD-Keypad-Shield zum Aufstecken auf den Arduino
- Sensoren: Ein Reedkontakt pro Fahrspur unter der Fahrbahn montiert

Sag Bescheid, ob den fertigen Sketch für LCD-Keypad-Shield mal posten 
soll!

[biede1987 (Gast)]

Ja das wäre toll wenn du das mal posten kannst, ich versuchs mal 
trotzdem mit den 7 Segemnetanzeigen!

Danke

[Kai S. (kai1986)]

Hallo,

das Ansteueren bzw. Multiplexen von 7-Segmentanzeigen ist hier ganz gut 
beschrieben.
http://www.mikrocontroller.net/articles/AVR-Tutorial:_7-Segment-Anzeige

Das Codebeispiel ist zwar in ASM, ist aber nicht wichtig, da du egal mit 
welcher Sprache immer das gleiche machen musst, um das Display 
anzusteueren.

Zum Umwandeln der Rundenzahl aus der Variable in ein anzeigetaugliches 
Format findest du hier noch einige Informationen.
http://www.mikrocontroller.net/articles/AVR_Arithmetik#Bin.C3.A4r_zu_BCD_-_Umwandlung

Gruß Kai

[Jürgen S. (jurs)]

biede1987 schrieb:
> Ja das wäre toll wenn du das mal posten kannst, ich versuchs mal
> trotzdem mit den 7 Segemnetanzeigen!

Das dürfte allerdings um einiges komplizierter werden als nur die 
Umstellung auf die Verwendung Deiner Lichtschranken als Sensor zur 
Erkennung, wann ein Fahrzeug die Ziellinie überquert.

Das hier habe ich mal für einen Bekannten gemacht, der mit seinem Enkel 
auf einer Carrera-Bahn Rennen ausfährt, wenn der mal zu Besuch ist:

/* 
   Slotcar timing by "jurs" for mikrocontroller.net forum
   Hardware required: Arduino UNO, LCD keypad shield, 2 reed contacts
*/
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); // LCD keypad shield (i.e. Sainsmart)

#define LEDPIN 13
#define SLOTS 2
// Mindestrundenzeit in Millisekunden, alles darunter als Kontaktprellen interpretieren
#define MINROUNDTIME 500
// Pins zum Anschluss der Reedkontakte (D2, D3)
byte reedPins[]={2,3};
// Interrupt-Nummern zu diesen Pins
byte pinInterrupts[]={0,1};
// Interrupt-Behandlungsroutinen
void (*isrFunctions[])() = { timing1, timing2 };

// Start der letzten Runde in Millisekunden, volatile weil Zugriff auch aus ISR!
volatile long rundenAnfang[]={0,0};
// Rundenzeit der letzten Runde in Millisekunden
long rundenZeit[]={99990,99990};
// Rundenzeit der schnellsten Runde in Millisekunden
long rundenZeitRekord[]={99990,99990};
// Rundenzähler
int rundenAnzahl[]={0,0};


void setup() {
  // LCD Anzeige mit Spalten und Zeilen initialisieren
  lcd.begin(16, 2);
  // Anzeige LED-13 auf dem Board initialisieren
  pinMode(LEDPIN,OUTPUT);
  // Reedkontakte und ISR Routinen initialisieren
  for (int i=0;i<SLOTS;i++)
  {
    pinMode(reedPins[i],INPUT_PULLUP);
    attachInterrupt(pinInterrupts[i], isrFunctions[i], FALLING);
  }  
}

void timing1()
{
  if (millis()-rundenAnfang[0]>MINROUNDTIME)
    rundenAnfang[0]=millis();
}

void timing2()
{
  if (millis()-rundenAnfang[1]>MINROUNDTIME)
    rundenAnfang[1]=millis();
}

void RundenzeitenVerarbeiten()
{
  // Start der vorletzten Runde in Millisekunden
  static long rundenAnfangVerarbeitet[]={0,0};
  long curMillis;
  // Aktuellen Stand der millis() Funktion merken
  curMillis=millis();
  // Alle Slots auf Veränderungen der Rundenstartzeit abklappern
  for (int i=0;i<SLOTS;i++)
  { 
    if  (rundenAnfangVerarbeitet[i]!=rundenAnfang[i])
    { // Neue Runde seit dem letzten Loopdurchlauf
      rundenAnzahl[i]++; // Rundenzähler hochzählen
      // Rundenzeit ermitteln
      rundenZeit[i]=rundenAnfang[i]-rundenAnfangVerarbeitet[i];
      // Feststellen ob es eine schnellste Runde war
      if (rundenZeit[i]<rundenZeitRekord[i])
        rundenZeitRekord[i]=rundenZeit[i];
      // Am Ende diese Rundenzeit als verarbeitet merken  
      rundenAnfangVerarbeitet[i]=rundenAnfang[i];
    }
  }
}

void RundenanzahlAnzeigen()
{ static long lastUpdate;
  char lcdline[17];
  // Anzeige nur alle 500 ms aktualisieren
  if (millis()/500==lastUpdate) return;
  lastUpdate=millis()/500; 
  for (int i=0;i<SLOTS;i++)
  {
    snprintf(lcdline,sizeof(lcdline),"%d %5d Runden  ",i+1,rundenAnzahl[i]);
    lcd.setCursor(0,i);
    lcd.print(lcdline);
  }  
}

void RundenzeitenAnzeigen()
{ static long lastUpdate;
  long dieseRunde, dieserRekord;
  char lcdline[17];
  int zeit[4];
  // Anzeige nur alle 500 ms aktualisieren
  if (millis()/500==lastUpdate) return;
  lastUpdate=millis()/500; 
  for (int i=0;i<SLOTS;i++)
  {
    // Rundenzeit und schnellste Zeit auf Zeitangabe in hundertstel runden
    dieseRunde=(rundenZeit[i]+5)/10;
    dieserRekord=(rundenZeitRekord[i]+5)/10;
    zeit[0]=dieseRunde/100; // ganze Sekunden
    zeit[1]=dieseRunde%100; // hundertstel Sekunden
    zeit[2]=dieserRekord/100;  // ganze Sekunden
    zeit[3]=dieserRekord%100; // hundertstel Sekunden
    snprintf(lcdline,sizeof(lcdline),"%d%3d:%02d SR%3d:%02d",i+1,zeit[0],zeit[1],zeit[2],zeit[3]);
    lcd.setCursor(0,i);
    lcd.print(lcdline);
  }  
}

void loop()
{
  RundenzeitenVerarbeiten();
  if ((millis()/2000)%2==1)
    RundenzeitenAnzeigen();
  else 
    RundenanzahlAnzeigen();  
  // Nun noch die Pin-13 LED ein wenig blinken lassen, wenn man möchte  
  if (millis()-rundenAnfang[0]<200 || millis()-rundenAnfang[1]<200)
    digitalWrite(LEDPIN,HIGH);
  else  
    digitalWrite(LEDPIN,LOW);  
}

Dieser Sketch ist so wie gepostet für die Erfassung von zwei Fahrzeugen 
vorgesehen. Eine Erweiterung auf mehr Fahrzeuge (4 bis 6) wäre am 
einfachsten möglich, indem man ein Board mit mehr als zwei 
Hardware-Interrupts verwendet (z.B. "Arduino-MEGA").

Die Sensoren müssen an einem UNO-kompatiblen Board an den beiden Pins 
angeschlossen werden, die Hardware-Interrupts erzeugen können, das sind 
D2 und D3. Für die Auswertung der Reedkontakte werden die internen 
PullUp-Widerstände in dieser Zeile aktiviert:
 pinMode(reedPins[i],INPUT_PULLUP);
Wenn Deine Lichtschranken keine PullUps benötigen, dort einfach INPUT 
statt INPUT_PULLUP einsetzen.

Und falls Du etwas an der Anzeige ändern möchtest: Das Programm 
realisiert eine automatische Wechselanzeige, und zwar wird in einem 
Rhythmus von 2 Sekunden umgeschaltet zwischen Anzeigen für 
"Rundenzeiten" und "Rundenanzahl". Als Rundenzeiten werden sowohl die 
Zeiten der letzten gestoppten Runde und die schnellste Rundenzeit "SR" 
pro Fahrzeug angezeigt.

Falls Du die Anzeige ändern möchtest (vielleicht zunächst mal zur 
Ausgabe auf dem Seriellen Monitor), diese Funktionen sind in diesen 
beiden Funktionen zusammengefasst:
void RundenanzahlAnzeigen()
void RundenzeitenAnzeigen()

Rückstellung auf Null und Neustart des Sketches für das nächste Rennen 
einfach durch Drücken des Reset-Buttons, dann startet der Controller 
neu.

Vielleicht findest Du durch den Code, ansonsten kannst Du ja fragen.

[Karl H. (kbuchegg)]

biede1987 schrieb:

> trotzdem mit den 7 Segemnetanzeigen!

LCD wär einfacher. Aber ich sehs wie du: 7-Segment sieht für den Zweck 
einfach cooler aus.

Und? Wirds was?

Wie gesagt: der Trick ist, dass die beiden Anzeigen (bzw. dann 4 in 
weiterer Folge) abwechselnd leuchten. Jede mit ihrer eigenen Ziffer bzw. 
dem jeweils anzuzeigendem LED-Muster.

Da fällt mir noch was ein.
Wenn du an anderen Programmstellen keine exzessiven Delays benutzt, dann 
kann man am Arduino auch mittels 'millis()'
http://arduino.cc/de/Reference/Millis
so was ähnliches machen, zu dem man normalerweise einen Timer einsetzt.



Shit:
Ich hab gerade versucht, dir da mal was zurecht zu machen.
Aber dieses digitalWrite wirft einem da dauerns Prügel zwischen die 
Beine. Mit dem kann man das alles nicht vernünftig machen.

An welchen Portpins hast du deine 7-Segment Anzeige wie angeschlossen? 
Das machen wir direkt am Arduino System vorbei. Das ist in Summe 
einfacher, als sich da am digitalWrite vorbei zu mogeln. Bzw. falls du 
nicht alle 7 Segnentleitungen an einem Port beisammen hast, kannst du 
die noch hardwaremässig umlegen? Denn wenn mehrere Leitungen auf einen 
Schlag gesetzt oder nicht gesetzt werden sollen, dann geht das deutlich 
einfacher als mit dieser if-then-else und digitalWrite Orgie. 
Voraussetzung ist aber, dass alle 7 Segmentleitungen an einem 
physikalischen AVR Port liegen.

[Karl H. (kbuchegg)]

Hätt ich eigentlich schon früher machen sollen.
Nein, eigentlich hättest du das schon früher machen sollen.

Warum nimmst du eigentlich nicht das hier?
http://playground.arduino.cc/Main/SevenSegmentLibrary

[biede1987 (Gast)]

Danke Karl Heinz das du mir so hilfst,

die Libary hab ich mir vorgestern schon runter geladen, deswegen hab ich 
auch gefragt ob man es besser ist mit einer libarty zu arbeiten. Bin da 
aber nicht wirklich weiter gekommen.

[biede1987 (Gast)]

ich hab hier mal mein Ein und Ausgänge

    // Um die Runden der Fahrzeuge zu zählen, bedarf es einer Abfrage am 
Startzielbogen
    // um dem Mikrocontroller mitzuteilen ob das Fahrzeuge durchgefahren 
ist oder nicht.
    // Die Kontrolle, ob ein Fahrzeug durch den Startzielbogen gefahren 
ist , geschieht durch
    // eine selbst gebaute Infrarot - Lichtschranke, die am Bogen unten 
angebracht ist.
    // Ist die Lichtschranke belegt, dann sendet sie eine 1 an den 
Mikrokontroller, sobald sich
    // nicht belegt ist sendet sie eine 0.  Durch einen Reset Taster 
werden die Runden wieder auf zurückgesetzt


      int Lichtschranke1 = 11; // Taster
      int Lichtschranke2 = 13; // Taster
      int Lichtschrankeunterbrochen1; // Variable für Pin Zustand Bahn 2
      int Lichtschrankeunterbrochen2; // Variable für Pin Zustand Bahn 2
      int letzteRunde1; // Variable für den letzten Schalterzustand 
letzte Runde Bahn1
      int letzteRunde2; // Variable für den letzten Schalterzustand 
letzte Runde Bahn2
      int Runde1 = 0; // Wie oft ist der Schalter gedrückt Bahn 1
      int Runde2 = 0; // Wie oft ist der Schalter gedrückt Bahn 2

      int reset = 12;
      int resetdruecken;   // Variable fuer Reset Taster

      int a = 9;
      int b = 3;
      int c = 4;
      int d = 5;
      int e = 6;
      int f = 7;
      int g = 8;
      int d1 =24;
      int d2 =26;
      int d3 =28;
      int d4 =30;




    void setup(){

      Serial.begin(9600); // Start der seriellen Kommunikation mit 
9600bps
      pinMode(Lichtschranke1,INPUT);
      pinMode(Lichtschranke2,INPUT);
      pinMode(reset,INPUT);
      pinMode(a,OUTPUT);
      pinMode(b,OUTPUT);
      pinMode(c,OUTPUT);
      pinMode(d,OUTPUT);
      pinMode(e,OUTPUT);
      pinMode(f,OUTPUT);
      pinMode(g,OUTPUT);
      pinMode(d1,OUTPUT)
      pinMode(d1,OUTPUT);
      pinMode(d2,OUTPUT);
      pinMode(d3,OUTPUT);
      pinMode(d4,OUTPUT);

[biede1987 (Gast)]

ich hab dir hier mal meine pin belegung

ich versuchs mal weiter mit der 7seg

Danke

[biede1987 (Gast)]

Hallo nochmal,

ich hab jetzt mal das Beispiel gemacht, hab meine Ausgänge dem Programm 
angepasst. Die Zeit läuft auch ab!

Aber Warum leuchte die ersten zwei Ziffern heller wie die letzten zwei?

Hab über die gleichen Widerstände verwendet!

[biede1987 (Gast)]

#include "SevSeg.h"

//Create an instance of the object.
SevSeg sevseg;

//Create global variables
unsigned long timer;
int CentSec=0;

void setup() {
  //I am using a common anode display, with the digit pins connected
  //from 2-5 and the segment pins connected from 6-13
  sevseg.Begin(1,24,26,28,30,9,3,4,5,6,7,8,40);
  //Set the desired brightness (0 to 100);
  sevseg.Brightness(80);

  timer=millis();
}

void loop() {
  //Produce an output on the display
  sevseg.PrintOutput();

  //Check if 10ms has elapsed
  unsigned long mils=millis();
  if (mils-timer>=10) {
    timer=mils;
    CentSec++;
    if (CentSec==10000) { // Reset to 0 after counting for 100 seconds.
      CentSec=0;
    }
    //Update the number to be displayed, with a decimal
    //place in the correct position.
    sevseg.NewNum(CentSec,(byte) 2);
  }
}

[biede1987 (Gast)]

Hallo nochmal

    
      #include "SevSeg.h"


      SevSeg sevseg;

      int Lichtschranke1 = 11; // Taster
      int Lichtschranke2 = 13; // Taster
      int Lichtschrankeunterbrochen1; // Variable für Pin Zustand Bahn 2
      int Lichtschrankeunterbrochen2; // Variable für Pin Zustand Bahn 2
      int letzteRunde1; // Variable für den letzten Schalterzustand letzte Runde Bahn1
      int letzteRunde2; // Variable für den letzten Schalterzustand letzte Runde Bahn2
      int Runde1 = 0; // Wie oft ist der Schalter gedrückt Bahn 1   
      int Runde2 = 0; // Wie oft ist der Schalter gedrückt Bahn 1 2
    
      int reset = 12;
      int resetdruecken;   // Variable fuer Reset Taster
      
      
      void setup(){
 
      Serial.begin(9600); // Start der seriellen Kommunikation mit 9600bps
      pinMode(Lichtschranke1,INPUT);
      pinMode(Lichtschranke2,INPUT);
      
      letzteRunde1 = digitalRead(Lichtschranke1); // Anfangszustand lesen
      letzteRunde2 = digitalRead(Lichtschranke1); // Anfangszustand lesen
      
      resetdruecken =digitalRead(reset); // Anfangszustand lesen
      
      sevseg.Begin(1,24,26,28,30,9,3,4,5,6,7,8,32);
        //Set the desired brightness (0 to 100);
      sevseg.Brightness(90);
          
      }
      
       void loop()  { 
         
          sevseg.PrintOutput();
          
          
          if (digitalRead(reset) == HIGH)
               Runde1 = 0;

              Lichtschrankeunterbrochen1 = digitalRead(Lichtschranke1);
            if (Lichtschrankeunterbrochen1 != letzteRunde1) { // Der Zustand des Schalters hat sich verändert 

    if (Lichtschrankeunterbrochen1 == HIGH) { // Ist der Schalter gedrückt? 
      Runde1++; // Inkrementieren der Variablen Runde 

      Serial.print("Wir sind jetzt in der ");
      Serial.print(Runde1);
      Serial.println(" Runde Bahn1");
    }

    letzteRunde1 = Lichtschrankeunterbrochen1;
    sevseg.NewNum(Runde1,(byte) 2);
    
  }

 
  
  
}

[biede1987 (Gast)]

Ich habs jetzt hinbekommen das ich wenn ich meine Lichtschranke 1 
betätige die Anzeig hochzählt von 1- 9999.

Wie bekomm ich jetzt hin, dass meine ersten zwei Ziffern für die erste 
bahn sind und meine letzten zwei für die die zweite Bahn, sodass dann 
beide bis 99 zählen.

[Karl H. (kbuchegg)]

Sorry, war unterwegs. Nach dem auspacken seh ich mir mal durch, was du 
gebaut hast.

Nur soviel vorab, wenn deine Anzeige Zahlen von 0 bis 9999 anzeigen 
kannst, dann kannst du ja aus 2 Rundenzählern, die jeder von 0 bis 99 
gehen, die auszuegbende Zahl zusammensetzen:

auszugebende_Zahl = Runde1 * 100 + Runde2;

[Karl H. (kbuchegg)]

Karl Heinz schrieb:
> Sorry, war unterwegs. Nach dem auspacken seh ich mir mal durch, was du
> gebaut hast.
>
> Nur soviel vorab, wenn deine Anzeige Zahlen von 0 bis 9999 anzeigen
> kannst, dann kannst du ja aus 2 Rundenzählern, die jeder von 0 bis 99
> gehen, die auszuegbende Zahl zusammensetzen:
>
> auszugebende_Zahl = Runde1 * 100 + Runde2;

Damit das geht musst du aber die Unterdrückung der führenden 0-en in der 
Lib entweder modifizieren oder aber ganz rauswerfen

Das ist in

void SevSeg::FindNums()

der ganze Teil nach

    //If there are zeros, set them to 20 which means a blank
    //However, don't cut out significant zeros

[biede1987 (Gast)]

Wie kann ich die ändern muss ich die in ne text datei umwandlen und dann 
rauslöschen?

[Karl H. (kbuchegg)]

biede1987 schrieb:
> Wie kann ich die ändern muss ich die in ne text datei umwandlen und dann
> rauslöschen?

Im Zip File hast du ja eine cpp-Datei und ein h-File vorgefunden.
Beides sind einfach nur Text-Dateien. Das cpp-File enthält den 
Programmtext deiner 'Library'.

[biede1987 (Gast)]

ich hab jetzt den teil rausgelöscht

 //If there are zeros, set them to 20 which means a blank
    //However, don't cut out significant zeros
    if (negative==0) {
      if (nums[0]==0 && DecPlace<3){
        nums[0]=20;
        if (nums[1]==0 && DecPlace<2) {
          nums[1]=20;
          if (nums[2]==0 && DecPlace==0) {
            nums[2]=20;
          }
        }
      }
    }
    else {
      if (nums[1]==0 && DecPlace<2) {
        nums[1]=20;
        if (nums[2]==0 && DecPlace==0) {
          nums[2]=20;
        }



die dritte 0 kommt trotzdem noch

[Karl H. (kbuchegg)]

biede1987 schrieb:

> die dritte 0 kommt trotzdem noch

'noch' oder 'nicht'?

Das angestrebte Ziel sieht so aus, dass deine 4-stellige 7_Segment 
Anzeige an allen 4 Stellen eine 0 ausgibt, wenn du

   ...NewNum( 0, 2 );

aufrufst.

[biede1987 (Gast)]

jetzt ist es so dass ich am Anfang nichts sehe, und sobald ich meine 
Lichtschranke betätige sind alle anzeigen an und bei der letzten steht 
ne 1 wenn ich jetzt hochzähle bis 20 dann steht bei allen  eine 0

[biede1987 (Gast)]

kommisch erst wenn ich die Lichtschranke betätige dann fängt bei sie 
anzuzählen, ich seh nicht von Anfang an die 0000.

 // Um die Runden der Fahrzeuge zu zählen, bedarf es einer Abfrage am Startzielbogen 
    // um dem Mikrocontroller mitzuteilen ob das Fahrzeuge durchgefahren ist oder nicht. 
    // Die Kontrolle, ob ein Fahrzeug durch den Startzielbogen gefahren ist , geschieht durch
    // eine selbst gebaute Infrarot - Lichtschranke, die am Bogen unten angebracht ist.  
    // Ist die Lichtschranke belegt, dann sendet sie eine 1 an den Mikrokontroller, sobald sich 
    // nicht belegt ist sendet sie eine 0.  Durch einen Reset Taster werden die Runden wieder auf zurückgesetzt
    
    
      #include "SevSeg.h"


      SevSeg sevseg;

      int Lichtschranke1 = 11; // Taster
      int Lichtschranke2 = 13; // Taster
      int Lichtschrankeunterbrochen1; // Variable für Pin Zustand Bahn 2
      int Lichtschrankeunterbrochen2; // Variable für Pin Zustand Bahn 2
      int letzteRunde1; // Variable für den letzten Schalterzustand letzte Runde Bahn1
      int letzteRunde2; // Variable für den letzten Schalterzustand letzte Runde Bahn2
      int Runde1 = 0; // Wie oft ist der Schalter gedrückt Bahn 1   
      int Runde2 = 0; // Wie oft ist der Schalter gedrückt Bahn 1 2
    
      int reset = 12;
      int resetdruecken;   // Variable fuer Reset Taster
      
      
      void setup(){
 
      Serial.begin(9600); // Start der seriellen Kommunikation mit 9600bps
      pinMode(Lichtschranke1,INPUT);
      pinMode(Lichtschranke2,INPUT);
      
      letzteRunde1 = digitalRead(Lichtschranke1); // Anfangszustand lesen
      letzteRunde2 = digitalRead(Lichtschranke1); // Anfangszustand lesen
      
      resetdruecken =digitalRead(reset); // Anfangszustand lesen
      
      sevseg.Begin(1,24,26,28,30,9,3,4,5,6,7,8,32);
        //Set the desired brightness (0 to 100);
      sevseg.Brightness(90);
          
      }
      
       void loop()  { 
         
          sevseg.PrintOutput();
          
          
          if (digitalRead(reset) == HIGH)
               Runde1 = 0;

              Lichtschrankeunterbrochen1 = digitalRead(Lichtschranke1);
            if (Lichtschrankeunterbrochen1 != letzteRunde1) { // Der Zustand des Schalters hat sich verändert 

    if (Lichtschrankeunterbrochen1 == HIGH) { // Ist der Schalter gedrückt? 
      Runde1++; // Inkrementieren der Variablen Runde 
       if (Runde1==20) { // Reset von 99 auf 0
           Runde1=0;}
       
          
      Serial.print("Wir sind jetzt in der ");
      Serial.print(Runde1);
      Serial.println(" Runde Bahn1");
    }

    letzteRunde1 = Lichtschrankeunterbrochen1;
    sevseg.NewNum(Runde1,(byte) 2);
    
  }

           
  
  
}

[Karl H. (kbuchegg)]

Dein Code ist furchtbar. Rück den doch mal ordentlich ein!
Das ist kein Selbstzweck, das Code eine ordentliche Einrückung hat. 
Anhand der Einrückung erkennt man die Struktur, inklusive welche 
Anweisungen von welchen anderen Anweisungen abhängen. Je mehr Chaos du 
da veranstaltest, desto unübersichtlicher wird das

// Um die Runden der Fahrzeuge zu zählen, bedarf es einer Abfrage am Startzielbogen 
// um dem Mikrocontroller mitzuteilen ob das Fahrzeuge durchgefahren ist oder nicht. 
// Die Kontrolle, ob ein Fahrzeug durch den Startzielbogen gefahren ist , geschieht durch
// eine selbst gebaute Infrarot - Lichtschranke, die am Bogen unten angebracht ist.  
// Ist die Lichtschranke belegt, dann sendet sie eine 1 an den Mikrokontroller, sobald sich 
// nicht belegt ist sendet sie eine 0.  Durch einen Reset Taster werden die Runden wieder auf zurückgesetzt
    
#include "SevSeg.h"

SevSeg sevseg;
int Lichtschranke1 = 11; // Taster
int Lichtschranke2 = 13; // Taster
int Lichtschrankeunterbrochen1; // Variable für Pin Zustand Bahn 2
int Lichtschrankeunterbrochen2; // Variable für Pin Zustand Bahn 2
int letzteRunde1; // Variable für den letzten Schalterzustand letzte Runde Bahn1
int letzteRunde2; // Variable für den letzten Schalterzustand letzte Runde Bahn2
int Runde1 = 0; // Wie oft ist der Schalter gedrückt Bahn 1   
int Runde2 = 0; // Wie oft ist der Schalter gedrückt Bahn 1 2
    
int reset = 12;
int resetdruecken;   // Variable fuer Reset Taster
      
void setup() {
  Serial.begin(9600); // Start der seriellen Kommunikation mit 9600bps

  pinMode(Lichtschranke1,INPUT);
  pinMode(Lichtschranke2,INPUT);
      
  letzteRunde1 = digitalRead(Lichtschranke1); // Anfangszustand lesen
  letzteRunde2 = digitalRead(Lichtschranke1); // Anfangszustand lesen
      
  resetdruecken =digitalRead(reset); // Anfangszustand lesen
      
  sevseg.Begin(1,24,26,28,30,9,3,4,5,6,7,8,32);
  //Set the desired brightness (0 to 100);
  sevseg.Brightness(90);
}

void loop() {

  sevseg.PrintOutput();

  if (digitalRead(reset) == HIGH)
    Runde1 = 0;

  Lichtschrankeunterbrochen1 = digitalRead(Lichtschranke1);
  if (Lichtschrankeunterbrochen1 != letzteRunde1) { // Der Zustand des Schalters hat sich verändert 

    if (Lichtschrankeunterbrochen1 == HIGH) { // Ist der Schalter gedrückt? 
      Runde1++; // Inkrementieren der Variablen Runde 
      if (Runde1==20) { // Reset von 99 auf 0
        Runde1=0;
      }
       
      Serial.print("Wir sind jetzt in der ");
      Serial.print(Runde1);
      Serial.println(" Runde Bahn1");
    }

    letzteRunde1 = Lichtschrankeunterbrochen1;
    sevseg.NewNum(Runde1,(byte) 2);  
  }
}

Ruf halt mal in setup()

   sevseg.NewNum( 0,(byte) 2);

auf, damit die Anzeige auch eine gesicherte Ausgabe hat, solange sich 
noch nichts an den Lichtschranken getan hat.

...
void setup() {
...
  sevseg.Begin(1,24,26,28,30,9,3,4,5,6,7,8,32);
  //Set the desired brightness (0 to 100);
  sevseg.Brightness(90);
  sevseg.NewNum( 0,(byte) 2);  
}

[biede1987 (Gast)]

Also wenn ich 0 eingebe dann kommen auch vier 0000

[Karl H. (kbuchegg)]

biede1987 schrieb:
> Also wenn ich 0 eingebe dann kommen auch vier 0000

ja, soll auch (momentan) so sein.
Die Unterdrückung führender 0-en ist abgeschaltet!

[biede1987 (Gast)]

Darf ich die zwei 0 vorne noch sehen oder nicht? seitdem wir was aus der 
sevseg datei was rausgelöscht haben?

Wenn ja dann würde es ja passen!

[biede1987 (Gast)]

ok warst schneller  danke!



jetzt würde ich mal meine zweite Lichtschranke in das Programm mit 
reinbauen.

[Karl H. (kbuchegg)]

passt fürs erste
kümmere dich jetzt erst mal um die 2-te lichtschranke

[biede1987 (Gast)]

// Um die Runden der Fahrzeuge zu zählen, bedarf es einer Abfrage am Startzielbogen 
    // um dem Mikrocontroller mitzuteilen ob das Fahrzeuge durchgefahren ist oder nicht. 
    // Die Kontrolle, ob ein Fahrzeug durch den Startzielbogen gefahren ist , geschieht durch
    // eine selbst gebaute Infrarot - Lichtschranke, die am Bogen unten angebracht ist.  
    // Ist die Lichtschranke belegt, dann sendet sie eine 1 an den Mikrokontroller, sobald sich 
    // nicht belegt ist sendet sie eine 0.  Durch einen Reset Taster werden die Runden wieder auf zurückgesetzt
    
    
      #include "SevSeg.h"


      SevSeg sevseg;

      int Lichtschranke1 = 11; // Taster
      int Lichtschranke2 = 13; // Taster
      int Lichtschrankeunterbrochen1; // Variable für Pin Zustand Bahn 2
      int Lichtschrankeunterbrochen2; // Variable für Pin Zustand Bahn 2
      int letzteRunde1; // Variable für den letzten Schalterzustand letzte Runde Bahn1
      int letzteRunde2; // Variable für den letzten Schalterzustand letzte Runde Bahn2
      int Runde1 = 0; // Wie oft ist der Schalter gedrückt Bahn 1   
      int Runde2 = 0; // Wie oft ist der Schalter gedrückt Bahn 1 2
    
      int reset = 12;
      int resetdruecken;   // Variable fuer Reset Taster
      
      int auszugebende_Zahl; 
      
      
      void setup(){
 
      Serial.begin(9600); // Start der seriellen Kommunikation mit 9600bps
      pinMode(Lichtschranke1,INPUT);
      pinMode(Lichtschranke2,INPUT);
      
      letzteRunde1 = digitalRead(Lichtschranke1); // Anfangszustand lesen
      letzteRunde2 = digitalRead(Lichtschranke2); // Anfangszustand lesen
      
      resetdruecken =digitalRead(reset); // Anfangszustand lesen
      
      sevseg.Begin(1,24,26,28,30,9,3,4,5,6,7,8,32);
        //Set the desired brightness (0 to 100);
      sevseg.Brightness(90);
          
      }
      
       void loop()  { 
         
          sevseg.PrintOutput();
          
          
          if (digitalRead(reset) == HIGH)
               Runde1 = 0;

              Lichtschrankeunterbrochen1 = digitalRead(Lichtschranke1);
            if (Lichtschrankeunterbrochen1 != letzteRunde1) { // Der Zustand des Schalters hat sich verändert 

    if (Lichtschrankeunterbrochen1 == HIGH) { // Ist der Schalter gedrückt? 
      Runde1++; // Inkrementieren der Variablen Runde 
       if (Runde1==20) { // Reset von 99 auf 0
           Runde1=0;}
       
          
      Serial.print("Wir sind jetzt in der ");
      Serial.print(Runde1);
      Serial.println(" Runde Bahn1");
      
      
    }}
    
    
        letzteRunde1 = Lichtschrankeunterbrochen1;
        
        
         if (digitalRead(reset) == HIGH)
               Runde2 = 0;

              Lichtschrankeunterbrochen2 = digitalRead(Lichtschranke2);
            if (Lichtschrankeunterbrochen2 != letzteRunde2) { // Der Zustand des Schalters hat sich verändert 

    if (Lichtschrankeunterbrochen2 == HIGH) { // Ist der Schalter gedrückt? 
      Runde2++; // Inkrementieren der Variablen Runde 
       if (Runde2==20) { // Reset von 99 auf 0
           Runde2=0;}
           
      Serial.print("Wir sind jetzt in der ");
      Serial.print(Runde2);
      Serial.println(" Runde Bahn2");
       
    }
    
    letzteRunde2 = Lichtschrankeunterbrochen2;
    
    auszugebende_Zahl = Runde1 * 100 + Runde2;
    
    sevseg.NewNum(auszugebende_Zahl,(byte) 2);
    
      }

           
  
    
}

[biede1987 (Gast)]

Ich zähle jetzt auf beiden Seiten,

Problem ist jetzt nur noch wenn ich die Lichtschranke Bahn 1 betätige 
zählt es zwar am Serial Monitor hoch, aber nicht auf meine Anzeige, erst 
wenn ich Lichtschranke 2 betätige dann leuchte meine Anteige und ich 
sehe beide Runden.

[biede1987 (Gast)]

Muss ich mein

auszugebende_Zahl = Runde1 * 100 + Runde2;

    sevseg.NewNum(auszugebende_Zahl,(byte) 2);

in die letzte Klammer oder?

[Karl H. (kbuchegg)]

biede1987 schrieb:

> Problem ist jetzt nur noch

Sorry. Ich greif den Chaoscode nicht mehr an, solange der so aussieht.
Wenn zureden nichts hilft, dann eben auf die harte Tour. Solange, bis du 
merkst, dass ein vernünftig aussehender Code eine Hilfe dabei ist, 
Logikfehler zu sehen und zu beseitigen.

[biede1987 (Gast)]

// Um die Runden der Fahrzeuge zu zählen, bedarf es einer Abfrage am Startzielbogen 
    // um dem Mikrocontroller mitzuteilen ob das Fahrzeuge durchgefahren ist oder nicht. 
    // Die Kontrolle, ob ein Fahrzeug durch den Startzielbogen gefahren ist , geschieht durch
    // eine selbst gebaute Infrarot - Lichtschranke, die am Bogen unten angebracht ist.  
    // Ist die Lichtschranke belegt, dann sendet sie eine 1 an den Mikrokontroller, sobald sich 
    // nicht belegt ist sendet sie eine 0.  Durch einen Reset Taster werden die Runden wieder auf zurückgesetzt
    
    
      #include "SevSeg.h"


      SevSeg sevseg;

      int Lichtschranke1 = 11; // Taster
      int Lichtschranke2 = 13; // Taster
      int Lichtschrankeunterbrochen1; // Variable für Pin Zustand Bahn 2
      int Lichtschrankeunterbrochen2; // Variable für Pin Zustand Bahn 2
      int letzteRunde1; // Variable für den letzten Schalterzustand letzte Runde Bahn1
      int letzteRunde2; // Variable für den letzten Schalterzustand letzte Runde Bahn2
      int Runde1 = 0; // Wie oft ist der Schalter gedrückt Bahn 1   
      int Runde2 = 0; // Wie oft ist der Schalter gedrückt Bahn 1 2
    
      int reset = 12;
      int resetdruecken;   // Variable fuer Reset Taster
      
      int auszugebende_Zahl; 
      
      
      void setup(){
 
      Serial.begin(9600); // Start der seriellen Kommunikation mit 9600bps
      pinMode(Lichtschranke1,INPUT);
      pinMode(Lichtschranke2,INPUT);
      
      letzteRunde1 = digitalRead(Lichtschranke1); // Anfangszustand lesen
      letzteRunde2 = digitalRead(Lichtschranke2); // Anfangszustand lesen
      
      resetdruecken =digitalRead(reset); // Anfangszustand lesen
      
      sevseg.Begin(1,24,26,28,30,9,3,4,5,6,7,8,32);
        //Set the desired brightness (0 to 100);
      sevseg.Brightness(90);
          
      }
      
       void loop()  { 
         
          sevseg.PrintOutput();
          
          
          if (digitalRead(reset) == HIGH)
               Runde1 = 0;

              Lichtschrankeunterbrochen1 = digitalRead(Lichtschranke1);
            if (Lichtschrankeunterbrochen1 != letzteRunde1) { // Der Zustand des Schalters hat sich verändert 

    if (Lichtschrankeunterbrochen1 == HIGH) { // Ist der Schalter gedrückt? 
      Runde1++; // Inkrementieren der Variablen Runde 
       if (Runde1==20) { // Reset von 99 auf 0
           Runde1=0;}
       
          
      Serial.print("Wir sind jetzt in der ");
      Serial.print(Runde1);
      Serial.println(" Runde Bahn1");
      
      
    }}
    
    
        letzteRunde1 = Lichtschrankeunterbrochen1;
        
        
         if (digitalRead(reset) == HIGH)
               Runde2 = 0;

              Lichtschrankeunterbrochen2 = digitalRead(Lichtschranke2);
            if (Lichtschrankeunterbrochen2 != letzteRunde2) { // Der Zustand des Schalters hat sich verändert 

    if (Lichtschrankeunterbrochen2 == HIGH) { // Ist der Schalter gedrückt? 
      Runde2++; // Inkrementieren der Variablen Runde 
       if (Runde2==20) { // Reset von 99 auf 0
           Runde2=0;}
           
      Serial.print("Wir sind jetzt in der ");
      Serial.print(Runde2);
      Serial.println(" Runde Bahn2");
       
    }
    
    letzteRunde2 = Lichtschrankeunterbrochen2;
    
    
    
      }

        auszugebende_Zahl = Runde1 * 100 + Runde2;
    
    sevseg.NewNum(auszugebende_Zahl,(byte) 2);   
  
    
}

[biede1987 (Gast)]

Doch so wars jetzt gehts ich tu ihn jetzt noch ordnen!

[biede1987 (Gast)]

habs in die letzte Klammer und hat funktioniert

[biede1987 (Gast)]

// Um die Runden der Fahrzeuge zu zählen, bedarf es einer Abfrage am 
Startzielbogen
    // um dem Mikrocontroller mitzuteilen ob das Fahrzeuge durchgefahren 
ist oder nicht.
    // Die Kontrolle, ob ein Fahrzeug durch den Startzielbogen gefahren 
ist , geschieht durch
    // eine selbst gebaute Infrarot - Lichtschranke, die am Bogen unten 
angebracht ist.
    // Ist die Lichtschranke belegt, dann sendet sie eine 1 an den 
Mikrokontroller, sobald sich
    // nicht belegt ist sendet sie eine 0.  Durch einen Reset Taster 
werden die Runden wieder auf zurückgesetzt


      #include "SevSeg.h"

      SevSeg sevseg;

      int Lichtschranke1 = 11; // Taster
      int Lichtschranke2 = 13; // Taster
      int Lichtschrankeunterbrochen1; // Variable für Pin Zustand Bahn 2
      int Lichtschrankeunterbrochen2; // Variable für Pin Zustand Bahn 2
      int letzteRunde1; // Variable für den letzten Schalterzustand 
letzte Runde Bahn1
      int letzteRunde2; // Variable für den letzten Schalterzustand 
letzte Runde Bahn2
      int Runde1 = 0; // Wie oft ist der Schalter gedrückt Bahn 1
      int Runde2 = 0; // Wie oft ist der Schalter gedrückt Bahn 1 2

      int reset = 12;
      int resetdruecken;   // Variable fuer Reset Taster

      int auszugebende_Zahl;

      void setup(){

        Serial.begin(9600); // Start der seriellen Kommunikation mit 
9600bps
        pinMode(Lichtschranke1,INPUT);
        pinMode(Lichtschranke2,INPUT);

        letzteRunde1 = digitalRead(Lichtschranke1); // Anfangszustand 
lesen
        letzteRunde2 = digitalRead(Lichtschranke2); // Anfangszustand 
lesen

        resetdruecken =digitalRead(reset); // Anfangszustand lesen

        sevseg.Begin(1,24,26,28,30,9,3,4,5,6,7,8,32);
        //Set the desired brightness (0 to 100);
        sevseg.Brightness(90);

        }

       void loop()  {

          sevseg.PrintOutput();

          if (digitalRead(reset) == HIGH)
               Runde1 = 0;

          Lichtschrankeunterbrochen1 = digitalRead(Lichtschranke1);
          if (Lichtschrankeunterbrochen1 != letzteRunde1) { // Der 
Zustand des Schalters hat sich verändert

            if (Lichtschrankeunterbrochen1 == HIGH) { // Ist der 
Schalter gedrückt?
              Runde1++; // Inkrementieren der Variablen Runde
               if (Runde1==99) { // Reset von 99 auf 0
               Runde1=0;}


            Serial.print("Wir sind jetzt in der ");
            Serial.print(Runde1);
            Serial.println(" Runde Bahn1");
    }
  }

          letzteRunde1 = Lichtschrankeunterbrochen1;


         if (digitalRead(reset) == HIGH)
               Runde2 = 0;

         Lichtschrankeunterbrochen2 = digitalRead(Lichtschranke2);
         if (Lichtschrankeunterbrochen2 != letzteRunde2) { // Der 
Zustand des Schalters hat sich verändert

             if (Lichtschrankeunterbrochen2 == HIGH) { // Ist der 
Schalter gedrückt?
             Runde2++; // Inkrementieren der Variablen Runde
             if (Runde2==99) { // Reset von 99 auf 0
                 Runde2=0;}

            Serial.print("Wir sind jetzt in der ");
            Serial.print(Runde2);
            Serial.println(" Runde Bahn2");

            }

          letzteRunde2 = Lichtschrankeunterbrochen2;
      }

        auszugebende_Zahl = Runde1 * 100 + Runde2;
        sevseg.NewNum(auszugebende_Zahl,(byte) 2);

}

[biede1987 (Gast)]

Vielen Dank nochmal das du mir so viel geholfen hast!!

[biede1987 (Gast)]

Warum leuchten meine ersten zwei Ziffern nicht so hell wie die letzten 
zwei?

[biede1987 (Gast)]

Hallo ich bins nochmal,

ich möchte mein Programm nochmals erweitertn:

4-stellige 7 Segmentanzeige bleibt,


zuätzlich soll über den Serial Monitor die Rundenzeit angezeigt werden!

Ich hab das Programm weiter geschrieben könnte es so funktionieren?

Vielen Dank schonmal für die Hinweise!

Danke

[Jürgen S. (jurs)]

biede1987 schrieb:
> Ich hab das Programm weiter geschrieben könnte es so funktionieren?

Du hast doch Dein Arduino-Board und eine Carrera-Bahn, probier's einfach 
aus!

Übrigens habe ich hier auch mal im Arduino-Forum für jemanden mit 
Carrera-Bahn eine Runden- und Zeitmessung gemacht und gepostet:
http://forum.arduino.cc/index.php?topic=158779.msg1189593#msg1189593
(Ich selbst habe keine Bahn.)

Als Sensoren werden da einfach nur zwei Reed-Kontakte verwendet, mit 
Heißkleber unter die Bahn geklebt, und die Anzeige erfolgt auf einem 
16x2 Text-LCD vom Typ "LCD Keypad Shield" zum Aufstecken für das 
Arduino-Board.

Die Rundenzeiten werden in meinem Sketch per Interrupt-Routine 
ermittelt, da ich mir nicht sicher war, ob die kleinen Flitzer nicht zu 
schnell sind und den Reed-Kontakt für zu kurze Zeit schließen, um per 
Polling zuverlässig abgefragt zu werden, insbesondere wenn zwei 
Rennwagen "fast gleichzeitig" den kurzen Rundenimpuls erzeugen, weil sie 
im Rennen gleichauf liegen.

Das LCD macht eine nette "Wechselanzeige", im Zweisekundentakt wechseln 
sich ab:
- Rundenzahlen auf den Bahnen
- Rundenzeiten (letzte Runde und schnellste Rennrunde)
So ist nicht nur auf der Rennbahn "Action", sondern auch auf der 
Anzeigentafel tut sich laufend etwas.

Vielleicht möchtest Du Dir auch diesen Code mal ansehen.

[biede1987 (Gast)]

Hallo ich hab mich jetzt nochmal versucht,


ich hab jetzt ein Programm geschrieben bei dem ich zeit der runden 
messe!

Funktioniert auch soweit

[biede1987 (Gast)]

int Lichtschranke1 =11;

long Rundenanfang1;
long Rundenzeit1; 

void setup()
{
 
  pinMode(Lichtschranke1, INPUT);
  
  Serial.begin(9600);
}


void loop()
{
      if(digitalRead(Lichtschranke1) == HIGH){           // Sobald die Taste gedrückt wurde
      Rundenanfang1 = millis();
       while(digitalRead(Lichtschranke1) == HIGH);       // Warten so lange bis die Lichtschranke wieder betätigt wird
       long Rundenzeit1 = millis() - Rundenanfang1;
      Serial.print("Das ist die Rundenzeit ");             // Ausgaben zum Serial Monitor, nur sichtbar am PC
      Serial.print(Rundenzeit1);
      Serial.println(" Bahn1"); 
  }
}

[biede1987 (Gast)]

Was jetzt kommisch ist wenn die das programmierte Programm in mein altes 
einfüge!

kommt am serial monitior die richtige Anzeige. Also Rundenzeit + Runde

Nur meine 4-stellige 7 Segmentanzeige funktioniert nicht, sie leuchtet 
nur dann wenn die Lichtschranke unterbrochen ist!

Könnt mir erklären wieso,

Vielen Dank schon mal im Vorraus!


PS
Hallo Jürgen, danke für die INFO hab ich vorgestern Abend auch schon 
gefunden, ich habs mir angeschaut und es war eine gute hilfe! möchte es 
aber nciht mit einem LCD display machen sondern mit 7 Segmentanzeigen! 
Hab auch alles schon aufgebaut und funktioniert! ich möchte jetzt nur 
auf dem Serialmontitor die Rundenzeiten und die Geschwindigkeit 
herrausgeben!

[biede1987 (Gast)]

// Um die Runden der Fahrzeuge zu zählen, bedarf es einer Abfrage am Startzielbogen 
    // um dem Mikrocontroller mitzuteilen ob das Fahrzeuge durchgefahren ist oder nicht. 
    // Die Kontrolle, ob ein Fahrzeug durch den Startzielbogen gefahren ist , geschieht durch
    // eine selbst gebaute Infrarot - Lichtschranke, die am Bogen unten angebracht ist.  
    // Ist die Lichtschranke belegt, dann sendet sie eine 1 an den Mikrokontroller, sobald sich 
    // nicht belegt ist sendet sie eine 0.  Durch einen Reset Taster werden die Runden wieder auf zurückgesetzt
    // Desweiteren soll ich Rundenzeit der beiden Bahnen gemessen werden
    
    
    
      #include "SevSeg.h"                     //4 stellige 7 Segemnt Library hinzufügen
      SevSeg sevseg;        

      int Lichtschranke1 = 11;                // Zuweisung für Lichtschranke Bahn1 = Pin 11
      int Lichtschranke2 = 13;                // Zuweisung für Lichtschranke Bahn2 = Pin 13
      int Lichtschrankeunterbrochen1;         // Variable für Pin Zustand Bahn 1
      int Lichtschrankeunterbrochen2;         // Variable für Pin Zustand Bahn 2
      int letzteRunde1;                       // Variable für den letzten Schalterzustand letzte Runde Bahn1
      int letzteRunde2;                       // Variable für den letzten Schalterzustand letzte Runde Bahn2
      int Runde1 = 0;                         // Varialbe für Rundeanzahl Bahn 1, am Anfang Runde = 0  
      int Runde2 = 0;                         // Varialbe für Rundeanzahl Bahn 2, am Anfang Runde = 0  
      long Rundenanfang1 = 0;                 // Start der letzten Runde in Millisekunden
      long Rundenanfang2 = 0;                 // Start der letzten Runde in Millisekunden
      long Rundenzeit1;               // Rundenzeit der letzten Runde in Millisekunden
      long RundenZeit2;               // Rundenzeit der letzten Runde in Millisekunden
      long RundenZeitRekord1;          // Rundenzeit der schnellsten Runde in Millisekunden
      long RundenZeitRekord2;          // Rundenzeit der schnellsten Runde in Millisekunden

    
      int reset = 12;                         // Zuweisung für Resettaster = Pin 11
      int resetdruecken;                      // Variable für Pin Zustand Resettaster
      
      int auszugebende_Zahl;                  // Variable für auszugebende Zahl, am Display
      
      void setup(){                           //Setup Bedingungen des Programms        
 
        Serial.begin(9600);                   // Start der seriellen Kommunikation mit 9600bps
        pinMode(Lichtschranke1,INPUT);        // setzt den DigitalPin als Eingang
        pinMode(Lichtschranke2,INPUT);        // setzt den DigitalPin als Eingang
      
        letzteRunde1 = digitalRead(Lichtschranke1);       // Anfangszustand auslesen
        letzteRunde2 = digitalRead(Lichtschranke2);       // Anfangszustand auslesen
        resetdruecken =digitalRead(reset);                // Anfangszustand auslesen
      
        sevseg.Begin(1,2,5,6,32,3,7,28,24,22,4,30,26);    // Pin Belegung des Mikroconrollers für 4 stellige 7 Segement Display
        
        sevseg.Brightness(10);                           // Helligkeit des Displays Wert von 0-100
          
      }
      
       void loop()  {                         // Bedingungen die ständig wiederholt werden
         
          sevseg.PrintOutput();               // Erzeugt die Ausgabe am Display
          
          if (digitalRead(reset) == HIGH)     // Wenn Reset 1, Dann Runde1 = 0, Runde wird zurückgesetzt
               Runde1 = 0;

          Lichtschrankeunterbrochen1 = digitalRead(Lichtschranke1);  // Lichtschranke1 Wert lesen und in Varibale Lichtschrankeunterbrochen1 speichern
          if (Lichtschrankeunterbrochen1 != letzteRunde1) {          // Der Zustand des Schalters hat sich verändert 

            if (Lichtschrankeunterbrochen1 == LOW) {                 // Wenn Lichtschranke unterbrochen dann  
              Runde1++;                                              // Runde1 hochzählen +1
              
               if (Runde1==99) {                                     // Wenn Runde 99 erreicht, dann zurücksetzen auf 0
               Runde1=0;}
       
          
            Serial.print("Wir sind jetzt in der ");                  // Ausgaben zum Serial Monitor, nur sichtbar am PC
            Serial.print(Runde1);
            Serial.println(" Runde Bahn1"); 
           }
  }
    
          letzteRunde1 = Lichtschrankeunterbrochen1;                 // Den letzten Schalterzustand merken
        
        
        auszugebende_Zahl = Runde1 * 100 + Runde2;                 // Formel umd Runden am Display anzuzeigen
        sevseg.NewNum(auszugebende_Zahl,(byte) 2);                   // Ausgabe zum 4 stelligen 7 Segmentanzeige
        
            if(digitalRead(Lichtschranke1) == HIGH){     // here if the switch is pressed
            Rundenanfang1 = millis();
            while(digitalRead(Lichtschranke1) == HIGH); // wait while the switch is still pressed
            long Rundenzeit1 = millis() - Rundenanfang1;
            Serial.print("Das ist die Rundenzeit ");                  // Ausgaben zum Serial Monitor, nur sichtbar am PC
            Serial.print(Rundenzeit1);
            Serial.println(" Bahn1"); 
          
    }
    
}

[biede1987 (Gast)]

Wäre super wenn ihr mir helfen könnt!

[Karl H. (kbuchegg)]

biede1987 schrieb:
>

> int Lichtschranke1 =11;
> 
> long Rundenanfang1;
> long Rundenzeit1;
> 
> void setup()
> {
> 
>   pinMode(Lichtschranke1, INPUT);
> 
>   Serial.begin(9600);
> }
> 
> 
> void loop()
> {
>       if(digitalRead(Lichtschranke1) == HIGH){           // Sobald die 
> Taste gedrückt wurde
>       Rundenanfang1 = millis();
>        while(digitalRead(Lichtschranke1) == HIGH);       // Warten so 
> lange bis die Lichtschranke wieder betätigt wird
>        long Rundenzeit1 = millis() - Rundenanfang1;
>       Serial.print("Das ist die Rundenzeit ");             // Ausgaben 
> zum Serial Monitor, nur sichtbar am PC
>       Serial.print(Rundenzeit1);
>       Serial.println(" Bahn1");
>   }
> }
>

So wird das nichts.

Du darfst nicht darauf warten, bis dein Auto die Runde beendet hat.
Du starrst ja auch nicht die ganze Zeit auf eine Stoppuhr, wenn du die 
Rundenzeit messen willst.

Warum machst du denn nicht das naheliegenste.
Hier, an dieser Stelle ....

....
            if (Lichtschrankeunterbrochen1 == LOW) {                 // Wenn Lichtschranke unterbrochen dann  
              Runde1++;                                              // Runde1 hochzählen +1

... weißt du, dass genau zu diesem Zeitpunkt das AUto die Lichtschranke 
durchfahren hat. Und genau zu diesem Zeitpunkt stellst du die aktuelle 
Zeit fest, indem du sie von millis() erfragst.
Die vergleichst du mit der Zeit von der Runde zuvor (wenn es eine Runde 
zuvor gab - das ist aber leicht festzustellen. Wenn die Rundenzahl 1 
ist, dann gab es keine Runde zuvor) und die Differenz der beiden ist die 
Rundenzeit. Die zu diesem Zeitpunkt festgestellte aktuelle Zeit aus 
millis() merkst du dir noch, denn sie ist die Startzeit mit der dann bei 
der nächsten Lichschrankenunterbrechung die nächste Rundenzeit ermittelt 
wird.

....
            if (Lichtschrankeunterbrochen1 == LOW) {                 // Wenn Lichtschranke unterbrochen dann  
              Runde1++;                                              // Runde1 hochzählen +1

              if (Runde1 > 1) {
                Rundenzeit1 = millis() - Rundenanfang1;
                Serial.print(Rundenzeit1);
              }
              Rundenanfang1 = millis();
...

[regine (Gast)]

Tu uns bitte den Gefallen und formatiere deinen Code. Das kann ja keiner 
lesen!!
Dann wird Dir sicherlich geholfen.

[Karl H. (kbuchegg)]

Und wie ich sehe, hat es in den letzten 3 einhalb Monaten auch nicht 
dazu gereicht, den Code mal ordentlich einzurücken.

[biede1987 (Gast)]

Hallo vielen dank für die Hilfe

bin wieder bisschen weiter gekommen!

geb jetzt die zeit in Sekunden aus und die Geschwindigkeit in km/h

Danke

[biede1987 (Gast)]

// Um die Runden der Fahrzeuge zu zählen, bedarf es einer Abfrage am Startzielbogen 
    // um dem Mikrocontroller mitzuteilen ob das Fahrzeuge durchgefahren ist oder nicht. 
    // Die Kontrolle, ob ein Fahrzeug durch den Startzielbogen gefahren ist , geschieht durch
    // eine selbst gebaute Infrarot - Lichtschranke, die am Bogen unten angebracht ist.  
    // Ist die Lichtschranke belegt, dann sendet sie eine 1 an den Mikrokontroller, sobald sich 
    // nicht belegt ist sendet sie eine 0.  Durch einen Reset Taster werden die Runden wieder auf zurückgesetzt
    // Desweiteren soll ich Rundenzeit der beiden Bahnen gemessen werden
    
    
    
      #include "SevSeg.h"                     //4 stellige 7 Segemnt Library hinzufügen
      SevSeg sevseg;        

      int Lichtschranke1 = 11;                // Zuweisung für Lichtschranke Bahn1 = Pin 11
      int Lichtschranke2 = 13;                // Zuweisung für Lichtschranke Bahn2 = Pin 13
      int Lichtschrankeunterbrochen1;         // Variable für Pin Zustand Bahn 1
      int Lichtschrankeunterbrochen2;         // Variable für Pin Zustand Bahn 2
      int letzteRunde1;                       // Variable für den letzten Schalterzustand letzte Runde Bahn1
      int letzteRunde2;                       // Variable für den letzten Schalterzustand letzte Runde Bahn2
      int Runde1 = 0;                         // Varialbe für Rundeanzahl Bahn 1, am Anfang Runde = 0  
      int Runde2 = 0;                         // Varialbe für Rundeanzahl Bahn 2, am Anfang Runde = 0  
      float Rundenanfang1 = 0;                 // Start der letzten Runde in Millisekunden
      float Rundenanfang2 = 0;                 // Start der letzten Runde in Millisekunden
      float Rundenzeit1;               // Rundenzeit der letzten Runde in Millisekunden
      float RundenZeit2;               // Rundenzeit der letzten Runde in Millisekunden
      float Geschwindigkeit1;          // Rundenzeit der schnellsten Runde in Millisekunden
      float Geschwindigkeit2;          // Rundenzeit der schnellsten Runde in Millisekunden

    
      int reset = 12;                         // Zuweisung für Resettaster = Pin 11
      int resetdruecken;                      // Variable für Pin Zustand Resettaster
      
      int auszugebende_Zahl;                  // Variable für auszugebende Zahl, am Display
      
      void setup()
      {                           //Setup Bedingungen des Programms        
 
        Serial.begin(9600);                   // Start der seriellen Kommunikation mit 9600bps
        pinMode(Lichtschranke1,INPUT);        // setzt den DigitalPin als Eingang
        pinMode(Lichtschranke2,INPUT);        // setzt den DigitalPin als Eingang
      
        letzteRunde1 = digitalRead(Lichtschranke1);       // Anfangszustand auslesen
        letzteRunde2 = digitalRead(Lichtschranke2);       // Anfangszustand auslesen
        resetdruecken =digitalRead(reset);                // Anfangszustand auslesen
      
        sevseg.Begin(1,2,5,6,32,3,7,28,24,22,4,30,26);    // Pin Belegung des Mikroconrollers für 4 stellige 7 Segement Display
        
        sevseg.Brightness(10);                           // Helligkeit des Displays Wert von 0-100
          
      }
      
       void loop()  
       {                         // Bedingungen die ständig wiederholt werden
         
          sevseg.PrintOutput();               // Erzeugt die Ausgabe am Display
          
          if (digitalRead(reset) == HIGH) Runde1 = 0;     // Wenn Reset 1, Dann Runde1 = 0, Runde wird zurückgesetzt
               

          Lichtschrankeunterbrochen1 = digitalRead(Lichtschranke1);  // Lichtschranke1 Wert lesen und in Varibale Lichtschrankeunterbrochen1 speichern
          if (Lichtschrankeunterbrochen1 != letzteRunde1)            // Der Zustand des Schalters hat sich verändert 
         {
             if (Lichtschrankeunterbrochen1 == LOW)                  // Wenn Lichtschranke unterbrochen dann  
           {
              Runde1++;                                              // Runde1 hochzählen +1
               
             if (Runde1 > 1)                                         // Wenn Runde größer 1 dann 
              {
                Rundenzeit1 = (millis() - Rundenanfang1)/1000;       // Millis von unten - Rundenanfang1
                Serial.print("Rundenzeit Runde ");                   // Ausgabe Serial Monitor
                Serial.print(Runde1);
                Serial.print(": " );
                Serial.print(Rundenzeit1);
                Serial.println(" Sekunden");
                
               Geschwindigkeit1 = 0.0051 / (Rundenzeit1 / 3600) ;        // Rundenzeit 1 / 3600 Sekunden / 0,51 m   =Geschwindigkeit in km/h          
               
               Serial.print("Durchschnittsgeschwindigkeit der letzten Runde ");                   // Ausgabe Serial Monitor
               Serial.print(Geschwindigkeit1);
               Serial.println( " km/h");
               Serial.println(" ");
             }
                Rundenanfang1 = millis();
                
          
               if (Runde1==99) {Runde1=0;}                             // Wenn Runde 99 erreicht, dann zurücksetzen auf 0
              
       
          
            Serial.print("Wir sind jetzt in der ");                  // Ausgaben zum Serial Monitor, nur sichtbar am PC
            Serial.print(Runde1);
            Serial.println(". Runde Bahn 1"); 
          
          }
        }
    
          letzteRunde1 = Lichtschrankeunterbrochen1;                 // Den letzten Schalterzustand merken
        
        
         auszugebende_Zahl = Runde1 * 100 + Runde2;                 // Formel umd Runden am Display anzuzeigen
        sevseg.NewNum(auszugebende_Zahl,(byte) 2);                   // Ausgabe zum 4 stelligen 7 Segmentanzeige
    
      }

[biede1987 (Gast)]

wenn ich das Programm in das Textfeld einfüge

kommt der immer ohne Einrückung gibt es da einen Trick,

deswegen hab ich auch jetzt das Programm angehängt!

[Karl H. (kbuchegg)]

biede1987 schrieb:
> wenn ich das Programm in das Textfeld einfüge
>
> kommt der immer ohne Einrückung gibt es da einen Trick,

vor das Programm

[c]

nach den Programmtext

[/c]

Siehe auch den Abschnitt "Formatierung" über dem Eingabefeld.

[biede1987 (Gast)]

ok danke

wenn ich jetzt bei dem Programm die Gesamtzeit nach 5 Runden anzeige 
will

Dann schreib ich jetzt auch wieder:
[c]

             if (Runde1 == 5 )                                // Ende 
nach 5 Runden
              {
                Gesamtzeit1 = (millis() - Start1)/1000;       // Millis 
von unten - Rundenanfang1
                Serial.print("Gesamtzeit ");                   // 
Ausgabe Serial Monitor
                Serial.print(": " );
                Serial.print(Gesamtzeit1);
                Serial.println(" Sekunden");

[c/]


wie kann ich meine Start1 ( Startzeit) im Programm ermittlen?

klar wenn die Lichtschranke das erste mal auslöst

am besten so oder?

 if (Runde1==1){   Start1 = millis();}

[biede1987 (Gast)]

ok danke

wenn ich jetzt bei dem Programm die Gesamtzeit nach 5 Runden anzeige
will

Dann schreib ich jetzt auch wieder:

             
              if (Runde1==1){ 
                Start1 = millis();}
             
             if (Runde1 == 5 )                                // Ende nach 5 Runden
              {
                Gesamtzeit1 = (millis() - Start1)/1000;       // Millis von unten - Rundenanfang1
                Serial.print("Gesamtzeit ");                   // Ausgabe Serial Monitor
                Serial.print(": " );
                Serial.print(Gesamtzeit1);
                Serial.println(" Sekunden");

wie kann ich meine Start1 ( Startzeit) im Programm ermittlen?

klar wenn die Lichtschranke das erste mal auslöst

am besten so oder?

 if (Runde1==1){   Start1 = millis();}

[biede1987 (Gast)]

hallo ok das mit der gesamtzeit funktioniert jetzt auch nochmals danke

    
    
      #include "SevSeg.h"                     //4 stellige 7 Segemnt Library hinzufügen
      SevSeg sevseg;        

      int Lichtschranke1 = 11;                // Zuweisung für Lichtschranke Bahn1 = Pin 11
      int Lichtschranke2 = 13;                // Zuweisung für Lichtschranke Bahn2 = Pin 13
      int Lichtschrankeunterbrochen1;         // Variable für Pin Zustand Bahn 1
      int Lichtschrankeunterbrochen2;         // Variable für Pin Zustand Bahn 2
      int letzteRunde1;                       // Variable für den letzten Schalterzustand letzte Runde Bahn1
      int letzteRunde2;                       // Variable für den letzten Schalterzustand letzte Runde Bahn2
      int Runde1 = 0;                         // Varialbe für Rundeanzahl Bahn 1, am Anfang Runde = 0  
      int Runde11;                            // Varialbe für Rundeanzahl -1 fuer Anzeige Bahn1   
      int Runde2 = 0;                         // Varialbe für Rundeanzahl Bahn 2, am Anfang Runde = 0  
      int Runde22;                            // Varialbe für Rundeanzahl -1 fuer Anzeige Bahn2 
    
      float Rundenanfang1 = 0;                // Start der letzten Runde in Millisekunden Bahn1
      float Rundenanfang2 = 0;                // Start der letzten Runde in Millisekunden Bahn2
      float Start1;                           // Start am Anfang des Rennens in Millisekunden Bahn1
      float Start2;                           // Start am Anfang des Rennens in Millisekunden Bahn2
      float Rundenzeit1;                      // Ergebnis Rundenzeit Bahn1
      float Rundenzeit2;                      // Ergebnis Rundenzeit Bahn2
      float Gesamtzeit1;                      // Ergebnis Gesamt Rundenzeit Bahn1
      float Gesamtzeit2;                      // Ergebnis Gesamt Rundenzeit Bahn2
      float Geschwindigkeit1;                 // Ergebnis Geschwindigkeit Bahn1
      float Geschwindigkeit2;                 // Ergebnis Geschwindigkeit Bahn2
      float Gesamtgeschwindigkeit1;           // Ergebnis Gesamt Geschwindigketi Bahn1
      float Gesamtgeschwindkgkeit2;           // Ergebnis Gesamt Geschwindigkeit Bahn2

    
      int reset = 12;                         // Zuweisung für Resettaster = Pin 11
      int resetdruecken;                      // Variable für Pin Zustand Resettaster
      
      int auszugebende_Zahl;                  // Variable für auszugebende Zahl, am Display
      
      void setup(){                           //Setup Bedingungen des Programms        
 
        Serial.begin(9600);                   // Start der seriellen Kommunikation mit 9600bps
        pinMode(Lichtschranke1,INPUT);        // setzt den DigitalPin als Eingang
        pinMode(Lichtschranke2,INPUT);        // setzt den DigitalPin als Eingang
      
        letzteRunde1 = digitalRead(Lichtschranke1);       // Anfangszustand auslesen
        letzteRunde2 = digitalRead(Lichtschranke2);       // Anfangszustand auslesen
        resetdruecken =digitalRead(reset);                // Anfangszustand auslesen
      
        sevseg.Begin(1,2,5,6,32,3,7,28,24,22,4,30,26);    // Pin Belegung des Mikroconrollers für 4 stellige 7 Segement Display
        
        sevseg.Brightness(10);                           // Helligkeit des Displays Wert von 0-100
          
      }
      
       void loop()                            // Bedingungen die ständig wiederholt werden 
   {                         
         
          sevseg.PrintOutput();               // Erzeugt die Ausgabe am Display
          
          // Rundenmessung Bahn1
          
          if (digitalRead(reset) == HIGH)     // Wenn Reset 1, Dann Runde1 = 0, Runde wird zurückgesetzt
               Runde1 = 0;

          Lichtschrankeunterbrochen1 = digitalRead(Lichtschranke1);  // Lichtschranke1 Wert lesen und in Varibale Lichtschrankeunterbrochen1 speichern
          if (Lichtschrankeunterbrochen1 != letzteRunde1)            // Der Zustand des Schalters hat sich verändert 
          { 
            if (Lichtschrankeunterbrochen1 == LOW)                   // Wenn Lichtschranke unterbrochen dann  
            { Runde1++;                                              // Runde1 hochzählen +1
              
              Runde11 = Runde1 - 1;                                  // Variable für Ausgaben Rundenzeit Runde -1 wegen Anzeige auf Serialmonitor
              
              
              
                if (Runde1 > 1)                                      // Wenn Runde größer 1 dann 
              {
                Rundenzeit1 = (millis() - Rundenanfang1)/1000;       // Rundenzeit1 = Millis  - Rundenanfang1 /1000 wegen Sekunden
                Serial.print("Runde Bahn 1: ");
                Serial.println(Runde11);
                Serial.print("Rundenzeit Runde ");                   // Ausgabe Serial Monitor Rundenzeit1
                Serial.print(": " );
                Serial.print(Rundenzeit1);
                Serial.println(" Sekunden");
                
               Geschwindigkeit1 = 0.0051 / (Rundenzeit1 / 3600) ;    // Geschwindigkeit1 in km/h  = 0,51 m Steckenlänge/ (Rundenzeit1 in Millisekunden / 3600 Sekunden)         
               
               Serial.print("Durchschnittsgeschwindigkeit der letzten Runde ");        // Ausgabe Serial Monitor
               Serial.print(Geschwindigkeit1);
               Serial.println( " km/h");
               Serial.println(" ");
             } 
             if (Runde1==1){Start1 = millis();}                     // Wenn Runde1 ==1 dann Start1 mit Gesamtmessung 
             
             if (Runde11 == 3)                                      // Ende nach gewünschten Runden z.B 10 Runden i
             {
                Gesamtzeit1 = (millis() - Start1)/1000;             // Gesamtzeit1 = Millis  - Start1/1000 wegen Sekunden
                Serial.print("Gesamtzeit Bahn1 ");                  // Ausgabe Serial Monitor
                Serial.print(": " );
                Serial.print(Gesamtzeit1);
                Serial.println(" Sekunden");
                Serial.println(" ");
             }
               Rundenanfang1 = millis();                            // Wenn Lichtschranke unterbrochen dann mit Rundenmessung beginnen
               if (Runde1==99) { Runde1=0;}                         // Wenn Runde 99 erreicht, dann zurücksetzen auf 0
               
          }
        }
    
          letzteRunde1 = Lichtschrankeunterbrochen1;                 // Den letzten Schalterzustand merken
          
          // Zeitmessung Bahn2
          
           if (digitalRead(reset) == HIGH)     // Wenn Reset 1, Dann Runde2 = 0, Runde wird zurückgesetzt
               Runde2 = 0;

          Lichtschrankeunterbrochen2 = digitalRead(Lichtschranke2);  // Lichtschranke2 Wert lesen und in Varibale Lichtschrankeunterbrochen2 speichern
          if (Lichtschrankeunterbrochen2 != letzteRunde2)            // Der Zustand des Schalters hat sich verändert 
          { 
            if (Lichtschrankeunterbrochen2 == LOW)                   // Wenn Lichtschranke unterbrochen dann  
            { Runde2++;                                              // Runde2 hochzählen +1
              
              Runde22 = Runde2 - 1;                                  // Variable für Ausgaben Rundenzeit Runde -1 wegen Anzeige auf Serialmonitor
              
             
                if (Runde2 > 1)                                      // Wenn Runde größer 1 dann 
              {
                Rundenzeit2 = (millis() - Rundenanfang2)/1000;       // Rundenzeit2 = Millis  - Rundenanfang2 /1000 wegen Sekunden
                Serial.print("Runde Bahn 2: ");
                Serial.println(Runde22);
                Serial.print("Rundenzeit Runde ");                   // Ausgabe Serial Monitor Rundenzeit2
                Serial.print(": " );
                Serial.print(Rundenzeit2);
                Serial.println(" Sekunden");
                
               Geschwindigkeit2 = 0.0051 / (Rundenzeit2 / 3600) ;    // Geschwindigkeit2 in km/h  = 0,51 m Steckenlänge/ (Rundenzeit2 in Millisekunden / 3600 Sekunden)         
               
               Serial.print("Durchschnittsgeschwindigkeit der letzten Runde ");        // Ausgabe Serial Monitor
               Serial.print(Geschwindigkeit2);
               Serial.println( " km/h");
               Serial.println(" ");
             } 
             if (Runde2==1){Start2 = millis();}                     // Wenn Runde2 ==1 dann Start2 mit Gesamtmessung 
             
             if (Runde22 == 3)                                      // Ende nach gewünschten Runden z.B 10 Runden i
             {
                Gesamtzeit2 = (millis() - Start2)/1000;             // Gesamtzeit2 = Millis  - Start2/1000 wegen Sekunden
                Serial.print("Gesamtzeit Bahn2 ");                  // Ausgabe Serial Monitor
                Serial.print(": " );
                Serial.print(Gesamtzeit2);
                Serial.println(" Sekunden");
                Serial.println(" ");
             }
              Rundenanfang2 = millis();                              // Wenn Lichtschranke unterbrochen dann mit Rundenmessung beginnen
              
               if (Runde2==99) { Runde2=0;}                         // Wenn Runde 99 erreicht, dann zurücksetzen auf 0
               
          
        }
    
          letzteRunde2 = Lichtschrankeunterbrochen2;                 // Den letzten Schalterzustand merken
          
      }
        auszugebende_Zahl = Runde1 * 100 + Runde2;                   // Formel umd Runden am Display anzuzeigen
        sevseg.NewNum(auszugebende_Zahl,(byte) 2);                   // Ausgabe zum 4 stelligen 7 Segmentanzeige
}

[biede1987 (Gast)]

Hallo nochmals ich möchte jetzt noch die beste Rundenzeit auswerten!

wie kann ich das machen?

wie kann ich es machen das sich der Atmega die Rundenzeiten sich merkt 
und vergleicht?