[Paul Stoffregen], creator of the Teensy series of microcontroller dev boards, noticed a lot of project driving huge LED arrays recently and decided to look into how fast microcontroller dev boards can receive data from a computer. More bits per second means more glowey LEDs, of course, so his benchmarking efforts are sure to be a hit with anyone planning some large-scale microcontroller projects.
The microcontrollers [Paul] tested included the Teensy 2.0, Teensy 3.0, the Leonardo and Due Arduinos, and the Fubarino Mini and Leaflabs Maple. These were tested in Linux ( Ubuntu 12.04 live CD ), OSX Lion, and Windows 7, all running on a 2012 MacBook Pro. When not considering the Teensy 2.0 and 3.0, the results of the tests were what you would expect: faster devices were able to receive more bytes per second. When the Teensys were thrown into the mix, though, the results changed drastically. The Teensy 2.0, with the same microcontroller as the Arduino Leonardo, was able to outperform every board except for the Teensy 3.0.
[Paul] also took the effort to benchmark the different operating systems he used. Bottom line, if you’re transferring a lot of bytes at once, it really doesn’t matter which OS you’re using. For transferring small amounts of data, you may want to go with OS X. Windows is terrible for transferring single bytes; at one byte per transfer, Windows only manages 4kBps. With the same task, Linux and OS X manage about 53 and 860 (!) kBps, respectively.
So there you go. If you’re building a huge LED array, use a Teensy 3.0 with a MacBook. Of course [Paul] made all the code for his benchmarks open source, so feel free to replicate this experiment.
Having a serial port on any Linux box is always useful, but with the tiny computers we’re carrying around in our pockets now, that isn’t always an option. Some of the more advanced phones out there break out a UART on their USB OTG port, but the designers of the Nexus 4 decided to do things differently. They chose to put the Nexus 4’s serial port on the mic and headphone input, and [Ryan] and [Josh] figured out how to access this port.
Basically, the Nexus 4 has a tiny bit of circuitry attached to the microphone input. If the Nexus detects more than 2.8 Volts on the mic, it switches over to a hardware UART, allowing everything from an Arduino to an old dumb terminal to access the port.
The guys used a USB to serial FTDI board wired up to a 3.5 mm jack with a few resistors to enable the hardware UART on their phone. With a small enclosure, they had a reasonably inexpensive way to enable a hardware serial port on a mobile device with GPS, cellular, a camera, and a whole bunch of other sensors that any portable project would love.
EDIT: An anonymous little bird told us this: “You should add a note to the Nexus 4 serial cable post that TX and RX need to be 1.8V. If you use 3.3V USB cables, you will likely eventually fry something. FTDI makes 1.8V IO cables that work – you just need to make the trigger voltage for the mic line.” Take that for what you will.
We’re pretty spoiled these days in that hobby electronics has made a lot of cool tools available on a budget. It’s hard to think of a better example than a logic analyzer, which you can get for a day or two of pay. Consumer-level devices just didn’t exist until a few years ago. [Jouko S] has this HP16500B industrial grade logic analyzer in his shop. It’s from the early 1990’s and it’s got a ton of features. Grabbing a still functional yet super-old model used to be the only way for hobbyists. But one thing you won’t find on it is the ability to connect it to your USB port to get screen captures. Younger readers might not recognize the slot at the top for magnetic media called a floppy disk which is the in-built way of recording your sessions. He set out to find an easier way to get color screen captures and ended up adding RS-232 control to the old hardware.
There is a 25-pin port on the back of the old hulk. But it is a female connector and he didn’t have the adapters on hand to make it work with his serial-to-USB converter. During development he used a breadboard and solder-tail connector to patch into the necessary signals. This was all hooked up to a Raspberry Pi which he planned to dedicate to the system. It worked, and he was able to use an interactive terminal for the rest of his sleuthing. With much trial and error he figured out the commands, and wrote some Python code for the Pi side of the equation. He can now pull color screenshots with ease thanks to the utilities available in the Python Imaging Module.
[Debraj] wrote in about his 2-wire serial backpack he developed for a Graphic LCD screen. It’s build on a hunk of protoboard and uses a pair of 595 shift registers to translate incoming serial data to the parallel interface which is used by the LCD screen. It takes more time to push commands this way, but the interface is still quite snappy as you can see in the clip after the jump.
The real trick here is how the hardware has been configured to get away without a third wire for latching the shift registers (if you need a primer on 595 chips check out this feature). The idea of using a latch is that all of the data can be shifted in over the serial pin before it appears on the output pins. Otherwise, the GLCD would see each bit as it shifts into the register, wreaking havoc on its communication protocol. [Debraj] gets around this by using a diode AND gate trick he learned from this other serial LCD project.
One good thing about this method is the 595 chips have a wide range of control voltage that will allow you to drive this with 3.3V or 5V microcontrollers. But you do need to implement the communication protocol and push those commands via serial. For nearly the same cost in chips something like an ATtiny2313 could be substituted to make an even simpler addressing scheme — or even switch to 1-wire protocol. But you’d then lose the wide input voltage tolerance.
Continue reading “Two-wire serial backpack for GLCD screens”
[Osgeld] is showing off what he calls a sanity check. It’s the first non-breadboard version of his Pocket Serial Host. He’s been working on the project as a way to simplify getting programs onto the Apple II he has on his “retro bench”. When plugged in, the computer sees it as a disk drive.
The storage is provided by an SD card which is hidden on the underside of that protoboard. This makes it dead simple to hack away at your programs using a modern computer, then transfer them over to the retro hardware. The components used (starting at the far side of the board) are a DB9 serial connector next to a level converter to make it talk to the ATmega328 chip being pointed at with a tool. The chip below that is a level converter to get the microcontroller talking to the RTC chip seen to the right. The battery keeps that clock running when there’s no power from the 5V and 3.3V regulators mounted in the upper right.
The video after the break shows off this prototype, the breadboard circuit, and a demonstration with the Apple II.
Continue reading “Pocket Serial Host acts as an Apple II disk drive”
It doesn’t happen often, but every now and again we find ourselves wanting for a more extensible cut and paste experience. Most notably we’ve searched for something that makes is very easy to keep multiple things in the clipboard and paste them as needed. Although we’ve tried several software offerings nothing really made it up to grade, but this hardware clipboard looks very promising. [Luca Dentella] calls it Type4me as it functions as a USB keyboard.
The PIC 18F14K50 enumerates as a USB keyboard, allowing it to send characters anywhere the cursor is located. It sends whatever string is stored inside, with an optional return character at the end. In addition to its keyboard properties it also establishes a serial connection, which allows you to push new strings to the device. This setup does require you to do copy or type your strings into a serial terminal, along with one of four special commands which are parsed by the microcontroller. One of these commands allows you to save the string to EEPROM so that it will be persistent through a power cycle.
The pasting back to the computer takes a mere push of the button. We’ve embedded the video demo after the break. It’s in Italian but there are English subtitles. Near the end [Luca] shows off the device as a macro button for gaming.
Continue reading “Type4me is a hardware clipboard for your digital copy and paste needs”
Since most of us are long past the days of hardware serial ports, the USB to serial adapter has become a mainstay on the hacker’s tool belt. While they’re cheap and convenient, USB to serial adapters aren’t always the easiest thing to use: there’s always the issue of what COM port Windows is calling your USB to serial adapter, or what TTY device it is in Linux/OS X.
[Avishay] has a very, very cool solution to this problem: put a display on a USB to serial converter to tell the user what COM port the OS labeled it as.
The prototype runs on a PIC 18F2553 dev board. When plugged into a Windows box, the serial adapter sets up two USB devices. The first device is a Communications Device Class that handles the grunt work of the USB to Serial connection. The second USB device is a proprietary piece of software that grabs the current COM port number. This number is displayed on an LCD thanks to a host application on the Windows PC that reports the COM port of the Serial adapter.
It’s one of those ideas where you didn’t know you needed it until it was presented to you. An excellent tool from [Avishay], although maybe a pair of 7-segment LEDs would make it a more manufacturable device.