This release targets mobile optimizations and performance. lirc_web now behaves more like a native app when added to the home screen of a mobile device. A favicon is now shown on the home screen, the URL bar will be hidden from view, and lirc_web will be selectable from the device’s multitasking screen. Furthermore, CSS assets are bundled into a single request, small images are now base64 encoded, and an application cache has been introduced to cache all assets locally between requests.

In my testing, with a warm cache, lirc_web now fires a load event within 300ms.

Here’s the relevant piece of CHANGELOG.md that describes all updates since v0.2.0:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

## [0.3.0] - 2016-03-13

* Adds `grunt-contrib-cssmin` task to combine all CSS requests into one
* Adds ability to set lirc socket in `config.json` (thanks @pmgration)
* Base64 `left-arrow.png` image to reduce a request
* Adds application cache manifest file for offline caching

## [0.2.4] - 2016-01-13

* Extracts macros into a standalone lib/macros.js file
* Adds Favicon (thanks @flochtililoch)
* Adds npm run test:watch action (thanks @OvisMaximus)
* Travis build will now run linter
* Updated dependencies
* Uses local version of jQuery for testing now

## [0.2.3] - 2016-01-03

* Fixing bug where labels were loaded before config (thanks @flochtililoch)

## [0.2.2] - 2016-01-01

* Removing `Makefile` for running tests. Only need `package.json`.
* Fixing .gitignore error for the global lirc_web build

## [0.2.1] - 2015-12-31

* `lirc_web` can now be installed globally and called by `lirc_web` from CLI
* Adding ESLint to the mix and ensuring all JS conforms to Airbnb ES5 standards

New features are documented in the README and the CHANGELOG

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[0.2.0] - 2015-12-30

Adding blacklist configuration option to hide unused keys from UI (thanks @OvisMaximus)
Adding support for SSL (thanks @de-live-gdev)
Fixing example config in the README (thanks @de-live-gdev)
Fixes url escaping bug with macros and remotes (issue #23)

[0.1.0] - 2015-12-30

Locking npm versions to ensure future install work
Adding CHANGELOG.md
Adding /refresh link on bottom to reload UI after making changes to LIRC (thanks @f00f)
Adding ability to set custom labels on command and remote names (thanks @elysion)
Adding Apple mobile app capability, disabling zoom (thanks @elysion)
Moving Lato fonts locally to remove external network dependency

New features are documented in the README.

On a related note, lirc_node (available at https://github.com/alexbain/lirc_node) has been updated to v0.0.4. There’s no new functionality in this release, simply locked NPM dependency versions and the addition of a change log.

If you run into any issues with either project, let me know in the comments or (ideally) via the issues page.

There are a few ways to determine if the RaspberryPi has network connectivity. For this script, we’ll be using ping.

Writing the script

To get started, we’ll need to determine if the RaspberryPi is connected to the network. To do this, we’ll attempt to ping a server and see if we get a response. If the command succeeds (RaspberryPi receives a response from the server), we have network connectivity. If the command fails, we’ll turn wlan0 off and back on.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#!/bin/bash

# The IP for the server you wish to ping (8.8.8.8 is a public Google DNS server)
SERVER=8.8.8.8

# Only send two pings, sending output to /dev/null
ping -c2 ${SERVER} > /dev/null

# If the return code from ping ($?) is not 0 (meaning there was an error)
if [ $? != 0 ]
then
    # Restart the wireless interface
    ifdown --force wlan0
    ifup wlan0
fi

Name the script something memorable (wifi_rebooter.sh), and place this script in /usr/local/bin. Make sure it’s executable by running:

1

chmod +x /usr/local/bin/wifi_rebooter.sh

Scheduling regular execution

To ensure the script runs automatically, we’ll use cron. The frequency that you run this script is a matter of personal preference - I chose to run the script every five minutes.

To schedule the script, open /etc/crontab for editing and add this line to the bottom:

1

*/5 *   * * *   root    /usr/local/bin/wifi_rebooter.sh

This will ensure that the script is run, as root, every 5 minutes. If you’re unfamiliar with cron syntax, take a look at the cron format.

Testing

To test that the script works as expected, we are going to take down the wlan0 interface and wait for the script to bring it back up. Before taking down wlan0, you may want to adjust the interval in /etc/crontab to 1 minute. Also, note that this will immediately disconnect you from your shell session.

To take down wlan0 to confirm the script works, run:

1

ifdown --force wlan0

After waiting patiently for ~1 minute, try SSHing back into your RaspberryPi. Assuming everything worked, your RaspberryPi should have automatically reconnected to WiFi. Don’t forget to adjust the interval in /etc/crontab back to a more appropriate value, if you set it to one minute for testing.

Hopefully this helps keep your RaspberryPi projects online! If you have any questions, or have an alternative method to suggest, feel free to leave a comment.

If you’d like additional context about the project, you may be interested in:

• Open Source Univeral Remote
• Open Source Universal Remote - Parts & Pictures
• RaspberryPi IR Schematic for LIRC
• Controlling LIRC From the Web

In v0.0.8 I’ve added two new features - macros and repeaters.

Macros

Macros allowing you to execute multiple IR commands in rapid succession from a single button tap or HTTP request. The use case for this would be when you need multiple devices to be turned on and set to a certain mode to perform an activity (say, playing a video game or watching a movie). An example macro might be:

• Turn TV on
• Set TV to input 3
• Turn receiver on
• Set receiver input HDMI2
• Turn game console on

Macros make performing common multi-step tasks simpler. In addition, Macros are exposed via the API, which means you can execute macros by sending an HTTP request from a growing number of internet of things or web connected devices. For example, you could adjust the volume of the TV from your Pebble watch or change the TV channel by waving your arm while wearing a Myo armband.

Macros are defined in a JSON configuration file (config.json) that lirc_web expects to find in the root of the project. Here’s an example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

{
  "macros": {
    "Play Xbox 360": [
      [ "SonyTV", "Power" ],
      [ "SonyTV", "Xbox360" ],
      [ "Yamaha", "Power" ],
      [ "Yamaha", "Xbox360" ],
      [ "Xbox360", "Power" ]
    ],
    "Listen to Music": [
      [ "Yamaha", "Power" ],
      [ "Yamaha", "AirPlay" ]
    ]
  }
}

The macros key is an object of keys (labels) that are set to arrays of [remote, command] pairs. The remote and command strings should match what is defined in the LIRC configuration file. A small delay is introduced between each command to ensure they are all received.

After you create or change anything in config.json, you will have to restart lirc_web. Afterwards, you’ll see your macros listed at the bottom of the user interface.

Macros are also available via the API. You can execute them by creating a POST request to a url like so:

1

http://ip-of-remote/macros/Play%20Xbox%20360

Repeaters

Repeaters are a type of button that repeatedly send it’s command as long as it is held down. The use case for a repeater would be a volume button that should continue to change the volume as long as it’s pressed - rather than needing to tap it many times.

Repeaters are also specified in the configuration file. Here’s an example:

1
2
3
4
5
6
7
8

{
  "repeaters": {
    "SonyTV": {
      "VolumeUp": true,
      "VolumeDown": true
    }
  }
}

Similar to macros, the name of the remote and command must match the names you gave these commands in the LIRC configuration file. If you want to change the name of a button, update the LIRC configuration file and restart LIRC / lirc_web.

Enjoy

I’ve found these two features make the Open Source Universal Remote significantly more useful for common tasks. If you have any suggestions for new features or ideas on how to improve the project, please share your ideas in the comments.

Previously, I discussed how I built an open source universal remote using a RaspberryPi, an expansion board, and a NodeJS web application. This device allows me to control any infrared device in my home from my phone, smart watch, laptop, or other web connected device. I use the remote daily, and it’s sparked my curiosity to devise new ways of enhancing my environment with internet connected devices.

In this post, I’m going to cover a new project I recently finished - creating a device that monitors a washer or dryer and sends a text message when it detects that a load of laundry has finished. Beyond the novelty and simplicity of receiving a text message when the laundry is done, I built this device for two reasons. First, I wanted a project that introduced me to accelerometers - a sensor I’ve wanted to work with. Second, I wanted to take another stab at applying the principles of progressive enhancement, a web software concept, to the physical world.

“Progressive enhancement uses web technologies in a layered fashion that allows everyone to access the basic content and functionality of a web page, […] while also providing an enhanced version of the page to those with more advanced browser software […].” (Wikipedia)

I wanted to see if I could apply the concept of progressive enhancement to the physical world by enhancing an existing appliance (in this case, a washer or dryer) with new digital functionality - without modifying it’s existing form or interface. I wanted the appliance to look and behave exactly as it did before the modification, and I wanted no visual evidence that my device had been installed. After some brainstorming, I came up with an approach that met my goals. Read on to learn how I build it, and how you can build one yourself.

Overview

At a high level, the project works as follows: a 3D printed enclosure magnetically attaches to the outside of the washer or dryer. Inside the enclosure is an Electric Imp microcontroller and an ADXL335 accelerometer. The accelerometer measures the vibrations of the washer and dryer. The microcontroller has firmware on it that samples the accelerometer, processes the output, and periodically sends a computed result to a server in the cloud. The server receives the output and runs an algorithm that determines whether the washer or dryer is currently running. Once the server has confidently determined that the washer or dryer has finished running, it sends an SMS (using Twilio) to one or more predefined phone numbers.

I’ll cover the implementation in more detail below. This post is broken down into three sections:

• The hardware
• The 3D printable enclosure
• The software

I’ll end with a conclusion and some closing thoughts.

Part 1: The Hardware

For this project, I purchased most of my parts from Adafruit, an online retailer of electronic components. The rest of the parts I purchased from Amazon. Here’s the bill of materials:

• Electric Imp
• April dev board for Electric Imp
• ADXL335 analog 3.3V +-3g accelerometer
• Quarter size perma-proto breadboard
• USB power supply
• USB A to Mini B cable
• Solid core wire
• 2 small rare earth magnets (available from any hardware store)

Electric Imp

For this project, I chose to work with the Electric Imp microcontroller. The Electric Imp is a microcontroller in the form factor of an SD card with a 32bit Cortex M3 processor. What I find most interesting about the Electric Imp is that it also includes an 802.11b/g/n chip, making it one of the smallest WiFi enabled microcontrollers I’ve found. I also used the April development board, a breakout board from the Electric Imp team, which breaks out the pins on the imp and provides a mini USB connection for power. You can see that development board, a green circuit board, in the image beneath the “Hardware” header.

Configuring the Electric Imp with your WiFi credentials is done through a clever process called BlinkUp. The Imp itself contains a phototransistor, which enables you to program your WiFi credentials optically, via an app on your Android or iOS device. Once you install and configure the app, the display on your phone strobes in a pattern that the Imp recognizes, which programs the WiFi credentials into the Imp. The process only takes a few seconds, and it worked flawlessly for me the first time.

Once you’ve programmed your WiFi credentials onto the Imp, it will automatically connect to the Electric Imp cloud service. From there, you’re able to login to the web based IDE and program the imp via your web browser. The IDE handles deploying code updates to the device, as well. I’d like to see a GitHub integration, which would provide version control, so hopefully that’s on their roadmap.

ADXL335 Analog Accelerometer

For the accelerometer (the component that measures the vibration of the washing machine / dryer), I chose the ADXL335. The ADXL335 is a 3.3V analog accelerometer sensitive to +- 3g. The device itself is widely used, and I found plenty of documentation online. In addition, Adafruit sells a breakout board (listed above in the bill of materials) that made including the device in my project an easy decision. The breakout board that Adafruit sells also allows you to connect the accelerometer to a 5V microcontroller, such as an Arduino.

Assembling the Hardware

The assembly of the device is relatively straightforward. First, you will need to assemble the April development board and the ADXL335 breakout board by soldering the header pins onto the breakout boards. Next, you’ll need to solder both breakout boards into the perma-proto board. Lastly, you’ll solder in the 5 wires to enable the two components to communicate. If you intend to use the 3D printable enclosure, please ensure that the two components are mounted identically to the image above.

The picture above shows how the device looks when assembled, and here are the specifics:

• Pin 1 from Electric Imp is connected to the X-out pin on accelerometer.
• Pin 2 from the Electric Imp is connected to the Y-out pin on accelerometer.
• Pin 5 from the Electric Imp is connected to the Z-out pin on accelerometer.
• 3V3 pin from Electric Imp is connected to the Vin pin on accelerometer.
• GND pin from Electric Imp is connected to GND pin on accelerometer.

At this point you should be able to:

• Boot the device up with a USB power supply
• Program the Electric Imp to connect to your WiFi
• Log into the Electric Imp web based IDE to program the device

Part 2: The 3D Printable Enclosure

For this project, I wanted a custom enclosure that would enable the device to be sealed from dust and debris. I contacted a friend of mine, John Steenson, who agreed to help me design a 3D printable enclosure for the project. He has agreed to let me post the STL files for the case, which you can download and have 3D printed yourself. I had my case printed from a local printer that I found on the 3D Hubs service. I had a great experience with 3D Hubs, and highly suggest it if you’re trying to find a local 3D printer.

The above photos show the device mounted in the case (with and without the lid). Inside of the case, but beneath the device, I have attached (with two sided tape) the two rare earth magnets. I then placed a thin sheet of plastic between the magnets and the device to ensure there is no chance of electrical short. I have not found that the magnets interfere with the device in any way. The two magnets are what enables the device to attach to the washer or dryer.

STL files for the 3D printable enclosure:

• Enclosure - Base
• Enclosure - Lid

Screws / nuts for mounting device within enclosure and securing lid:

All part numbers are from McMaster-Carr. Per my friend John, quantities noted are the quantities required for assembly, not package quantity. You’ll have some extra parts, but they’ll probably come in handy for future projects down the road.

• 3x - 91420A008
• 2x - 92000A015
• 2x - 93475A195
• 5x - 90592A004
• 1x - 8461K12 - Trim to fit

Part 3: Writing the Software

When writing software for the Electric Imp, you write two programs. The first program, called the “Device”, runs on the Electric Imp hardware. The second program, called the “Agent”, runs on the Electric Imp cloud. The Agent has the ability to send and receive HTTP traffic, making it a perfect candidate for the Twilio API, a RESTful API that allows you to send SMS messages.

For this project, the Device samples the accelerometer 50x a second. I found this to be frequent enough to get a clear picture for how much the washer or dryer is vibrating. For each sample, I determine the magnitude of the accelerometer vector and compute the percentage of change against the previous sample’s magnitude. I track the amount of change over 5 seconds (250 samples), and return that value to the Agent. In my testing, I found that the average reading when the machine was turned off to be between 100 and 250. When the washer or dryer are running, I find the samples vary between 275 and 6000 depending on what stage of the cycle the machine is in.

The Agent receives the total amount change over the past 250 samples, and compares that against a threshold to determine if the machine is ON or OFF. If the value is above the threshold, the device is experiencing enough vibration where it’s safe to call the machine ON. In my testing, I found 280 to be a good threshold to determine if the washer or dryer was running. Once the Agent receives N consecutive samples above the threshold, it enters the RUNNING state. Then, at some point in the future, once the Agent receives M consecutive samples below the ON threshold, it returns to the OFF state. These delays help take into account lulls in vibration during a typical laundry cycle (ex: filling the washer, rinse cycle, draining the washer). Depending on your appliances, you may need to adjust the thresholds in the Agent to reduce false positives. Finally, when returning to the OFF state, if the device was in the RUNNING state, an SMS notification is emitted (via Twilio) to each phone number stored in the phoneNumbers array.

If you’d like to read more about how to process the data coming off an accelerometer, I found A Guide To using IMU (Accelerometer and Gyroscope Devices) in Embedded Applications to be an extremely informative read.

Note: The Agent code requires you to setup a Twilio account and enter your Twilio credentials before you can send any messages. Twilio, at the time of writing this article, charges $0.01 per text message. At the rate I do laundry, it should cost < $2 a year to send these text messages.

Note2: If you would like to log all of your data to a persistent data store (either to show on a web page, or just to analyze output), Firebase is a great option, and they have a free tier. Just change logToFirebase to be true and enter your Firebase URL if you want to enable this feature.

You may also view this code on GitHub.

Here is the code for the Device, which reads in and processes the accelerometer data:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

total <- 0; // Sum of % change from all samples
n <- 0;     // Counter for number of samples read
last <- 1;  // Previous reading of magnitude

function readSensor() {
    // Time interval
    local interval = 0.02;

    // Get source voltage, should be 3.3V
    local vRef = hardware.voltage();

    // Read in ADC values from accelerometer
    local adcRx = hardware.pin1.read();
    local adcRy = hardware.pin2.read();
    local adcRz = hardware.pin5.read();
    // server.log(format("Raw ADC values: %f, %f, %f", adcRx, adcRy, adcRz));

    // Convert 16bit ADC accelerometer values (0-65535) into voltage
    local voltsRx = (adcRx * vRef) / 65535.0;
    local voltsRy = (adcRy * vRef) / 65535.0;
    local voltsRz = (adcRz * vRef) / 65535.0;
    // server.log(format("Voltages: %f, %f %f", voltsRx, voltsRy, voltsRz));

    // Subtract 0g (1.5V at 3V, 1.65V at 3.3V)
    local deltaVoltsRx = voltsRx - (vRef / 2);
    local deltaVoltsRy = voltsRy - (vRef / 2);
    local deltaVoltsRz = voltsRz - (vRef / 2);
    // server.log(format("Adjusted voltages %f, %f, %f", deltaVoltsRx, deltaVoltsRy, deltaVoltsRz));

    // Convert from voltage to g, using sensitivity of 300mV
    local rX = deltaVoltsRx / 0.3;
    local rY = deltaVoltsRy / 0.3;
    local rZ = deltaVoltsRz / 0.3;
    // server.log(format("Gs: %f, %f, %f", rX, rY, rZ));

    // Compute magnitude of force
    local magnitude = math.sqrt(math.pow(rX,2) + math.pow(rY, 2) + math.pow(rZ, 2));

    // Compute % change since last reading
    local change = math.fabs((magnitude - last)/last) * 100.0;

    // Store magnitude in last for next time
    last = magnitude;

    // Log magnitude and percent change
    // server.log(format("magnitude: %f, change amount: %f", magnitude, change));

    // Increment total with % change, increment N
    total = total + change;
    n = n + 1;

    // Log data to server once ever 250 samples (5 seconds)
    if (n >= 250) {
        agent.send("data", total);
        n = 0;
        total = 0;
    }

    // Sleep until time to read sensor again
    imp.wakeup(interval, readSensor);
}

// X input
hardware.pin1.configure(ANALOG_IN);

// Y input
hardware.pin2.configure(ANALOG_IN);

// Z input
hardware.pin5.configure(ANALOG_IN);

// Start reading the sensor
readSensor();

Here is the code for the Agent, which determines when to send an SMS

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

// Run on Agent

// Thresholds to adjust for better accuracy
dataThreshold <- 280; // Minimum accelerometer value to count as ON
onThreshold <- 24;    // Number of ON samples before machine enters RUNNING state
offThreshold <- 60;   // Number of OFF samples before machine enters OFF state

// State variable
running <- false;

// Keep track of counts
onCount <- 0;
offCount <- 0;

// Twilio
twilioURL <- "https://USER:PASS@api.twilio.com/2010-04-01/Accounts/ID/Messages.json";
twilioHeaders <- { "Content-Type": "application/x-www-form-urlencoded" };
twilioNumber <- "+14155551212";

// Array of phone numbers to be contacted with the laundry is done
phoneNumbers <- ["+14155555555", "+14155555556"];

// Firebase
logToFirebase <- false;
firebaseURL <- "https://FIREBASE_URL.firebaseIO.com/data.json";
firebaseHeaders <- { "Content-Type": "application/json" };

// Called every time the imp emits data
device.on("data", function(data) {

    // Is there enough accelerometer activity for the device to be considered ON?
    if (data >= dataThreshold) {
        onCount = onCount + 1;

        // Prevent overflow errors by resetting onCount when it gets close to limit
        if (onCount >= 65500) {
            onCount = onThreshold;
        }

        // If the device has been ON for long enough, set running state to be true
        if (onCount >= onThreshold) {
            running = true;

            // Running, so reset offCount
            offCount = 0;
        }

        // debug / logs
        if (running == true) {
            server.log(format("ON - RUNNING (%f), onCount (%d), offCount (%d)", data, onCount, offCount));
        } else {
            server.log(format("ON (%f), onCount (%d), offCount (%d)", data, onCount, offCount));
        }

    // Imp is not recording much accelerometer movement, so device seems to be OFF
    } else {
        offCount = offCount + 1;

        // Prevent overflow errors by resetting offCount when it gets close to limit
        if (offCount >= 65500) {
            offCount = offThreshold;
        }

        // Has the device been off for long enough to be "done"?
        if (offCount >= offThreshold) {

            // Was the device previously running?
            if (running == true) {

                // This means that the laundry had been running, and is now done.

                // Send an SMS to each phone number in the phoneNumbers array.
                foreach (number in phoneNumbers) {
                    local body = format("To=%s&From=%s&Body=The%%20laundry%%20is%%20done.", number, twilioNumber);
                    local request = http.post(twilioURL, twilioHeaders, body);
                    local response = request.sendasync(function(done) {});
                }

                // debug / logs
                server.log("!!!! Emitting OFF event !!!!");
            }

            // Reset on count
            onCount = 0;

            // Machine is no longer running
            running = false;
        }

        // debug / logs
        if (running == true) {
            server.log(format("OFF - WAS RUNNING (%f), onCount (%d), offCount (%d)", data, onCount, offCount));
        } else {
            server.log(format("OFF (%f), onCount (%d), offCount (%d)", data, onCount, offCount));
        }
    }

    if (logToFirebase == true) {
        // Build a post request to Firebase to log the data
        local body = format("{\"amount\": %f, \"running\": %s, \".priority\": %d}", data, running ? "true" : "false", time());
        local request = http.post(firebaseURL, firebaseHeaders, body);

        // Send the data to Firebase async
        local response = request.sendasync(function(done) {});
    }
});

After loading these two pieces of software onto the Electric Imp (via the web IDE), you should be ready to install the device in your home! Installation is simple - just magnetically attach the device to any metal service on the washer or dryer. Give it a whirl by doing a load of laundry and watching the log files (via the web IDE). If all goes well, you should receive a text message a few minutes after the load of laundry completes.

Conclusion

I set out to build a minimally invasive device that progressively enhanced an appliance into the digital age, which didn’t physically modify the appliance in any way. During the project I had the opportunity to work with a few new technologies - the Electric Imp, an accelerometer, and 3D printing. All in all, I’d say the project was a success. The device is currently hooked up to my washer, and it works well in it’s current state.

This project came out of a (relatively) trivial need - to know when a load of laundry is done when you aren’t in close proximity to the washer or dryer. I thought it would be clever to receive a text message when the laundry is done, since all phones support SMS and Twilio has made interacting with SMS easy. This also gets around the need to download or install a native app on your phone.

I do recognize there are other approaches to solving this problem - monitoring the power output of the appliance, listening for the buzzer with a microphone, or placing a photodiode over a “done” indicator - but I ultimately chose the accelerometer because I wanted to gain experience working with the sensor.

While I do not believe I’ll be spending much additional time on this project, there are a number of potential enhancements that I see:

• Adding a battery, to make the device portable.
• Swapping out a WiFi chip for a GSM chip, allowing you to take the device to a laundromat.
• Designing a custom circuit board, to dramatically reduce the size of the device.
• Creating a waterproof (and heat tolerant) device/enclosure so you can place the device inside the washer/dryer. This would be more secure than leaving a device on top of a machine.

Hopefully you found this post helpful if you’re trying to implement a similar device yourself. If you have any questions, feel free to ask in the comments. If you’re interested in having one of these devices for yourself, but don’t want to build one, send me an email at alex@alexba.in and we can work something out.

To accomplish this will take three steps:

1. Configure the hostname for the RaspberryPi
2. Install and configure Upstart
3. Install and configure NGINX

Note: Not all mobile devices support .local domains. You may still need to connect via IP.

Configure the hostname for the RaspberryPi

If you want your RaspberryPi to be accessible on your local network via hostname, instead of always typing it’s IP address, you’ll want to install an mDNS daemon. If you’d like to learn why, I recommend reading How (and Why) to Assign the .local Domain to Your Raspberry Pi. The RaspberryPi supports Avahi, which can be installed with:

sudo apt-get install avahi-daemon

When that finishes, try pinging raspberrypi.local from a different computer. Everything should just work. Next, we’ll update the hostname of the RaspberryPi to be universalremote. This requires three steps:

1. Edit /etc/hosts and change the last line to 127.0.1.1 universalremote
2. Edit /etc/hostname and change the hostname to universalremote
3. Reboot the RaspberryPi by running sudo shutdown -r now

After the RaspberryPi boots back up, you should be able to connect to the RaspberryPi via hostname (http://universalremote.local) or IP.

Install and configure Upstart

To ensure the lirc_web app starts when the RaspberryPi boots, we will use a tool called Upstart. Upstart is a project from Ubuntu that simplifies writing init scripts. If you want to learn more about it, you can visit http://upstart.ubuntu.com/ and read more. RaspbianOS does not include Upstart by default, but it can be installed to replace sysvinit with no negative consequences. Here are the commands:

sudo apt-get install upstart
# You will be asked to type 'Yes, do as I say!'
# You may see an error about initctl being unable to connect, which will be fixed after a reboot

# Reboot the RaspberryPi
sudo shutdown -r now

Once the RaspberryPi reboots Upstart should be installed. Upstart configuration files are placed in /etc/init. You can either use the sample Upstart configuration that comes with the lirc_web Git repository, or you can use this example (place in /etc/init/open-source-universal-remote.conf):

# /etc/init/open-source-universal-remote.conf
description "universalremote.local"

start on runlevel [2345]
stop on runlevel [016]

# Restart when job dies
respawn

# Give up restart after 5 respawns in 60 seconds
respawn limit 5 60

script

  echo $$ > /var/run/open-source-universal-remote.pid
  exec /usr/local/bin/node /home/pi/lirc_web/app.js 2>&1 >> /var/log/open-source-universal-remote.upstart.log

end script

pre-start script
    # Date format same as (new Date()).toISOString() for consistency
    echo "[`date -u +%Y-%m-%dT%T.%3NZ`] (sys) Starting" >> /var/log/open-source-universal-remote.upstart.log
end script

pre-stop script
    rm /var/run/open-source-universal-remote.pid
    echo "[`date -u +%Y-%m-%dT%T.%3NZ`] (sys) Stopping" >> /var/log/open-source-universal-remote.upstart.log
end script

After creating the Upstart script, you should be able to start the lirc_web project by running:

sudo initctl start open-source-universal-remote

You can verify everything works by opening http://universalremote.local:3000 (or the RaspberryPi’s IP address) in your web browser. You should see the lirc_web web interface.

Install and Configure NGINX

If you run lirc_web by itself it creates a basic web server on port 3000. This is fine, but it’s more convenient when an web application runs on port 80, the default port for web traffic. We’ll use the free and open source NGINX web server to accomplish this.

To install nginx and ensure it starts on boot, run:

sudo apt-get install nginx
update-rc.d nginx defaults
sudo service nginx start

When this completes, confirm everything installed correctly by trying to access http://universalremote.local in your web browser. You should see a “Welcome to nginx!” web page.

Next, we have to configure nginx to serve the lirc_web app. You can use the sample config file included in the lirc_web Git repository (within the config directory), or use this example:

server {
    listen            80;
    server_name       universalremote.local;

    # Change this to the location you installed lirc_web
    root              /home/pi/lirc_web;
    index             index.html index.htm;

    access_log        /var/log/open-source-universal-remote.nginx.log;

    location / {
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_set_header X-NginX-Proxy true;

        proxy_pass http://127.0.0.1:3000/;
        proxy_redirect off;
    }
}

Update November 11th, 2013: Save this configuration data in a file called /etc/nginx/conf.d/open-source-universal-remote.conf. Nginx will automatically detect this file once you restart it.

Restart nginx to pick up the new configuration file with sudo service nginx restart.

Now, if you visit http://universalremote.local in your web browser you should now see the project running. In the future, any time you reboot the RaspberryPi lirc_web will start automatically.

Conclusion

If everything went smoothly you should now have a daemonzized version of lirc_web running on your RaspberryPi, which is being served via nginx over port 80. In addition, any time you restart your RaspberryPi the lirc_web app will start up at boot.

Are you interested in reading more about the Open Source Universal Remote project? Check out:

• Setting up LIRC on the RaspberryPi
• Controlling LIRC from the web
• Using a RaspberryPi and a Pebble Watch to control your home theater
• Open Source Universal Remote - Parts & Pictures

I’ve updated the lirc_web project (available at http://github.com/alexbain/lirc_web) to v0.0.5. This version fixes a bug related to the swig npm module that was causing an error when trying to view the project in a browser.

If you were encountering a JavaScript error after trying to install lirc_web this should fix it. Thanks to the folks that reported this.

Please let me know if you encounter any other errors!

This past weekend I converted my Open Source Universal Remote breadboard layout into a more permanent soldered circuit. I used the Adafruit Protoboard as a base instead of having a custom circuit board printed, which worked out well. The protoboard is perfectly sized for the RaspberryPi and I highly recommend it for any RaspberryPi related hardware projects.

Below, I’ve attached some high resolution photographs of the finished protoboard (front and back). I’ve also created separate versions of the photographs which are fully annotated and explain how all of the components are laid out. Please note that I did make one miscalculation in my circuit which I have corrected with a yellow jumper wire. I’ve pointed out the miscalculation on both annotated photographs.

Parts list:

• 1 Adafruit RaspberryPi Protoboard
• 2 940nm 40deg IR LEDs
• 2 right angle LED holders
• 1 P2N2222AGOD-ND transistor
• 1 10k Ohm resistor
• 1 TSOP38238 38KHz IR receiver
• Hook-up Wire Spool Set - 22AWG Solid Core - 6 x 25 ft
• RaspberryPi running LIRC (See: RaspberryPi Quickstart, Setting Up LIRC on the RaspberryPi, Installing NodeJS on your RaspberryPi, and Controlling LIRC from the Web)

Schematic:

Project pictures:

All pictures link to a full resolution image (10+ megapixel) which provides plenty of additional resolution for examining the circuit. The annotated photographs should help fill in anything that is unclear. If you have any questions, please leave them in the comments.

If you’d like to read more about this project, here is some further reading:

• Open Source Universal Remote intro - Intro post to the project
• RaspberryPi IR Schematic for LIRC - Electrical schematic for the hardware
• Setting up LIRC on the RaspberryPi - Installing and configuring IR software
• Controlling LIRC From the Web - Installing (mobile/desktop) web interface

To open the current working directory in Finder, just run:

open .

Simple, right? The more you know.

Introduction

For a bit of backstory, around eighteen months ago I decided to start experimenting with and teaching myself electronics. I started working with an Arduino Uno and eventually moved to a RasperryPi. I wanted to build open hardware, open source, web connected devices and these seemed like the right tools for the job. I wanted to ensure that every device I built could, down the road, be controlled in entirely new ways with novel human computer interfaces like the Pebble Watch, Thalmic Labs Myo, Emotiv EPOC EEG Headset, Leap Motion, Google Glass, and others.

So, after some consideration, I chose to build a RaspberryPi powered device that controls all of the infrared devices in my home. This project has turned into the Open Source Universal Remote, an open hardware/open source device you can make yourself with a RaspberryPi and $10 of electronic parts. This post will discuss how I wired up my Pebble Watch to control my Open Source Universal remote using my Android phone.

Let’s get started!

Outline

• Part 0: How it Works
• Part 1: Open Source Universal Remote
• Part 2: The Android Phone
• Part 3: The Pebble Watch
• Part 4: Conclusion / What’s next

Part 0: How it Works

At a high level, the project works like this:

1. User taps button on Pebble Watch.
2. Pebble Watch tells Android phone that a button has been tapped.
3. Android phone makes web request to Open Source Universal Remote API.
4. Open Source Universal Remote receives web request and sends out infrared pulses.
5. Home theater device detects infrared pulses and responds accordingly.

I’ll work backwards from the Open Source Universal Remote to the Pebble Watch.

Part 1: Open Source Universal Remote

The foundation of this project is the Open Source Universal Remote. I won’t be going into detail about how to make one here, but if you’re interested in learning more or making your own, here is all the information you need:

1. Open Source Universal Remote - The open source universal remote home page. This is an overview of the project and how it works.
2. RaspberryPi QuickStart - A guide I wrote to purchasing and doing the initial configuration on a RaspberryPi.
3. Setting up LIRC on the RaspberryPi - How to setup and install the Linux Infrared Remote Control (LIRC) software on the RaspberryPi
4. Controlling LIRC from the Web - How to install and configure two open source projects I wrote (lirc_node and lirc_web) to enable you to control LIRC from the web.
5. Open Source Universal Remote - Parts & Picturse - Finalized parts list and build pictures from a protoboard I soldered together.

For this project, I’ll be using the HTTP based API that the Open Source Universal Remote generates based on the remotes and commands you teach it. Here are the three URLs I used for this project:

http://192.168.1.115:3000/remotes/Yamaha/power
http://192.168.1.115:3000/remotes/Microsoft_xbox360/onoff
http://192.168.1.115:3000/remotes/sonytv/power

You could get clever and use the hostname of the open source remote, I’m just using the static IP address here.

Part 2: The Android Phone

The second component of this project is an Android phone with the Tasker app installed on it. Tasker is a great app that provides a rich way to control your Android phone. One of the functions is the ability to send HTTP POST requests to specific URLs, which is the feature we’ll be using for this project.

Within the Tasker app you’ll need to create three new tasks, one for each button on the Pebble watch. Each task should be created with a descriptive name (like “Yamaha Power”) and will contain a single HTTP POST action (found in the Net menu), which will be sent to the open source remote. Here’s where the HTTP POST action can be found:

The HTTP POST action should be setup like this:

# IP / Port of the Open Source Universal Remote
Server:Port   http://192.168.1.115:3000

# Path to the remote/command combo you want to call
Path          /remotes/Yamaha/power

Once you’ve created those three Tasks, you’re ready to setup the Pebble Watch.

Part 3: Pebble Watch

The Pebble Watch was a successful Kickstarter project that launched in 2012. It’s a smart watch which connects to your cell phone via Bluetooth. It has a software development kit enabling anyone to write apps for the watch. I participated in the Kickstarter project, and have been very excited to start using my watch as a “remote control for reality.”

For this project we’ll be using the Android/Pebble combo app called PebbleTasker. This is a very straightforward app. You install the app on your phone, which gives you the option to install the PebbleTasker app on the watch.

Once the watch app has been installed, you use the Android app to define which Tasker actions should be assigned to which button. Select the three Tasker actions that you created above and you should be set!

Here’s a photograph of my Pebble Watch with the above Tasker actions programmed into the watch:

Part 4: Conclusion / What’s Next

Not to wax too philosophical, but I believe that next generation user interface devices like the Pebble Watch have the potential to transform how humans interact with the digital world. The cell phone was revolutionary - it enabled humans to interact with their data while away from a desktop or laptop computer. Now, devices like the Pebble Watch and the RaspberryPi allow you to move beyond the phone and begin interacting with the digital world in an entirely new way.

As additional web connected devices are made that control lights, garage doors, cars, appliances, and beyond, the interplay between those devices and user interface devices like the Pebble Watch, Myo, Emotiv EPOC, Google Glass, and others are going to give us new and powerful interactions to control the digital and physical world. These interactions were, until now, the stuff of science fiction. These are exciting times we live in.

If you found this post interesting, please subscribe to the RSS feed to receive future updates or share this post with your social network. If you have any questions, feel free to leave a comment or send me an email (alex[at]thisdomain).

Tune in next time where I’ll be writing up how to control the Open Source Universal Remote with your mind using an Emotiv EPOC EEG headset.

As part of the Open Source Universal Remote project I’ve been creating a simple and touch friendly user interface for LIRC. In a previous post I covered Controlling LIRC From the Web, where I introduced version 0.0.1 of lirc_web. Lirc_web is a simple NodeJS app I created for controlling LIRC from the web.

Since then, I’ve created a set of UI styles and fixed a number of touch related bugs with the project. I’m excited to announce v0.0.3 of lirc_web which is now on GitHub.

Here is a screen shot of the remote listing page:

Upon tapping on any remote, you’ll be taken to a page that shows all known commands for that remote:

I have a long list of intended improvements, so if you’re interested in contributing to the project please let me know. As always, if you discover any bugs or have any feedback, please let me know in the comments.

June 1st, 2013: Thanks to some feedback and experimentation I’ve updated the schematic. This latest version reflects the best combination of parts I’ve found so far.

June 3rd, 2013: Two more schematic bugfixes.

June 8th, 2013: Read about the finished protoboard build in my Open Source Universal Remote - Parts & Picturse blog post.

View the schematic and parts list

If you have any suggestions for improvements feel free to tinker on it and submit them.

Interested in installing LIRC on your RaspberryPi? You may be interested in reading Setting up LIRC on the RaspberryPi and Controlling LIRC From the Web.

Update: Thanks to Steve in the comments for pointing out a few errors I had in the schematic.

Almost a year ago I decided to teach myself electronics by creating my own WiFi enabled universal remote. Initially I tried to build the project with an Arduino, but later switched to a RaspberryPi. As I’ve made progress on my project I’ve open sourced the software I’ve written and blogged about every step of the process.

To date, I’ve had over nine thousand unique visitors check out the posts related to this project. Based on the positive feedback I’ve received and the questions asked, I believe it makes sense to aggregate all of the data I’ve spread out across numerous blog posts into one guide. Over the coming weeks I’ll be creating a step by step guide for building your own RaspberryPi powered universal remote. In addition, I’ll be creating and open sourcing additional components of the project such as a printed circuit board and a 3D printable case to enclose the project.

Check out the Open Source Universal Remote landing page I created for the project. In the coming weeks I’ll be adding additional content to that page.

If you have any requests or ideas for this project please don’t hesitate to ask in the comments. In addition, if you have hardware engineering experience or industrial design experience and would like to contribute please get in touch.

If you’re completely new to the RaspberryPi and want to learn more I wrote a RaspberryPi Quickstart post which covers everything from purchasing the parts to configuring the WiFi. Check that out if you’re new to the RaspberryPi ecosystem.

With that out of the way, let’s get started!

Why a web interface + API?

LIRC is an awesome open source project that handles all of the low level requirements of sending and receiving Infrared commands from a Linux computer. It’s well documented, well supported, and thanks to the work of the open source community there is now a lirc_rpi driver included in the latest version of RaspbianOS. This means that, as long as you’re running a RaspberryPi with the latest OS and firmware, LIRC can interface with the RaspberryPi GPIO pins. Fantastic.

Once you have LIRC installed and configured (which I cover in my Setting up LIRC on the RaspberryPi post), you can use LIRC executables like irsend and irrecord to send and record IR commands for all your IR devices - right from the command line! This is great fun, but not very user friendly.

I wanted a way to control LIRC from the web. I wanted a web application that enabled me to interact with LIRC from any web connected device. If I had that, I could create a mobile web app for my phone, a regular web app for a desktop, and a RESTful API for web services. The API would give me a way to connect LIRC with any external web service - opening the door for future integrations. All I needed to do was find a way to call LIRC commands from within a web application.

Which brings us to the meat of this post. Getting NodeJS and LIRC to talk.

Getting LIRC and NodeJS to talk

To make LIRC usable from the web I needed a client library in a language I could build a web application in. The client library would provide some way to make calls from the web application to LIRC. This would give me the building blocks I needed to build a web application. The usual web languages include PHP, Python, Ruby, and NodeJS.

For this project I chose to work in NodeJS. If you would prefer to implement a web application in a different language, I found two existing LIRC client libraries. Sadly, neither seem maintained. I found lircr for Ruby and pyLirc for Python.

Since I could not find an existing NodeJS LIRC client library, and the existing libraries I did find were not up to date, I built my own. I created lirc_node, a lightweight NodeJS client library that interfaces with LIRC. v0.0.1 of lirc_node only supports irsend. This allows you to send IR commands to devices that LIRC knows about.

Before trying to install and use lirc_node make sure you have completed these steps:

• Purchased, setup, and configured a RaspberryPi to join a network
• Wired up an IR LED and an IR Receiver to your RaspberryPi
• Installed and configured LIRC to interface with your IR LED and IR Receiver
• Programmed LIRC to understand your remote controls
• Installed NodeJS on your RaspberryPi

If you have not completed all of those steps scroll back to the top of this post and check out my earlier posts. I have written detailed step by step guides to get you through each of those steps.

All caught up? Great! We’re ready to install a basic web application for LIRC.

Creating a NodeJS web application using lirc_node and lirc_web

The easiest way to setup a NodeJS web application using lirc_node is to use v0.0.1 of lirc_web, a sample NodeJS application I wrote as a proof of concept for lirc_node. This web application is extremely basic, and only proves that lirc_node works. I have plans to grow this application with additional functionality and an improved interface. You may also use the basic API included in this web application to connect your universal remote with services like Tasker or IFTTT.

January 17th 2015 Update: lirc_web is now at v0.0.8 and contains bugfixes and additional functionality. The user interface has been improved since v0.0.1, as well.

To download and install lirc_web:

wget https://github.com/alexbain/lirc_web/archive/master.zip
unzip master.zip
mv lirc_web-master lirc_web
rm master.zip
cd lirc_web
npm install
node app.js

That should do it. Now, visit http://raspberrypi:3000/ (or the IP address of your RaspberryPi) to confirm the sample web application shows all of the remotes and commands LIRC knows about. Clicking any of the links will tell LIRC to send that IR command via the API endpoint.

November 2nd 2013 Update: I have posted a follow up post that discusses how to ensure the lirc_web project automatically starts on boot and is accessible via port 80. Check out Running lirc_web with Nginx and Upstart to learn more.

Success!

At this point, assuming you’ve been able to get each step working, you should have a web application you can use to control any IR device that LIRC knows about.

What’s next?

In the coming months I hope to:

• Create an open hardware schematic and PCB board that anyone can use for the hardware.
• 3D print an enclosure for the RaspberryPi + expansion board.
• Improve the web application and give it a proper mobile web interface.
• Write about how to connect lirc_web to Tasker or IFTTT.

If you have any questions, suggestions, or run into any issues - please let me know.

Upgrade to the latest OS / Firmware

If you have not already upgraded to the latest version of Raspbian OS and the latest RaspberryPi firmware, I recommend following my RaspberryPi Quickstart.

Getting and Compiling NodeJS

Once your RaspberryPi is up to date, here’s how to download and compile NodeJS:

# Install some prerequisites
sudo apt-get install python g++ make

# Grab the latest version of NodeJS
mkdir ~/nodejs && cd $_
wget -N http://nodejs.org/dist/node-latest.tar.gz
tar xzvf node-latest.tar.gz && cd `ls -rd node-v*`

# Compile and install to your RaspberryPi
./configure
make
sudo make install

Please note that it takes about two hours to compile NodeJS.

Confirming Installation

You can confirm that NodeJS was installed correctly by running:

node -v
npm --help

That’s it! You’re ready to begin development.

Additional Reading:

If you’d like to do some additional reading about NodeJS or ways to access the GPIO pins on the RaspberryPi, check out:

• NodeJS - NodeJS home page
• pi-gpio - “node.js based library to help access the GPIO of the Raspberry Pi”
• GpiO - “Talk to your Raspberry Pi’s GPIO”

If you have any other recommended resources please let me know!

0: Make sure your RaspberryPi is fully updated

Before you get started I highly recommend you follow my RaspberryPi Quickstart guide to get your RaspberryPi updated to the latest OS and Firmware. That post also includes links to the case and peripherals I purchased for this project.

1: Install Chromium

First, you’ll want to install Chromium on your RaspberryPi. We’ll be using Chromium to load the dashboard. I’ve also included the ttf-mscorefonts-installer package so things render nicely.

sudo apt-get install chromium ttf-mscorefonts-installer

2: Boot into X11 automatically

You’ll want to make sure your RaspberryPi immediately boots into X11.

sudo raspi-config

Scroll down to boot_behavior and hit enter. Make sure “Yes” is marked and hit enter again.

You’re done here, so scroll to Finish (right arrow key) and hit enter.

3: Start Chromium on boot

Third, you’ll want to make sure Chromium starts in kiosk (full screen, no user interface) as soon as your RaspberryPi boots up.

Create (or modify) ~/.config/lxsession/LXDE/autostart and add the line:

chromium --kiosk http://url_to_your_dashboard.com --incognito

Kiosk mode boots Chromium into full screen mode, by default. Incognito mode prevents a “Chrome did not shutdown cleanly” message from appearing on the top if the RaspberryPi loses power.

4: Make sure the screen does not go to sleep

Dashboards aren’t very useful if the screen goes into standy after ten minutes.

Edit /etc/xdg/lxsession/LXDE/autostart and make sure the @xscreensaver line is commented out. In addition, we’ll be adding three options that prevent the screen from going blank:

#@xscreensaver -no-splash
@xset s off
@xset -dpms
@xset s noblank

I also needed to modify /etc/lightdm/lightdm.conf. Add this line to the [SeatDefaults] section:

xserver-command=X -s 0 dpms

5: Hide the mouse cursor

There’s no reason to keep the mouse cursor stuck in the middle of the screen. We’ll use the unclutter utility to hide it after boot.

sudo apt-get install unclutter

You’ll need to add this to your ~/.config/lxsession/LXDE/autostart file:

unclutter -idle 0

Enjoy!

Reboot your RaspberryPi and it should:

• Boot directly into X11
• Start Chromium in kiosk mode and load up your dashboard
• Prevent the screen from going to sleep after 10 minutes
• Hide the mouse cursor

Please let me know if you have any questions or comments.

March 9th 2013 Update: I have formalized the schematic and parts list that I’m using and have made it available on Upverter. Please read RaspberryPi IR Schematic for LIRC for more details.

March 4th Update: I’ve written a follow up post that describes how to control your RaspberryPi universal remote from the web. Please check out Controlling LIRC from the web for instructions on how to install and configure the software.

Preface

In July 2012 I wrote a post called Universal remote experiments about creating a web controlled universal remote from the electronics up. The first platform I started with was an Arduino Uno. After much experimentation I learned that asking an Arduino to maintain a WiFi connection, maintain a TCP socket with a host computer, and send/receive IR signals was a bit much. With the limited memory and storage I had a hard time managing memory and keeping the system stable. I was, however, able to build a functional prototype:

At the end of that post I had decided to rebuild the project on a RaspberryPi. I chose the RaspberryPi because I wanted a single device to host a web server in addition to being able to handle the IR transmitting and receiving. Given that the RaspberryPi runs Linux I could rely on it’s stable TCP/IP implementation and use open source software packages like nginx and NodeJS to build a web application.

This post will serve as ‘part two’ of that project and cover how to install and configure LIRC on a RaspberryPi.

LIRC - Linux Infrared Remote Control

LIRC is a mature and stable open source library that provides the ability to send and receive IR commands. Thanks to the contributions of ar0n, LIRC support is now included by default in the latest version of Raspbian OS. If you’d like to see the details of the RaspberryPi GPIO integration check out the pull request he opened for it a while back.

Setting up LIRC on the RaspberryPi

Getting LIRC setup on the RaspberryPi is significantly easier now than it was six months ago.

You must be running on the latest firmware and OS for this guide to work. If you’re new to the RaspberryPi, or you haven’t upgraded to the latest firmware and OS, I recommend following my RaspberryPi Quickstart guide to get your RaspberryPi up and running on the latest OS and firmware.

First, we’ll need to install and configure LIRC to run on the RaspberryPi:

sudo apt-get install lirc

You have to modify two files before you can start testing the receiver and IR LED. I modified these files based on a thread I found on the RaspberryPi forums. If you would like to read more about these changes please check out the LIRC GPIO driver for homebrew adapter thread. In particular, read through the posts by rudiratlos on page five, as he posts his configuration files.

Add this to your /etc/modules file:

lirc_dev
lirc_rpi gpio_in_pin=23 gpio_out_pin=22

Change your /etc/lirc/hardware.conf file to:

########################################################
# /etc/lirc/hardware.conf
#
# Arguments which will be used when launching lircd
LIRCD_ARGS="--uinput"

# Don't start lircmd even if there seems to be a good config file
# START_LIRCMD=false

# Don't start irexec, even if a good config file seems to exist.
# START_IREXEC=false

# Try to load appropriate kernel modules
LOAD_MODULES=true

# Run "lircd --driver=help" for a list of supported drivers.
DRIVER="default"
# usually /dev/lirc0 is the correct setting for systems using udev
DEVICE="/dev/lirc0"
MODULES="lirc_rpi"

# Default configuration files for your hardware if any
LIRCD_CONF=""
LIRCMD_CONF=""
########################################################

Now restart lircd so it picks up these changes:

sudo /etc/init.d/lirc stop
sudo /etc/init.d/lirc start

January 25th 2015: Marc W. in the comments pointed out that in the 3.18.x RaspberryPi firmware you must modify one additional file for the lirc-rpi kernel extension to be loaded:

Edit your /boot/config.txt file and add:

dtoverlay=lirc-rpi,gpio_in_pin=23,gpio_out_pin=22

Reboot your RaspberryPi after making this change.

Wiring up the IR transceiver

June 8th 2013 Update: I’ve finished a more permanent build and documented the process in my Open Source Universal Remote - Parts & Picturse blog post.

March 9th 2013 Update: I have formalized the schematic and parts list that I’m using and have made it available on Upverter. Please read RaspberryPi IR Schematic for LIRC for more details.

To send and receive IR signals from your RaspberryPi you’ll need to wire up an IR LED and an IR receiver and tell LIRC where to find them. Here are the parts I purchased for my own project:

• 940nm IR LED 20deg - 20 degree viewing angle. Bright and tuned to 940nm wavelength
• 940nm IR LED 40deg - 40 degree viewing angle. Bright and tuned to 940nm wavelength.
• 38khz IR Receiver - Receives IR signals at remote control frequencies
• PN2222 Transistor - Transistor to help drive IR LED
• 10k Ohm resistor - Resistor that goes between rPi GPIO and the PN2222 transistor

If you don’t already have wires and a breadboard to prototype with, you may be interested in:

• Mounting plate + breadboard - A mounting plate + breadboard for your RaspberryPi
• Adafruit Pi Cobbler Breakout Kit - Breakout kit for getting the GPIO pins onto the breadboard
• Breadboard wire bundle - Bundle of wires to use in the breadboard

For this project I wired up the IR LED to GPIO pin 22 and the IR Receiver to GPIO pin 23. You’ll see that mentioned in the /etc/modules file above.

Please check out these diagrams for information and schematics about how to wire everything up:

• RasperryPi IR Schematic for LIRC - My own schematic, which I’ve been using myself.
• RaspberryPi lirc_rpi - Contains hardware and schematics for the raspberryPi
• TV-B-Gone Schematic - Info on wiring up IR leds / receivers
• GPIO pinout for RaspberryPi - GPIO pinout diagram

Here’s a picture of my initial schematic (view the updated one here) wired up to my RaspberryPi with all of the components tested and working:

Testing the IR receiver

Testing the IR receiver is relatively straightforward.

Run these two commands to stop lircd and start outputting raw data from the IR receiver:

sudo /etc/init.d/lirc stop
mode2 -d /dev/lirc0

Point a remote control at your IR receiver and press some buttons. You should see something like this:

space 16300
pulse 95
space 28794
pulse 80
space 19395
pulse 83
space 402351
pulse 135
space 7085
pulse 85
space 2903

If you don’t, something is probably incorrectly configured. Triple check that you’ve connected everything properly and haven’t crossed any wires. I highly recommend referring to the schematics I linked to above. There is also some trouble shooting advice in the RaspberryPi Forum thread I linked to above. Finally - you may want to do this in a dark room. I found that my desk lamp and overhead light would cause the IR receiver to think it was receiving valid signals.

Testing the IR LED

You’re going to need to either find an existing LIRC config file for your remote control or use your IR receiver to generate a new LIRC config file. In my case I created a new LIRC config file. To do this, read the documentation on the irrecord application that comes with LIRC.

When using irrecord it will ask you to name the buttons you’re programming as you program them. Be sure to run irrecord --list-namespace to see the valid names before you begin.

Here were the commands that I ran to generate a remote configuration file:

# Stop lirc to free up /dev/lirc0
sudo /etc/init.d/lirc stop

# Create a new remote control configuration file (using /dev/lirc0) and save the output to ~/lircd.conf
irrecord -d /dev/lirc0 ~/lircd.conf

# Make a backup of the original lircd.conf file
sudo mv /etc/lirc/lircd.conf /etc/lirc/lircd_original.conf

# Copy over your new configuration file
sudo cp ~/lircd.conf /etc/lirc/lircd.conf

# Start up lirc again
sudo /etc/init.d/lirc start

Once you’ve completed a remote configuration file and saved/added it to /etc/lirc/lircd.conf you can try testing the IR LED. We’ll be using the irsend application that comes with LIRC to facilitate sending commands. You’ll definitely want to check out the documentation to learn more about the options irsend has.

Here are the commands I ran to test my IR LED (using the “yamaha” remote configuration file I created):

# List all of the commands that LIRC knows for 'yamaha'
irsend LIST yamaha ""

# Send the KEY_POWER command once
irsend SEND_ONCE yamaha KEY_POWER

# Send the KEY_VOLUMEDOWN command once
irsend SEND_ONCE yamaha KEY_VOLUMEDOWN

I tested that this was working by pointing the IR led at my Yamaha receiver and testing whether I could turn it on and adjust the volume.

Success!

That’s it! You’ve now successfully installed and configured LIRC on your RaspberryPi. You can add additional remote control configuration files to your /etc/lirc/lircd.conf file to control multiple remotes.

Resources

Here’s a few resources to explore if you’d like to learn more:

• lirc - LIRC home page
• RaspberryPi lirc_rpi GPIO driver - ar0n’s lirc_rpi page
• LIRC GPIO driver for homebrew adapter
• TV-B-Gone Schematic

My next steps

The next step for my web controlled universal remote project is going to be finding or creating remote files for all of the IR devices in my house. Once I’ve gathered all of those files together and placed them in the lircd.conf file I’ll begin work on the web application server.

I’ll cover all of that in a future post.

Questions? Comments?

Please let me know if you have any questions or run into any trouble while running through these steps. All of these steps were tested and working on the date this post was published.

Parts List

• RaspberryPi - 512MB version
• Enclosure for the RaspberryPi - Clear and contains cutous for all of the ports + GPIO pins.
• WiFi Card - Drivers are included in the latest Raspbian distribution.
• 8GB Class 10 SD card - Class 10 cards have a fast read / write speed.
• USB A to USB MicroB cable - The ‘power cable’ for the RaspberryPi
• USB power supply - High powered USB power supply to drive the RaspberryPi + WiFi card.
• HDMI cable - HDMI cable to connect to HDTV / monitor.

Setting up the SD card

1. Download the latest Rasbian linux image.
2. Setup the SD card by following the RPi Easy SD Card Setup guide.

Booting it all up

Plug everything in, boot up the system. If you’re planning to SSH into the RaspberryPi via Ethernet (instead of using a keyboard/mouse/monitor) you’ll have to log into your router and determine what it’s IP address is.

The default RaspberryPi login is username pi with password raspberry. You’ll probably want to change this.

Expanding the root partition

Update: April 12th 2013: Thanks to Conky (and Kevin) for suggesting this.

Once your RaspberryPi boots up, you’ll want to adjust the root partition to take up the entire SD card. This will help prevent errors about the file system being full once you start updating packages and installing new packages:

# Open the RaspiConfig tool:
sudo raspi-config

# Navigate to the "expand_rootfs" option and select it
# Quit out of the raspi-config screen

# Reboot the system:
sudo shutdown -r now

Setting up the WiFi

Assuming everything booted up okay, you’re ready to setup the wireless. To setup the wireless card to connect to your WPA/WPA2 secured wireless network, edit /etc/network/interfaces and add this to the bottom of the file. You may need to remove some existing configuration for wlan0.

allow-hotplug wlan0
auto wlan0
iface wlan0 inet dhcp
    wpa-ssid YOUR_SSID
    wpa-psk YOUR_PASSWORD

Save this file, and run:

sudo ifdown wlan0
sudo ifup wlan0

Run ifconfig and you should see that wlan0 has an IP address.

Setting up NTP

Accurate time is useful.

sudo apt-get install ntpdate
sudo ntpdate -u ntp.ubuntu.com

Updating Raspbian OS

After everything is setup you’ll probably want to update Raspbian to the latest packages and version.

sudo apt-get update
sudo apt-get upgrade
sudo apt-get dist-upgrade

Updating the RaspberryPi’s firmware

To update the firmware to the latest version, we’ll use Hexxeh’s rpi-update script.

sudo apt-get install git-core
sudo wget http://goo.gl/1BOfJ -O /usr/bin/rpi-update && sudo chmod +x /usr/bin/rpi-update
sudo rpi-update

You’re done!

At this point you should be completely setup and operational.

If you had any troubles with this please let me know in the comments.

More reading

Here are some resources to do further reading:

• http://elinux.org/RPi_Community
• http://www.raspberrypi.org/phpBB3/
• Should I add a link here? Let me know.

I can imagine this being extremely useful for someone who already maintains a spreadsheet with carefully tabulated and calculated data who isn’t interested in repeatedly exporting / importing it into a database for web viewing.

Tabletop

Tabletop takes a Google Spreadsheet and makes it easily accessible through Javascript.

http://builtbybalance.com/Tabletop/

Sheetsee

Sheetsee.js is a javascript library mashup that allows you to fill a website with content from a Google Spreadsheet. The web content and visualizations will update with every auto save by Google.

https://github.com/jllord/sheetsee.js

Here is the user agent stylesheet rule that was being applied:

input:not([type="image"]), textarea {
  box-sizing: border-box;
}

After some troubleshooting it turns out this rule was being applied due to a typo in the DOCTYPE for the project. After changing the DOCTYPE back to the correct HTML5 doctype (<!doctype html>) everything loaded correctly.