How to tell an IP address with 4 LEDs?

I am developing a net-managed device with the .NET Micro Framework. Since the idea开发者_开发百科 is to have a bunch of devices in an office, sometimes it is necessary for the user to know the IP address of a specific device.

So I've been trying to come with ideas on how to indicate the IP address the user. The only user interface is 4 LED lights that I can blink on and off at varying speeds.

So far, the best idea I could come up with is this: seeing how the IP address has 4 parts and I have 4 LEDs, it would make sense that each LED be responsible for a single IP address part. So for address like 192.168.0.34, I'd have LED1 blink once, then pause, then blink 9 times, pause, then blink 2 times. The action would then shift to the LED2, which would blink out 168 in a similar manner and so on. Number 0 would be indicated by blinking really fast for half a second.

Any other ideas?

Use all 4 displays at once for each number, showing it in binary. Blink all 4 really fast for a 0, light all 4 longer to denote a point.

[ ] [ ] [ ] [x] # 1
[x] [ ] [ ] [x] # 9
[ ] [ ] [x] [ ] # 2
[x] [x] [x] [x] # . (long)
[ ] [ ] [ ] [x] # 1
[ ] [x] [x] [ ] # 6
[x] [ ] [ ] [ ] # 8
[x] [x] [x] [x] # . (long)
[x] [x] [x] [x] # 0 (short)

Alternatively you can use an un-used number (ie: 10) to denote 0

[ ] [ ] [ ] [x] # 1
[x] [ ] [ ] [x] # 9
[ ] [ ] [x] [ ] # 2
[x] [x] [x] [x] # . 
[ ] [ ] [ ] [x] # 1
[ ] [x] [x] [ ] # 6
[x] [ ] [ ] [ ] # 8
[x] [x] [x] [x] # . 
[x] [ ] [x] [ ] # 0 

Having a lookup table ready by the device should be enough for those who don't know binary.

I'd do the reverse. From a control station, I would bring up a list of all IPs used by my devices. I'd then select one to start blinking in a pattern that would be easy to recognize (like 1 2 3 4 over and over) until shut off. That way I could ask everybody who's LEDs are blinking like that and know what device owned that IP.

I'd then write the IP on the bottom of the device in magic marker. There's an amazing amount of bandwidth in a sharpie.

Provide a well-mounted cord for the user to swing the device around in the air like a lasso

Then flash the LEDs like a propeller clock

You might also consider binary, displaying a single digit at a time. But this would require the user to know (or take a crash course on) binary.

9: 1 0 0 1
8: 1 0 0 0
7: 0 1 1 1
6: 0 1 1 0
5: 0 1 0 1
4: 0 1 0 0
3: 0 0 1 1
2: 0 0 1 0
1: 0 0 0 1
0: 0 0 0 0

To indicate the decimal point, you could show 1 1 1 1. It would be ideal if you had a button or some form of user interaction so that you could iterate through the digits.

You could translate the number to HEX and print off the hex representation in binary.

F: 1 1 1 1
E: 1 1 1 0
D: 1 1 0 1 
C: 1 1 0 0
B: 1 0 1 1
A: 1 0 1 0
9: 1 0 0 1 
8: 1 0 0 0 
7: 0 1 1 1 
6: 0 1 1 0 
5: 0 1 0 1 
4: 0 1 0 0 
3: 0 0 1 1 
2: 0 0 1 0 
1: 0 0 0 1 
0: 0 0 0 0 

192.168.0.34 becomes C0.A8.00.22. Very similar to the solution put forth by @JYelton, just taken a step further to reduce the amount of work an individual needs to do to read the message out of the LEDs. Still require a bit of translation though because you have to go from hex to decimal again (standard calculator is an easy/handy tool).

I'm thinking outside the box.. but one of the biggest complaints I see here is the translation. What about an app that takes a video (recording or prerecorded) and does the interpretation? This reminds me of iphone apps that can read upc codes.

Alternatively, but along the same thought, what about a parallel port or usb?

Why don't you get an external LCD screen... no teaching users binary and you can display loads more information. If you provide me with which micro framework device you are using I may be able to provide more detailed help.

• LCDs - SparkFun <= good products and service
• LCDs - Jameco
• LCDs - Mouser

Could do it the way that the pulse dialing worked in the phone system. Basically one blink is zero, and it counts up from there.

1 = **          (2 blinks)
9 = **********  (10 blinks)
2 = ***         (3 blinks)
Long Blink
1 = **          (2 blinks)
6 = *******     (7 blinks)
8 = *********   (9 blinks)
Long Blink
0 = *           (1 blink)
0 = *           (1 blink)
1 = **          (2 blinks)
Long Blink
2 = ***         (3 blinks)
4 = *****       (5 blinks)
1 = **          (2 blinks)

Depending on how geeky your users are, you could also use:

• Morse code
• Display IP as a sequence of digits in binary
• ...

if it's DHCP, and they can access a list of the devices ip addresses on a computer next to the devices' MAC addresses, you could write the MAC address on each device and then they'd be able to tell which device had which IP.

If you think MAC addresses would be too un user friendly then you could have a table of the MAC addresses with a short description or the name of the devices.

Even more, you could write a program that got the list of ip addresses next to MAC addresses and matched it up with the table of device names next to MAC addresses.

If you replace one of the leds with an IR led, you can write an app for a cell phone IR sensor that decodes and displays the binary pattern for the IP address.

What about Broadcasting UDP packets and using a winforms app to listen for those packets. If you have multiple of these devices, the following might work.

1. Open Windows Client that is listening on the correct port.
2. Reset device or push a button on it to activate the UDP Broadcast.
3. Maybe combine the LED's flashing actively on that unit for 1 minute.
4. The Windows Client would then receive the IP Address and any other status information.

There may be an option here to set a unique ID (1-16 binary) in the device that is displayed on the device and broadcast with the IP Information. (??DIP Switches??) This gets away from having users interpreting binary flashing of the LED's.

So device 1010 shows it's LED's and the output in the Windows App shows On, Off, On, Off = 192.168.0.150

If you got fancy with this using Images of an LED On and Off would be even better.

I'm in a similar situation and haven't tested these theories yet.

Well, does the IP address need to be interpreted by a machine or by a human? Because your suggestion is using decimal digits, which is wonderful for humans but very complicated for computers to understand.

IP addresses are actually just a 32-bit binary number. The IP 192.168.0.34 is seen by the router (and broadcasted across the internet) as 11000000 10101000 00000000 00100010

If you're having a computer or other hardware device interpret the IP address, I suggest just using binary. You could have one light which displays the next digit, and another which toggles a "ready" light to indicate that the digit is in fact the next one and not a repetition of the previous one. This would only require 2 LEDs, and you would essentially display the aforementioned address like so:

on on, on off, off on, off off, off on, off off, off on, off off, on on, off off, on on, off off, on on, off off, off on, off off, etc.

Make sure the second bit has toggled before reading the first bit, otherwise you could read the same number twice.

If you want to display it using four LEDs for human interpretation then having the LEDs blinks according to digit might be difficult since humans have trouble counting 4 numbers simultaneously. It may be easier if you just went through all the digits 1, 9, 2, 1, 6, 8, 0, 0, 0, 0, 3, 4 (3 digits per number) and displayed these in binary using all four LEDs.

off off off on, on off off on, off off on off, etc.

With a pause in between each one.

Adding an LCD display would work really well, but would add a lot to the cost. However, what about using 8 LEDs instead of 4? If you purchase the 8 LEDs in the form of a 7-segment LED display with decimal point, it might not cost much more than 4 discrete LEDs, but it would let you display the decimal digits of the IP address sequentially. No complicated translation scheme for the users to master.

It depends on your environment, but I'd not display an entire IP address, just the component that is relevant, and map that itself to a single 4-bit number. This assumes you only need to uniquely identify < 2^4 entities. If you need more, then just use more LEDs (if possible).

In this way, you'd only need to indicate a local mapping, which could then be used to look the actual IP address up via a local internal website. You can use the typical binary strategy that's been described in this thread already to have the LEDs flash out a 4bit number, and it should be pretty easy to train people on (which appropriate labeling on the device).