Einschaltverzögerung Bodenstrahler mit BM

[s-buali (Gast)]

Hallo zusammen,

ich habe folgendes Problem. Ich will in meine Hofeinfahrt 4-5
LED-Bodenstrahler einbauen. Nun kam mir die Idee einer verzögerten
Einschaltung der einzelnen Strahler. Sprich ähnlich wie bei einem
Lauflicht, soll beim Auslösen eines Bewegungsmelders zu erst der 1.
Strahler, dann zeitlich versetzt der 2. Strahler und so weiter,
eingeschalten werden. Bei erreichen des 4 bzw 5. Strahler sollen alle in
einer Art Selbsthaltung bleiben, bis die "Einschaltzeit" des
Bewegungsmelders alle Strahler gleichtzeitig abschält.

vielleicht noch zu Ergänzung:

habe die Bodenstrahler noch nicht gekauft um etwas flexibel zu bleiben.
Solche Bodenstrahler gibt es meines Wissens mit 230 V und 12 V.

Nun habe ich grobe Kenntnisse im Bereich Elektronik aber komme nicht
selber auf eine Lösung und bitte um Hilfe. Zeit-Relais sind mir
eigentlich generell zu teuer, da ich ja mehrere bräuchte.

Hat mir jemand eine gut umsetzbare und kostengünstige Lösung?

Vielen Dank schon im Voraus

Grüße

s-buali

[Frank (Gast)]

Ganz ohne Elektronik (-Kenntnisse) wirds nicht gehen. Das Projekt 
besteht aus vier Teilen, das macht die Sache sehr übersichtlich. Es geht 
sicher auch viel kompakter ("einfacher" - entsprechende Beiträge werden 
nicht lange auf sich warten lassen), aber dann ist es nicht gut für 
Anfänger geeignet.

a) die Leistungsschalter für die Lampen, optisch potentialgetrennt
b) die Steuerung für das Zeitverhalten
c) dem Empfänger/Auslöser
d) Netzteil für b u. c

Die kann man alle einzeln aufbauen, testen und wenn sie funktionieren 
zusammen in ein Gehäuse Setzen und in Betrieb nehmen.

zu a) da würde ich Solid-State-Relais nehmen. Einfach aunzusteuern, ohne 
Verschleiß

zu b) ICH würde da einen MC nehmen, es geht aber auch mit einem Zähler 
oder Schieberegister nebst Taktgenerator aus Logikbausteinen - je nach 
Vorliebe. Oder so einen LED-Bar-Controller für Audioanzeigen an einem 
sich ladenden Kondensator.

zu c) ist im einfachsten Fall ein Schalter. Oder ein IR- bzw. 
Funkempfäger. Kann auch ein Relais sein, was z.B. vom Gartentorantrieb 
nebenbei mit ausgelöst wird

zu d) ohne große Erklärung

[Hugo P. (portisch)]

Ich habe sowas für mein Stiegenlicht umgesetzt.
Aber um einen µC wirst du nicht rumkommen.

Mein System läuft auf 12V.

Wenn die 12V vom Netzteil kommen fährt der µC an. Je nach Input Pin 
PINB0 wird das Lauflicht von unten oder oben gestartet. Zusätzlich habe 
ich die SoftPWM übernommen, damit ich die Leitungslängen zu den 
einzelnen Lichter kompensiert werden kann.

PINB1 dient dazu, da eine Stiege nur 9 Lichter hat und die andere 11.
Über DelayBetweenPINs kann die Verzögerung der einzelnen Lichter 
eingestellt werden.

Funktioniert einwandfrei!

/*
    Eine 8-kanalige PWM mit intelligentem Lösungsansatz
 
    ATmega32 @ 8 MHz
 
*/
 
// Defines an den Controller und die Anwendung anpassen
 
#define F_CPU         12000000L          // Systemtakt in Hz
#define F_PWM         100L               // PWM-Frequenz in Hz
#define PWM_PRESCALER 8                  // Vorteiler für den Timer
#define PWM_STEPS     256                // PWM-Schritte pro Zyklus(1..256)
#define PWM_PORT_1    PORTD              // Port für PWM
#define PWM_DDR_1     DDRD               // Datenrichtungsregister für PWM
#define PWM_PORT_2    PORTC              // Port für PWM
#define PWM_DDR_2     DDRC               // Datenrichtungsregister für PWM
#define PWM_CHANNELS  11                 // Anzahl der PWM-Kanäle

// ab hier nichts ändern, wird alles berechnet
 
#define T_PWM (F_CPU/(PWM_PRESCALER*F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt
//#define T_PWM 1   //TEST
 
#if ((T_PWM*PWM_PRESCALER)<(111+5))
    #error T_PWM zu klein, F_CPU muss vergrössert werden oder F_PWM oder PWM_STEPS verkleinert werden
#endif
 
#if ((T_PWM*PWM_STEPS)>65535)
    #error Periodendauer der PWM zu gross! F_PWM oder PWM_PRESCALER erhöhen.   
#endif
// includes
 
#include <stdint.h>
#include <string.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
 
// globale Variablen

uint16_t PINFreigabe = 0;
uint8_t DelayBetweenPINs = 50;          // verzögerung zwischen den ausgängen
 
uint16_t pwm_timing[PWM_CHANNELS+1];          // Zeitdifferenzen der PWM Werte
uint16_t pwm_timing_tmp[PWM_CHANNELS+1];      
 
uint16_t  pwm_mask[PWM_CHANNELS+1];            // Bitmaske für PWM Bits, welche gelöscht werden sollen
uint16_t  pwm_mask_tmp[PWM_CHANNELS+1];        // ändern uint16_t oder uint32_t für mehr Kanäle
 
uint8_t  pwm_setting[PWM_CHANNELS];           // Einstellungen für die einzelnen PWM-Kanäle
uint8_t  pwm_setting_tmp[PWM_CHANNELS+1];     // Einstellungen der PWM Werte, sortiert
                                              // ändern auf uint16_t für mehr als 8 Bit Auflösung  
 
volatile uint8_t pwm_cnt_max=1;               // Zählergrenze, Initialisierung mit 1 ist wichtig!
volatile uint8_t pwm_sync;                    // Update jetzt möglich
 
// Pointer für wechselseitigen Datenzugriff
 
uint16_t *isr_ptr_time  = pwm_timing;
uint16_t *main_ptr_time = pwm_timing_tmp;
 
uint16_t *isr_ptr_mask  = pwm_mask;              // Bitmasken fuer PWM-Kanäle
uint16_t *main_ptr_mask = pwm_mask_tmp;          // ändern uint16_t oder uint32_t für mehr Kanäle
 
// Zeiger austauschen
// das muss in einem Unterprogramm erfolgen,
// um eine Zwischenspeicherung durch den Compiler zu verhindern
 
void tausche_zeiger(void) {
    uint16_t *tmp_ptr16;
    uint16_t *tmp_ptr8;                          // ändern uint16_t oder uint32_t für mehr Kanäle
 
    tmp_ptr16 = isr_ptr_time;
    isr_ptr_time = main_ptr_time;
    main_ptr_time = tmp_ptr16;
    tmp_ptr8 = isr_ptr_mask;
    isr_ptr_mask = main_ptr_mask;
    main_ptr_mask = tmp_ptr8;
}
 
// PWM Update, berechnet aus den PWM Einstellungen
// die neuen Werte für die Interruptroutine
 
void pwm_update(void) {
 
    uint8_t i, j, k;
    uint16_t m1, m2, tmp_mask;                   // ändern uint16_t oder uint32_t für mehr Kanäle    
    uint8_t min, tmp_set;                       // ändern auf uint16_t für mehr als 8 Bit Auflösung
 
    // PWM Maske für Start berechnen
    // gleichzeitig die Bitmasken generieren und PWM Werte kopieren
 
    m1 = 1;
    m2 = 0;
    for(i=1; i<=(PWM_CHANNELS); i++) {
        main_ptr_mask[i]=~m1;                       // Maske zum Löschen der PWM Ausgänge
        pwm_setting_tmp[i] = pwm_setting[i-1];
        if (pwm_setting_tmp[i]!=0) m2 |= m1;        // Maske zum setzen der IOs am PWM Start
        m1 <<= 1;
    }
    main_ptr_mask[0]=m2;                            // PWM Start Daten 
 
    // PWM settings sortieren; Einfügesortieren
 
    for(i=1; i<=PWM_CHANNELS; i++) {
        min=PWM_STEPS-1;
        k=i;
        for(j=i; j<=PWM_CHANNELS; j++) {
            if (pwm_setting_tmp[j]<min) {
                k=j;                                // Index und PWM-setting merken
                min = pwm_setting_tmp[j];
            }
        }
        if (k!=i) {
            // ermitteltes Minimum mit aktueller Sortiertstelle tauschen
            tmp_set = pwm_setting_tmp[k];
            pwm_setting_tmp[k] = pwm_setting_tmp[i];
            pwm_setting_tmp[i] = tmp_set;
            tmp_mask = main_ptr_mask[k];
            main_ptr_mask[k] = main_ptr_mask[i];
            main_ptr_mask[i] = tmp_mask;
        }
    }
 
    // Gleiche PWM-Werte vereinigen, ebenso den PWM-Wert 0 löschen falls vorhanden
 
    k=PWM_CHANNELS;             // PWM_CHANNELS Datensätze
    i=1;                        // Startindex
 
    while(k>i) {
        while ( ((pwm_setting_tmp[i]==pwm_setting_tmp[i+1]) || (pwm_setting_tmp[i]==0))  && (k>i) ) {
 
            // aufeinanderfolgende Werte sind gleich und können vereinigt werden
            // oder PWM Wert ist Null
            if (pwm_setting_tmp[i]!=0)
                main_ptr_mask[i+1] &= main_ptr_mask[i];        // Masken vereinigen
 
            // Datensatz entfernen,
            // Nachfolger alle eine Stufe hochschieben
            for(j=i; j<k; j++) {
                pwm_setting_tmp[j] = pwm_setting_tmp[j+1];
                main_ptr_mask[j] = main_ptr_mask[j+1];
            }
            k--;
        }
        i++;
    }
 
    // letzten Datensatz extra behandeln
    // Vergleich mit dem Nachfolger nicht möglich, nur löschen
    // gilt nur im Sonderfall, wenn alle Kanäle 0 sind
    if (pwm_setting_tmp[i]==0) k--;
 
    // Zeitdifferenzen berechnen
 
    if (k==0) { // Sonderfall, wenn alle Kanäle 0 sind
        main_ptr_time[0]=(uint16_t)T_PWM*PWM_STEPS/2;
        main_ptr_time[1]=(uint16_t)T_PWM*PWM_STEPS/2;
        k=1;
    }
    else {
        i=k;
        main_ptr_time[i]=(uint16_t)T_PWM*(PWM_STEPS-pwm_setting_tmp[i]);
        tmp_set=pwm_setting_tmp[i];
        i--;
        for (; i>0; i--) {
            main_ptr_time[i]=(uint16_t)T_PWM*(tmp_set-pwm_setting_tmp[i]);
            tmp_set=pwm_setting_tmp[i];
        }
        main_ptr_time[0]=(uint16_t)T_PWM*tmp_set;
    }
 
    // auf Sync warten
 
    pwm_sync=0;             // Sync wird im Interrupt gesetzt
    while(pwm_sync==0);
 
    // Zeiger tauschen
    cli();
    tausche_zeiger();
    pwm_cnt_max = k;
    sei();
}
 
// Timer 1 Output COMPARE A Interrupt
 
ISR(TIMER1_COMPA_vect) {
    static uint8_t pwm_cnt;        // ändern auf uint16_t für mehr als 8 Bit Auflösung
    uint16_t tmp;            // ändern uint16_t oder uint32_t für mehr Kanäle
 
    OCR1A += isr_ptr_time[pwm_cnt];
    tmp    = isr_ptr_mask[pwm_cnt];
 
    if (pwm_cnt == 0) {
    tmp &= PINFreigabe;
        PWM_PORT_1 = tmp;               // Ports setzen zu Begin der PWM
        PWM_PORT_2 = tmp >> 8;      // zusätzliche PWM-Ports hier setzen
    
        pwm_cnt++;
    }
    else {
    tmp &= PINFreigabe;
        PWM_PORT_1 &= tmp;              // Ports löschen
        PWM_PORT_2 &= tmp >> 8;      // zusätzliche PWM-Ports hier setzen
    
        if (pwm_cnt == pwm_cnt_max) {
            pwm_sync = 1;        // Update jetzt möglich
            pwm_cnt  = 0;
        }
        else pwm_cnt++;
    }
}
 
int main(void) {
  
  // Helligkeit für jeden PIN einstellen
  //                CN14 CN12 CN11 CN10 CN9  CN8  CN7  CN6  CN5  CN3  CN1
  uint8_t timing[PWM_CHANNELS]={243, 243, 244, 245, 246, 249, 249, 250, 253, 254, 255};
  uint8_t Anzahl = 9;
  uint8_t cnt;
  int i;

 
    // PWM Port einstellen
 
    PWM_DDR_1 = 0xFF;       // Port als Ausgang
    PWM_DDR_2 = 0x07;    // zusätzliche PWM-Ports hier setzen
  DDRB = 0x00;      // Port B als Input
  PORTB = 0x03;      // Pull Up auf PB0 und PB1 aktivieren
 
    // Timer 1 OCRA1, als variablen Timer nutzen
 
    TCCR1B = 2;             // Timer läuft mit Prescaler 8
    TIMSK1 |= (1<<OCIE1A);   // Interrupt freischalten
 
    sei();                  // Interrupts global einschalten
  
  // Abfrage ob 9 oder 11 Pins benutzt werden sollen
  if ((PINB & (1<<PINB1)) == 0)
    Anzahl = 11;
 
  
    memcpy(pwm_setting, timing, PWM_CHANNELS);
    pwm_update();
  
  // Abfrage in welche Richtung gezählt werden soll  
  if ((PINB & (1<<PINB0)) == 0)
  {
    for (i=0; i<Anzahl; i++)
    {
      PINFreigabe |= (1 << i);
      
      for (cnt=0;cnt<DelayBetweenPINs;cnt++)
      {
        _delay_ms(1);
      }
    }    
  }
  else
  {
    for (i=Anzahl-1; i>=0; i--)
    {
      PINFreigabe |= (1 << i);
      
      for (cnt=0;cnt<DelayBetweenPINs;cnt++)
      {
        _delay_ms(1);
      }      
    }    
  }
  
while(1);
}

[Der Axel (Gast)]

Funktioniert einwandfrei!

/*
    Eine 8-kanalige PWM mit intelligentem Lösungsansatz

    ATmega32 @ 8 MHz

*/

im Anhang...

[Der Axel (Gast)]

Beitrag "Re: Anzugsverzögerung Relais mit RC-Glied"
Beitrag "Re: Einschaltverzögerung bzw. Auschaltverzögerung für Relais"
Beitrag "Re: Nochmal Einschaltverzögerung: RC-Glied berechnen+Schaltplan"