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.

goom2

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.

This Home-Made 6-Axis Robotic Arm is Quite the Looker

With a background in software engineering, [Kris Temmerman] decided to make a physical demonstration of his knowledge in the form of a six axis robotic arm… the final product is a delicious display of mechanical eye candy.

Built from mostly aluminum stock, [Kris] machined the bulk of his parts with a CNC mill which he picked up for cheap from China. These custom pieces coupled with some hefty stepper motors ensure the arm’s accuracy as it twists freely and slides along the gantry it’s mounted to. Though the majority of the arm is metal, the hand at the end of his robot was built with 3D printed parts and can be switched out with the future attachments [Kris] plans to design. This classic gripper piece is driven separately with its own Arduino brain controlling the individual servos in the fingers. loadcels

Each finger includes some load bearing sensors which [Kris] harvested from an old scale so that the gripper can tell whether or not it has a hold of an object without crushing it. To orchestrate the robot’s movement, he wrote some nice looking software in C++ which visualizes the inverse kinematics at work in each point of articulation. For the sake of demonstrating his creation in action, he whipped up a basic demo that can locate and move colored blocks laid at random on a surface. A small camera mounted on the hand determines the orientation of the blocks relative to the machine so that the wrist can rotate itself in the proper alignment in order to pick them up.

[Kris] documented the build of his robot in a fascinating speed video which includes footage of the finished arm in action at the end:

Continue reading “This Home-Made 6-Axis Robotic Arm is Quite the Looker”