Monday, August 15, 2016

Control AC Devices over the Internet



When I built the project described in my post on controlling devices from a smartphone, my brother-in-law said "yeah, but can you do that over the internet?"  The answer was yes, but I needed to wait until my +Adafruit Industries Feather Huzzah with ESP8266 WiFi arrived. I had already decided to use adafruit.io as the browser component.  It was super easy to set up a dashboard and two feeds-a button interface to turn the light on and off and a text feed (output from the Huzzah) so I could see what the code thinks it's doing (see the tutorials at the adafruit.io link provided above.

By following the tutorials and code examples, and cloning what I could from tmy bluetooth project (see above), I got it working very quickly.  However, I wanted it to be a useful device that I could give to my brother-in-law. As noted in other posts, he has helped with all kinds of projects.  So, I needed a project box, a circuit board and a few other things, and I needed to do some designing. My first thought was to find a 120V relay and make my own Power Switch Tail.  In studying the schematic, I found that there were all kinds of circuit protections included, so I decided to go with a commercial product.  The powerswitch was US$26, so I looked for an alternative.  I found this AC/DC Control Relay on Amazon. The price has gone up by $2 since I bought it, but it's still $9 less than the powerswitch and has more capability. For example, it has 4 receptacles, 2 normally off and 2 normally on, so it can control multiple devices.

Parts and supplies list, partially annotated

  • AC/DC Comtrol Relay (takes input from the Huzzah: a signal line and a ground line; different from powerswitch tail, which also takes a DC power input; in addition the logic is opposite--power swith tail closes the relay on LOW, this one closes it on HIGH) )
  • +Adafruit Industries Feather Huzzah with ESP8266 WiFi Board
  • 2-wire JST connectors (connect to the relay)
  • LEDs (I used 5mm, one green, one red)
  • resistors (current-limiting for LEDs--I used 330Ohm)
  • 22-gauge solid core hookup wire 
  • tinned copper bus wire
  • project box (this was tight, but I wanted it small)
  • circuit board (I started to use plain perf board, but it broke--these boards were not quite the right size, so I had to file them. The soldering pads were useful.)
  • 3/8" 4-40 machine screws (to attache the circuit board to the standoffs in the box)
  • Drill and bits
  • A set of files (to deburr the drilled holes, and to size the holes properly)
  • Normal project tools: soldering iron and accessories, multimeter, strippers, clippers, helping hands and/or Panavise Jr., and the like
  • Super Glue or the like to fix the LEDs and JST to the box
  • Heat shrink tubing

Concept

The circuit is very simple, maybe deceptively so.  As you will see in the code, it connects to wifi, then connects to adafruit.io, and turns everything off at the start (in setup), then waits for orders from adafruit.io.  The toggle button on the adafruit.io dashboard sends info to the Huzzah, and depending on the state of the lamp (or whatever device you have plugged into the relay), it toggles the state.

The LEDs are used as indicators.  The green LED turns on after successful connection to adafruit.io (if it's not on, there's a problem). The red LED turns on and off with the lamp or other device (also to help see what's going on).

Schematic


Assembly

I spent a lot of time planning where to put the LEDS and the JST connectot. I had some scrap ABS plastic left from my robot cart project, so I used that to test a few options:




I wanted the JST to be recessed, but that didn't work out. I liked the LED holders, but they took up too much room in the box.

I drilled a hole in one end of the box for the USB cable, then drilled 3 3/16" holes in one side for the LEDs and JST connector.  The holes needed to be enlarged, so I took time to get just enough room to get the components through, while still not allowing the whole component to pass.

I had to expand two of the mounting holes on the circuit board to get the screws through. The other two holes did not line up with the standoffs.  I planned to mount the board with the soldering pads down, so I could keep the minimal wiring out of the way.

I positioned the Huzzah on the board, and used hookup wire to fix the back end to the circuit board through the mounting holes.  I had to remove one later to allow access to one of the LED holes in the case.  I ran black hookup wire under the board from the HUZZAH GND pin to the Ground bus on the other side of the board.  I soldered the hookup wire to the GND pin and to the soldering pad in the corner of the opposite side.  I ran tinned copper bus wire from the hookup wire down that side of the board and soldered each corner.


Next, I conencted the 330Ohm resistors through the board to the Ground bus and soldered them to it, then cut the wires on the female end of the JST to length, positioned it in the hole in the box, and soldered the black wire to the Ground bus and the red wire to pin 2 (see schematic above).

Note: if I were to do this again, I would run the Ground bus down the opposite side of the board, solder one end of the resistors to it on the underside, and solder the other ends of the resistors to the ground leads of the LEDs. That would make it neater.

I then took the time to test the circuit to be sure the connections were OK.  Using the Arduino IDE serial monitor and the relay with a lamp plugged in, I found that all was good.  I then added the LEDs, connecting the proper leads to the resistors and to the correct pins, and soldering.  One more test showed the LEDs functioning properly, so I screwed the circuit board to the box.

The final touches were to trim the connections to the resistors, use some electrical tape for insulation, and to super glue the LEDs and JST connector to the box.  Finally, I spliced the male end of the JST to hookup wires leading to the corresponding connections on the relay (there is a terminal block on the relay).  After testing the connections for continuity with my multimeter, I applied heat shrink to each splice and then a long piece of heat shrink to the whole connection.
Enclosure before gluing LEDS and JST and adding screws

Project Video

On my youtube channel

Code

/***************************************************
  Adafruit MQTT Library ESP8266 Example

  Must use ESP8266 Arduino from:
    https://github.com/esp8266/Arduino

  Works great with Adafruit's Huzzah ESP board:
  ----> https://www.adafruit.com/product/2471
  products from Adafruit!

  Written by Tony DiCola for Adafruit Industries.
  Adafruit IO example additions by Todd Treece.
  MIT license, all text above must be included in any redistribution
 ****************************************************/
/*  Adafruit invests time and resources providing this open source code,
  please support Adafruit and open-source hardware by purchasing */

/*2015-08-15 Virgil Machine
  Light goes on, light goes off, internet style
  I used the adfruit.io tutorial and the adafruit esp8266
  tutorial and library examples to get the connection stuff.
  The logic is mainly cloned from my bluetooth example 
  (see virgilmachine.blogspot.com). Connects to WIFI, connects 
  to adafruit.io, turns on green LED to indicate connection,inbitializes 
  logic and devices to off, then waits for instructions from 
  adafruit.io--toggle switch to turn light on and off. Sets relay
  pin to HIGH, also turns on red LED and on-board LED, and vice versa.
  */
#include
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"

// function prototypes
void connect(void);

/****************************** Pins ******************************************/

#define LAMP           2  // AC/DC Control Relay 
#define LED            0  // on-board LED
#define POWER_LED      4  // lED to show power on
#define LAMP_LED       5  // lED to show LAMP on

/************************* WiFi Access Point *********************************/
//use your own values here

#define WLAN_SSID       "SSID"
#define WLAN_PASS       "PASSWORD"

/************************* Adafruit.io Setup *********************************/

#define AIO_SERVER      "io.adafruit.com"
#define AIO_SERVERPORT  1883
//use your own values here
#define AIO_USERNAME    "USERNAME"
#define AIO_KEY         "adafruit.io KEY"

/************ Global State (you don't need to change this!) ******************/

// Create an ESP8266 WiFiClient class to connect to the MQTT server.
WiFiClient client;

// Store the MQTT server, client ID, username, and password in flash memory.
// This is required for using the Adafruit MQTT library.
const char MQTT_SERVER[] PROGMEM    = AIO_SERVER;
// Set a unique MQTT client ID using the AIO key + the date and time the sketch
// was compiled (so this should be unique across multiple devices for a user,
// alternatively you can manually set this to a GUID or other random value).
const char MQTT_CLIENTID[] PROGMEM  = __TIME__ AIO_USERNAME;
const char MQTT_USERNAME[] PROGMEM  = AIO_USERNAME;
const char MQTT_PASSWORD[] PROGMEM  = AIO_KEY;
int current = 0;
char light_on[] = "Light Goes On";
char light_off[] = "Light Goes Off";
//2016-08-08 vm char stuff replaced by boolean
bool lamp_on = false;  //initalized to off to match the rest of the code

// Setup the MQTT client class by passing in the WiFi client and MQTT server and login details.
Adafruit_MQTT_Client mqtt(&client, MQTT_SERVER, AIO_SERVERPORT, MQTT_CLIENTID, MQTT_USERNAME, MQTT_PASSWORD);

/****************************** Feeds ***************************************/

// Setup a feed called 'lamp' for subscribing to changes.
// Notice MQTT paths for AIO follow the form: /feeds/
const char LAMP_FEED[] PROGMEM = AIO_USERNAME "/feeds/UncleJimThing";
Adafruit_MQTT_Subscribe lamp = Adafruit_MQTT_Subscribe(&mqtt, LAMP_FEED);
// Use feed UncleJimText as TEXT_FEED for publishing changes.
// Notice MQTT paths for AIO follow the form: /feeds/
const char TEXT_FEED[] PROGMEM = AIO_USERNAME "/feeds/UncleJimText";
Adafruit_MQTT_Publish text = Adafruit_MQTT_Publish(&mqtt, TEXT_FEED);
/*************************** Sketch Code ************************************/

void setup() {

  // setup relay and LED pins as outputs and start off as LOW
  pinMode(LAMP, OUTPUT);
  digitalWrite(LAMP, LOW);  //default to off at startup (had this backwards) 
  pinMode(LED, OUTPUT);  //for testing
  digitalWrite(LED, LOW);  //default to off at startup
  // setup pins for indicator LEDS 
  pinMode(LAMP_LED, OUTPUT);
  digitalWrite(LAMP_LED, LOW);  //default to off at startup
  // POWER_LED IS SET to HIGH in connect() routine, after successful connection
  //but default to off until then
  pinMode(POWER_LED, OUTPUT);  //to show if we're connected
  digitalWrite(POWER_LED, LOW);  //default to off at startup 
  
  Serial.begin(115200);

  Serial.println(F("Uncle Jim IO Example"));

  // Connect to WiFi access point.
  Serial.println(); Serial.println();
  delay(10);
  Serial.print(F("Connecting to "));
  Serial.println(WLAN_SSID);

  WiFi.begin(WLAN_SSID, WLAN_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(F("."));
  }
  Serial.println();

  Serial.println(F("WiFi connected"));
  Serial.println(F("IP address: "));
  Serial.println(WiFi.localIP());

  // listen for events on the lamp feed
  mqtt.subscribe(&lamp);

  // connect to adafruit io
  /* when we connect successfully, the LED is turned on
  so we enter loop with the POWER_LED indicator on
  but it's off until then
  */
  connect();
/****2016-07-17 VM 
     We want the test to say "light goes off at startup, since we set if off in setup
     I think this will work here--***experiment***
****/
     text.publish(light_off);
}

void loop() {

  Adafruit_MQTT_Subscribe *subscription;

  // ping adafruit io a few times to make sure we remain connected
  if(! mqtt.ping(3)) {
    // reconnect to adafruit io
    if(! mqtt.connected())
    { digitalWrite(POWER_LED, LOW);  //turn off LED to show we're not connected  
      connect();
    }  
  }


  // this is our 'wait for incoming subscription packets' busy subloop
  while (subscription = mqtt.readSubscription(1000)) {

    // we only care about the lamp events
    if (subscription == &lamp) {

      // convert mqtt ascii payload to int
      char *value = (char *)lamp.lastread;
      Serial.print(F("Received: "));
      Serial.println(value);
      Serial.print(F("\nlamp-state in: "));
      Serial.println(lamp_on);
      int current = atoi(value);
      if (lamp_on) {  
        Serial.println(light_off);
        text.publish(light_off);
        digitalWrite(LAMP, LOW);  //RELAY
        digitalWrite(LED, LOW);  //ON-BOARD
        digitalWrite(LAMP_LED, LOW); //INDICATOR
      } else {  
        Serial.println(light_on);
        text.publish(light_on);
        digitalWrite(LAMP, HIGH); 
        digitalWrite(LED, HIGH);
        digitalWrite(LAMP_LED, HIGH);          
      } 
      lamp_on = !lamp_on; //toggle lamp state         
      Serial.print(F("\nlamp-state out: "));
      Serial.println(lamp_on);
  
      Serial.print(F("\nSending button value: "));
      Serial.print(value);
      Serial.print("... ");

    }   //if subscription is lamp
  }     //while subscription
}       //loop

// connect to adafruit io via MQTT
void connect() {

  Serial.print(F("Connecting to Uncle Jim IO... "));

  int8_t ret;

  while ((ret = mqtt.connect()) != 0) {

    switch (ret) {
      case 1: Serial.println(F("Wrong protocol")); break;
      case 2: Serial.println(F("ID rejected")); break;
      case 3: Serial.println(F("Server unavail")); break;
      case 4: Serial.println(F("Bad user/pass")); break;
      case 5: Serial.println(F("Not authed")); break;
      case 6: Serial.println(F("Failed to subscribe")); break;
      default: Serial.println(F("Connection failed")); break;
    }

    if(ret >= 0)
      mqtt.disconnect();

    Serial.println(F("Retrying connection..."));
    delay(5000);

  }

  Serial.println(F("Uncle Jim IO Connected!"));
  digitalWrite(POWER_LED, HIGH);  //turn on LED to show we're connected  
}