wie Variable in if-abfrage ändern? -> neues problem: PulseIn, map und if/else

Jetzt hab ichs eingestellt und es funktioniert.
Man sollte sich wohl auch darüber informieren, was man da einträgt und nicht einfach nur tun :blush:

Normalerweise steht da 9600 deswegen sagt man es nicht explizit.
Grüße Uwe

Hallo Daniel_N !

Für dein Problem gibts 'ne Lösung: die Interrupts

Der kleinste Arduino hat 2 externe Interrupts. Diese Interrupts können sogar Warte-Schleifen ( delay ) durchbrechen.
Das heisst, während ein Delay ausgeführt wird, wird das Programm unterbrochen, und führt etwas anderes aus. Danach kehrt das Programm wieder in den Normal-Modus zurück, und führt das Delay zu Ende.

Die Befehle siehst du hier: http://arduino.cc/en/Reference/AttachInterrupt

Aber sauber sind die nicht implementiert. Ich versuche gerade 2 Tasten-Abfragen über einen Interrupt.

MfG

Neues Problem:

Erstmal der aktuelle Code:

// Variables will change:
int ledState = LOW;             // ledState used to set the LED
long previousMillis = 0;        // will store last time LED was updated

// the follow variables is a long because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
int interval = 0;           // interval at which to blink (milliseconds)


#define led1 3
#define led2 5
#define fled1 10 //Led on digital pin 10
#define fled2 11 //Led on digital pin 11

unsigned long btnMillis = 0; //clock value to be stored at the time milli() is called

//Fade a led without delaying the rest of the code
//START
unsigned long fadeMillis = 0;
boolean fadeUp = true;
int fadeValue = 0;
void analogFade()
{
  if (millis() - fadeMillis >= 2)
  {
    fadeMillis = millis();

    if (fadeUp == true)
    {
      if (fadeValue < 255)
      {
        fadeValue++;
      }
      else
      {
        fadeUp = false;
        fadeValue--;
      }
    }
    else
    {
      if (fadeValue > 0)
      {
        fadeValue--;
      }
      else
      {
        fadeUp = true;
        fadeValue++;
      }
    }
    analogWrite(fled1, fadeValue);
    analogWrite(fled2, fadeValue);
  }
}
//STOP

   void frontflash()
   {

 unsigned long currentMillis = millis();

  if(currentMillis - previousMillis > interval) {
    // save the last time you blinked the LED 
    previousMillis = currentMillis;   

    // if the LED is off turn it on and vice-versa:
    if (ledState == LOW)
      ledState = HIGH;
    else
      ledState = LOW;

    // set the LED with the ledState of the variable:
    digitalWrite(led1, ledState);
    digitalWrite(led2, ledState);

  if (interval == 59)
     interval = 100;
  else if (interval == 100)
     interval = 61;
  else if (interval == 61)
     interval = 800;
  else
     interval = 59; 
  }
   }
   
   void flashlight()
   {
     
  analogFade();

  frontflash();
   }



int PPMin1 = 2;  // connect the desired channel (PPM signal) from your RC receiver to analog pin2 on Arduino. 

    int RCpuls1;  // store RC signal pulse length
    int adj_puls1;

    void setup()
    {
      Serial.begin(9600); //serial library start
     
      pinMode(PPMin1, INPUT); //Pin 2 as input
      pinMode(led1, OUTPUT);
      pinMode(led2, OUTPUT);

    }


    void loop()
    { 
        RCpuls1 = pulseIn(PPMin1, HIGH);      //read RC channel 1
        adj_puls1 = map(RCpuls1, 1000, 2000, 2000, 1000);  // my observed RC values are between 1000 and 2000.. these might need to be changed, depending on your RC system.

       
        //light1
        if (adj_puls1 > 1700) {             
        //write here what to do
        flashlight();
      }
        else
     
      Serial.print ("puls1: ");
      Serial.print (RCpuls1);  // if you turn on your serial monitor you can see the readings.
      Serial.print ("       ");
      Serial.print ("adjusted:  ");
      Serial.print (adj_puls1);
      Serial.println ("  ");
     
    }

vorlage für das ganze ist dies hier: Arduino RC car - adafruit industries

So, Probleme:

  1. Wozu brauch man 4 stellen bei map? die ersten beiden sind die range, also von bis und die beiden dahinter?
  2. es funktioniert soweit recht gut, aber das analogfade und das frontflash wird vieeel zu langsam ausgeführt. wieso? und wie kann ich das lösen?

Daniel_N:
So, Probleme:

  1. Wozu brauch man 4 stellen bei map? die ersten beiden sind die range, also von bis und die beiden dahinter?
  2. es funktioniert soweit recht gut, aber das analogfade und das frontflash wird vieeel zu langsam ausgeführt. wieso? und wie kann ich das lösen?

zielWert = map(quellWert, quellRangeMin, quellRangeMax, zielRangeMin, zielRangeMax);

du hast einen QuellWert und der liegt irgendwo innerhalb der QuellRange, die du definierst. Du sagst map dann in welche neue Range er den Wert transformieren soll und das tut er dann.
map (50, 1, 100, 1, 10) macht folgendes.

Er schaut wo zwischen 1 und 100 die 50 liegt. Sie liegt in der Mitte (also bei 50%). Nun sucht er zwischen 1 und 10, wo die Mitte liegt und das ist dann der Wert, den map zurückgibt. Oder als Formel ausgedrückt: 50/(100-1) * (10-1).

Zu deinem 2. Problem.
Dein Fade erhöht den Wert bei jedem Durchlauf um 1 (bis zum Maximum von 255). Ein Durchlauf kommt alle 2 Millisekunden (dafür hast du die Abfrage mit den fadeMillis). Daher dauert der Fade 500ms.
Wenn dir das zu lang ist, dann musst du es anders lösen. Ich würde es aber komplett anders machen. Ich würde den Zeitraum definieren, den die Led brauchen darf, bis sie vollständig hell ist. Und den würde ich dann dazu nutzen, um zu errechnen, wie hoch der Fadevalue sein muss.
Etwa so:

const unsigned long fadeTime = 200; //200ms

analogFade(){
  static unsigned long fadeStartMillis = 0;
  static boolean fadeUp = true;

  if (fadeStartMillis == 0) {
    fadeStartMillis = millis();  //der Fade beginnt
  } else {
    unsigned long actualMillis = millis();
    if (fadeStartMillis + fadeTime > actualMillis) {
      fadeStartMillis = 0;   //der Fade ist fertig, jetzt umkehren und neu anfangen
      fadeUp != fadeUp;
    } else {
      int fadeDuration = actualMillis - fadeStartMillis;
      int fadeValue = 0;
      if (fadeUp) {
        fadeValue = map(fadeDuration, 0, fadeTime, 0, 255);
      } else {
        fadeValue = map(fadeDuration, fadeTime, 0, 0, 255);
      }
      analogWrite(fled1, fadeValue);
      analogWrite(fled2, fadeValue);      
    }
  }
}

Ist jetzt einfach mal schnell hingeschrieben. Ich nutze kein festes Intervall sondern ich schaue in jedem Loop nach, wieviele Millis seit Beginn des Fadevorgangs vergangen sind und berechne die FadeValue passend zum aktuellen Zeitpunkt. Das mache ich dann einfach mit Map. Das eine mal anschwellend und das andere mal abschwellend (einfach in Map eins der Wertepaare vertauschen). Ob der Code kompiliert weiß ich grad nicht, habs direkt ins Forum getippt. Wenn dann fehlt ne Klammer oder sowas. Aber als Orientierung und zum Verstehen des Algorithmus sollte es reichen.

Der Vorteil dieser Methode: Man kann jede beliebige FadeDuration realisieren.

Normalerweise ist neues Problem - neue Tread

Daniel_N:
So, Probleme:

  1. Wozu brauch man 4 stellen bei map? die ersten beiden sind die range, also von bis und die beiden dahinter?
  2. es funktioniert soweit recht gut, aber das analogfade und das frontflash wird vieeel zu langsam ausgeführt. wieso? und wie kann ich das lösen?

So und jetzt die Antworten:
Hier eine Referenz: Arduino - Home

  1. Map mapt einen Wert im Eingangsbereich in den Ausgangsbereich um. Beispiel:
    risultat = map (Wert;100, 200, 0, 20);
    De Bereich 100 bis 200 wird in 0 bis 20 ungerechnet; also ist zB Wert=150 ist risultat =10.
    http://arduino.cc/en/Reference/Map

  2. also muß ich dennoch den Kode lesen :wink: :wink:
    pulseIn() blockiert den Arduino gleich wie delay(); deshalb wartet er dort bis er den Puls gemessen hat.

Statt "adj_puls1 = map(RCpuls1, 1000, 2000, 2000, 1000); "
ist "adj_puls1= 3000-RCpuls1;" einfacher.
Statt
"if (ledState == LOW)
ledState = HIGH;
else
ledState = LOW;"
einfach
"ledState = 1-ledState;"

Grüße Uwe

Sry, dachte, da es auf dem "alten" Code aufbaut bleibe ich mal in dem Topic :confused:

Ein fade dauert aktuell geschlagene 16Sek (ca Angabe).
Vorgabe ist das: stock Mustang tail lights - YouTube (Blinker bzw Warnblinker)

ich probier mal den Code von TeloxNox aus und berichte dann.

Wieso aber wird der Fade verzögert, der Blitzer aber nicht?
Die Reference bin ich übrigens immer am durchforsten wenn ich nicht weiter weiss. und google :wink:

Hallo Daniel_N
Ich weiß nicht welche Frequenz das PPM-Signal hat; wenn es von einer Fernsteuerung ist, dann hat es 50 Hz und eine HIGH Impuls-Zeit von 1 bis 2mSek und Low-Zeit von 18 bis 19 mSek. Das heißt, daß ein pulsIn() bis zu 20mSek wartet bis es den HIGH Impuls mißt.
Der Fade hätte eine Wartezeit von 2mSeK und von 0 bis 255 und zurück bräuchte es ca 1 Sek. Durch die pulsIn() Funktion hast Du eine Zeitverzögerung um den Fakto 15 ca (laut Deinen Schätzungen)
Das Blink hat zeiten von 59,61,100 und 800 mSek da sind 79, 61,120 und 820 mSek keine großen Unterschiede die man bemerken könnte.

Grüße Uwe

Das erklärt natürlich die extreme Verzögerung.
Der echte Mustang braucht übrigens für einmal blinken 750mSek.

Den frontflash (Doppelblitzer) kann ich ja anpassen indem ich die Werte um 20 runter setz, das funktioniert auch super.

Aber für den "Warnblinker" analogFade will mir nichts einfallen um das delay durch den pulsein zu verhindern :frowning:

Gibt es eine gute Alternative zum PulseIn? Ich möchte am Ende einfach nur 3 Schaltzustände haben:
< 1200mSek für eine Lichtsequenz
1400 - 1600mSek für aus

1800mSek für eine andere Lichtsequenz

Am wichtigsten ist hierbei die > 1800mSek-Sequenz, da diese später den fade beinhaltet, die 1200er hat nur "lampe an".

Ich hab per google was von wegen timings auslesen gelesen, bin aber absolut nicht durchgestiegen und es war wohl auch kein "arduino C"

//EDIT:
Ganz vergessen, wollte ich schon vor ein paar Posts schreiben, da ich nicht weiss ob es wichtig ist.
Mein Arduino ist ein Pro Mini 328 - 5V/16MHz

Daniel_N
Die Alternative zu pulsIn() sind: den Eingang dauernd abzufragen oder Interrupt.
Einfach vor Aufruf der Fade-Schleife schauen welchen Zustand der Eingang hat und mit millis() die Länge bestimmen. (ziemlich ungenau)
Die Alternative ist es das Fernstuersignal auf einen Interrupteingang ( Pin 2 oder 3) geben und und in der Interruptroutine die millis in eine Variable speichern. (ein bißcen kompliziert)
Unter Umständen mußt Du um Zeit zu sparen digitalRead bzw digitalWrite durch direkte Portprogrammierung ersetzen.
http://arduino.cc/en/Reference/AttachInterrupt
http://arduino.cc/en/Reference/Interrupts
http://www.arduino.cc/playground/Code/Interrupts

http://www.arduino.cc/playground/Learning/PortManipulation

Grüße Uwe

Daniel_N:
Aber für den "Warnblinker" analogFade will mir nichts einfallen um das delay durch den pulsein zu verhindern :frowning:

Wenn du mit dem Algorithmus fadest, den ich dir aufgeschrieben hab, dann funktioniert es auch mit pulseIn korrekt. Die Zeiten bleiben immer gleich (leicht schwankend, aber solange der Arduino nicht irgendwo ständig 100ms hängen bleibt, fällt das nicht auf). Das einzige, was dir passieren kann, ist dass der Fade "ruckelt". Also dass man dann sieht, wie die Helligkeit stufenweise rauf und runter geht.

telos dein fade funktioniert bei mir irgendwie überhaupt nicht. :~
Er spuckt aber auch keinen Fehler beim compilieren aus.

aktueller code (den ich vllt mal aufräumen sollte):

// Variables will change:
int ledState = LOW;             // ledState used to set the LED
long previousMillis = 0;        // will store last time LED was updated

// the follow variables is a long because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
int interval = 0;           // interval at which to blink (milliseconds)

int brightness = 10;    // how bright the LED is

#define led1 3
#define led2 5
#define led3 6
#define led4 9
#define fled1 10 //Led on digital pin 10
#define fled2 11 //Led on digital pin 11

unsigned long btnMillis = 0; //clock value to be stored at the time milli() is called

//Fade a led without delaying the rest of the code
//START
const unsigned long fadeTime = 375; //375ms

void analogFade(){
  static unsigned long fadeStartMillis = 0;
  static boolean fadeUp = true;

  if (fadeStartMillis == 0) {
    fadeStartMillis = millis();  //der Fade beginnt
  } else {
    unsigned long actualMillis = millis();
    if (fadeStartMillis + fadeTime > actualMillis) {
      fadeStartMillis = 0;   //der Fade ist fertig, jetzt umkehren und neu anfangen
      fadeUp != fadeUp;
    } else {
      int fadeDuration = actualMillis - fadeStartMillis;
      int fadeValue = 0;
      if (fadeUp) {
        fadeValue = map(fadeDuration, 0, fadeTime, 0, 255);
      } else {
        fadeValue = map(fadeDuration, fadeTime, 0, 0, 255);
      }
      analogWrite(fled1, fadeValue);
      analogWrite(fled2, fadeValue);      
    }
  }
}
//STOP

   void normallight()
   {
      analogWrite(6, brightness);
      analogWrite(9, brightness);
      
   }

  void frontflash()
   {

 unsigned long currentMillis = millis();

  if(currentMillis - previousMillis > interval) {
    // save the last time you blinked the LED 
    previousMillis = currentMillis;   

    // if the LED is off turn it on and vice-versa:
    ledState = 1-ledState;

    // set the LED with the ledState of the variable:
    digitalWrite(led1, ledState);
    digitalWrite(led2, ledState);

  if (interval == 39)
     interval = 80;
  else if (interval == 80)
     interval = 41;
  else if (interval == 41)
     interval = 780;
  else
     interval = 39; 
  }
   }
   
   void flashlight()
   {
     
  analogFade();

  frontflash();
  
  normallight();
   }



int PPMin1 = 2;  // connect the desired channel (PPM signal) from your RC receiver to analog pin2 on Arduino. 

    int RCpuls1;  // store RC signal pulse length
    int adj_puls1;

void setup()
{
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
}


    void loop()
    { 
        RCpuls1 = pulseIn(PPMin1, HIGH);      //read RC channel 1
        adj_puls1= 3000-RCpuls1;  // my observed RC values are between 1000 and 2000.. these might need to be changed, depending on your RC system.

       
        //light1
        if (adj_puls1 > 1700) {             
        //write here what to do
        flashlight();
      }
        else
        flashlight();
    }

if (fadeStartMillis + fadeTime > actualMillis) {

da ist das GrößerZeichen falsch

es muss
if (fadeStartMillis + fadeTime < actualMillis) {
sein.

Sind halt dumme Fehler, die passieren, wenn man das spät abends mal noch schnell runtertippt =).

Die vorherige Version führt dazu, dass fadeStartMillis jedes mal auf 0 gesetzt wird und somit beginnt der fade immer von vorn.
Man bewegt sich sozusagen immer nur zwischen init und reset und der eigentliche Fade wird nie ausgeführt.

Jetzt hab ich auf den LEDs ein dauerleuchten.

Sry das ich wegen jedem schnipsel nachfrag, aber durch den code steig ich nich so durch wie durch den rest :confused:

uwefed:
...
Die Alternative zu pulsIn() sind: den Eingang dauernd abzufragen oder Interrupt.
Einfach vor Aufruf der Fade-Schleife schauen welchen Zustand der Eingang hat und mit millis() die Länge bestimmen. (ziemlich ungenau)
...

wie ungenau ist das denn?
mir reicht es ja schon wenn Msek unter 1200 bzw über 1800 ausgegeben werden, je nachdem wie der Schalter an der funke gelegt ist.
Die signale wären wie schon geschrieben 1000, 1500 bzw 2000

Pack mal ins setup() noch Serial.begin(9600); mit rein.
Und dann analogFade mit Debugausgaben füllen (ich mach das mal hier für dich)

void analogFade(){
  static unsigned long fadeStartMillis = 0;
  static boolean fadeUp = true;

  Serial.print("FadeStartMilis: ");
  Serial.println(fadeStartMillis);
  Serial.print("fadeUp: ");
  Serial.println(fadeUp);

  if (fadeStartMillis == 0) {
    Serial.println("Begin fade");
    fadeStartMillis = millis();  //der Fade beginnt
  } else {
    unsigned long actualMillis = millis();
    if (fadeStartMillis + fadeTime < actualMillis) {
      Serial.println("Reset fade");
      fadeStartMillis = 0;   //der Fade ist fertig, jetzt umkehren und neu anfangen
      fadeUp != fadeUp;
    } else {
      int fadeDuration = actualMillis - fadeStartMillis;
      int fadeValue = 0;
      if (fadeUp) {
        fadeValue = map(fadeDuration, 0, fadeTime, 0, 255);
      } else {
        fadeValue = map(fadeDuration, fadeTime, 0, 0, 255);
      }
      Serial.print("FadeValue: ");
      Serial.println(fadeValue);
      analogWrite(fled1, fadeValue);
      analogWrite(fled2, fadeValue);      
    }
  }
}

Damit müsstest du dann sehen können, woran es klemmt.
Müsste etwa so aussehen:

FadeStartMillis: 0
fadeUp: 1
BeginFade
FadeStartMillis: 100
fadeUp: 1
FadeValue: 3
FadeStartMillis: 100
fadeUp: 1
FadeValue: 6
FadeStartMillis: 100
fadeUp: 1
FadeValue: 7
FadeStartMillis: 100
fadeUp: 1
FadeValue: 10
FadeStartMillis: 100
fadeUp: 1
FadeValue: 15
...
FadeStartMillis: 100
fadeUp: 1
FadeValue: 255
ResetFade
FadeStartMillis: 0
fadeUp: 0
BeginFade
FadeStartMillis: 480
fadeUp: 0
u.s.w.

Wenn irgendwas nicht auftaucht oder sich gewisse Werte nicht ändern, dann liegt da irgendwo der Fehler. Ich müssts selbst auch erstmal debuggen, du kannst das aber einfacher als ich.
Achtung, das wird extrem spammig. Am besten 5sec laufen lassen, stecker ziehen und dann den SerialMonitor anschauen.

ansich funktionierts jetzt, aber extram abgehakt und zu schnell, wobei man das zu schnelle ja noch mit dem interval lösen könnte.
ich muss mich wohl mal mit den interrupts beschäftigen.
achja, serial monitor:

FadeStartMilis: 0
fadeUp: 
Begin fade
FadeStartMilis: 249
fadeUp: 
FadeValue: 22
FadeStartMilis: 249
fadeUp: 
FadeValue: 55
FadeStartMilis: 249
fadeUp: 
FadeValue: 89
FadeStartMilis: 249
fadeUp: 
FadeValue: 122
FadeStartMilis: 249
fadeUp: 
FadeValue: 156
FadeStartMilis: 249
fadeUp: 
FadeValue: 190
FadeStartMilis: 249
fadeUp: 
FadeValue: 223
FadeStartMilis: 249
fadeUp: 
Reset fade
FadeStartMilis: 0
fadeUp: 
Begin fade
FadeStartMilis: 685
fadeUp: 
FadeValue: 22
FadeStartMilis: 685
fadeUp: 
FadeValue: 55
FadeStartMilis: 685
fadeUp: 
FadeValue: 89
FadeStartMilis: 685
fadeUp: 
FadeValue: 122
FadeStartMilis: 685
fadeUp: 
FadeValue: 156
FadeStartMilis: 685
fadeUp: 
FadeValue: 189
FadeStartMilis: 685
fadeUp: 
FadeValue: 223
FadeStartMilis: 685
fadeUp: 
Reset fade
FadeStartMilis: 0
fadeUp: 
Begin fade
FadeStartMilis: 1375
fadeUp: 
FadeValue: 23
FadeStartMilis: 1375
fadeUp: 
FadeValue: 57
FadeStartMilis: 1375
fadeUp: 
FadeValue: 91
FadeStartMilis: 1375
fadeUp: 
FadeValue: 125
FadeStartMilis: 1375
fadeUp: 
FadeValue: 159
FadeStartMilis: 1375
fadeUp: 
FadeValue: 194
FadeStartMilis: 1375
fadeUp: 
FadeValue: 229
FadeStartMilis: 1375
fadeUp: 
Reset fade

//EDIT:

hier sieht man mal warum ich mir das ganze antu :wink: :

Also wenn das Video dein Projekt zeigt, dann sieht der Fade doch richtig aus oder was passt daran nicht?
Wenn der Fade zu schnell ist, dann musst du die FadeTime erhöhen. Wenns abgehackt ist, dann liegt das daran, dass das Programm zu lang unterbrochen wird. Man sieht ja an der Ausgabe, dass du etwa 6 Stufen für den Fade hast.

Was mir noch aufgefallen ist. Mein Code schafft es so gut wie nie ganz auf 0 oder ganz auf 255 beim Fade (weil bei dir eben zu viel Pause dazwischen ist). Da müsste man noch in Init und Reset den Wert entsprechend setzen, dann würde das auch wieder passen.
Aber wenn ichs recht überlege. Du hast eine FadeTime von 375. Die 6 Stufen heißen alle 60ms ein anderer Wert. Macht ca. 20 Änderungen pro Sekunde also quasi 20fps. Ein Kinofilm hat auch nur 24fps und wirkt fürs Auge flüssig.

Das Video beinhaltet auch nur den Code ohne die RC-Fernsteuerung.
Aktuell ist es so:

Aber ich glaube ich werde das anders machen.
Eine einfache und hoffentlich funktionierende Idee ist:
Das ganze auf 2 Servosignale aufteilen und mit Interrupt einfach nur gucken ob es high oder low ist.
So habe ich hoffentlich keine PulseIn-Verzögerung. 2 Signale übbrigens, weil ich 2 verschiedene Beleuchtungen haben möchte.

Da dauert wohl der pulseIn() arg lange. Das sind nicht nur 20ms.

Entweder muss man den pulseIn() so ändern, dass er kein Delay mehr verursacht oder man löst es über Interrupt. Du könntest z.B. ein PWM Signal erzeugen, das du dir auf Pin 2 oder Pin 3 legst und triggerst damit dann den Fade (und auch den Flash u.s.w.).
Allerdings müsstest du dann die PWM Frequenz verändern, wodurch sich je nach dem neue Probleme ergeben können (man muss dann wissen, welcher Taktgeber verändert ist und darauf ggf. entsprechend reagieren). Aber das wäre durchaus ne Lösung.
100hz pwm erzeugen und auf Pin2 legen. Dort dann per interrupt flash und fade ausführen.

Sauberer wäre aber eine Lösung, bei der pulseIn() kein delay mehr erzeugt.