1 2 3 Previous Next

BeagleBone Black

87 posts


In previous blog posts, I've showed how to use small LCD displays as a Linux framebuffer on the BeagleBone Black thanks to the fbtft drivers:


In this post, I will show how to use fbtft drivers on BBB with the latest version of the Linux kernel.  In this case, that is Linux 4.4.

Full transcript in this GitHub Gist.



Step 1: Build kernel

Clone Robert C. Nelson's bb-kernel repo and checkout the am33x-v4.4 branch.  When I did last week, the latest kernel version was 4.4-rc1-bone0:

laptop$ git clone https://github.com/RobertCNelson/bb-kernel


laptop$ cd bb-kernel/


laptop$ git checkout am33x-v4.4


laptop$ ./build_kernel.sh


The build kernel script will at some point open the kernel config menu system.  Enable Device Drivers->Staging->fbtft:





Step 2: Install kernel

Flash latest Debian 8.2 (Jessie) console image for the BBB:

laptop$ wget https://rcn-ee.com/rootfs/bb.org/testing/2015-11-15/console/bone-debian-8.2-console-armhf-2015-11-15-2gb.img.xz


laptop$ xz -d bone-debian-8.2-console-armhf-2015-11-15-2gb.img.xz


laptop$ sudo dd if=/home/afustini/Downloads/bbb-images/bone-debian-8.2-console-armhf-2015-11-15-2gb.img.xz of=/dev/sdc


laptop$ sudo eject /dev/sdc


Remove and re-insert so that fs gets mounted.  Run this from bb-kernel directory:

laptop$ ./tools/install_kernel.sh


Eject card and boot the BeagleBone with it.  Once booted, grow the filesystem to make use of free space on the card:

bone$ sudo /opt/scripts/tools/grow_partition.sh


bone$ sudo reboot


Finish installation of the new kernel on the BeagleBone.  The install script fails to do this.  In this case, my new kernel is 4.4.0-rc1-bone0:

bone$ sudo cp -pr /dtbs /boot/dtbs/4.4.0-rc1-bone0


bone$ sudo cp /zImage /boot/vmlinuz-4.4.0-rc1-bone0


Edit /boot/uEnv.txt on Beaglebone so that the new kernel is booted:

bone$ sudo vi /boot/uEnv.txt




bone$ sudo reboot


Verify the the BeagleBone booted the new kernel:

bone$ uname -a

Linux beaglebone 4.4.0-rc1-bone0 #4 Thu Nov 19 20:26:04 CST 2015 armv7l GNU/Linux



Step 3: Configure SPI


Build the latest Device Tree Overlays:

bone$ sudo apt-get update


bone$ sudo apt-get install git


bone$ git clone https://github.com/beagleboard/bb.org-overlays


bone$ cd bb.org-overlays


bone$ ./dtc-overlay.sh


bone$ ./install.sh

Load the Device Tree Overlay for BB-SPIDEV1 "virtual cape" as my LCD is wired up to spi1 pins:

bone$ cat /sys/devices/platform/bone_capemgr/slots

0: PF----  -1

1: PF----  -1

2: PF----  -1

3: PF----  -1

bone$ sudo /bin/sh -c 'echo BB-SPIDEV1 > /sys/devices/platform/bone_capemgr/slots'

bone$ cat /sys/devices/platform/bone_capemgr/slots

0: PF----  -1

1: PF----  -1

2: PF----  -1

3: PF----  -1

4: P-O-L-  0 Override Board Name,00A0,Override Manuf,BB-SPIDEV1



Step 4: Load fbtft drivers


Load fbtft_device module for adafruit18 (Adafruit 1.8" TFT LCD) which will use the fb_st7735r driver:

bone$ sudo modprobe fbtft_device busnum=1 name=adafruit18 debug=7 verbose=3 gpios=dc:48,reset:60

Display image on the LCD display:

bone$ sudo apt-get install fbi

bone$ wget 'http://beagleboard.org/static/uploads/BorisTux_w_Logo.png'

bone$ sudo fbi -d /dev/fb0 -T 1 -a BorisTux_w_Logo.png


Texas Instruments has their own Linux kernel repo with branches to support their processors such as the Sitara AM3358 in the BeagleBone Black:


Gitorious@TI: ti-linux-kernel

This repo contains a Linux kernel that has been integrated with outstanding TI open source patches based on the open source Linux kernel found at kernel.org

Here is a good presentation for TI TechDay 2015 on how TI handles Linux engineering.


The most excellent Robert C. Nelson has made it very easy to run TI kernels on your BeagleBone Black by using his ti-linux-kernel-dev repo.  The newest branch is ti-linux-4.1.y.  While current kernel.org stable is 4.3, TI is working on 4.1 as it is current Long Term Support (LTS) kernelLinux 4.4 is expected to be released at the end of the year, and that will become the new LTS kernel.  I believe TI will then move forward to that.


A big advantage of moving to Linux 4.1 is that the fbtft drivers are now in the Linux kernel: drivers/staging/fbtftLast December, Thomas Petazzoni of Free Electrons took it upon himself to add notro's fbtft drivers to the kernel: [PATCH 00/29] staging: add drivers from the fbtft project.  Development in notro's repo has ceased and moved to the Linux kernel drivers staging treefbtft is maintained by Noralf Trønnes (notro) & Thomas Petazzoni.


Here are the steps that I followed.  Full transcript is in my GitHub Gist.


Step 1: Build kernel

These commands were on my 64-bit Intel laptop running Debian GNU/Linux 8.2:

laptop$ git clone https://github.com/RobertCNelson/ti-linux-kernel-dev/

Cloning into 'ti-linux-kernel-dev'...

remote: Counting objects: 6549, done.

remote: Compressing objects: 100% (56/56), done.

remote: Total 6549 (delta 37), reused 0 (delta 0), pack-reused 6493

Receiving objects: 100% (6549/6549), 5.21 MiB | 3.17 MiB/s, done.

Resolving deltas: 100% (5036/5036), done.

Checking connectivity... done.



laptop$ cd ti-linux-kernel-dev


laptop$ git checkout ti-linux-4.1.y

Branch ti-linux-4.1.y set up to track remote branch ti-linux-4.1.y from origin by rebasing.

Switched to a new branch 'ti-linux-4.1.y'


laptop$ ./build_kernel.sh

After running for awhile, build_kernel.sh will invoke the kernel config menu.  Enable the fbtft modules located in the Device Drivers -> Staging menu.  Here are photos of kernel config menus:





Step 2: Flash SD card

Flash a Debian 8.2 (Jessie) Snapshot console image from the BeagleBoneBlack Debian page on the eLinux.org wiki:

laptop$ sudo dd if=bone-debian-8.2-console-armhf-2015-10-11-2gb.img of=/dev/sdc

3481600+0 records in

3481600+0 records out

1782579200 bytes (1.8 GB) copied, 686.836 s, 2.6 MB/s


laptop$ sudo eject /dev/sdc


Step 3: Install new kernel

Re-insert SD card so that its filesystem is mounted.  Run the kernel install script from your ti-linux-kernel-dev directory:

laptop$ sudo ./tools/install_kernel.sh

Unmount and eject the SD card:

laptop$ sudo umount /dev/sdc1

laptop$ sudo eject /dev/sdc

Insert SD card into BeagleBone Black and boot it.


The install script fails to do the following so it must be done manually.  Copy the kernel image and device tree bindings to the expected location:

bone$ sudo cp /zImage /boot/vmlinuz-4.1.13-ti-r30

bone$ sudo cp -pr /dtbs /boot/dtbs/4.1.13-ti-r30


Edit /boot/uEnv.txt to set uname_r=4.1.13-ti-r30 and set dtb=am335x-boneblack-overlay.dtb:

bone$ sudo vi /boot/uEnv.txt



Run script to grow filesystem to make use of the SD cards full capacity:

bone$ cd /opt/scripts/tools

bone$ sudo ./grow_partition.sh

Reboot the BeagleBone:

bone$ sudo reboot


After rebooting, verify that the new kernel is running:

bone$ uname -a

Linux beaglebone 4.1.13-ti-r30 #1 SMP PREEMPT Mon Nov 16 00:50:22 CST 2015 armv7l GNU/Linux


Step 4: Enable SPI

Now build & install the latest Device Tree Overlays from bb.org-overlays repo:

bone$ git clone https://github.com/beagleboard/bb.org-overlays

bone$ cd bb.org-overlays/

bone$ ./dtc-overlay.sh

bone$ ./install.sh


Enable the spi1 peripheral (which LCD is wired up to) by loading the BB-SPIDEV1 Device Tree overlay:

bone$ cat /sys/devices/platform/bone_capemgr/slots

0: PF---- -1

1: PF---- -1

2: PF---- -1

3: PF---- -1


bone$ sudo /bin/sh -c 'echo BB-SPIDEV1 > /sys/devices/platform/bone_capemgr/slots'


bone$ cat /sys/devices/platform/bone_capemgr/slots

0: PF---- -1

1: PF---- -1

2: PF---- -1

3: PF---- -1

4: P-O-L- 0 Override Board Name,00A0,Override Manuf,BB-SPIDEV1


Step 5: Load fbtft driver

Load the fbtft_device kernel module for adafruit18 (Adafruit 1.8" TFT LCD) which will then load the fb_st7735r driver:

bone$ sudo modprobe fbtft_device busnum=1 name=adafruit18 debug=7 verbose=3 gpios=dc:48,reset:60


Install fbi to display image on the LCD:

bone$ sudo apt-get update

bone$ sudo apt-get install fbi


bone$ wget 'http://beagleboard.org/static/uploads/BorisTux_w_Logo.png'

bone$ sudo fbi -d /dev/fb1 -T 1 -a BorisTux_w_Logo.png


My previous post showed how to use small TFT LCDs as a Linux framebuffer on a BeagleBone Black:


BeagleBone Black LCDs with Prebuilt FBTFT drivers


I showed how to use pre-built fbtft kernel modules to provide the necessary Linux device driver.  However, what if you want to use fbtft modules with a newer version of the Linux kernel?


The BeagleBone Black currently ships with a Linux 3.8 kernel built from Robert C. Nelson's am33x-v3.8 branch.  I do also have fbtft working on the BBB with newer kernels such as TI's 4.1 branch and mainline 4.4-rc1, but I will focus on Linux 3.8 for this post.


Here is how I built FBTFT for Linux 3.8.13-bone79 kernel:

(for my complete transcript see this GitHub Gist)


Step 1: Clone repo & checkout branch

Clone bb-kernel repo & checkout am33x-v3.8 branch

$ git clone https://github.com/RobertCNelson/bb-kernel


$ cd bb-kernel


$ git checkout am33x-v3.8

Already on 'am33x-v3.8'

Your branch is up-to-date with 'origin/am33x-v3.8'.


Step 2: Run build script

Move into the new branch directory & run the build kernel script:

$ ./build_kernel.sh



make -j4 ARCH=arm LOCALVERSION=-bone79 CROSS_COMPILE="ccache /home/afustini/dev/bbb/bb-kernel/dl/gcc-linaro-arm-linux-gnueabihf-4.7-2013.04-20130415_linux/bin/arm-linux-gnueabihf-" dtbs



Script Complete


Step 3: Add fbtft drivers

Add fbtft drivers into Linux kernel source based on instructions from fbtft README.


From within the bb-kernel dir:

$ cd KERNEL/drivers/video



$ git clone https://github.com/notro/fbtft

Cloning into 'fbtft'...

remote: Counting objects: 1170, done.

remote: Total 1170 (delta 0), reused 0 (delta 0), pack-reused 1170

Receiving objects: 100% (1170/1170), 526.16 KiB | 0 bytes/s, done.

Resolving deltas: 100% (726/726), done.

Checking connectivity... done.


Add to KERNEL/drivers/video/Kconfig:

source "drivers/video/fbtft/Kconfig"


Add to KERNEL/drivers/video/Makefile:

obj-y += fbtft/

Verify files were modified correctly

$ git diff

diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig

index a0c757a..50c5d62 100644

--- a/drivers/video/Kconfig

+++ b/drivers/video/Kconfig

@@ -2494,4 +2494,6 @@ config FB_SSD1307

  This driver implements support for the Solomon SSD1307

  OLED controller over I2C.


+source "drivers/video/fbtft/Kconfig"



diff --git a/drivers/video/Makefile b/drivers/video/Makefile

index 28bfbca..6bd03af 100644

--- a/drivers/video/Makefile

+++ b/drivers/video/Makefile

@@ -174,3 +174,6 @@ obj-$(CONFIG_DISPLAY_TIMING) += display_timing.o

obj-$(CONFIG_OF_DISPLAY_TIMING) += of_display_timing.o

obj-$(CONFIG_VIDEOMODE) += videomode.o

obj-$(CONFIG_OF_VIDEOMODE) += of_videomode.o


+obj-y += fbtft/



Step 4: Rebuild kernel

Now run the rebuild script to compile the fbtft modules:

$ ./tools/rebuild.sh

+ Detected build host ["Fedora release 22 (Twenty Two)"]

+ host: [x86_64]

+ git HEAD commit: [a50680ea2cc2fc4519353dee4c1cbb47e475d8b2]



The kernel config menu should appear shortly after starting the rebuild script.  Follow these screenshots to select the fbtft drivers:





After exit the kernel config menu, the rebuild script should continue:

‘.config’ -> ‘/home/afustini/dev/bbb/bb-kernel/patches/defconfig’


make -j4 ARCH=arm LOCALVERSION=-bone79 CROSS_COMPILE="ccache /home/afustini/dev/bbb/bb-kernel/dl/gcc-linaro-arm-linux-gnueabihf-4.7-2013.04-20130415_linux/bin/arm-linux-gnueabihf-" zImage modules


scripts/kconfig/conf --silentoldconfig Kconfig


Script Complete


Verify in bb-kernel dir that fbtft modules were compiled:

$ find |grep fbtft |grep ko$







Verify in bb-kernel/deploy that kernel and tarballs were created

$ ls -ltar deploy/

-rwxrwxr-x 1 afustini afustini 5552136 Oct 31 13:01 3.8.13-bone79.zImage

-rw-rw-r-- 1 afustini afustini 110207 Oct 31 13:01 config-3.8.13-bone79

-rw-rw-r-- 1 afustini afustini 11690719 Oct 31 13:01 3.8.13-bone79-modules.tar.gz

-rw-rw-r-- 1 afustini afustini 1263879 Oct 31 13:01 3.8.13-bone79-firmware.tar.gz

-rw-rw-r-- 1 afustini afustini 39642 Oct 31 13:01 3.8.13-bone79-dtbs.tar.gz


Step 5: Install new kernel on SD Card (from Linux host)

My SD card already had been imaged with:


From within bb-kernel dir

$ sudo ./tools/install_kernel.sh

ERROR: MMC is not defined in system.sh


Edit script to specify which device is your SD card:

$ vi system.sh


Install new kernel onto microSD card:

$ sudo ./tools/install_kernel.sh


Installing 3.8.13-bone79-modules.tar.gz to /dev/sdd2

info: [3.8.13-bone79] now installed...

This script has finished...

For verification, always test this media with your end device...


Step 6: Boot new kernel

Boot BBB with the updated microSD card:

$ dmesg| head

[ 0.000000] Booting Linux on physical CPU 0x0

[ 0.000000] Initializing cgroup subsys cpu

[ 0.000000] Linux version 3.8.13-bone79 (XXXX@YYYY) (gcc version 4.7.3 20130328 (prerelease) (crosstool-NG linaro-1.13.1-4.7-2013.04-20130415 - Linaro GCC 2013.04) ) #4 SMP Sat Oct 31 13:00:55 CDT 2015


$ uname -a

Linux beaglebone 3.8.13-bone79 #4 SMP Sat Oct 31 13:00:55 CDT 2015 armv7l GNU/Linux


$ find /lib/modules/3.8.13-bone79/|grep fbtft







Edit u-boot config file uEnv.txt so the SPIDEV1 loads at boot and HDMI & eMMC are not loaded




For reference, this is my uEnv.txt


Verify that HDMI & eMMC are not loaded and SPIDEV1 is loaded:

NOTE: My BBB has no need for HDMI or eMMC. It may not be completely necessary to disable, but I did not investigated this.

$ cat /sys/devices/bone_capemgr.9/slots

0: 54:PF---

1: 55:PF---

2: 56:PF---

3: 57:PF---

4: ff:P-O-- Bone-LT-eMMC-2G,00A0,Texas Instrument,BB-BONE-EMMC-2G

5: ff:P-O-- Bone-Black-HDMI,00A0,Texas Instrument,BB-BONELT-HDMI

6: ff:P-O-- Bone-Black-HDMIN,00A0,Texas Instrument,BB-BONELT-HDMIN

7: ff:P-O-L Override Board Name,00A0,Override Manuf,BB-SPIDEV1


Step 7: Load fbtft driver & test display:

Photos of breadboard wiring using SPI1 (CS0, MOSI, SCLK), D/C, RESET.


Load fbtft st7735r driver for adafruit18 (Adafruit 1.8" TFT LCD display):

$ sudo modprobe fbtft_device busnum=1 name=adafruit18 debug=7 verbose=3 gpios=dc:48,reset:60


Console should now appear on the display. Refer to photos.


NOTE: if you have not already done, so run script to make sure all the free space on SD card can be utilized

$ sudo /opt/scripts/tools/grow_partition.sh


NOTE: apt-get may fail with warning "There is no public key available for the following key IDs". Fix by running running:

$ sudo apt-get install debian-keyring debian-archive-keyring

$ sudoe apt-get update


Display image file on the display with fbi:

$ sudo apt-get install fbi

$ wget https://kernel.org/theme/images/logos/tux.png

$ sudo fbi -d /dev/fb0 -T 1 -a tux.png

using "DejaVu Sans Mono-16", pixelsize=16.67 file=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSansMono.ttf


Play video clip on the display with mplayer:

$ sudo apt-get install mplayer

$ wget http://hubblesource.stsci.edu/sources/video/clips/details/images/hst_1.mpg

$ sudo mplayer -nolirc -vo fbdev:/dev/fb0 scale=WIDTH:128 hst_1.mpg


Kernel log with verbose debug output for adafruit18:

If using the Adafruit 2.2" TFT LCD display, then specify adafruit22a [note: the "a" suffix is important]

$ sudo modprobe fbtft_device busnum=1 name=adafruit22a debug=7 verbose=3 gpios=dc:48,reset:60


fbi and mplayer all work OK for adafruit22a.  Kernel log with verbose debug output for adafruit22a:



BeagleBone Black using Prebuilt FBTFT drivers



Step 1: Download, Flash & Boot Image


Download bone-debian-7.5-2014-05-14-2gb image:


Write image to SD card.  Here is example on my Linux laptop:

$ sudo dd if=/home/afustini/Downloads/bone-debian-7.5-2014-05-14-2gb.img of=/dev/sdc


Boot the BeagleBone with the microSD card and verify it is running Linux kernel 3.8.13-bone50:

$ cat /proc/version

Linux version 3.8.13-bone50 (root@imx6q-wandboard-2gb-0) (gcc version 4.6.3 (Debian 4.6.3-14) ) #1 SMP Tue May 13 13:24:52 UTC 2014


$ cat /etc/dogtag

BeagleBoard.org BeagleBone Debian Image 2014-05-14



Step 2: Expand SD card to ensure full capacity


Run script to grow the filesystem as root on BeagleBone:

$ sudo /opt/scripts/tools/grow_partition.sh


sfdisk: backing up partition layout.

sfdisk: initial calculation.


Disk /dev/mmcblk0: 242560 cylinders, 4 heads, 16 sectors/track

Old situation:

Units = mebibytes of 1048576 bytes, blocks of 1024 bytes, counting from 0



Re-reading the partition table ...

BLKRRPART: Device or resource busy

The command to re-read the partition table failed.

Run partprobe(8), kpartx(8) or reboot your system now,

before using mkfs

If you created or changed a DOS partition, /dev/foo7, say, then use dd(1)

to zero the first 512 bytes: dd if=/dev/zero of=/dev/foo7 bs=512 count=1

(See fdisk(8).)


Reboot the BeagleBone and verify that the root filesystem now is using the entire capacity of the the microSD card:

$ df -h

Filesystem Size Used Avail Use% Mounted on

rootfs 7.2G 1.6G 5.4G 22% /




Step 3: Install prebuilt fbtft drivers

Download the prebuilt fbtft kernel modules:

$ wget tronnes.org/downloads/fbtft-2014-02-07-3.8.13-bone50.tar.gz


Install the kernel modules:

$ sudo tar -zxPvf fbtft-2014-02-07-3.8.13-bone50.tar.gz





$ sudo depmod

Verify the modules are for 3.8.13-bone50:

$ modinfo fbtft


filename: /lib/modules/3.8.13-bone50/extra/fbtft.ko

license: GPL

srcversion: 3C6839F44999EEA4C1D8A9F


vermagic: 3.8.13-bone50 SMP mod_unload modversions ARMv7 thumb2 p2v8

parm: debug:override device debug level (ulong)

parm: dma:Use DMA buffer (bool)

Edit /boot/uboot/uEnv.txt to disable HDMI & eMMC "virtual capes" and enable SPIDEV1 "virtual cape":

$ sudo vi /boot/uboot/uEnv.txt


Uncomment this cape_disable line for HDMI & eMMC:

##BeagleBone Black:

##Disable HDMI/eMMC


Add this line to enable SPIDEV1:



Save the changes uEnv.txt & reboot the BeagleBone



Step 4: Load fbtft driver


Verify which capes are loaded:

$ cat /sys/devices/bone_capemgr.9/slots


0: 54:PF---

1: 55:PF---

2: 56:PF---

3: 57:PF---

4: ff:P-O-- Bone-LT-eMMC-2G,00A0,Texas Instrument,BB-BONE-EMMC-2G

5: ff:P-O-- Bone-Black-HDMI,00A0,Texas Instrument,BB-BONELT-HDMI

6: ff:P-O-- Bone-Black-HDMIN,00A0,Texas Instrument,BB-BONELT-HDMIN

7: ff:P-O-L Override Board Name,00A0,Override Manuf,BB-SPIDEV1

Use fbtft_device kernel module to load the fb_st7735r driver for Adafruit 1.8" TFT LCD display connected to SPI1:

$ sudo modprobe fbtft_device busnum=1 name=adafruit18 debug=7 verbose=3 gpios=dc:48,reset:60


Use fbtft_device kernel module to load the fb_ili9340 driver for Adafruit 2.2" TFT LCD display connected to SPI1:

$ sudo modprobe fbtft_device busnum=1 name=adafruit22a debug=7 verbose=3 gpios=dc:48,reset:60

NOTE: a suffix is important in adafruit22a


/dev/fb0 device should now exist:

$ ls -lsda /dev/fb*

0 crw-rw---T 1 root video 29, 0 Oct 30 06:27 /dev/fb0


The system console should now be displayed on the LCD:


More photos of fbtft working for 1.8" & 2.2" TFT LCDs


Example kernel log:

[ 181.848604] fbtft_device: SPI devices registered:

[ 181.848671] fbtft_device: spidev spi1.1 16000kHz 8 bits mode=0x00

[ 181.848705] fbtft_device: spidev spi1.0 16000kHz 8 bits mode=0x01

[ 181.848728] fbtft_device: 'fb' Platform devices registered:

[ 181.848860] fbtft_device: omapfb id=-1 pdata? yes

[ 181.849152] fbtft_device: Deleting spi1.0

[ 181.851923] fbtft_device: GPIOS used by 'adafruit22a':

[ 181.851960] fbtft_device: 'dc' = GPIO48

[ 181.851982] fbtft_device: 'reset' = GPIO60

[ 181.852002] fbtft_device: SPI devices registered:

[ 181.852033] fbtft_device: spidev spi1.1 16000kHz 8 bits mode=0x00

[ 181.852061] fbtft_device: fb_ili9340 spi1.0 32000kHz 8 bits mode=0x00

[ 182.235255] Console: switching to colour frame buffer device 60x53

[ 182.236682] graphics fb0: fb_ili9340 frame buffer, 240x320, 150 KiB video memory, 4 KiB DMA buffer memory, fps=20, spi1.0 at 32 MHz



Step 5: Display images and video


Based on FBTFT Wiki article: Framebuffer use


When using a fresh Debian image, one should first update the list of available packages before attempting to install new packages:

$ sudo apt-get update

Reading package lists... Done

W: There is no public key available for the following key IDs:


Fix public key ID warning:

$ sudo apt-get install debian-keyring debian-archive-keyring


$ sudo apt-get update

Install fbi utility to display image files on the framebuffer device:

$ sudo apt-get install fbi


$ wget https://kernel.org/theme/images/logos/tux.png


$ sudo fbi -d /dev/fb0 -T 1 -a tux.png

using "DejaVu Sans Mono-16", pixelsize=16.67 file=/usr/share/fonts/truetype/ttf-dejavu/DejaVuSansMono.ttf

Tux the Linux mascot should now be displayed on the LCD:


More photos of fbtft working for 1.8" & 2.2" TFT LCDs

Next, install mplayer to play a MPEG-2 video clip:

$ sudo apt-get install mplayer


$ wget http://hubblesource.stsci.edu/sources/video/clips/details/images/hst_1.mpg


$ sudo mplayer -nolirc -vo fbdev:/dev/fb0 scale=WIDTH:128 hst_1.mpg

MPlayer svn r34540 (Debian), built with gcc-4.6 (C) 2000-2012 MPlayer Team


Playing scale=WIDTH:128.

File not found: 'scale=WIDTH:128'

Failed to open scale=WIDTH:128.



Playing hst_1.mpg.

libavformat version 53.21.1 (external)

Mismatching header version 53.19.0

MPEG-ES file format detected.

VIDEO: MPEG1 320x240 (aspect 1) 29.970 fps 320.0 kbps (40.0 kbyte/s)

Load subtitles in ./


Opening video decoder: [ffmpeg] FFmpeg's libavcodec codec family

libavcodec version 53.35.0 (external)

Mismatching header version 53.32.2

Selected video codec: [ffmpeg1] vfm: ffmpeg (FFmpeg MPEG-1)


Audio: no sound

Starting playback...

Unsupported PixelFormat 61

Unsupported PixelFormat 53

Unsupported PixelFormat 81

Could not find matching colorspace - retrying with -vf scale...

Opening video filter: [scale]

Movie-Aspect is 1.33:1 - prescaling to correct movie aspect.

[swscaler @ 0xb670f978]No accelerated colorspace conversion found from yuv420p to rgb565le.

[swscaler @ 0xb670f978]using unscaled yuv420p -> rgb565le special converter

VO: [fbdev] 320x240 => 320x240 BGR 16-bit

framebuffer too small for double-buffering, disabling

V: 19.0 570/570 20% 65% 0.0% 0 0



Exiting... (End of file)


You should now see the video clip playing on the display:


Borissmall-tor-bbb.jpgTor logo

My Tor​ relay running on a BeagleBone Black is even faster after upgrading to Debian 8 (Jessie) and TorProject.org​ tor 0.2.6 package for Jessie:

15 - 1.jpg

Thanks to Alison Macrina of the Library Freedom Project for the motivation to upgrade after watching her inspiring talk during the Aaron Swartz's Day 2015 celebration at Internet Archive last weekend:


A quick aside, if you've not seen this documentary about Aaron's life, then please be sure to watch it:

And... thanks to Comcast.  Despite their past sins, I've been able to run a Tor exit node (e.g. exit relay) via my cable modem connection for 1.5 years with no problems.  My connect is 50 Mbps down and 10 Mbps up.


My current Tor config



Previous version

My BBB had previously been running Debian 7 (Wheezy) for which TorProject​.org package was 0.2.4.

Reduced Exit Policy

If you run a Tor exit node, then I recommend using this Reduced Exit Policy which will limit BitTorrent traffic (and thus DMCA complaints):



Debian 8 image

My BeagleBone Black is running this Debian 8.2 (Jessie) image from Robert C Nelson listed on eLinux.org:

Jessie Snapshot console

Flasher: (console) (BeagleBone Black/Green eMMC):

wget https://rcn-ee.com/rootfs/bb.org/testing/2015-11-08/console/BBB-eMMC-flasher-debian-8.2-console-armhf-2015-11-08-2gb.img.xz

sha256sum: 3c489ef2d6809a7b50396d16770752a8c067478680946428d12a747bb8c4688f


I've not posted about my Tor relay on element14 Community before, so I figure I should provide some context.


Last year I did a presentation at my hackerspace about how to run a Tor relay on a BeagleBone Black:



If that Meetup link breaks over time, then here is a GitHub Gist all my notes and links:



I was inspired to run a Tor relay after watching these talks:




Tor for users


Talks by Josh Datko about Tor & BeagleBone

How Tor works

Tor Hardware Hacking


Tor on BeagleBone blog posts:


Run a your own Tor relay!


Stats for my BeagleBone Black relay

Notes for Tor Relay running as Exit Node


Not into running a Tor relay home?

# file: /etc/tor/torrc

ORPort 443

Exitpolicy reject *:*

Nickname EFFisMyHero

ContactInfo pdp7pdp7 AT gmail dot com GPG: 0x84D44A9317F1138E

Log notice file /var/log/tor/notices.log

RelayBandwidthRate 1024 KB

RelayBandwidthBurst 1024 KB

MaxAdvertisedBandwidth 1024 KB

DisableDebuggerAttachment 0

Stats for my EFFisMyHero relay on DigitalOcean:


Not into running your own Tor relay?

In some previous posts, I first set up Bluetooth on the Beaglebone Black and then set up Node-Red to convert the Bluetooth data to MQTT messages. In this third post, I'll be using OpenHAB to receive the MQTT messages, process them and use them for notifications, trending, etc ...






The installation of Java and OpenHAB is already covered in detail in one of my posts here on element14. The post can be found here: [AirCare] InTheAir - Week 5: openHAB and MQTT

In order to use OpenHAB with the SensorTag, different items, sitemap, rules, etc ... will be created though. You'll find them in the next paragraphs.






From Node-RED, all data is being published to the same topic, so in OpenHAB a master item has been defined to subscribe to the appropriate topic.

Other items have been defined in addition to the master item. They will be assigned with values parsed from the master item, categorising the data in different types such as temperature, humidity, buttons, etc ...


The items file contains the following:


debian@beaglebone:~$ cat /opt/openhab/configurations/items/sensortag.items

Group All

String SensorTag "SensorTag Raw Data [%s]" <sensortag> (All) {mqtt="<[eclipseIot:fvan-sensortag:state:default]"}

Number SensorTag_Temperature_Ambient "SensorTag Ambient Temperature [%.1f °C]" <sensortag> (All)
String SensorTag_Temperature_Object "SensorTag Object Temperature [%s °C]" <sensortag> (All)
String SensorTag_Humidity "SensorTag Humidity [%s %%RH]" <sensortag> (All)
String SensorTag_Pressure "SensorTag Pressure [%s hPa]" <sensortag> (All)
String SensorTag_Keys_1 "SensorTag Key #1 [MAP(bool.map):%s]" <sensortag> (All)
String SensorTag_Keys_2 "SensorTag Key #2 [MAP(bool.map):%s]" <sensortag> (All)

Number Chart_Period "Chart Period"


The screenshot below demonstrates the initial tests, comparing Node-RED's output to OpenHAB's input. A limiter was set in place to prevent flooding of data, limiting to 6 messages per minute per sensor used.

Screen Shot 2015-07-17 at 21.14.59.png




The sitemaps file is used to arrange the different items visually, in certain (sub)categories, even including charts. In this example, a chart has been defined for the ambient temperature item, with three possible display periods: hour, day, week.


debian@beaglebone:~$ cat /opt/openhab/configurations/sitemaps/sensortag.sitemap

sitemap sensortag label="SensorTag" {
        Frame {
                Text item=SensorTag
        Frame {
                Text item=SensorTag_Temperature_Ambient {
                        Frame {
                                Text item=SensorTag_Temperature_Ambient
                        Frame {
                                Switch item=Chart_Period label="Chart Period" mappings=[0="Hour", 1="Day", 2="Week"]
                                Chart item=SensorTag_Temperature_Ambient period=h refresh=10000 visibility=[Chart_Period==0, Chart_Period=="Uninitialized"]
                                Chart item=SensorTag_Temperature_Ambient period=D refresh=10000 visibility=[Chart_Period==1]
                                Chart item=SensorTag_Temperature_Ambient period=W refresh=10000 visibility=[Chart_Period==2]
                Text item=SensorTag_Temperature_Object
                Text item=SensorTag_Pressure
                Text item=SensorTag_Humidity
                Text item=SensorTag_Keys_1
                Text item=SensorTag_Keys_2


The result is the following:

Screen Shot 2015-07-20 at 11.14.40.png




Rules can be used to trigger actions based on certain events. In this particular case, two rules have been defined:

  • Categorise data
  • Temperature alarm


The first rule is triggered when the master item defined in the items file is updated to a new value. The rule then parses the content in order to categorise it and assign the contents to the item representing the correct sensor. Using some simple string operations, the useful content is extracted from the incoming data.


The second rule demonstrates the use of notifications using Prowl. For testing purposes, I have a notification triggered when the temperature is lower than 50°C. Obviously, this would need to be set to more realistic values, but it is a quick way of verifying the notification mechanism works.


To know more about notifications in OpenHAB using Prowl, be sure to check out the following post: http://www.element14.com/community/community/design-challenges/forget-me-not/blog/2014/10/20/cats-forgetmenot--final#jiv…


debian@beaglebone:~$ cat /opt/openhab/configurations/rules/sensortag.rules

import org.openhab.core.library.types.*
import org.openhab.core.persistence.*
import org.openhab.model.script.actions.*
import java.lang.Math
import java.lang.Double
import java.lang.String

var Timer temperature_alarm = null

rule "Categorise data"
        Item SensorTag changed
        var state = SensorTag.state.toString()
        var output = ""

        if(state.contains("ambient")) {
                output = state.substring(state.indexOf('"ambient":')+10,state.indexOf('}'))

                output = state.substring(state.indexOf('"object":')+9,state.indexOf(','))
        else if(state.contains("pressure")) {
                output = state.substring(state.indexOf(':')+1,state.indexOf('}'))
        else if(state.contains("humidity")) {
                output = state.substring(state.indexOf('"humidity":')+11,state.indexOf('}'))
        else if(state.contains("right")) {
                output = state.substring(state.indexOf('"right":')+8,state.indexOf('}'))

                output = state.substring(state.indexOf('"left":')+7,state.indexOf(','))

rule "Temperature alarm"
        Item SensorTag_Temperature_Ambient changed
        var state = SensorTag_Temperature_Ambient.state as DecimalType

        if(state < 50.0) {
                if(temperature_alarm == null) {
                        pushNotification("<api key>","Ambient temperature", "too low: " + state)
                        temperature_alarm = createTimer(now.plusMinutes(1)) [|
                                temperature_alarm = null


Here's a screenshot demonstrating the data being categorised properly:

Screen Shot 2015-09-12 at 12.42.15.png


And some screenshot of the notifications being received on my phone:





It is also possible to transform the data in the visualisation layer of OpenHAB. For example, the buttons return a true/false state. More meaningful would be to have the state reported as pressed or released.

By creating a bool.map file in the transform folder and reference it in the items file, this can be done quickly. The file contains one translation per line. In the GUI, "true" will be replaced by "pressed" and "false" by "released". The "-=-" is there to avoid OpenHAB reporting translation errors when no data has been received yet.


debian@beaglebone:~$ cat /opt/openhab/configurations/transform/bool.map





Finally, persistence is what defines which data to store and with which type of storage (MySQL, RRD4J, ...). Persistence is required when using charts.


debian@beaglebone:~$ cat /opt/openhab/configurations/persistence/rrd4j.persist

Strategies {
        everyMinute : "0 * * * * ?"
        everyHour : "0 0 * * * ?"
        everyDay : "0 0 0 * * ?"

        default = everyChange

Items {
        * : strategy = everyChange, everyMinute, restoreOnStartup





This concludes this short series of post on how to retrieve data from a SensorTag via Bluetooth, convert it to MQTT using Node-RED and persist/monitor/trend it using OpenHAB.

This week's embedded.fm episode features Jason of BB:


110: Happiness Is a Warm Puppy — Embedded

In my previous post, I was able to retrieve data from the SensorTag 2.0 on the Beaglebone Black using command line tools such as "hcitool" and "gatttool". For this post, I'll be setting up Node-RED to collect the SensorTag data automatically and make it available for other applications to process or store.




What is Node-RED? Node-RED is a tool used to wire together different devices, APIs or online service in a visual way. The website is located at http://nodered.org/and contains a wealth of information on how to install and use Node-RED on different operating systems and devices.

Install Node-RED


Node-RED requires Node.js to be installed. Fortunately for me, this is the case by default on the Beaglebone Black. Just to be sure, I tried to install Node.js using "apt-get".


debian@beaglebone:~$ sudo apt-get install nodejs
Reading package lists... Done
Building dependency tree
Reading state information... Done
nodejs is already the newest version.
nodejs set to manually installed.
0 upgraded, 0 newly installed, 0 to remove and 0 not upgraded.


As expected, Node.js is already installed and is even reported to be at the latest version. Installing Node-RED is very easy and only takes a couple of minutes. The command can be found on the Node-RED website: http://nodered.org/docs/getting-started/installation.html


debian@beaglebone:~$ sudo npm install -g --unsafe-perm node-red


Once installed, Node-RED can be run using the "node-red-pi" command. This will start the application, which can then be accessed using a webbrowser at http://device_ip:1880/.


debian@beaglebone:~$ node-red-pi

Welcome to Node-RED

15 Jul 19:45:03 - [info] Node-RED version: v0.11.1
15 Jul 19:45:03 - [info] Node.js version: v0.10.25
15 Jul 19:45:03 - [info] Loading palette nodes
15 Jul 19:45:12 - [warn] ------------------------------------------
15 Jul 19:45:12 - [warn] Failed to register 1 node type
15 Jul 19:45:12 - [warn] Run with -v for details
15 Jul 19:45:12 - [warn] ------------------------------------------
15 Jul 19:45:12 - [info] Settings file : /usr/local/lib/node_modules/node-red/settings.js
15 Jul 19:45:12 - [info] User directory : /home/debian/.node-red
15 Jul 19:45:12 - [info] Flows file : /home/debian/.node-red/flows_beaglebone.json
15 Jul 19:45:13 - [info] Server now running at
15 Jul 19:45:13 - [info] Creating new flow file
15 Jul 19:45:13 - [info] Starting flows
15 Jul 19:45:13 - [info] Started flows


Screen Shot 2015-07-15 at 19.45.55.png


Install node-sensortag


In order to have support for the TI SensorTag in Node-RED, a new node needs to be installed. Before being able to install it though, it is required to have the bluetooth development files installed first.

More information on the SensorTag node can be found on its GitHub page: https://github.com/sandeepmistry/node-sensortag.


debian@beaglebone:~/.node-red$ sudo apt-get install libbluetooth-dev


Once done, it should be possible to install the SensorTag node without issues.


debian@beaglebone:~$ cd ~/.node-red
debian@beaglebone:~/.node-red$ sudo npm install sensortag


When that is installed, Node-RED has to be run as "root" or with "sudo"in order to access the Bluetooth system calls. And because Node-RED is run as a different user, it is recommended to specify the path to the user directory where the SensorTag node was installed.


debian@beaglebone:~$ sudo node-red-pi -u /home/debian/.node-red/

Welcome to Node-RED

15 Jul 20:14:27 - [info] Node-RED version: v0.11.1
15 Jul 20:14:27 - [info] Node.js version: v0.10.25
15 Jul 20:14:27 - [info] Loading palette nodes
15 Jul 20:14:37 - [warn] ------------------------------------------
15 Jul 20:14:37 - [warn] Failed to register 1 node type
15 Jul 20:14:37 - [warn] Run with -v for details
15 Jul 20:14:37 - [warn] ------------------------------------------
15 Jul 20:14:37 - [info] Settings file : /usr/local/lib/node_modules/node-red/settings.js
15 Jul 20:14:37 - [info] User directory : /home/debian/.node-red
15 Jul 20:14:37 - [info] Flows file : /home/debian/.node-red/flows_beaglebone.json
15 Jul 20:14:37 - [info] Server now running at
15 Jul 20:14:37 - [info] Creating new flow file
15 Jul 20:14:38 - [info] Starting flows
15 Jul 20:14:38 - [info] Started flows


The SensorTag node should be available in the Node-RED GUI.

Screen Shot 2015-07-15 at 20.15.18.png



As a first test, I connected the SensorTag node directly to a debug output. This allowed me to confirm the Bluetooth connection between the SensorTag and the Beaglebone Black was properly set up without any manual intervention and that Node-RED was able to capture the data.


Screen Shot 2015-07-15 at 20.48.38.pngScreen Shot 2015-07-15 at 20.57.09.png


I started with a few parameters, tested a bit, and then enabled the others. As you may be able to see from the screenshots above, all that was required to set it up was to:

  • drag the necessary nodes in the sheet, in this case: sensortag & debug
  • enter the MAC address of the sensortag
  • select which parameters to report on
  • press the "deploy" button in the top right corner


It doesn't get any more simple than this! You can see the debug data in the column on the right.


After a successful first test, I added a second, more useful output: MQTT. This allows me to publish the SensorTag data to a MQTT broker and topic of my choice. Adding the MQTT output is simple:

  • drag the MQTT node in the sheet
  • connect it to the SensorTag node
  • configure a broker and topic
  • deploy

Screen Shot 2015-07-16 at 19.47.13.pngScreen Shot 2015-07-16 at 20.10.39.png

Using MQTTLens, I was able to subscribe to the topic and visualise the published data. It works! This is of course only a very simple example meant to demonstrate some basic features, and does not take any security into account, as all the data is just published on the internet for anyone to see. So keep that in mind if you plan to try this out.

In my next post, I'll be collecting the data to build historical data that can be used for trending, processing, ... Until then!

This post is part of my RoadTest review for the TI CC2650STK SimpleLink IoT SensorTag. As I plan to use the BeagleBone Black for data collection, I thought I'd blog about how to get BLE to work on it first.

photo (22).JPGphoto+1.JPG

Here we go ...


Preparing the BBB


Before we jump to setting up BLE on the BBB, we require an operational BBB with internet connection. The full setup of the BBB using Debian can be found in one of my earlier posts: [AirCare] InTheAir - Week 2: Preparing the Beaglebone Black


It covers the following topics:

  • preparing the SD card with Debian
  • expanding the filesystem, making use of the full SD card's available space
  • setting up network connectivity using wifi
  • connect a touchscreen display


Setting up Bluetooth




I hadn't use my BBB for a while before setting up the bluetooth, so the first thing I did was to update the software.


debian@beaglebone:~$ sudo apt-get update
debian@beaglebone:~$ sudo apt-get upgrade




Once the BBB's software was up-to-date, I installed the bluetooth software.


debian@beaglebone:~$ sudo apt-get install bluetooth


This resulted in a lot of packages being installed, for a total of 144MB of additional disk space.


The following extra packages will be installed:
  bc bluez bluez-alsa bluez-cups bluez-gstreamer cups cups-client cups-common cups-filters cups-ppdc dc fonts-droid fonts-freefont-ttf foomatic-db-compressed-ppds foomatic-db-engine foomatic-filters ghostscript ghostscript-cups hpijs hplip hplip-data libart-2.0-2
  libcupscgi1 libcupsdriver1 libcupsfilters1 libcupsimage2 libcupsmime1 libcupsppdc1 libescpr1 libgs9 libgs9-common libgutenprint2 libhpmud0 libijs-0.35 libjbig2dec0 liblcms1 libpaper-utils libpaper1 libpoppler19 libsane-hpaio libsensors4 libslp1 libsnmp-base libsnmp15
  mscompress poppler-data poppler-utils printer-driver-all printer-driver-c2050 printer-driver-c2esp printer-driver-cjet printer-driver-escpr printer-driver-foo2zjs printer-driver-gutenprint printer-driver-hpcups printer-driver-hpijs printer-driver-m2300w
  printer-driver-min12xxw printer-driver-pnm2ppa printer-driver-postscript-hp printer-driver-ptouch printer-driver-pxljr printer-driver-sag-gdi printer-driver-splix python-imaging python-pexpect python-renderpm python-reportlab python-reportlab-accel samba-common
  samba-common-bin smbclient ttf-freefont
Suggested packages:
  cups-bsd cups-pdf xpp hplip-cups openprinting-ppds cjet foomatic-db-gutenprint ghostscript-x hplip-gui hplip-doc system-config-printer gutenprint-locales liblcms-utils lm-sensors slpd openslp-doc snmp-mibs-downloader fonts-japanese-mincho fonts-ipafont-mincho
  fonts-japanese-gothic fonts-ipafont-gothic fonts-arphic-ukai fonts-arphic-uming fonts-unfonts-core psutils hannah-foo2zjs tk8.4 tix gutenprint-doc hpijs-ppds magicfilter apsfilter python-imaging-doc python-imaging-dbg python-renderpm-dbg pdf-viewer
  python-egenix-mxtexttools python-reportlab-doc cifs-utils
Recommended packages:
The following NEW packages will be installed:
  bc bluetooth bluez bluez-alsa bluez-cups bluez-gstreamer cups cups-client cups-common cups-filters cups-ppdc dc fonts-droid fonts-freefont-ttf foomatic-db-compressed-ppds foomatic-db-engine foomatic-filters ghostscript ghostscript-cups hpijs hplip hplip-data
  libart-2.0-2 libcupscgi1 libcupsdriver1 libcupsfilters1 libcupsimage2 libcupsmime1 libcupsppdc1 libescpr1 libgs9 libgs9-common libgutenprint2 libhpmud0 libijs-0.35 libjbig2dec0 liblcms1 libpaper-utils libpaper1 libpoppler19 libsane-hpaio libsensors4 libslp1
  libsnmp-base libsnmp15 mscompress poppler-data poppler-utils printer-driver-all printer-driver-c2050 printer-driver-c2esp printer-driver-cjet printer-driver-escpr printer-driver-foo2zjs printer-driver-gutenprint printer-driver-hpcups printer-driver-hpijs
  printer-driver-m2300w printer-driver-min12xxw printer-driver-pnm2ppa printer-driver-postscript-hp printer-driver-ptouch printer-driver-pxljr printer-driver-sag-gdi printer-driver-splix python-imaging python-pexpect python-renderpm python-reportlab
  python-reportlab-accel samba-common samba-common-bin smbclient ttf-freefont
0 upgraded, 74 newly installed, 0 to remove and 0 not upgraded.
Need to get 47.8 MB of archives.
After this operation, 144 MB of additional disk space will be used.
Do you want to continue [Y/n]? y




I got myself a cheap BT dongle from Trust, paying special attention to support for Bluetooth 4.0 (BLE).

photo (21).JPG


Plugged in the dongle in the BBB's USB port and check if the device was detected properly. If you have more than one USB device to connect, you may need a powered USB HUB to connect them all simultaneously.


debian@beaglebone:~$ lsusb
Bus 001 Device 003: ID 0a12:0001 Cambridge Silicon Radio, Ltd Bluetooth Dongle (HCI mode)
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub




With the software installed and the dongle plugged it, it's time to look at the software tools used to get some data from the SensorTag.




hcitool is used to configure Bluetooth connections and send some special command to Bluetooth devices.


First, check hcitool detects your bluetooth dongle.


debian@beaglebone:~$ sudo hcitool dev
  hci0 00:1A:7D:DA:71:0F


Perform a scan to find out the SensorTag's address.


debian@beaglebone:~$ sudo hcitool lescan
LE Scan ...
B0:B4:48:B8:23:01 (unknown)
B0:B4:48:B8:23:01 CC2650 SensorTag


Create connection to SensorTag, using previously scanned address.


debian@beaglebone:~$ sudo hcitool lecc B0:B4:48:B8:23:01
Connection handle 69




gatttool is a tool used to interact with BLE devices.


Use gatttool in interactive mode to send commands to the previously scanned address.


debian@beaglebone:~$ sudo gatttool -b B0:B4:48:B8:23:01 -I
[  ][B0:B4:48:B8:23:01][LE]>


Connect to the SensorTag, notice how the prefix changes from "[  ]" to "[CON]".


[  ][B0:B4:48:B8:23:01][LE]> connect


Request the characteristics of the device.


[CON][B0:B4:48:B8:23:01][LE]> characteristics
handle: 0x0002, char properties: 0x02, char value handle: 0x0003, uuid: 00002a00-0000-1000-8000-00805f9b34fb
handle: 0x0004, char properties: 0x02, char value handle: 0x0005, uuid: 00002a01-0000-1000-8000-00805f9b34fb
handle: 0x0006, char properties: 0x02, char value handle: 0x0007, uuid: 00002a04-0000-1000-8000-00805f9b34fb
handle: 0x0009, char properties: 0x20, char value handle: 0x000a, uuid: 00002a05-0000-1000-8000-00805f9b34fb
handle: 0x000d, char properties: 0x02, char value handle: 0x000e, uuid: 00002a23-0000-1000-8000-00805f9b34fb
handle: 0x000f, char properties: 0x02, char value handle: 0x0010, uuid: 00002a24-0000-1000-8000-00805f9b34fb
handle: 0x0011, char properties: 0x02, char value handle: 0x0012, uuid: 00002a25-0000-1000-8000-00805f9b34fb
handle: 0x0013, char properties: 0x02, char value handle: 0x0014, uuid: 00002a26-0000-1000-8000-00805f9b34fb
handle: 0x0015, char properties: 0x02, char value handle: 0x0016, uuid: 00002a27-0000-1000-8000-00805f9b34fb
handle: 0x0017, char properties: 0x02, char value handle: 0x0018, uuid: 00002a28-0000-1000-8000-00805f9b34fb
handle: 0x0019, char properties: 0x02, char value handle: 0x001a, uuid: 00002a29-0000-1000-8000-00805f9b34fb
handle: 0x001b, char properties: 0x02, char value handle: 0x001c, uuid: 00002a2a-0000-1000-8000-00805f9b34fb
handle: 0x001d, char properties: 0x02, char value handle: 0x001e, uuid: 00002a50-0000-1000-8000-00805f9b34fb
handle: 0x0020, char properties: 0x12, char value handle: 0x0021, uuid: f000aa01-0451-4000-b000-000000000000
handle: 0x0023, char properties: 0x0a, char value handle: 0x0024, uuid: f000aa02-0451-4000-b000-000000000000
handle: 0x0025, char properties: 0x0a, char value handle: 0x0026, uuid: f000aa03-0451-4000-b000-000000000000
handle: 0x0028, char properties: 0x12, char value handle: 0x0029, uuid: f000aa21-0451-4000-b000-000000000000
handle: 0x002b, char properties: 0x0a, char value handle: 0x002c, uuid: f000aa22-0451-4000-b000-000000000000
handle: 0x002d, char properties: 0x0a, char value handle: 0x002e, uuid: f000aa23-0451-4000-b000-000000000000
handle: 0x0030, char properties: 0x12, char value handle: 0x0031, uuid: f000aa41-0451-4000-b000-000000000000
handle: 0x0033, char properties: 0x0a, char value handle: 0x0034, uuid: f000aa42-0451-4000-b000-000000000000
handle: 0x0035, char properties: 0x0a, char value handle: 0x0036, uuid: f000aa44-0451-4000-b000-000000000000
handle: 0x0038, char properties: 0x12, char value handle: 0x0039, uuid: f000aa81-0451-4000-b000-000000000000
handle: 0x003b, char properties: 0x0a, char value handle: 0x003c, uuid: f000aa82-0451-4000-b000-000000000000
handle: 0x003d, char properties: 0x0a, char value handle: 0x003e, uuid: f000aa83-0451-4000-b000-000000000000
handle: 0x0040, char properties: 0x12, char value handle: 0x0041, uuid: f000aa71-0451-4000-b000-000000000000
handle: 0x0043, char properties: 0x0a, char value handle: 0x0044, uuid: f000aa72-0451-4000-b000-000000000000
handle: 0x0045, char properties: 0x0a, char value handle: 0x0046, uuid: f000aa73-0451-4000-b000-000000000000
handle: 0x0048, char properties: 0x10, char value handle: 0x0049, uuid: 0000ffe1-0000-1000-8000-00805f9b34fb
handle: 0x004d, char properties: 0x0a, char value handle: 0x004e, uuid: f000aa65-0451-4000-b000-000000000000
handle: 0x004f, char properties: 0x0a, char value handle: 0x0050, uuid: f000aa66-0451-4000-b000-000000000000
handle: 0x0052, char properties: 0x1a, char value handle: 0x0053, uuid: f000ac01-0451-4000-b000-000000000000
handle: 0x0055, char properties: 0x0a, char value handle: 0x0056, uuid: f000ac02-0451-4000-b000-000000000000
handle: 0x0057, char properties: 0x0a, char value handle: 0x0058, uuid: f000ac03-0451-4000-b000-000000000000
handle: 0x005a, char properties: 0x12, char value handle: 0x005b, uuid: f000ccc1-0451-4000-b000-000000000000
handle: 0x005d, char properties: 0x08, char value handle: 0x005e, uuid: f000ccc2-0451-4000-b000-000000000000
handle: 0x005f, char properties: 0x08, char value handle: 0x0060, uuid: f000ccc3-0451-4000-b000-000000000000
handle: 0x0062, char properties: 0x1c, char value handle: 0x0063, uuid: f000ffc1-0451-4000-b000-000000000000
handle: 0x0066, char properties: 0x1c, char value handle: 0x0067, uuid: f000ffc2-0451-4000-b000-000000000000


Request the device name using the proper characteristic, by handle.


[CON][B0:B4:48:B8:23:01][LE]> char-read-hnd 0x3
Characteristic value/descriptor: 53 65 6e 73 6f 72 54 61 67 20 32 2e 30


The response is hexadecimal. To make it human readable, it needs to be converted to ASCII. This can be done using some command line magic.


debian@beaglebone:~$ echo -e $(echo -e " 53 65 6e 73 6f 72 54 61 67 20 32 2e 30" | sed 's/ /\\x/g') | awk '{printf "%s\n", $_}'
SensorTag 2.0


(The above command is probably far too complicated for what I'm trying to achieve, so if any command line wizard is reading this, please help improve my magic ...)


Or using Python for example.


debian@beaglebone:~$ python
Python 2.7.3 (default, Mar 14 2014, 17:55:54)
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> "53656e736f7254616720322e30".decode("hex")
'SensorTag 2.0'




There you have it, BLE on the BBB. I was able to connect to the SensorTag and retrieve it's name. Once I've identified the other characteristics, I'll be able to take in the data I want and keep a history of it.

Gorgeous black solder mask!

I have always wanted to get my hands on a BeagleBoneBlackBeagleBoneBlack (BBB), and it seems that I chose the right time to do so. It hasn't been long now since the new spin of the BeagleBoneBlack started shipping with Debian pre-installed onto the board's permanent eMMC storage. This was enabled through the upgrade in size, from 2GB to the current 4GB, of the on-board flash, which was done for a couple of reasons: first of all, 2GB isn't that much space. The Raspberry PiRaspberry Pi recommends at least a 4GB SD card, by comparison. Also, the supply of the 2GB eMMC chips was starting to fade – 4GB being the lowest offering currently, so the move was done to maintain supply as well. Remember, though, that storage is not an issue – you can add a 64GB SD card if you wanted! It's mostly the access time that is the major difference.


Originally, as many BBB owners will know, the BBB used a distribution of Linux known as Angstrom Linux – so named because of its small size and fast booting. A perfect match, it would seem, for a small single-board computer. However, with a large number of the maker community using Raspberry Pi, and having the Raspbian spin of Debian available, many felt underwhelmed by the default settings and GUI of Angstrom after picking up a BBB.


As soon as the Rev C version of the BBB became available, sales went through the roof – as many will remember, during parts of 2014 it was almost impossible to buy one. This was largely due to the fact that it now had enough space for the pre-installed Debian, plus the increased processor speed and RAM. The huge, dual 46-pin headers helped, too – compared to other single-board computers this size, it's hard to believe that you can have this many pins brought out for user applications!


Upon opening the box, I was immediately impressed with the board. I must admit, I'm a bit of a TI fanboy, so that helped – but the black solder mask and the rounded corners made it look sleek and sexy. I eagerly fired it up, and was impressed with the boot time into Debian – one of the effects of having the OS in eMMC memory. Everything just worked out of the box – SSH was set up, plugging the USB into my laptop revealed a serial terminal, a built-in web server (which we'll talk about in a bit!) and an emulated USB flash drive! Clearly this was designed with development in mind. Having a serial terminal over USB is a great move – though there is a serial header on board, you don't even need to use it! This can make a big difference in the ease of troubleshooting and/or development. If SSH is not an option, plugging it into USB means you can work on the board with literally no other connections – no monitor, keyboard, DC input, Wi-Fi, Ethernet, nothing. Just a single USB cable. Now that is how it should be done! This is even more critical as there is only one USB host port, meaning to have more than just a keyboard plugged in you need a USB hub. For most developers this isn't an issue, but it's annoying to Check out the huge headers!have this extra box hanging off of the board. I've found the best way to work with the BBB is to have it plugged into a laptop, with an Ethernet cable for internet access (if you have a cable nearby – otherwise, you can use the empty USB port for Wi-Fi!).


Now, the real question today is what the differences are between Angstrom Linux and Debian. For those familiar with Linux and its varieties, you'll know that Debian is one of the big names. With a huge user base and many excellent developers (not to mention being the distro that Ubuntu is based on!) Debian provides a smooth experience, with a wide choice of desktop environments to choose from and an enormous package repository. This is a plus for developers as your favourite IDE and compiler are likely available (in my case, Code::Blocks was, of course, immediately installable). However, the flair and large package assortment is also the weakness on a platform like the BBB. Remember that this is just a small ARMsmall ARM processor with 512MB of RAM. Though overall responsiveness is acceptable, there are times when the processor gets bogged down which make it feel completely sluggish and unusable. This is part of the reason I wanted to compare it to Angstrom. From what I'd heard, Angstrom was a much more bare-bones, stripped-down distro aimed at lightweight computing and development. It seems on paper like a much better choice for writing code and doing embedded development.


So it was off to the BeagleBone website to try and find the Angstrom flasher – I wanted to install Angstrom to the eMMC to have a fair comparison against Debian. As the BBB has now completely switched to Debian, the Angstrom images are listed under “Older Images”. I noticed there were both SD card and eMMC flasher versions. I downloaded the flasher version, and burned it to a freshly formatted SD card. Flashing the BBB (or even booting from the SD card) is supposed to be very simple – insert the SD card, remove power, hold down the BOOT button (S2, down by the SD card slot), and then power up the board while continuing to hold the BOOT button. If you're flashing Debian to the eMMC, you'll be rewarded by the LEDs flashing in a back-and-forth pattern. Once the process starts, it can take anywhere from 15 to 45 minutes to write the flash. However, be warned – when flashing Angstrom, there are no such LED indications to let you know you're on the right track. It actually boots into Angstrom while it flashes! This really confused me, and so I spent ages unplugging and replugging the power, holding down the BOOT button for as many different lengths of time as seemed reasonable, and formatting/re-burning the SD card five or six times. I even found two different versions of the eMMC burner, dated a few months apart in 2013. Eventually, I just left it running overnight at the command prompt, and when I tried to boot back into Debian the next morning, it booted into Angstrom without the SD card! So, clearly it had worked. You just need to be aware of how the burning process works!

Get hacking!


The first thing I noticed after booting into Angstrom is that it uses a non-standard package manager. As a long-time Linux user, I feel comfortable using pacman, yum, apt-get, even the lower-level stuff like RPM and DPKG. However, Angstrom uses opkg, a manager I hadn't heard of but seems to accept similar commands to yum and apt-get – things like opkg install, opkg update and opkg upgrade worked flawlessly. I highly recommend running those last two (update and upgrade) out of the box, as it seems there are a large number of updates not included in the last release available on the BeagleBone website.


To do our comparison testing, I'm going to be using a piece of software called the Phoronix Test Suite. This is an open software benchmarking application which is cross-platform and freely available! It also has a companion site called openbenchmarking.org which contains tons of pre-written tests that you can execute directly from the command line. Today, we'll be using two tests, one to test the hardware, and one to test the system. To test the hardware, we run a series of compression tests, which will stress the processor and give us a baseline. We shouldn't see too much of a difference, but the OS does indeed schedule tasks and give priority, so this will also test the system a bit as well. For the system testing, we'll encode audio in a variety of formats – this will also stress the processor, but according to what I've read it seems to be more of a system stress test as it really pushes the OS to see how well it manages tasks. For whatever reason, some of the tests wouldn't run on Debian, and some wouldn't run on Angstrom – I've marked these with DNR. This is almost certainly just a compatibility problem, as these tests were designed for full-size systems, in most cases. I've included the results of the same tests done on a Raspberry Pi Model B+ overclocked to 900MHz. This isn't a wholly fair comparison, but should give readers familiar with the Pi a sort of baseline with which to compare.


As you can see, the results are slightly mixed. Angstrom performed much better on the compression tests, but falls short on FLAC and MP3 encoding. I can't say this is exactly what I expected, although without knowing more about how the kernel is compiled for each distribution, my only theory is that Debian generally has more focus on multimedia applications, which gives it the slight edge in audio encoding. Angstrom is much lighter, which probably explains the compression test results being so varied.


Now that the BeagleBoneBlack comes pre-installed with Debian, I imagine that the vast majority of users will stick with it. However, after using both, I've started to take a liking to Angstrom. On some tasks it feels much snappier and responsive, though Debian's wider software support is also a plus. Angstrom's smaller installation size, the original reason the BBB developers chose it in the first place, is another plus if size becomes an issue. The older BBB revisions, will, of course, have to stay with Angstrom on the eMMC as they cannot hold Debian. You can still boot and run Debian from an SD card, so that option is there as well, though of course the performance won't be as good. My recommendation, especially to newer users, would be to stick with Debian unless you have a good reason to switch.


However, the real shocker was how poorly the Raspberry Pi performed in some categories! While it performed better at encoding FLAC and MP3, it fell apart in the compression category, with the exception of 7-Zip compression. I was really surprised that the LZMA compression was almost 400 seconds longer than the BBB with Angstrom! However, as I mentioned earlier, these two boards are for very different purposes, which is actually revealed through these tests. The Raspberry Pi is optimized for multimedia and GUI interaction, whereas the BBB is optimized for embedded software and hardware development. This is shown by the huge GPIO headers on the BeagleBoneBlack – 80 pins in total to the RPi's 40 on the B+ and only 26 on the original models.

Beautiful layout!


Whichever board you end up choosing, there are vast amounts of cool hardware add-ons and thousands of software libraries and tutorials available online. I highly recommend checking out both boards if you have the chance – you'll see that they fit their categories exceptionally well. The BeagleBoneBlack is the sort of device I would put into an autonomous robot. The Raspberry Pi could also be used, but the advantage of the huge GPIO and multiple hardware protocols is evident in such an application. The Raspberry Pi is the board of choice for projects like the Super Pi Boy – building a Pi into a Game Boy case, with an upgraded colour LCD and an SD card full of emulated games! The Pi's excellent multimedia support, coupled with the good support for touchscreens and LCDs, really shines through in such an application.


Thanks for reading, and stick around for more projects in the near future! Let me know below what projects you've used these boards for, and what your pros and cons for each would be.


All test results are measured in seconds!


BeagleBoneBlack with Debian









7-Zip Compress







Parallel BZIP2







GZIP Compress







LZMA Compress













































BeagleBoneBlack with Angstrom









7-Zip Compress







Parallel BZIP2







GZIP Compress







LZMA Compress














































Raspberry Pi Model B+ with Debian

Overclocked to 900MHz









7-Zip Compress







Parallel BZIP2







GZIP Compress







LZMA Compress













































Video Overview:


Flashing the BBB:

NASA Jet Propulsion Laboratory prototyped a new rover design with the BeagleBone Black!


"Testing a Space Rover Under Alaskan Ice"



Here's a screenshot of the BeagleBone:

Screenshot from 2015-06-15 16:40:18.png

Fixing the problems with the BBView and the latest Beaglebone Debian image.


So since the new Debian update for the Beaglebone some problems have surfaced with using the BBView. Here I hope to help people fix those errors and get full use of their BBView.


Not many steps, and it is very easy to do.


     1.    Firstly we need to download the newest Debian Image from Here http://beagleboard.org/latest-images

          Make sure you download the latest SD image (to boot from SD) or the flasher image (to reflash the EMMC with the new image)


     2.    Flash the image onto the SD card using your preferred means, dd command in linux /  win32DiskImager in windows are my preferred means.



     3.     Connect a an HDMI screen and keyboard, or or a TTL serial cable to the Beaglebone. If using the TTL cable you will also need a computer running a serial terminal program                (eg putty for windows)



     4.    Boot the Beaglebone Black from the new microSD card.

              Insert the microSD card.

               This will either boot the board from the microSD, or flash the new image onto the EMMC if you are using the flasher (This could take a while if using the flasher image)



     5.    When the board is booted, login using the username:root and password:debian



     6.     You will need some files to change the display output these files can be downloaded from HERE for Debian. Or from here.

               Just extract the downloaded zip file onto a USB stick and plug this into your Beaglebone Black



     7.    Now we need to change a few of the files to get the BBView to work

              In the terminal type....

root@beaglebone:~# mkdir /media/udisk
root@beaglebone:~# mount /dev/sda1 /media/udisk
root@beaglebone:~# cp -f /media/udisk/zImage /boot/vmlinuz-3.8.13-bone70 
root@beaglebone:~# cp -f /media/udisk/*.dtb  /boot/dtbs/3.8.13-bone70 
root@beaglebone:~# tar -xvf /media/udisk/kernel_modules.tar.gz -C /
root@beaglebone:~# cp -f /media/udisk/xorg.conf /etc/X11/
root@beaglebone:~# sync




root@beaglebone:~# cd /boot/dtbs/3.8.13-bone70
root@beaglebone:~# cp am335x-boneblack-lcd4.dtb am335x-boneblack.dtb
root@beaglebone:~# sync




root@beaglebone:~# cd /boot/dtbs/3.8.13-bone70
root@beaglebone:~# cp am335x-boneblack-lcd7.dtb am335x-boneblack.dtb
root@beaglebone:~# sync



     7.     Now shutdown your board. Connect your BBView and power it back up again.


Your BBView should now work as a screen for your Beaglebone Black. Have fun.


Make your own BeagleBot

Posted by callum.ds May 15, 2015

The BeagleBot


How to make your own Beaglebone black bot that you can control over WiFi.


So I've just done a project with the Beaglebone Black and I've managed to make a little robot car that can be controlled via WiFi from any browser on the same network.

Sounds cool, and it kind of is, but there's a lot that can be improved and changed. If any of you guys do improve it or add anything to it then please please please let me know even if it doesn't quite work, then maybe we can help you get it to work.


But first we need to build Bob (Yes, I named it)

BBB Bots almost finished.jpg


The Steps:





1. Get stuff (easy):

    Stuff we need (there's quite a bit)

Where to buyFarnell Order Codequantityproduct
cpc.farnell.comHK012091ROBOT KIT CHASSIS
uk.farnell.com243798124379811WIFI DONGLE
uk.farnell.com165068516506852BATTERY HOLDER, LEADED, 4 X AA
uk.farnell.com234525723452571Alkaline AA Batteries (any will do, get rechargeable if you prefer)
uk.farnell.com207536620753662Continuous rotation servos

PCB, RAW, 100X160

uk.farnell.com156468215646821Step-Down Voltage Regulator
uk.farnell.com247467524746751Prototyping Board
uk.farnell.com945108094510801100 µf radial capacitor
uk.farnell.com9451129945112911000 µf radial capacitor
uk.farnell.com120954612095461100µH inductor


You will also need.....

  • Soldering station (Soldering iron, heat mat, solder, and whatever PPE you need)
  • A bit of wire (some capable of taking up to 5V at 3A, and some thinner gauge just for controlling servos etc)
  • A few male to male and male to female jumper wires may also come in handy
  • pliers thin nosed
  • screwdriver (flat or philips)
  • super glue (be careful) or double sided tape
  • a bit of foam (or another way to hold the BBB and batteries in place and allow them to be removed)
  • duct tape or another way to attach the Beaglebone flap to the chassis
  • A sharp craft/Stanley knife (Be VERY careful when using this, get someone to help if you're not confident. And mind your fingers)



2. Build the chassis (very easy)


Get all the chassis stuff out, we're just using the main base platform, ball bearing at the back, and the wheels.


Use the bolts provided to screw the ball bearing wheel to the back of the chassis making sure the bolts go down so that they stick out the bottom and not stick out the top, or else we won't be able to fit our batteries in correctly.


Super glue/stick/attach the servos to the bottom of the chassis like the picture below

Then route the wires to the top. You may need to enlarge the hole to get the connectors through.....


Next we need to cut the flap for the Beaglebone Black to rest on. Measure out however big you want it (making sure the Beaglebone fits onto it with spare room for the foam) then score the PCB board down the line you want it to break, be very careful and use a cutting rule if possible. Keep scoring from both sides until almost through the board then carefully snap the board. If you don't have a cutting rule or you are not too confident with a craft/Stanley knife then use a hacksaw or similar.


Carefully stick the flap to the front of the chassis to create a hinge. that allows the flap to lift up and down so we can access the batteries later.


Now we can cut out the foam to fit the Beaglebone Black and the Batteries. Measure and outline the Beaglebone onto the foam then cut out the shape to make a Beaglebone sized hole in the foam then cut around the hole so all you're left with is an outline of foam which we can stick onto the flap.

Now repeat for the batteries.


Now we can stick/glue the foam onto the flap and chassis. Make sure the Beaglebone foam holder goes on the top of the flap and the battery holder goes right at the back of the chassis.



3. Soldering the Prototyping Board for the power connections (You WILL need some basic electronics knowledge and some previous soldering experience for this bit)

This bit is probably the hardest bit of the project because it's very fiddly and requires you to have at least a basic understanding of electronics.


Firstly get your protoboard and score it then snap it in half, then score and snap in half again the other way to get a quarter (scoring down the holes makes it easier to snap). This quarter is the bit we're going to use.


Now by carefully following the circuit diagram below solder all the components in place.

Circuit Diagram for the BeagleBot power board

The batteries need soldering in series.

On the DC jack the inner pin is positive and the outer metal shell is ground. Check you have the correct wires the correct way round before soldering or else you will blow your Beaglebone!

Also make sure the capacitor and diode polarisation is correct.


After checking the voltage insert the DC jack into the Beaglebone and wait for it to boot. Once successfully boot shut it down. Congratulations you now have a working battery powered Beaglebone.



4. Installing the packages on the Beaglebone (easy)

This bit is easy peasy.

Plug in and boot the Beaglebone.

Make sure you have internet connection either through Ethernet or WiFi.

Now install everything we need.

In the command terminal type the following lines.

sudo apt-get update
sudo apt-get install build-essential python-dev python-setuptools python-pip python-smbus -y --force-yes --fix-missing
sudo pip install Adafruit_BBIO
sudo apt-get install apache2 php5 libapache2-mod-php5 -y --force-install --fix-missing
systemctl disable cloud9.service
systemctl disable gateone.service
systemctl disable bonescript.service
systemctl disable bonescript.socket
systemctl disable bonescript-autorun.service
systemctl disableavahi-daemon.service
systemctl disable gdm.service
systemctl disable mpd.service



5. Get the webserver running (fairly easy)

Now we need to get the webserver running.

First extract the .zip folder with the files in it onto a memory stick.

Insert the memory stick into the Beaglebone and reboot it.

In the terminal copy the files onto the board

sudo cp -R /media/<path_to_memory_stick>/www/* /var/www/
sudo chmod -R www-data:www-data /var/www

Now let's check that Apache is running on the correct port (port 80)

Use whichever editor you prefer, but here I'm using nano to make it simpler for beginner users

sudo nano /etc/apache2/ports.conf

Find the line related to listening ports, and make sure it is referring to port 80, change it if needed.

then press ctrl+x then y then enter to save the file.

then type

sudo service apache2 restart

to restart apache with the new settings


now we need to get the Beaglebone to connect to the wifi network.



6. Get the python script running (easy)

For this all we need to do is make sure the script is executable and make sure python can run it fine

in the terminal type

sudo chmod a+x /var/www/*.py
python2.7 /var/www/move_php.py

You should hopefully see the words

"Move_php script running..."

on your screen if it is worki

press Ctrl+C to stop python



7. Auto run the scripts we need running (easy)

For this we are going to use crontab, it is a service that runs in the background and is used to automate the running of tasks, exactly what we need.

In the terminal type

sudo crontab -e

In the crontab window add to the bottom the following lines

@reboot sudo service apache2 start
@reboot sudo python2.7 /var/www/move_php.py &

Notice the & sign at the end of the second line. This is very important, as it tells python to run in the background. If you do not include this then python will run in the foreground and prevent the boot sequence from continuing.

Now when we reboot apache2 should auto start and the python script should also run in the background. You can check this by rebooting your Beaglebone then in the terminal typing

ps -e | grep python

this should return a process I.D. for the python script running in the background


8. Assembling Bob (very easy, but can be fiddly)

This bit is very easy but can be a bit annoying to get perfect.

Place the Beaglebone in the foam holder on the flap, and the batteries in the foam holder at the back of the main chassis.

Route all the wires in a neat fashion to where the Beaglebone is on top of the flap.

Follow the picture in the zip file named BeagleBot_connections.png to connect everything (except the power) up to the correct pins, you may need to use jumper wires. If you don't have any jumper wires then you can simply cut the wires the connectors off of the wires you can't connect, strip them twist them and tin them, then you can insert them into the header on the BeagleBone.

Once everything is plugged in, tuck away/neaten up any wires hanging around the place until it looks neat and tidy. It might be a good idea to use electrical tape to hold wires down and out the way. At all costs prevent short-circuits.


9. Power (very easy)

Once your BeagleBot is ready to go, plug in the power and wait for it to boot. If you have not set up a static I.P from your router then you will need to connect to the Beaglebone during boot either by ssh over the wifi or via a serial cable to get the I.P. address.

Once you have the I.P address and your board is fully powered and not tethered to anything via a wire you are ready to go!


10. GO!! (fun)

Open up a browser window on any PC/phone/tablet that is connected to the same network as the BeagleBot and enter http://<I.P. of your BeagleBot>/move.php into the address bar.

Once the page is loaded tap the buttons to send your BeagleBot on its way.

Hello everyone,

I've been playing with the BeagleBone Black for a long time now.

If you're just getting started I've created a 4 part series on how to get started with the BeagleBone Black.


You can access the complete list of tutorials here: http://randomnerdtutorials.com/category/bbb-series/


Or you can choose a topic that interests you:


Thank you for reading and I hope you find this information useful.

If you have any questions feel free to ask and I'll try to help you.

Hi Guys ,


First of all Thanks a ton Element14 for sending one of the BeagleBone Black to test I recently have interfaced a 2.2" SPI LCD 240x320 To the Element14 Beagle Bone Black. Below is a Working demonstration of the Display in action



I also made a breakout board for the above featuring

1. Easy Plug and play capability (Modular design)

2. Easy UART Access using a Standard arduino mini FTDI module



Quick Observations,

1. The board is officially BeagleBone Black compliant !! Still No BeagleBone Black Logo is present on board ??

2. This board uses the Latest AM3358 Chip instead of AM3359 one on previous versions.

3. It is an Exact replica of the original BeagleBone Black, and works PREFECTLY.

4. Finally, By default the E14 BBB comes with Debian pre-installed, my old BBB 2G version came with Armstrong installed  


Thanks again to Element 14 for sending me a BeagleBone Black.

and please comment below if you want to know more.

Filter Blog

By date:
By tag: