This BeagleBone’s Got AI

There are a lot of BeagleBones, from Blue, to White, Green, Black, and we think there’s a purple one in there for some reason. The diversity of BeagleBones is due to the openness of the design, and is the biggest advantage over the ‘bone’s main competitor, the Raspberry Pi.

Now, there’s a new BeagleBone, and this time the color is AI. The BeagleBoard foundation has just unveiled the BeagleBone AI, and it is going to be the most powerful BeagleBone ever developed.

Unlike the BeagleBone Blue, Black, or the PocketBeagle, the BeagleBone AI uses the TI AM5729 processor, a dual-core ARM Cortex-A15 running at 1.5 GHz. It’s not a BeagleBone unless it has those nifty real-time programmable units, and yes, this one has four. This is the BeagleBone AI, so something else has to be different, and it comes with four Embedded Vision Engines (EVEs), a TIC66x DSP, and support for machine learning with pre-installed tools.

Of especially interesting note, this board features USB C connectors, Gigabit Ethernet, onboard WiFi, 1 GB of RAM, and 16 GB of eMMC Flash. The massive block of pin headers remains the same.

If this feature set sounds somewhat familiar to the Beagle family, you’re right. The BeagleBoard X-15 — the alpha wolf of the BeagleBone family — also comes with DSP, and Cortex-A15 cores running at 1.5 GHz. The use case for the X-15 was a little puzzling, as it was too big to really be a portable or embeddable system, but didn’t have the power of the likes of an Nvidia Jetson or what have you. The BeagleBone AI is essentially a minified version of the X-15, albeit slightly less capable in terms of RAM and Flash.

Adding Linux To A PDP-11

The UNIBUS architecture for DEC’s PDPs and Vaxxen was a stroke of genius. If you wanted more memory in your minicomputer, just add another card. Need a drive? Plug it into the backplane. Of course, with all those weird cards, these old UNIBUS PDPs are hard to keep running. The UniBone is the solution to this problem. It puts Linux on a UNIBUS bridge, allowing this card to serve as a memory emulator, a test console, a disk emulator, or any other hardware you can think of.

The key to this build is the BeagleBone, everyone’s second-favorite single board computer that has one feature the other one doesn’t: PRUs, or a programmable real-time unit, that allows you to blink a lot of pins very, very fast. We’ve seen the BeagleBone be used as Linux in a terminal, as the rest of the computer for an old PDP-10 front panel and as the front end for a PDP-11/03.

In this build, the Beaglebone’s PRU takes care of interfacing to the UNIBUS backplane, sending everything to a device emulator running as an application. The UniBone can be configured as memory or something boring, but one of these can emulate four RL02 drives, giving a PDP-11 an amazing forty megabytes of storage. The real killer app of this implementation is giving these emulated drives a full complement of glowing buttons for load, ready, fault, and write protect, just like the front of a real RL02 drive. This panel is controlled over the I2C bus on the Beaglebone, and it’s a work of art. Of course, emulating the drive means you can’t use it as the world’s largest thumb drive, but that’s a small price to pay for saving these old computers.

Turning The Beaglebone On A Chip Into A 3D Printer Controller

It’s understood that 3D printers and CNC machines need to control motors, but there are a few other niceties that are always good to have. It would be great if the controller board ran Linux, had support for a nice display, and had some sort of networking. The usual way of going about this is either driving a CNC machine from a desktop, or by adding a Raspberry Pi to a 3D printer.

The best solution to this problem is to just drive everything from a BeagleBone. This will give you Linux, and with a few motor drivers you can have access to the fancy PRUs in the BeagleBone giving you fast precise control. For the last few years, the Replicape has been the board you need to plug a BeagleBone into a few motors. Now, there’s a better, cheaper solution. At the Midwest RepRap Festival this weekend, [Elias Bakken] has unveiled the Revolve, a single board that combines Octavo Systems’ OSD3358 ‘BeagleBone On A Chip’ with silent TMC2130 motor drivers from Trinamic. It’s an all-in-one 3D printer controller board that runs Linux.

The specs for the Revolve are more or less exactly what you would expect for a BeagleBone with a 3D printer controller. The main chip is the Octavo Systems OSB3358, there are six TMC2130 stepper drivers from Trinamic connected directly to the PRUs, 4 GB of eMMC, 4 USB host ports, 10/100 Ethernet, 1080p HDMI out, and enough headers for all the weird and wonderful 3D printers out there. The software is based on Redeem, a daemon that simply turns G-code into spinning motors and switching MOSFETs.

The price hasn’t been set, but [Elias] expects it to be somewhere north of $100, and a bit south of $150. That’s not bad for a board that effectively does everything from online printer monitoring to real-time motion control. There’s no date for the release of this board, but as with most things involving 3D printer, the best place to check for updates is Google+.

From Cop Car Data Terminal, To Retro Computer

It is possible that you will have lived your life without ever coming into contact with a Motorola MDT9100-T. The data terminal of choice for use in police cars across the globe was a computer with a full-sized QWERTY keyboard, a small CRT display, a mainboard sporting an Intel 386SX processor, and a custom version of Windows 3.1. [Trammell Hudson] and some friends from NYC Resistor scored some MDT9100s in an online auction and found them to be just too good an opportunity not to crack them open and see what could be done.

The custom Windows install could be bypassed with a DOS prompt for some period demoscene action, but [Trammell] wanted more. The 386SX wasn’t even quick when it was new, and this computer deserved the power of a BeagleBone! A custom cape was created on a prototyping cape to interface with the MDT9100 header carrying both keyboard and video. A bit of detective work revealed the display to be a 640×480 pixel mono VGA. The ‘Bone’s LVDS output can drive VGA through a resistor ladder DAC with the aid of an appropriate device tree overlay. The keyboard was then taken care of with a Teensy working as a USB device, resulting in a working Linux computer in the shell of an MDT9100.

It’s always good to see old technology brought up to date. Amusingly a couple of years ago we reported on the death of VGA, but retro projects like this one mean it’ll be a long time before we’ve heard the last of it.

Programming Linux Devices With Arduino And The Cloud

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.

Continue reading “Programming Linux Devices With Arduino And The Cloud”

Introduce Yourself To a PocketBeagle With BaconBits

The PocketBeagle single-board computer is now a few months old, and growing fast like its biological namesake. An affordable and available offering in the field of embedded Linux computing, many of us picked one up as an impulse buy. For some, the sheer breadth of possibilities can be paralyzing. (“What do I do first?”) Perhaps a development board can serve as a starting point for training this young puppy? Enter the BaconBits cape.

When paired with a PocketBeagle, everything necessary to start learning embedded computing is on hand. It covers the simple basics of buttons for digital input, potentiometer for analog input, LEDs for visible output. Then grow beyond the basics with an accelerometer for I²C communication and 7-segment displays accessible via SPI. Those digging into system internals will appreciate the USB-to-serial bridge that connects to PocketBeagle’s serial console. This low-level communication will be required if any experimentation manages to (accidentally or deliberately) stop PocketBeagle’s standard USB network communication channels.

BaconBits were introduced in conjunction with the E-ALE (embedded apprentice Linux engineer) training program for use in hands-on modules. The inaugural E-ALE session at SCaLE 16X this past weekend had to deal with some last-minute hiccups, but the course material is informative and we’re confident it’ll be refined into a smooth operation in the near future. While paying for the class will receive built hardware and in-person tutorials to use it, all information – from instructor slides to the BaconBits design – is available on Github. Some of us will choose to learn by reading the slides, others will want their own BaconBits for independent experimentation. And of course E-ALE is not the only way to learn more about PocketBeagle. Whichever way people choose to go, the embedded Linux ecosystem will grow, and we like the sound of that!

Caped Beagle is FPGA Superhero

We miss the days when everything had daughterboards. Now, Arduinos have shields and Raspberry Pis have hats. The BeagleBone has capes. Whatever. However, regardless of the name, the open source BeagleWire cape/shield/hat/daughterboard connects to a BeagleBone and provides a Lattice iCE40HX FPGA, some support hardware, and common I/O connectors like Pmod and Grove. You can see a video about the board below.

In addition to the FPGA, the board contains a EEPROM, RAM, flash memory, an oscillator, and a few buttons, switches and LEDs. The buttons even feature hardware debouncing. The parts list and design files are all available and — depending on a successful crowdfunding campaign — you might be able to buy one for $75 in the future.

The board is configured to communicate over the 100 MHz 16-bit GPMC port. Linux software and example drivers are available so it should be fairly simple to get the FPGA and CPU talking to each other for your own purposes.

If you decide to build your own, there’s a one-click button that will populate a DigiKey cart for you with most of the components. Although the DigiKey site complained about an error, it did seem to order 24 of the 26 components and the total came to just over $50. Of course, you’d still need to source the missing parts and the board.

We’ve talked about the Lattice iCE FPGAs quite a bit in the past. Not only do you have our tutorial videos, but there are plenty of others, too.

Continue reading “Caped Beagle is FPGA Superhero”