Digitize Your Room With LIDAR

What’s the best way to image a room? A picture? Hah — don’t be so old-fashioned! You want a LIDAR rig to scan the space and reconstruct it as a 3D point map in your computer.

Hot on the heels of [Saulius Lukse]’s scanning thermometer, he’s replaced the thermal camera on their pan/tilt setup with a time-of-flight (TOF) camera — a Garmin LIDAR — capable of 500 samples per second and end up scanning their room in a mere fifteen minutes. Position data is combined with the ranging information to produce a point cloud using Python. Open that file in a 3D manipulation program and you’ll be treated to a sight like this:

Continue reading “Digitize Your Room With LIDAR”

Simple Scanner Finds the Best WiFi Signal

Want to know which way to point your WiFi antenna to get the best signal? It’s a guessing game for most of us, but a quick build of a scanning WiFi antenna using mostly off-the-shelf components could point you in the right direction.

With saturation WiFi coverage in most places these days, optimizing your signal might seem like a pointless exercise. And indeed it seems [shawnhymel] built this more for fun than for practical reasons. Still, we can see applications where a scanning Yagi-Uda antenna would come in handy. The build started with a “WiFi divining rod” [shawnhymel] created from a simple homebrew Yagi-Uda and an ESP8266 to display the received signal strength indication (RSSI) from a specific access point. Tired of manually moving the popsicle stick and paperclip antenna, he built a two-axis scanner to swing the antenna through a complete hemisphere.

The RSSI for each point is recorded, and when the scan is complete, the antenna swings back to the strongest point. Given the antenna’s less-than-perfect directionality — [shawnhymel] traded narrow beam width for gain — we imagine the “strongest point” is somewhat subjective, but with a better antenna this could be a handy tool for site surveys, automated radio direction finding, or just mapping the RF environment of your neighborhood.

Yagi-Uda antennas and WiFi are no strangers to each other, whether it be a WiFi sniper rifle or another recycling bin Yagi.  Of course this scanner isn’t limited to WiFi. Maybe scanning a lightweight Yagi for the 2-meter band would be a great way to lock onto the local Ham repeater.

Continue reading “Simple Scanner Finds the Best WiFi Signal”

Custom Sensor Head Turns 3D Printer into Capacitive Scanner

The best thing about owning a 3D printer or CNC router may not just be what you can additively or subtractively create with it. With a little imagination you can turn your machine into a 3D scanner, and using capacitive sensors to image items turns out to be an interesting project.

[Nelson]’s scanner idea came from fiddling with some capacitive sensors at work, and with a high-resolution capacitance-to-digital sensor chip in hand, he set about building a scan head for his printer. In differential mode, the FDC2212 sensor chip uses an external LC tank circuit with two plain sensor plates set close to each other. The sensor plates form an air-dielectric variable capacitor, and the presence of an object can be detected with high sensitivity. [Nelson]’s custom sensor board and controller ride on a 3D-printed bracket and scan over the target on the printer bed. Initial results were fuzzy, but after compensating for room temperature variations and doing a little filtering on the raw data, the scans were… still pretty fuzzy. But there’s an image there, and it’s something to work with.

Need a slightly more approachable project to get your feet wet with capacitive sensors? Maybe you should use your phone’s touchscreen as a 2D-capacitive scanner.

[via r/electronics]

Embed with Elliot: I2C Bus Scanning

A lot of great ICs use I2C to communicate, but debugging a non-working I2C setup can be opaque, especially if you’re just getting started with the protocol/bus. An I2C bus scanner can be a helpful first step in debugging an I2C system. Are all the devices that I think should be present actually there and responding? Do they all work at the bus speed that I’m trying to run? If you’ve got an Arduino or Bus Pirate sitting around, you’re only seconds away from scanning your I2C bus, and answering these questions.

Continue reading “Embed with Elliot: I2C Bus Scanning”

1337-sp34k Keyboard

What started off as a quick prank-hack to re-map a colleague’s keyboard turned into a deep dive in understanding how keyboards work. [ch00f] and his other work place colleagues are in a habit of pulling pranks on each other. When [ch00f]’s buddy, who is an avid gamer and montage parody 1337-sp34k (leet speak) fan, went off on a holiday, [ch00f] set about re-mapping his friend’s keyboard to make it spit out words his friend uses a lot – “SWAG” “YOLO” and “420”. But remapping in software is too simple, his hack is a hardware remapping!

The keyboard in question used mechanical keys mounted on a keyboard sized PCB. Further, it was single sided, with jumper links used in place of front side tracks. This made hacking easier. The plan was to use keys not commonly used – Scroll Lock, Print Screen, and Pause/Break – and get them to print out the words instead. The signal tracks from these three keys were cut away and replaced with outputs from a microcontroller. The original connections were also routed to the microcontroller, and a toggle switch used to select between the remapped and original versions. This was eventually not implemented due to a lack of space to install the toggle switch. [ch00f] decided to just replace the keyboard if his friend complained about the hack. A bit of work on the ATMega PCB and firmware, and he was able to get the selected keys to type out SWAG, YOLO and 420.

And this is where a whole can of worms opened up. [ch00f] delves in to an explanation on the various issues at hand – keyboard scanning/multiplexing, how body-diodes in switching FET’s affected the scanning, ghosting and the use of blocking diodes. Towards the end, he just had the word SWAG activated by pressing the Pause/Break key. But he does get to the bottom of why the keyboard was behaving odd after he had wired in his hack, which makes for some interesting reading. Don’t miss the video of the hack in action after the break.

Continue reading “1337-sp34k Keyboard”

A Single Pixel Digital Camera with Arduino

[Jordan] managed to cobble together his own version of a low resolution digital camera using just a few components. The image generated is pretty low resolution and is only in grey scale, but it’s pretty impressive what can be done with some basic hardware.

The heart of the camera is the image sensor. Most consumer digital cameras have tons of tiny receptors all jammed into the sensor. This allows for a larger resolution image, capturing more detail in a smaller space. Unfortunately this also usually means a higher price tag. [Jordan’s] sensor includes just a single pixel. The sensor is really just an infrared photodiode inside of a tube. The diode is connected to an analog input pin on an Arduino. The sensor can be pointed at an object, and the Arduino can sense the brightness of that one point.

In order to compile an actual image, [Jordan] needs to obtain readings of multiple points. Most cameras do this using the large array of pixels. Since [Jordan’s] camera only has a single pixel, he has to move it around and take each reading one at a time. To accomplish this, the Arduino is hooked up to two servo motors. This allows the sensor to be aimed horizontally and vertically. The Arduino slowly scans the sensor in a grid, taking readings along the way. A Processing application then takes each reading and compiles the final image.

Since this camera compiles an image so slowly, it sometimes has a problem with varying brightness. [Jordan] noticed this issue when clouds would pass over while he was taking an image. To fix this problem, he added an ambient light sensor. The Arduino can detect the amount of overall ambient light and then adjust each reading to compensate. He says it’s not perfect but the results are still an improvement. Maybe next time he can try it in color.

Make that C64 Keyboard Work as a USB Keyboard


Let’s face it, we all have keyboard peculiarities. Don’t try to deny it, everyone who types a lot has an opinion of the keyboard they stroke so frequently. We know [Brian Benchoff] swears by his model M, and we’re guessing he was the one that bumped into [Evan] and convinced him to write about his conversion of a Commodore 64 keyboard for use as a USB device.

This is not [Evan’s] first rodeo. We recently saw him fixing up the worn off letters of his own model M. But this time around there’s some clever microcontroller work at play. Apparently mapping 122 keys using an Atmel AVR 32u4 chip (built in USB connectivity) is quite a task. Luckily someone’s already worked out all kinds of good things and is sharing the love with the Soarer’s Keyboard Controller Firmware. Of course it handles scanning, but also includes debounce, muxing, and the trick to scan more keys than the uC has pins for. We still don’t fully understand that bit of it. But [Evan] did post the config file he’s using so perhaps after we get elbow-deep in the code we’ll have a better understanding.

If you give this a try, we want to hear about it. Anyone have any modern keyboards they’re in love with? Leave a comment below.