Hackaday Links: November 15, 2015

There are a surprising number of Raspberry Pis being used in industrial equipment. This means the Arduino is left behind, but no longer. There’s your PLCs that use Arduinos.

A few weeks ago, Google introduced a machine intelligence and computer vision technique that made the world look psychedelic. Now, this library is available. On another note, head mounted displays exist, and a sufficiently creative person could mash these two things together into a very, very cool project.

Welcome to Kickstarter! Kickstarter is an uphill battle. People will doubt you because you don’t have a ‘target audience’ or ‘the rights to this franchise’ or ‘any talent whatsoever’, but that’s what crowdfunding is for!

Several years ago, Apple shipped a few million 17″ iMacs with defective displays. They’re still useful computers, though, especially if you can find a replacement LCD. Apple, in all its wisdom, used a weird connector for this LCD. Here’s the adapter board, and this adapter will allow displays running up to 1920×1200.

[Jan] has earned a reputation of building some very cool synths out of single ARM chips. His previous build was a Drumulator and now he’s shrinkified it. He’s put four drum sounds, pitch CV, and audio out on an 8-pin DIP ARM.

YouTube gives you cadmium! [AvE], recently got 100,000 subscribers on his YouTube channel. Apparently, YouTube sends you a terrible belt buckle when you manage to do that. At least he did it without playing video games and screaming.

Low Parts Count ARM SDR

[Alberto di Bene] wanted to build an SDR for relatively low frequencies. Usually, you’d start with some front end to get the radio frequency signal down where you can work with it. But [Alberto] practically just fed an antenna into an STM32F429 Discovery board and did all the radio processing in the onboard ARM chip.

There is a little more to it than that, but only a little. If you open the PDF file on [Alberto’s] site, you’ll see there is a simple front end filter (a transformer, along with a few capacitors and inductors). This low pass filter prevents high frequencies from reaching the ARM processor’s analog to digital converter. In addition, a capacitor and a couple of resistors ensure the converter only sees positive voltages.

The CPU digitizes the incoming signal and processes it, demodulating several different types of radio transmission. The recovered audio is sent through the onboard digital to analog converter.

In addition to an input filter, the output also needs a filter to prevent high frequencies from reaching the speaker. Unlike the input filter, this one is a bit more complicated. The inductors needed for a passive filter were too large to be practical, so the output filter is an active one with a few transistors. The only other external circuitry is the power supply for the Discovery board.

The document does a great job of explaining the rationale behind the design choices and how the whole system works. It also includes simulations of both analog and digital filters used in the design.

This is really bare metal SDR and reading the code is educational. However, if you want to start with something simpler, consider GNU Radio and either an SDRPlay or a cheap RTL-SDR dongle.

 

BBC’s micro:bit Gets Python

The BBC has developed a computer to be used by thousands of students across the UK. While not very powerful in terms of hardware, it comes with an interpreted language that will get students writing their own code and will launch the careers of an entire generation of web developers. This is, of course, the BBC Micro, a computer introduced in 1981, but is still deeply revered by millions of former students.

Microcontrollers are everywhere now, and the BBC is looking to replicate their success with the micro:bit. Unlike the BBC Micro, this isn’t a proper computer with a keyboard and a monitor. Instead, it’s a microcontroller development platform based on an ARM chip. Now, the micro:bit is getting Python, the BASIC of today, and will assuredly be even more useful in UK classrooms.

The initial development for Python on the micro:bit started down the road of using Microsoft’s TouchDevelop as a browser-based IDE that would send C++ code to an mBed cloud compilation service. A hex file would be generated, this would be downloaded to the local file system, and finally the student would simply drag the hex file over to the micro:bit since it appeared on the desktop as a USB storage device. This was a terrible idea, because MicroPython exists. The current way of running Python on the micro:bit is as simple as plugging it in to a USB port, opening a terminal, and writing some code. It’s the closest you’re ever going to get to a computer with BASIC in ROM, and it’s the best device for millions of 11-year-olds to learn how to code.

Thanks [dassheep] for the tip.

Flying High with Zynq

[Aerotenna] recently announced the first successful flight of an unmanned air vehicle (UAV) powered by a Xilinx Zynq processor running ArduPilot. The Zynq is a dual ARM processor with an onboard FPGA that can offload the processor or provide custom I/O devices. They plan to release their code to their OcPoC (Octagonal Pilot on a Chip) project, an open source initiative that partners with Dronecode, an open source UAV platform.

Continue reading “Flying High with Zynq”

FRDM-K22F ARM Board doesn’t have an SD Card Socket? Not so Fast!

The Freescale Freedom development boards come in several different flavors and at several different price points. It is pretty clear that Freescale counts up pennies to hit their desired target price. For example, the costlier boards with bigger processors (like the K64F which costs about $35) has sockets to fit an Arduino shield or other external connections. Many of the cheaper boards (like the KL25Z for $13) just has PCB holes. If you want to add sockets, that’s on you.

The $30 K22F board has the sockets, but it also omits a few components that are on the PCB. [Erich Styger] noted that there was a micro SD card socket footprint on the board and wondered if he could add an SD card to the board by just soldering on the socket. The answer: yes!

Continue reading “FRDM-K22F ARM Board doesn’t have an SD Card Socket? Not so Fast!”

ARMing a Breadboard — Everyone Should Program an ARM

I’m always a little surprised that we don’t see more ARM-based projects. Of course, we do see some, but the volume isn’t what I’d expect given that low-level ARM chips are cheap, capable, low power, and readily available. Having a 32-bit processor with lots of memory running at 40 or 50 MIPS is a game changer compared to, say, a traditional Arduino (and, yes, the Arduino Due and Zero are ARM-based, so you can still stay with Arduino, if that’s what you want).

A few things might inhibit an Arduino, AVR, or PIC user from making the leap. For one thing, most ARM chips use 3.3V I/O instead of the traditional 5V levels (there are exceptions, like the Kinetis E). There was a time when the toolchain was difficult to set up, although this is largely not a problem anymore. But perhaps the largest hurdle is that most of the chips are surface mount devices.

Of course, builders today are getting pretty used to surface mount devices and you can also get evaluation boards pretty cheaply, too. But in some situations–for example, in classrooms–it is very attractive to have a chip that is directly mountable on a common breadboard. Even if you don’t mind using a development board, you may want to use the IC directly in a final version of a project and some people still prefer working with through hole components.

The 28 Pin Solution

One solution that addresses most, if not all, of these concerns is the LPC1114FN28 processor. Unlike most other ARM processors, this one comes in a 28 pin DIP package and works great on a breadboard. It does require 3.3V, but it is 5V tolerant on digital inputs (and, of course, a 3.3V output is usually fine for driving a 5V input). The chip will work with mbed or other ARM tools and after prototyping, you can always move to a surface mount device for production, if you like. Even if you are buying just one, you should be able to find the device for under $6.

Continue reading “ARMing a Breadboard — Everyone Should Program an ARM”

ARMs and FPGAs Make for Interesting Dev Boards

Tiny Linux computers are everywhere, and between BeagleBones, Raspberry and Banana Pis, and a hundred other boards out there, there are enough choices to go around. There is an extremely interesting ARM chip from Xilinx that hasn’t seen much uptake in the field of tiny credit-card sized computers: the Zynq. It’s an ARM Cortex-A9 coupled with an FPGA. It’s great for building peripherals that wouldn’t normally be included on a microcontroller. With Zynq, you just instantiate the custom bits in the FPGA, then interface them with a custom Linux driver. Thanks to CrowdSupply, there’s now a board out there that brings this intriguing chip to a proper development platform. It’s called the Snickerdoodle, and if you’ve ever wanted to see the capabilities of an FPGA tightly coupled to a fast processor, this is the board to watch.

The core of the Snickerdoodle is a Xilinx Zynq that features either a 667 MHz ARM Cortex A9 and a 430k gate FPGA (in the low-end configuration) or an 866 A9 and 1.3M gate FPGA. This gives the Snickerdoodle up to 179 I/O ports – far more than any other tiny Linux board out there.

Fully loaded, the Snickerdoodle comes with 2.4 and 5GHz WiFi, Bluetooth, 1GB of RAM, and an ARM Cortex A9 that should far surpass the BeagleBone and Raspberry Pi 2 in capabilities. This comes at a price, though: the top-shelf Snickerdoodle has a base price of about $150.

Still, the power of a fast ARM and a big FPGA is a big draw and we’re expecting a few more of these Zynq boards in the future. There are even a few projects using the Zynq on hackaday.io, including one that puts the Zynq in a Raspberry Pi-compatible footprint. That’s exceedingly cool, and we can’t wait to see what people will build with a small, fast ARM board coupled to an FPGA.