Zustand eines Counters merken

[Steven (Gast)]

Hallo,

ich habe ein Arduino-Programm, bei dem 2 LED-Streifen abhängig von dem 
Vergleich zweier Counter ein- oder ausgeschalten werden sollen.
Wenn ein Wechsel erfolgt (also LED1 ist ein, soll aber ausgeschalten 
werden; LED2 ist aus und soll eingeschalten werden) soll es ein 
optisches Vorwarnsignal geben (bei mir die Funktionen blinken1() bzw. 
blinken2()), soweit so gut.
Wenn nun aber Counter 1 beim vorigen Zählen höher als Counter 2 war und 
beim jetzigen Zählen wieder, gibt es bei den LEDs ja keine Änderung, 
blinken ist also nicht erforderlich.
Ich hoffe es ist verständlich, was ich gern hätte.
Code schicke ich untenstehend mit.
Ich brauche wahrscheinlich im handleleds() 2 if mehr, bzw. mit else if 
oder?

Lg Steven

CODE:

#define LDRpin1 A0 // pin where we connected the LDR and the resistor
#define LDRpin2 A1
#define LDR_THRESHOLD 993
#include <SimpleTimer.h>
SimpleTimer timer;
const int led11 = 11;
const int led10 = 10;
const int led9 = 9;
const int led8 = 8;
const int led7 = 7;
const int led6 = 6;
const int led5 = 5;
const int led4 = 4;


int LDRValue1 = 0;     // result of reading the analog pin
int LDRValue2 = 0;
int counter1=0;
int counter2=0;
int ldr1flag = 0;
int ldr2flag = 0;

void blinken1(int x){ //funktion lässt led 12 5sek lang pro umlauf 
blinken
  digitalWrite(12, HIGH);
  delay(500);
  digitalWrite(12, LOW);
  delay(500);
  digitalWrite(12, HIGH);
  delay(500);
  digitalWrite(12, LOW);
  delay(500);
  digitalWrite(12, HIGH);
  delay(500);
  digitalWrite(12, LOW);
  delay(500);
  digitalWrite(12, HIGH);
  delay(500);
  digitalWrite(12, LOW);
  delay(500);
  digitalWrite(12, HIGH);
  delay(500);
  digitalWrite(12, LOW);
  delay(500);
}

void blinken2(int y){ //funktion lässt led 13 5sek lang pro umlauf 
blinken
  digitalWrite(13, HIGH);
  delay(500);
  digitalWrite(13, LOW);
  delay(500);
  digitalWrite(13, HIGH);
  delay(500);
  digitalWrite(13, LOW);
  delay(500);
  digitalWrite(13, HIGH);
  delay(500);
  digitalWrite(13, LOW);
  delay(500);
  digitalWrite(13, HIGH);
  delay(500);
  digitalWrite(13, LOW);
  delay(500);
  digitalWrite(13, HIGH);
  delay(500);
  digitalWrite(13, LOW);
  delay(500);
}


void handleLEDs(){
  if(counter1 > counter2){
    blinken1(5000); //funktion blinken1 wird 5000ms (5sek also genau ein 
umlauf) aufgerufen bevor umgeschalten wird
    digitalWrite(12,HIGH);
    digitalWrite(13,LOW);
   digitalWrite(8,HIGH);//rot innen
   digitalWrite(9,LOW);//gruen innen
   digitalWrite(10,HIGH);//rot aussen
   digitalWrite(11,HIGH);//gruen aussen
   digitalWrite(4, HIGH);//gruen innen
   digitalWrite(5, HIGH);//gruen aussen
   digitalWrite(6, HIGH);//rot aussen
   digitalWrite(7, LOW);//rot innen
  }
  else{
   blinken2(5000);  //funktion blinken2 wird 5000ms (5sek also genau ein 
umlauf) aufgerufen bevor umgeschalten wird
   digitalWrite(13,HIGH);
   digitalWrite(12,LOW);
   digitalWrite(8,LOW);//rot innen
   digitalWrite(9,HIGH);//gruen innen
   digitalWrite(10,HIGH);//rot aussen
   digitalWrite(11,HIGH);//gruen aussen
   digitalWrite(4, LOW);//gruen innen
   digitalWrite(5, HIGH);//gruen aussen
   digitalWrite(6, HIGH);//rot aussen
   digitalWrite(7, HIGH);//rot innen
  }
  counter1 = 0;
  counter2 = 0;
}

void setup() {
 timer.setInterval(10000, handleLEDs);
 Serial.begin(9600); // sets serial port for communication
 pinMode(12, OUTPUT);
 pinMode(13, OUTPUT);
 pinMode(led11, OUTPUT);
 pinMode(led10, OUTPUT);
 pinMode(led9, OUTPUT);
 pinMode(led8, OUTPUT);
 pinMode(led7, OUTPUT);
 pinMode(led6, OUTPUT);
  pinMode(led5, OUTPUT);
 pinMode(led4, OUTPUT);
 analogReference (EXTERNAL) ;
 analogRead (0) ;
}

void loop() {
  timer.run();
  LDRValue1 = analogRead(LDRpin1);// read the value from the LDR
 // counter1++;
  LDRValue2 = analogRead(LDRpin2);
 // counter2++;
  Serial.print(LDRValue1);
  Serial.print( " ");
  Serial.print(counter1);
  Serial.println( " ");// read the value from the LDR
  Serial.print(LDRValue2);      // print the value to the serial port
  Serial.print( " ");
  Serial.print(counter2);

  if(LDRValue1 <= LDR_THRESHOLD && ldr1flag == 0)
  {
    counter1++;
   // Serial.println(counter1);
    ldr1flag = 1;
  }

  if(LDRValue1 > LDR_THRESHOLD) ldr1flag = 0;

  if(LDRValue2 <= LDR_THRESHOLD && ldr2flag == 0)
  {
    counter2++;
   // Serial.println(counter2);
    ldr2flag = 1;
  }

  if(LDRValue2 > LDR_THRESHOLD) ldr2flag = 0;

  /*if(LDRValue1 >= LDR_THRESHOLD && LDRValue2 >= LDR_THRESHOLD)
  {
    digitalWrite(12, HIGH);
    digitalWrite(13, HIGH);
  }*/

//  if(LDRValue1 >= LDR_THRESHOLD && LDRValue2 <= LDR_THRESHOLD /*&& 
counter1>counter2*/)
//  {
  //  counter1++;
  //  digitalWrite(13, HIGH);
    //Serial.println(counter1);
 //  digitalWrite(12, LOW);

 // } else {
   // counter1 = 0;
//  }
  //if(LDRValue1 <= LDR_THRESHOLD && LDRValue2 >= LDR_THRESHOLD/* && 
counter2>counter1*/)
  //{

  // counter2++;
  // digitalWrite(12, HIGH);
 //  Serial.println(counter2);
  // digitalWrite(13, LOW);
 // }
  // if(LDRValue1 <= LDR_THRESHOLD && LDRValue2 <= LDR_THRESHOLD)
  //{
  //  digitalWrite(12, LOW);
    //digitalWrite(13, LOW);
 // }

  delay(1000);

  //handleLEDs();

}

[codeleser (Gast)]

Die Parameter x und y der 2 Funktionen "blinken*()" werden ja nirgends 
berücksichtigt, also bei Funktionsaufruf da 5000ms mitgeben bewirkt nix.

[Steven (Gast)]

Inwiefern meinst du berücksichtigt, muss ich die irgendwo definieren was 
die machen sollen?

Sorry ich bin nicht so der Profi damit, deswegen frage ich, bitte erklär 
mir wie ich das machen soll dass das Ganze funktioniert?

[codeleser (Gast)]

Ich habe Deine Beschreibung nicht verstanden, dann habe ich Dein 
Programm diagonalgelesen bis zur ersten Auffälligkeiten und diese 
gemeldet.

Deine Kommentare bei den Funktionsaufrufe "blinken*(5000);" nennen dass 
es 5s dauern soll. Ändert man den Wert 5000 ab, dauern die Funktionen 
aber immernoch 5s
Der als Funktionsparameter x, resp. y, übergebene Wert beeinflusst die 
Blinkdauer gar nicht.
Was wolltest Du mit x, resp. y, denn bezwecken?

Was Du tun must, das musst Du Dir schon selber klar beschreiben können. 
Ich kann nicht hellsehen.

[codeleser (Gast)]

Ich habe dein Beschreibungstext nochmals gelesen und verstehe immer noch 
nicht:
- wie soll es richtig sein/werden?
- was ist nun falsch?

Ausserdem:
- was zählen die 2 counter?
- die counter werden alle 10s auf null gesetzt, ja?
- was ist Hell resp.Dunkel ggü. dem Schwellwert?

[Steven (Gast)]

Was ich mir im handleLEDs() vorstelle, ist:

if(counter1 > counter2)
{
blinken1();
...
}
else if(counter1 < counter2)
{
blinken2();
...
}
else if(counter1 > counter2 && counter1 war auch im vorigen durchlauf 
von handleLEDs (also vor 10sek.) schon größer wie counter2)
{
    digitalWrite(12,HIGH);
    digitalWrite(13,LOW);
   digitalWrite(8,HIGH);//rot innen
   digitalWrite(9,LOW);//gruen innen
   digitalWrite(10,HIGH);//rot aussen
   digitalWrite(11,HIGH);//gruen aussen
   digitalWrite(4, HIGH);//gruen innen
   digitalWrite(5, HIGH);//gruen aussen
   digitalWrite(6, HIGH);//rot aussen
   digitalWrite(7, LOW);//rot innen
}
else if(counter1 < counter2 && counter2 war auch im vorigen durchlauf 
von handleLEDs (also vor 10sek.) schon größer wie counter1)
{
   digitalWrite(13,HIGH);
   digitalWrite(12,LOW);
   digitalWrite(8,LOW);//rot innen
   digitalWrite(9,HIGH);//gruen innen
   digitalWrite(10,HIGH);//rot aussen
   digitalWrite(11,HIGH);//gruen aussen
   digitalWrite(4, LOW);//gruen innen
   digitalWrite(5, HIGH);//gruen aussen
   digitalWrite(6, HIGH);//rot aussen
   digitalWrite(7, HIGH);//rot innen
}

Das blinken soll also nur aufgerufen werden, wenn die LEDs auf Pin 12 
und 13 HIGH und LOW tauschen.

Das ganze Programm steuert Fahrbahnmarkierungen aus LEDs, die variabel 
ist.

Falsch ist, dass ich nicht weiß, wie ich die Bedingung im if setzen 
muss, zu prüfen, ob Pin 12 und 13 ihre Zustände ändern oder ob eh alles 
bleibt wie es ist.

Die verwendeten LDRs fungieren als Zählsensoren, wenn ein Auto 
drüberfährt, kommt es zu einer Verdunkelung, dadurch wird das Fahrzeug 
gezählt. Es gibt pro Fahrtrichtung einen LDR, um das Verkehrsaufkommen 
beider Fahrtrichtungen vergleichen zu können.

Mit den momentanen Einstellungen werden alle 10 Sekunden die Counter auf 
0 zurückgesetzt, da ja alle 10 Sekunden handleLEDs() aufgerufen wird.

[Steven (Gast)]

Hier ein Bild, habe ich auf Google gefunden, dass ich in meinem Fall die 
Funktion blinken1() oder blinken2() nur für 5000ms aufrufe, deswegen 
habe ich das so gemacht.

Ist das nicht korrekt?

[Kirsch (Gast)]

Wenn du den Übergabeparameter nicht benutzt, dann las ihn weg:

Deklaration:
void blinken1(){ ... }

Aufruf:
blinken1();

[Kirsch (Gast)]

Ansonsten mach es variabel, dann brauchst du nur eine Funktion:
blink(uint8_t pin, uint8_t count, uint16_t delay) {
  do{
    digitalWrite(pin, HIGH);
    delay(delay);
    digitalWrite(pin, LOW);
    delay(delay);
  } while(count--);
}

[Kirsch (Gast)]

edit

so rum ist besser fall man Count mit 0 aufruft gibt es kein überlauf:
blink(uint8_t pin, uint8_t count, uint16_t delay) {
  while(count--) {
    digitalWrite(pin, HIGH);
    delay(delay);
    digitalWrite(pin, LOW);
    delay(delay);
  }
}

[Theor (Gast)]

Nötig ist eine klare und detaillierte verbale Beschreibung, was 
eigentlich wann geschehen soll. Dazu auch ein paar Skizzen. Es ist 
nützlich wenn Du selbst und wir eine klare Vorstellung davon haben, was 
passieren soll .
Wenn da Autos vorkommen, sollte in der Beschreibung davon die Rede sein. 
Ebenso etwaiges Blinken und die Orte bzw. die Strecken an denen die 
Autos sich befinden bzw. auf denen sie entlang fahren.

Dann eine zweite Beschreibung wie das realisiert werden soll. Erst hier 
kommen Zähler oder sonstige Programmdetails ins Spiel, da die reale 
Situation ja solche nicht enthält.

Erst dann kommt das Programm, das dieses Verfahren oder den Ablauf 
realisiert.

Es ist soweit klar, dass die Zähler das Anhalten bestimmter Situationen 
feststellen sollen und dass es Übergänge zwischen Situationen geben 
soll. Aber viel mehr kann man so nicht erfahren.

Das mag Dir mühsam vorkommen, aber letztlich machen das erfahrende 
Programmierer so - wenn auch oft im Kopf. Das muss man am Anfang üben. 
In jedem Fall hilft es, Probleme klarer zu fassen.