Deurbel -> Raspberry GPIO

[geerttttt]

Hallo, Even ter verificatie voordat ik ga kopen wat ik denk dat goed is...

Ik heb een deurbel die op 12v werkt. Dit wil ik opzich wel zo houden, maar ik wil graag parallel daaraan kunnen meten wanneer deze wordt ingedrukt.

Nu zat ik te denken aan deze oplossing:

http://www.ebay.com/itm/1...41ce65:g:fzwAAOSwjVVVn09H

Oftewel, een 12v relais. Die knoop ik parallel aan het circuit van de deurbel zodat , zodra de deurbel ingedrukt wordt, de relais stroom krijgt en het relais sluit. Aan dat relais zit dan weer een lijntje van een GPIO poort naar de GND.

Oftewel, deurbel wordt ingedrukt, stroom komt op relais, die sluit zich en daardoor sluit het circuit op de Raspberry, wat ik weer kan meten.

Klopt mijn aanname, of mis ik nu nog iets? En hoe lang mag zo'n kabel vanaf de relais naar de raspberry zijn? En de lange kabel die naar de deurbel loopt, zou dat te veel weerstand geven om de relais te schakelen?

Bedankt!

[Pizza_Boom]

geerttttt schreef op dinsdag 20 oktober 2015 @ 11:42:
Ik heb een deurbel die op 12v werkt. Dit wil ik opzich wel zo houden, maar ik wil graag parallel daaraan kunnen meten wanneer deze wordt ingedrukt.

Nu zat ik te denken aan deze oplossing:

http://www.ebay.com/itm/1...41ce65:g:fzwAAOSwjVVVn09H

Oftewel, een 12v relais. Die knoop ik parallel aan het circuit van de deurbel zodat , zodra de deurbel ingedrukt wordt, de relais stroom krijgt en het relais sluit. Aan dat relais zit dan weer een lijntje van een GPIO poort naar de GND.

Oftewel, deurbel wordt ingedrukt, stroom komt op relais, die sluit zich en daardoor sluit het circuit op de Raspberry, wat ik weer kan meten.

Alleen moet je er even rekening mee houden dat dit relais bedoelt is om 12 volt te schakelen vanaf een Arduino/Raspberry, niet om zelf door 12 volt geschakeld te worden.

Klopt mijn aanname, of mis ik nu nog iets? En hoe lang mag zo'n kabel vanaf de relais naar de raspberry zijn? En de lange kabel die naar de deurbel loopt, zou dat te veel weerstand geven om de relais te schakelen?

Dat is gewoon een kwestie van trial&error. Wat je kan doen is je 12 volt zo dicht mogelijk bij je raspberry brengen en daar pas het relais plaatsen. Ik zou trouwens ook nog een 10k weerstand tussen GND en GPIO pin plaatsen als pull down. Anders gaat je ingang zweven als de bel niet wordt ingedrukt.
Zo dus:


Nou is natuurlijk de vraag, wat wil je met de raspberry gaan registreren en wat doet ie nog meer? Als het verder allemaal webbased is en er gebeurt verder niets, kan je overwegen om de raspberry bij de bel in de buurt te hangen en gewoon een UTP kabeltje te trekken.

[geerttttt]

Pizza_Boom schreef op dinsdag 20 oktober 2015 @ 11:48:
[...]
Alleen moet je er even rekening mee houden dat dit relais bedoelt is om 12 volt te schakelen vanaf een Arduino/Raspberry, niet om zelf door 12 volt geschakeld te worden.

Als ik het goed lees is zijn input voltage 12v en relay max voltage 230VAC of 30VDC toch?

[memphis]

Gezien je deurbel hoogstwaarschijnlijk op 12v wisselspanning werkt moet je dus een relais hebben dat op AC werkt. En dan waarom een module terwijl een los relais goedkoper is?

Andere optie is een optocoupler. met een diode en elko als simpele gelijkrichter kan je stabile spanning aanbieden voor de LED in de optocoupler.

[Pizza_Boom]

geerttttt schreef op dinsdag 20 oktober 2015 @ 12:17:
[...]

Als ik het goed lees is zijn input voltage 12v en relay max voltage 230VAC of 30VDC toch?

Daar heb ik dan overheen gekeken. Maar ik zou gewoon lekker een los relais zoeken bij een van de electronicaboeren. Goedkoper en netter aan te sluiten met een klein stukje print.

[grizzlybear]

Ik heb zelf een ander soort schakeling gemaakt: bij mij zit de belknop aan de gpio en detecteert dat de belknop wordt ingedrukt. Daarop stuur ik een relais aan dat spanning op de bel zet. Ik heb een stukje software gemaakt op de Raspberry Pi dat de hele bel bediening regelt.

De voordelen voor mij:

- Ik kan de bel op afstand bedienen (voor Sinterklaas erg handig)
- De bel belt altijd even lang, ongeacht hoe lang de knop wordt ingedrukt
- Er kan niet 2x achter elkaar gebeld worden
- Ik zet nu een ledje aan bij de belknop om te laten zien dat er gebeld is
- Er zijn nu meerdere wifi deurbellen in mijn huis die ook afgaan
- 's Nachts zet ik de bel automatisch uit.

[ Voor 0% gewijzigd door grizzlybear op 20-10-2015 12:54 . Reden: spelfout ]

[K-Jay]

Ik heb dit gedaan met een optocoupler. Mijn bel werkt op 8V wisselstroom, als de bel wordt ingedrukt loopt die stroom door de optocoupler die op zijn beurt twee GPIO-pinnen van mijn Pi verbindt. Op de Pi draait pimatic wat op zijn beurt weer een berichtje naar mijn telefoon pusht.
Werkt al maanden prima! Zorg wel dat je een optocoupler aanschaft die met wisselstroom overweg kan. Sterker nog, koop er meteen drie ofzo, voor als je iets verkeerd doet...

[memphis]

Met een optocoupler:

[geerttttt]

grizzlybear schreef op dinsdag 20 oktober 2015 @ 12:54:
Ik heb zelf een ander soort schakeling gemaakt: bij mij zit de belknop aan de gpio en detecteert dat de belknop wordt ingedrukt. Daarop stuur ik een relais aan dat spanning op de bel zet. Ik heb een stukje software gemaakt op de Raspberry Pi dat de hele bel bediening regelt.

De voordelen voor mij:

- Ik kan de bel op afstand bedienen (voor Sinterklaas erg handig)
- De bel belt altijd even lang, ongeacht hoe lang de knop wordt ingedrukt
- Er kan niet 2x achter elkaar gebeld worden
- Ik zet nu een ledje aan bij de belknop om te laten zien dat er gebeld is
- Er zijn nu meerdere wifi deurbellen in mijn huis die ook afgaan
- 's Nachts zet ik de bel automatisch uit.

Dat zijn wel voordelen waar ik niet aan gedacht heb inderdaad. Nadeel echter is dat als de raspberry vast loopt, of stuk is, of mijn stuk software die de deurbel checkt stopt of vastgelopen is, de deurbel niks meer doet... De reden om het parallel te doen was dan ook dat de normale techniek blijft werken, scheelt weer met de WAF

[grizzlybear]

Ik heb dat opgelost door er een Microchip PIC voor te gebruiken die dit afhandelt, dat kan eigenlijk nooit niet werken. Mijn vrouw heeft er nog nooit over geklaagd. De PIC doet dus eigenlijk alles en vertelt over USB tegen de Raspberry dat er gebeld is. Als dat niet meer werkt, dan doet de bel het dus nog steeds.

Ik kan ook per bel instellen van hoe laat tot hoe laat deze mag gaan, voor als de kinderen slapen.

[ThinkPad]

Als je een 8V AC deurbel hebt (zoals het merendeel van de huizen in NL denk ik) dan gewoon gelijkrichten en in in een 12V DC relais stoppen. Elcotje erover om het signaal uit te vlakken en aan je GPIO hangen.

Zo heb ik het ook ongeveer gedaan: ThinkPad's Tweakblog: Deurbel ombouw naar 433Mhz (incl. schema).

Via een optocoupler moet ook prima kunnen, maar ook daar wel gelijkrichten, anders schakelt hij 50x per seconde aan/uit (50 Hz immers). Heb het ook wel met een optocoupler geprobeerd, maar kreeg dat niet goed voor elkaar. Relaisje werkte gelijk en had ik toch nog liggen.

[ Voor 3% gewijzigd door ThinkPad op 29-03-2023 10:11 ]

[geerttttt]

Oke, dus ik zou het ook anders kunnen doen:

5v relay, powered door raspberry pi.
Relay 5v ----> 5v Raspberry
Relay GND -> GND Raspberry + ader 1 van deurbel
Relay IN ---- > ader 2 van deurbel + GPIO van Raspberry

Aan de andere kant van de Relay dus de twee draadjes waar de deurbel ooit mee verbonden was.

Dus, de deurbel werkt altijd nog steeds, mits er 5v op de relay staat. Dus tenzij de Raspberry pi echt uit staat werkt hij altijd.
Daarnaast kan ik door de GPIO als input te gebruiken deze uitlezen en zien wanneer de deurbel ingedrukt is.

Zo omzeil ik gedoe met AC en DC... Toch?

[ThinkPad]

Volg gewoon het schema wat ik ook gebruikt heb: http://tweakers.net/ext/f/Fly1GYzLyKkudd0dc6sTdgZL/full.png

De remote is in jouw geval de 5V + GPIO van de Raspberry.

Edit 2023: Tegenwoordig gebruik de volgende oplossing. Dit hangt parallel aan de 8VAC deurbel


De 8V AC hangt via de ene poot met een 1N4007 en 1k weerstand in serie aan pin 1 van de PC817 optocoupler. De andere draad vanaf 8VAC gaat rechtstreeks naar pin 2 van de opto. Parallel over de uitgang van de opto zit een 1uF 50V elco (minkant elco aan pin 3 van de opto). Pin 4 gaat naar D1 en pin 3 naar Gnd.

In Tasmota de GPIO geconfigureerd als 'Switch', met switchmode 0. En een rule ingesteld om Node-RED aan te roepen:

code:

"Rules":"on Power1#State=1 do WebSend [192.168.8.21:1880] /deurbeltrigger endon"

De 'relay' heeft qua hardware geen functie, maar is blijkbaar nodig om de rule te laten functioneren.

[ Voor 91% gewijzigd door ThinkPad op 27-08-2023 21:49 ]

[IVEL]

grizzlybear schreef op dinsdag 20 oktober 2015 @ 12:54:
Ik heb zelf een ander soort schakeling gemaakt: bij mij zit de belknop aan de gpio en detecteert dat de belknop wordt ingedrukt. Daarop stuur ik een relais aan dat spanning op de bel zet. Ik heb een stukje software gemaakt op de Raspberry Pi dat de hele bel bediening regelt.

De voordelen voor mij:

- Ik kan de bel op afstand bedienen (voor Sinterklaas erg handig)
- De bel belt altijd even lang, ongeacht hoe lang de knop wordt ingedrukt
- Er kan niet 2x achter elkaar gebeld worden
- Ik zet nu een ledje aan bij de belknop om te laten zien dat er gebeld is
- Er zijn nu meerdere wifi deurbellen in mijn huis die ook afgaan
- 's Nachts zet ik de bel automatisch uit.

Dit klinkt wel als een erg slimme oplossing waar over nagedacht is. Zou je de details qua aansluiting en je stukje software willen delen zodat anderen hier ook gebruik van kunnen maken?

[grizzlybear]

Hieronder de code van de PIC met daarin ook in ASCII art de aansluitingen.

Ik heb een belknop gebruikt waar zo'n lampje inzit. Dat lampje heb ik vervangen door een LED zodat je kunt zien dat je echt gebeld hebt. Ik heb een ultra bright blauwe LED gebruikt van 20mA. Gelukkig is de PIC beveiligd, want als de LED aan is en je drukt nog een keer op de bel, dan maak je eigenlijk kortsluiting....

Er zit ook een anti dender functie op om te korte pulsen af te vangen. Wij hebben een ding-dong bel en daarom zet ik deze 200ms aan (ding) en dan doet hij zelf dong. Dat is de perfecte tijd voor onze bel. Daarna gaat de LED 10s aan en gedurende die tijd kun je niet nog een keer aanbellen (dat vond ik irritant...)

Over de UART wordt gestuurd dat de deurbel ging. Dat wordt door een QT programma dat draait op de Raspberry Pi opgepikt en verder afgehandeld (bericht gestuurd en de andere bellen worden verteld om te bellen als dat nodig is).

Het programma op de Raspberry luistert ook op een HTTP poort om een bericht binnen te krijgen om te bellen. Dan stuurt deze een R naar de UART van PIC en deze zal dan ook gaan bellen. Dat is echt ideaal voor Sinterklaas en zo.

C:

/***********************************************************************
 *                                                                     *
 *                              16F690                                 *
 *                         _______ _______                             *
 *                        |       U       |                            *
 *                +5V ----|1 vdd    vss 20|---- Gnd                    *
 *                      |-|2 RA5    RA0 19|<-----------|---- switch_1  *
 *                      |-|3 RA4    RA1 18|>--/\/\/\/--| 75 Ohm        *
 *                      |-|4 RA3    RA2 17|----------------> switch_2  *
 *                      |-|5 RC5    RC0 16|----> relay_transistor      *
 *                      |-|6 RC4    RC1 15|-|                          *
 *                      |-|7 RC3    RC2 14|-|                          *
 *                      |-|8 RC6    RB4 13|-|                          *
 *                      |-|9 RC7    RB5 12|<---- rx ----> tx           *
 *       rx ----> tx <----|10 RB7   RB6 11|-|                          *
 *                        |_______________|                            *
 *                                                                     *
 ***********************************************************************
 *                                                                     *
 * relay_transistor                                                    *
 *                      E   /-<-- +5V               BC640 PNP (E C B)  *
 *                      |  /                                   1 2 3   *
 *                120   | /                                            *
 * 16f690_16 ---/\/\/\/-|B               1n4007                        *
 *                      | \        |-------|<--------|                 *
 *                      |  \       |                 |                 *
 *                      C   \--------> 4  relay  3 <------ Gnd         *
 *                                                                     *
 ***********************************************************************
 *                                                                     *
 * switch (NO)          /                                              *
 *   16f690_19   1 ----/ ---- 2   16f690_18                            *
 *                  |      |                                           *
 *                  --->|---                                           *
 *                     LED                                             *
 *                                                                     *
 ***********************************************************************
 *                                  TR5V relay (bottom view)           *
 *       78L05                      ____________________               *
 *                                 | 1  ______3___5__   | 1 = ~9V      *
 *   1     2      3                | O |      O   O   | | 2 = nc       *
 *  In    GND    Out(+5V)          | | |      |   |  _| | 3 = Gnd      *
 *  |      |      |                | |-|      $    /    | 4 = BC640_2  *
 *  -+| |-----| |--                | |        |   |     | 5 = Doorbell *
 *    10uF    100nF                | O        O   O     | 6 = nc       *
 *                                 |_2________4___6_____|              *
 ***********************************************************************/

#include <xc.h>
#define _XTAL_FREQ 8000000 // Oscillator at 8Mhz for delay functions

// CONFIG
#pragma config WDTE = OFF      // Watchdog Timer Enable bit (WDT disabled and can be enabled by SWDTEN bit of the WDTCON register)
#pragma config PWRTE = ON      // Power-up Timer Enable bit (PWRT enabled)
#pragma config MCLRE = OFF     // MCLR Pin Function Select bit (MCLR pin function is digital input, MCLR internally tied to VDD)
#pragma config CP = OFF        // Code Protection bit (Program memory code protection is disabled)
#pragma config CPD = OFF       // Data Code Protection bit (Data memory code protection is disabled)
#pragma config BOREN = OFF     // Brown-out Reset Selection bits (BOR disabled)
#pragma config FOSC  = INTRCIO // Oscillator Selection bits (INTOSCIO oscillator: I/O function on RA4/OSC2/CLKOUT pin, I/O function on RA5/OSC1/CLKIN)
#pragma config IESO  = OFF     // Internal External Switchover bit (Internal External Switchover mode is disabled)
#pragma config FCMEN = OFF     // Fail-Safe Clock Monitor Enabled bit (Fail-Safe Clock Monitor is disabled)

#define PIN_RELAY        RC0
#define PIN_SWITCH       RA0
#define PIN_LED_POSITIVE RA1
#define PIN_LED_NEGATIVE RA2

#define RELAY_OFF_VALUE 1
#define RELAY_ON_VALUE  0

#define RESET_DELAY 10

void delay_s(unsigned char time)
{
    while (time-- > 0)
    {
        CLRWDT();
        __delay_ms(998);
    }
}

void UART_SendChar(unsigned char c)
{
    // Send one character
    while ((!TRMT) && TXEN); // loop until the register get's emptied
    CLRWDT();
    TXREG = c; // this action clears TXIF also;
}

void UART_SendInt(const unsigned short value)
{
    unsigned short temp = value;
    if (temp >= 100)
    {
        UART_SendChar(temp / 100 + 48);
        temp %= 100;
    }
    if (temp >= 10 || value > 100)
        UART_SendChar(temp / 10 + 48);
    temp %= 10;
    UART_SendChar(temp % 10 + 48);
}

void UART_SendEOL()
{
    // This sends a newline and a carriage return
    UART_SendChar('\r');
    UART_SendChar('\n');
}

void UART_SendString(const unsigned char* str)
{
    while (*str != 0x00) // Here we check if there is still more chars to send, this is done checking the actual char and see if it is different from the null char
    {
        UART_SendChar(*str); // Using the simple send function we send one char at a time
        str++; // We increment the pointer so we can read the next char
    }
}

unsigned char UART_ReceiveCharTimeout(unsigned char *rcv)
{
    unsigned long timeout = 130000;
    // Receive one character within a timeout
    if (OERR || FERR)
    {
        CREN = 0;
        CREN = 1;
    }
    CLRWDT();
    while (!RCIF && timeout > 0)
        timeout--;
    if (RCIF)
    {
        *rcv = RCREG; // Clears the RCIF bit
        return 1;
    }
    return 0;
}

void SoundBell()
{
    PIN_RELAY = RELAY_ON_VALUE;
    __delay_ms(200);
    PIN_RELAY = RELAY_OFF_VALUE;
}

void LedOn()
{
    PIN_LED_POSITIVE = 1;
    PIN_LED_NEGATIVE = 0;
}

void LedOff()
{
    PIN_LED_POSITIVE = 0;
    PIN_LED_NEGATIVE = 1;
}

void interrupt interruptHandler(void)
{
    unsigned char command;
    CLRWDT();
    if (TMR2IF && TMR2IE)
    {
        TMR2IF = 0;
    }
    if (RCIF && RCIE)
    {
        if (UART_ReceiveCharTimeout(&command))
        {
            if (command == 'D')
            {
                UART_SendString("Doorbell ready.");
                UART_SendEOL();
            }
            else if (command == 'R')
            {
                LedOn();
                SoundBell();
                UART_SendString("DEBUG: Doorbell rang.");
                UART_SendEOL();
                delay_s(RESET_DELAY);
                LedOff();
            }
        }
        RCIF = 0;
    }
    if (RABIF && RABIE)
    {
        if (PIN_SWITCH)
        {
            command = 0;
            while(PIN_SWITCH && command++ < 100)
                __delay_ms(1);
            if (command >= 100)
            {
                LedOn();
                SoundBell();
                UART_SendString("Doorbell rang.");
                UART_SendEOL();
                delay_s(RESET_DELAY);
                LedOff();
            }
            else
            {
                UART_SendString("Button press too short.");
                UART_SendEOL();
            }
        }
        RABIF = 0;
    }
}

void Init_UART()
{
    TRISBbits.TRISB5 = 1; // Set RB5 as an input
    ANSELHbits.ANS11 = 0; // Set RB5 as digital
    TRISBbits.TRISB7 = 0; // Set RB7 as a digital output;
    //  SPEN = 1; // Enable the serial port
    //  RX9 = 0; // Receive only 8 bits
    //  CREN = 1; // Enable the receiver
    RCSTA = 0b10010000;
    //  ABDEN = 0; // Set the Auto-Baud Detect Enable bit to false
    //  BRG16 = 1; // Set baud rate generator to 16-bit mode instead of 8-bit
    BAUDCTL = 0b00001000;
    //  SYNC = 0; // Set to asynchronous mode
    //  TXEN = 1; // Enable transmit
    //  TX9 = 0; // Transmit only 8 bits
    //  BRGH = 1; // Set the baudrate to 115k2
    TXSTA = 0b00100100;
    SPBRG = 16; // Set the baudrate to 115k2
    WUE = 1; // WakeUp on RCIF enabled
    RCIF = 0;
    RCIE = 1; // Enable the receive interrupt
}

void Init_Relay_Pins()
{
    TRISCbits.TRISC0 = 0; // Set RC0 as an output
    PIN_RELAY = RELAY_OFF_VALUE;
}

void Init_Switch_Pins()
{
    TRISAbits.TRISA0 = 1; // Set RA0 as an input
    WPUAbits.WPUA0 = 0; // Disable the weak-pull up for RA0
    ANSELbits.ANS0 = 0; // Set RA0 as digital
    IOCAbits.IOCA0 = 1; // Enable interrupt on change for RA0
    TRISAbits.TRISA1 = 0; // Set RA0 as an output
    TRISAbits.TRISA2 = 0; // Set RA2 as an output
    PIN_RELAY = RELAY_OFF_VALUE;
    LedOff();
    RABIE = 1;
}

void Init_WatchdogTimer()
{
    CLRWDT(); // Clear the watchdog timer
    TMR0 = 0; // Clear timer0
    OPTION_REGbits.PSA = 1; // Pre-scaler is assigned to the watchdog timer
    OPTION_REGbits.PS = 0b111; // Set pre-scaler to 1:128
    CLRWDT(); // Clear the watchdog timer
    WDTCON = 0b00010111; // Set pre-scaler to 1:65536 and enable the watchdog timer
    CLRWDT(); // Clear the watchdog timer
}

void Init()
{
    // IRCF = 0b111 (Set Internal OSC to 8 MHZ)
    // SCS = 1 (Set clocksource to internal oscillator)
    OSCCON = 0b01110001;

    OPTION_REGbits.nRABPU = 1; // Disable the weak-pull-ups globally
    CM1CON0 = 0x00; // Disable Comperator C1
    CM2CON0 = 0x00; // Disable Comperator C2
    ANSEL = 0x00; // Set ports ANS0 - ANS7 as digital
    ANSELH = 0x00; // Set ports ANS8 - ANS11 as digital
    TRISA = 0x00; // Configure PortA as outputs
    PORTA = 0x00; // All PortA pins are low
    TRISB = 0x00; // Configure PortB as outputs
    PORTB = 0x00; // All PortB pins are low
    TRISC = 0x00; // Configure PortC as outputs
    PORTC = 0x00; // All PortC pins are low
    CCP1CON = 0x00; // Disable the ECCP module
    ADCON0 = 0x00; // Disable the A/D convertor
    RCSTA = 0x00; // Disable the UART reception
    TXSTA = 0x00; // Disable the UART transmission
}

void main(void)
{
    Init();
    Init_UART();
    Init_Relay_Pins();
    Init_Switch_Pins();
    Init_WatchdogTimer();

    PEIE = 0x01; // Enable peripherial interrupts
    GIE = 0x01; // Enable Global Interrupts

    UART_SendString("** System Started **");
    UART_SendEOL();

    while (1)
    {
        CLRWDT();
    }
}

[ Voor 8% gewijzigd door grizzlybear op 20-10-2015 14:37 ]

[Pizza_Boom]

grizzlybear schreef op dinsdag 20 oktober 2015 @ 14:35:
Hieronder de code van de PIC met daarin ook in ASCII art de aansluitingen.

Jij hebt zeker ook een PICkit 2 thuis liggen?

[grizzlybear]

Inderdaad en ook een ICD3

[Pizza_Boom]

Die heb ik dan weer niet. Wel een PK3.

[balk]

ThinkPad schreef op dinsdag 20 oktober 2015 @ 13:49:
Volg gewoon het schema wat ik ook gebruikt heb: http://tweakers.net/ext/f/Fly1GYzLyKkudd0dc6sTdgZL/full.png

De remote is in jouw geval de 5V + GPIO van de Raspberry.

Edit 2023: Tegenwoordig gebruik de volgende oplossing. Dit hangt parallel aan de 8VAC deurbel
[Afbeelding]

De 8V AC hangt via de ene poot met een 1N4007 en 1k weerstand in serie aan pin 1 van de PC817 optocoupler. De andere draad vanaf 8VAC gaat rechtstreeks naar pin 2 van de opto. Parallel over de uitgang van de opto zit een 1uF 50V elco (minkant elco aan pin 3 van de opto). Pin 4 gaat naar D1 en pin 3 naar Gnd.

In Tasmota de GPIO geconfigureerd als 'Switch', met switchmode 0. En een rule ingesteld om Node-RED aan te roepen:

code:

"Rules":"on Power1#State=1 do WebSend [192.168.8.21:1880] /deurbeltrigger endon"

[Afbeelding]
De 'relay' heeft qua hardware geen functie, maar is blijkbaar nodig om de rule te laten functioneren.

Bedankt voor het delen! Wat is de functie van de elco aan de esp kant? Hier werkt het nu iig zonder
Ik gebruik een 4N35 opto (had ik nog liggen) en een 4.7kOhm weerstand.
Ik heb deze code in Esphome:

code:

- platform: gpio
    pin: 
      number: GPIO32
      mode:
        input: true
        pullup: true
      inverted: true
    name: "Deurbel actief"
    filters:
      - delayed_off: 100ms

De delayed_off filtert eventuele 50Hz'jes er uit.

[ Voor 1% gewijzigd door balk op 29-10-2023 20:11 . Reden: details toegevoegfd ]

[ThinkPad]

Mooi dat het werkt. De elco is volgens mij voor het debouncen, wat jij nu in de code hebt opgelost. Die mogelijkheid heb ik in Tasmota niet