PJON, Fancy One Wire Arduino Communications Protocol For Home Automation

PJON, pronounced like the iridescent sky rats found in every city, is a cool one wire protocol designed by [gioblu].

[gioblu] wasn’t impressed with the complications of I2C. He thought one-wire was too proprietary, too complicated, and its Arduino implementations did not impress. What he really wanted was a protocol that could deal with a ton of noise and a weak signal in his home automation project with the smallest amount of wiring possible.

That’s where is his, “Padded Jittering Operative Network,” comes in. It can support up to 255 Arduinos on one bus and its error handling is apparently good enough that you can hold an Arudino in one hand and see the signals transmitted through your body on the other. The fact that a ground and a signal wire is all you need to run a bus supporting 255 devices and they’ll play nice is pretty cool, even if the bandwidth isn’t the most extreme.

Aside from the cool of DIY protocols. We really enjoyed reading the wiki describing it. Some of the proposed uses was running your home automation through your ducting or water pipes (which should be possible if you’re really good at isolating your grounds). Either way, the protocol is neat and looks fun to use. Or check out PJON_ASK if you want to do away with that pesky single wire.

Amazing IMU-based Motion Capture Suit Turns You Into a Cartoon

[Alvaro Ferrán Cifuentes] has built the coolest motion capture suit that we’ve seen outside of Hollywood. It’s based on tying a bunch of inertial measurement units (IMUs) to his body, sending the data to a computer, and doing some reasonably serious math. It’s nothing short of amazing, and entirely doable on a DIY budget. Check out the video below the break, and be amazed.

Cellphones all use IMUs to provide such useful functions as tap detection and screen rotation information. This means that they’ve become cheap. The ability to measure nine degrees of freedom on a tiny chip, for chicken scratch, pretty much made this development inevitable, as we suggested back in 2013 after seeing a one-armed proof-of-concept.

But [Alvaro] has gone above and beyond. Everything is open source and documented on his GitHun. An Arduino reads the sensor boards (over multiplexed I2C lines) that are strapped to his limbs, and send the data over Bluetooth to his computer. There, a Python script takes over and passes the data off to Blender which renders a 3D model to match, in real time.

All of this means that you could replicate this incredible project at home right now, on the cheap. We have no idea where this is heading, but it’s going to be cool.

Continue reading “Amazing IMU-based Motion Capture Suit Turns You Into a Cartoon”

MSX with BlinkenLights

Blinkenlights-originalOld Mini and Mainframe computers often had huge banks of diagnostic lights to indicate the status of address, data and control buses or other functions. When the lights blinked, the computer was busy at work. When they stopped in a particular pattern, engineers could try and figure out what went wrong by decoding the status of the lights.

[Folkert van Heusden] has an old MSX-based Philips VG-8020 computer and decided to add his own set of BlinkenLights to his system. The VG-8020 was a first generation MSX released in 1983 and featured a Zilog Z80A microprocessor clocked at 3.56 MHz, 64KB of RAM, 16KB of VRAM, and two cartridge slots.

The cartridge slots of the MSX are connected to the address and data buses in addition to many of the control signals, so it seemed logical to tap in to those signals. Not wanting to play around with a whole bunch of transistors, he opted to use an Arduino Nano to connect to his computer and drive the LEDs. In hindsight, this seemed like a wise decision as it allowed him to do some processing on the incoming data before driving the LEDs.

Instead of creating a new PCB, he cut open one of his beloved game cartridges. A switch was added to the slot select control pin (SLTSL) and eight wires soldered directly to the data bus. These were hooked up as inputs to the Arduino. A bank of eight LEDs with limiting resistors were connected to outputs on the Arduino. A quick test confirmed it all worked, including the switch to enable / disable the cartridge. He had to experiment with the code a bit as the LEDs were initially blinking too fast.

v2_frontA couple of months later, he upgraded his BlinkenLight display to include the 16 bit address, 8 bit data and 8 lines for control signals. To do this, he used two MCP23017 – I2C 16 input/output port expander chips. For the LEDs, he installed a bank of four NeoPixel LED bars. A Pro-Mini takes care of the processing, and a custom PCB in the cartridge format houses all of it neatly. Check out the two videos below showing the BlinkenLights in action.

And if these BlinkenLights got you interested, take a look at this awesome Z80 Computer With Switches And Blinkenlights that has a hand operated crank to advance clock cycles.

Continue reading “MSX with BlinkenLights”

Triple Frequency VFO on a Bamboo Breadboard

Historically when hams built low power (QRP) transmitters, they’d use a crystal to set the frequency. Years ago, it was common to find crystals in all sorts of radios, including scanners and handheld transceivers. Crystals are very stable and precise and it is relatively easy to make a high quality oscillator with a crystal and a few parts.

The big problem is you can’t change the frequency much without changing crystals. Making a high quality variable frequency oscillator (VFO) out of traditional components is quite a challenge. However, today you have many alternatives ranging from digital synthesis to all-in-one IC solutions that can generate stable signals in a wide range of frequencies.

[N2HTT] likes to build radio projects and he decided to take an Si5351 clock generator and turn it into a three frequency VFO for his projects. The Si5351 uses a crystal, so it is very stable. However, you can digitally convert that crystal frequency into multiple frequencies over a range of about 8kHz to 160MHz.

Continue reading “Triple Frequency VFO on a Bamboo Breadboard”

Wii MotionPlus Gyro to Microchip PIC

Sometimes the most mundane products have surprisingly sophisticated internals. What’s in a game controller? If it is a Wii remote, you’ll find a lot inside–an IR sensor, Bluetooth, an accelerometer, and EEPROM. It also has a six pin expansion port that allows I2C peripherals connect to the controller.

[DotMusclera] wanted to experiment with a gyroscope and decided to hook up to the Wii MotionPlus to a Microchip PIC. Using information from the WiiBrew wiki, [DotMusclera] connected a PIC18F4550, an LCD, and a handful of components (mostly to do 3.3V level conversion), he set up the hardware on a breadboard. The only odd part you might have to work around is a Wii breakout board that converts from the breadboard to the Wii interface.

The software is easy to follow since it is written in Hi-TECH C and well-commented. The hardware lacks a schematic, but from the parts list and the video, you can probably figure it out. The setup works well and shows roll, pitch, and yaw on the LCD screen.

The project log is very detailed, with a lot of information about gyroscopes and the communication format the gyro uses. The video demo is worth watching as well.

Continue reading “Wii MotionPlus Gyro to Microchip PIC”

Analyzing The Microsoft Surface Touch Keyboard Cover

The Microsoft Surface is an awesome Tablet PC, but it has one problem: there is just one USB port on it. There is an additional port, though: a connector for the Surface Touch Keyboard connector. That’s what [Edward Shin] is looking into, with the long-term intention of creating an adapter that allows him to connect a Thinkpad keyboard to this proprietary connector. His initial work identified the connector as using Microsoft’s own HID over I2C protocol, which sends the standard USB HID protocol over an I2C connection. So far so good, but it seems to get a little odd after that, with a serial connection running at nearly 1 Mbps and sending 9 bits per transfer with 1 stop bit. Presumably this is because Microsoft had planned to release other devices that used this connector, but this hasn’t panned out so far.

Anybody want to help him out? He has posted some captured data from the connection for analysis, and is looking for assistance. We hope he manages to build his converter: a Microsoft Surface with a decent keyboard and an open USB port would be a great portable setup. Bonus: for those teardown fans among you, he has done a great teardown of a Touch Cover keyboard that reveals some interesting stuff, including a lot of well-labelled test points.

Via [Reddit]

I2C Bus Splitting with a more Professional Touch

Last week, I covered some of the bitter details of an interesting hack that lets us split up the I²C clock line into multiple outputs with a demultiplexer, effectively giving us “Chip Selects” for devices with the same address.

This week, I figured it’d be best to layout a slightly more practical method for solving the same problem of talking to I²C devices that each have the same address.

I actually had a great collection of comments mention the same family of chips I’m using to tackle this issue, and I’m glad that we’re jumping off the same lead as we explore the design space.

Recalling the Work of Our Predecessors

Before figuring out a clever way of hacking together our own solution, it’s best to see if someone before us has already gone through all of the trouble to solve that problem. In this case–we’re in luck–so much that the exact bus-splitting behavior we want is embedded into a discrete IC, known as the PCA9547.

chip_reverence

It’s worth remembering that our predecessors have labored tirelessly to create such a commodity piece of silicon.

The PCA9547 (PDF) is an octal, I²C bus multiplexer, and I daresay, it’s probably the most practical solution for this scenario. Not only does the chip provide 8 separate buses, up to seven more additional PCA9547s can be connected to enable communication with up to 64 identical devices! What’s more, the PCA9547 comes with the additional benefit of being compatible with both 3.3V and 5V logic-level devices on separate buses. Finally, as opposed to last week’s “hack,” each bus is bidirectional, which means the PCA9547 is fully compliant with the I²C spec.

Selecting one of the eight I²C buses is done via a transfer on the I²C bus itself. It’s worth mentioning that this method does introduce a small amount of latency compared to the previous clock-splitter solution from last week. Nevertheless, if you’re planning to read multiple devices sequentially from a single bus anyway, then getting as close-as-possible to a simultaneous read/write from each device isn’t likely a constraint on your system.

 

With a breakout board to expose the pads, I mocked up a quick-n-dirty Arduino Library to get the conversation started and duplicated last week’s demo.

Happily enough, with a single function to change the bus address, the PCA9547 is pretty much a drop-in solution that “just works.” It’s definitely reassuring that we can stand on the shoulders of our chip designers to get the job done quickly. (They’ve also likely done quite a bit more testing to ensure their device performs as promised.) Just like last week, feel free to check out the demo source code up on Github.

Until next time–cheers!