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.

INSTEON vs. WEMO[edit]

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[edit]

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[edit]

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[edit]

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[edit]

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[edit]

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[edit]

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[edit]

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[edit]

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.

Web API[edit]

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[edit]

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[edit]

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[edit]

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[edit]

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[edit]

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[edit]

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.