[erledigt] LED Einschaltzucken verhindern? (Micro)

Hallo,

beim einschalten oder nach Reset habe ich einen LED Zündeffekt. Die LED wird demnach kurzzeitig eingeschalten obwohl sie das nicht soll und laut Code auch nicht macht.

Auf dem Genuino Micro habe ich den Zündeffekt. Auf dem Mega2560 sehe ich keinen. Habe allerdings an dem nicht die gleiche LED dran. Gibt eine Möglichkeit das zu umgehen?

Beim einschalten läuft kurz ein Fading als Spass. Dabei wird schon der Mittelwert für den Sollwert nebenbei ermittelt. Am Ende wird auf Sollwerthelligkeit gedimmt.

Edit:
was ich eingrenzen kann ist, dass es mit der Timereinstellung zu tun haben könnte. Habe das mit delays davor und danach probiert.

/*
 Doc_Arduino - german Arduino Forum
 IDE 1.6.6
 Genuino Micro

 LED Helligkeitssteuerung
 
 Timer 1: Phase & Frequenz Correct, Mode 9
 TOP:  OCR1A     (Takt-Frequenz)
 Pulsweite: OCR1 (<= TOP)
 Schaltpin: 10   (OC1B bzw. PB6) nicht invertiert
*/

#include <avr/pgmspace.h>

const byte _LEDpin  = 10;   // OC1B bzw. PB6 nicht invertiert, IRLZ34N Mosfet 
const byte _LDR1pin = A0;   // LDR
const byte _LDR2pin = A1;   // LDR
const byte _Pot1pin = A2;   // Potentiometer, Minimum Helligkeit
const byte _Pot2pin = A3;   // Potentiometer, Maximal Helligkeit

float _LDR_filt;            // gefilteter gleitender LDR Mittelwert
int _Index_PWM_Table;

// vorberechnete PWM Pulsweiten, linearisiert Helligkeitwahrnehmung fürs menschliche Auge
const int PWM_Table[202] PROGMEM =     // 12 Bit, aus 256 Werten, Gammakorrektur 3,0
          {0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,2,2,2,3,3,3,4,4,5,5,6,7,7,8,9,10,11,12,13,14,
           15,16,17,18,20,21,23,24,26,27,29,31,33,35,37,39,41,43,46,48,51,53,56,59,62,65,68,71,
           74,78,81,85,88,92,96,100,104,108,113,117,122,126,131,136,141,146,152,157,163,168,174,
           180,186,192,199,205,212,219,225,232,240,247,255,262,270,278,286,294,303,311,320,329,
           338,347,356,366,376,386,396,406,416,427,438,449,460,471,482,494,506,518,530,543,555,
           568,581,594,608,621,635,649,663,678,692,707,722,738,753,769,785,801,817,834,850,868,
           885,902,920,938,956,974,993,1012,1031,1050,1070,1090,1110,1130,1151,1171,1192,1214,
           1235,1257,1279,1301,1324,1347,1370,1393,1417,1441,1465,1489,1514,1539,1564,1590,1615,
           1641,1668,1694,1721,1748,1776,1804,1832,1860,1889,1917,1947,1976,2006};   // letzter Indexwert 201                              
    
void setup()  { 
  digitalWrite(_LEDpin, LOW);    // OC1B bzw. PB6 nicht invertiert
  pinMode(_LEDpin, OUTPUT);      
    
  set_Timer1();

  DemoFading();
}

  
void loop() {         

  _Index_PWM_Table = calculate_PWM();  // aktualisiert LDR Werte und mapt
                                       // auf Tabellen Indexposition
  refresh_LED(_Index_PWM_Table);       // aktualisiert das PWM Tastverhältnis
  
}   // loop Ende


// ****** Funktionen ******* //
int calculate_PWM ()
{
  int LDR1 = analogRead(_LDR1pin);
  int LDR2 = analogRead(_LDR2pin); 
  int minBrightness = analogRead(_Pot1pin);             // minimum Index 
  minBrightness = map(minBrightness, 0, 1023, 13, 60);  // Bereich 13 ... 60 möglich
  int maxBrightness = analogRead(_Pot2pin);       
  maxBrightness = map(maxBrightness, 0, 1023, (minBrightness+10), 201);  // muß <= höchstem PWM_Table Index bleiben
  int LDR = (LDR1+LDR2)/2;      
  Filtern(_LDR_filt, LDR, 500);
  int Index_PWM_Table = map(_LDR_filt, 0, 1023, minBrightness, maxBrightness);
  return Index_PWM_Table;
}


void refresh_LED (int Index_PWM_Table)
{
  int PWM_Wert = pgm_read_word_near(PWM_Table + Index_PWM_Table);  
  OCR1B = PWM_Wert;
} 


void DemoFading()     // einmalig beim Start
{
  static unsigned long lastTime;
  static unsigned int stepTime = 5;
  static unsigned int Index_PWM_Table = 0;
    
  for (int i=0; i<=201;)  {                  // Fading IN        
    if (millis() - lastTime > stepTime )  {  // Fading Geschwindigkeit einhalten
      Index_PWM_Table = i;                   // PWM_Table Index Position anpassen
      lastTime = millis(); 
      i++;
    }
    refresh_LED(Index_PWM_Table);
    _Index_PWM_Table = calculate_PWM();
  }
  stepTime = stepTime+6;
  
  for (int i=201; i>=15;)  {                  // Fading OUT        
    if (millis() - lastTime > stepTime )  {   // Fading Geschwindigkeit einhalten
      Index_PWM_Table = i;                    // PWM_Table Index Position anpassen
      lastTime = millis(); 
      i--;
    }
    refresh_LED(Index_PWM_Table);
    _Index_PWM_Table = calculate_PWM();
  }
  stepTime = stepTime+8;

  for (int i=15; i<=_Index_PWM_Table;)  {     // Fading IN auf Sollwert        
    if (millis() - lastTime > stepTime )  {   // Fading Geschwindigkeit einhalten
      Index_PWM_Table = i;                    // PWM_Table Index Position anpassen
      lastTime = millis(); 
      i++;
    }
    refresh_LED(Index_PWM_Table);
    _Index_PWM_Table = calculate_PWM();
  }
    
}  

    
void set_Timer1()       //  12 Bit PWM, Phase Frequency Correct, Mode 9
{
  cli();         // Interrupts ausschalten
  TCCR1A = 0;    // Reset TCCR1A Register 
  TCCR1B = 0;    // Reset TCCR1B Register
  TIMSK1 = 0;    // Reset TIMSK1 Register (disable Timer Compare Interrupts)
  TCNT1  = 0;    // initialize counter value to 0
  TCCR1A = (1<<COM1B1) | (1<<WGM10);   // nicht invertiert
  TCCR1B = (1<<WGM13) | (1<<CS11);     // Prescaler 8 >> 244,2Hz (TOP 4095)
  OCR1A = 4095;  // TOP Wert bestimmt Auflösung und mit Prescaler den PWM Takt
  OCR1B = 0;     // Pulsweite, OCR1B <= 4095 (2^12)
  sei();         // Interrupts einschalten
}  // end Funktion


/****************************************************************************************
** Funktion Filtern()  by GuntherB                                                     **
*****************************************************************************************
** Bildet einen Tiefpassfilter (RC-Glied) nach.                                        **
** FF = Filterfaktor;  Tau = FF / Aufruffrequenz                                       **                                                                                     **
** Input: FiltVal der gefilterte Wert, NewVal der neue gelesene Wert; FF Filterfaktor  **
** Output:  FiltVal                                                                    **
** genutzte Globale Variablen: _LDR_filt  (call by Reference)                          **
*****************************************************************************************/
void Filtern(float &FiltVal, int NewVal, int FF){
  FiltVal= ((FiltVal * FF) + NewVal) / (FF +1); 
}

An welchem Pin und wie sieht die Beschaltung aus?

Hallo,

Pin 10 wie im Code steht.
Schaltplan im Anhang. Ist kein Shield. Ist der echte Micro.

Hast du schon mal eine andere IDE probiert. Man liest ja einiges von der 1.6.6.

Hallo,

so verbugt ist die 1.6.6 nicht wie man immer wieder liest. Mit der 1.6.7 beta ist das gleiche Problem. Es gibt aber wie eben gesehen eine neue 1.6.7 final. Werde diese noch probieren. Dann werde ich die LEDs aufwändigerweise umbauen um sie am Mega2560 zu testen.

Wenn 18x der Schaltplan aufgerufen wurde, nehme ich an der ist i.O. :)

Falls noch andere Ideen kommen, nur zu ...

Der Schaltplan ist ok, soweit ich das erkennen kann.

Den Code würde ich testweise auf ein Minimum reduzieren.

Und nein! Pin 10 darf nicht einfach so zucken.

Der Bootloader ist es nicht? Der könnte auch noch ein böses Spiel treiben.....

Zuckt es auch wenn Du R1 von Pin 10 abziehst? Grüße UWe

Hallo,

mit der IDE Version hat sich nichts geändert.

Bootloader. Du meinst das Ding löschen? Löschen ginge, aber danach sehe ich Probleme. Dann könnte ich nur noch mittels mkII flashen, was aus der IDE heraus nicht funktioniert, soweit ich micht entsinne. Gut, ich könnte dann über Atmel Studio flashen, müßte dafür den Code abändern. Also nicht mehr IDE like. Weil das Visual Micro Plugin zur Zeit nur bis IDE 1.6.5 unterstützt. Mittlerweile habe ich 1.6.7 installiert. Wäre aber machbar.

Wenn der Bootloader beim Micro gelöscht ist, funktioniert dann noch die serielle/USB im eigentlichen Programmcode?

Den Aufwand auf meinen Mega2560 umzubauen scheue ich noch etwas. Deshalb habe ich den Timer nochmal angefasst. Habe den Timer Mode geändert. Wieder auf den ehemals zu Anfang verwendeten Fast Mode. Hier störte mich das er nicht sauber auf 0 geht nicht invertiert oder invertiert nicht sauber auf 100%. Deshalb bin ich zum Phase Frequenz Correct übergegangen. Der sollte eigentlich der non plus ultra Timer Mode sein ohne jede Schwäche.

Lange Rede kurzer Sinn. Im Fast Mode habe ich kein zucken beim einschalten.

Jetzt kommen Feiertage mit Familie, da wird nicht viel werden. Ich nehme mich dem Phase Frequenz Correct Mode nochmal an mit reduzierten Code und werde berichten. Idee ist aktuell. Timer setzen aber den PWM Wert auf 0 belassen. Theoretisch dürfte sich der Ausgang nie zucken, immer aus bleiben.

So langsam ahne ich warum den Micro niemand verwendet. :slight_smile: :slight_smile: :slight_smile: Hätte ich einen nackten Atmel genommen wäre ich bestimmt schon fertig. :slight_smile:

@ Uwe:
wie meinst du das genau? Soll ich R1 brücken? Oder Pin10 von der “Mosfet Beschaltung” trennen? Du meinst das die LED zuckt wegen 12V Netzteilfehler? Das könnte ich verneinen. Ich schalte ein, die LED zuckt. Das macht die auch nach Reset, dann werkelt der Micro 8sec rum und legt dann los. Die LED zuckt dann erst nach den 8 sec. Wartezeit.
Wenn Pin10 getrennt ist, wie soll ich dann ein zucken feststellen? Verstehe wirklich noch nicht wie du das meinst.

Code Vollständigkeitshalber

/*
 Doc_Arduino - german Arduino Forum
 IDE 1.6.7
 Genuino Micro

 LED Helligkeitssteuerung
 
 Timer 1: 10 Bit Fast PWM, Mode 7
 TOP:  1023
 Pulsweite: OCR1 (<= TOP)
 Schaltpin: 10   (OC1B bzw. PB6) nicht invertiert
*/

#include <avr/pgmspace.h>

const byte _LEDpin  = 10;   // OC1B bzw. PB6 nicht invertiert, IRFxxxx Mosfet 
const byte _LDR1pin = A0;   // LDR
const byte _LDR2pin = A1;   // LDR
const byte _Pot1pin = A2;   // Potentiometer, Minimum Helligkeit
const byte _Pot2pin = A3;   // Potentiometer, Maximal Helligkeit

float _LDR_filt;            // gefilteter gleitender LDR Mittelwert
int _Index_PWM_Table;

// vorberechnete PWM Pulsweiten, linearisiert Helligkeitwahrnehmung fürs menschliche Auge
const int PWM_Table[99] PROGMEM =     // 10 Bit, 99 aus 128 Werten, Gammakorrektur 3,0
          {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,3,3,4,5,5,6,7,8,9,10,11,12,13,
           15,16,18,20,21,23,25,27,30,32,34,37,40,43,46,49,52,55,59,62,66,70,
           74,79,83,88,92,97,103,108,113,119,125,131,137,144,150,157,164,171,
           179,186,194,202,211,219,228,237,246,256,265,275,286,296,307,318,
           329,340,352,364,376,389,402,415,428,442,456,470};   // letzte Indexposition 98               
    
void setup()  { 
  digitalWrite(_LEDpin, LOW);    // OC1B bzw. PB6 nicht invertiert
  pinMode(_LEDpin, OUTPUT);      
    
  set_Timer1();

  DemoFading();
}

  
void loop() {         

  _Index_PWM_Table = calculate_PWM();  // aktualisiert LDR Werte und mapt
                                       // auf Tabellen Indexposition
  refresh_LED(_Index_PWM_Table);       // aktualisiert das PWM Tastverhältnis
  
}   // loop Ende


// ****** Funktionen ******* //
int calculate_PWM ()
{
  int LDR1 = analogRead(_LDR1pin);
  int LDR2 = analogRead(_LDR2pin); 
  int minBrightness = analogRead(_Pot1pin);             // minimum Index 
  minBrightness = map(minBrightness, 0, 1023, 12, 30);  // Bereich 12 ... 30 möglich
  int maxBrightness = analogRead(_Pot2pin);       
  maxBrightness = map(maxBrightness, 0, 1023, (minBrightness+10), 98);  // muß <= höchstem PWM_Table Index bleiben
  int LDR = (LDR1+LDR2)/2;      
  Filtern(_LDR_filt, LDR, 500);
  int Index_PWM_Table = map(_LDR_filt, 0, 1023, minBrightness, maxBrightness);
  return Index_PWM_Table;
}


void refresh_LED (int Index_PWM_Table)
{
  int PWM_Wert = pgm_read_word_near(PWM_Table + Index_PWM_Table);  
  OCR1B = PWM_Wert;
} 


void DemoFading()     // einmalig beim Start
{
  static unsigned long lastTime;
  static unsigned int stepTime = 15;
  static unsigned int Index_PWM_Table = 0;
    
  for (int i=0; i<=98;)  {                   // Fading IN        
    if (millis() - lastTime > stepTime )  {  // Fading Geschwindigkeit einhalten
      Index_PWM_Table = i;                   // PWM_Table Index Position anpassen
      lastTime = millis(); 
      i++;
    }
    refresh_LED(Index_PWM_Table);
    _Index_PWM_Table = calculate_PWM();
  }
  stepTime = stepTime+5;
  
  for (int i=98; i>=12;)  {                   // Fading OUT        
    if (millis() - lastTime > stepTime )  {   // Fading Geschwindigkeit einhalten
      Index_PWM_Table = i;                    // PWM_Table Index Position anpassen
      lastTime = millis(); 
      i--;
    }
    refresh_LED(Index_PWM_Table);
    _Index_PWM_Table = calculate_PWM();
  }
  stepTime = stepTime+5;

  for (int i=12; i<=_Index_PWM_Table;)  {     // Fading IN auf Sollwert        
    if (millis() - lastTime > stepTime )  {   // Fading Geschwindigkeit einhalten
      Index_PWM_Table = i;                    // PWM_Table Index Position anpassen
      lastTime = millis(); 
      i++;
    }
    refresh_LED(Index_PWM_Table);
    _Index_PWM_Table = calculate_PWM();
  }
}  

    
void set_Timer1()       //  10 Bit Fast PWM - Mode 7
{
  cli();         // Interrupts ausschalten
  TCCR1A = 0;    // Reset TCCR1A Register 
  TCCR1B = 0;    // Reset TCCR1B Register
  TIMSK1 = 0;    // Reset TIMSK1 Register (disable Timer Compare Interrupts)
  TCNT1  = 0;    // initialize counter value to 0
  TCCR1A = (1<<COM1B1) | (1<<WGM11) | (1<<WGM10);   // nicht invertiert
  TCCR1B = (1<<WGM12) | (1<<CS11) | (1<<CS10);      // Prescaler 64 > 244,1Hz
  TCNT1 = 0;
  OCR1B = 0;     // Pulsweite, OCR1x <= 1023 (2^10)
  sei();         // Interrupts wieder eingeschalten
  
}  // end Funktion


/****************************************************************************************
** Funktion Filtern()  by GuntherB                                                     **
*****************************************************************************************
** Bildet einen Tiefpassfilter (RC-Glied) nach.                                        **
** FF = Filterfaktor;  Tau = FF / Aufruffrequenz                                       **                                                                                     **
** Input: FiltVal der gefilterte Wert, NewVal der neue gelesene Wert; FF Filterfaktor  **
** Output:  FiltVal                                                                    **
** genutzte Globale Variablen: _LDR_filt  (call by Reference)                          **
*****************************************************************************************/
void Filtern(float &FiltVal, int NewVal, int FF){
  FiltVal= ((FiltVal * FF) + NewVal) / (FF +1); 
}

Doc_Arduino: Hier störte mich das er nicht sauber auf 0 geht nicht invertiert oder invertiert nicht sauber auf 100%. Deshalb bin ich zum Phase Frequenz Correct übergegangen.

Du kannst abfragen ob an der Grenze bist und statt dessen digitalWrite() machen

Lange Rede kurzer Sinn. Im Fast Mode habe ich kein zucken beim einschalten.

Dann ist der Bootloader von jeglicher Schuld befreit.

Hat sich erledigt. Grüße Uwe

Hallo,

digitalWrite könnte man machen, würde aber das sanfte Fading beeinflussen. Ich würde dann eher, wenn alles nichts bringt den invertierten Modus verwenden und verzichte auf 100% Tastverhältnis.

Hab mich dem Phase Frequency Correct, Mode 9 wieder angenommen und den Code reduziert.
Ich setze also nur den Timer in den Modus und belasse den PWM Wert im OCR1B Register bei 0.
Beim einschalten zuckt meine LED immer noch kurz um dann dauerhaft aus zu sein.

Ist an den Settings vom Timer Mode 9 demnach noch etwas falsch? Ich denke nicht, bin mir aber jetzt nicht mehr so sicher.

Auf dem Mega2560 zum Bsp. wäre der Timerpin dann Pin 12. Falls das jemand testen möchte.

/*
 Doc_Arduino - german Arduino Forum
 IDE 1.6.7
 Genuino Micro

 LED Helligkeitssteuerung
 
 Timer 1: Phase & Frequenz Correct, Mode 9
 TOP:  OCR1A     (Takt-Frequenz)
 Pulsweite: OCR1 (<= TOP)
 Schaltpin: 10   (OC1B bzw. PB6) nicht invertiert

 !!! reduzierter Code Fehlersuche Einschalt-Zündeffekt
*/

const byte _LEDpin  = 10;   // OC1B bzw. PB6 nicht invertiert 


void setup()  { 
  digitalWrite(_LEDpin, LOW);    // OC1B bzw. PB6 nicht invertiert
  pinMode(_LEDpin, OUTPUT);      
    
  set_Timer1();

}

 
void loop() {         
  
}   // loop Ende


// ****** Funktionen ******* //
void set_Timer1()       //  12 Bit PWM, Phase Frequency Correct, Mode 9
{
  cli();         // Interrupts ausschalten
  TCCR1A = 0;    // Reset TCCR1A Register 
  TCCR1B = 0;    // Reset TCCR1B Register
  TIMSK1 = 0;    // Reset TIMSK1 Register (disable Timer Compare Interrupts)
  TCNT1  = 0;    // initialize counter value to 0
  TCCR1A = (1<<COM1B1) | (1<<WGM10);   // nicht invertiert
  TCCR1B = (1<<WGM13) | (1<<CS11);     // Prescaler 8 >> 244,2Hz (TOP 4095)
  OCR1A = 4095;  // TOP Wert bestimmt Auflösung und mit Prescaler den PWM Takt
  OCR1B = 0;     // Pulsweite, OCR1B <= 4095 (2^12)
  sei();         // Interrupts einschalten
}  // end Funktion

Hallo,

wenn ich “Phase and Frequency Correct Mode 9” mit invertierten Ausgang verwende, habe ich keinen Zündeffekt.
Mit “Phase Correct Mode 3 und 11” nicht invertiert habe ich auch keinen Zündeffekt.

Ich belasse es beim Phase Correct Mode oder Fast PWM und gut ist. Wer weis was der “Phase and Frequency Correct Mode 9” für eine Macke hat. :o

Und seit morgen schön artig. :slight_smile:

void set_Timer1_d()       // 10 Bit PWM, Phase Correct, Mode 3
{                         // ohne Zündeffekt
  cli();         // Interrupts ausschalten
  TCCR1A = 0;    // Reset TCCR1A Register 
  TCCR1B = 0;    // Reset TCCR1B Register
  TIMSK1 = 0;    // Reset TIMSK1 Register (disable Timer Compare Interrupts)
  TCNT1  = 0;    // initialize counter value to 0
  TCCR1A = (1<<COM1B1) | (1<<WGM11) | (1<<WGM10);   // Mode 3
  TCCR1B = (1<<CS11);                               // Prescaler 8 >> x,xHz)
  OCR1B = 0;     // Pulsweite, OCR1B <= 1023 (2^10)
  sei();         // Interrupts einschalten
}  // end Funktion


void set_Timer1_e()       // 12 Bit PWM, Phase Correct, Mode 11
{                         // ohne Zündeffekt
  cli();         // Interrupts ausschalten
  TCCR1A = 0;    // Reset TCCR1A Register 
  TCCR1B = 0;    // Reset TCCR1B Register
  TIMSK1 = 0;    // Reset TIMSK1 Register (disable Timer Compare Interrupts)
  TCNT1  = 0;    // initialize counter value to 0
  TCCR1A = (1<<COM1B1) | (1<<WGM11) | (1<<WGM10);   // Mode 11
  TCCR1B = (1<<WGM13) | (1<<CS11);                  // Prescaler 8 >> x,xHz 
  OCR1A = 4095;  // TOP Wert bestimmt Auflösung und mit Prescaler den PWM Takt
  OCR1B = 0;     // Pulsweite, OCR1B <= 4095 (2^12)
  sei();         // Interrupts einschalten
}  // end Funktion

Hallo,

hab nochmal mit dem Mode 9 rumgefummelt. Läßt mir keine Ruhe. Dazu dann doch eine 2W LED an meinem Mega gebammelt und siehe da, ich sehe auch hier den Zündeffekt, denn ich mit einer 5mm LED nicht sehe. Die einzigste Lösung derzeit die hilft ist, den Pin erst nach dem Timer setzen auf Ausgang zu schalten. Vorher darf man dann aber nicht noch auf LOW setzen. Sonst geht gar nichts. Das ist zwar erstmal eine Lösung, jedoch bissel quick & dirty. Also falls jemanden nochwas einfällt, warum der Timerpin kurz zuckt, nur zu.

/*
 Doc_Arduino - german Arduino Forum
 IDE 1.6.7
 Arduino Mega2560

 LED Helligkeitssteuerung
 
 Timer 1: Phase & Frequenz Correct, Mode 9
 TOP:  OCR1A     (Takt-Frequenz)
 Pulsweite: OCR1 (<= TOP)
 Schaltpin: 12   (OC1B bzw. PB6) nicht invertiert

 !!! reduzierter Code Fehlersuche Einschalt-Zündeffekt
*/

const byte _LEDpin  = 12;   // OC1B bzw. PB6 nicht invertiert


void setup()  {
  
  set_Timer1();
  
  //digitalWrite(_LEDpin, LOW);    // darf nicht ausgeführt werden ???
  
  pinMode(_LEDpin, OUTPUT);      

}

 
void loop() {        
  
}   // loop Ende


// ****** Funktionen ******* //
void set_Timer1()       //  12 Bit PWM, Phase Frequency Correct, Mode 9
{
  cli();         // Interrupts ausschalten
  TCCR1A = 0;    // Reset TCCR1A Register
  TCCR1B = 0;    // Reset TCCR1B Register
  TIMSK1 = 0;    // Reset TIMSK1 Register (disable Timer Compare Interrupts)
  TCNT1  = 0;    // initialize counter value to 0
  TCCR1A = (1<<COM1B1) | (1<<WGM10);   // nicht invertiert
  TCCR1B = (1<<WGM13) | (1<<CS11);     // Prescaler 8 >> 244,2Hz (TOP 4095)
  OCR1A = 4095;  // TOP Wert bestimmt Auflösung und mit Prescaler den PWM Takt
  OCR1B = 0;     // Pulsweite, OCR1B <= 4095 (2^12)
  sei();         // Interrupts einschalten
}  // end Funktion

Hallo,

so Leute, der Witz ist, auf dem Micro hab ich trotzdem den Zündeffekt, auch wenn ich erst den Timer setze und dann den Pin auf Ausgang. Der Mode 9 kann mich mal kreuzweise. Ich bleib jetzt bei Fast PWM.

Doc_Arduino:
Der Mode 9 kann mich mal kreuzweise.

der Witz schlecht hin. Es läßt einem ja doch keine Ruhe. :slight_smile:
Ich habe mir nochmal die Beschreibung des Phase & Frequency Correct Mode durchgelesen. Eigentlich schon öfters. Diesmal kam ich drauf. Der Zündeffekt ist demnach ein normales Verhalten in dem Modus. Es kommt darauf wie man ihn initialisiert.
nicht invertierter Modus:
Der OC1B Pin wird gelöscht nach Compare Match beim hochzählen und gesetzt beim Compare Match beim runterzählen.
Das heißt, der Pin ist immer gelöscht, wenn der Zähler größer als seinem Vergleichswert ist.
Also setze ich den Zähler nicht auf 0 sondern zum Bsp. auf 2. Hauptsache größer wie mein Startwert OCR1B.
Ergebnis, kein Zündeffekt mehr. Saubere Lösung wie ich finde. Quick & Clean. :grin:
Damit ist das Thema für mich endlich vom Tisch. :wink:

void setup()  { 
  digitalWrite(_LEDpin, LOW);    // OC1B bzw. PB6 nicht invertiert
  pinMode(_LEDpin, OUTPUT);      
  set_Timer1();
}

  
void set_Timer1()       //  12 Bit PWM, Phase Frequency Correct, Mode 9
{
  cli();         // Interrupts ausschalten
  TCCR1A = 0;    // Reset TCCR1A Register 
  TCCR1B = 0;    // Reset TCCR1B Register
  TIMSK1 = 0;    // Reset TIMSK1 Register (disable Timer Compare Interrupts)
  TCNT1  = 2;    // setzt Counter größer OCR1B, damit keinen Zündeffekt beim Start
  TCCR1A = (1<<COM1B1) | (1<<WGM10);   // nicht invertiert
  TCCR1B = (1<<WGM13) | (1<<CS11);     // Prescaler 8 >> 244,2Hz (TOP 4095)
  OCR1A = 4095;  // TOP Wert bestimmt Auflösung und mit Prescaler den PWM Takt
  OCR1B = 0;     // Pulsweite, OCR1B <= 4095 (2^12)
  sei();         // Interrupts einschalten
}  // end Funktion