IR Example Usage Docs

[shortstuffsushi]

I'm playing with the IR module this evening, and I've got a couple of questions.

1. How can I tell what devices expect a signal, and in what pattern? For instance, if I want to send my TV a 'power on/off' signal, how do I know what it is expecting? Is there a standard 'code' for this? Are there docs on the web for it?

2. How do I make sense of incoming data, or do I? If I observe the incoming data from a button on my remote, I receive buffers that seem to contain random arrays of integers each time... Not a pattern like I'd expect.

3. In the sendRawSignal docs, it states "the max length of the signal durations is 100 durations," but in the example code directly above it, you provide it with an array of length 134. Am I misunderstanding the docs? Is this a typo? What happens with additional durations, are they just dropped, or transmitted as an additional batch after the first complete?

4. Is there going to be any sort of tutorial around this module? I know that you're working on a couple of other ones, but this one in particular seems like a total shot in the dark as someone totally unfamiliar with IR hardware.

[jon]

Hi @shortstuffsushi,

I'm going to answer 1 last because, unfortunately, it's rather complicated.

1. If you point a remote at the IR Module and press the same button twice, you should receive the same signal. We do have to take an analog signal (light) and turn it into a digital signal so there may be a couple of digits off by 1, but for the most part the signal should be the same. If it's not, please share the result of the data captures.

2. You're absolutely right that the documentation is confusing and needs to be changed. The clearer explanation is that the max length of signal duration is 100 16-bit words. The example provided makes an array of 134 8-bit words, so 67 16-bit words.

3. We hadn't planned a tutorial around the IR Module but I can see the need. What haven't gotten around to a port of the Arduino IR Library. That library makes it much easier to generate IR codes for devices from different manufacturers. Let me know if you're interested in working on that! Otherwise, we may get around to it in a couple weeks but our hands are full at the moment.

Okay, so back to your first question. There is no standard code or way of figuring out what code to send to a certain device. It mostly takes some persistent Googling. I'll share the story about how I was able to test out the IR Module for the first time by turning on my TV.

tldr: Try to find an some identifying code on your device remote. Then look for that code in this database which should give you two pieces of information. First, it should say what the on/off durations are for a one and and zero. It should also give you a list of codes for common commands. From there you'll just need a simply iterate over the binary interpretation of the code, and turn each digit into the corresponding 1 and 0 durations.

For a more in-depth explanation of my own journey to getting IR working:

Whoever designed the Infrared protocol made it rather complicated in an effort to avoid detectors receiving false positives from incoming sunlight (the sun also emits in the infrared band of light). At its simplest, the infrared protocol is turning on and off a modulated signal (see image below) for various amounts of time. An on signal is known as a “mark” and an off signal is known as a “gap”:

source: electronics.stackexchange.com

But of course, it’s not quite that simple. Every manufacturer (Phillips, Sony, Sharp, etc.) has their own definition for an on/off duration that constitutes a one or a zero. For example, Sharp defines a binary “1” as 315 microseconds of a mark followed by 1779 microseconds of a gap.

To add to the complexity of all the minor timing tweaks in the protocol from all these different manufacturers, the signal can also be modulated at different frequencies. During a mark, it is actually modulating (switching between on and off) thousands of times a second. The most popular modulation frequency is 38 kHz (36 and 40 kHz are also quite common).

The only IR activated device I could find for testing in my apartment was an old Sharp television. I needed to find the code that could be converted to its underlying binary representation of 1’s and 0’s, which in turn could be translated into the right on/off durations in order to turn on the TV. But where does one find IR codes? After a bit of Googling, I found a database of IR codes for each manufacturer.

To my dismay, Sharp has dozens of different codes for different devices, and I couldn’t find a model number anywhere on my TV. The only identifier I could find was an obscure, white code I located on the bottom of the TV remote. I Googled that alphanumeric code, which took me to an Ebay auction item for the same remote, which happened to list a bunch of TV model codes that the remote works with. I found a fairly similar model code (“G1059J is pretty close to G1059SA, right?”) on the infrared code database, and found a power code of “0x00000000000041A2”. I ran the number through the Arduino IR Library I mentioned above and it produced an array of on/off durations (negative numbers are gaps):

[4011, -3875, 561, -1906, 561, -1906, 561, -1906, 561, -1906, 561, -921, 561, -921, 561, -1906, 561, -921, 561, -1906, 561, -921, 561, -1906, 561, -921, 561, -921, 561, -921, 561, -921, 561, -921, 561, -1906, 561, -921, 561, -1906, 561, -921, 561, -921, 561, -921, 561]

After converting this array to 16-bit signed numbers, I could pass it into our infrared module and power the tv.

I hope that helps!

-Jon

[shortstuffsushi]

Wow @jon, thanks for the lengthy and descriptive reply. Your story reminds me of most of last night for me, including coming to the same list of codes

Unfortunately, I think I was still taking the wrong approach (I too was unable to find the correct code, and mostly randomly guessed through the list), and beyond having likely the wrong sets of codes, was also encoding everything incorrectly. Now that I have a slightly better understanding of the theory behind that, I might be able to pull it off tonight.

I'm still a little confused by the output you got from the Arduino library, though. I looked your remote up in that list, then the remote listed in the Arduino library for Sharp, and (maybe I'm looking at this wrong) the gap listed for a ONE signal is either 320 or 1650. In their constants, they actually show 1805, though. The output lists various gaps, but none of them are, or are multiple of, either of these numbers.

Now, as to your other points -- I would be interesting in aiding in that library for sure... once I've better understood how it works myself. If I can understand how you received the result you did, I think I could probably do it.

I hadn't at all noticed that you used 8 bit words... I hadn't even thought of that. Does that mean the top number you could send would actually be 65535 (0xFFFF)? In your example, how are you representing those numbers, would 0xFFFF be represented by [ 0xFF, 0xFF ]? Also, with the negative numbers the Arduino library uses... I don't see those anywhere in your example, do you just represent gaps differently (as 0s)?

Lastly, I'll try to get some captures of the remote data tonight. It seemed to be incrementing each time (and maybe I was just printing it wrong, console.log(buffer) might be printing the address of the buffer?

Mostly just confused on my end, but thanks a lot for helping out. Really appreciated.

[jon]

Hi @shortstuffsushi,

I went back through my notes from when I was working through this IR puzzle and I frankly can't figure out how I came up with the numbers I did. There is some discrepancy between the online database and the Arduino library in terms of signal durations b/c the online database is actually measured signal output. I believe Ken Shirriff's library got its signal durations from some official source.

The durations being sent to/from the IR Module are signed 16-bit numbers so the longest duration should be 2^15-1. The Arduino library doesn't use negative numbers for spaces, it just assumes it should switch between an on signal and off signal. I felt like that wasn't the best way to do it so I implemented a signed system.

I think the main takeaway here is that figuring out the IR signal through Googling and analysis is a bad idea. We should really get IR receiving working so you can just learn the signals from your remote.

Can you receive the IR signal from the power button, wait a second, then emit that power button and see if it powers whatever device you're working with?

I should also note that the IR library is tuned for remote with an IR frequency of 36-40Hz (best at 38). If your remote uses a non-standard frequency (pretty unlikely) that could produce undefined results.

-Jon

[shortstuffsushi]

Hey @jon, I'll respond later with more results of playing around with it, but a quick dump of input from ten presses to the power button on my remote (I'm using the standard Time Warner Cable non-HD remote)

<Buffer 34 0b 00 06>
<Buffer a7 19 00 05>
<Buffer b1 01 00 04>
<Buffer a6 fe 00 05>
<Buffer b0 55 00 04>
<Buffer b5 68 00 05>
<Buffer b9 e9 00 05>
<Buffer aa 00 00 04>
<Buffer b6 fd 00 04>
<Buffer 06 67 00 05>

Now, if the low-order bit is sent first (that seemed to be the case for Sharp), these are somewhat close, but I don't know what to expect really. The variance is from <aa 00 00 04> to <34 0b 00 06>, which is a pretty big spread. I haven't tried sending any of that data at our TV yet, but I'm not sure which one to pick to try sending. Every so often, this remote sends a longer buffer, but not at any particular time. This longer buffer always seems to match the other long buffers within a bit here and there.

[shortstuffsushi]

So some good news. Tried with another remote on another TV (also figured out how to print -- buffer.toJSON is great for that), and received standard results (plus or minus a bit here and there). Resent the signals I received, and got the expected result on the TV. It seems that the TWC remote is just a bit unusual, and sends some sort of truncated code. I also haven't played with different frequencies yet.

If you're interested, I've uploaded the results of the Emerson (successful) remote as a Gist. I normalized the off-by-one bits, and the signals completely match other than the leading numbers for each signal type. I've also marked locations between the different signals where they vary, which I'm eventually hoping to analyze and match against one of the database codes. I'm not sure how to take the numbers I have and turn them into 0s and 1s yet though.

[jon]

@shortstuffsushi,

That's good to hear about your second remote working. Could you try sending the entire code except the first two durations (the ones that are inconsistent) and see if it still succeeds in activating your TV? I was digging through the IR firmware that I wrote months and months ago and it looks like the first two durations may be inconsistent because they could be the duration since the last IR data (except the duration will "roll over" once it gets too big). I'm trying to figure out if we should just parse those two durations out before emitting the data event.

Am I correct in assuming that the first remote signal didn't correctly activate your tv when it was routed through the Tessel?

-Jon

[shortstuffsushi]

I'll try to get test without the leading intervals in the morning. As to the signal, the remote was working with the TV while the Tessel was observing it. I could have both side by side and the TV was still receiving the signal as expected. I also tried with the remote in another room, and received those same 4-duration codes.

[williamaadams]

If you're really into experimenting with IR signaling, you might find the USB IR Toy from dangerous prototypes useful: http://dangerousprototypes.com/docs/USB_IR_Toy_v2

There's a writeup there about dealing with IR signals. Some of what's been covered here, and then some.

There's also an IR Analyzer thing: http://www.analysir.com/blog/2014/01/10/usb-ir-toy-infrared-modulation-frequency-review/

I don't know if the same things will eventually be achievable with the Tessel IR module alone. That would be nice.

You could use a USB toy to figure out the signaling, then just plug those numbers into the teasel for output.

[shortstuffsushi]

Thanks for the suggestion, I'll definitely take a look.

[williamaadams]

The AnalysisIR site has lots of good question/answer/examples in their blog. Additionally, they have links to IR specific resources. This one: http://www.sbprojects.com/knowledge/ir/index.php

Looks very good. Looking at protocol information, particularly Rc5, and Rc6 will give you some details on how to interpret raw signal data into actual 1/0 values, and so on and so forth.

[unRob]

For anyone else looking into controlling your TV and stuff, I managed to make it work like so:

var tessel = require('tessel');
var ir = (require('ir-attx4')).use(tessel.port.A);
var tv = new Buffer([       244,147,0,91,255,166,0,11,255,222,0,11,255,222,0,11,255,222,0,10,255,244,0,11,255,245,0,11,255,245,0,12,255,245,0,11,255,245,0,12,255,223,0,12,255,222,0,10,255,222,0,11,255,245,0,12,255,245,0,11,255,245,0,12,255,245,0,11,255,245,0,11,255,245,0,12,255,222,0,11,255,245,0,11,255,245,0,12,255,245,0,11,255,245,0,11,255,244,0,11,255,245,0,11,255,222,0,11,255,245,0,12,255,223,0,12,255,223,0,11,255,222,0,11,255,222,0,11,255,222,0,11,255,223,0,12
]);

ir.on('ready', function(err){
	if (err) {
		console.log(err);
	} else {
		console.log('ir.ready');

		tessel.button.on('press', function(time){
			console.log('sending');


			ir.sendRawSignal(38, tv, function(err){
				if (err) {
					console.log('TV err');
				} else {
					console.log('TV sent!');
				}

			});

		});


	}
});

Getting the codes was easy, just put the control right up to the sensor (the black diode), and press the button a couple of times, by using code like:

ir.on('data', function(data) {
    console.log("Data: ", data.toString('hex'));
});

And then splitting every two characters (string.match(/.{2}/g) did not seem to match all, so I just copied and processed it in the browser), and converting each individual pair into an integer. This Stack Overflow answer seems to be able to do it all within the JS runtime.

Hope this helps!

[shortstuffsushi]

Hi @unRob. It is easy enough to get the signals from the source (the remote), but my goal was to be able to determine them on my own, by knowing the algorithm that generates them, and the specific values provided by the vendor (or rather, the large database of known values) for each command.

Your data gathering mechanism does seem like it wouldn't quite work (though you seem to have figured that out). If you wanted to split with a regex, using something like string.match(/\d{2,3}/g) may work better -- all the decimal groups of 2 or 3 captured. I think there is a better way to do it overall, though. Next time I get a chance to look at the script I used to capture remote input, I'll share it here.

[Rowno]

Can anyone explain how to convert these remote codes to duration Buffer's? I'm struggling to get any IR stuff working.

[shortstuffsushi]

I can roughly describe the process for you, based on how @jon explained it to me. I haven't gotten it working yet (though I admittedly haven't put a lot of effort into it). It basically comes down to this, though.

• Take the Hex code you want to send, convert it to binary. This is what you will send to your TV.
  • For example, say you want to send a 1 (0x010, easy enough). Binary for this is 10000.
• For each one and zero, send the corresponding duration sequences to your TV.
  • Your remote specifies one as ~1250ms on, ~550 off; zero is about ~650 on, ~550 off.

Now the part that I'm missing here, the part I don't fully understand, is that you can't strictly send series of 1250/550 and 650/550s, you need to run it through an appropriate transform for your remote, which you can (apparently, haven't gotten this far yet) calculate by running it through the Arduino IR Remote library linked early by Jon. I believe you can pass hex value (long, it looks like) directly to the method, and if it's running in debug, it should print out. For Sharp, check this out. I actually played with this with Sharp values before, and wrote a JS script to output the values, I'll try to upload that later, and maybe you'll find it useful.

Now, once you've gotten that code (that's most of the ghost magic part), you think have to make a buffer out of it. I'm also a little confused about this, as the Arduino library outputs both positive and negative numbers, while the Tessel expects only signed, 16bit numbers (or pairs for 8bit, 0-255). But anyway, once you get an array of those numbers, you can create a buffer out of it, and that's what you send to your TV.

Sorry if this is a bit vague, sort of 'the blind leading the blind' since I don't fully understand it myself. Hopefully it at least gives you a step in the right direction.

[jon]

Hi @Rowno,

@shortstuffsushi's advice is almost completely accurate. You'll notice that the remote code file you posted also mentions a header byte of 2490 559 which means you'll want to have an 'on' duration of 2490 ms and an 'off' duration of 559 ms at the beginning of every packet.

Below is some sample code that I think should do the trick. I haven't tested it thoroughly because I don't have an IR receiving device but hopefully you get the gist of how it's supposed to work. We're also totally open to PRs on the IR module repo if you can think of a better API:

// Values pulled from http://lirc.sourceforge.net/remotes/sony/RM-ED035
var headerBytes = [2490, -559];
var oneOnDuration = 1252;
var zeroOnDuration = 658;
var offDuration = -539;
var bodyLen = 12;


function generateIRCode(hexValue) {
  var headerBuf = new Buffer(4);
  headerBuf.writeInt16BE(headerBytes[0], 0);
  headerBuf.writeInt16BE(headerBytes[1], 2);

  // multiply by 4 b/c we're sending int16s (2 8-byte words) for each duration
  // and there is both an on and an off duration
  var bodyBuf = new Buffer(bodyLen * 2 * 2);

  for (var i = 0; i < bodyLen; i++) {
    // If the next bit is a 1
    if (hexValue & 1) {
      // Write the one ON duration
      bodyBuf.writeInt16BE(oneOnDuration, i * 4);
    }
    else {
      // Write the zero ON duration
      bodyBuf.writeInt16BE(zeroOnDuration, i * 4);
    }

    // Write the standard OFF duration
    bodyBuf.writeInt16BE(offDuration, (i * 4) + 2);

    // Move on to the next bit
    hexValue = hexValue >> 1;
  }

  return Buffer.concat([headerBuf, bodyBuf]);
}

console.log(generateIRCode(0xA50));

[Rowno]

Hmmm, I still can't get it to work, even with that code. Though the RM-ED035 isn't quite my remote (I have a RM-GD015), but it looks almost exactly like my remote with only few different buttons and they both control a Sony Bravia TV.

I sampled some IR from my remote (I removed the first 2 random numbers) and the hex codes do match but the durations are quite different. I've tried sending these at the TV but they do nothing. Not sure where to go to from here.

Power

[ 0, 48, 255, 244, 0, 24, 255, 244, 0, 12, 255, 245, 0, 24, 255, 244, 0, 12, 255, 244, 0, 24, 255, 244, 0, 11, 255, 244, 0, 12, 255, 244, 0, 24, 255, 244, 0, 12, 255, 244, 0, 11, 255, 244, 0, 12, 255, 244, 0, 12 ]

1

[ 0, 47, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 11, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 24, 255, 244, 0, 11, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12 ]

2

[ 0, 48, 255, 245, 0, 24, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12, 255, 245, 0, 12, 255, 244, 0, 12, 255, 244, 0, 24, 255, 244, 0, 12, 255, 244, 0, 11, 255, 244, 0, 12, 255, 244, 0, 12 ]

3

[ 0, 48, 255, 244, 0, 12, 255, 244, 0, 24, 255, 244, 0, 12, 255, 244, 0, 11, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 24, 255, 245, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 11 ]

4

[ 0, 48, 255, 244, 0, 24, 255, 244, 0, 23, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 11, 255, 244, 0, 12, 255, 244, 0, 24, 255, 244, 0, 12, 255, 244, 0, 11, 255, 244, 0, 12, 255, 244, 0, 12 ]

5

[ 0, 47, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 24, 255, 244, 0, 12, 255, 245, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 24, 255, 245, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12 ]

6

[ 0, 48, 255, 244, 0, 24, 255, 244, 0, 12, 255, 244, 0, 24, 255, 245, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 23, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 11 ]

[shortstuffsushi]

@Rowno, note here that you're seeing 8-byte numbers , @jon's script was outputting 2 8-byte, or 16-byte numbers.

[Rowno]

Well here's a comparison for the 1 button (0x010).

Remote

[ 0, 47, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 11, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 24, 255, 244, 0, 11, 255, 244, 0, 12, 255, 244, 0, 12, 255, 244, 0, 12 ]

generateIRCode

[ 9, 186, 0, 0, 2, 146, 0, 0, 2, 146, 0, 0, 2, 146, 0, 0, 2, 146, 0, 0, 4, 228, 0, 0, 2, 146, 0, 0, 2, 146, 0, 0, 2, 146, 0, 0, 2, 146, 0, 0, 2, 146, 0, 0, 2, 146, 0, 0, 2, 146, 0, 0 ]

I think I'll have to wait for the Arduino IR library port, it's just too painful atm.

[jon]

Hi @Rowno,

Can you confirm that recording a button press with the IR Module, then sending that same signal to the receiving device has no effect? If that's true, it's possible that your remote isn't using a non-standard IR frequency. Most IR signals are at 38kHz but 36kHz and 40kHz are also occasionally used. I recommend trying to send the signal at those frequencies:

// Send a signal at 40kHz. 
ir.sendRawSignal(40, yourSignalBuffer);
// OR
//Also try with 36kHz.
ir.sendRawSignal(36, yourSignalBuffer);

-Jon