Alorium rolled out a new product late last year that caught our attention. The Sno (pronounced like “snow”) board is a tiny footprint Arduino board that you can see in the video below. By itself that isn’t that interesting, but the Sno also has an Altera/Intel Max 10 FPGA onboard. If you aren’t an FPGA user, don’t tune out yet, though, because while you can customize the FPGA in several ways, you don’t have to.

Like Alorium’s XLR8 product, the FPGA comes with preprogrammed functions and a matching Arduino API to use them. In particular, there are modules to do analog to digital conversion, servo control, operate NeoPixels, and do floating point math.

However, you can reprogram the FPGA to have other functions — known as XBs or Xcelerator Blocks — if you like. The only problem we see is that, so far, there aren’t many of them. In addition to the stock XBs, there is one that will do quadrature decoding for dealing with things like shaft encoders. There are a few others you can find on their GitHub page. You can get an idea for the workflow by looking at this tutorial for the XLR8 board.

Of course, you can write your own FPGA configurations as you see fit, but they also provide a standard workflow — OpenXLR8 — that lets you build your own blocks that operate just like their blocks. It would be easy to imagine an “app store” concept where people develop custom blocks and make them available.

We really like the idea of this device and it is certainly inexpensive. You can prototype on the XLR8 which looks like a UNO or you can put headers in the Sno. They also sell a breakout board that will make the Sno physically more like an UNO. We are surprised, though, that there are not more XBs created over the last two years.

The FPGA onboard is similar to the one on the Arrow board we looked at earlier this year, although that has some additional components like SDRAM. If you are looking for a project, it might be interesting to convert our PWM code into an XB.

Thanks to [K5STV] for showing us one of these.

Linux programs, when they misbehave, produce core dumps. The reason they have that name is that magnetic core memory was the primary storage for computers back in the old days and many of us still refer to a computer’s main memory as “core.” If you ever wanted to have a computer with real core memory you can get a board that plugs into an Arduino and provides it with a 32-bit core storage. Of course, the Arduino can’t directly run programs out of the memory and as designer [Jussi Kilpeläinen] mentions, it is “hilariously impractical.” The board has been around a little while, but a recent video shined a spotlight on this retro design.

Impractical or not, there’s something charming about having real magnetic core memory on a modern CPU. The core plane isn’t as dense as the old commercial offerings that could fit 32 kilobits (not bytes) into only a cubic foot. We’ll leave the math about how much your 8-gigabyte laptop would have to grow to use core memory to you.

Honestly, this is purely a novelty, but we do miss core memory somewhat. It was inherently nonvolatile. You could turn the computer off, turn it back on, and everything was just how you left it. Sure, it was peculiar that reading a bit also destroyed it, but many of the old computers had the write after read cycle built into the CPU architecture so that it wasn’t a big deal.

If you want to look at how it was to repair a big core system, we looked at that earlier. Surprisingly, though, this isn’t the first Arduino core memory rig we’ve seen.

Space is big. Really big. Yet on TV and movies, enemy spacecraft routinely wind up meeting at roughly the same spot and, miraculously, in the same orientation. If you’ve ever tried to find something smaller than the moon in a telescope, you’ll appreciate that it isn’t that easy. There are plenty of tricks for locating objects ranging from expensive computerized scopes with motors to mounting a phone with Google Sky or a similar program to your telescope. [DentDentArthurDent] didn’t use a phone. He used an Arduino with an outboard GPS module.

You still have to move the scope yourself, but the GPS means you know your location and the time to a high degree of accuracy. Before you start an observing session, you simply point the telescope at Polaris to calibrate the algorithm, a process which in the northern hemisphere is pretty easy.

The telescope in question is a Dobson, so is easy to move and easy to sense its position using potentiometers and an A/D. The project also includes a detailed description of the math used to convert the time, latitude, longitude, right ascension, and declination into position data. One of four LEDs show if you should move up, down, left, or right. When you are on target, all four LEDs light. We assume you should use red LEDs and a red LCD filter so you don’t ruin your night vision.

There are a few sources of error and [Arthur] does a great job of analyzing and correcting each one. The project even has a nice 3D printed case. The database only contains 45 objects but it is easy to add more. We wondered if it wouldn’t have been better to use a larger computer such as a Raspberry Pi to get the stellar data — maybe even from the Internet — and rely on the Arduino to just manage the position sensing and direction indication, but then again, this works and it is very inexpensive.

This isn’t the first Arduino telescope finder we’ve seen. The last one even had a touchscreen.

Experience — or at least education — often makes a big difference to having a successful project. For example, if you didn’t think about it much, you might think it is simple to control the temperature of something that is heating. Just turn on the heater if it is cold and turn it off when you hit the right temperature, right? That is one approach — sometimes known as bang-bang — but you’ll find there a lot of issues with that approach. Best practice is to use a PID or Proportional/Integral/Derivative control. [Electronoob] has a good tutorial about how to pull this off with an Arduino. You can also see a video, below.

The demo uses a 3D printer hot end, a thermocouple, a MAX6675 that reads the thermocouple, and an Arduino. There’s also an LCD display and a FET to control the heater.

The idea behind a PID controller is that you measure the difference between the current temperature and the desired temperature known as the setpoint. The proportional gain tells you how much output occurs due to that difference. So if the setpoint is way off, the proportional term will generate a lot of output to the heater. If it is close, only a little bit of output will result. This helps prevent overshoot where the temperature goes too high and has to come back down.

The integral term adds a little bit to the output based on the cumulative error over time. The derivative term reacts to changes in the temperature difference. For example, if something external causes the temperature to drop suddenly, the derivative term can goose the output to compensate.

However, the operative word is “can.” Part of setting up a PID is finding the coefficients for each term which for some systems could be zero or even negative (indicating a reverse effect).  There are a lot of other subtleties, too, like what happens if the output stops affecting the temperature for a long period and the integral amount grows to unmanageable magnitude.

By the way, we’ve covered a PID library for Arduino before. While this post talks about temperature, PID control is used for everything from flight control to levitation.

If your Arduino runs out of I/O lines, you can always add one of the several I/O expander chips that takes a serial interface to set its several pins. Or perhaps you could buy something like an Arduino Mega, with its extra sockets to fulfil your needs. But what would you do if you really needed more pins, say a thousand of them? Perhaps [Brian Lough] has the answer. OK, full disclosure: If you really need a thousand, the video isn’t exactly for you, as he shows you how to add up to 992 PWM outputs. The chip he uses works with any microcontroller (the video shows an ESP8266), and we suppose you could use two daisy chains of them and break the 1,000 barrier handily.

We like how short the video is (just two minutes; see below) as it gets right to the point. The PCA9685 chip gives you 16 12-bit PWM channels via an I2C interface. You can daisy chain up to 62 of the boards to get the 992 outputs promised.

[Brian] uses a cheap $2 breakout board that lets you set a 6-bit address, has a nice power connector and makes it easy to use the little surface mount device. Each of the 16 outputs on the board can have an independent duty cycle, but they do share a single output frequency. That means if you want to use some channels for low-frequency devices like motors and some for high-frequency devices like LEDs, you might have to spring $4 for two boards.

Over on Hackaday.io, we’ve seen these devices driving 128 vibration motors. The PCA9685 made us think of the time we rolled our own serial to PWM devices using an FPGA.

Taking a vintage radio and cramming it full of modern, Internet-connected, guts has long been a staple of the hacking and making scene. While some might see it as a crime to take what’s arguably a legitimate piece of history and turn it into nothing more than a slipshod case for the Raspberry Pi, we have to admit there’s a certain appeal to the idea. Taking the beauty of classic design and pairing it with more modern capabilities is getting the best of both worlds.

But this project by [Nick Koumaris] is a somewhat unique take on the concept. Rather than sacrificing a real vintage piece of hardware to house the electronics, he’s designed a 3D printable case that looks like a classic 1936 AWA Radiolette. But what’s really interesting to us is that he then puts a basic FM radio inside of it.

That’s right, no Internet radio streaming or smartphone Bluetooth compatibility here. It’s just a regular FM radio, not entirely unlike the kind of hardware you’d expect to be inside of a classic radio. Of course, it’s much more modern, and [Nick] actually built it himself from a TEA5767 FM radio module and an Arduino Pro Mini.

While functionally it might not be terribly exciting, we do appreciate that he went through the trouble to make a vintage-looking user interface for the radio. While physical buttons would arguably have been more appropriate given the era, the art deco inspired font and graphics that show on the device’s Nokia 5110 LCD do look really slick.

Purists will surely be happy to see another project where a piece of vintage piece of audio equipment wasn’t sacrificed at the Altar of Hack, but we’ve also played host to many projects which weren’t nearly as concerned with historical preservation.

Quality software development examples can be hard to come by. Sure, it’s easy to pop over to Google and find a <code> block with all the right keywords, but having everything correctly explained can be hit or miss. And the more niche the subject, the thinner the forum posts get. Bucking the downward trend [HansLuijten] provides an astoundingly thorough set of LED strip patterns in his comprehensive post titled Arduino LED strip effects.

Don’t let the unassuming title lead you astray from the content, because what’s on offer goes beyond your average beginner tutorial on how to setup a strand of NeoPixels. [HansLuijten] is thorough to a fault; providing examples for everything from simple single color fades and classic Cylon eyes to effects that look like meteors falling from the sky. Seriously! Check out the video after the break. Those chasing lights you see around theater signs? Check. Color twinkle and sparkle? Check. Color wipes and rainbow fades? Check, and check.

At this point, an average forum post would be a jumbled mess of source which only works on an authentic Arduino Duemilanove running at 3.3v sitting on top of the 2nd printing of the author’s favorite issue of Make. But not here! These samples work with Adafruit’s easy to use NeoPixel library as well as FastLED, the quickest pixel in the West. On top of that the examples are clear and concise and explanation is plentiful. But the best part is definitely that each effect has a video clearly showing what it looks like.

If only everything were this easy to use, the open source revolution would already be here.

Self-described “Inventor Dad” [pepelepoisson]’s project is called Stecchino (English translation link here) and it’s an Arduino-based physical balancing game that aims to be intuitive to use and play for all ages. Using the Stecchino (‘toothpick’ in Italian) consists of balancing the device on your hand and trying to keep it upright for as long as possible. The LED strip fills up as time passes, and it keeps records of high scores. It was specifically designed to be instantly understood and simple to use by people of all ages, and we think it has succeeded in this brilliantly.

To sense orientation and movement, Stecchino uses an MPU-6050 gyro and accelerometer board. An RGB LED strip gives feedback, and it includes a small li-po cell and charger board for easy recharging via USB. The enclosure is made from a few layers of laser-cut and laser-engraved material that also holds the components in place. The WS2828B LED strip used is technically a 5 V unit, but [pepelepoisson] found that feeding them direct from the 3.7 V cell works just fine; it’s not until the cell drops to about three volts that things start to glitch out. All source code and design files are on GitHub.

Games are great, and the wonderful options available to people today allow for all kinds of interesting experimentation like a blind version of tag, or putting new twists on old classics like testing speed instead of strength.

We’re big fans of the impractical around here at Hackaday. Sure there’s a certain appeal to coming up with the most efficient method to accomplish your goal, the method that does exactly what it needs to do without any superfluous elements. But it’s just not as much fun. If at least one person doesn’t ask “But why?”, then you probably left something on the table, design wise.

So when we saw this delightfully complex clock designed by [Tucker Shannon], we instantly fell in love. Powered by an Arduino, the clock uses an articulated arm with a UV LED to write out the current time on a piece of glow-in-the-dark material. The time doesn’t stay up for long depending on the lighting in the room, but at least it only takes a second or two to write out once you press the button.

Things are pretty straightforward inside the 3D printed case. There’s an Arduino coupled with an RTC module to keep the time, which is connected to the two standard hobby servos mounted in the front panel. A UV LED and simple push button round out the rest of the Bill of Materials. The source code is provided, so you won’t have to figure out the kinematics involved in getting the two servos to play nicely together if you want to try this one at home.

We’ve seen many clocks powered by Arduinos over the years, occasionally they even have hands. But few can boast their own robotic arm.

Back in the olden days, when the Wire library still sucked, the Arduino was just a microcontroller. Now, we have single board computers and cheap microcontrollers with WiFi built in. As always, there’s a need to make programming and embedded development more accessible and more widely supported among the hundreds of devices available today.

At the Embedded Linux Conference this week, [Massimo Banzi] announced the beginning of what will be Arduino’s answer to the cloud, online IDEs, and a vast ecosystem of connected devices. It’s Arduino Create, an online IDE that allows anyone to develop embedded projects and manage them remotely.

As demonstrated in [Massimo]’s keynote, the core idea of Arduino Create is to put a connected device on the Internet and allow over-the-air updates and development. As this is Arduino, the volumes of libraries available for hundreds of different platforms are leveraged to make this possible. Right now, a wide variety of boards are supported, including the Raspberry Pi, BeagleBone, and several Intel IoT boards.

The focus of this development is platform-agnostic and focuses nearly entirely on ease of use and interoperability. This is a marked change from the Arduino of five years ago; there was a time when the Arduino was an ATmega328p, and that’s about it. A few years later, you could put Arduino sketches on an ATtiny85. A lot has changed since then. We got the Raspberry Pi, we got Intel stepping into the waters of IoT devices, we got a million boards based on smartphone SoCs, and Intel got out of the IoT market.

While others companies and organizations have already made inroads into an online IDE for Raspberry Pis and other single board computers, namely the Adafruit webIDE and Codebender, this is a welcome change that already has the support of the Arduino organization.

You can check out [Massimo]’s keynote below.