Anfänger braucht Hilfe mit uno

mediakasper:
also muss ich meinen zweiten reed Kontakt an pin 3 anschliessen bei einem gemeinsamen GND?

Ja, Reedkontakt-1 zwischen Ground und D2, Reedkontakt-2 zwischen Ground und D3.

Die Interrupts sind wie folgt zu verwenden:
D2 ==> Interrupt 0
D3 ==> Interrupt 1

Bis zu 6 Slotcars könntest Du übrigens mit einem MEGA Board per Interupt timen, siehe: http://arduino.cc/en/Main/arduinoBoardMega

mediakasper:
jetzt muss nur noch die Programmierung klappen

Was hast Du denn als LCD?
Ein "Keypad-Shield" (LCD mit 6 Tasten) zum Aufstecken auf den Arduino?
Ein "I2C LCD" das mit nur Plus, Minus und 2 Leitungen angeschlossen wird?
Oder nur ein "nacktes" LCD mit 16 Anschlüssen, von denen Du etliche selbst verdrahten müßtest?

Was hast Du denn als LCD?

ich habe das aufsteck lcd mit den 6 Tasten, habe auch weiter oben einen link zu dem bild eingefügt.

mediakasper:

Was hast Du denn als LCD?

ich habe das aufsteck lcd mit den 6 Tasten, habe auch weiter oben einen link zu dem bild eingefügt.

Dann hast Du ja wenig zu basteln und brauchst nur die beiden Reedkontakte anschließen.

Du kannst ja mal zusehen, ob Du in der loop-Funktion aus "roundStart1" und einer Hilfsvariablen die Rundenzeiten selbst herausbekommst, wenn sich der Wert von "roundStart1" ändert.

Ich muß jetzt erstmal einkaufen fürs Wochenende und kann mir dann nachher nochmal ein paar Gedanken dazu machen.

wäre nett wenn du mir da nochmal Hilfestellung leisten könntest.

baue jetzt mal auf dem script vom Kollegen jurs auf:

#define LEDPIN 13  /das wirds der pin sein der meine led blinken lässt?!
#define REEDPIN1 2         /der Eingang der als erste von zwei Interrupts an Pin 2 fungiert?!
#define REEDINTERRUPT1 0
long roundStart1=-9999;   verstehe ich noch nicht

denke das ich das ganze zweimal machen muss wegen der zwei eingänge, versuche das mal in einem script einzubauen

void setup() {
  // put your setup code here, to run once:
  pinMode(LEDPIN,OUTPUT);
  pinMode(REEDPIN1,INPUT_PULLUP);
  attachInterrupt(REEDINTERRUPT1, timing1, CHANGE);
}

void timing1()
{
  boolean static lastState;
  boolean state;
  state=digitalRead(REEDPIN1);
  if (state!=lastState && state==LOW)
    roundStart1=millis();
  lastState=state;  
}

void loop()
{
  if (millis()-roundStart1<500)
    digitalWrite(LEDPIN,HIGH);
  else  
    digitalWrite(LEDPIN,LOW);
}

jetzt mal mein abgeändertes Script:

#define LEDPIN 13
#define REEDPIN1 2
#define REEDINTERRUPT1 0
long roundStart1=-9999;

#define LEDPIN 14               /tu jetzt mal so als würde es die LED mit pin 14 geben für den zweiten Reed Kontakt
#define REEDPIN2 3
#define REEDINTERRUPT2 1
long roundStart1=-9999;

mediakasper:
wäre nett wenn du mir da nochmal Hilfestellung leisten könntest.

Ich bin dann mal so nett.

Das mit der Interruptprogrammierung geht natürlich weit über "Anfängerprogrammierung" hinaus. Aber ohne die Nutzung von Interrupts ist es für Deinen Anwendungsfall kaum sinnvoll zu realisieren, wenn man nicht "verschluckte" Runden riskieren möchte. Mit typischer Anfängerprogrammierung ist Dein Anwendungsfall leider nicht perfekt in Software umsetzbar, sondern nur mit fortgeschrittenen Programmiertechniken und Nutzung der Hardware-Interrupts.

Als Goodies außerhalb Deiner Spezifikation habe ich gleich nochmal einen "Rundenzähler" eingebaut und eine Anzeige, die im Zweisekundentakt wechselt zwischen "Anzeige der Rundenzeiten" und "Anzeige der Rundenanzahl".

Vollständig unter Echtbedingungen testen kann ich natürlich nicht, da ich weder die Rennbahn noch die Reedkontakte habe.

Das Timing selbst ist bis hin zur Verarbeitung übrigens auf tausendstel Sekunden genau und erst beim Anzeigen der Zeiten wird auf hundertsel Sekunden gerundet.

Probier's aus, ob Du was damit anfangen kannst!

Damit Du ggf. selbst Änderungen vornehmen kannst, habe ich einige Kommentarzeilen dazugeschrieben und mich bemüht, sprechende Variablennamen zu vergeben, die von selbst erklären, was darin gespeichert ist.

Außerdem habe ich das Programm gleich so angelegt, daß man es mit möglichst geringem Aufwand auf bis zu sechs Slot-Zeitmessungen erweitern könnte, falls man es auf ein MEGA Board (mit 6 Interrupts) umschreiben und erweitern möchte.

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

#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);  
}

vielen vielen Dank jurs,

habe es gestern Abend noch umgesetzt und es funktionieret super...echt geil wie du das mit dem umschwenken auf die zweite Ebene gemacht hast wäre ich erstmal gar nicht drauf gekommen :wink:

Jedenfalls kommen mein Sohn und mein Enkel heute und wir werden viel Spass haben, kannst sicher sein das Dein Name fällt :wink:

Danke nochmal

jetzt habe ich noch einen Grund mehr mich mit der Programmierung zu beschäftigen....Es ist ein geiles Zeug

mediakasper:
habe es gestern Abend noch umgesetzt und es funktionieret super...echt geil wie du das mit dem umschwenken auf die zweite Ebene gemacht hast wäre ich erstmal gar nicht drauf gekommen :wink:

Ich habe mir gedacht, dass die Anzeige etwas zu langweilig aussieht, wenn sie immer nur dieselben Werte anzeigt. Beim Autorennen ist ja Action angesagt, da kann etwas Action auf der Anzeigetafel auch nicht schaden und ich habe daher die Wechselanzeige realisiert, mit automatischer Umschaltung alle zwei Sekunden zwischen Rundenzeiten und Rundenanzahl.

Nacheinander angezeigt kann man ja mehr Werte darstellen als sie auf einmal ins Display passen.

mediakasper:
Jedenfalls kommen mein Sohn und mein Enkel heute und wir werden viel Spass haben,

Na dann viel Spass mit Kind und Enkel beim Autorennen!

Ganz schön gemischtes Publikum hier im Forum, vom Schulkind bis zum Opa alles dabei.

Nochmal was mir gerade zu den Reedkontakten einfällt, ich habe mir mal im Internet angesehen, wie andere die Kontakte in ihre Bahn einbauen:
http://hackadaycom.files.wordpress.com/2011/06/sensors.jpg?w=1000&h=
Dort sind noch zusätzliche kleine Kondensatoren parallel zu den Reedkontakten geschaltet, mit denen offenbar Kontaktprellen vermieden werden soll. Diese Kondensatoren brauchst Du natürlich nicht, denn im Programm wird Kontaktprellen softwaretechnisch unterdrückt, über die mit 500 Millisekunden extrem lang festgelegte MINROUNDTIME. Durch die Kondensatoren sinkt höchstens die Lebensdauer der Kontakte, denn Reedkontakte sind leider Verschleißteile und nach einigen Millionen Schließvorgängen werden sie meistens defekt. Also die Kondensatoren würde ich lieber weglassen und nur die Reedkontakte einbauen.

mediakasper:
jetzt habe ich noch einen Grund mehr mich mit der Programmierung zu beschäftigen....Es ist ein geiles Zeug

Dann mal zu!

Denn im Endeffekt ist Dein neuer Slotcar-Renncomputer mit dem Programm noch lange nicht ausgelastet, der könnte noch viel mehr. Bis auf die Reset-Taste zum Neustart werden die übrigen Tasten des Keypad-Shields noch gar nicht verwendet und es sind noch etliche Ein-/Ausgänge am Arduino frei.

Z.B. könnte man das Teil zum Startcomputer erweitern: Man könnte z.B. einen Piezo-Piepser oder einige LEDs als "Rennampel" anschließen, beim Drücken auf "Select" könnte dann eine Startsequenz ablaufen an deren Ende der Start signalisiert wird. Wenn man die Rennwagen direkt vor der Start-/Ziellinie mit dem Reedkontakt platziert (Rundenzahl dann am besten auf -1 initialisieren, beim Überfahren der Startlinie springt die Rundenzahl auf 0), könnten dann auch "Frühstarts" einwandfrei erkannt werden, wenn nämlich der Wagen eines Fahrers beim Start den Reedkontakt auslöst, noch bevor das Startsignal gegeben wurde. Der Frühstarter könnte dann vom Arduino automatisch eine Strafrunde aufgebrummt bekommen, oder eine Strafzeit.

Und auch für das Rennende könnte man es verwenden: Wenn man beispielsweise vor Rennbeginn festlegt, wieviele Runden gefahren werden sollen (einstellbar über die Tasten), könnte der Arduino das Rennende ermitteln (wenn der erste Fahrer seine Rundenzahl absolviert hat), die Gesamtzeit ermitteln und feststellen, um wieviel die Nachfolgenden hinterherhängen.

Erweiterungsmöglichkeiten sind also noch vorhanden. :wink:

genauso habe ich mir das auch gedacht :wink:

das wird aber noch ein weiter Weg für mich sein....der aber verdammt viel Spass macht.

Eine Frage noch....wenn ich das Script grafisch auf dem PC wiedergeben möchte, muss ich dann ein Network Shield haben oder kann ich direkt über den am USB angeschlossenen Controllerdie Daten abfragen und weiter reichen?

Danke nochmal und ein schönes Rest Wochenende

mediakasper:
Eine Frage noch....wenn ich das Script grafisch auf dem PC wiedergeben möchte, muss ich dann ein Network Shield haben oder kann ich direkt über den am USB angeschlossenen Controllerdie Daten abfragen und weiter reichen?

Grafische Darstellungen auf dem Arduino zu erstellen, dürfte sehr schwierig werden, denn Grafiken belegen sehr viel Speicherplatz und der Arduino hat nur 2 KB RAM zur Verfügung. Das wird wohl eher nichts.

Was einfach machbar ist und auch über USB-Anschluß am PC funktioniert, ist das Übertragen der Daten per serieller Schnittstelle an den PC.

Im einfachsten Fall machst Du einfach einen seriellen Zeilenticker, der zeilenweise Daten darstellen kann. Dazu einfach in der Arduino-Software den seriellen Monitor öffnen, in der Setup-Funktion die serielle Schnittstelle initialisieren und per Serial.print() bzw. Serial.println() die gewünschten Daten an den PC senden. Dasselbe USB-Kabel, über das der Programmsketch auf den PC geladen wird kann auch dazu dienen, aus dem laufenden Programm heraus Text und Daten an den PC zu senden.

Aus dem Textfenster des Terminals könntest Du die gesendeten Daten und Auswertungen dann auch herauskopieren und ausdrucken oder abspeichern, so dass die Daten später noch nachlesbar sind.

Wenn es ein bischen hübscher dargestellt werden soll als per Zeilenticker, bunt und in Farbe, dann gäbe es die Möglichkeit ein Terminalprogramm auf dem PC laufen zu lassen. Also beispielsweise Hyperterm unter Windows, Putty, oder eines der vielen seriellen Terminalprogramme. Dann könnte man über den Arduino nicht nur einfach Text und Daten senden, sondern auch Steuerzeichen: Zum Setzen von Hintergrund- und Vordergrundfarbe, Positionierung des Cursors, Löschen und Neuaufbauen des Bildschirms etc. So daß man zur Darstellung statt 16 Zeichen mal 2 Zeilen in monochrom auf dem Display dann 80 Zeichen mal 25 Zeilen in 16 Farben auf einem PC-Monitor im Terminalprogramm zur Verfügung hat.

Wenn die Darstellung auf dem PC-Monitor noch toller werden soll als es mit einem Terminal möglich ist, mußt Du wahrscheinlich zur Darstellung auf dem PC auch noch ein PC-Programm programmieren. Dann sendet der Arduino die Daten an den PC, der PC liest die Daten mit dem speziell dafür programmierten Programm von der seriellen Schnittstelle und stellt sie so dar wie man es möchte.

Eine Ethernet-Shield Netzwerkkarte benötigt man für den Arduino dafür nicht. Die wäre erst dann empfehlenswert, wenn man die Daten live ins Internet senden möchte, sagen wir mal Du betreibst eine Livestream-Webcam zur Übertragung Deiner Rennen ins Internet und möchtest auf einer Webseite gleichzeitig das Live-Bild einbinden, aber auch die Renndaten sollen auf der Webseite live neben oder unterhalb des Videostream dargestellt werden.

mediakasper:
Eine Frage noch....wenn ich das Script grafisch auf dem PC wiedergeben möchte, muss ich dann ein Network Shield haben oder kann ich direkt über den am USB angeschlossenen Controllerdie Daten abfragen und weiter reichen?

Für diesen Fall bietet sich Processing an (http://www.processing.org/). Die Arduino IDE basiert im übrigen auf dieser Software, was die Einarbeitung vereinfachen sollte. Mit Processing kann man sehr einfach grafische Ausgaben erzeugen z.B. Diagramme o.ä.
Es gibt sehr viele Beispiele im Netz, die eine Anbindung des Arduino an Processing mittels der seriellen Schnittstelle über USB realisieren. Der Arduino sendet einfach nur Daten über die serielle Schnittstelle und Processing kümmert sich dann (entsprechend programmiert natürlich) um die grafische Aufarbeitung der Daten. In Processing könnte man so z.B. eine richtig große Rundentafel auf den Monitor zaubern.
Mario.

Eine mehr mechanische Frage:

Wie groß sollen die Magnete sein, die in die Autos verbaut werden, wie stark (Remanenz in T) und wie schwer höchstens?

Das Problem ist ja, dass nicht genügend Platz ist für große Magnete und dass ein zu starker oder zu schwerer Magnet das Auto ja abbremst (magnetische Kraft bzw. Gewichtskraft), während ein zu schwacher Magnet den Reed-Kontakt nicht schließen kann.

ardu_englisch:
Eine mehr mechanische Frage:

Wie groß sollen die Magnete sein, die in die Autos verbaut werden, wie stark (Remanenz in T) und wie schwer höchstens?

Das Problem ist ja, dass nicht genügend Platz ist für große Magnete und dass ein zu starker oder zu schwerer Magnet das Auto ja abbremst (magnetische Kraft bzw. Gewichtskraft), während ein zu schwacher Magnet den Reed-Kontakt nicht schließen kann.

Wenn ich das damals richtig verstanden habe, als der Themenstarter dieses Thema vor vier Jahren gestartet hat, dann hat er einfach eine fertige Carrera-Bahn aus dem Karton aufgebaut und gut war's. Die Fahrzeuge hatten den/die Magneten schon dran, so dass er da nichts ändern brauchte. Und einfache Reedkontakte hat er sich vom Elektronikhändler besorgt, und schon hat es auf Anhieb funktioniert, ohne dass er an den Magneten etwas ändern brauchte.

Es kommt aber wohl sehr auf den Maßstab der Bahn an, ob das alles so aus dem Karton funktioniert. Insbesondere bei großen Fahrzeugen sollen die Magnetenab Werk ausreichend stark sein, um einen Reedkontakt unter der Bahn auszulösen.

Ich kenne mich in dem Bereich überhaupt nicht aus, aber es gibt wohl diese Bahnen in den Maßstäben 1:24 oder 1:36 oder 1:43. Von diesen dreien sind die Fahrzeuge und entsprechend wohl auch die Magneten bei 1:24 am größten und kräftigsten.

Von den ganz kleinen Fahrzeugen habe ich gehört, dass es mit der Rundenerfassung mit Reedkontakten unter der Bahn nicht funktioniert, so dass Bastler sich auch andere Systeme haben einfallen lassen, zum Beispiel mit schnellen Lichtschrankensystemen zur Rundenerfassung.

Mir war das im Original-Beitrag nicht aufgefallen (und auch jetzt beim Nachlesen steht da meines Wissens nach nichts), aber egal, die Antwort hat mich zum Nachforschen gebracht:

Und in der Tat werden die Autos im "Amateur-Bereich" (für Kinder und zuhause) wohl standardmäßig mit Magneten an der Bahn gehalten, um die Traktion zu gewährleisten.

Ob dieser Magnet bei meiner Carrera Go!!! (= Maßstab 1:43) für einen Subminiatur-Reed-Kontakt ausreicht, müsste ich also tatsächlich einfach mal ausprobieren. Ich habe mir aber im Baumarkt ein magnetisches Band gekauft. Das sollte leicht und flach genug sein, um nicht zu stören, die Fahreigenschaften nicht zu beeinträchtigen, aber gfs. den magnetischen Impuls gerade genug anzuheben, damit der Reed-Kontakt eine Flanke zeigt.

Vielen Dank auch für die unerwartet schnelle Antwort nach so langer Zeit der Funkstille in diesem Thread!

Nachtrag: In der Tat ist es wohl weniger ein Problem der Stärke des Magneten, sondern der Platzierung der Reed-Kontakte (siehe attachte Skizze).

Die Autos verfügen im Gehäuseboden über einen recht starken, aber leider sehr kompakten Magneten, der etwa so breit ist, wie die beiden Stromleiterspuren auseinander liegen. Links und rechts davon fällt sein Magnetfeld offenbar recht schnell stark ab.

Und egal ob ich die Reed-Kontakte bei Position A, B oder C anklebe, ist der Abstand zum Magneten M leider so hoch, dass die Reed-Kontakte nicht zuverlässig schalten.

Hat irgendwer einen Verbesserungsvorschlag?

Aber es gibt doch mehr Interruptmöglichkeiten beim Arduino.
Stichwort PinChange-Interrupt.

Ulli

Hallo,

jetzt habe ich es alternativ auch mal mit Hall-Sensoren versucht, doch ohne durchschlagenden Erfolg.

Zwar sind die "empfindlicher" als Reed-Relais (sprich: der Abstand, in dem sie auf den Magneten im Gehäuseboden des Fahrzeugs anschlagen, ist deutlich größer und liegt sicher über dem Abstand zwischen Magnet und Fahrbahnuntergrund während des Betriebs, Position "C"), aber es klappt trotzdem nicht.

Ich vermute, dass es an den stromdurchflossenen Leitern liegt, die ein deutlich größeres Magnetfeld induzieren als der Permanentmagnet und diesen damit überlagern, so dass die Änderung des Magnetfelds nicht mehr über einem Schwellwert liegt.

Kennt sich hier jemand aus? Wo und wie sollte man den Hall-Sensor anbringen?

Jurs, I am new to arduino in 2020, and I can only get your code to work if I shuffle the order around a bit. If I try to run in the original order, it will not work.

In my configuation, I am using a 16X2 i2c LCD. That is the only real change, I can't label the variable interrupts before defining the interrupt, unless I shuffle the order of the voids. When I get it running, it only works when I trip both sensors at the same time, and displays both times as identical.

/*
Slotcar timing by "jurs" for German Arduino forum
Hardware required: Arduino UNO, LCD keypad shield, 2 reed contacts
My set-up is two laser gates modules - they work great - no need to rename variables
*/
#include <Wire.h> // Library for I2C communication
#include <LiquidCrystal_I2C.h> // Library for LCD
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2);

#define LEDPIN 13
#define SLOTS 2
// Minimum lap time in milliseconds, interpreting everything below as contact bouncing
#define MINROUNDTIME 500
// Pins for connecting the reed contacts (D2, D3)
byte reedPins[] = {2, 3};
// Interrupt-Numbers for these pins
byte pinInterrupts[] = {0, 1};
// Interrupt-Behandlungsroutinen (treatment routines)

// Start of the last round in milliseconds, volatile because access is also from ISR!
volatile long rundenAnfang[] = {0, 0}; //round start
//Lap time of the last lap in milliseconds
long rundenZeit[] = {99990, 99990}; //lap time
// Lap time of the fastest lap in milliseconds
long rundenZeitRekord[] = {99990, 99990}; //lap time record
// Rundenzähler Lap Counter
int rundenAnzahl[] = {0, 0}; //round number

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

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

void (*isrFunctions[])() = { timing1, timing2 };

void setup() {
// Initialize the LCD display with columns and rows
lcd.init();
lcd.backlight();
// Anzeige LED-13 auf dem Board initialisieren
pinMode(LEDPIN, OUTPUT);
// Initialize reed contacts and ISR routines
for (int i = 0; i < SLOTS; i++)
{
pinMode(reedPins*, INPUT);*
attachInterrupt(pinInterrupts_, isrFunctions*, HIGH);
}
}
void RundenzeitenVerarbeiten() //Process lap times
{
// Start of the penultimate round in milliseconds*
* static long rundenAnfangVerarbeitet[] = {0, 0};
long curMillis;
// Note the current status of the millis () function*
* curMillis = millis();
// Check all slots for changes in the round start time*
* for (int i = 0; i < SLOTS; i++)
{_
if (rundenAnfangVerarbeitet _!= rundenAnfang)
{ // New lap since the last loop run*

rundenAnzahl*++; // Round counters high counts*
* // Determine lap time*
rundenZeit = rundenAnfang - rundenAnfangVerarbeitet*;*
* // Determine if it was the fastest lap*
if (rundenZeit < rundenZeitRekord*)*
rundenZeitRekord = rundenZeit*;*
* // In the end, mark this lap time as processed*
rundenAnfangVerarbeitet = rundenAnfang*;*
* }
}
}
void RundenanzahlAnzeigen() //Show number of laps
{ static long lastUpdate;
char lcdline[17];
// Update display only every 500 ms*

* if (millis() / 500 == lastUpdate) return;
lastUpdate = millis() / 500;
for (int i = 0; i < SLOTS; i++)
{
snprintf(lcdline, sizeof(lcdline), "%d %5d Lap ", i + 1, rundenAnzahl);
lcd.setCursor(0, i);
lcd.print(lcdline);
}
}
void RundenzeitenAnzeigen() //Show lap times
{ static long lastUpdate;
long dieseRunde, dieserRekord;
char lcdline[17];
int zeit[4];
// Update display only every 500 ms*

* if (millis() / 500 == lastUpdate) return;
lastUpdate = millis() / 500;
for (int i = 0; i < SLOTS; i++)
{
// Lap time and fastest lap time in hundredths of a lap*

dieseRunde = (rundenZeit + 5) / 10; // lap time
dieserRekord = (rundenZeitRekord + 5) / 10; // lap time record
* zeit[0] = dieseRunde / 100; // whole seconds*
* zeit[1] = dieseRunde % 100; // hundredths of second*
* zeit[2] = dieserRekord / 100; // whole seconds*
* zeit[3] = dieserRekord % 100; // hundredths of second*
* 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(); // process lap times*

* if ((millis() / 2000) % 2 == 1)
RundenzeitenAnzeigen(); // show lap times*

* else*
* RundenanzahlAnzeigen(); // show number of laps*
* // Now let the pin 13 LED flash a little if you want*
* if (millis() - rundenAnfang[0] < 200 || millis() - rundenAnfang[1] < 200)
digitalWrite(LEDPIN, HIGH);
else*

* digitalWrite(LEDPIN, LOW);
}*_

Es hat keinen Sinn, einen uralten Thread zu kapern. Jurs ist leider nicht mehr aktiv.
Eröffne einen neuen Thread in deutsch oder im englischsprachigen Teil.

Setze Deinen Code bitte in Codetags (</>-Button oben links im Forumseditor oder [code] davor und [/code] dahinter ohne *).
Dann ist er auch auf mobilen Geräten besser lesbar.

Gruß Tommy

thanks Tommy...will do