3D Printed Vice Holds Dev Boards Beside Breadboard

The Stickvise has been a staple of the Hackaday community for a while now. If you need something held for soldering there’s no better low-cost helping hand. But if you’re just using a breadboard and a dev board of some sort, there’s another vice on the horizon that uses similar spring clamping to hold everything in place while you build something awesome.

BreadboardVise1-croppedWhile [Pat]’s inspiration came from the aforementioned Stickvise, the new 3d-printed vice is just what you’ll need before you’re ready to do the soldering. The vice is spring-loaded using rubber bands. The base is sized to fit a standard breadboard in the center with clamping arms on either side to hold dev boards such as an Arduino. This innovative yet simple de”vice” grips boards well enough that you won’t be chasing them around your desk, knocking wires out of place, anymore.

There are some nuances to this board, so be sure to check out the video below to see it in action. As we mentioned, it uses rubber bands instead of springs to keep it simple, and it has some shapes that are easily 3d printed such as the triangular rails. If you want to 3d print your own, the files you’ll need are available on the project’s site. If you want to get even simpler, we’ve seen a few other vices around here as well.

The Stickvise is available for sale in the Hackaday Store.

Continue reading “3D Printed Vice Holds Dev Boards Beside Breadboard”

Review: Microchip Curiosity is a Gorgeous New 8-bit Dev Board

Microchip has unveiled a new dev board called the Curiosity Development Board. I had my first look at this at Bay Area Maker Faire back in May but was asked not to publicize the hardware since it wasn’t officially released yet. Yesterday I got my hands on one of the first “pilot program” demo units and spent some time working with it.

I requested a sample board out of my own curiosity. As you may know, Microchip is one of the sponsors of the 2015 Hackaday Prize, but that partnership does not include this review. However, since we do have this relationship we asked if they would throw in a few extra boards that we could give away and they obliged. More about that at the end of the post.

Continue reading “Review: Microchip Curiosity is a Gorgeous New 8-bit Dev Board”

Update: Battlezone on Vector Display Step-by-Step

When we ran the story of Battlezone played on tube displays earlier this week there were immediately questions about recreating the hack. At the time the software wasn’t available, and there is also a bit of hardware hacking necessary to get the audio working. You asked and [Eric] from Tubetime delivered. He’s posted a pair of articles that show how to get an STM32F4 Discovery board to play the classic game, along with instructions to build the firmware.

The hardware hack in this case is untangling the pinout used on the discovery board. It seems that one of the lines needed to get sound working for this hack is tied to one of the two DACs. If you read the original coverage you’ll remember that both of the DACs are used to drive X and Y on the vector display. The image above shows a cut trace on the bottom of the board. You’ll then need to route that signal to an alternate pin by soldering a jumper wire from the chip to a resistor on the board.

This (as well as one other alteration that bridges two of the chip pins) is a great example of work you should be unafraid to do on your own dev boards. We’ve had to do it with the Launchpad boards to get at the functionality we needed. We’d like to hear your own epic stories of abusing dev boards to do your bidding. Let us know in the comments.

A Dev Board For The ESP Lua Interpreter

From the great minds behind the NodeMCU Lua interpreter for the ESP8266 comes a proper dev board for the WiFi platform of 2015. They are calling it, the NodeMCU-devkit, and it’s a reasonable, cheap, and breadboardable breakout board for the ESP8266.

The version of ESP8266 used in this project is the ESP-12, the newer, fancier model with RF shielding, a questionable FCC logo, and every single one of the GPIOs exposed on castellated connectors. The rest of the board is a USB to serial converter (the CH340G – probably the cheapest USB to serial chip out there), a few passives, and a USB micro connector. It’s simple, cheap, and open source. You can’t do better than that.

This dev board is explicitly designed to work with the NodeMCU firmware, a Lua-based firmware for the ESP. Already we’ve seen some projects make the Hackaday front page with this firmware. Sure, it’s just a garage door opener, but that’s extremely impressive for a chip that’s only a few months old.

Thanks [Baboon] for the tip.

A Development Board for the ESP8266

[Necromant] is ready to dip his toes into the world of firmware development for everyone’s favorite WiFi chip, the ESP8266. Before that begins, it would be a good idea to make a nifty little breakout board for this chip. Here it is, a board with a USB to UART converter with board art that’s compatible with a toner transfer process.

Since this is just a board that turns USB into something the ESP8266 can understand, the most reasonable course of action would be to throw an FTDI chip in there and call it a day. We wouldn’t suggest that. Instead, [necromant] is using a Prolific PL2303HX. The RTS/DTR pins on the serial chip aren’t used, but only because the ESP8266 forums haven’t yet decided on how to connect them to the WiFi chip. GPIOs on the Prolific are broken out for some other projects [necromant] has in mind, with a userspace driver to make everything work.

[Necromant] is the creator of Antares, a build system for microcontrollers and a Hackaday Prize entry. He intends to make his build system compatible with this WiFi chip, just as soon as everyone else figures out an easy way to make it work.

Espruino Pico, Javascript on a USB Stick

There are probably very few official numbers for this, but web developers at least seem to outnumber the amount of people who regularly poke pins and registers with C. For them, the embedded world must be a scary and foreboding domain, full of bitwise operations and dynamic types. [Gordon] figured there was another way and built a Javascript interpreter for a microcontroller. The latest board built around this interpreter is up on Kickstarter, and its even smaller and more capable than his earlier version.

This isn’t [Gordon]’s first rodeo; last year he launched the (full-sized) Espruino, featuring an ARM Cortex M3 and his very own Javascript interpreter. The large-scale Espruino was a rousing success, and now he’s moving on to a smaller thumb drive-sized footprint for the Pico. The hardware is a bit better, relying on the ARM Cortex M4 STM32F4 with a bit more RAM, and this time the board is slightly cheaper. It still runs the same Javascript interpreter, though, so all the code is exactly what you’d expect.

We haven’t seen many projects using this tiny Javascript of Things, but the new layout does make it fantastically useful. Depending on how the crowd funding campaign turns out, [Gordon] might be adding socket, and USB HID support, along with inline C functions.

Another Internet of Things Board (But This One Has Lisp)

Using routers as dev boards has been a long and cherished tradition in the circles we frequent, and finally design houses in China are taking notice. There have been a few ‘Internet of Things’ boards in recent months that have taken the SoC found in low-end routers, packaged the on a board with USB, some GPIOs, and a fair bit of memory and called it a dev board. The ZERO Plus is not an exception to this trend, but it does include a very interesting feature when it comes to the development environment: this one uses Lisp as its native language.

The Zero Plus is pretty much what you would expect from a router SoC being transplanted to an Internet of Things board: it uses the Ralink RT5350 SoC, giving it 802.11b/g/n, has 32MB of RAM, 8 or 16 M of Flash, I2C, I2S, SPI, USB, two UARTs, and 14 GPIOs. There is support for a webcam, temperature and humidity sensor, displays, and Arduino via a breakout board that appears to contain a standard, DIP-sized ATMega328,

All of that could be found in dozens of other boards, though. What really sets this one apart is the Lisp development environment. Programming the Zero is exactly as elegant as you would expect, with a ‘toggle a LED according to what time it is’ program looking something like this:

(define LED_On (lambda ()(dev.gpio 11 “out” 1)))
(define LED_Off (lambda ()(dev.gpio 11 “out” 0)))
(define CurrentTime? (lambda ()
(int (time.strftime “%H” (time.localtime (time.time))))))
(define Night?
(lambda ()
(> ( CurrentTime? ) 16) (< ( CurrentTime? ) 23)
(if (Night?) (LED_On) (LED_Off)

Dev boards built around somewhat more esoteric programming language isn’t anything new; The Espruino brings Javascript to ARM microcontrollers, and the MicroPython project is an astonishing undertaking and successful Kickstarter that brings the BASIC for the 21st century to the embedded world. Lisp, though… I don’t think anyone expected that. It’s a great way to differentiate your product, though.