Verschiedene Freuenz trotz gleicher PWM.

[Peter S. (mkhl77)]

Hallo lieben Foren Mitglieder,

ich hoffe hier etwas Hilfe zu bekommen, da ich noch nichts passendens 
gefunden habe, erstelle ich einen eigenen Post.

Mein Vorhaben:

Ich möchte mit einem ARDUINO NANO uC 4 LEDs steuern mittels PWM, 
idealerweise sollen alle viers LEDs mit der selben Frequenz und LED 
angesteuert werden.
Desweiteren benötige ich ein Referenzsignal welches in Phase und 
Amplitude zu der jeweilgen Leuchtenden LED gleich ist und snychron an 
einem Ausgang liegt wenn die jeweilige LED bzw. der Port HIGH ist.

Mein problem nun:

wenn ich die LEDs nach und nach durchschalte, habe ich unterschiedliche 
Frequenzen obwohl ich alle mit der selben pwm ansteuern.

Kontrollieren tue ich das mit einem Oszi.
Hardware:

Arduino Nano

RGB und Infrarot LED

Woran könnte das liegen ?

Vielen Dank im Voraus

Ich Poste meinen Code mal für eine Farbe:

int   analogpin          = A1;
int   ledpin             = 11;   //Blau
int   ledpin1            = 5;    //Gruen    
int   ledpin2            = 6;    // Rot
int   ledpin3            = 9;    // Infrarot      
int   maxi               = 1024; // 1024 entsprechen 5V 
float wert               = 0.0;
float Mittelwertblau     = 0.0;
float Mittelwertgruen    = 0.0;
float Mittelwertrot      = 0.0;
float Mittelwertinfrarot = 0.0;
float Voltblau           = 0.0;
float Voltgruen          = 0.0;
float Voltrot            = 0.0;
float Voltir             = 0.0;
float gesamt = 0.0;


void setup() 
{
  Serial.begin(9600);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(11,OUTPUT);
  pinMode(A1,INPUT);
}
void loop() 
{
  start:
  
     int p=0;
       if (Serial.available()>0)
        {
         p = Serial.read();
         p-=48;
         Serial.println(p);
        }else {goto start;}
    
switch(p)
{
//------------------------------------------Blau---------------------
  case 1:
    gesamt = 0.0;                    // setzt gesamt jedes mal wieder auf 0
    analogWrite(5, LOW);
    analogWrite(6, LOW);
    analogWrite(9, LOW);
    
    Serial.println("Blau ");
    Serial.println("_______");
    
    for(int i=0; i<=500; i++)
      {
        analogWrite(11, 127);                  // Duty Cycle von ca.75%
        delay(1);
        wert= analogRead(A1);                     //Einlesen der Werte
        gesamt           = wert   + gesamt;
        Mittelwertblau   = gesamt / 500;         // Mittelwert ausrechnen 
      }
      
      //Serial.println("_______");
     //Serial.println( Mittelwertblau);       // Ausgeben des Mittelwerts
      Voltblau= ( Mittelwertblau*5)/1024;    //Spannungswert ausrechnen                                    
      Serial.print("Der Spannungswert der Farbe Blau ergibt[V]: ");     // Ausgabe des Spannungswerts
      Serial.println(Voltblau); 
      break;

[Peter S. (mkhl77)]

Guten Morgen,

hat keiner eine Idee wie ich an mindestens 4 Ausgängen des Arduino Nano 
die selbe Frequenz hinbekomme ?

MfG

Vielen Dank

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Peter Stein schrieb:
> Ich Poste meinen Code mal für eine Farbe:
Und was kann man daran sehen? Wie kommt damit der Fehler bei den 
anderen Farben zustande? Was erwartest du? Und was erhältst du 
stattdessen?

> wenn ich die LEDs nach und nach durchschalte, habe ich unterschiedliche
> Frequenzen obwohl ich alle mit der selben pwm ansteuern.
Hast du da auch Zahlen?

Peter Stein schrieb:
> hat keiner eine Idee wie ich an mindestens 4 Ausgängen des Arduino Nano
> die selbe Frequenz hinbekomme ?
Doch: eine Sofware-PWM im Timerinterrupt. Sonst wirst du das niemals 
zuverlässig zum Laufen bekommen: siehe den Artikel Soft-PWM

Und sowas mit GOTO wie in BASIC macht man seit C nicht mehr:

  start:
        ...  
        else {goto start;}

Bei welchem Schlauberger hast du das abgekuckt?
Für die Hauptschleife ist ein while(1) {} erfunden worden.

BTW:
du kannst deinen Code mit den passenden Token schön formatieren lassen 
mit

[c]
   // dein Code (ist ja nur ein C-Derivat)
[/c]

Das steht übrigens ein paar Zeilen über der Eingabebox...

[Michael K. (Gast)]

Ich sehe gleich ein paar Probleme die Deinem Vorhaben im Wege stehen.
1. Der Arduino Software Unterbau ist für seine Langsamkeit berüchtigt.
2. float zieht langwierige Berechnungen nach sich.
3. Software PWM
4. delay()

Du bremmst den ATmega328 an jeder nur möglichen Stelle aus was zu einer 
PWM Frequenz führt die er dann je nach Berechnung noch so schafft.

Lese das Datenblatt zum ATmega328, speziell die Kapitel über Timer und 
PWM (output compare).
4 zusammenhängende PWM hat der nicht, aber verteilt über zwei timer 
sollte das kein Problem sein.

Statt float lese was über 
https://www.mikrocontroller.net/articles/Festkommaarithmetik

[S. K. (hauspapa)]

Zitat:
"On the Uno and similar boards, pins 5 and 6 have a frequency of 
approximately 980 Hz. Pins 3 and 11 on the Leonardo also run at 980 Hz."

Ausserdem:
"The PWM outputs generated on pins 5 and 6 will have 
higher-than-expected duty cycles. ..... This will be noticed mostly on 
low duty-cycle settings (e.g 0 - 10) and may result in a value of 0 not 
fully turning off the output on pins 5 and 6. "

aus:
http://www.arduino.cc/en/pmwiki.php?n=Reference/AnalogWrite

viel Erfolg
Hauspapa

[Frank L. (hermastersvoice)]

Guck dir mal das hier an:
http://playground.arduino.cc/Code/Timer1
Damit kann man richtige PWM machen.

[Peter S. (mkhl77)]

Guten Morgen,

vielen Dank für die Antworten, dass mit den 980 Hz und 480 Hz wußte ich 
nicht, dass sind genau die Werte die ich Messe.
Aber dann muß ich mir sowieso was anderes überlegen, wenn ich 5 
snychrone frequenzen haben möchte.

Danke

[Eric (Gast)]

Peter Stein schrieb:
> Ich möchte mit einem ARDUINO NANO uC 4 LEDs steuern mittels PWM,
> idealerweise sollen alle viers LEDs mit der selben Frequenz und LED
> angesteuert werden.
> Desweiteren benötige ich ein Referenzsignal welches in Phase und
> Amplitude zu der jeweilgen Leuchtenden LED gleich ist und snychron an
> einem Ausgang liegt wenn die jeweilige LED bzw. der Port HIGH ist.

Wenn ich es also richtig interpretiere soll nur ein- und ausschalten 
individuell per LED steuerbar sein? Ansonsten alles gleich?
Dann nimm doch 1 PWM-Ausgang und verknüpfe (UND) die mit einem 
Steuersignal für jede LED:

.-----.
| PWM |]--ooo.
|     |   ||||  .---.
|     |   |||'--| & |-----> LED1
| LED1|]--+++---|   |
|     |   |||   '---'
|uC   |   |||   .---.
|     |   ||'---| & |-----> LED2
| LED2|]--++----|   |
|     |   ||    '---'
|     |   ||    .---.
|     |   |'----| & |-----> LED3
| LED3|]--+-----|   |
|     |   |     '---'
|     |   |     .---.
|     |   '-----| & |-----> LED4
| LED4|]--------|   |
'-----'         '---'

[Peter S. (mkhl77)]

Hallo,


ich steuer damit das Gate eines Transistors.

Da die Dioden ca. 700mA ziehen , habe ich eine Treiberschaltung.
Somit funktioniert Ihre Idee nicht.

Aber trotzden danke.

[Peter S. (mkhl77)]

oder das könnte doch funktionieren.

[Rene H. (Gast)]

Drei RGB LED und eine IR LED ziehen 700mA? Was sind das für Dioden?

[Pandur S. (jetztnicht)]

Schema bitte.

[Peter S. (mkhl77)]

Das sind Hochleistungs LEDS von osram, da zieht eine 700 mA, alle 
zusammen sind nie an.

[Samuel C. (neoexacun)]

Peter Stein schrieb:

> ich steuer damit das Gate eines Transistors.
>
> Da die Dioden ca. 700mA ziehen , habe ich eine Treiberschaltung.
> Somit funktioniert Ihre Idee nicht.

Warum sollte es dann nicht funktionieren?

Andere Frage, wozu brauchst du das Signal einer LED an verschiedenen 
Pins? Greif es doch für beide Zwecke (Verstärkung und was auch immer) 
einfach direkt am selben Pin ab.

[Peter S. (mkhl77)]

Sorry, aber das versteh ich jetzt gerade nicht, was Sie meinen mit dem 
selben Pin.

Also Ihre Idee funktioniert ja trotzdem, kann ja mit de Ausgang von der 
& Verknüpfung trotzdem das Gate von jedem Transitor durchschalten.

[Samuel C. (neoexacun)]

Naja, du hast einen Pin, an dem deine PWM liegt. An diesem sind die 
Transistoren angeschlossen. Warum brauchst du dann jetzt noch einen 
zweiten Pin, an dem genau das selbe Signal liegt?

Und ja, das funktioniert mit den UND-Gattern, ist im Prinzip die 
einfachste Lösung, wenn du keine eigene Soft-PWM schreiben willst.

[Martin L. (martin_l795)]

Irgendwie muss ich ja jetzt doch mal blöd fragen: Wozu hast Du 
eigentlich noch Potis vor den LEDs, wenn die eh durch eine PWM gesteuert 
werden?

[Peter S. (mkhl77)]

Wie würde eine Soft-PWM aussehen ?
Könnte ich mir damit die UND Lösung sparen?

Ich brauch ein in Phasen und Amplituden gleiches Signal, welches ich an 
einen Lock-In-Versträker anschliese.

[Peter S. (mkhl77)]

Die Potis sind mein vorwiderstand für die LED, will die ja nicht an 5 V 
legen.

[Martin L. (martin_l795)]

Ja, nur warum Potis und keine festen Widerstände?

[Peter S. (mkhl77)]

weil ich noch am einstellen bin, und ich ja bis zu 2 w verarbeiten muß, 
da ist das die einfachste lösung.

[Peter D (Gast)]

Peter Stein schrieb:
> und ich ja bis zu 2 w verarbeiten muß,
> da ist das die einfachste lösung.

Also hast du Potis die 2W abkönnen ?

[Peter S. (mkhl77)]

Ja 10 W

[Samuel C. (neoexacun)]

Peter Stein schrieb:
> Wie würde eine Soft-PWM aussehen ?
> Könnte ich mir damit die UND Lösung sparen?

Wird in Arduino vermutlich nicht wirklich schön, da kenne ich mich aber 
nicht aus. In reinem C ist es kein großes Problem:
https://www.mikrocontroller.net/articles/Soft-PWM

Ja, dann brauchst du kein UND mehr.

[Peter S. (mkhl77)]

Guten Abend Samuel,

danke für den Link aber da ich  ja in der EWU Arduino das ganze 
realisieren will, komme ich damit leider nicht weiter.

Ich meine das muß doch sofware technisch auch irgendwie möglich sein, 5 
exakt die selben Frequenzen zu generieren, die Hardware kann das doch 
oder liege ich da falsch.

Ich werde mal folgende varianten testen:

1:

void setup()
{
  pinMode(13, OUTPUT);
}

void loop()
{
  digitalWrite(13, HIGH);
  delayMicroseconds(100); // Approximately 10% duty cycle @ 1KHz
  digitalWrite(13, LOW);
  delayMicroseconds(1000 - 100);
}


2:

  pinMode(3, OUTPUT);
  pinMode(11, OUTPUT);
  TCCR2A = _BV(COM2A0) | _BV(COM2B1) | _BV(WGM21) | _BV(WGM20);
  TCCR2B = _BV(WGM22) | _BV(CS22);
  OCR2A = 180;
  OCR2B = 50;


bei variante zwei habe ich nur das problem das das glaube ich nur an pin 
3 und 11 möglich ist oder kann ich das an allen pins so generieren ?

[Samuel C. (neoexacun)]

Ja, die Hardware kann das in der Tat. Du hast 6 PWM-Einheiten zur 
Verfügung, allerdings sind diese über Arduino-Befehle schwer in den 
Griff zu bekommen, aber du hast ja den richtigen Ansatz über die 
Register schon gezeigt.

Allerdings musst du, um alle 6 PWM-Kanäle nutzen zu können, alle drei 
Timer für dich reservieren, und da wird dir die Arduino-API vermutlich 
einen Strich durch die Rechnung machen, da diese vermutlich mindestens 
einen Timer für sich will.

Somit bleibt dir, wenn du weiter mit der Arduino-API arbeiten willst, 
nur eine Soft-PWM, und auch da kann ich dir leider nicht sagen, ob die 
mit der Arduino-API so einfach zu machen ist, wie mit blankem C.

[Peter S. (mkhl77)]

Hm....

Was nun tun ??

Die einfachste Lösung wäre denke ich, die Baustein zu nehmen mit den UND 
Gattern, aber ist das auch die beste lösung ?

Kann ich den Arduino Nano auch mit einer anderen EW-Umgebung 
Programmieren ?
So das ich Hardware mäßig nix verändern muß , oder muß ich einen andern 
uC nehmen ?

[Samuel C. (neoexacun)]

Du musst an der Hardware überhaupt nichts verändern. Du kannst jede IDE, 
die mit AVRs umgehen kann verwenden. Ich verwende dafür Atmel-Studio, 
aber da hat jeder seinen eigenen Geschmack.

Die Arduino-Geschichte ist auch nur C mit einem Batzen an Bibliotheken. 
Theoretisch kannst du sogar in der Arduino-IDE direkt normales C 
schreiben, allerdings ist das nicht wirklich komfortabel.

[Peter S. (mkhl77)]

Okay danke,

doof nur das ich mich damit nnicht so gut auskenne, naja probieren geht 
über studieren ;-)

[Samuel C. (neoexacun)]

https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial

[Peter S. (mkhl77)]

Vielen Dank