Hey ;)

Ich plane eine Lichsteuerung auf Arduino Basis für die 80cm Nuri Klasse zu entwickeln.

Kurz vorweg das Anliegen dieses Threats : Da die Entwicklungkosten für eine solche Steuerung (im Verhältnis zu dem was das entgültige Projekt kosten würde) relativ hoch sind wollte ich Frage ob der ein oder andere Interesse an einer kompletten Lichtsteuerung für solch einen Nuri hätte.
Würden sich ein paar Leute finden, die Interesse hätten könnte ich einseits die Entwicklungskosten minimieren und andererseite wärs natürlich auch ein super Vereinsprojekt ;)

Jetzt zurück zum Projekt :

Welcher Flieger und welche Leuchten?

Bei uns würde die Steuerung auf einem Hacker SkyCarvan eingesetzt werden.
Die Stereurung soll dann 4 RGB LED Strips ansteuern. Die Strips werden im Flieger wie an der Stelle eines Holmes in die Fläche eingelassen. Jeweils rechts und links dann einmal nach vorne und hinten zeigend. Durch das Einlassen der Strips leuchtet dann das ganze EPP und man hat 4 unterschiedlich ansterbare Bereiche in der Fläche.
Natürlich könnte die Steuerung auch auf jedem anderen Flieger untergebracht werden ;)

Was für hardware wird eingesetzt?

Die Entwicklung würde auf einem Arduino Duemilanove statt finden und das fertige Projekt wird dann auf ein (hardwaregleichen) Arduino Pro Mini übertragen. Neben dem 18x33mm kleinen Arduino Pro Mini werden nur noch ein paar Transistoren benötigt. Der Modul ist also so klein, dass es auf/in jedem Flieger dieser Größe unterzubringen ist.

Was soll die Steuerung können?

Die Steuerung kann alles was der programmieren kann ;D
Spaß beiseite : Also Die Steuerung soll 1 (oder vielleicht auch 2) RC Signale aus dem Empfänger auswerten können. je nachdem ob der Kanal dann über einen Drehregler oder 3-Stufen-Schalter etc. betrieben wird können unterschiedlich viele Beleuchtungsprogramme einprogrammiert werden (Bei einem 3-Stufen-Schalter logischerweise nur 3, bei einem Proportionalkanal dann so viele wie man möchte).

Die Programme können dann im Prinzip fast alles.
Ein paar Beispiele :
- Stroboskopblinken aller Strips (auch in unterschiedlichen Farben möglich)
- Durchfaden (Übergänge) zwischen allen möglichen Farben
- Wildes geflacker mit zufälligen Farben
- Simple Positionsbeleuchtung
- usw ;)

Es ist also wirklich fast alles möglich - nur muss der Pilot damit ja auch noch klarkommen


Also, ich hoffe ihr könnt euch ein grobes Bild von meinen Vorstellungen für das Projekt machen!


Preislich kann ich nur ganz grobe Angaben machen, aber ich denke mal ich könnte die Steuerung inkl. RGB Strips für etwa 50 - 60€ anbieten.

Also, wenn ihr Interesse an soetwas hättet, dann meldet euch hier eifach mal ;)

Wenn ihr euch meldet ist das nichts bindendes, ich weiß ja selbst noch nicht einmal ob es dann verwirklicht wird und auf welche Probleme man unterwegs stolpert ;)

Zum Nachfliegen beim Vereinsfest wird es leider denke ich mal nichts mehr, da ich auch noch eine Woche auf Stufenfahrt mit der Schule bin ;)


So, jetzt hab ich so viel geschrieben, jetzt seid ihr dran :D

Hallo Yannik,

hört sich sehr interessant an was du da planst. Wenn es zeitlich bei mir klappt würde ich da gerne mit machen. Evtl. kann ich ein bisschen bei der Programmierung helfen. Wobei ich schon sehr lange kein C mehr programmiert habe . In letzter Zeit habe ich nur Code-Generatoren dafür geschrieben.

Viele Grüße,

Stefan

So, es gibt Neuigkeiten!

Heute ist der Arduino Duemilanove gekommen - leider noch nicht die RGB Strips und sonstigen Bauteile.

Aber ein paar Sachen konnte ich schon testen.

Die Software PWM Library ( http://code.google.com/p/rogue-code/wiki...ryDocumentation ) zum dimmen der LEDs funktioniert schonmal!
Es ist leider kein Ausgleich für die unlinearität von LED Helligkeiten vorhanden (eine LED mit 50% angesteuert ist nicht 50% hell, sondern geschätze 75% - da das menschliche Auge diese Helligkeit nicht linear wahrnimmt). Das wäre aber nur entscheident, wenn wir später exakte Mischfarben erstellen wollen.. Wenn es nur um bunt geht ist eine leichte abweichung der Farben ja nicht so entscheident.

Dann habe ich den pulseIn Befehl getestet um das RC-Signal einzulesen. Was soll ich sagen - einfach perfekt. Es kommt ohne irgendeine Glättung oder sonstwas aus. Ich kriege bei -150% bis 150% Servoweg Werte von ca. 900µs bis 2100µs zurück, was auch herauskommen sollte ;)

Leider scheinen die beiden Befehle bzw. die Library auf dem selben Timer oder soetwas zurückzugreifen. War erst verwirrend, stellt aber schlussendlich kein großes Problem dar.

Die ausgelesenen Werte vescheiben sich einfach auf den Bereich zwischen 600 und 1400µs.. Keine Ahnung, warum das genau passiert, aber es scheint trotzdem zu funktionieren ;)

Dann habe ich ein mini-programm geschrieben, wass die Helligkeit der LED in 4 Stufen, je nach Stickposition, dimmt.

Hier ein kleines Video dazu (Bitte entschuldigt die Qualität.. Ist nur zur Info kurz mitm handy aufgenommen) : http://youtu.be/w2WmQKmz9MU

Für Leute die eventuell was damit anfangen können, hier der Code :

Zitat

---

#include <SoftPWM.h>

int rcpin = 12; //Pindefinitionen
int rcValue = 0;

void setup()
{
Serial.begin(9600); //Nur zur Kommunikation mit dem PC
SoftPWMBegin(); //Initialisieren des SoftwarePWM

SoftPWMSet(13, 0);

SoftPWMSetFadeTime(13,0,0);

pinMode(12,INPUT);
}

void loop()
{
rcValue = pulseIn(rcpin,HIGH); //Einlesen des RC-Signals
Serial.println(rcValue);
if(rcValue < 800) //Aufteilung in 4 Stufen und jeweils dimmen
{
SoftPWMSet(13,0);
}
else if(rcValue < 1000)
{
SoftPWMSetPercent(13,5);
}
else if(rcValue < 1200)
{
SoftPWMSetPercent(13,30);
}
else
{
SoftPWMSetPercent(13,100);
}
delay(50); //50ms pause

}

---

Habe den Code jetzt nocheinmal optimiert.

Das RCSignal wird jetzt nicht mehr über die Funktion PulseIn gemessen, sondern über einen Interrupt.

Die steigende Flanke des PWM Signals des Empfängers löst einen Interrupt aus. Dieser speichert den aktuellen Zeitwert auf 1µs genau ab. Die fallende Flanke löst wieder einen Interrupt aus, der wieder den aktuellen Zeitwert abspeichert. Die Differenz dieser beiden Werte ist dann die Länge des Pulses. Diese möglichkeit beißt sich auch nicht mit dem SoftPWM der LEDs. Ich bekomme jetz also exakte Werte zwischen 900 und 2100µs.

Ein weiterer Vorteil ist, dass so jeder(!) Puls des Empfängers gelesen wird. Ändert man also während eines laufenden Programmes (Welche später grade bei Fadeprogrammen einige Sekunden lang sein können) das Signal, so kann direkt das neue Programm gestartet werden, ohne das das alte erst zu Ende laufen muss (Wäre bei der Methode mit PulseIn der Fall gewesen).
EDIT : Das ist doch leider nicht so ganz richtig.. Hab gedacht, ich könnte aus dem Interrupt die main Loop neu starten, aber das scheint nicht zu gehn - Schade. Damit ist eigentlich der Hauptvorteil wieder zu nicht gemacht. Mal sehen, ob ich schlussendlich den Interrupt oder doch den PulseIn befehl verwenden werde. Schlussendlich ists eigentlich egal - hat beides Vor- und Nachteile.

Einziger Nachteil ist natürlich die erhöhte Prozessorbelastung, da jeder Puls gemessen wird. Bei einem solchen Proejekt kommen wir aber um Längen nicht an die Leistungsgrenze des ATMega328, von daher ist das egal ;)

Zitat

---

#include <SoftPWM.h>

int time = 0;
int oldtime = 0;
int rcValue = 0;

void setup()
{
attachInterrupt(0, getRc, RISING);
Serial.begin(9600);

SoftPWMBegin();
SoftPWMSet(13, 0);
SoftPWMSetFadeTime(13,0,0);
}

void loop()
{
if(rcValue < 1200)
{
SoftPWMSet(13,0);
}
else if(rcValue < 1500)
{
SoftPWMSetPercent(13,5);
}
else if(rcValue < 1800)
{
SoftPWMSetPercent(13,30);
}
else
{
SoftPWMSetPercent(13,100);
}
}

void getRc()
{
oldtime = micros();
attachInterrupt(0, endGetRc, FALLING);
}

void endGetRc()
{
time = micros();
rcValue = time - oldtime;
attachInterrupt(0, getRc, RISING);
}

---

So, heute sind die letzten Teile gekommen!

Und ich habe fleißig zusammengetüddelt und programmiert ;)

Nach ein paar anfänglichen Schwierigkeiten, die unter anderem durch Montagsmodelle der Transistor-Array-ICs und der chinesischen Verwechslung von Grün und Blau bedingten waren, hat es dann jetzt doch schließlich geklappt!

Erstaunlicherweise bin ich auf keine größeren Probleme gestoßen, sodass ich euch schonmal Version 1 vorstellen kann!

Das ganze kommt mit sehr wenigen Bauteilen aus : dem Arduino Board, den RGB Strips und zwei ULN2003A Darliton Transistor Arrays..

Hier das Video, wo ich einmal alle drei bis jetz exitierenden Programme zeige. Ich suche noch Ideen für ein viertes Programm, oder Anregungen zur Veränderung/Verbesserung der ersten drei!

www.youtube.com/watch?v=UI_zjUlX_I0

Hoffe auf Freedback von euch ;)

So wies aussieht wird der erste Prototyp beim Nachtfliegen doch fertig sein ;)

Das sieht ja schon richtig gut aus

Was hast du denn bis jetzt programmiert? Nutzt du das PWM Signal des Empfängers zum Ändern des laufenden Programms? Was für Lichteffekte möchtest du noch relisieren?

~Stefan

Das ist ja eine super Arbeit, Yannik!

Da lässt sich so etwas:https://www.youtube.com/watch?v=wocRkNmu1v8&feature=relmfu
ja ohne Probleme realisieren!

Bin gespannt wie es weiter geht und was beim Nachtfliegen zu sehen sein wird.

Weiter so !!!

Gruß

Möglich ist alles ;)

ohne zusätzliche ICs kann ich allerdings max. 4 RGB LEDs ansteuern + noch 5 normale LED (im Notfall kann hier auch noch eine RGB LED angehängt werden.

Mit zusätzlichen ICs wie z.B. dem TLC5940 (super Teil, aber schwer zu bekommen) könnte man soweit ich weiß 64 (natürlich nicht mit einem TLC5940, aber man kann mehrere hintereinander hängen) weitere RGB LEDs ansteuern ;)

Mit anderen Transistorstufen kann man auch etwas anschließen, was mehr als 500mA verbraucht..

Der Rest ist dann Hirnschmalz des Programmierers :D

So, es gibt wieder Neuigkeiten!

Also erstmal habe ich neu ein viertes Programm hinzugefügt. Es ist eine Art lauflicht, was halt im Kreis wandert mit zufälligen Farben. Diesmal aber nicht komplett zufällig sondern zufällig aus 10 vorher einprogrammierten Farben.

Desweiteren habe ich angefangen die Schaltung fürs Modell zu bauen. Am Anhang dazu die ersten Bilder!

So, es gibt Neues

Ohne Worte hier das Video und ein paar Bilder ;)

http://youtu.be/fN5hY-XNACY Qualität ist leider wie immer eher bescheiden, da sich die LEDs schlecht filmen lassen.. bei Nachtfliegen gibts dann das Original zu gucken ;)

Leider ist die Qualität der LED Strips bescheiden.. Es haben sich jetzt schon an einigen Stellen ein paar LEDs verabschiedet :(
Original sind die Strips mit einem Silikon zum Spritzwasserschutz überzogen.. Da das aber extrem schwer ist haben wir das abgezogen. Anscheinent hat das den Lötkontakten der LEDs nicht so gut getan..

Um das ganze noch ein bisschen zu verbessern..

Was würdet ihr besser finden :

1. 1 RC Kanal und dann halt mit nem Drehregler die Programme einstellen

oder

2. 2 RC Kanäle wo einer nur das Licht aktiviert/deaktiviert und der zweite ein Momentschalter, der immer ein Programm weiter schaltet

Ganz klar !!!

Zitat

---

2. 2 RC Kanäle wo einer nur das Licht aktiviert/deaktiviert und der zweite ein Momentschalter, der immer ein Programm weiter schaltet

---

Okay, werde ich mich in den nächsten Tagen mal dransetzen ;)

Ist wie gesagt meine Meinung.
Denn die Bedienbarkeit ist mit der Tippfunktion etwas komfortabler, wärend des Fluges.

Aber gute Arbeit!

So, es ist mal wieder Zeit für ein Update ;)

Habe mich mal drangesetzt und siehe da, nun klappt die Steuerung über zwei RC Kanäle!

Der eine Schalter dient nur zur allgemeinen Aktivierung.. Also nur wenn der Aktiviert ist leuchtet überhaupt irgendwas und die Programme können durchgeschaltet werden.
Der zweite Schalter ist dann der Momentschalter mit dem man ein Programm weiter schalten kann.

Hier dann auch nochmal der Code für die, die was damit anfangen können ;)

/*
  SkyCarver RGB RC Lichtsteuerung V6 (2.7.12)
  By Yannik Wertz
*/
 
#include <SoftPWM.h>
#include <SimpleTimer.h>
 
SimpleTimer timer;
 
#define rechts_oben 8
#define rechts_unten 11
#define links_oben 2
#define links_unten 5
#define rcPin1 A3
#define rcPin2 A2
#define aussen1 A0
#define aussen2 A1
int rcValue = 0;
int counterprog2 = 0;
int counterprog3 = 0;
int oldtime = 0;
int time = 0;
int value = 0;
int counter = 0;
boolean freigegeben = false;
boolean first = true;
 
int randomRot[10] = {255,0,0,255,255,0,255,255,72,148};
int randomGruen[10] = {0,255,0,255,0,255,255,140,209,0};
int randomBlau[10] = {0,0,255,0,255,255,255,140,204,211};
 
void setup()
{
  SoftPWMBegin();
  pinMode(rcPin1,INPUT);
  pinMode(rcPin2,INPUT);
  SoftPWMSetFadeTime(ALL, 0, 0);
  
  PCICR |= (1<<PCIE1);
  PCMSK1 |= (1<<PCINT10);
  MCUCR = (1<<ISC01) | (1<<ISC01);
  
  timer.setTimeout(250, freigabe);
  
  //Initialisierungsleuchten
  setColor(rechts_oben,255,0,0);
  delay(100);
  setColor(rechts_unten,255,0,0);
  delay(100);
  setColor(links_unten,255,0,0);
  delay(100);
  setColor(links_oben,255,0,0);
  delay(100);
  
  setColor(rechts_oben,0,255,0);
  delay(100);
  setColor(rechts_unten,0,255,0);
  delay(100);
  setColor(links_unten,0,255,0);
  delay(100);
  setColor(links_oben,0,255,0);
  delay(100);
  
  setColor(rechts_oben,0,0,255);
  delay(100);
  setColor(rechts_unten,0,0,255);
  delay(100);
  setColor(links_unten,0,0,255);
  delay(100);
  setColor(links_oben,0,0,255);
  delay(400);
  
  for(int a = 0 ; a < 10 ; a++)
  {
    setColor(rechts_oben,255,255,255);
    setColor(rechts_unten,255,255,255);
    setColor(links_unten,255,255,255);
    setColor(links_oben,255,255,255);
    SoftPWMSet(aussen1,255);
    SoftPWMSet(aussen2,255);
    delay(50);
    blank();
    SoftPWMSet(aussen1,0);
    SoftPWMSet(aussen2,0);
    delay(50);    
  }
}
 
void loop()
{
  rcValue = getRC();
  
  
  if(rcValue <= 1000)
  {
    SoftPWMSet(aussen1,0);
    SoftPWMSet(aussen2,0);
    blank(); //Alles dunkel machen
  }
  else
  {
    switch (counter)
    {
      case 0:  
        blank();
        SoftPWMSet(aussen1,255);
        SoftPWMSet(aussen2,255);
       break;
      
      case 1:
        blank();
        SoftPWMSet(aussen1,255);
        SoftPWMSet(aussen2,255);
        prog1(); //Wildes blinken
       break;
      
      case 2:
        SoftPWMSet(aussen1,255);
        SoftPWMSet(aussen2,255);
        prog2(); //Oben grün / rot und unten langsamen faden
       break;
       
      case 3:
        blank();
        SoftPWMSet(aussen1,255);
        SoftPWMSet(aussen2,255);
        prog3(); //Stroboeffekt rot -> grün -> blau 
       break;
       
      case 4:
        blank();
        SoftPWMSet(aussen1,255);
        SoftPWMSet(aussen2,255);
        prog4(); //Umlauf zufälliger Farben
       break;
    }
  }
}
 
void prog1()
{
    for(int a = 2 ; a < 14 ; a++)
    {
       SoftPWMSet(a,random(255)); 
    }
    delay(150);  
}
 
void prog2()
{
  setColor(rechts_oben,0,255,0); //Grün
  setColor(links_oben,255,0,0); //Rot
  
  SoftPWMSetFadeTime(ALL, 1100, 1000);
  
  switch (counterprog2)
  {
    case 0:
      setColor(rechts_unten,255,255,0); //Gelb
      setColor(links_unten,255,255,0);
      delay(1000);
    break;
    case 1:
      setColor(rechts_unten,255,140,0); //Organge
      setColor(links_unten,255,140,0);
      delay(1000);
    break;
    case 2:
      setColor(rechts_unten,0,255,0); //Grün
      setColor(links_unten,0,255,0);
      delay(1000);
    break;
    case 3:
      setColor(rechts_unten,255,255,255); //Weiss
      setColor(links_unten,255,255,255);
      delay(1000);
    break;
    case 4:
      setColor(rechts_unten,72,209,204); //Türkis
      setColor(links_unten,72,209,204);
      delay(1000);
    break;
    case 5:
      setColor(rechts_unten,148,0,211); //Lila
      setColor(links_unten,148,0,211);
      delay(1000);
    break;
    case 6:
      setColor(rechts_unten,255,20,147); //Pink
      setColor(links_unten,255,20,147);
      delay(1000);
    break;
    case 7:
      setColor(rechts_unten, 0,250,154); //komisches Grün
      setColor(links_unten, 0,250,154);
      delay(1000);
    break;
    case 8:
      setColor(rechts_unten,0,0,255); //Blau
      setColor(links_unten,0,0,255);
      delay(1000);
    break;
  } 
  
  if(counterprog2 < 8)
  {
    counterprog2++;
  }
  else
  {
    counterprog2 = 0;
  } 
}
 
void prog3()
{  
  switch(counterprog3)
  {
    case 0:
      for(int a = 0 ; a < 4 ; a++)
      {
        setColor(rechts_oben,255,0,0); //Rot
        setColor(links_oben,255,0,0); 
        setColor(rechts_unten,255,0,0);
        setColor(links_unten,255,0,0);  
        delay(100);  
        blank();  
        delay(100);
      }
     break;
    case 1:
      for(int a = 0 ; a < 4 ; a++)
      {
        setColor(rechts_oben,0,255,0); //Grün
        setColor(links_oben,0,255,0); 
        setColor(rechts_unten,0,255,0);
        setColor(links_unten,0,255,0);
        delay(100);  
        blank();  
        delay(100);
      }  
     break;
    case 2:
      for(int a = 0 ; a < 4 ; a++)
      {
        setColor(rechts_oben,0,0,255); //Blau
        setColor(links_oben,0,0,255); 
        setColor(rechts_unten,0,0,255);
        setColor(links_unten,0,0,255);
        delay(100);  
        blank();  
        delay(100);
      }
     break;
  }
  
  if(counterprog3 < 2)
  {
    counterprog3++;
  }
  else
  {
    counterprog3 = 0;
  } 
}
 
void prog4()
{
  int color = random(9);
  setColor(rechts_oben,randomRot[color],randomGruen[color],randomBlau[color]);
  delay(150);
  blank();
  setColor(rechts_unten,randomRot[color],randomGruen[color],randomBlau[color]);
  delay(150);
  blank();
  setColor(links_unten,randomRot[color],randomGruen[color],randomBlau[color]);
  delay(150);
  blank();
  setColor(links_oben,randomRot[color],randomGruen[color],randomBlau[color]);
  delay(150);
}
 
void setColor(int led, int r, int g, int b)
{
  SoftPWMSet(led,r);
  SoftPWMSet(led+1,g);
  SoftPWMSet(led+2,b);
}
 
void blank()
{
  SoftPWMSetFadeTime(ALL, 0, 0);
  for(int a = 2 ; a < 14 ; a++)
 {
    SoftPWMSet(a,0);
 } 
}
 
int getRC()
{
  return((pulseIn(rcPin1,HIGH)));
}
 
ISR(PCINT1_vect) 
{
  if(first)
  {
    oldtime = micros();
    MCUCR = (1<<ISC01) | (1<<ISC00);
    first = false;
  }
  else
  {
    time = micros();
    value = (time-oldtime);
    MCUCR = (1<<ISC01) | (1<<ISC00);
    first = true; 
    
    if(value >= 1500)
    {
      if(freigegeben == true)
      {
         if(counter <= 3)
         {
           counter++; 
         }
         else
         {
           counter = 0;  
         }
         
      }
      freigegeben = false;       
      timer.run();      
    }
  }
}
 
void freigabe()
{
  freigegeben = true;
  timer.setTimeout(250, freigabe); 
}