Elektriciteitskast controller

Toon hier Uw afgeronde projecten aan anderen.
Berichten: 6
Geregistreerd: 15 Apr 2014, 11:55

Elektriciteitskast controller

Berichtdoor on1bte » 15 Okt 2014, 21:06

Controller voor een bestaande elektriciteitskast met impulsrelais (mijn eerste Arduino projectje ...)

Algemeen :

Mijn elektriciteitskast, centraal opgesteld op de 1e verdieping van de woning, heeft 25 enkelpolige impulsrelais waarmee de verlichting wordt geschakeld. Deze impulsrelais werken op 24VAC. De Arduino controller neemt de besturing van de impulsrelais voor zijn rekening. De bestaande installatie blijft behouden. Parallel met de drukknop(pen) komt een relaiskontakt die de impulsrelais aanstuurt. De controle van de toestand (aan/uit) wordt gedetecteerd door een 230VAC detection circuit.
Bij het commando ‘Lamp 1 aan’ komende van bijvoorbeeld een KaKu afstandsbediening of Nodo controller moet de in de elektriciteitskast aanwezige controller eerst de positie van de overeenstemmende impulsrelais controleren. Indien deze uit is, zal er een relais kortstondig sluiten en de impulsrelais laten schakelen. Is deze reeds aan dan mag er niets gebeuren.


Spanningsdetectie op impulsrelais :
Mijn elektriciteitskast heeft 25 enkelpolige impulsrelais waarmee mijn verlichting wordt geschakeld.
Deze impulsrelais werken op 24VAC. Om de toestand van deze impulsrelais te kennen, heb ik een soort van spanningsdetectie gemaakt. Streefdoel daarbij is geen bruggelijkrichters en elko’s te gebruiken.

Principe schema :
schema optpcoupler input 640x480.jpg
schema optpcoupler input 640x480.jpg (77.34 KiB) 4653 keer bekeken


Werking van de schakeling :

De toegepaste opto coupler SFH620A-3X heeft intern 2 antiparallel ledjes. Elke nuldoorgang kan zeer eenvoudig gedetecteerd worden. De detectie verbruikt slechts een 0.18W per geactiveerde impulsrelais.
De bovenste opto coupler krijgt via 2 weerstanden continu 50Hz wisselspanning aangeboden.
De emittor van de opto coupler is verbonden met de Aa Schmitt trigger input van een monostabiele multivibrator MC14538. Deze wordt op een positief gaande flank getriggerd. De Q not output is verbonden met de clock ingang van een latch 74HCT574. Deze wordt getriggerd op een positieve flank. Wanneer we de tijdsconstante ongeveer 4ms maken, dan worden de latchen in het midden van elke positieve en negatieve alternantie van de wisselspanning geklokt.
Wanneer er een impulsrelais kontakt sluit, zal er op één van de ingangen van een 74HCT574 een spanningsverloop komen gelijk aan dat van de opto coupler die het referentiesignaal levert. De pulsen van de nuldoorgangen hebben geen effect omdat er steeds geklokt wordt in het midden van een alternatie. De signalen die op de uitgangen van de 74HCT574 latch verschijnen, zijn actief hoog.

In deze vorm kan de schakeling enkel gebruikt worden voor een enkelfazige aansluiting.

Op deze manier krijg ik 8 bits info die de toestand van mijn impulsrelais weergeeft. De uitgangen van een 74HCT574 latch hang ik aan Port1 van een I2C 16 bit I/O expander PCA9555D. Aan Port 0 van deze PCA9555D hangt een relaisbord met 8 relais.

Bij het schakelen van de deze impulsrelais worden er stoorpulsen gevormd waardoor het output register zijn initiële setup verliest. Er werd over elk relaiskontakt een condensator van 470nF/400V aangebracht.

Foto van de opstelling

el kast contr.jpg
el kast contr.jpg (89.94 KiB) 4653 keer bekeken


Code: Alles selecteren
/*
  KaKu receiver to control 64 Pulsar pulse relays V1.05
  --------------------------------------------------------
  Input detection through opto-coupler (lights on or lights off).
  Pulses to control the Pulsar pulse relays are made with relay contacts.
  16 Inputs with 1x PCA9555D (I2C) addresses 0x20, 0x21, 0x22, 0x23.
  16 Outputs with 1x PCA9555D (I2C) addresses 0x24, 0x25, 0x26, 0x27. 
  Arduino Mega2560 : SDA=20 ; SCL=21.
  Arduino Pro Mini : SDA=A4 ; SCL=A5.
  Receiver 433.9MHz is on pin 2 from the Arduino.
  Serial monitoring possible on 115200 Baud.
  In this example there are 32 on/off codes.
  You can easily add more codes.
  If the code is not in the case list, it will be displayed in the serial monitor.
  Use 470nF on the relay contacts !
  V1.04 : "All on/off" function implemented.
  V1.04.01 : Working with Arduino Pro Mini.
  V1.04.02 : Tuned for Hager EP513 pulse relays (100ms).
  V1.04.03 : Delay after decoding otherwise problem with LCD remote control.
  V1.04.04 : "All on/off" function is the 65th and 66th switch case.
  V1.05 : Maskbyte implemented.
  -----------------------------------------
  |  Download Remote Library from :       |
  |  http://code.google.com/p/rc-switch/  |
  -----------------------------------------
 
  Dipswitches systemcode :
    OFF = 1 (open contact)
    ON =  0 (closed contact)
  Examples dipswitch settings (left to right is switch 1 to switch 5) : ON ON ON ON ON =        00000  (00)    In the commercial Kaku manual this is systemcode 12345.
                                                                        OFF OFF OFF OFF OFF =   11111  (31)    In the commercial Kaku manual this is systemcode 0.
                                                                        ON OFF ON OFF ON =      01010  (10)    In the commercial Kaku manual this is systemcode 135.
                                                                        ON ON ON OFF OFF =      11100  (28)    In the commercial Kaku manual this is systemcode 123.
                                                                       
  These switch commands are the 'switch on' commands.
  Switch off command is 'switch on + 3'
 
    1361,4433,5201,5393,                //  00000  00  (A, B, C, D)
    17745,20817,21585,21777,            //  00001  01  (A, B, C, D)
    66897,69969,70737,70929,            //  00010  02  (A, B, C, D)
    83281,86353,87121,87313,            //  00011  03  (A, B, C, D)
    263505,266577,267345,267537,        //  00100  04  (A, B, C, D)
    279889,282961,283729,283921,        //  00101  05  (A, B, C, D)
    329041,332113,332881,333073,        //  00110  06  (A, B, C, D)
    345425,348497,349265,349457,        //  00111  07  (A, B, C, D)
    1049937,1053009,1053777,1053969,    //  01000  08  (A, B, C, D)
    1066321,1069393,1070161,1070353,    //  01001  09  (A, B, C, D)
    1115473,1118545,1119327,1119505,    //  01010  10  (A, B, C, D)
    1131857,1134929,1135697,1135889,    //  01011  11  (A, B, C, D)
    1312081,1315153,1315921,1316113,    //  01100  12  (A, B, C, D)
    1328465,1331537,1332305,1332497,    //  01101  13  (A, B, C, D)
    1377617,1380689,1381457,1381649,    //  01110  14  (A, B, C, D)
    1394001,1397073,1397841,1398033,    //  01111  15  (A, B, C, D)
    4195665,4198737,4199505,4199697,    //  10000  16  (A, B, C, D)
    4212049,4215121,4215889,4216081,    //  10001  17  (A, B, C, D)
    4261021,4264273,4265041,4265233,    //  10010  18  (A, B, C, D)
    4277585,4280657,4281425,4281617,    //  10011  19  (A, B, C, D)
    4457809,4460881,4461649,4461841,    //  10100  20  (A, B, C, D)
    4474193,4477265,4478033,4478225,    //  10101  21  (A, B, C, D)
    4523345,4526417,4527185,4527377,    //  10111  22  (A, B, C, D)
    4539729,4542801,4543569,4543761,    //  10111  23  (A, B, C, D)
    5244241,5247313,5248081,5248273,    //  11000  24  (A, B, C, D)
    5260625,5263697,5264465,5264657,    //  11001  25  (A, B, C, D)
    5309777,5312849,5313617,5313809,    //  11010  26  (A, B, C, D)
    5326161,5329233,5330001,5330193,    //  11011  27  (A, B, C, D)
    5506385,5509457,5510225,5510417,    //  11100  28  (A, B, C, D)
    5522769,5525841,5526609,5526801,    //  11101  29  (A, B, C, D)
    5571921,5574993,5575761,5575953,    //  01111  30  (A, B, C, D)
    5588305,5591377,5592145,5592337,    //  11111  31  (A, B, C, D)     

                                                                         
  by   on1bte    07/2014
 
*/

int Maskbyte[] = {B00000000,B00000000,B00000000,B11111110};
// 0 = no masking , 1 = masking
// In8,In7,In6,In5,In4,In3,In2,In1     In16,In15,In14,In13,In12,In11,In10,In9     In24,In23,In22,In21,In20,In19,In18,In17     In32,In31,In30,In29,In28,In27,In26,In25

unsigned long Code;
int Interface = 4;        // Amount of PCA9555D chips. To control 16 Pulsar relays you need 2 times PCA9555D. The first 16 inputs are on the first PCA9555D on address 0x20.
                          // The first 16 outputs are on address 0x24. The second 16 inputs are on 0x21, the second 16 outputs on 0x25, ...
int PulseDuration = 100;  // Pulseduration. Put this between 75 and 300ms
byte RData = 0x00;        // initial value Remote Data
byte In = 0x00;           // initial value Optocoupler board data
byte OnOff = 0x00;        // initial value OnOff bit
byte Pulse = 0x00;        // initial value Pulse bit
byte Bit = 0x00;          // initial value for Bit
byte Board = 0x00;        // initial value for Board
byte Port = 0x00;         // initial value for Port
byte Pin = 0x01;          // initial value for Pin

#define PCA9555 0x20    // 1st PCA9555D on adress 0x20
           
#define IN_P0 0x00       // Register 0 : Input port register Port 0
#define IN_P1 0x01       // Register 1 : Input port register Port 1
#define OUT_P0 0x02      // Register 2 : Output port register Port 0
#define OUT_P1 0x03      // Register 3 : Output port register Port 1
#define INV_P0 0x04      // Register 4 : Polarity Inversion register Port 0    --> 1 = polarty inverted , 0 = polarity retained
#define INV_P1 0x05      // Register 5 : Polarity Inversion register Port 1    --> 1 = polarty inverted , 0 = polarity retained
#define CONFIG_P0 0x06   // Register 6 : Configuration register Port 0   --> 1 = input , 0 = output (high value resistor tied to VDD at each pin)
#define CONFIG_P1 0x07   // Register 7 : Configuration register Port 1   --> 1 = input , 0 = output

#define PAUSE 250

#include <Wire.h>

#include <RCSwitch.h>

RCSwitch mySwitch = RCSwitch();

void setup() {
  Serial.begin(115200);
  mySwitch.enableReceive(0);  // Receiver on interrupt 0 => that is pin #2
  Wire.begin(); 
  for(int i =0; i < Interface/2; i++){
  Board = i;
  write_io (CONFIG_P0, B11111111);  // Configure Port 0 all input
  write_io (INV_P0, B00000000);     // Set Port 0 Bit polarity 
  write_io (CONFIG_P1, B11111111);  // Configure Port 1 all input
  write_io (INV_P1, B00000000);     // Set Port 1 Bit polarity
  delay (PAUSE);
 } 
  for(int i =0; i < Interface/2; i++){
  Board = i + 4;
  write_io (CONFIG_P0, B00000000);  // Configure Port 0 all output
  write_io (OUT_P0, B11111111);     // Set Port 0 All Bits High 
  write_io (CONFIG_P1, B00000000);  // Configure Port 1 all output
  write_io (OUT_P1, B11111111);     // Set Port 1 All Bits High
 }
}

void loop() {
  if (mySwitch.available()) {
   
    int value = mySwitch.getReceivedValue();
   
    if (value == 0) {
      Serial.print("Unknown encoding");
    } else {
  Code = mySwitch.getReceivedValue();
      switch (Code) {
    case 1394001:   
      Serial.println("15A^");
      RData = 0x01; RemoteSwitching();
      break;
    case 1394004:   
      Serial.println("15A_");
      RData = 0x00; RemoteSwitching();
      break;
    case 1397073:   
      Serial.println("15B^");
      RData = 0x03; RemoteSwitching();   
      break;
    case 1397076:   
      Serial.println("15B_");
      RData = 0x02; RemoteSwitching();
      break;
    case 1397841:   
      Serial.println("15C^");
      RData = 0x05; RemoteSwitching();
      break;
    case 1397844:   
      Serial.println("15C_");
      RData = 0x04; RemoteSwitching();
      break;
    case 1398033:   
      Serial.println("15D^");
      RData = 0x07; RemoteSwitching();
      break;
    case 1398036:   
      Serial.println("15D_");
      RData = 0x06; RemoteSwitching();
      break;
    case 4539729:   
      Serial.println("23A^");
      RData = 0x09; RemoteSwitching();
      break;
    case 4539732:   
      Serial.println("23A_");
      RData = 0x08; RemoteSwitching();
      break;
    case 4542801:   
      Serial.println("23B^");
      RData = 0x0B; RemoteSwitching();
      break;
    case 4542804:   
      Serial.println("23B_");
      RData = 0x0A; RemoteSwitching();
      break;
    case 4543569:   
      Serial.println("23C^");
      RData = 0x0D; RemoteSwitching();
      break;
    case 4543572:   
      Serial.println("23C_");
      RData = 0x0C; RemoteSwitching();
      break;
    case 4543761:   
      Serial.println("23D^");
      RData = 0x0F; RemoteSwitching();
      break;
    case 4543764:   
      Serial.println("23D_");
      RData = 0x0E; RemoteSwitching();
      break;
    case 5326161:   
      Serial.println("27A^");
      RData = 0x11; RemoteSwitching();
      break;
    case 5326164:   
      Serial.println("27A_");
      RData = 0x10; RemoteSwitching();
      break;
    case 5329233:   
      Serial.println("27B^");
      RData = 0x13; RemoteSwitching();
      break;
    case 5329236:   
      Serial.println("27B_");
      RData = 0x12; RemoteSwitching();
      break;
    case 5330001:   
      Serial.println("27C^");
      RData = 0x15; RemoteSwitching();
      break;
    case 5330004:   
      Serial.println("27C_");
      RData = 0x14; RemoteSwitching();
      break;
    case 5330193:   
      Serial.println("27D^");
      RData = 0x17; RemoteSwitching();
      break;
    case 5330196:   
      Serial.println("27D_");
      RData = 0x16; RemoteSwitching();
      break;
    case 5522769:   
      Serial.println("29A^");
      RData = 0x19; RemoteSwitching();
      break;
    case 5522772:   
      Serial.println("29A_");
      RData = 0x18; RemoteSwitching();
      break;
    case 5525841:   
      Serial.println("29B^");
      RData = 0x1B; RemoteSwitching();
      break;
    case 5525844:   
      Serial.println("29B_");
      RData = 0x1A; RemoteSwitching();
      break;
    case 5526609:   
      Serial.println("29C^");
      RData = 0x1D; RemoteSwitching();
      break;
    case 5526612:   
      Serial.println("29C_");
      RData = 0x1C; RemoteSwitching();
      break;
    case 5526801:   
      Serial.println("29D^");
      RData = 0x1F; RemoteSwitching();
      break;
    case 5526804:   
      Serial.println("29D_");
      RData = 0x1E; RemoteSwitching();
      break;               
    case 5571921:   
      Serial.println("30A^");
      RData = 0x21; RemoteSwitching();
      break;
    case 5571924:   
      Serial.println("30A_");
      RData = 0x20; RemoteSwitching();
      break;
    case 5574993:   
      Serial.println("30B^");
      RData = 0x23; RemoteSwitching();   
      break;
    case 5574996:   
      Serial.println("30B_");
      RData = 0x022; RemoteSwitching();
      break;
    case 5575761:   
      Serial.println("30C^");
      RData = 0x25; RemoteSwitching();
      break;
    case 5575764:   
      Serial.println("30C_");
      RData = 0x24; RemoteSwitching();
      break;
    case 5575953:   
      Serial.println("30D^");
      RData = 0x27; RemoteSwitching();
      break;
    case 5575956:   
      Serial.println("30D_");
      RData = 0x26; RemoteSwitching();
      break;
    case 345425:   
      Serial.println("07A^");
      RData = 0x29; RemoteSwitching();
      break;
    case 345428:   
      Serial.println("07A_");
      RData = 0x28; RemoteSwitching();
      break;
    case 348497:   
      Serial.println("07B^");
      RData = 0x2B; RemoteSwitching();
      break;
    case 348500:   
      Serial.println("07B_");
      RData = 0x2A; RemoteSwitching();
      break;
    case 349265:   
      Serial.println("07C^");
      RData = 0x2D; RemoteSwitching();
      break;
    case 349268:   
      Serial.println("07C_");
      RData = 0x2C; RemoteSwitching();
      break;
    case 349457:   
      Serial.println("07^");
      RData = 0x2F; RemoteSwitching();
      break;
    case 349460:   
      Serial.println("07D_");
      RData = 0x2E; RemoteSwitching();
      break;
    case 1131857:   
      Serial.println("11A^");
      RData = 0x31; RemoteSwitching();
      break;
    case 1131860:   
      Serial.println("11A_");
      RData = 0x30; RemoteSwitching();
      break;
    case 1134929:   
      Serial.println("11B^");
      RData = 0x33; RemoteSwitching();
      break;
    case 1134932:   
      Serial.println("11B_");
      RData = 0x32; RemoteSwitching();
      break;
    case 1135697:   
      Serial.println("11C^");
      RData = 0x35; RemoteSwitching();
      break;
    case 1135700:   
      Serial.println("11C_");
      RData = 0x34; RemoteSwitching();
      break;
    case 1135889:   
      Serial.println("11D^");
      RData = 0x37; RemoteSwitching();
      break;
    case 1135892:   
      Serial.println("11D_");
      RData = 0x36; RemoteSwitching();
      break;
    case 1328465:   
      Serial.println("13A^");
      RData = 0x39; RemoteSwitching();
      break;
    case 1328468:   
      Serial.println("13A_");
      RData = 0x38; RemoteSwitching();
      break;
    case 1331537:   
      Serial.println("13B^");
      RData = 0x3B; RemoteSwitching();
      break;
    case 1331540:   
      Serial.println("13B_");
      RData = 0x3A; RemoteSwitching();
      break;
    case 1332305:   
      Serial.println("13C^");
      RData = 0x3D; RemoteSwitching();
      break;
    case 1332308:   
      Serial.println("13C_");
      RData = 0x3C; RemoteSwitching();
      break;
    case 1332497:   
      Serial.println("13D^");
      RData = 0x3F; RemoteSwitching();
      break;
    case 1332500:   
      Serial.println("13D_");
      RData = 0x3E; RemoteSwitching();
      break;
    case 1115473:   
      Serial.println("10A^");
      RData = 0x01; all_on_off();
      break;
    case 1115476:   
      Serial.println("10A_");
      RData = 0x00; all_on_off();
      break;     
           
      default:
      // no valid code for this system :
      Serial.print("Received Code = ");
      Serial.println(Code);
      Serial.println("-----------------------");
    }
    delay (200);   // necessary !!!
  mySwitch.resetAvailable();
    }
  }
}


  void RemoteSwitching() {
    Serial.print("RData = ");
    Serial.println(RData, BIN);
   
    Bit = RData >>1 & 0x07;                        // Shift one to the right AND 0x07 gives the Output pin
    Pin = B00000001 << Bit;                        // Shift left to the correct bit position                               
    OnOff = RData & 0x01;                          // OnOff data is the least significant bit from RData
    OnOff = OnOff << Bit;                          // Bring OnOff bit to the same bitposition as the Pin to be used
    Port = RData >> 4 & 0x01;                      // Shift 4 times to the right AND 0x01 gives the port selection data
    Board = RData >> 5 & 0x07;                     // Shift 5 times to the right AND 0x07 gives the Board selection data
   
    Serial.print("Bit = ");
    Serial.println(Bit);
    Serial.print("Pin = ");
    Serial.println(Pin, BIN);   
    Serial.print("OnOff = ");
    Serial.println(OnOff, BIN);
    Serial.print("Port = ");
    Serial.println(Port, BIN);   
    Serial.print("Board = ");
    Serial.println(Board, BIN);
   
    read_io();                               // Go to subroutine read_io 
    In = In & Pin;                           // Select only the pin to be activated - Input Data AND Pin
    Serial.print("In = "); Serial.println(In, BIN);
   
    if (OnOff == In)
    {
      Serial.println("OnOff and In =="); Pulse = 0xFF;          // OnOff  In equal? --> No action
    }
    else
    {
      Serial.println("OnOff and In xx"); Pulse = ~Pin;        // OnOff  In not equal? --> the byte Pin is inverted and renamed to Pulse
    }
   
    Serial.print("Pulse = ");
    Serial.println(Pulse, BIN);
   
    Board = Board + 4;
   
    // Reinitialisation output register before and after a write. Pulsar Relays can cause a lot of interferences   
    write_io (CONFIG_P0, B00000000);  // Configure Port 0 all output
    write_io (OUT_P0, B11111111);     // Set Port 1 all bits high
    write_io (CONFIG_P1, B00000000);  // Configure Port 0 all output
    write_io (OUT_P1, B11111111);     // Set Port 1 all bits high
   
    write_io (OUT_P0 + Port, Pulse);                   // Go the subroutine write_io
    delay (PulseDuration);                             // Output pin stays low for a while
    write_io (OUT_P0 + Port, B11111111);               // All output pins High
   
    write_io (CONFIG_P0, B00000000);  // Configure Port 0 all output
    write_io (OUT_P0, B11111111);     // Set Port 1 all bits high
    write_io (CONFIG_P1, B00000000);  // Configure Port 0 all output
    write_io (OUT_P1, B11111111);     // Set Port 1 all bits high   
   
    Serial.println("-------------------------");
  }

 
   void write_io(int command, int value)
{
  Wire.beginTransmission(PCA9555 + Board);    // write to PCA9555 + Board
  Wire.write(command),Wire.write(value);
  Wire.endTransmission();
}


  void read_io()
{
  Wire.beginTransmission(PCA9555 + Board);
    Wire.write(IN_P0 + Port);                   // must act as a position pointer
    Wire.endTransmission();
    Wire.requestFrom(PCA9555 + Board, 1);       // request 1 byte
    In = Wire.read();                           // receive a byte
}     


  void all_on_off()
{
    for(int i =0; i < Interface/2; i++){
    Board = i;
   
      Serial.print("Board = ");
      Serial.println(Board, BIN);
     
      for(Port =0; Port < 2; Port++){
     
      Serial.print("Port = ");
      Serial.println(Port, BIN);           
       
      read_io();
     
      Serial.print("In = "); Serial.println(In, BIN);
      int Mask = 2*Board + Port;   // select Maskbyte
      Serial.print("Mask = "); Serial.println(Mask, BIN);
      Serial.print("Maskbyte = "); Serial.println(Maskbyte[Mask], BIN);
     
      OnOff = RData & 0x01;                          // OnOff data is the least significant bit from RData
     
      Serial.print("OnOff = ");
      Serial.println(OnOff, BIN);     

        if (OnOff == 1)
        {
          Serial.println("All^"); Pulse = In | Maskbyte[Mask];          // all on (taking maskbyte into account)
        }
        else
        {
          Serial.println("All_"); Pulse = ~In | Maskbyte[Mask];        // all off (taking Maskbyte into account)
        }     
     
      Serial.print("Pulse = ");
      Serial.println(Pulse, BIN);
     
      Board = Board + 4;

      // Reinitialisation output register before and after a write. Pulsar Relays can cause a lot of interferences   
      write_io (CONFIG_P0, B00000000);  // Configure Port 0 all output
      write_io (OUT_P0, B11111111);     // Set Port 1 all bits high
      write_io (CONFIG_P1, B00000000);  // Configure Port 0 all output
      write_io (OUT_P1, B11111111);     // Set Port 1 all bits high
   
      write_io (OUT_P0 + Port, Pulse);                   // Go the subroutine write_io
      delay (PulseDuration);                             // Output pin stays low for a while
      write_io (OUT_P0 + Port, B11111111);               // All output pins High
   
      write_io (CONFIG_P0, B00000000);  // Configure Port 0 all output
      write_io (OUT_P0, B11111111);     // Set Port 1 all bits high
      write_io (CONFIG_P1, B00000000);  // Configure Port 0 all output
      write_io (OUT_P1, B11111111);     // Set Port 1 all bits high
     
      Board = Board - 4;
     
      delay (PAUSE);

      Serial.println("-------------------------");
     
    }
  }
}   
     

Advertisement

Terug naar Afgeronde projecten

Wie is er online?

Gebruikers in dit forum: Geen geregistreerde gebruikers en 5 gasten