A Development Board For The ESP8266

November 5, 2014 by Brian Benchoff 44 Comments

[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

October 29, 2014 by Brian Benchoff 39 Comments

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)

October 23, 2014 by Brian Benchoff 26 Comments

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 ()
            (and
            (> ( 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.

Bluetooth Thingies At Maker Faire

September 23, 2014 by Brian Benchoff 14 Comments

In case you haven’t noticed, one of the more popular themes for new dev boards is Bluetooth. Slap a Bluetooth 4.0 module on a board, and you really have something: just about every phone out there has it, and the Low Energy label is great for battery-powered Internets of Things.

Most of these boards fall a little short. It’s one thing to throw a Bluetooth module on a board, but building the software to interact with this board is another matter entirely. Revealing Hour Creations is bucking that trend with their Tah board. Basically, it’s your standard Arduino compatible board with a btle module. What they’ve done is add the software for iOS and Android that makes building stuff easy.

Putting Bluetooth on a single board is one thing, but how about putting Bluetooth on everything. SAM Labs showed off their system of things at Maker Faire with LEDs, buttons, fans, motors, sensors, and just about every electrical component you can imagine.

All of these little boards come with a Bluetooth module and a battery. The software for the system is a graphical interface that allows you to draw virtual wires between everything. Connect a button to a LED in the software, and the LED will light up when the button is pressed. Move your mouse around the computer, and the button will turn on a motor when it’s pressed.

There are a few APIs that also come packaged into the programming environment – at the booth, you could open a fridge (filled with cool drinks that didn’t cost five dollars, a surprise for the faire) and it would post a tweet.

Cypress Launches $5 ARM Dev Board

June 16, 2014 by Eric Evenchick 73 Comments

We do love new development boards at Hackaday, and it’s always nice to see companies providing cheap tools for their products. For those needing a cheap ARM solution, Cypress has just released a PSoC based board that’ll cost you less than $5.

There’s two main ICs on the development board. The first is the target: an ARM Cortex M0+ based PSoC 4 MCU. The second is a CY7C65211 USB bridge. This device is communicates with the target’s built in bootloader for flashing code.

The bridge can also be configured to talk UART, GPIO, I2C or SPI. If you need a USB to serial converter, this part of the board could be worth $5 alone.

The PSoC 4 target happens to be similar to the one our own [Bil Herd] used in his Introduction to PSoC video. If you’re looking to get into PSoC, [Bil] provides a good introduction to what makes these chips unique, and how to get started.

Wake On LAN With A Dev Board

May 19, 2014 by Brian Benchoff 23 Comments

Screen

At home, [Daniel] has an extremely powerful dual quad-core Xeon system with ECC RAM that he uses for heavy lifting tasks – compiling, CUDA processing, and actual computing. Of course the electric bill for running this box all the time would be crazy, so Wake on LAN it is. There’s only one problem: for some reason, the BIOS doesn’t have Wake on LAN. The solution, of course, was a microcontroller system that would listen for the magic WoL packet and turn the computer on when it was received. This project eventually turned into a great case mod with an integrated LCD that powers the computer up over Ethernet, shows the current running processes, CPU and memory usage, and is an excellent use of a TI dev board.

The dev board in question is a TI Sitara AM355x starter kit that runs Linux, has two Ethernet ports and a touch sensitive LCD, and more than enough power to handle something as simple as a system monitor. To power on his monster computer from the dev board, [Daniel] is using a LED on the board, an inverter, a ULN2003 driver chip, and a relay connected to the computer’s power button. It’s not exactly a masterpiece of craftsmanship, but the dev board looks good mounted in the case, and from the videos below, it’s a great way to get system information embedded right into a computer case.

Continue reading “Wake On LAN With A Dev Board” →

A Simple Forth Development Board

October 12, 2013 by Brian Benchoff 74 Comments

forth

Forth is a very interesting programming language. It’s very flexible and is extremely efficient on low powered hardware, but unfortunately not very popular simply due to the fact that it’s not very popular. There were a few Forth-based microcomputers built in the 1980s, but these were largely unsuccessful.

[Leon] is a Forth aficionado and came up with his own Forth development board in the hopes of Forth making a comeback. It’s a very small and cheap board – only about $12 in parts – but it’s still extremely powerful and a fun platform for investigating Forth.

Compared to other programming languages found in 80s microcomputers, Forth is just weird. It’s a stack-based language, so instead of adding two numbers like 3 + 4, Forth uses postfix notation (or Reverse Polish Notation) so the same statement is expressed as 3 4 +. It’s a much more efficient way for computers to handle data, and some claim it’s more efficient for humans as well.

[Leon] created his own board able to be programmed in Forth, shown above, that uses an ATMega328 microcontroller. He’s using AmForth to put Forth on his system, but also extended the base AmForth install with his own floating point version. making this version of Forth at least as powerful as any 80s microcomputer or ATMega development board is today.

[Leon] put together a great demo of the capabilities of Forth and his dev board. You can check that out below.

Continue reading “A Simple Forth Development Board” →