The Teensy LC. LC Means Low Cost.

For one reason or another, we’ve been seeing a lot of builds featuring the Teensy 3.1 filtering in on the tip line recently. In retrospect, it’s somewhat obvious; it’s a good board that’s cheap and fast. Yes, somehow [Paul] hit all three in the good/cheap/fast mutually exclusive triumvirate.

Now, there’s a new Teensy. It’s the Teensy LC – Low Cost. It’s not as powerful as the Teensy 3.1, but it does give you the power of an ARM for something that’s just about as cheap as a board with an ATMega.

The chip [Paul] chose for the Teensy LC is the Freescale MKL26Z64 (datasheet here and 876-page reference manual here. PDFs of course). This is a 32-bit Cortex-M0+ running at 48 MHz with 64k of Flash and 8k of RAM. There are 27 digital I/O pins on this one, and the Teensy LC has been designed to be pin-compatible with the Teensy 3.0 and 3.1.

On board are 13 analog inputs, 8 PWM outputs, on 12-bit DAC output, three serial ports, two SPI ports, and two I2C ports. Most of the pins can drive 5mA with a few capable of driving 20mA, and there is a single 5v output pin for driving WS2812 Neopixel LEDs.

Since this is a cut-down version of the Teensy, everything available on the Teensy 3.1 just can’t fit into the BOM of the Teensy LC. The pins aren’t 5V tolerant, there’s no CAN bus, and there are only 4 DMA channels instead of 16 on the Teensy 3.1. Still, it’s a great ARM answer to the ATMega Trinket or other small dev boards.

ARM Pro Mini

Slowly but surely, the age of 8-bit micros being the first tool anyone picks up is coming to an end, and we’re seeing more and more ARM dev boards in nifty, breadboard-friendly packages. [Zapta] thought he would throw his hat into the ring with the ARM Pro Mini, a tiny little board based on the ARM M0 microcontroller.

The ARM chip on this board is the NXP LPC11 with 64 kB of Flash, 12 kB of RAM, and just enough pins to make the whole endeavor worthwhile. The board itself is extremely simple, with just enough SMD parts to be annoying to hand solder.

All the nifty bonuses of ARM boards are available on the ARM Pro Mini, including drag and drop firmware over the USB port, support for single stepping and debugging, and the IDE is a single install with NXP Eclipse/LPCXpresso. Mbed is also supported, so it’s possible to use this board with no software installs when using the online Mbed IDE.

[Zapta] has put everything you need to build this board up on his Github, and has even done a few simple ‘getting started’ tutorials, including a cool little example with a graphics library and a small OLED.

ZX81 Emulated on an mbed

This is a wonderful example of the phenomenon of “feature creep”. [Gert] was working on getting a VGA output running on an mbed platform without using (hardly) any discrete components. Using only a few resistors, the mbed was connected to a VGA display running at 640×480. But what could he do with something with VGA out? He decided to emulate an entire Sinclair ZX81 computer, of course.

With more than 1.5 million units sold, the Sinclair ZX81 was a fairly popular computer in the early ’80s. It was [Gert]’s first computer, so it was a natural choice for him to try to emulate. Another reason for the choice was that his mbed-VGA device could only output monochrome color, which was another characteristic of the ZX81.

[Gert] started by modifying a very lean Z80 emulator to make the compiled code run as efficiently as possible on the mbed. Then he went about getting a picture to display on the screen, then he interfaced an SD card and a keyboard to his new machine. To be true to the original, he built everything into an original ZX81 case.

This isn’t the first time we’ve seen a ZX81, but it is one of the better implementations of an emulated version of this system we’ve seen.

Thanks to [Jeroen] for the tip!

The Most Minimal WS2812B Driver

Whether you call them individually controllable RGB LEDs, WS2812, or NeoPixels, there’s no denying they are extremely popular and a staple of every glowey and blinkey project. Fresh off the reel, they’re nearly useless – you need a controller, and that has led to many people coming up with many different solutions to the same problem. Here’s another solution, notable because it’s the most minimal WS2812 driver we’ve ever seen.

The critical component in this build is NXP’s LPC810, an ARM Cortex M0+ in an 8-pin DIP package. Yes, it’s the only ARM in a DIP-8, but still able to run at 30MHz, and hold a 4kB program.

JeeLabs is using the SPI bus on the LPC810 to clock out data at the rate required by the LEDs. The only hardware required is a small LED to drop the voltage from 5V to 3.3V and a decoupling capacitor. Yes, you could easily get away with this as a one-component build.

The build consists of a ring of sixty WS2812b RGB LEDs, and the chip dutifully clocking out bits at the correct rate. It’s the perfect start to an LED clock project, an Iron Man arc reactor (are we still doing those?), or just random blinkey LEDs stuffed into a wearable.

Thanks [Martyn] for sending this one in.

A 16-voice Homebrew Polyphonic Synth

Homebrew synths – generating a waveform in a microcontroller, adding a MIDI interface, and sending everything out to a speaker – are great projects that will teach you a ton about how much you can do with a tiny, low power uC. [Mark] created what is probably the most powerful homebrew synth we’ve seen, all while using a relatively low-power microcontroller.

The hardware for this project is an LPC1311 ARM Cortex M3 running at 72 MHz. Turning digital audio into something a speaker can understand is handled by a Wolfson WM8762, a stereo 24-bit DAC. Both of these chips can be bought for under one pound in quantity one, something you can’t say about the chips used in olde-tyme synths.

The front panel, shown below, uses 22 pots and two switches to control the waveform, ADSR, filter, volume, and pan. To save pins on the microcontroller, [Mark] used a few analog multiplexers. As far as circuitry goes, it’s a fairly simple setup, with the only truly weird component being the optocoupler for the MIDI input.


The software for the synth is written mostly in assembly. In a previous version where most of the code was written in C, everything was a factor of two slower. Doing all the voice generation in assembly allowed for twice as many simultaneous voices.

It’s a great project, and compared to some of the other synth builds we’ve seen before, [Mark]’s project is at the top of its class. A quick search of the archives says this is probably the most polyphonic homebrew synth we’ve seen, and listening to the sound sample on the project page, it sounds pretty good, to boot.

Running Debian on a Graphing Calculator

While the ubiquitous TI-83 still runs off an ancient Zilog Z80 processor, the newer TI-Nspire series of graphing calculators uses modern ARM devices. [Codinghobbit] managed to get Debian Linux running on a TI-Nspire calculator, and has written a guide explaining how it’s done.

The process uses Ndless, a jailbreak which allows code to run at a low level on the device. Ndless also includes a full SDK, emulator, and debugger for developing apps. In this case, Ndless is used to load the Linux kernel.

The root filesystem is built on a PC using debootstrap and the QEMU ARM emulator. This allows you to install whatever packages are needed via apt, before transitioning to the calculator itself.

With the root filesystem on a USB flash drive, Ndless runs the Linux loader, which starts the kernel, mounts the root filesystem, and boots in to a Debian system in about two minutes. As the video after the break demonstrates, this leaves you with a shell on the calculator. We’re not exactly sure what to do with Linux on a graphing calculator, but it is a neat demonstration.

Continue reading “Running Debian on a Graphing Calculator”

Hackaday Links: November 16, 2014

There have been a few people asking us to do our full teardown of a crowdfunding campaign, this time for Bleen. We’ll get to that, but here’s the TL;DR version: 208 people just threw money away, and right now Indiegogo is ~$3000 richer for doing nothing.

Insipired by a Hacklet, [Chris] documented his retro console build. He started out like most people do with a Raspberry Pi, but found emulating newer consoles like the N64 consumed too much processor time. He moved his build over to custom-assembled hardware with an AMD Micro-ATX board, a drive, and a USB gamepad. It’s beautiful, and much, much more powerful than a Raspberry Pi.

SD card in your Pi died? Of course it did. The problem is you’re not shutting down your Pi correctly. [satya] whipped up a quick project to fix that. One button, a bit of Python, and a shell script is all you need for a one-button shutdown for your Raspberry Pi.

A while ago, [Jan] built an ARM-based modeling MIDI synth that sounds a lot like the old Junos of the 80s. It’s build around the one 8-pin DIP ARM that’s being manufactured, placed between a MIDI jack and a 1/4″ jack. That’s pretty much all the components. [Gritty] plugged it into a Teensy that’s connected to a sequencer. It sounds awesome.

Everyone loves the Spark Core – there are a few floating around the office here. Now there’s a new Spark. It’s called the Photon, and they’re packaging it as a module. There’s an STM32F2 microcontroller and a BCM43362 Wi-Fi transceiver packaged in a nice, FCC certified module. Very cool.