Arduino: Stroboskop PWM

[Ecd E. (ecd)]

Hallo,

ein Kumpel und ich bauen gerade an einem naja etwas größerem LED 
Stroboskop mit 8x 100W LED's die Hardware steht im großen und ganzem, 
zum Steuern haben wir uns für ein Arduino entschieden.

Mit dem Programm soll man u.a die Helligkeit der LED und derren 
Blitzgeschwindkeit regeln.
Sprich ein Ausgang wird EIN und AUSGESCHALTEN (Blink-Geschwindkeit) und 
parallel dazu wird der selbige Ausgang mit PWM beschrieben (Helligkeit)
Die Werte für die Helligkeit und Geschwindkeit soll er sich von 2 
Variablen holen, die dann später per Taster inkrementiert bzw. 
dekrementiert werden.

Am Ausgangs Pin des Arduino hängt ein Tranistor der praktisch den 
LED-Treiber steuert (hat ein PWM Eingang)

Als wir mit einer LED angefangen haben um das  ganze zu testen haben wir 
uns dieses Programm zurecht gestrickt, das die Helligkeits und 
geschwindkeits werte von 2 Potis ausliest - das hat auch wunderbar 
funktioniert.
Mit dem neuem Code, ohne Potis, mit Tastern, will das ganze nicht. Wir 
machen da seit einer Woche dran rum un finden unseren Denkfehler nicht.
Villeicht könnt ihr uns helfen :) ?

Altes Programm mit Potis - FUNKTIONIERT:

/* Blink without Delay
 
 Turns on and off a light emitting diode(LED) connected to a digital  
 pin, without using the delay() function.  This means that other code
 can run at the same time without being interrupted by the LED code.
 */

// constants won't change. Used here to
// set pin numbers:
const int ledPin =  11;      // the number of the LED pin

// 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.
long interval;           // interval at which to blink (milliseconds)
int Helligkeit = 0;       // Variable für den ADC Wert vom Freq Poti
long potiFrequenz = 0;    // INPUT Poti Frequenz
int potiHelligkeit = 1;
void setup() {
  // set the digital pin as output:
  pinMode(ledPin, OUTPUT);      
}

void loop()
{
  // here is where you'd put code that needs to be running all the time.

  // check to see if it's time to blink the LED; that is, if the
  // difference between the current time and last time you blinked
  // the LED is bigger than the interval at which you want to
  // blink the LED.
  unsigned long currentMillis = millis();
 interval = analogRead(potiFrequenz);    // Analog Wert lesen
  
  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(ledPin, ledState);
    }
if (ledState == HIGH)
{Helligkeit = analogRead(potiHelligkeit);   // liest den Input Pin
analogWrite(ledPin, Helligkeit / 4);  // analogRead Werte reichen von 0 to 1023, analogWrite Werte von 0 to 255 
}
}

und hier unser neues Programm - funktioniert nicht

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Projekt: 800W LED Stroboskop
// Projektdatum: August 2014       
// Ersteller: J&L
// Software Version 4.9
//
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                           EINGÄNGE
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const int I_freigabe = 2;                             // Freigabe Taster (N.O), an PIN 
const int I_gh = 4;                                  // Geschwindigkeit (1) oder Helligkeits (0)  Wahlschalter (N.O), an PIN 
const int I_remote = 7;                             // Remote Wahlschalter (N.O), an PIN
const int I_inc = 8;                               // Inkrement Taster (N.O), an PIN 
const int I_dec = 10;                              // Inkrement Taster (N.O), an PIN 
const int I_temp = A0;                                // PT 100 Temperatur Sensor über Spannungsteiler an ANALOG PIN 0
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                           VARIABLEN
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int X_freigabe = 0;                     // Freigabe Taster (N.O), an PIN 
int X_gh = 0;                          // Geschwindigkeit (1) oder Helligkeits (0)  Wahlschalter (N.O), an PIN 
int X_remote = 0;                     // Remote Wahlschalter (N.O), an PIN
int X_inc = 0;                       // Inkrement Taster (N.O), an PIN 
int X_dec = 0;                      // Inkrement Taster (N.O), an PIN 
int X_temp = 0;                        // PT 100 Temperatur Sensor über Spannungsteiler an PIN
long X_helligkeit = 1023.0;                 // Helligkeitswert 
long X_geschwindigkeit = 6000.0;           // Geschwindigkeitswert

int X_ledState_1 = 0;            // Speicher aktueller LED Zustand

long X_previousMillis_1 = 0;         // Speicher für Geschwindigkeit in ms


unsigned long X_currentMillis_2 = millis();
unsigned long X_currentMillis_3 = millis();
unsigned long X_currentMillis_4 = millis();
long pause = 200;
long zeitschalter = millis();


// Für Freigabe
int X_freigabestatus = LOW;
int X_freigabepre = LOW;
long time = 0;
long debounce = 200;

int X_handstatus = 0;
int X_remotestatus =0;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                           AUSGÄNGE
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const int O_pwm1 = 3;                // PWM Ausgang Nr 1 an PIN 3
const int O_freigabe = 11;            // Freigabe Ausgang für das Netzteil an PIN 11
const int O_ready = 12;               // LED Ausgang Betriebsbereit an PIN 12
const int O_overtemp = 13;            // LED Ausgang Übertemperatur an PIN 13

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                           SETUP
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() 
{
// EINGÄNGE deklarieren
pinMode(I_freigabe, INPUT);
pinMode(I_gh, INPUT);
pinMode(I_remote, INPUT);
pinMode(I_inc, INPUT);
pinMode(I_dec, INPUT);
pinMode(I_temp, INPUT);

// AUSGÄNGE deklarieren
pinMode(O_pwm1, OUTPUT);
pinMode(O_freigabe, OUTPUT);
pinMode(O_ready, OUTPUT);
pinMode(O_overtemp, OUTPUT);

// SERIELLE SCHNITTSTELLE initialisieren
Serial.begin(9600); // 9600 Baud
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                           MAIN ROUTINE, hier beginnt das eigentliche Programm
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop() 
{
// Eingänge in die Variablen übertragen (PROZESSABILD der EINGÄNGE)
X_freigabe= digitalRead(I_freigabe);
X_gh=       digitalRead(I_gh);
X_remote=   digitalRead(I_remote);
X_inc=      digitalRead(I_inc);
X_dec=      digitalRead(I_dec);
X_temp=     analogRead(I_temp);


/* Status der Variablen zur seriellen Schnittstelle schieben
IST IM MOMENT "AUSGESCHALTEN"
Serial.println ("Remotestatus:");
  Serial.println(X_remotestatus);
Serial.println ("-------");
Serial.println ("Handstatus");
  Serial.println(X_handstatus);
Serial.println ("-------");
Serial.println ("Hellikeit");
  Serial.println(X_helligkeit);
Serial.println ("-------");
Serial.println ("Geschwindkeit");
  Serial.println(X_geschwindigkeit);
Serial.println ("-------");
Serial.println ("O PWm1");
  Serial.println(O_pwm1);
Serial.println ("-------");
delay (2000); // 2s warten

*/



// 00 ---- Sicherheiten und TEMP abfrage


// 01 ---- Freigabe
// Ist X_freigabe HIGH  UND X_temp KLEINER 55GRAD Celsius, dann schalte O_freigabe auf HIGH
// Schalte O_freigabe auf LOW WENN X_temp GRÖSSER 55 GRAD Celsius (vorerst) ODER X_Freigabe ERNEUT HIGH IST

if (X_freigabe == 1 && X_temp <= 55 && X_freigabepre == 0 && millis() - time > debounce)
{
if (X_freigabestatus == 1)
X_freigabestatus = 0;
else
X_freigabestatus = 1;
time = millis();
}
if (X_temp > 55)
{
  X_freigabestatus = 0;
}

digitalWrite(O_freigabe, X_freigabestatus);
X_freigabepre = X_freigabe;

// 02 ---- Remote
// Ist X_remote HIGH ignoriere die Befehle vom Bedienfeld (Außer Freigabe)
// Ist X_remote LOW ignoriere die Befehle von Remote
if (X_freigabestatus == HIGH)
{ 
  if ((X_remote == HIGH) && (X_freigabestatus == 1))
{ 
 // 03 ---- REMOTE und WEBOBERFLÄCHE
X_remotestatus = 1;
X_handstatus = 0;
}
else
{
// 04 ---- HANDBETRIEB 
X_handstatus = 1;
X_remotestatus = 0;

// 4.1 ---- Wahlschalter für Geschwindkeit oder Helligkeit, inkremente und dekremente
// Ist X_gh HIGH dann bedeutet das GESCHWINDIGKEIT, ist X_gh LOW dann HELLIGKEIT

if (X_gh == LOW);                                     // Wahlschalter: HELLIGKEIT ist angewähält
{
if (X_inc == HIGH)                                    // Inkrementtaster gedrückt ?
{ 
X_helligkeit = X_helligkeit +51;                     // Inkrementiere X_helligkeit um 51
}
if (X_dec == HIGH)                                  // Decrementtaster gedrückt ?                 
{ 
X_helligkeit = X_helligkeit -51;                    // Dekrementiere X_helligkeit um 51
}
}   
if (X_gh == HIGH);                           // Wahlschalter: GESCHWINDKEIT ist angewählt
{  
if (X_inc == HIGH)                              
{ 
X_geschwindigkeit = X_geschwindigkeit +51;           
}
if (X_dec == HIGH)                             
{ 
X_geschwindigkeit = X_geschwindigkeit -51;
}

// Überlauf: Die Helligkeit und die Geschwindkeit dürfen nicht größer 255 sein, wenn ja setze zurück auf 0

if (X_helligkeit > 255.0)                                  
{ 
(X_helligkeit = 0.0); 
}
if (X_geschwindigkeit > 255.0)                              
{ 
(X_geschwindigkeit = 0.0); 
}
}
}  
}  
// 05 ---- AUSGANGSTUFEN 

// 05.1 ---- Ausgangstufe 1  
unsigned long X_currentMillis_1 = millis();
if(X_currentMillis_1 - X_previousMillis_1 > X_geschwindigkeit)   // Auswertung Blink geschwindigkeit 
{
X_previousMillis_1 = X_currentMillis_1;                      // letzten Wert überschreiben

if (X_ledState_1 == LOW)                   // LED Ein/Ausschalten abhängig vom aktuellen Zustand
{                               
analogWrite(O_pwm1, X_helligkeit);
X_ledState_1 = HIGH;
}
else 
{
analogWrite(O_pwm1, 0); 
X_ledState_1 = LOW;
}
}
}

Schonmal Danke für's drüber schauen

Gruß
Leo

[Karol B. (johnpatcher)]

Ecd Ecd schrieb:
> und hier unser neues Programm - funktioniert nicht

Denkbar ungünstige Fehlerbeschreibung die ein gezieltes Suchen nach dem 
Problem im Prinzip unmöglich macht.

Ich weiß natürlich nicht wie viel Programmiererfahrung ihr schon habt, 
aber Kommentare wie dieser

Ecd Ecd schrieb:
> // Inkrementiere X_helligkeit um 51

sind ein Musterbeispiel für unnötige Kommentare. Das die Variable um 51 
inkrementiert wird, sieht man auf den ersten Blick, der Kommentar sollte 
eher beantworten warum inkrementiert wird. Überhaupt, wo kommt 
eigentlich der Wert 51 her? Das sieht mir nach einer "magischen" 
Konstante aus, und die sollte man als Konstante bzw. Makro definieren 
und gut kommentieren.

Ansonsten erscheint mir euer Programm unnötig kompliziert. Wenn ich das 
richtig sehe, dann generiert ihr das PWM Signal in der Hauptschleife 
"manuell". Gleichzeitig bremst ihr die Hauptschleife aber in jeder 
Iteration für 2 Sekunden aus. Das verträgt sich nicht sonderlich gut.

Der richtige Ansatz wäre es wohl das PWM Signal mittels Timer und einem 
Output Compare Register zu generieren (also wirklich in Hardware). In 
einer Timer ISR könnt ihr dann die eigentliche Stroboskop Funktion 
implementieren, indem ihr das Generieren des PWM Signals durch 
Beschreiben der entsprechenden Konfigurationsregister des Timers an- 
bzw. ausschaltet. Keine Ahnung wie gut sich das mit dem Arduino-Gedöns 
umsetzen lässt, aber soweit ich informiert bin, gibt es auch hierfür 
entsprechende Bibliotheken ;).

Mit freundlichen Grüßen,
Karol Babioch

[Ecd E. (ecd)]

Karol Babioch schrieb:
> Ecd Ecd schrieb:
>> und hier unser neues Programm - funktioniert nicht
>
> Denkbar ungünstige Fehlerbeschreibung die ein gezieltes Suchen nach dem
> Problem im Prinzip unmöglich macht.

Sorry - das hatte ich komplett vergessen.
Und zwar, kann ich nun ganz gut die Geschwindkeit, also den Blinktakt 
verstellen, aber an der Helligkeit tut sich nicht wirklich etwas. (Indem 
ich oben die Variablen X_helligkeit und X_geschwindigkeit "hart" von 
außen mit einem Wert beschreibe.

Wir haben uns das follgendermaßen gedadacht:
Die Werte für Geschwindkeit und Helligkeit stehen in den Variablen:
X_helligkeit und X_geschwindigkeit diese sind normalerweise auf "0" 
gesetzt.

Es wird ein Wahlschalter abgefragt mit dem ich zwischen den zwei 
Variablen wechseln kann: Sprich ist der schalter  (I_gh) High ist die 
Geschwindkeit gemeint.
Drücke ich nun einmal auf den Inkrement Taster zählt der zur 
Geschwindkeit "51" dazu - 51 weil 5mal 51 255 ergibt (Vollgas) - (5 
Stufen)
Das gleiche passiert rückwärts wenn man den Dekrement Taster drückt.
und für die Helligkeitsvariable dann wenn der Wahlschalter eben Low ist.

Karol Babioch schrieb:
> Gleichzeitig bremst ihr die Hauptschleife aber in jeder
> Iteration für 2 Sekunden aus. Das verträgt sich nicht sonderlich gut.

Das war nur ein Test um die Werte der Variablen anzuzeigen im Serial 
Monitor - ist aber AUSGESCHALTEN weil AUSGEKLAMMERT. Sprich das ist 
nicht der Punkt.

Gruß Leo

P.S wir haben in Siemens S7 Programmiererfahrungen, aber das ist ein 
bisschen anderst wie mit dem Arduino, wegen der echtzeit... Ich denke 
das auch hier irgendwo unser Denkfehler liegt...