Hallo,
wieder mal ein Update von mir nach etwas längerer Zeit. Ich habe ewig ein Problem gesucht, und endlich gefunden. Die Dimmung hat grundsätzlich funktioniert. Auch die Umschaltung zwischen An- und Abschnitt. Allerdings hatte ich sehr viel flackern in der Lampe. Die Messung mit dem Oszi hat bestätigt, dass bereits die Ansteuerung ab und zu für eine Halbwelle auf High oder Low bleibt. Für mich war das eindeutig ein Software-Fehler, da ich direkt am AVR-Pin gemessen habe. Ich habe tagelang versucht den Fehler zu finden und es war keiner da.
Der AVR-Pin hat einen Weg bekommen, vermutlich bei einem der vielen Versuche bei dem etwas in der Schaltung den Magic Smoke abgelassen hat. Ärgerlicheweise hat der Pin grundsätzlich funktioniert und nur so ca. jede 100. bis 500. Halbwelle etwas anderes gemacht als die Software ihm befahl.
Deshalb poste ich hier auch wie angefragt die Software bisher. Sie ist noch nicht ganz Stör-Unanfällig. Wenn z.B. ein anderer Verbraucher am Netz eine Spitze erzeugt kommt es vor, dass ein weiterer Nulldurchgang detektiert wird. Dies habe ich versucht zu umgehen, indem ich die Plausibilität der Halbwelle prüfe. Dadurch konnte ich dann erfolgreich das Aufblitzen der Lampe verhindern, wenn ein anderer Verbraucher Müll ins Netz wirft, ohne weitere Bauteile zu verwenden. Allerdings werden aktuell dadurch zwei Halbwellen keine Zündimpulse generiert. Die Lampe wird also kurz dunkler. Das ist zwar wesentlich besser, als ein aufblitzen, aber die Ursache werde ich schon noch finden...
Der nächste Plan ist jetzt erst mal den erwähnten Schaltregler für die Erzeugung der 5V zu ergänzen. Dadurch erhoffe ich mir eine stabiliere Versorung des Controllers. Der stürzt nämlich bei Störungen im Netz auch ab, was ich von den Atmels überhaupt nicht gewohnt bin. Durch den Schaltregler erhoffe ich mir eine bessere Filterung der VCC.
Viele Grüße
Andreas
Code: Alles auswählen
/**
Target: ATmega168 @ 16 MHz
IOs:
PB0 frei
PB1 frei
PB2 frei (war OC1B Ansteuerung PWM-Transistor)
PB3 MOSI
PB4 MISO
PB5 SCK
PC0 frei
PC1 frei
PC2 frei
PC3 frei
PC4 frei
PC5 frei
PD0 frei
PD1 frei
PD2 INT0 Schalter-Eingang
PD3 INT1 Nullgangs-Erkennung
PD4 frei
PD5 OUT Ansteuerung PWM-Transistor Phasenabschnitt
PD6 frei
PD7 frei
Timer 0: 100 Hz für allgemeine Zeitmessung
Prescaler: 1024
Timer 1: PWM-Steuerung und Messung der Periodendauer
OCR1A schaltet den PWM-Pin
OCR1B ist ein Timeout für die Messung der Periodendauer
Timer wird synchronisiert auf Netz-Sinus (Reset des Timer-Stands bei Null-Durchgang)
Annahme Netz-Sinus: 50 Hz --> Periodendauer: 20 ms
--> Clocks pro Periode: 320000 (@ FCPU = 16000000)
da aber jede Halbwelle gesteuert wird (100 Hz) --> Clocks pro Halbwelle: 160000 (@ FCPU = 16000000)
Maximale Timer-Auflösung (16 Bit): 65536 --> Prescaler minimum: 2,44 (@ FCPU = 16000000)
--> Prescaler: 8
--> Timer-Frequenz: 2 MHz
--> Ticks pro Periode: 40000
Annahme Netz-Sinus: 50 Hz --> Ticks pro Halbwelle: 20000
Annahme Netz-Sinus: 60 Hz --> Periodendauer: 16,66 ms
--> Clocks pro Periode: 266666 (@ FCPU = 16000000)
--> Clocks pro Halbwelle: 133333 (@ FCPU = 16000000)
--> Prescaler minimum: 2,03 (@ FCPU = 16000000)
--> Ticks pro Periode: 33333
--> Ticks pro Halbwelle: 16666
**/
#define AVRGCC
#include <avr/io.h>
#include <avr/sleep.h>
#include <util/atomic.h>
#include <compiler.h>
#define Taster_Entprellung 5 // * 10 ms
#define Taster_min_duration 3 // * 10 ms
#define Taster_dimm_duration 100 // * 10 ms
#define Taster_dimm_speed 3 // * 10 ms pro %-Step
#define Taster_doppel_tip_intervall 80 // * 10 ms
#define Halbwellendauer_min 15000 // ca. 66 Hz
#define Halbwellendauer_max 21500 // ca. 45 Hz
#define Halbwellendauer_init 20000 // 50 Hz Standard-Wert
#define Halbwellendauer_timeout 2000 // Timeout, falls kein Nulldurchgang erkannt wird
#define Halbwellendauer_Entprellung 100
#define Netzfrequenz_min 45
#define Lampe_off PORTD = (PORTD | (1<<PD5))
#define Lampe_on PORTD = ~(~PORTD | (1<<PD5))
#define Halbwellendauer_buffer_size 32
#define Halbwellendauer_buffer_divisor 5
typedef struct sSetup
{
U8 Taster_brightness_min;
U8 Taster_brightness_max;
bool Taster_is_Schalter;
bool Taster_direct_control;
U8 Lampe_brightness_min;
U8 Lampe_brightness_max;
U8 Lampe_power_on_brightness_min;
U8 Lampe_power_on_duration;
bool Dimmer_mode_Abschitt;
} tSetup;
typedef struct sDevice_state
{
bool Taster_state;
U8 Taster_value;
bool Taster_value_changed;
bool Lampe_state;
bool Lampe_last_state;
U8 Lampe_value;
U8 Lampe_power_on;
} tDevice_state;
volatile tSetup setup;
volatile tDevice_state state;
volatile U8 Sekunden_precounter = 0;
volatile U8 Taster_last_detection = 0xFF;
volatile U8 Taster_duration = 0;
volatile U8 Taster_dimm_timer = 0;
volatile bool Taster_dimm_direction = TRUE;
volatile U8 Taste_last_tip = 0xFF;
volatile U16 Lampe_PWM_value = 0;
volatile U8 Netzfrequenz_counter = 0;
volatile U8 Netzfrequenz = 0;
volatile bool Halbwelle_was_timeout = TRUE;
volatile U16 Halbwellendauer_current = 0;
volatile U16 Halbwellendauer_last = 0;
volatile U16 Halbwellendauer_buffer[Halbwellendauer_buffer_size];
volatile U8 Halbwellendauer_buffer_pointer = 0;
volatile U16 Halbwellendauer = Halbwellendauer_init;
ISR (TIMER0_COMPA_vect) // Timer 0 output compare A (ca. 100 Hz)
{
Sekunden_precounter++;
if (Sekunden_precounter == 100)
{
Sekunden_precounter = 0;
Netzfrequenz = Netzfrequenz_counter>>1; // gezählte Netzfrequenz übernehmen...
Netzfrequenz_counter = 0; // und neue Zähung starten
}
if (state.Lampe_power_on < 0xFF) // Lampe-Power-On Dauer zählen
state.Lampe_power_on++;
if (Taste_last_tip < 0xFF)
Taste_last_tip++;
if (Taster_last_detection < 0xFF)
Taster_last_detection++;
bool Taster_aktiv = (Taster_last_detection <= 2);
if (setup.Taster_is_Schalter)
{
state.Taster_state = Taster_aktiv; // Bei Schalter-Modus einfach den Wert direkt übernehmen:
}
else // ansonsten Taster auswerten:
{
if (Taster_aktiv)
{ // wenn Taster betätigt:
if (Taster_duration < 0xFF) // ...dann Betätigungs-Zeit zählen
Taster_duration++;
if (Taster_duration >= Taster_dimm_duration) // Taster lange genug gedrückt zum dimmen?
{
if (Taster_dimm_timer >= Taster_dimm_speed) // Dimm-Geschwindigkeit einhalten
{
Taster_dimm_timer = 0;
if (Taster_dimm_direction) // Dimm-Schritt Berechnung
{
state.Taster_value++; // Heller
if (state.Taster_value >= setup.Taster_brightness_max) // Bei Überlauf Dimm-Richtung ändern
{
state.Taster_value = setup.Taster_brightness_max;
Taster_dimm_direction = FALSE;
}
}
else
{
state.Taster_value--; // Dunkler
if (state.Taster_value <= setup.Taster_brightness_min) // Bei Überlauf Dimm-Richtung ändern
{
state.Taster_value = setup.Taster_brightness_min;
Taster_dimm_direction = TRUE;
}
}
state.Taster_state = TRUE; // Auf jeden Fall Status auf "Ein", wenn gedimmt wird
}
else
Taster_dimm_timer++; // Dimm-Geschwindigkeits-Timer weiterzählen
}
}
else // Taster wurde losgelassen:
{
if (Taster_last_detection == Taster_Entprellung) // Schalter lange genug losgelassen (Entprellung)?
{
if (Taster_duration >= Taster_min_duration) // Kurze Impulse ignorieren (ebenfalls Entprellung)
{
if (Taster_duration < Taster_dimm_duration) // Taster war kurz getippt?
{
if (Taste_last_tip <= Taster_doppel_tip_intervall) // dann prüfen, ob letzter kurzes Tipp im Doppel-Tipp-Intervall ist?
{
state.Taster_state = TRUE; // wenn ja, dann Status auf "Ein" mit voller Helligkeit:
state.Taster_value = setup.Taster_brightness_max;
Taste_last_tip = 0xFF;
Taster_dimm_direction = FALSE;
}
else
{
state.Taster_state = !state.Taster_state; // wenn kein Doppel-Tipp, dann einfach Zustand wechseln:
Taste_last_tip = 0; // Timer für Doppel-Tipp erkennung starten
}
}
else
Taster_dimm_direction = !Taster_dimm_direction; // Taster war lange gedrückt (Dimmen) --> Dimm-Richtung umkeheren für nächsten Dimm-Vorgang
}
Taster_duration = 0; // Tastdauer zurücksetzen
}
}
}
}
ISR (INT0_vect) // INT0 (Taste-Eingang, kommt bei Betätigung 100x pro Sekunde)
{
Taster_last_detection = 0;
}
ISR (INT1_vect) // INT1 (Null-Durchgang Netzspannung)
{
if (Halbwelle_was_timeout)
Halbwellendauer_current = 0; // Bei Timeout, Halbewellen-Dauer verwerfen
else
Halbwellendauer_current = TCNT1; // ansonsten Halbwellen-Dauer festhalten
// PWM-Timer (Timer1) steuern:
TCNT1 = 0; // Timer auf Null-Durchgang synchronisieren
TIFR1 = (1<<OCF1B) | (1<<OCF1A); // OCR1A und OCR1B zurücksetzen, falls noch welche anstehen
OCR1A = Lampe_PWM_value; // neuen PWM-Wert übernehmen
OCR1B = Halbwellendauer + Halbwellendauer_timeout; // neuen Timeout übernehmen
bool Halbwellendauer_plausibel = (!Halbwelle_was_timeout && (Halbwellendauer_current >= Halbwellendauer_min) && (Halbwellendauer_current <= Halbwellendauer_max));
if (!Halbwellendauer_plausibel && !Halbwelle_was_timeout) // wenn Halbwellendauer unplausibel, dann letzte Dauer mit einbeziehen (um Störimpulse zu ignorieren):
{
// Funktioniert noch nicht.
U16 Halbwellendauer_temp = Halbwellendauer_current + Halbwellendauer_last; // vermutliche Halbwellendauer ohne Störimpuls berechnen
if ((Halbwellendauer_temp >= Halbwellendauer_min) && (Halbwellendauer_temp <= Halbwellendauer_max))
{
Halbwellendauer_current = Halbwellendauer_temp; // wenn neue Dauer plausibel, dann übernehmen
Halbwellendauer_plausibel = TRUE;
}
}
if (Halbwellendauer_plausibel)
{
if (setup.Dimmer_mode_Abschitt)
{
if (state.Lampe_state) // Wenn Lampe an bei Phasen-Abschnitts-Modus, dann Lampe einschalten
Lampe_on;
}
else
Lampe_off; // Bei Phasenanschnitt Lampe im Null-Durchgang auf jeden Fall ausschalten
Netzfrequenz_counter++;
Halbwellendauer_last = 0;
}
else
Halbwellendauer_last = Halbwellendauer_last + Halbwellendauer_current; // Wenn Halbwellendauer unplausibel, dann Dauer addieren
Halbwelle_was_timeout = FALSE; // Neue Messung, also Timeout-Flag zurücksetzen
}
ISR (TIMER1_COMPA_vect) // Timer 1 output compare A (PWM-Wert der Lampe erreicht)
{
if (setup.Dimmer_mode_Abschitt)
Lampe_off; // bei Phasenabschnitt Phasenabschnitt Lampe ausschalten
else
{
if (state.Lampe_state) // Bei Phasenanschnitt und wenn Lampe an, dann jetzt einschalten:
Lampe_on;
}
}
ISR (TIMER1_COMPB_vect) // Timer 1 output compare B (Timeout erreicht, Halbwelle zu lang)
{
Lampe_off;
Halbwelle_was_timeout = TRUE;
}
int main (void)
{
DDRB = 0b00000111; // IOs konfigurieren und initialisieren:
PORTB = 0b11111111;
DDRC = 0b00000000;
PORTC = 0b11111111;
DDRD = 0b00100010;
PORTD = 0b11110010;
EICRA = (1<<ISC10) | (1<<ISC00); // steigende und fallende Flanke für INT0 und INT1 konfigurieren
EIMSK = (1<<INT1) | (1<<INT0); // INT0 und INT1 aktivieren
// Timer 0 konfigurieren (CTC-Mode 2)
TCCR0A = (1<<WGM01); // CTC-Mode 2, normal port operation
TCCR0B = (1<<CS02) | (1<<CS00); // CTC-Mode 2, Prescaler auf 1024
OCR0A = (F_CPU / 1024l / 100l); // output compare A auf 100 Hz
TIMSK0 = (1<<OCIE0A); // output compare A Interrupt aktivieren
// Timer 1 konfigurieren (Mode 0)
TCCR1A = 0; // Mode 0, normal port operation
TCCR1B = (1<<CS11); // Mode 0, PreScaler auf 8
TCCR1C = 0;
TIMSK1 = (1<<OCIE1A) | (1<<OCIE1B); // output compare A und B Interrupt aktivieren
OCR1A = 0; // PWM-Position setzen (0%)
OCR1B = Halbwellendauer + Halbwellendauer_timeout; // Maximal-Wert (Halbwellen-Dauer) initialisieren
for (U8 i1 = 0; i1 < Halbwellendauer_buffer_size; i1++) // Perioden-Dauer Durchschnitts-Buffer initialisieren
Halbwellendauer_buffer[i1] = Halbwellendauer;
setup.Taster_brightness_min = 10;
setup.Taster_brightness_max = 100;
setup.Taster_is_Schalter = FALSE;
setup.Taster_direct_control = TRUE;
setup.Lampe_brightness_min = 20;
setup.Lampe_brightness_max = 100;
setup.Lampe_power_on_brightness_min = 30;
setup.Lampe_power_on_duration = 50;
setup.Dimmer_mode_Abschitt = TRUE;
state.Taster_state = FALSE;
state.Taster_value = 30;
state.Lampe_state = FALSE;
state.Lampe_value = 30;
state.Lampe_power_on = 0;
Lampe_off;
_delay_ms (100);
sei (); // Interrupts aktivieren
while (1)
{
if (state.Taster_value < setup.Taster_brightness_min) // Taster-Werte auf Grenzen prüfen und ggf. korrigieren:
state.Taster_value = setup.Taster_brightness_min;
if (state.Taster_value > setup.Taster_brightness_max)
state.Taster_value = setup.Taster_brightness_max;
if (setup.Taster_direct_control) // wenn der Taster die Lampe direkt steuert, dann Werte übernehmen:
{
state.Lampe_state = state.Taster_state;
state.Lampe_value = state.Taster_value;
}
if (state.Lampe_value < setup.Lampe_brightness_min) // Lampen-Werte auf Grenzen prüfen und ggf. korrigieren
state.Lampe_value = setup.Lampe_brightness_min;
if (state.Lampe_value > setup.Lampe_brightness_max)
state.Lampe_value = setup.Lampe_brightness_max;
if (state.Lampe_state && !state.Lampe_last_state) // Wurde die Lampe eingeschaltet?
state.Lampe_power_on = 0; // dann Power-On-Timer der Lampe starten
state.Lampe_last_state = state.Lampe_state;
U16 Halbwellendauer_new;
ATOMIC_BLOCK (ATOMIC_FORCEON)
{
Halbwellendauer_new = Halbwellendauer_current;
Halbwellendauer_current = 0;
}
if ((Halbwellendauer_new >= Halbwellendauer_min) && // gemessene Halbwellen-Dauer plausibel?
(Halbwellendauer_new <= Halbwellendauer_max))
{ // dann Halbwellen-Dauer im Glättungs-Buffer ablegen:
Halbwellendauer_buffer[Halbwellendauer_buffer_pointer] = Halbwellendauer_new;
Halbwellendauer_buffer_pointer++;
if (Halbwellendauer_buffer_pointer >= Halbwellendauer_buffer_size)
Halbwellendauer_buffer_pointer = 0;
U32 temp = 0; // Neue Durchschnitts-Perioodendauer berechnen
ATOMIC_BLOCK (ATOMIC_FORCEON)
{
for (U8 i1 = 0; i1 < Halbwellendauer_buffer_size; i1++)
temp = temp + Halbwellendauer_buffer[i1];
temp = temp>>Halbwellendauer_buffer_divisor; // Durchschnitt berechnen
ATOMIC_BLOCK (ATOMIC_FORCEON)
{
Halbwellendauer = temp;
}
}
}
U32 PWM_value = state.Lampe_value; // Neuen PWM-für Lampe Wert berechnen:
if ((state.Lampe_power_on < setup.Lampe_power_on_duration) && // Ist die Lampe noch in Power-Up-Zeit?
(PWM_value < setup.Lampe_power_on_brightness_min)) // und die Helligkeit kleiner als die minimale Power-Up Helligkeit?
PWM_value = setup.Lampe_power_on_brightness_min; // dann Mindest-Helligkeit übernehmen
if (!setup.Dimmer_mode_Abschitt) // Bei Phasenanschnitt wird der Zeitpunkt "von hinten" angenommen
PWM_value = setup.Lampe_brightness_max - PWM_value;
PWM_value = PWM_value * (U32)Halbwellendauer;
PWM_value = PWM_value / (U32)setup.Lampe_brightness_max;
if (Lampe_PWM_value != PWM_value) // Wert nur übernehmen, wenn er sich auch geändert hat:
{
ATOMIC_BLOCK (ATOMIC_FORCEON)
{
Lampe_PWM_value = PWM_value;
}
}
}
return (0);}
.
Irgendwas habe ich an diesem Konzept noch nicht richtig verstanden.