Arduino Nano + 4-kanaals relais: bedienen van rolruiten en AC-motoren

Onderdelen en benodigdheden

• Arduino Nano R3 (1x)
• ControlEverything.com 4-KANAALS RELAIS CONTROLLER VOOR I2C (1x)
• Solid state 4-kanaals bord (1x)
• Rolruitmotor (1x) — maximaal 4 motoren per Arduino
• Condensator 100 nF 630V (1x per motor)
• Weerstand 100 ohm (0,5W min!) (1x per motor) — geen precisieweerstanden (blauwe)!
• Varistor 275 VAC (1x per motor)
• Diode (willekeurige signaal- of power-diode) (3x per rolruit)
• Raspberry Pi 3 Model B (1x, optioneel — voor remote bediening)
• nRF24 Module (2x, optioneel — voor remote bediening)

Benodigde tools en machines

• Solderbout

Apps en online diensten

• Arduino IDE
• Domoticz (optioneel, voor remote bediening — elke andere automatiseringscontroller kan ook, of zelfs geen)

Over dit project

Inleiding

Net een nieuw huis gekocht en alles willen automatiseren, beginnend met de rolruiten. Wat een simpel project leek, werd een nachtmerrie: de relatief zware motoren (150W) vernietigden mijn relais en triacs, keuze van draadloze communicatie en controller was niet voor de hand liggend, ruis op de lijnen veroorzaakte willekeurige activatie van de rolruiten (best eng 's nachts)... Uiteindelijk loste ik alle problemen op met heel goedkope componenten en hoop ik iemand anders deze hoofdpijn en veel tijd te besparen.

Niet graag programmeren, wel graag solderen? Lees toch de tutorial — aan het einde vind je een discrete schakeling die hetzelfde doet, maar zonder intelligentie.

Uitleg

Bij het sturen van motoren is de inductie een belangrijk probleem: bij het openbreken van de stroom wil de stroom doorgaan door het schakelapparaat, wat extreme spanningspieken veroorzaakt. Een klein relais krijgt vastzittende contacten; een triac (solid state relais) wordt door de overspanning (ik meet pieken >1600V) vernield.

Anderen losten dit op met grote, dure relais (die nog steeds kleine relais nodig hebben om aan te sturen), maar de contacten lijden nog steeds. Als ingenieur wilde ik de meest efficiënte oplossing. In het schema hieronder is de oplossing: één weerstand, één condensator en één varistor per motor.

• De varistor beschermt de triac tegen overspanning.
• De RC-snubber (weerstand + condensator) absorbeert de energie tijdens het afschakelen.

PS: Na nader inzien van mijn bord zag ik dat ik de RC-snubber in de praktijk tussen de bruine en grijze draad van de motor had geplaatst (kleuren volgens schema), niet direct over de triac-contacten. Beide werken, maar het voordeel van de tweede optie is dat de snubber niet permanent op het net ligt.

PS2: SebDominguez maakte een mooi schema van de daadwerkelijke configuratie:

In plaats van 2 pinnen per rolruit (omhoog/omlaag), delen de schakelaars een gemeenschappelijke lijn voor richting. We gebruiken dus 5 inputs ipv 8. Geen filter nodig, softwarematig gedebounced.

De Arduino activeert eerst het relaisbord om de motorrichting te selecteren, na een kleine vertraging (contacten liggen dan vast) activeert hij de triac, voedt de motor met 230 VAC via de goedkope relais en triacs. Bij uitschakelen: eerst triacs, dan relais — relais maken dus nooit een levend schakelen.

Je kunt 1 tot 4 motoren aansluiten zonder code-wijziging. Ongebruikte motor-logica doet geen er toe, tenzij je de pinnen elders nodig hebt.

We hebben twee verdiepingen en dus twee circuits. Omdat remote-commando's uniek moeten zijn, werkt de code voor beide door bij upload één regel uit te commentariëren. Bij één circuit hoef je niets te veranderen. Eigenlijk hebben we drie circuits (totaal 8 rolruiten): één vol (4 motoren), de andere twee gesplitst (3 + 1 motor). Gedupeerde circuits reageren identiek op remote-commando's; waar niets aangesloten is, gebeurt er niets. Met de MySensors-versie kun je tot 256 nodes met elk 4 rolruiten aansturen zonder code-wijziging.

Past in een 22×15×5,2 cm inbouwdoos (wel krap). Ik monteerde alles in een open houten doos met lijmpistool: praktisch, snel, makkelijk.

Als je de Arduino Web IDE gebruikt, vindt hij automatisch alle benodigde bibliotheken.

Remote bediening (optioneel)

De code bevat twee manieren voor remote bediening via nRF24L01+:

1. MySensors (aanbevolen)
2. Direct een integer sturen met rolruit-nummer en commando (0/1 voor omhoog/omlaag)

In beide gevallen gebruik ik een RPi als master met nRF24L01+ direct aangesloten, en Domoticz als controller.

Optie 1: MySensors

Installeer MySensors MQTT gateway (mysensors.org). Mijn configuratie (Ethernet op localhost):

sudo ./configure --my-gateway=mqtt --my-controller-ip-address=127.0.0.1 \
  --my-mqtt-publish-topic-prefix=domoticz/in/MyMQTT \
  --my-mqtt-subscribe-topic-prefix=domoticz/out/MyMQTT \
  --my-mqtt-client-id=mygateway1 --my-transport=rf24 \
  --my-port=1883 --my-rf24-irq-pin=15

Integratie in Domoticz: voeg hardware "MySensors MQTT gateway" toe, voed de node, hij wordt direct gevonden.

Optie 2: Custom applicatie

Een virtuele schakelaar voert het console-commando uit:

./remote -m XY

(X: rolruit #, Y: actie). Details in de header van de Arduino sketch.

De code voor deze remote-opdracht is beschreven op hack.lenotta.com. Neem alleen de sectie "The Lamp Switch Application". De hardware-sectie is nuttig voor radio-aansluitingen. Altijd een 10 µF condensator op de voedingspinnen van de radio module. Overweeg een module met externe antenne; binnen is het bereik van de PCB-antenne vaak <10m, zeker als modules in muren zitten.

De code moet aangepast worden: radio-parameters matchen met Arduino, en enkelvoudig versturen (geen retries tot 5x) om "acteren-stil-acteren" te voorkomen.

Finale Raspberry Pi code (remote.c)

#include <unistd.h>
#include <string>
#include <getopt.h>
#include <cstdlib>
#include <sstream>
#include <iostream>
#include <RF24/RF24.h>
using namespace std;

RF24 radio(RPI_V2_GPIO_P1_22, RPI_V2_GPIO_P1_24, BCM2835_SPI_SPEED_8MHZ);
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };
unsigned long got_message;

void setup(void) {
  printf("\nPreparing interface\n");
  radio.begin();
  radio.setRetries(15, 15);
  radio.setChannel(0x70);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_MAX);
  radio.printDetails();
  radio.openWritingPipe(pipes[0]);
  radio.openReadingPipe(1, pipes[1]);
}

bool sendMessage(int action) {
  radio.stopListening();
  unsigned long message = action;
  printf("Now sending %lu...", message);
  bool ok = radio.write(&message, sizeof(unsigned long));
  if (!ok) { printf("failed...\n\r"); }
  else { printf("ok!\n\r"); }
  radio.startListening();
  unsigned long started_waiting_at = millis();
  bool timeout = false;
  while (!radio.available() && !timeout) {
    if (millis() - started_waiting_at > 1000) timeout = true;
  }
  if (timeout) {
    printf("Puta mierda, no me responde nadie...\n\r");
    return false;
  } else {
    radio.read(&got_message, sizeof(unsigned long));
    printf("Yeah, me han respondido > %lu.\n\r", got_message);
    return true;
  }
}

int main(int argc, char **argv) {
  char choice;
  setup();
  bool switched = false;
  int counter = 0;
  while ((choice = getopt(argc, argv, "m:")) != -1) {
    if (choice == 'm') {
      printf("\nTalking with my NRF24l01+ friends out there....\n");
      while (switched == false && counter < 1) {
        switched = sendMessage(atoi(optarg));
        counter++;
        sleep(1);
      }
    } else {
      printf("\n\rIt's time to make some choices...\n");
      printf("\n\rTIP: Use -m idAction for the message to send.");
      printf("\n\rExample (id 12, action 1):\nsudo ./remote -m 121\n");
    }
  }
  return (counter < 5) ? 0 : 2;
}

Compileren is nodig; ik heb een zip met alles (bron, bibliotheken, gecompileerde binary voor RPi3) gemaakt: goo.gl/ocCwk3. Uitpakken op de RPi en ./remote draait direct.

Het resultaat

Drie schakelaarparen bedienen drie rolruiten. De tablet toont Domoticz met virtuele schakelaars. Achter de tablet zit de Raspberry Pi (controller). De Arduino zit bij de rolruiten; RPi en Arduino communiceren draadloos via nRF24L01+.

Google Home + IFTTT Webhooks + Domoticz = stemcommando's ("Hey Google, rolruiten dicht"). Als je hier bent gekomen, lukken stemcommando's zeker.

Er is een korte video van het resultaat.

Laat weten of deze tutorial geholpen heeft!

Groetjes,
gomecin

Extra: Uit nieuwsgierigheid of omdat je computers/programmeren haat, probeerde ik eerst een discrete oplossing zonder intelligentie:

Ik bouwde het, het werkt, maar ik was toen nog niet bekend met Arduino — wat flexibeler en betrouwbaarder is. Ik raad deze discrete versie af; het valt buiten de scope van deze tutorial.

Code

Arduino sketch

(Zie originele projectpagina voor de volledige sketch)

Schema