1. Case Studies - Introduction

It’s an excisting time to be making projects that use embedded processors. Make:'s Makers' Guide to Boards shows many of the options that are available and groups them into different types. Single board computers (SBCs) generally run Linux on some sort of ARM processor. Examples are the BeagleBoard and the Raspberry Pi. Another type is the microcontroller, of which the Arduino is popular.

The SBCs are used because they have an operating system to manage files, I/O, and schedule when things are run, all while possibly talking to the Internet. Microcontrollers shine when things being interfaced require careful timing and can’t afford to have an OS preempt an operation.

But what if you have a projcet that needs the flexibility of an OS and the timing of a microcontroller? This is where the BeagleBoard excells since it has both an ARM procssor running Linux and two Programmable Real-Time Units (PRUs). The PRUs have 32-bit cores which run independently of the ARM processor, therefore they can be programmed to respond quickly to inputs and produce very precisely timed outputs.

There are many projects that use the PRU (http://processors.wiki.ti.com/index.php/PRU_Projects) to do things that can’t be done with just a SBC or just a microcontroller. Here we present some case studies that give a high-level view of using the PRUs. In later chapters you will see the details of how they work.

Here we present

The following are resources used in this chapter.

1.1. Robotics Control Library

Robotics is an embedded application that often requires both an SBC to control the high-level tasks (such as path planning, line following, communicating with the user) and a microcontroller to handle the low-level tasks (such as telling motors how fast to turn, or how to balance in response to an IMU input). The EduMIP balancing robot demonstrates that by using the PRU, the Blue can handle both the high and low -level tasks without an additional microcontroller. The EduMIP is shown in Blue balancing.

Blue balancing

Blue balancing

The Robotics Control Library is a package that is already installed on the Blue, Black and Pocket, that contains a C library and example/testing programs. It uses the PRU to extend the real-time hardware of the Bone by adding eight addional servo channels and one addition real-time encoder input.

The following examples show how easy it is to use the PRU for robotics.

Controlling Eight Servos


You need to control eight servos, but the Bone doesn’t have enough pulse width modulation (PWM) channels and you don’t want to add hardware.


The Robotics Control Library provides eight additional PWM channels via the PRU that can be used out of the box.


The I/O pins on the Beagles have a mutliplexer that lets you select what I/O appears on a given pin. The Blue has the mux already configured to to run these examples. Follow the instructions in Configuring Pins for Controlling Servos to configure the pins for the Black and the Pocket.

Just run:

bone$ sudo rc_test_servos -f 10 -p 1.5

The -f 10 says to use a frequency of 10 Hz and the -p 1.5 says to set the position to 1.5. The range of positions is -1.5 to 1.5. Run rc_test_servos -h to see all the options.

bone$ rc_test_servos -h

 -c {channel}   Specify one channel from 1-8.
                Otherwise all channels will be driven equally
 -f {hz}        Specify pulse frequency, otherwise 50hz is used
 -p {position}  Drive servo to a position between -1.5 & 1.5
 -w {width_us}  Send pulse width in microseconds (us)
 -s {limit}     Sweep servo back/forth between +- limit
                Limit can be between 0 & 1.5
 -r {ch}        Use DSM radio channel {ch} to control servo
 -h             Print this help messege

sample use to center servo channel 1:
   rc_test_servo -c 1 -p 0.0

The BeagleBone Blue sends these eight outputs to it’s servo channels. The Black and the Pocket use the pins shown in the Register to pin table.

Table 1. PRU register to pin table
PRU pin Blue pin Black pin Pocket pin





























You can find these details in the P8 Header Table, P9 Header Table and then Pocket Beagle System Reference Manual. (Here is a more usable version of the table.)

Be default the PRUs are already loaded with the code needed to run the servos. All you have to do is run the command.

Controlling Individual Servos


rc_test_servos is nice, but I need to control the servos individually.


You can modify rc_test_servos.c. You’ll find it on the bone at /opt/source/Robotics_Cape_Installer/examples/src/rc_test_servos.c, or online at https://github.com/StrawsonDesign/Robotics_Cape_Installer/blob/master/examples/src/rc_test_servos.c.

Just past line 250 you’ll find a while loop that has calls to rc_servo_send_pulse_normalized(ch,servo_pos) and rc_servo_send_pulse_us(ch, width_us). The first call sets the pulse width relative to the pulse period; the other sets the width to an absolute time. Use whichever works for you.

Controlling More Than Eight Channels


I need more than eight PWM channels, or I need less jitter on the off time.


This is a more advanced problem and required reprograming the PRUs. See PWM Generator for an example.

Reading Hardware Encoders


I want to use four encoders to measure four motors, but I only see hardware for three.


The forth encoder can be implemented on the PRU. If you run rc_test_encoders_eqep on the Blue, you will see the output of encoders E1-E3 which are connected to the eEQP hardware.

bone$ rc_test_encoders_eqep

Raw encoder positions
      E1   |      E2   |      E3   |
         0 |         0 |         0 |^C

You can also access these hardware encoders on the Black and Pocket using the pins shown in eQEP to pin mapping.

Table 2. eQEP to pin mapping
eQEP Blue pin Black pin A Black pin B Pocket pin A Pocket pin B



























The I/O pins on the Beagles have a mutliplexer that lets you select what I/O appears on a given pin. The Blue has the mux already configured to to run these examples. Follow the instructions in Configuring Pins for Controlling Encoders to configure the pins for the Black and the Pocket.

Reading PRU Encoder


I want to access the PRU encoder.


The forth encoder is implemented on the PRU and accessed with sudo rc_test_encoders_pru


This command needs root permission, so the sudo is needed.

Here’s what you will see

bone$ sudo rc_test_encoders_pru
[sudo] password for debian:

Raw encoder position
      E4   |
         0 |^C

If you aren’t running the Blue you will have to configure the pins as shown in the note above.

1.2. BeagleLogic - a 14-channel Logic Analyzer


I need a 100Msps, 14-channel logic analyzer


BeagleLogic is a 100Msps, 14-channel logic analyzer that runs on the Beagle.

BeagleLogic turns your BeagleBone [Black] into a 14-channel, 100Msps Logic Analyzer. Once loaded, it presents itself as a character device node /dev/beaglelogic.

The core of the logic analyzer is the 'beaglelogic' kernel module that reserves memory for and drives the two Programmable Real-Time Units (PRU) via the remoteproc interface wherein the PRU directly writes logic samples to the System Memory (DDR RAM) at the configured sample rate one-shot or continuously without intervention from the ARM core.
— https://github.com/abhishek-kakkar/BeagleLogic/wiki

The quickest solution is to get the no-setup-required image. It runs on an older image (15-Apr-2016) but should still work.

If you want to be running a newer image, there are instructions on the site for installing BeagleLogic, but I had to do the additional steps in Installing BeagleLogic.

Installing BeagleLogic
bone$ git clone https://github.com/abhishek-kakkar/BeagleLogic
bone$ cd BeagleLogic/kernel
bone$ mv beaglelogic-00A0.dts beaglelogic-00A0.dts.orig
bone$ wget https://gist.githubusercontent.com/abhishek-kakkar/0761ef7b10822cff4b3efd194837f49c/raw/eb2cf6cfb59ff5ccb1710dcd7d4a40cc01cfc050/beaglelogic-00A0.dts
bone$ make overlay
bone$ sudo cp beaglelogic-00A0.dtbo /lib/firmware/
bone$ sudo update-initramfs -u -k `uname -r`
bone$ sudo reboot

Once the Bone has rebooted, browse to where you’ll see BeagleLogic Data Capture. Here you can easily select the sample rate, number of samples, and which pins to sample. Then click Begin Capture to capture your data, at up to 100 MHz!

BeagleLogic Data Capture
Figure 1. BeagleLogic Data Capture


BeagleLogic is a complete system that includes firmware for the PRUs, a kernel module and a web interface that create a powerful 100 MHz logic analyzer on the Bone with no additional hardware needed.


If you need buffered inputs, consider BeagleLogic Standalone, a turnkey Logic Analyzer built on top of BeagleLogic.

The kernel interface makes it easy to control the PRUs through the command line. For example

bone$ dd if=/dev/beaglelogic of=mydump bs=1M count=1

will capture a binary dump from the PRUs. The sample rate and number of bits per sample can be controlled through /sys/.

bone$ cd /sys/devices/virtual/misc/beaglelogic
bone$ ls
buffers      filltestpattern  power       state         uevent
bufunitsize  lasterror        samplerate  subsystem
dev          memalloc         sampleunit  triggerflags
bone$ cat samplerate
bone$ cat sampleunit

You can set the sample rate by simply writing to samplerate.

bone$ echo 100000000 > samplerate

sysfs attributes Reference has more details on configuring via sysfs.

If you run dmesg -Hw in another window you can see when a capture is started and stopped.

bone$ dmesg -Hw
[Jul25 08:46] misc beaglelogic: capture started with sample rate=100000000 Hz, sampleunit=1, triggerflags=0
[  +0.086261] misc beaglelogic: capture session ended

BeagleLogic uses the two PRUs to sample at 100Msps. Getting a PRU running at 200Hz to sample at 100Msps is a slick trick. The Embedded Kitchen has a nice article explaining how the PRUs get this type of performance.

1.3. NeoPixels - 5050 RGB LEDs with Integrated Drivers (LEDScape)


You have an Adafruit NeoPixel LED string, Adafruit NeoPixel LED matrix or any other type of WS2812 LED and want to light it up.


You can either write your own code (See WS2812 Driver), or use LEDscape which is a library for controlling NeoPixels using Open Pixel Control.

LEDscape is a library and service for controlling individually addressable LEDs from a Beagle Bone Black or Beagle Bone Green using the onboard PRUs. It currently supports WS281x (WS2811, WS2812, WS2812b), WS2801 and initial support for DMX.

It can support up to 48 connected strings and can drive them with very little load on the main processor.

LEDscape was originally written by Trammell Hudson (http://trmm.net/Category:LEDscape) for controlling WS2811-based LEDs. Since his original work, his version (https://github.com/osresearch/LEDscape) has been repurposed to drive a different type of LED panel (e.g. http://www.adafruit.com/products/420).

This version of the library was forked from his original WS2811 work. Various improvements have been made in the attempt to make an accessible and powerful LED driver based on the BBB. Many thanks to Trammell for his excellent work in scaffolding the BBB and PRUs for driving LEDs.
— https://github.com/Yona-Appletree/LEDscape

LEDscape can drive 48 strings of LEDs that are arbitary length with no addional hardware! Here’s how to install it.


LEDscape uses UIO, an older method for talking to the PRU. See Configuring for UIO Instead of RemoteProc to configure your Bone to use UIO.

First install LEDscape and openpixelcontrol.

bone$ git clone https://github.com/Yona-Appletree/LEDscape.git
bone$ git clone https://github.com/zestyping/openpixelcontrol

Next find which channels are on which pins

bone$ node LEDscape/pru/pinmap.js
Using mapping: Original LEDscape from original-ledscape
                       Internal Channel Index
 Row  Pin#           P9            Pin#  |  Pin#           P8            Pin# Row
  1    1                            2    |   1                            2    1
  2    3                            4    |   3                            4    2
  3    5                            6    |   5                            6    3
  4    7                            8    |   7       25          26       8    4
  5    9                            10   |   9       28          27       10   5
  6    11      13          23       12   |   11      16          15       12   6
  7    13      14          21       14   |   13      10          11       14   7
  8    15      19          22       16   |   15      18          17       16   8
  9    17                           18   |   17      12          24       18   9
  10   19                           20   |   19       9                   20   10
  11   21       1           0       22   |   21                           22   11
  12   23      20                   24   |   23                           24   12
  13   25                   7       26   |   25                           26   13
  14   27                  47       28   |   27      41                   28   14
  15   29      45          46       30   |   29      42          43       30   15
  16   31      44                   32   |   31       5           6       32   16
  17   33                           34   |   33       4          40       34   17
  18   35                           36   |   35       3          39       36   18
  19   37                           38   |   37      37          38       38   19
  20   39                           40   |   39      35          36       40   20
  21   41       8           2       42   |   41      33          34       42   21
  22   43                           44   |   43      31          32       44   22
  23   45                           46   |   45      29          30       46   23

LEDscape supports up to 48 channels (strings) of LEDs. The above table shows how the channel numbers map to BeagleBone Black pins. We’ll use channel 0 which maps to P9_22. Wire your LED string to P9_22.


The following is a hack, but it makes it work.

We need to edit ledsacpe.c and opc-server.c to make them work.

bone$ cd LEDscape

Now edit opc-server.c and comment out line 723.

// pthread_create(&g_threads.e131_server_thread.handle, NULL, e131_server_thread, NULL

Next edit ledscape.c and comment out lines 29-44

// static const uint8_t gpios0[] = {
//  // 2, 3, 7, 8, 9, 10, 11, 14, 20, 22, 23, 26, 27, 30, 31
//  3, 7, 8, 9, 10, 11, 14, 20, 22, 23, 26, 27, 30, 31
// };

// static const uint8_t gpios1[] = {
//  12, 13, 14, 15, 16, 17, 18, 19, 28, 29
// };

// static const uint8_t gpios2[] = {
//  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 22, 23, 24, 25,
// };

// static const uint8_t gpios3[] = {
//  14, 15, 16, 17, 19, 21
// };

And also lines 176-184

// Configure all of our output pins.
// for (unsigned i = 0 ; i < ARRAY_COUNT(gpios0) ; i++)
//  pru_gpio(0, gpios0[i], 1, 0);
// for (unsigned i = 0 ; i < ARRAY_COUNT(gpios1) ; i++)
//  pru_gpio(1, gpios1[i], 1, 0);
// for (unsigned i = 0 ; i < ARRAY_COUNT(gpios2) ; i++)
//  pru_gpio(2, gpios2[i], 1, 0);
// for (unsigned i = 0 ; i < ARRAY_COUNT(gpios3) ; i++)
//  pru_gpio(3, gpios3[i], 1, 0);

Now configure P9_22 and run make.

bone$ config-pin P9_22 out
bone$ config-pin -q P9_22
P9_22 Mode: gpio Direction: out Value: 0
bone$ make

Now run sudo opc-server.

bone$ sudo ./opc-server
[main] Starting server on ports (tcp=7890, udp=7890) for 176 pixels on 48 strips
[main] Demo Mode Enabled
Allocating buffers for 8448 pixels (202752 bytes)
[main] Initializing / Updating server...frame_size1=8448
Starting demo data thread
[udp] Starting UDP server on port 7890
[render] Starting render thread for 8448 total pixels
[main] Starting LEDscape...pru_init: PRU 0: data 0xb4d5d000 @ 8192 bytes,  DMA 0xb4cdd000 / 9c940000 @ 262144 bytes
pru_init: PRU 1: data 0xa4c5f000 @ 8192 bytes,  DMA 0xa4bdd000 / 9c940000 @ 262144 bytes
String PRU0 with pru/bin/ws281x-original-ledscape-pru0.bin... OK
String PRU1 with pru/bin/ws281x-original-ledscape-pru1.bin... OK
[tcp] Starting TCP server on 7890
[demo] Starting Demo: fade
    "outputMode": "ws281x",
    "outputMapping": "original-ledscape",
    "demoMode": "fade",
    "ledsPerStrip": 176,
    "usedStripCount": 48,
    "colorChannelOrder": "BRG",
    "opcTcpPort": 7890,
    "opcUdpPort": 7890,
    "enableInterpolation": true,
    "enableDithering": true,
    "enableLookupTable": true,
    "lumCurvePower": 2.0000,
    "whitePoint": {
        "red": 0.9000,
        "green": 1.0000,
        "blue": 1.0000
[render] fps_info={frame_avg_usec: 1924, possible_fps: 519.75, actual_fps: 0.10, sample_frames: 1}

You should now see "a pleasing pattern of rotating color hues".


LEDscape is higly configurable. When you run opc-server it first prints out its configuration. If it doesn’t receive any data after three seconds it will go into demo mode. In this configuration, demoMode is set to fade which produces the nice pattern you are seeing. (You can set demoMode to none if you would rather not see anything. See README.md for other options.)

Notice it’s currently configured to drive 48 strings (usedStripCount) with 176 LEDS (ledsPerStrip). It’s also set to interpolate (enableInterpolation) colors, that is, rather than abruptly switching to a new color, it will smoothly fade between the two. With this configuration it uses about 26% of the ARM CPU.

Let’s write a configuration file that fits our LEDs string. Copy the default configuration and edit it.

bone$ cp configs/ws281x-config.json my-config.json

Now edit it to match my-config.json.

    "outputMode": "ws281x",
    "outputMapping": "original-ledscape",
    "demoMode": "fade",
    "ledsPerStrip": 16,
    "usedStripCount": 1,
    "colorChannelOrder": "BRG",
    "opcTcpPort": 7890,
    "opcUdpPort": 7890,
    "enableInterpolation": false,
    "enableDithering": false,
    "enableLookupTable": true,
    "lumCurvePower": 2.0000,
    "whitePoint": {
        "red": 0.9000,
        "green": 1.0000,
        "blue": 1.0000

Run this with:

bone$ sudo ./opc-server --config my-config.json

Now we are only using about 7% of the ARM CPU.

You can now run a program that sends data to the string. circle.py is a simple python example that sequencies an LED through the entire string. It uses opc.py which is included in the code directory.

!/usr/bin/env python

"""A demo client for Open Pixel Control

Runs an LED around in a circle


import time
import opc

ADDRESS = 'localhost:7890'

 Create a client object
client = opc.Client(ADDRESS)

# Test if it can connect
if client.can_connect():
    print 'connected to %s' % ADDRESS
    # We could exit here, but instead let's just print a warning
    # and then keep trying to send pixels in case the server
    # appears later
    print 'WARNING: could not connect to %s' % ADDRESS

# Send pixels forever
for i in range(STR_LEN):
    leds = [(0, 0, 0)] * STR_LEN
leds[0] = (0, 127, 0)

while True:
    tmp = leds[0]
    for i in range(STR_LEN-1):
        leds[i] = leds[i+1]
    leds[-1] = tmp
    if client.put_pixels(leds, channel=0):
        print 'sent'
        print 'not connected'

1.4. RGB LED Matrix - No Integrated Drivers (Falcon Christmas)


You want to use a RGB LED Matrix display that doesn’t have integrated drivers such as the 64x32 RGB LED Matrix by Adafuit shown in Adafruit LED Matrix.

Adafruit LED Matrix
Figure 2. Adafruit LED Matrix


Falcon Christmas makes a software package called Falcon Player (FPP) which can drive such displays.

The Falcon Player (FPP) is a lightweight, optimized, feature-rich sequence player designed to run on low-cost SBC’s (Single Board Computers).
FPP is a software solution that you download and install on hardware which can be purchased from numerous sources around the internet. FPP aims to be controller agnostic, it can talk E1.31, DMX, Pixelnet, and Renard to hardware from multiple hardware vendors, including controller hardware from Falcon Christmas available via COOPs or in the store on FalconChristmas.com.
— http://www.falconchristmas.com/wiki/FPP:FAQ#What_is_FPP.3F

The Beagle hardware can be either a BeagleBone Black with the Octoscroller Cape, or a PocketBeagle with the PocketScroller LED Panel Cape. (See to purchase.) Building and Octoscroller Matrix Display gives details for using the BeagleBone Black.

Pocket Beagle Driving a P5 RGB LED Matrix via the PocketScroller Cape shows how to attach the PocketBeagle to the P5 LED matrix and where to attach the 5V power. If you are going to turn on all the LEDs to full white at the same time you will need at least a 4A supply.

Pocket Beagle Driving a P5 RGB LED Matrix via the PocketScroller Cape
Figure 3. Pocket Beagle Driving a P5 RGB LED Matrix via the PocketScroller Cape

The FPP software is most easily installed by downloading the current FPP image, flashing an SD card and booting from it.


The really brave can install it on a already running image. See details at https://github.com/FalconChristmas/fpp/blob/master/SD/FPP_Install.sh

Assuming the PocketBeagle is attached via the USB cable, on your host computer browse to and you will see Falcon Play Program Control.

Falcon Play Program Control
Figure 4. Falcon Play Program Control

You can test the display by first setting up the Channel Outputs and then going to Display Testing. Selecting Channel Outputs shows where to select Channel Outputs and Channel Outputs Settings shows which settings to use.

Selecting Channel Outputs
Figure 5. Selecting Channel Outputs
Channel Outputs Settings
Figure 6. Channel Outputs Settings

Click on the LED Panels tab and then the only changes I made was to select the Single Panel Size to be 64x32 and to check the Enable LED Panel Output.

Next we need to test the display. Select Display Testing shown in Selecting Display Testing.

Selecting Display Testing
Figure 7. Selecting Display Testing

Set the End Channel to 6144. (6144 is 3*64*32) Click Enable Test Mode and your matrix should light up. Try the different testing patterns shown in Display Testing Options.

Display Testing Options
Figure 8. Display Testing Options
xLights - Creating Content for the Display

Once you are sure your LED Matrix is working correctly you can program it with a sequence.

xLights is a free and open source program that enables you to design, create and play amazing lighting displays through the use of DMX controllers, E1.31 Ethernet controllers and more.

With it you can layout your display visually then assign effects to the various items throughout your sequence. This can be in time to music (with beat-tracking built into xLights) or just however you like.
xLights runs on Windows, OSX and Linux
— https://xlights.org/

xLights can be installed on your host computer (not the Beagle) by following instructions at https://code.launchpad.net/~chris-debenham/+archive/ubuntu/xlights.

Run xLights and you’ll see xLights Setup.

host$ apt install xlights
host$ xLights
xLights Setup
Figure 9. xLights Setup

We’ll walk you through a simple setup to get an animation to display on the RGB Matrix. xLights can use a protocol called E1.31 to send information to the display. Setup xLights by clicking on Add E1.31 and entering the values shown in Setting Up E1.31.

Setting Up E1.31
Figure 10. Setting Up E1.31

The IP Address is the Bone’s address as seen from the host computer. Each LED is one channel, so one RGB LED is three channels. The P5 board has 3*64*32 or 6144 channels. These are grouped into universes of 512 channels each. This gives 6144/512 = 12 universes. See the E.13 documentation for more details.

Your setup should look like xLights setup for P5 display. Click the Save Setup button to save.

xLights setup for P5 display
Figure 11. xLights setup for P5 display

Next click on the Layout tab. Click on the Matrix button as shown in Setting up the Matrix Layout, then click on the black area where you want your matrix to appear.

Setting up the Matrix Layout
Figure 12. Setting up the Matrix Layout

Layout details for P5 matrix shows the setting to use for the P5 matrix.

Layout details for P5 matrix
Figure 13. Layout details for P5 matrix

All I changed was # Strings, Nodes/String, Starting Location and most importantly, expand String Properties and select at String Type of RGB Nodes. Above the seeting you should see that Start Chan is 1 and the End Chan is 6144, which is the total number of individual LEDs (3*63*32). xLights now knows we are working with a P5 matrix, now on to the sequencer.

Now click on the Sequencer tab and then click on the New Sequence button (Starting a new sequence).

Starting a new sequence
Figure 14. Starting a new sequence

Then click on Animation, 20fps (50ms), and Quick Start. Learning how to do sequences is beyond the scope of this cookbook, however I’ll shown you how do simple sequence just to be sure xLights is talking to the Bone.

Setting Up E1.31 on the Bone

First we need to setup FPP to take input from xLights. Do this by going to the Input/Output Setup menu and selecting Channel Inputs. Then enter 12 for Universe Count and click set and you will see E1.31 Bridge Mode Universes.

.E1.31 Bridge Mode Universes
Figure 15. E1.31 Bridge Mode Universes

Click on the Save button above the table. Then go to the Status Control menu and select Status Page. Set the FPPD Mode: to Bridge as shown in Bridge Mode.

Bridge Mode
Figure 16. Bridge Mode
Testing the xLights Connection

The Bone is now listening for commands from xLights via the E1.31 protocol. A quick way to verify everything is t o return to xLights and go to the Tools menu and select Test (xLights test page).

xLights test page
Figure 17. xLights test page

Click the box under Select channels…​, click Output to lights and select Twinkle 50%. You matrix should have a colorful twinkle pattern (xLights Twinkle test pattern).

xLights Twinkle test pattern
Figure 18. xLights Twinkle test pattern
A Simple xLights Sequence

Now that the xLights to FPP link is tested you can generate a sequence to play. Close the Test window and click on the Sequencer tab. Then drag an effect from the Effects box to the timeline that below it. Drop it to the right of the Matrix label (Drag an effect to the timeline). The click Output To Lights which is the yellow lightbulb to the right on the top toolbar. Your matrix should now be displaying your effect.

Drag an effect to the timeline

Drag an effect to the timeline

The setup requires the host computer to send the animation data to the Bone. The next section shows how to save the sequence and play it on the Bone standalone.

Saving a Sequence and Playing it Standalone

In xLights save your sequence by hitting Ctrl-S and giving it a name. I called mine fire since I used a fire effect. Now, switch back to FPP and select the Content Setup menu and select File Manager. Click the blue Select Files button and select your sequence file that ends in .fseq (FPP file manager).

FPP file manager

FPP file manager

Once your sequence is uploaded, got to Content Steup and select Playlists. Enter you playlist name (I used fire) and click Add. Then go down to the New Playlist Entry section and select Sequence Only (Adding a new playlist to FPP), then click Add.

Adding a new playlist to FPP
Figure 19. Adding a new playlist to FPP

Be sure to click Save under Playlist Details. Now return to Status/Control and Status Page and make sure FPPD Mode: is set to Player (Standalone). You should see your playlist. Click the Play button at the bottom of the page and your sequence will play.

The beauty of the PRU is that the Beagle can play a detailed sequence at 20 frames per second and the ARM procossor is only 15% used. The PRUs are doing all the work.

1.5. MachineKit

MachineKit is a platform for machine control applications. It can control machine tools, robots, or other automated devices. It can control servo motors, stepper motors, relays, and other devices related to machine tools.

Machinekit is portable across a wide range of hardware platforms and real-time environments, and delivers excellent performance at low cost. It is based on the HAL component architecture, an intuitive and easy to use circuit model that includes over 150 building blocks for digital logic, motion, control loops, signal processing, and hardware drivers. Machinekit supports local and networked UI options, including ubiquitous platforms like phones or tablets.
— http://www.machinekit.io/about/

1.6. ArduPilot

ArduPilot is a open source autopilot system supporting multi-copters, traditional helicopters, fixed wing aircraft and rovers. ArduPilot runs on a many hardware platforms including the BeagleBone Black and the BeagleBone Blue.

Ardupilot is the most advanced, full-featured and reliable open source autopilot software available. It has been developed over 5+ years by a team of diverse professional engineers and computer scientists. It is the only autopilot software capable of controlling any vehicle system imaginable, from conventional airplanes, multirotors, and helicopters, to boats and even submarines. And now being expanded to feature support for new emerging vehicle types such as quad-planes and compound helicopters.
Installed in over 1,000,000 vehicles world-wide, and with its advanced data-logging, analysis and simulation tools, Ardupilot is the most tested and proven autopilot software. The open-source code base means that it is rapidly evolving, always at the cutting edge of technology development. With many peripheral suppliers creating interfaces, users benefit from a broad ecosystem of sensors, companion computers and communication systems. Finally, since the source code is open, it can be audited to ensure compliance with security and secrecy requirements.

The software suite is installed in aircraft from many OEM UAV companies, such as 3DR, jDrones, PrecisionHawk, AgEagle and Kespry. It is also used for testing and development by several large institutions and corporations such as NASA, Intel and Insitu/Boeing, as well as countless colleges and universities around the world.
— http://www.machinekit.io/about/