eCurtains – automatisch gordijnen bedienen

Ik liep al een tijdje met de gedachte rond om mijn gordijnen in het huis automatisch open en dicht te kunnen doen. Dit is bijvoorbeeld ook handig als je op vakantie bent. Nu zijn hiervoor kant en klare oplossingen, maar deze zijn schrikbarend duur. Dat moet ik zelf toch ook kunnen maken dacht ik. Ik ben toen eens gaan nadenken en heb het ‘eCurtains’ project bedacht. Met behulp van een Arduino Wifi board en een stappen motor ga ik gordijnen aansturen.

De stappenmotor stuurt een band aan waar ik de gordijnen aan bevestig. Het volgende plaatje maakt dit duidelijker.

De stappenmotor stuur ik tenslotte weer aan met een ‘ULN Stepper Motor Driver’ die aangesloten is op de Arduino ESP8266. Ik kan de ESP8266 draadloos via een Web-Interface en/of API bedienen.

Benodigheden

Je hebt de volgende zaken nodig voor dit project:

1 x Breadboard 400
1 x NodeMcu ESP8266 (CH340/CP2102)
1 x MB102 Breadboard Power Supply Module 3.3V 5V
1 x 28BYJ-48 Stepper Motor + ULN2003 Driver Board Module
1 x Waterproof ABS Plastic Electronic Enclosure Project Box Case Black 125 x 80 x 32 mm
1 x Voltcraft 12V/DC 2250 mA 27W Adapter (Euro 16,50)
1 x GT2 40T 5 mm Timing Pulley
1 x GT2 20T 5 mm Timing Pulley
1 x 10 meter GT2 Timing Belt 6 mm
1 x Silk Satin Ribbon 6 mm

Zoals je ziet heb ik een dure voeding in het lijstje hierboven staan terwijl je op eBay veel goedkopere voedingen vind. Ik heb geen voeding van eBay gekozen daar ik voedingen uit China niet helemaal vertrouw en ik geen brand wil riskeren.

Als je de gordijnen ook nog met een schakelaar (via Pimatic) wilt bedienen dan heb je ook nog nodig:

1 x 433MHz Universal Wireless Remote Control 2 Button

Uiteindelijk ben je ongeveer Euro 35,= kwijt aan materialen per gordijn paar dat je wilt bedienen (waarvan Euro 16,50 voor de voeding).

Update 5 juni 2018:

De 28BYJ-48 stappen motor draait wel langzaam. Met een Nema17 stappen motor gaat het een stuk sneller. Ik heb eCurtains inmiddels voorbereid om ook een Nema17 stappen motor te ondersteunen. In de volgende blog leg ik uit hoe je een Nema17 stappen motor kunt gebruiken en aansluit in eCurtains.

Aansluiten

Het aansluiten is heel eenvoudig als je de pin-aansluitingen van je ESP8266 module weet:

Plaats het 3.3V/5V Breadboard Power Supply Module op het Breadboard en zet de dip-switches op 5V. Plaats nu de ESP8266 hier achter en sluit de 5V van de Power Supply Module aan op de Vin pin van de ESP8266. Doe hetzelfde voor de GND die je op op de GND pin van de ESP8266 aansluit. Sluit IN1, IN2, IN3 en IN4 van de ULN Stepper Motor Driver aan op respectievelijk D1, D2, D5 en D6 van de NodeMCU. Sluit verder de andere 5V en GND van de Breadboard Power Supply Module aan op de ULN Stepper Motor Driver.



Tenslotte moet je nog de stappen motor inpluggen op je ULN Stepper Motor Driver en de Breadboard Power Supply Module op de Power Supply Adapter.

Programmeren

Het aansturen van de stappen motor is niet moeilijk (zie ook het volgende artikel met veel achtergrond informatie). We gebruiken hiervoor de Arduino IDE software die je hier kunt downloaden. Voordat we aan de slag gaan moet we nog wat instellingen in de Arduino IDE veranderen. Vul bij ‘File > Preferences’ voor ‘Additional Boards Manager URLs’ de volgende waarde in:

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Ga naar Open Boards Manager vanaf ‘Tools > Board’. Scroll naar beneden en selecteer ‘esp8266 by ESP8266 Community’. Kies nu ‘install’.



Ga verder naar ‘Sketch > Include Library > Manage Libraries…’ en installeer de ‘AccelStepper’ library van Mike McCauley.



We zijn nu klaar om eindelijk te gaan programmeren. Om de stappenmotor aan te sturen kun je onderstaande code-snippet gebruiken

// For ESP8266
#include                                // ESP8266 WiFi
#include                                // ESP8266 Web Server
#include                                // EEPROM
#include                                // Serial Peripheral Interrface
#include                                // File system

// For Steppermotor
#include                                // Acceleration Stepper Driver

//
// Steppermotor settings
//
#define STEPS_PER_REVOLUTION  2048      // Steps per Revolution

#define MOTOR_ACCELERATION   100.0      // Acceleration of motor 
#define MOTOR_MAX_SPEED      250.0      // Maximum speed of motor

#define MOTOR_PIN1              D1      // IN1 pin on ULN2003A Driver => GPIO16
#define MOTOR_PIN2              D2      // IN2 pin on ULN2003A Driver => GPIO5
#define MOTOR_PIN3              D5      // IN3 pin on ULN2003A Driver => GPIO14
#define MOTOR_PIN4              D6      // IN4 pin on ULN2003A Driver => GPIO12

// Initialize for using AccelStepper with 28BYJ-48
// Remark: use pin sequence: IN1-IN3-IN2-IN4 when using the AccelStepper with 28BYJ-48
AccelStepper  Stepper( AccelStepper::FULL4WIRE, MOTOR_PIN1, MOTOR_PIN3, MOTOR_PIN2, MOTOR_PIN4 );

// -----------------------------------------------------------------------------------------
// setup
// Default setup() method called once by Arduino
// -----------------------------------------------------------------------------------------
void setup() 
{
  // Setup serial port for your Serial Monitor
  Serial.begin( 115200 );
 
  // Move motor 3 rotations
  move_motor ( 3.0 );
 
  // Wait 1 second
  delay (1000);
 
  // Move motor 3 rotations back
  move_motor ( -3.0 )
}

void move_motor (float no_rotations)
{
  // Set maximum of motor speed
  Stepper.setMaxSpeed ( MOTOR_MAX_SPEED );

  // Set acceleration8
  Stepper.setAcceleration ( MOTOR_ACCELERATION );

  // Give stepper instruction to move motor
  Stepper.move( no_rotations * STEPS_PER_REVOLUTION);
}

Verder moet je in je Arduino ‘loop’ functie de ‘run’ methode van de Stepper aanroepen:

//
// loop ()
// Here you find the main code which is run repeatedly
//
void loop() 
{
  // Control movement of motor
  Stepper.run(); 
}

Ik ben hiermee verder aan de slag gegaan en heb uitgebreide software geschreven voor mijn ‘eCurtains’ project. De software bestaat uit meer dan 2650 regels source-code en hiermee kun je via een Web-Interface of API de stappen motor aansturen. Om de software op je ESP8266 te krijgen moet je de volgende stappen doorlopen:

• In de Arduino IDE kies je in ‘File > Open’ menu de file ‘eCurtains.ino’ in de directory waar je deze hebt opgeslagen
• Zet in ‘File > Preferences’ je ‘Sketchbook location’ naar de lokatie waar je ‘eCurtains’ hebt opgeslagen
• Kies nu ‘Sketch > Verify/Compile’
• Sluit je ESP8266 board via USB aan op je computer
• Stel je upload poort in bij ‘Tools > Port’ (bijvoorbeeld /dev/ttyUSB0 op Debian of COM4 op Windows)
• Kies ‘Sketch > Upload’

Als je Port niet juist ingesteld krijgt met Windows dan moet je wellicht nog de FTDI USB Drivers installeren op je computer

eCurtains software

Initiëel zal je ESP8266 opstarten als een Access Point (AP Mode). Wacht totdat je ‘eCurtains’ ziet verschijnen bij je draadloze netwerken. Maak verbinding met de SSID ‘eCurtains‘ en vul voor wachtwoord ‘eCurtains’ in. Ga vervolgens met je browser naar 192.168.4.1 en vul de Wifi gegevens van je lokale Wifi netwerk in en druk op [Submit].

Als het goed is gegaan verschijnt er OK op het browser-scherm. Herstart nu de ESP8266 (door reset knopje op ESP8266 te drukken of even de stroom eraf halen). De ESP8266 zal na de herstart automatisch verbinding maken met je Wifi Netwerk. Controleer welk IP adres je ESP8266 heeft gekregen van je DHCP server en ga met je browser naar dit IP-adres. Je krijgt nu een login-scherm te zien.



De standaard gebruikers-naam is ‘admin‘ en hier hoort standaard het wachtwoord ‘notdodo‘ bij. Deze gegevens kun je eventueel later in de Web-Interface van ‘eCurtains’ aanpassen bij [Instellingen]. Na het invullen van deze gegevens verschijnt de web-interface.



Idee achter de ‘eCurtains’ software is dat je eerst je stappen motor gaat calibreren voor je gordijnen. Stel de ‘linkse’ en ‘rechtse’ grens (open en dicht) van je gordijnen in door het bewegen van de stappen motor. stel vervolgens de drempel waarde voor links en rechts in. Op deze manier kan de motor nooit voorbij deze punten komen. Ik denk dat de Web-Interface voor zichzelf spreekt en geen verdere uitleg nodig heeft.

Je kunt met [Instellingen] de taal, hostnaam en motor instellingen veranderen. Let op dat je de maximale snelheid niet te hoog instelt, want dat gaat ten koste van je ’torque’, waardoor de motor gemakkelijker zal ‘slippen’ bij tegenkracht. Je kunt hiermee experimenteren en een goede waarde instellen voor jouw gordijnen (afhankelijk hoe gemakkelijk je deze normaal gesproken kunt bewegen).

Wil je nu de gordijnen open doen dan druk je in de web-interface op de [Helemaal Links] knop. Voor dicht doen druk je op de [Helemaal Rechts] knop. Je kunt de ESP8266 ook via een API besturen. Dat is handig als je dit project in Pimatic wilt integreren. Je kunt bijvoorbeeld in Pimatic een knop definieren en dan een ‘curl’ commando uitvoeren met deze API.

Het formaat van de API actions is als volgt:

http://ip-address/api?action=xxx&value=yyy&api=zzz

De ‘value’ is afhankelijk van de ‘action’ optioneel. De API moet altijd (vanuit veiligheids oogpunt) meegegeven worden. De default API key waarde is ‘27031969’. Je kunt deze eenmalig met ‘set_api’ veranderen. Op dit moment worden de volgende API actions ondersteund:

reboot, value             (value=false of true)
reset, value              (value=false of true)

set_api, value            (value=nieuwe API key)
set_host, value           (value=nieuwe host-name)
set_language, value       (0=Engels, 1=Nederlands)

reset_left
reset_current
reset_right

set_left, [value]         (indien geen value opgegeven dan huidige positie)
move_motor, value
set_right, [value]        (indien geen value opgegeven dan huidige positie)
stop_motor

motor_acceleration, value (value=acceleration)
motor_max_speed, value    (value=maximum speed)

move_total_left
move_total_right

Om bijvoorbeeld de host-name van je ESP8266 te veranderen gebruik je:

http://ip-address/api?action=set_host&value=my_host&api=your_api

Upgraden eCurtains

Je kunt tenslotte ook nog ‘eCurtains’ via de Web-Interface updaten (dus via Wifi zonder draad). Dat is handig als je alles al ingebouwd hebt. Hiervoor maak je gebruik van de gecompileerde code. Dit doe je door in de Arduino IDE ‘Sketch > Export Compiled Binary’ te kiezen. Er zal dan een ‘bin’ file gegenereerd worden in de directory van je ‘eCurtains.ino’ sketch file. Deze kun je dan uploaden via de volgende verborgen URL van de ‘eCurtains’ Web-Interface:

http://ip-adres/upgradefw

Uit veiligheids oogpunt moet je wel eerst in de web-interface ingelogd zijn wil je deze URL kunnen gebruiken.

Kies de file-naam van je ‘bin’ en druk op de [Upgrade] knop. Na 1 minuutje zal je ESP8266 van nieuwe software zijn voorzien en automatisch worden herstart. Indien de major versie (getal voor de punt) van ‘eCurtains’ is veranderd dan zal de software weer in AP mode opstarten en worden alle instellingen gereset. Je moet dan alles weer opnieuw instellen.

Installeren van de Hardware

Tot nu toe hebben we nog niks met de gordijnen zelf gedaan. We gaan nu de hardware verbinden met de gordijnen. Ik heb hiervoor gebruik gemaakt van een behuizing voor de stappen-motor. Ik heb de volgende STL file opgestuuurd naar 3D Printservice. Binnen een aantal dagen ontvang je deze als 3D print terug:

De ESP8266 met voeding en Motor Driver heb ik ingebouwd in een zwarte 125 x 80 x 32 mm enclosure box. Deze box en de stappenmotor in de 3D print (gebruik M2.2 x 8 schroefjes) plaats ik aan 1 kant van het gordijn.

Om de band op maat te maken heb ik de volgende youtube video gebruikt:

Aan de andere kant van het gordijn heb ik een as met tandwiel bedacht die ik strak zet met een veer. De onderdelen hiervoor heb ik bij de Praxis gehaald.

De gordijnen bevestig ik met een dun ijzerdraadje aan de band. Uiteindelijk ziet het er zo uit in actie:

Pimatic/Domoticz integratie

Aangezien ‘eCurtains’ een API heeft kun je deze heel gemakkelijk in Pimatic of Domoticz integreren.  Voor Pimatic maak je een ‘ButtonsDevice’ aan:

{
  "id": "curtains-front-buttons",
  "name": "Voorkant",
  "class": "ButtonsDevice",
  "buttons": [
    {
      "id": "curtains-back-open",
      "text": "Open"
    },
    {
      "id": "curtains-back-close",
      "text": "Dicht"
    },
    {
      "id": "curtains-back-left",
      "text": " < " 
    }, 
    {
      "id": "curtains-back-stop",
      "text": " o "
    },
    { 
      "id": "curtains-back-right", 
      "text": " > "
    }
  ]
}

Aan elke button hang je dan een “rule” die je API aanstuurt. Zie het onderstaande voorbeeld:

{
  "id": "rule-curtains-back-open",
  "name": "Gordijnen Achter Open",
  "rule": "when curtains-back-open is pressed then execute \"curl -s http://192.168.1.80/api?action=move_total_left 2> /dev/null\"",
  "active": true,
  "logging": true
},
{
  "id": "rule-curtains-back-close",
  "name": "Gordijnen Achter Dicht",
  "rule": "when curtains-back-close is pressed then execute \"curl -s http://192.168.1.80/api?action=move_total_right 2> /dev/null\"",
  "active": true,
  "logging": true
},
{
  "id": "rule-curtains-back-left",
  "name": "Gordijnen Achter Links",
  "rule": "when curtains-back-left is pressed then execute \"curl -s http://192.168.1.80/api?action=move_motor'&'value=-5'&'api=your_api' > /dev/null\"",
  "active": true,
  "logging": true
},
{
  "id": "rule-curtains-back-stop",
  "name": "Gordijnen Achter Stop",
  "rule": "when curtains-front-stop is pressed then execute \"curl -s http://192.168.1.80/api?action=stop_motor'&'api=27031969 > /dev/null\"",
  "active": true,
  "logging": true
},
{
  "id": "rule-curtains-back-right",
  "name": "Gordijnen Achter Rechts",
  "rule": "when curtains-back-right is pressed then execute \"curl -s http://192.168.1.80/api?action=move_motor'&'value=5'&'api=your_api' > /dev/null\"",
  "active": true,
  "logging": true
}

In het bovenstaand voorbeeld wordt bij de betreffende knop ‘curl’ aangeroepen met de juiste syntax.

Voor Domoticz maak je een Dummy Switch aan waaraan je een selector hangt.

Vervolgens maak je een rule aan waarin je reageert op drukken van de selecties:

commandArray = {}

-- loop through all the changed devices
for deviceName,deviceValue in pairs(devicechanged) do
    
    -- Gordijn Achter Links (Open)
    if (deviceName=='Dummy Gordijn Achter Links') then
        print("Knop Gordijnen Achter Links gedrukt")

        os.execute("curl -s http://192.168.1.81/api?action=move_total_left'&'api=your_api 2> /dev/null &")
        
    -- Gordijn Achter Stop
    elseif (deviceName=='Dummy Gordijn Achter Stop') then
        print("Knop Gordijnen Achter Stop gedrukt")

        os.execute("curl -s http://192.168.1.81/api?action=stop_motor'&'api=your_api 2> /dev/null &")

    -- Gordijn Achter Rechts (Close)
    elseif (deviceName=='Dummy Gordijn Achter Rechts') then
        print("Knop Gordijnen Achter Rechts gedrukt")

        os.execute("curl -s http://192.168.1.81/api?action=move_total_right'&'api=your_api 2> /dev/null &")

    end
end

return commandArray

Voor de WAF (Wife Acceptance Factor) heb ik ook nog 2 fysieke knoppen toegevoegd. Op eBay vond ik een 433MHz RF Switch (US$ 4,50).

Hiermee kun je een signaal naar Pimatic/Domoticz sturen die dan vervolgens weer de API van ‘eCurtains’ aanstuurt.

Hoe kom ik aan de software?

Ik ben nu bijna 8 jaar met deze blog bezig en heb in die tussentijd alles bij elkaar opgeteld ongeveer 1.000.000 hits gehad en 895.000 bezoekers. In al die tijd hebben tot nu toe 7 mensen de moeite genomen om een kleine bijdrage te leveren omdat de informatie hen geholpen had. Dit terwijl bijvoorbeeld mijn blogs over reparatie van de Humax Receiver, Vaatwas Machine en Combi-Magnetron vele mensen honderden Euro’s hebben bespaard.

Daarom wil ik eens wat anders proberen deze keer. Je kunt de software van dit ‘eCurtains’ project bij mij kopen voor een kleine bijdrage van Euro 5,=. Als je deze wilt hebben moet je dit bedrag overmaken naar mijn bankrekeningnummer NL70RABO0145390640 ten name van H.M.M. Matthijssen onder vermelding van je email-adres en de toevoeging ‘eCurtains’. Ik stuur je dan de source-code toe zodat je zelf de code kunt compileren en/of aanpassen. Ik hoop dat je begrip hebt voor deze actie.

Als alternatief (indien je de software niet wilt kopen) kun je zelf aan de slag gaan. Dit artikel zou genoeg input moeten bevatten om je op weg te helpen.

Initializing

EEPROM Hostname     : eCurtains
EEPROM eCurtains version : 1.06
EEPROM Language     : Nederlands
EEPROM API key      : 27031969
EEPROM API key set    : 0

EEPROM Web User     : admin
EEPROM Web Password   : notdodo

EEPROM Motor + driver  : Nema17 + A4988
EEPROM Steps/Revolution : nan
EEPROM Acceleration   : 100.00
EEPROM Max Speed     : 250.00

EEPROM Position (left)  : -100.00
EEPROM Position (prv)  : 0.00
EEPROM Position (cur)  : 0.00
EEPROM Position (right) : 100.00

EEPROM ssid       : 
EEPROM password     : 

No WiFi configuration found, starting in AP mode

SSID     : 'eCurtains'
Password   : 'eCurtains'

Connected to : 'eCurtains'
IP address  : 192.168.4.1

Connected in AP mode thus display simple WiFi settings page

Initializing AccelStepper for Nema17 + A4988

HTTP server started

No WiFi configuration found, starting in AP mode
SSID     : ‘eCurtains’
Password   : ‘eCurtains’

settings_html_page += "<html lang=nl-NL><head><meta http-equiv='refresh' content='5'/>"; 

   else if (action == "motor_acceleration")
   {
     Serial.println("Handle 'motor_acceleration' action");

     // Flash internal LED
     flash_internal_led();

     g_data.motor_acceleration = value.toFloat();
     EEPROM.put( g_start_eeprom_address, g_data);
     EEPROM.commit();

     server.send ( 200, "text/html", "OK");
     delay(200);     
   }

 // Set acceleration
 g_AccelStepper.setAcceleration ( g_data.motor_acceleration );

 // Set maximum motor speed
 g_AccelStepper.setMaxSpeed ( g_data.motor_max_speed );

 // Initialize AccelStepper library:
 if (g_data.stepper_motor_and_driver == 0)
 { 
   // 28BYJ-48 + ULN
   // Remark: use pin sequence: IN1-IN3-IN2-IN4 when using the AccelStepper with 28BYJ-48   
   g_AccelStepper = AccelStepper( AccelStepper::FULL4WIRE, MOTOR_PIN1, MOTOR_PIN3, MOTOR_PIN2, MOTOR_PIN4 );

   Serial.println();
   Serial.println("Initializing AccelStepper for 28BYJ-48 + ULN");
 }
 else
 {
   // Nema17 + A4988
   // Remark: connect MOTOR_PIN1 to 'direction' and MOTOR_PIN2 to 'steps' of A4988 Driver
   g_AccelStepper = AccelStepper( AccelStepper::DRIVER, MOTOR_PIN2, MOTOR_PIN1 );

   // Set 'reset' pin to HIGH
   pinMode( MOTOR_PIN4, OUTPUT);
   digitalWrite( MOTOR_PIN4, HIGH );

   Serial.println();
   Serial.println("Initializing AccelStepper for Nema17 + A4988");
 }

   // Action: stepper_motor
    else if (action == "stepper_motor")
  {
   Serial.println("Handle 'stepper_motor' action");

   // Flash internal LED
   flash_internal_led();

   g_data.stepper_motor_and_driver = value.toInt();
   EEPROM.put( g_start_eeprom_address, g_data);
   EEPROM.commit();

    
   char buffer[256];
   sprintf( buffer, "OK (stappenmotor gewijzigd '%s')", g_data.stepper_motor_and_driver );
    
   server.send ( 200, "text/html", "OK");
   delay(200);  
  }

 // Initialize AccelStepper library:
 if (g_data.stepper_motor_and_driver == 0)
 { 
  // 28BYJ-48 + ULN
  // Remark: use pin sequence: IN1-IN3-IN2-IN4 when using the AccelStepper with 28BYJ-48  
  g_AccelStepper = AccelStepper( AccelStepper::FULL4WIRE, MOTOR_PIN1, MOTOR_PIN3, MOTOR_PIN2, MOTOR_PIN4 );

  Serial.println();
  Serial.println("Initializing AccelStepper for 28BYJ-48 + ULN");
 }
 else
 {
  // Nema17 + A4988
  // Remark: connect MOTOR_PIN1 to 'direction' and MOTOR_PIN2 to 'steps' of A4988 Driver
  g_AccelStepper = AccelStepper( AccelStepper::DRIVER, MOTOR_PIN2, MOTOR_PIN1 );

  // Set 'reset' pin to HIGH
  pinMode( MOTOR_PIN4, OUTPUT);
  digitalWrite( MOTOR_PIN4, HIGH );

  Serial.println();
  Serial.println("Initializing AccelStepper for Nema17 + A4988");
 }

 // Set acceleration
g_AccelStepper.setAcceleration ( g_data.motor_acceleration ); 

// Set maximum motor speed 
g_AccelStepper.setMaxSpeed ( g_data.motor_max_speed );

   // Set new 'Stepper Motor & Driver', 'Steps Per Revolution, 'Motor Acceleration' and 'Max Speed'
   if (g_data.stepper_motor_and_driver == 0)
   {
     g_data.steps_per_revolution = STEPS_PER_REVOLUTION_28BYJ;
   }
   else
   {
     g_data.steps_per_revolution = STEPS_PER_REVOLUTION_NEMA17;
   }