Phasenanschnittssteuerung mit AVR

Hallo zusammen, ich suche ein Beispiel für eine einfache Schaltung für eine Phasenanschnittssteuerung.
Das Ziel ist die Geschwindigkeit einer Bohrmaschine (500W) zu steuern.
Ich habe da eine schöne alte Flott im Keller wo mal eine Schaltung dafür drinn war, die wohl abgeraucht ist und dann leider entfernt wurde.
Dies will ich nun richtig Chic mit einem AVR und Display aufbauen.

Bis jetzt finde ich immer nur alte Beiträge in denen steht wie einfach das doch ist, aber keine konkreten Vorschläge.
Wenn es ein "Standard-Problem" ist, sollte hierfür sogar schon etwas Bascom- oder C-Code existieren ...

Die Triac-Ansteuerung würde ich mit einem MOC 3020 angehen, aber wie baut man möglichst einfach und geschickt eine netzgetrennte Synchronisation auf?
Kann ich mit dem MOC 3020 zu einem beliebigen Phasenwinkel zünden?

Es wäre schön dieses Rad nicht neu erfinden zu müssen, daher wäre ich für Links oder Vorschläge und Erfahrungen sehr dankbar.

Meinst Du so was:

Code:

---

/****************************************************
Chip type          : ATmega8
Program type        : Application
Clock frequency    : 8,000000 MHz
Memory model        : Small
External SRAM size  : 0
Data Stack size    : 256
*****************************************************/
#include <mega8.h>
#include <delay.h>

volatile bit ub_newcalc=0;                /* Flag Phasenwinkel neu berechnen */
volatile bit ub_ms100=0;                  /* Flag, das alle 100ms durch Counter 0 getriggert wird */
volatile unsigned char uc_init=0;          /* Counter für die Phasendauerermittlung */
volatile unsigned int ui_phasenwinkel;    /* Berechneter Timerwert für den Phasenwinkel */
volatile unsigned int ui_leistungswinkel;  /* Wert für den Phasenanschnittwinkel */
const unsigned int ui_defaultwinkel=10000;  /* Defaultwert bei 50 Hz= 10000, bei 60 Hz= 8333 */
volatile unsigned int ui_oldtimer=0;        /* Zwischenspeicher für den vorherigen Timerwert */
volatile signed long int li_leistung;    /* Gewünschte Leistung in 0,1% Schritten */
volatile unsigned char uc_tim0counter=0;    /* Überlaufcounter für timer 0*/

#asm
.EQU PORTB=0x18
#endasm

// External Interrupt 0 service routine
interrupt [EXT_INT0] void ext_int0_isr(void)
{
#asm("wdr");
if(uc_init>0&&uc_init<5)  /* Zweiter Schritt der Initialisierung */
    {
    ui_phasenwinkel+=(TCNT1-ui_oldtimer);
    ui_oldtimer=TCNT1;
    uc_init++;
    }
else
    {
    if(uc_init==0)            /* Erster Schritt der Initialisierung */
        {
        ui_phasenwinkel=0;
        ui_oldtimer=TCNT1;
        uc_init=1;
        }
    else
        {
        OCR1A=TCNT1+ui_leistungswinkel; /* normaler Betrieb */
        ub_newcalc=1;  /* Werte können neu berechnet werden */
        if(li_leistung<990)
            {
            PORTB.3=1;      /* Zündspannung im Nulldurchgang abschalten */
            };
        };
    };
}

// Timer 0 overflow interrupt service routine
interrupt [TIM0_OVF] void timer0_ovf_isr(void)
{
uc_tim0counter++;
if(uc_tim0counter>2)
    {
    uc_tim0counter=0;
    ub_ms100=1;                  /* Flag für "100ms" vorbei setzen */
    };
// Place your code here

}

#pragma savereg-  /* Retten der Register abschalten */
// Timer 1 output compare A interrupt service routine
interrupt [TIM1_COMPA] void timer1_compa_isr(void)
{
// Inline Assembler für maximale Geschwindigkeit
#asm
push r26;              Register retten
in r26,SREG
push r26
lds r26,_uc_init;      Initialisierung abgeschlossen ?
cpi r26,5
brcs endintcp0
cbi PORTB,3;            Zündpuls ausgeben
endintcp0:
pop r26;                Register zurückspielen
out SREG,r26
pop r26
#endasm
}
#pragma savereg+  /* Retten der Register aktivieren */

// Phasenwinkel berechnen
void calcphase(void)
{
uc_init=0;
while (uc_init<5);            /* Warten auf Periodendauerermittlung */
ui_phasenwinkel=ui_phasenwinkel/((uc_init-1));

// Abfangen ungültiger Phasenwerte
if (ui_phasenwinkel>(ui_defaultwinkel+1000)||ui_phasenwinkel<(ui_defaultwinkel-1000))
    {
    ui_phasenwinkel=ui_defaultwinkel;
    };
ui_phasenwinkel-=200;          /* Phasenwinkel auf die sichere Seite ziehen */
}



#define ADC_VREF_TYPE 0xC0

// Read the AD conversion result
unsigned int read_adc(unsigned char adc_input)
{
ADMUX=adc_input | (ADC_VREF_TYPE & 0xff);
// Delay needed for the stabilization of the ADC input voltage
delay_us(10);
// Start the AD conversion
ADCSRA|=0x40;
// Wait for the AD conversion to complete
while ((ADCSRA & 0x10)==0);
ADCSRA|=0x10;
return ADCW;
}

// Declare your global variables here

void main(void)
{


// Input/Output Ports initialization
// Port B initialization
// Func7=In Func6=In Func5=In Func4=Out Func3=Out Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=0 State3=1 State2=T State1=T State0=T
PORTB=0x08;
DDRB=0x18;

// Port C initialization
// Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTC=0x00;
DDRC=0x00;

// Port D initialization
// Func7=In Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
// State7=T State6=T State5=T State4=T State3=T State2=T State1=T State0=T
PORTD=0x00;
DDRD=0x00;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 7,813 kHz
TCCR0=0x05;
TCNT0=0x00;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: 1000,000 kHz
// Mode: Normal top=FFFFh
// OC1A output: Discon.
// OC1B output: Discon.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer 1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: On
// Compare B Match Interrupt: Off
TCCR1A=0x00;
TCCR1B=0x02;
TCNT1H=0x00;
TCNT1L=0x00;
ICR1H=0x00;
ICR1L=0x00;
OCR1AH=0x00;
OCR1AL=0x00;
OCR1BH=0x00;
OCR1BL=0x00;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: Timer 2 Stopped
// Mode: Normal top=FFh
// OC2 output: Disconnected
ASSR=0x00;
TCCR2=0x00;
TCNT2=0x00;
OCR2=0x00;

// External Interrupt(s) initialization
// INT0: On
// INT0 Mode: Rising Edge
// INT1: Off
GICR|=0x40;
MCUCR=0x03;
GIFR=0x40;

// Timer(s)/Counter(s) Interrupt(s) initialization
TIFR=0x11;
TIMSK=0x11;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
SFIOR=0x00;

// ADC initialization
// ADC Clock frequency: 125,000 kHz
// ADC Voltage Reference: Int., cap. on AREF
ADMUX=ADC_VREF_TYPE & 0xff;
ADCSRA=0x86;

// Ist der Shutdown Eingang freigegeben ?
while (PIND.5==0);


// 100ms Warten
delay_ms(100);

// 2 Nulldurchgänge abwarten
while(PIND.2==0);
while(PIND.2>0);
while(PIND.2==0);
while(PIND.2>0);


GIFR=0x40;              /* Anstehende Interupts löschen */

// EEPROM Variablen holen
li_leistung=0;


// Watchdog Timer initialization
// Watchdog Timer Prescaler: OSC/1024k
#pragma optsize-
WDTCR=0x1E;
WDTCR=0x0E;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif

// Global enable interrupts
#asm("sei")

//Phasenwinkel ermitteln
calcphase();

while (1)
      {
      li_leistung=read_adc(0);
      li_leistung=(li_leistung*1000)/1023;        /* Auf 1000 normieren */
      if(li_leistung>1000){li_leistung=1000;};    /* Überläufe verhindern */
      // Enable Eingang gesperrt Ausgang deaktiviert
      while(PIND.5==0)
        {
        PORTB.3=1;                      /* Zündausgang gesperrt */
        TIMSK&=0b11101111;              /* Weitere Zündimpulse durch sperren des Timerinterrupts verhindern */
        TIFR|=0b000100000;                /* Anstehende Zündimpulse löschen */
        calcphase();                    /* Phasenwinkel berechnen */
        delay_ms(100);
        li_leistung=0;
        if(li_leistung>1000)
            {
            li_leistung=1000;              /* Ungültige Werte abfangen */
            PORTB.4=1;                    /* Full LED an */
            };
        };
     
           
      // Routine zur Leistungsregelungseinstellung, wird in INT0 getriggert
      if(ub_newcalc>0)
        {
        if(li_leistung<5)                    /* Weniger als 0,5% Leistungsanforderung schaltet den Dimmer ab */
            {
            li_leistung=0;
            TIMSK&=0b11101111;              /* Weitere Zündimpulse durch sperren des Timerinterrupts verhindern */
            TIFR|=0b00010000;                /* Anstehende Zündimpulse löschen */
            ub_newcalc=0;
            calcphase();
            }
        else
            {
            if(li_leistung>=995)                /* Mehr als 99,5% Leistungsanforderung gibt Daueraktivierung auf den Zündausgang */
                {
                TIMSK&=0b11101111;              /* Weitere Zündimpulse durch sperren des Timerinterrupts verhindern */
                TIFR|=0b00010000;                /* Anstehende Zündimpulse löschen */
                PORTB.3=0;                      /* Zündausgang dauerhaft aktivieren */
                ub_newcalc=0;
                }
            else
                {
                ui_leistungswinkel=ui_phasenwinkel-((li_leistung*ui_phasenwinkel)/1000); /* Delta Timerwert für Leistung berechnen */
                TIFR|=0b00010000;                /* Anstehende Zündimpulse löschen */
                TIMSK|=0b00010000;              /* Zündimpulse wieder freigeben */
                ub_newcalc=0;
                };
            }
        };
        // Full Power LED
      if(li_leistung>990)
        {
        PORTB.4=1;        /* Full Power LED ein */
        }
      else
        {
        PORTB.4=0;          /* Full Power LED aus  */
        }

      };
}

---

Hallo!

Vielleicht eignet sich das: http://www.pollin.de/shop/dt/Nzg4OTc...15_0900_9.html ? ;)

Vielen Dank für die schnellen Antworten!

@PICture: Nee - mit genau so einem Schrott habe ich die Maschine gekauft - da ist sogar nur ein normaler Lichtdimmer drinn.
Eine Drehzahl kann man damit einstellen, aber die knickt sofort ein wenn Last auf den Bohrer kommt. Auf Dauer bekommr man da eine Krise.

@wkrug: Ja - das kommt schon in die richtige Richtung.
So in der Art würde ich es gerne umsetzen, allerdings bin ich einer von den C-gehassten Bascom-Programmierern. :)
In dem Beispiel wird auch so viel direkt auf den Registern rumgeorgelt ...

Inspiration bräuchte ich eher noch für die Schaltung.
Die Ansteuerung des Triacs werde ich wohl auf jeden Fall mit einem MOC 3023 machen.
Das ist schön minimalistisch und im Datenblatt gibt es auch schon eine Applikation für induktive Lasten.

Jetzt ist nur noch die Frage wie ich den Nulldurchgang mit dem Controller detektiere?

1. Optokoppler zurück?
Hat den Nachteil wie man die LED bestromt - vor allem für beide Halbwellen.
Gleichrichten und dann Kondensator oder nur Widerstand oder Beides?
Gibt alles auch wieder viel Phasenverschiebung und evtl. ein paar dickere Bauteile.

2. Ohne Netztrennung nur mit Koppelkondensator und hochohmigen Widerständen.
Wäre schön einfach aber halt ohne Netztrennung.

3. Stromversorgung mit Trafo und Signal von der Sekundärspule nehmen.
Habe von Pollin aber noch so schöne Schaltnetzteile als Spannungsversorgung für 1,- Eurone.

Zitat:

---

Zitat von lsmod

Jetzt ist nur noch die Frage wie ich den Nulldurchgang mit dem Controller detektiere?

---

Nur als Lektüre: https://www.roboternetz.de/community...mmer-Schaltung . ;)

Zitat:

---

1. Optokoppler zurück

---

Das ist die Variante die ich nehmen würde. Du brauchst ja nicht jeden Nulldurchgang detektieren, sondern nur den, wenn die Halbwelle vom negativen in den positiven Bereich wechselt oder umgekehrt. Also einmal pro Periode.
Die Zündzeiten für die zweite Halbwelle kannst Du ja dann ausrechnen.

Eine andere Möglichkeit wäre zwei Optokoppler mit antiparallel geschalteten LED's und parallelgeschalteten Ausgangstransistoren an einem gemeinsamen Pullup Widerstand zu legen. Dadurch bekommst Du Nadelimpulse in den Nulldurchgängen.
Alternativ kannst Du einem Optokoppler auch einen Brückengleichrichter vorschalten.

Die Variante 2 wär mir zu gefährlich und man kann ohne Trenntrafo nichts debuggen.

Variante 3 hört sich im ersten Augenblick sehr gut an. Allerdings generiert ein Trafo Phasenverschiebungen zwischen dem Eingangs und dem Ausgangssignal, die zudem Lastabhängig sind, die Du wieder kompensieren musst. Beim Wechseln des Trafos auf einen anderen Typ geht das Spielchen dann wieder von vorne los.
Gerade Phasenverschiebungen in den Nulldurchgangsdetektoren kann man schon gar nicht brauchen.

Als Leistungstreiber hab ich nen MOC3021 verwendet. Dieser treibt einen Leistungstriac vom Typ BTA 41 600. Der dann doch Reserven hat.

Erst verlangst Du C - Code, dann moserst Du, wenn Du welchen kriegst ;) .

Letztlich funktioniert so eine Phasenanschnittsteuerung so.
Die Periodendauer wird auf Counts eines Timers umgerechnet.
Dann wird der gewünschte Phasenwinkel vom Zählerwert für eine Halbwelle abgezogen.
Der ermittelte Wert wird dann in ein Comparematch Register geschrieben. Der dann aufgerufene Comparematch Interrupt zündet dann den Triac.
Wenn du nur einen Nulldurchgang pro Periode zur Verfügung hast, musst Du dafür sorgen, das die Triac Ansteuerung vor dem nächsten Nulldurchgang wieder gelöscht wird und auch der gewünschte Phasenwinkel für die 2te Halbwelle wieder zu einer Zündung führt.

Der Nullduchgangsdetektor synchronisiert diesen Timer.
Das kann man durch setzen des Zählerwertes auf 0 erreichen, oder den Zähler frei laufen lassen und den Counterwert beim Nulldurchgang abspeichern.
Ich nutze lieber die Variante mit dem freilaufenden Counter, weil man sich dadurch nicht in das Timing des Timers einmischt und somit keinen Phasenjitter erhält.

Die Bascom Jünger machen das lieber anders, aber das soll ja nicht mein Problem sein.

Noch was - Eine Bohrmaschine ist eine induktive Last, die eine Phasenverschiebung zwischen Spannung und Strom verursacht.
Dein Nulldurchgangsdetektor wertet aber nur die Spannung aus. Beim Nulldurchgang des Stromes müsste der Triac erneut gezündet werden.
Ich umgehe das, indem ich die Ansteuerung für den Triac bis zum nächsten Nulldurchgang aufrecht erhalte und so der Triac auf jeden Fall wieder nachgezündet wird.

Die, leider nicht mehr erhältlichen, Phasenanschnitt IC's hatten da noch einen zusätzlichen Stromsensor drin, der die IC- Elektronik zur Nachzündung veranlasste.

Zitat:

---

Zitat von PICture

Nur als Lektüre: https://www.roboternetz.de/community...mmer-Schaltung . Bild hier  

---

Die Lektüre ist gut - Danke!

Lösungen 1+3 sind auch schon ausgearbeitet worden - sehr schön.

Fehlt noch Lösung 2.
Z.B. in der Form das man einen 3M9 Widerstand (oder besser 2 X 1M8 in Reihe) und eine ZPD 4V7 (Oder z.B. weisse LED) nimmt.
Dies dann direkt auf den Comparator-Eingang oder AD des Microcontrollers.
Das benötigt nur sehr wenige Bauelemente mit kleiner Leistung.

Diese Lösung hat auch was, aber eigentlich gefällt mir Lösung 3 mit Trafo eigentlich noch am besten.

Zitat:

---

Zitat von wkrug

Die Variante 2 wär mir zu gefährlich und man kann ohne Trenntrafo nichts debuggen.

---

Zwiebelt nur ein bisschen und man sollte besser keine Programmierschnittstelle dran haben wenn Netz da ist. :)
Nee - im Ernst - das ist wirklich eine unschöne Lösung.
Und auf jeden Fall keine Empfehlung - vor allem für unerfahrene Bastler.

Die Spannungsversorgung würde in diesem Fall natürlich über ein Schaltnetzteil erfolgen.
An sonsten kann man besser direkt Variante 3 nehmen.

Zitat:

---

Zitat von wkrug

Erst verlangst Du C - Code dann moserst Du, wenn Du welchen kriegst :wink: .

Die Bascom Jünger machen das lieber anders, aber das soll ja nicht mein Problem sein.

---

Nun - C habe ich auch erst an 2. Stelle genannt. ;)
Es ist ja nicht so das der C-Code unverständlich ist - inspirierend allemal.

Aber ich bekenne mich doch als Bascom Jünger.
Ich konnte mich mit C leider nie anfreunden.

Das heisst aber nicht das die programmierte Lösung deswegen grundsätzlich anders umgesetzt wird.

Zitat:

---

Zitat von wkrug

Noch was - Eine Bohrmaschine ist eine induktive Last, die eine Phasenverschiebung zwischen Spannung und Strom verursacht.
Dein Nulldurchgangsdetektor wertet aber nur die Spannung aus. Beim Nulldurchgang des Stromes müsste der Triac erneut gezündet werden.
Ich umgehe das, indem ich die Ansteuerung für den Triac und so der Triac auf jeden Fall wieder gezündet wird.

---

Danke für Deine textuelle Programmbeschreibung.
Die ist ein schöner Leitfaden für eine Umsetzung.

Ich würde nun auch einen fortlaufenden Zähler nehmen und die Ansteuerung bis zum nächsten Nulldurchgang aufrecht erhalten.

Du hast mich nun aber auch wieder für die Variante 1. begeistern können.
Ich möchte dort aber ungern zu viele Bauteile drin haben.
Vor allem aber auch keine Bratwiderstände.
Hier müsste man noch den optimalen Kompromiss finden.

Vielleicht ist dieser Vorschlag trotzdem schon die Lösung:
https://www.roboternetz.de/community...3&d=1321542559
Leider hat demmy nicht mehr geschrieben ob diese so funktioniert.

Hab hier nochmal einen Vorschlag für eine Nulldurchgangserkennung, hatte ich mal auf µC.net gefunden, ist galvanisch getrennt und du kannst dir den Pegel, den du zum schluss haben willst, selbst raussuchen. Die schaltung sollte selbst auf einem externen Interrupt funktionieren.


Anhang 21691

Anhang 21692


MfG Dennis

Danke - dies ist auch eine schöne schmale Lösung.

Ich denke ich werde nun aber einfach mal ein paar Bauelemente mehr investieren und die Schaltung mit den beiden Transistoren und einem Optokoppler aufbauen.
Letzten Endes hat mich diese überzeugt - trotz des höheren Bauteileaufwands.

Bin gerade dabei eine Bestellung fertig zu machen.
Wenn die da ist werde ich das dann aufbauen + programmieren.
Das wird wohl einiges dauern, aber ich werde Euch auf jeden Fall eine Rückmeldung geben.

Beim "Theaterzentrum" Dimmer wurde ein CNY65 als Nulldurchgangsdetektor verwendet.
Wär auch eventuell auch sinnvoll, weil der größere Sicherheitsabstände zwischen Primär und Sekundärseite hat.

Die von Dir vorgeschlagen Schaltung ist genau die Mit den antiparallel geschalteten LED's.
Lediglich die Ausgänge sind anders verschaltet und ohne?! Strombegrenzungswiderstände.

schaut euch mal den LTV814 von Liteon an, da sind 2 antiparallel LEDs verbaut, einfach mit einem passenden Widerstand ans Netz hängen und fertig

Hallo,

ich habe die Schaltung vor ein paar Tagen endlich aufgebaut (s. Bild).
Leider scheint diese aber nicht zu funktionieren.

Ich habe heute die Schaltung noch mal kontrolliert und konnte keinen Verdrahtungsfehler finden.
An dem Kondensator liegen brav 5V an, aber hinter dem Optokoppler sind keine Impulse mit dem Oszi zu sehen.
Der Transi im Opto schaltet gegen Masse und ist einfach an einen Eingang vom AVR mit aktivierten Pullup geschaltet.

Die Schaltung hat nur geringfügige Änderungen gegenüber der hier veröffentlichten Schaltung:
R11 + R12 habe ich in 680K zusammengefasst.
R7 + R14 habe ich in 220K zusammengefasst.
C1 ist ein Elko mit 10µF/63V
Statt BC547 habe ich BC546B verbaut.
Statt einem PC817 habe ich einen 4N25 verbaut.

Zur Zeit sehe ich in den Änderungen keinen Grund warum es nicht trotzdem funktionieren sollte?

Ich kann die Schaltung zur Zeit leider nicht weiter analysieren, da mir kein Trenntrafo zur Verfügung steht.
Und ob Impulse an den Transistoren vorhanden sind kann ich leider mit einem Multimeter nicht überprüfen.

Ein Schaltplan wäre viel aussagekräftiger gewesen, weis ja keiner wie du was verschalten hast.

Ich dachte das wäre klar - blätter mal zurück.

Das ist die Schaltung die ich aufgebaut habe:
https://www.roboternetz.de/community...3&d=1321542559

schau dir mal das hier an, schimpft sich AC-Optokoppler z.B. IL250, LTV814... Sparst dir damit den Gleichrichter(oder deine 4 Dioden) komplett ein. Zu beachten, der Widerstand R1 spannungsfest sein am besten 2 oder 3 Metalltypen die für 500V Dauerspannung ausgelegt sind in Reihe. Also links 230V drauf und rechts wertest du die fallende Flanke aus, die bei jeder Halbwelle leicht verzögert(etwa bei 2 V) auftritt. R1 so berechnen das auch ein Peak im Netz die Dioden im Optokoppler nicht grillt und R2 so das du Steile Flanken zum auswerten bekommst aber den Transistor nicht überlastest. Wenn das ganze einen Interrupt auslöst muss man den Timer eben nicht auf Null zurücksetzen sondern etwas weiter vor um diese 2V Verzögerung bis die LED durchschaltet wieder auszugleichen. Bild hier  

Ist schon Recht - aber an der anderen Schaltung hatte mir imponiert das man auf grillende Widerstände und Optokoppler-Dioden verzichten kann.
Das hilft mir natürlich nicht, da diese leider nicht funktioniert.

Dein Vorschlag hilft mir zur Zeit auch nicht, da ich weder diesen Optokoppler noch passende Grillwiderstände da habe.
Aber er ist eine sehr schöne Ergänzung für den Thread hier.

Hallo!

Man könnte auch im Schaltplan vom Thomass zwei unidirektionale OK's verwenden, wenn die LED's antiparalell und die Phototransistoren paralell geschaltet werden. ;)

Zitat:

---

Man könnte auch im Schaltplan vom Thomass zwei unidirektionale OK's verwenden, wenn die LED's antiparalell und die Phototransistoren paralell geschaltet werden.

---

Würd ich auch für nen guten Vorschlag halten.
Dadurch entstehen dann Nadelimpulse um den Nulldurchgang der Wechselspannung herum, weil nur dort beide Optokoppler gesperrt sind.

hier noch mal 2 Bilder beim 2ten habe ich den Wert des Pullup-Widerstandes erhöht was zu schönen Nadelimpulsen führt.
Anhang 21966Anhang 21967

Das Bild 2 schaut ja schon mal gut aus.
Aber anscheinend sind deine beiden Optokoppler nicht gleich und ich würde den Lastwiderstand an den Kollektoren der Optokoppler verrringern, weil mir 1V bei den Nadelimpulsen zu wenig wäre - Laut Oszillogrammbild.

das habe ich schon korrigiert, die LEDs leiten anscheinend leicht unterschiedlich aber nach Anpassung des Widerstandes passt alles. Platz und kostenmäßig wird man nichts sparen wenn man 2 einzelne Optokoppler nimmt.

@ Thomass

Mit Rv1 und Rv2 ist die beste Abgleichmöglichkeit, weil die paralell geschaltete Transistoren in OK's (die "wired" OR Funktion realisieren) nur einen gemeinsamen Kollektorwiderstand (Rc) haben (siehe Code). :)

Code:

---

                                VCC
                                +
            >------+--+          |
          A        |  |        .-.
          |        |  |        | |Rc
          |        | .-.        | |
          |        | | |Rv1    '-'
          |        | | |        |
    230V |        | '-' OK1 +---+-----> Impulse
    50Hz |        |.-|------|.  |
          |        || |    |/ |  |
          |        || V -> |  |  |
          |        || -    |> |  |
          |        |'-|------|'  |
          V        |  |      +-+ |
            >------|--+        | |
                  |  |  OK2 +-|-+
                  | .|------|.|
                  | ||    |/ ||
                  | |V -> |  ||
                  | |-    |> ||
                  | '|------|'|
                  | .-.    +-+
                  | | |Rv2    |
                  | | |      ===
                  | '-'      GND
                  |  |
                  +--+

(created by AACircuit v1.28.6 beta 04/19/05 www.tech-chat.de)

---

Wenn's mal wieder länger dauert ... :)

In der Zwischenzeit habe ich erst noch ein anderes Projekt gebastelt und mich nun endlich wieder der Phasenanschnittssteuerung gewidmet.
Meinen Trenntrafo habe ich wieder gefunden und konnte die Schaltung mal endlich messen (Messergebnisse anbei).
Dabei durfte ich herausfinden das die Schaltung wunderbar arbeitet!
Der Fehler lag in der Verdrahtung wo ich ihn nicht gesucht habe - auf der Ausgangsseite des Optokopplers. :rolleyes:

Diese Schaltungsvariante hat auf jeden Fall den Vorteil schöne saubere Impulse phasengerecht zu liefern, ohne mehrere Watt an irgendwelchen Widerständen zu verbraten.
Dies rechtfertigt den höheren Bauteileaufwand allemal - zumindest wenn man die Stromrechnung selber zahlt. ;)

Nun muss ich mich an die Programmierung geben ...

Hier der Vollständigkeit halber das Gesamtschaltbild.
Die Diode 1N4148 könnte man sich prinzipiell auch noch sparen.
Für den Optokoppler-Ausgang reicht der aktivierte 10K-Pullup-Widerstand der Microcontrollers.

Zitat:

---

Für den Optokoppler-Ausgang reicht der aktivierte 10K-Pullup-Widerstand der Microcontrollers.

---

Mach da mal nur so aus Spaß trotzdem mal nen 2k2 Pullup mit rein.
Die Flanken sollten dann noch sauberer werden.
Ausserdem ist der interne Pullup Widerstand meines Wissens nicht genauer spezifiziert, aber um die 47k rum.

Oder man nutzt den internen Komparator bezogen auf die interne Referenzspannung.
Aber eigentlich sehen die Signale doch sehr schön aus - vor allem die fallende Flanke auf die getriggert wird.
Die Praxistests stehen aber noch aus ...

Diese Schaltung ist eine von denen die bei mir einfach nicht funktionieren wollen! :MistPC

Ich habe nun ein Testprogramm fertig das schon mal wunderbar funktioniert. :)
Dabei hatte ich zunächst versucht den Schaltausgang OC1A nur über den Timer mit einem Clear bei Compare-Match zu schalten.
Dies funktioniert aber leider nicht!
Daher läuft es nun mit zwei Interrupts - Der Timer-Interrupt schaltet den MOC ein und INT0 über die Netz-Impulse aus.
Ich erhalte wunderschöne PWM-Impulse und dies funktioniert wie vorgesehen.

Allerdings schaltet der TRIAC überhaupt nicht!
Ich habe die Schaltung schon mehrfach überprüft und auch schon den MOC3023 ausgetauscht, alles ohne Erfolg.
Auch ein entfernen des 47 nF Kondensators macht keinen Unterschied.
Ebenso ist es egal ob ich eine Glühbirne oder einen Ventilator anschliesse.
Einfach nichts, höchstens mal ein flackern beim anschliessen des Netzstromes.

Ein häufiger Fehler ist, wenn man A1 mit A2 vom Triac miteinander vertauscht. Das wirkt sich dann genau so aus, wie Du es beschreibst.
Ist aber nur eine Möglichkeit.

Ja - das ist es tatsächlich!
Manchmal hat es auch Vorteile "häufige Fehler" zu machen. :)

Es funktioniert nun endlich wie vorgesehen - auch mit induktiven Lasten.:Strahl
Damit dieser Thread nun einen schönen und vollständigen Abschluss erhält, hier noch der dazugehörige BASCOM-Code.
Somit gibt es nun ein vollständiges Beispiel für eine Realisierung der Phasenanschnittssteuerung.