From eBower Wiki
Jump to: navigation, search

The current state of home automation is a bit lacking, but I feel that we're on the cusp of a revolution. There are plenty of competing standards out there for home automation protocols, but they follow two distinct patterns. The classic home automation grew from X10 which sent signals over the powerlines already in your house to control remote devices. It's decentralized and very flexible - considering it was invented in the 1970s. These protocols are built from the bottom up, usually hardware-based and built without modern thoughts around software/firmware upgrades. There is a new breed of protocols like WEMO which are top-down - more software and microprocessor oriented and usually connecting over WiFI. These, I feel, are the way of the future - but their applications are currently limited as they lac the 40+ years of experience.

INSTEON falls into the former category. Destined to evolve or be replaced it's in an interesting position of being actively developed and having a wealth controller options. My gamble is that as the INSTEON devices I have fail (and they are prone to failure) something will be able to replace them - whether it's a new INSTEON controller (my hope) or a WiFi-enabled protocol with a robust set of options.

INSTEON takes X10-like powerline signaling and adds a proprietary low-range RF signalling for when the power lines are too noisy or you need to bridge phases (in the US, you've probably got 240V coming into the house which is split into two legs, to get from one leg to the other you need to bridge the X10/INSTEON signal). It's a big mesh repeater network so the more devices you have the better. You've also got legacy devices that are powerline-only and new devices that are RF-only - so try to get at least one dual-mode device which is the bulk of modern devices today.


Both are home automation protocols. Both are largely proprietary and managed by a single vendor (SmartHome vs. Belkin). Both have ambiguous capitalization. Which one wins?

SPOLIER ALERT: Neither. At least as of now.

Initial Setup

WEMO wins for setup, you plug it in and it becomes an access point if it can't connect to a network. This means it's all wireless and you never have to open it up to configure it. It also means that you can access it anyplace you've got Internet access. If it loses configuration you just need to be near it to set it up again.

INSTEON is a bit more...interesting. You need to know a device ID, so make sure you write it down. Or you can push a setup button to have it broadcast said ID, but plug-in devices can be awkward to reach and if you've just installed a ceiling fan controller you're going to start exercising your vocabulary. More importantly, you need this information every time you lose the config - keep it safe, boys and girls.


This is mostly a push. WEMO is simple, you've got an app. The app controls the device. Done. Unless you want to do anything interesting, then you're stuck with third party integrations which are a bit limiting at best.

INSTEON is complex and fragmented. You can do a ton of wonderful things, but you may need a lot of UIs to do so. You can do this completely without a controller, effectively think of it like Bluetooth pairing where you physically press and hold a button on a "controller" (something like a light switch or pushbutton remote) and then push and hold a button on a "receiver" (something like a fan controller or plug-in adapter) and they'll be paired. But that's not interesting, if there's no app for control it's not a very smart home.

First you need a way to bridge your IP-based network to the INSTEON network. In the old days this was a serial device attached to a computer, today it's the Hub - a little device with a power cable and an Ethernet jack. There are two (soon to be three?) versions of the hub, and as near as I can tell you may want the older 2012 version because the 2014 version removes some legacy support and hackability - but good luck trying to figure out which version you're buying.

Once you've got the Hub setup, you need to control it. There's an app for that, of course, and the Android app isn't bad at all. But the Windows 8 app for the desktop is designed for phones and lacks some device support. And neither can handle scene controllers, effectively pushbutton remotes. For that you'll need the HouseLinc software. And remember, it's all decentralized so the Hub has one configuration known and the HouseLinc software has other bits known but they don't know about each other. But thankfully it works. Mostly.

Action Android App Windows 8 App HouseLinc
Add receiver Yes Yes Yes No
Add Scene controller No No Yes No
Control Light Yes Yes Yes Yes
Control Fan Yes No Yes No

The Android app can add basic switches, but handles Scenes poorly. The RF-only mini-remotes simply don't exist to it. The KeypadLinc can be configured, but poorly. All buttons are toggles, there's no option for this button to turn the ceiling fan on low - the first push will do so and the second will turn it off. For these devices I'd recommend the HouseLinc software instead.


WEMO has a tiny edge here. The WEMO app usually just works and the pushbutton UI is also flawless, but limited.

The INSTEON Hub app is hit or miss. Since moving the hub slightly higher it's now a bit more hit than miss, but sometimes the devices just go yellow (unknown). On the other hand the pushbutton UI using remotes also seems to just work - once it's set up.


Both probably losers, but for different reasons. WEMO is proprietary and "cloud-based" which means you're at the mercy of Belkin's developers for security. They goofed once, but a software patch to the devices fixed things. Belkin is an accessory builder, there isn't much need for security in a USB hub or mouse. They've done a decent job on WEMO, but it's still early days.

On the other hand, we know where SmartHome has failed. The Hub is an HTTP-based device. The default password is easy to guess, nothing's encrypted, and - most damaging - the initial Hub can't be updated and the Hub II still seems to be a microcontroller so it's not as simple as grabbing OpenSSL and patching things. But this isn't horribly critical if you don't expose the Hub to the outside world. First, change the username/password in the Android App. Don't open up the port number to the outside world or, if you do, at least change it from the default and NEVER connect over insecure WiFi since it will pass your password in plaintext. Even better, set up a VPN into your home network. Now you won't be able to access the app unless you're connected, but it will be secure.

The bad news is that INSTEON's security probably cannot be fixed on your device. The good news is it can be fixed by swapping out the Hub with something new.

Robustness of Devices

WEMO's barely on the map here. We've got based wall switches, plug-in adapters and a motion detector but nothing else from a traditional home automation standpoint. They've got weird things like crockpots and coffee makers as well as some specialty things like water flow detectors, but it was designed by software people who thought remote relay control was a fun project rather than people who want to actually create a smart home. Still, the number of items has grown significantly over the past year so perhaps it's just a matter of time.

INSTEON was designed by lighting people. It supports basic switches and plug-in adapters, but also dimmers, ceiling fan controllers, blind controllers, leak detectors, motion detectors, certain IP cameras, thermostats, and pretty much anything else you can imagine. And this is why INSTEON is still, and will continue to be, relevant in the world of WEMO and Nests.


There are a ton of INSTEON devices out there, I've only got a handful. I'm assuming you'll be adding these to a Hub, if you're going decentralized you may have a different experience.

The Hub

This is the core of the system, so it's useful to cover it in a bit more detail.


The Hub device comes in a few flavors. The original Hub is model 2242-222, the Hub 2 is model 2245-222. Here's a rundown of the reasons to get a Hub 2:

  • Field upgrades
  • Better RF range
  • Improved UI

You'd think it would be a no-brainer. But here are the reasons to find an original Hub:

  • X10 support
  • Better support for legacy HTTP APIs

Being able to upgrade the firmware seems like a key feature, but to my knowledge there are no custom firmware images and I don't know that SmartHome has any updates for the Hub II that are meaningful. The better RF range is nice, but can be replaced with some plug adapters. If you've got a rich set of switches and dimmers you shouldn't need it. The improved UI is a hard one, I've never seen the new UI, but I do like the ability to write my own. When I found that the 2244-224 Starter Kit I purchased had the old Hub I was initially upset that I got the old hardware, now I think it's more of a push for someone like me.

Look and Feel

It's a white plastic brick with an LED. Someone described it quite correctly as similar to a Wii, but the light weight and sharp edges gives it a bit of a cheaper feel in my opinion.


Pretty simple, plug in power and plug in Ethernet. For some reason I needed to do a factory reset to detect it from the Android App. If you need to do this it's documented in the manual, but you unplug it, press and hold the reset button near the power while you plug it in. After the long beep, let go of the reset button and you'll get a double beep. Wait for 30 second for another double beep and then unplug/replug the Hub.

What's missing here is WiFi access. SmartHome recommends not using power strips or surge suppressors on the Hub, it messes with the INSTEON signals. But that means I need to track down a free, non-suppressed outlet that's also near an Ethernet port - not very easy. On the other hand, I could just find a closet with a disused outlet if it had WiFi. I've got it plugged into a power strip now and it's working, but your mileage may vary.


There are plenty of UI's on the Hub, for better or for worse. I'll cover each of the following in a bit more detail as I get the time.

Android App

This is the way you're "supposed" to use the Hub. It seems to be mostly feature complete, and allows you to (in theory) add a Nest thermostat (I haven't been able to do so successfully yet) but you can't add nor configure the mini remotes yet.

Windows 8 App

This is found in the Windows App Store and is obviously designed for phones and tablets. It works and seems to follow a Windows 8 UI guideline, but lacks fan controls.


This is standalone software for Windows that reminds me of the old days of home automation where a CS degree was a good idea before getting started.

Web UI

If you open up the Hub's IP/port number in a browser it sends you to where you can log in with your Insteon (not hub) username/password. It's not very feature-rich but it does give you a browser-based access to most of the features the Android app supports.

Secret Web UI

There are some secret pages in the Hub web interface, apparently left over from a previous product. Many of these pages are reportedly not available in the Hub 2.


This is where things get interesting, and another thing that may be less-functional in the Hub 2. The Hub is really an updated SmartLinc which has an API defined. It's not great, but it works.

The side effect of completely horrid security is that you can quite easily reverse engineer the protocols. Essentially what I do is run a version of tcpdump on my phone. I use something along the lines of:

tcpdump -w test.pcap host ${hub_ip}

Then on my Linux box I can run:

tcpick -C -yP -r test.pcap > test.txt

Now test.txt contains mostly plaintext strings of the HTTP commands send.

For example:

curl -u [username]:[password] -X POST http://[hub_ip_address]:[hub_port]/3?0262[device_id]0F11[level]=I=3

This command will set the light on a specific device ID to a certain level (between 00 and FF).

Status can be read using this:

curl -u [username]:[password] http://[hub_ip_address]:[hub_port]/sx.xml[device_id]=[command]

Using 1902 or 1903 can grab the light and fan level of my devices and it represents a common command (command 19 with parameters 02 and 03), there's a common command summary table here.

A more complex and flexible version is below, with it I can do things like this to my ceiling fan (which has both light and fan controls):

$ insteon
Syntax: insteon device command [value]
device: The device ID or insteon.hosts name of the device
command: on, fast_on, off, fast_off, fan, status, status_fan
value: The percent you'd like to set the dimmer to (0-100) or
       low|medium|high|off for fan control.

ERROR: Device  doesn't have a device ID of the format [00-FF].[00-FF].[00-FF]

$ insteon mbr_fan on
$ insteon mbr_fan off
$ insteon mbr_fan on 25
$ insteon mbr_fan fan low
$ insteon mbr_fan status
$ insteon mbr_fan status_fan
$ insteon 12.34.56 on

Here's the code (don't worry, the line numbers shouldn't copy if you want to steal this). I'm also playing around with GitHub and it can be found here.

  1. #!/bin/bash
  3. for filename in /etc/insteon.conf ~/.insteon.conf /etc/insteon.hosts ~/.insteon.hosts; do
  4.   if [ -f "$filename" ]; then
  5.     . $filename
  6.   fi
  7. done
  9. function debug() {
  10.   if [ "$debug" = "TRUE" ]; then
  11.     >&2 echo "DEBUG: $1"
  12.   fi
  13. }
  15. function usage() {
  16.   echo "Syntax: $(basename $0) device command [value]"
  17.   echo "device: The device ID or insteon.hosts name of the device"
  18.   echo "command: on, fast_on, off, fast_off, fan, status, status_fan, details"
  19.   echo "value: The percent you'd like to set the dimmer to (0-100) or"
  20.   echo "       low|medium|high|off for fan control."
  21.   echo
  22.   echo "$1"
  23.   exit 1
  24. }
  26. # See the following for details:
  27. #
  28. devices="
  29. x01x0Ex43 2457D2 LampLinc Plug-In Dimmer
  30. x01x20x44 2477D Dimmer
  31. x01x2Ex41 2475F FanLinc
  32. x02x2Ax43 2477S Switch
  33. x02x37x48 2635-222 Plug-In On/Off Module
  34. "
  36. err_msg=""
  38. for var in insteon_ip insteon_port insteon_user insteon_pwd; do
  39.   if [ "${!var}" = "" ]; then
  40.     err_msg="$err_msg
  41. ERROR: $var not set in /etc/insteon.conf or ~/.insteon.conf"
  42.   fi
  43.   debug "$var = ${!var}"
  44. done
  46. for dependency in curl bc; do
  47.   dep_loc=$(whereis $dependency | awk '{print $2}')
  48.   debug "$dependency location: $dep_loc"
  49.   if [ "$dep_loc" = "" ]; then
  50. err_msg="$err_msg
  51. ERROR: $dependency not installed."
  52.   fi
  53. done
  55. if [ "$err_msg" != "" ]; then
  56.   usage "$err_msg"
  57. fi
  59. device=$1
  60. cmd=$2
  61. value=$3
  63. debug "device = $device; cmd = $cmd; value = $value"
  65. if [ "${!device}" ]; then
  66.   device_id="${!device}"
  67.   debug "found device in hosts file"
  68.   # Allow the classic hh.hh.hh format, hh:hh:hh format for those 
  69.   # who love IPv6, or just hhhhhh
  70.   device_id=$(echo "${device_id^^}" | sed 's/[\:\.]//g')
  71. else
  72.   device_id=$device
  73.   device_id=$(echo "${device^^}" | sed 's/[\:\.]//g')
  74. fi
  75. debug "device_id = $device_id"
  77. if ! [[ "$device_id" =~ ^[0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F]$ ]]; then
  78.   usage "ERROR: Device $device doesn't have a device ID of the format [00-FF].[00-FF].[00-FF]"
  79. fi
  81. function send_cmd() {
  82.   cmd=$1
  83.   device_id=$2
  84.   value=$3
  85.   debug "send_cmd: cmd = $cmd; device_id = $device_id; value = $value"
  86.   sd_flag="0F"
  87.   case $cmd in
  88.     "on")
  89.       cmd_code=11
  90.     ;;
  91.     "fast_on")
  92.       cmd_code=12
  93.     ;;
  94.     "off")
  95.       cmd_code=13
  96.       value=00
  97.     ;;
  98.     "fast_off")
  99.       cmd_code=14
  100.       value=00
  101.     ;;
  102.     "fan")
  103.       cmd_code="11"
  104.       # This is an extended command
  105.       sd_flag="1F"
  106.     ;;
  107.     "status")
  108.       cmd_code="19"
  109.       value="02"
  110.     ;;
  111.     "status_fan")
  112.       cmd_code="19"
  113.       value="03"
  114.     ;;
  115.     "details")
  116.       cmd_code="10"
  117.       value="00"
  118.     ;;
  119.     *)
  120.       usage "ERROR: There's a bug in my code and I sent an invalid command internally!"
  121.     ;;
  122.   esac
  123.   debug "send_cmd: cmd_code = $cmd_code; sd_flag = $sd_flag; value = $value"
  124.   if [ "$cmd_code" != "19" ]; then
  125.     curl_command="http://$insteon_ip:$insteon_port/3?0262${device_id}${sd_flag}${cmd_code}${value}=I=3"
  126.     debug "send_cmd: sending $curl_command as $insteon_user:$insteon_pwd"
  127.     curl -X POST -u $insteon_user:$insteon_pwd "$curl_command"
  128.     if [ "$cmd_code" = "10" ]; then
  129.       curl_command="http://$insteon_ip:$insteon_port/buffstatus.xml"
  130.       debug "send_cmd: sending $curl_command as $insteon_user:$insteon_pwd"
  131.       count=0
  132.       while [ "$(echo "$rsp" | sed 's/0//g')" = "" ] && [ $count -lt 10 ]; do
  133.         count=$((count+1))
  134.         curr_buff=$(curl --silent -u $insteon_user:$insteon_pwd "$curl_command" |  sed 's/<[^>]*>//g')
  135.         debug "curr_buff = $curr_buff"
  136.         cmd="${curr_buff:0:18}"
  137.         rsp="${curr_buff:18:22}"
  138.         ext_rsp1="${curr_buff:40:22}"
  139.         ext_rsp2="${curr_buff:62:22}"
  140.         device_details="x${ext_rsp1:10:2}x${ext_rsp1:12:2}x${ext_rsp1:14:2}"
  141.         sleep 0.1
  142.       done
  143.       debug "count = $count; cmd = $cmd; rsp = $rsp"
  144.       debug "ext_rsp1 = $ext_rsp1; ext_rsp2 = $ext_rsp2"
  145.       if [ $count -lt 10 ]; then
  146.         device_name="$(echo "$devices" | grep -w ^$device_details)"
  147.         if [ "$device_name" = "" ]; then
  148.           device_name="$device_details UNKNOWN DEVICE"
  149.         fi
  150.         echo $device_name
  151.       else
  152.         echo "ERROR: Buffer took too long to populate."
  153.         exit 2
  154.       fi
  155.     fi
  156.   else
  157.     # We're looking for a status.
  158.     curl_command="http://$insteon_ip:$insteon_port/sx.xml?${device_id}=${cmd_code}${value}" 
  159.     debug "send_cmd: sending $curl_command as $insteon_user:$insteon_pwd"
  160.     curr_status=$(curl --silent -u $insteon_user:$insteon_pwd "$curl_command" | grep "D=" | awk -F\" '{print $2}')
  161.     response_id=${curr_status:0:6}
  162.     response_ack=${curr_status:6:1}
  163.     response_hop=${curr_status:7:1}
  164.     response_cmd=${curr_status:8:2}
  165.     response_value=${curr_status:10:2}
  166.     debug "send_cmd: curr_status = $curr_status"
  167.     debug "send_cmd: response_id = $response_id; response_ack = $response_ack; response_hop: $response_hop"
  168.     debug "send_cmd: response_cmd = $response_cmd; response_value = $response_value"
  169.     if [ "$response_ack" != "2" ]; then
  170.       echo "ERROR: Device not ready. $curr_status"
  171.       exit 2
  172.     fi
  173.     if [ "$response_id" != "$device_id" ]; then
  174.       echo "ERROR: Wrong device ID in response. $curr_status"
  175.       exit 2
  176.     fi
  177.     if [ "$response_cmd" != "$cmd_code" ]; then
  178.       echo "ERROR: Response for wrong command. $curr_status"
  179.       exit 2
  180.     fi
  181.     if [ "$cmd" = "status" ]; then
  182.       printf "%0.f\n" $(echo "scale=1;ibase=16;64*$response_value/FF" | bc)
  183.     else 
  184.       case $response_value in
  185.         "00")
  186.           echo "off"
  187.         ;;
  188.         "55")
  189.           echo "low"
  190.         ;;
  191.         "AA")
  192.           echo "medium"
  193.         ;;
  194.         "FF")
  195.           echo "high"
  196.         ;;
  197.         *)
  198.           echo $response_value
  199.         ;;
  200.       esac
  201.     fi
  202.   fi
  203. }
  205. cmd=${cmd,,}
  206. case $cmd in
  207.   "on"|"fast_on")
  208.     if [ "$value" == "" ]; then
  209.       value=100
  210.     fi
  211.     if ! [[ "$value" =~ ^[0]*[0-9][0-9]?$|^[0]*100$ ]]; then
  212.       echo "ERROR: $value is out of range (0-100)"
  213.       exit 2
  214.     fi
  215.     hex_value=$(echo "ibase=10;obase=16;255 * $value / 100" | bc | awk -F\. '{printf("%02X", strtonum("0x"$1))}')
  216.     debug "value = $value; hex_value = $hex_value"
  217.     send_cmd $cmd $device_id $hex_value
  218.   ;;
  219.   "off"|"fast_off")
  220.     send_cmd $cmd $device_id
  221.   ;;
  222.   "status"|"status_fan")
  223.     send_cmd $cmd $device_id
  224.   ;;
  225.   "fan")
  226.     case $value in
  227.       "off")
  228.         hex_value="0002"
  229.       ;;
  230.       "low")
  231.         hex_value="5502"
  232.       ;;
  233.       "medium"|"med")
  234.         hex_value="AA02"
  235.       ;;
  236.       "high")
  237.         hex_value="FF02"
  238.       ;;
  239.       *)
  240.         usage "ERROR: Invalid value $value - expecting low, medium, high, off"
  241.         exit 1
  242.       ;;
  243.     esac
  244.     debug "value = $value; hex_value = $hex_value"
  245.     send_cmd $cmd $device_id $hex_value
  246.   ;;
  247.   "details")
  248.     send_cmd $cmd $device_id
  249.   ;;
  250.   *)
  251.     usage "ERROR: Unrecognized Command \"$cmd\""
  252.   ;;
  253. esac

Just create a ~/.insteon.conf or /etc/insteon.conf with the following information:


Note: Your username, password, and IP information is all in plaintext, but they're also in plaintext on the wire - be careful!

Custom Web-Based Controllers

I've also created an INSTEON controller web UI using the script above as a baseline. Feel free to improve on the code I've submitted to GitHub.

Fan Controller

The 2475F FanLinc controller should be a familiar device to anyone who's installed a wireless remote for their ceiling fan. Most of the time compatible fans have three wires in, power for the fan, power for the light, and neutral/return. This module is slightly different in that you need to splice the neutral from the wall to both the remote and the fan (most of the ones I've installed have a separate neutral out of the controller), but otherwise it's about the same. Feed it power on the black wire, and it will output power to the light and fan on the blue and red wires (respectively). Physically it's a bit smaller than a Westinghouse-branded model I replaced and it fits in the mounting bracket above the flush mount fan (a Westinghouse Comet if you care). The good news is there is no protruding antenna like many of these devices have, but the bad news is there is no protruding antenna so reception could be a problem if you've got high ceilings or a large room - then again, reception could be via the powerline if you've got other dual-band devices so there are options.

Adding the FanLinc is something you should do before you install it because getting to the buttons is a pain once most fans are installed. I did this with the controller in place in the ceiling and with the disassembled fan (no blades) connected to it just to see if it worked. Write down the INSTEON ID before you do the final fan assembly - just in case. Of course, you'll need to make sure the physical controls on the fan have the light on and the fan speed on high (I actually put mine on medium, high is a bit too fast for my tastes).

In the Hub App for Android the device shows up nicely with a six-button controller allowing you to turn the light on/off and set the fan to high, medium, low, or off. Bizarrely Smarthome doesn't offer a wireless remote that has this layout nor is the 6-button KeypadLinc an ideal option since switching the light off would switch the fan controller off - meaning you couldn't connect the fan to the load on the Keypad. I'm currently using both options. Note that unlike the standard RF fan controllers there is no remote included.

KeypadLinc 6 Scene Controller

The 2487S is a simple on/off switch with four buttons you can use to control just about whatever you like. In my case, it's a dedicated fan controller using a 232-382 button kit. The device is slightly deeper than an INSTEON switch/dimmer and for my use case I just have the red switched output capped off - all this is for me is a fairly expensive remote controller comparable to the RF-only Mini-Remote at half the price. Configuration isn't horrid, but it would be nice for some support for pre-programmed templates. Use as a fan controller is common enough that there are laser-etched keys available, but the software doesn't seem to have a "configure this as a fan controller for the FanLinc in this room" button which means I need to make four scenes, rename the buttons, set them to "always on" instead of "toggle", assign the buttons to the fan, and then write to the device. If only SmartHome had a good product architect to help them design their UIs...

Mild annoyances aside, the keypad feels decent. I probably should have gotten the 2334-232 dimmer to see if I could configure a long-press as a dimmer, but while the ramp up/down is nice the steady-state dimmed light is a bit less useful to me.

4 Scene Mini-Remote

The 2342-232 4 Scene Mini-Remote is a little handheld remote with a built-in battery and a micro-USB charger. One of the nice things about these mini-remotes is that they're the same size as a Decora wall switch. If you buy this bracket you can mount them to the wall (if you want to mount it on an electrical box there is no back so if you remove it there's a hole - using a Decora blank and some epoxy you can construct a backing). There's also a stand for tabletop use.

The remote itself is small and light, the smooth white plastic common to INSTEON products it a bit contradictory, it doesn't feel cheap or flimsy by itself, but its light weight of the products makes the product feel a little cheap. The built-in rechargeable battery hopefully beats needing to swap out button batteries but we'll see about the longevity. The range is pretty decent and with only two devices close to each other I can use it on the opposite side of my apartment through several walls, but the nice thing is if it's not enough you can just add a dual-mode plug adapter close to where you want to use it and you've got an instant range extender. The one thing I'd like to see is a bit of a finger groove on the back, there is an LED at the top of the remote, but otherwise from a tactile perspective it's symmetric. Adding a groove between the top two buttons would help fix that.

You can add these as a controller for the fan by using you Android phone to click on this link on your PC. Sorry, not supported by the Android App at the moment so you need HouseLinc. The plus side is the software is free and the Hub can be used as a bridge. The downside is that it seems to be Windows-only - not an issue for me with my gaming rig but sadly Linux users are on their own for this one, this can help get you started.

Documentation on pairing the remote to the FanLinc forthcoming.

Plug-In Modules

There are both the 2-prong 2457D2 LampLinc dimmer and the 3-prong grounded 2635-222 On/Off Module. They share a common look to the rest of the products in a gloss white finish with sharp corners. And they work. The former is designed around lamps, the latter is non-dimming and suitable for just about anything. I my grounded switch to control some grow lights at the moment, the dimmers came with my Hub and they're not overly useful to me.

Installation is trivial. There are buttons to turn on/off (or brighten/dim) and connect on the side. They're a bit large, and the plug connects in from the bottom so you may be limited in where you install them without a liberator of some sort.

In-Wall Switches

For dimmer applications the 2477D dimmer is the standard choice. For fluorescent lights or other non-dimmable applications the 2477S on/off switch is what you're looking for. Both devices' rear cases are clear to provide an interesting view into the complexity of INSTEON devices. Both also have a set of 9 white LEDs to show the dim level, but of course only "on" and "off" at the top and bottom actually illuminate on the on/off switch. This provides a common look between dimmers and switches, but that also means you can't distinguish them easily. It's a little hard to tell from the picture, but these are rocker switches rather than pushbutton - you must hit the top of the switch for on and the bottom for off. They behave nearly identically except for the switch only accepting 0 and !0 power levels (set it to 5% and it just turns on).

Installation isn't hard, you may need to rewire slightly since a traditional switch will only interrupt the power (black) line and the white wire isn't connected to the switch. These switches need you to connect the power coming in to the black lead, the power going out to the red one, and the white lead to the return (and, of course, ground). They're also a bit deeper than most switches and take up most of the electrical box. If you've got full, stiff wiring it may be a tight fit.

The connect button is accessible even with the wallplate cover in place, the ID is visible on a sticker just by taking off the wall cover (no need to remove the switch). Press and hold to dim or brighten the levels.