Relè attivato per l'attraversamento dello zero

Come potrei fare per programmare un interruttore (basato su relè a stato solido o triac) che si innesca sulla potenza di attraversamento zero?

Per coloro che non hanno familiarità con il soggetto: accendere l'alimentazione a 230 V, quando l'onda sinusoidale della linea di alimentazione attraversa lo zero - il risultato è ridurre al minimo i disturbi elettromagnetici derivanti da un rapido picco di corrente.

In particolare, preferirei passare il più possibile al software. Il circuito di rilevamento costituito da un piccolo trasformatore, un diodo e una coppia di resistori per mantenere sotto controllo livelli e correnti fornisce "1" quando la potenza di ingresso AC è nella metà positiva, "0" in negativo, collegata a un pin GPIO di ingresso. L'uscita è composta da alcuni relè a stato solido e elementi essenziali per mantenerli in esecuzione (pull-up, ecc.), Collegati ai pin GPIO di uscita.

Il problema è il tempismo: con 50Hz AC otteniamo 100 incroci zero in un secondo, un mezzo ciclo è 10ms. Per raggiungere una distanza ragionevole dall'attraversamento zero per mantenere bassa la suddetta EMI, non dovremmo attivare l'output di oltre il 10% oltre (o prima) l'evento di attraversamento dello zero, ciò significa tolleranza + -1ms. Ciò non significa un tempo di reazione di 1 ms - possiamo ragionevolmente aspettarci che il prossimo passaggio per lo zero avvenga esattamente 10 ms dopo il primo, o il quarto - 40 ms. Riguarda la granularità: se consentiamo 20ms di reazione, deve essere compreso tra 19 e 21ms, non 18 o 22.

Come posso implementare un tale timer - innescare l'uscita GPIO entro 1ms poiché l'ingresso rileva un fronte o entro un multiplo fisso di 10ms da allora - preferibilmente con tolleranza per alcuni bias negativi (diciamo, il trasformatore e il relè introducono un ritardo di 1,6ms; quindi voglio che il trigger si disattivi 8.4+ (n * 10) ms dall'impulso di ingresso, in questo modo il bias contrasta il ritardo introdotto dal circuito.) - ovviamente "su richiesta dell'utente", ad esempio, l'utente scrive "1 "in un file / sys / class / ... e all'opportunità (approssimativamente) più vicina l'output diventa" on ". L'utente scrive "0" e quando arriva l'attraversamento zero, il relè specifico si disattiva.

Credo che ciò richiederebbe la scrittura o l'hacking di un modulo del kernel. Potresti indicarmi cosa gestisce i pin GPIO di Raspberry Pi nel kernel e quale tipo di timer posso collegarvi (a meno che non ce ne siano già in atto) per ottenere questo tipo di funzionalità?

Non è necessario hackerare il kernel. Hai solo bisogno di spostare il processo fuori dalla coda dello scheduler.

    #include<sched.h>

    struct sched_param param;               
    param.sched_priority = sched_get_priority_max(SCHED_FIFO);
    if( sched_setscheduler( 0, SCHED_FIFO, &param ) == -1 )
    {
            perror("sched_setscheduler");
            return -1;
    }

Da ora in poi il nostro processo riceve cat /proc/sys/kernel/sched_rt_runtime_usmillisecondi da ogni cat /proc/sys/kernel/sched_rt_period_ussegmento di millisecondi, di esecuzione ininterrotta senza il rischio di essere anticipati durante quel periodo (in pratica, per impostazione predefinita su BerryBoot: 0,95 secondi al secondo). Se hai bisogno di più, pasticcia con questi valori, ma non ho bisogno di altro per il mio scopo qui.

Sto usando una funzione timer in millisecondi (che riguarda la precisione di cui ho bisogno) in base clock_gettime()al clock dei miei ritardi.

La chiamata lo timer(1)ripristina, la chiamata timer(0)restituisce il tempo dall'azzeramento.

    #include<time.h>
    typedef unsigned long long ulong64;

    ulong64 timer(unsigned char reset)
    {
            struct timespec t;
            static struct timespec lt={0,0};
            clock_gettime(CLOCK_REALTIME, &t);
            if(reset)
            {
                    lt.tv_sec = t.tv_sec;
                    lt.tv_nsec = t.tv_nsec;
            }

            int r = ((ulong64)(t.tv_sec - lt.tv_sec))*1000 + (t.tv_nsec - lt.tv_nsec)/1000000;

            return r;
    }

Devi rtcompilare il collegamento con la libreria per compilare questo - aggiungi -lrtal tuo comando gcc.

Ora, per il ciclo principale. Sto utilizzando un input switch per "richiesta utente" ma è possibile utilizzare rete, timer o altro. Tutto ciò che serve è ottenere il valore booleano in.

    while(1)
    {
            //when idle, return a lot of CPU time back to the system. 
            //A call every 100ms is perfectly sufficient for responsive reaction.
            usleep(100000); 

            in  = bcm2835_gpio_lev(SWITCH_PIN);
            out = bcm2835_gpio_lev(TRIAC_PIN);

            if(in==out) continue;   //nothing to do; wait user input, return control to system.

            //The output needs to be changed.
            //First, let's wait for zero-crossing event.
            timer(TIMER_RESET);
            zx = bcm2835_gpio_lev(ZEROXING_PIN);

            //We don't want to freeze the system if the zero-xing input is broken.
            //If we don't get the event within reasonable time, 
            // (like three half-sines of the power; ZEROXING_TIMEOUT = 70)
            // we're going to bail.
            while(timer(TIMER_READ) < ZEROXING_TIMEOUT)
            {
                    if(zx != bcm2835_gpio_lev(ZEROXING_PIN))
                    {
                            //Event detected.                  
                            timer(TIMER_RESET);
                            break;
                    }
            }
            if(timer(TIMER_READ) >= ZEROXING_TIMEOUT) continue;     //Zero-crossing detection is broken, try again soon.

            //Now we are mere milliseconds after zero-crossing event arrived
            // (but it could have taken some time to arrive) so let's wait for the next one, making adjustments for the system delay.
            // This is to be worked out using an oscilloscope and trial and error.
            // In my case BIASED_DELAY = 19.

            while(timer(TIMER_READ)<BIASED_DELAY) ;

            //We can reasonably expect if we perform this right now:
            bcm2835_gpio_set_pud(TRIAC_PIN, in);
            //the signal will reach the output right on time.

            // The 100ms delay on return to start of the loop should be enough 
            // for the signals to stabilize, so no need for extra debouncing.
    }