next topic »

[Reply #15 on:]

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

[Reply #16 on:]

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

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.

[Reply #17 on:]

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):

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)

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

[Reply #18 on:]

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.

[Reply #19 on:]

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 :/

...
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

[Reply #20 on:]

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.

[Reply #21 on:]

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:

Code:

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 :

[Reply #22 on:]

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.

[Reply #23 on:]

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.

[Reply #24 on:]

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.