Category Archives: Raspberry Pi

Setting up SSH in VS Code to connect to a Raspberry Pi

26th April 2022 Karl

There have been a lot of posts written about how to connect from Visual Studio Code (VS Code) on a Windows PC to a Raspberry PI over SSH using public/private keys avoiding the need to use a password. This is another one, and I aim to be fairly terse.

The PC is running Windows 11, the Raspberry Pi is running the latest version of Raspberry Pi OS – Debian Bullseye. Note that <username> is a placeholder for your own username, the greater than symbol: > represents a Windows PowerShell prompt and the dollar sign: $ is a Linux Bash prompt.

Setup The PI

SSH needs enabling on the PI and an ~/.ssh directory needs creating in your users home directory.

On the Pi, in the terminal enable SSH with: sudo raspi-config then select 3 Interface Options > I2 SSH and choose Yes – Enable. Now create the directory where your keys will be kept: mkdir ~/.ssh

It is also useful to find the IP address of your PI with: hostname -I Mine is 192.168.2.45 and I shall being using this in the examples.

You should now be able to login to the Pi from the Windows PC, open Windows Terminal or PowerShell and use ssh <username>@192.168.2.45 answer yes to add it to the known hosts file and it will ask for your PI’s password. If your Windows username is the same as that on the PI you can login with ssh 192.168.2.45.

Setup Windows for SSH

This stage installs the SSH client on the PC, creates a keypair and copied the public key to the PI.

The OpenSSH client can be installed using Windows Settings on Windows Server 2019 and Windows 10 and above devices.

Open Settings, select Apps > Apps & Features, then select Optional Features.
Scan the list to see if the OpenSSH is already installed. If not, at the top of the page, select Add a feature, then:
Find OpenSSH Client, then click Install

A full description is given on Microsofts Get started with OpenSSH page.

On the Windows PC, in your PowerShell create the directory for your keys if it doesn’t exist already mkdir ~/.ssh and then change into it cd ~/.ssh generate a keypair and add it to the ssh-agent:

> ssh-keygen -t ed25519
Generating public/private ed25519 key pair.
Enter file in which to save the key (C:\Users\<username>/.ssh/id_ed25519):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in C:\Users\<username>/.ssh/id_ed25519.
Your public key has been saved in C:\Users\<username>/.ssh/id_ed25519.pub.
The key fingerprint is:
SHA256:YCETnl4GmmYSokjE+vE5UaJ1/nzXB1tboE730sxkujw <username>@<computer>
The key's randomart image is:
+--[ED25519 256]--+
|=o  =..          |
|=o +o=o.      .  |
|= =oo==      . . |
|.+o..+..    o o =|
| . o.o oS  o o %o|
|  . +   o . o =.*|
|     .   . . . + |
|              E  |
|               . |
+----[SHA256]-----+
PS C:\Users\<username>\.ssh> ssh-add ~\.ssh\id_ed25519

> ssh-keygen -t ed25519

Generating public/private ed25519 key pair.

Enter file in which to save the key (C:\Users\<username>/.ssh/id_ed25519):

Enter passphrase (empty for no passphrase):

Enter same passphrase again:

Your identification has been saved in C:\Users\<username>/.ssh/id_ed25519.

Your public key has been saved in C:\Users\<username>/.ssh/id_ed25519.pub.

The key fingerprint is:

SHA256:YCETnl4GmmYSokjE+vE5UaJ1/nzXB1tboE730sxkujw <username>@<computer>

The key's randomart image is:

+--[ED25519 256]--+

|=o =.. |

|=o +o=o. . |

|= =oo== . . |

|.+o..+.. o o =|

| . o.o oS o o %o|

| . + o . o =.*|

| . . . . + |

| E |

| . |

+----[SHA256]-----+

PS C:\Users\<username>\.ssh> ssh-add ~\.ssh\id_ed25519

We now need to copy the public key to the PI:

> scp ~\.ssh\id_ed25519.pub <username>@192.168.2.45:~/.ssh/

1	> scp ~\.ssh\id_ed25519.pub <username>@192.168.2.45:~/.ssh/

And on the PI we need to add that public key to the authorized keys, connect into the PI ssh <username>@192.168.2.45 and:

$ cd ~/.ssh
$ touch authorized_keys
$ cat id_ed25519.pub >> authorized_keys
$ chmod 600 authorized_keys
$ rm id_ed25519.pub

$ cd ~/.ssh

$ touch authorized_keys

$ cat id_ed25519.pub >> authorized_keys

$ chmod 600 authorized_keys

$ rm id_ed25519.pub

the commands, touch creates a blank file if it doesn’t exist, cat appends the pub file to authorized_keys, making sure that any existing keys are preserved permissions are set with chmod and finally the pub file is deleted.

Setup VS Code

Load up VS Code and add the Remote – SSH and Remote SSH: Editing Configuration Files extensions, once restarted you will see a >< icon in the bottom left-hand corner with a green background, click that and select Edit SSH Configuration file…, choose the one in your home directory C:\Users\<username>\.ssh\config and add the following:

Host piComputer_192.168.2.45
  HostName 192.168.2.45
  User <username>
  ForwardAgent yes
  IdentityFile C:/Users/<username>/.ssh/id_ed25519

Host piComputer_192.168.2.45

HostName 192.168.2.45

User <username>

ForwardAgent yes

IdentityFile C:/Users/<username>/.ssh/id_ed25519

The Host “piComputer_192.168.2.45” is the friendly name displayed within VS Code for when you are choosing it from lists, the User id your user on the PI. Save the config file when complete.

You should now be able to connect to the PI. Click the >< icon in the bottom left-hand corner, and choose Connect To Host… A popup saying Setting Up… should appear, it may ask if the host is Linux or Windows, choose Linux, and within a few seconds it’ll be connected and ready. From within VS Code you can open a Bash Terminal – Ctrl+Shift+’

If it asks for a password, you may have missed a stage, or copied the private key to the PI instead of the public one.

Links and Sources

Computer, linux, Raspberry Pi

Setup a Network Camera with a Raspberry PI

1st July 2021 Karl 2 Comments

In this post I am setting up a network available RTSP video camera on a Raspberry Pi 4 Model B with the latest Debian Buster installed, you will also want another ‘remote’ computer with VLC installed on the same network. I have used a camera module connected via a ribbon cable to the Pi’s video port. The performance is more like what you would see from a security camera rather than some fancy dedicated device. I will be making the configuration with a bash shell using SSH rather than the GUI.

Installation

If you haven’t already, enable the camera on the Pi with sudo raspi-config and go to Interface Options > Camera. To reduce the load on the computer I also set the Pi to boot to the Console in System Options > Boot / Auto Login and selecting Console, you should also check that at least 256MB of memory is allocated to the GPU in Performance Options > GPU Memory, when complete reboot to set the updated configuration.

Install some prerequisites, you may have some or all of these installed already:

$ sudo apt update
$ sudo apt install curl git build-essential software-properties-common cmake

1 2	$ sudo apt update $ sudo apt install curl git build-essential software-properties-common cmake

Next add the Video For Linux (V4L) Repository, this adds the drivers for the video on the hardware side

$ curl https://www.linux-projects.org/listing/uv4l_repo/lpkey.asc | sudo apt-key add -

1	$ curl https://www.linux-projects.org/listing/uv4l_repo/lpkey.asc \| sudo apt-key add -

and add the following line to your apt sources with $ sudo nano /etc/apt/sources.list

deb https://www.linux-projects.org/listing/uv4l_repo/raspbian/stretch stretch main

1	deb https://www.linux-projects.org/listing/uv4l_repo/raspbian/stretch stretch main

We can now install the V4L packages:

$ sudo apt update
$ sudo apt install uv4l uv4l-raspicam liblog4cpp5-dev libv4l-dev uv4l-server uv4l-raspicam-extras

1 2	$ sudo apt update $ sudo apt install uv4l uv4l-raspicam liblog4cpp5-dev libv4l-dev uv4l-server uv4l-raspicam-extras

We now need to install the RTSP server from Git, this server connects to the V4L drivers above:

$ cd ~
$ git clone https://github.com/mpromonet/v4l2rtspserver.git
$ cd v4l2rtspserver
$ cmake .
$ sudo make install
$ sudo reboot

$ cd ~

$ git clone https://github.com/mpromonet/v4l2rtspserver.git

$ cd v4l2rtspserver

$ cmake .

$ sudo make install

$ sudo reboot

Configuration

To setup V4L, edit the configuration file $ sudo nano /etc/uv4l/uv4l-raspicam.conf and update the driver options and uncomment the h264 options:

##################################
# raspicam driver options
##################################
encoding = h264
#720p
width = 1280
height = 720
framerate = 12

### h264 options:
profile = high
level = 4.2
bitrate = 8000000
intra-refresh-mode = dummy
intra-period = #arg
inline-headers = yes
sps-timing = no
quantisation-parameter #arg

##################################

# raspicam driver options

##################################

encoding = h264

#720p

width = 1280

height = 720

framerate = 12

### h264 options:

profile = high

level = 4.2

bitrate = 8000000

intra-refresh-mode = dummy

intra-period = #arg

inline-headers = yes

sps-timing = no

quantisation-parameter #arg

Restart the service once you have saved the file:

$ sudo service uv4l_raspicam restart

1	$ sudo service uv4l_raspicam restart

Useful screen Resolutions; designation, ratio: width x height:

1080p, 16:9: 1920 x 1080
720p, 16:9: 1280 x 720
720, 4:3: 1296 x 792
Standard Definition, 4:3: 640 x 480

I’ve chosen 720p 16:9 widescreen, this gives a good image quality without stressing the Pi 4B. The framerate is a compromise between quality and usability, its unlikely you would want to go above 25fps.

Connecting

If you don’t know it already, find the IP address of your Pi with $ ip a. Look for the address in eth0 or wlan0 depending on if you are using ethernet or wireless. In this case I will be using 192.168.2.33 in the examples.

Start the RTSP server with:

$ v4l2rtspserver -U user:password -F12 -W 1280 -H 720 -P 8555 /dev/video0

1	$ v4l2rtspserver -U user:password -F12 -W 1280 -H 720 -P 8555 /dev/video0

Replace user:password with a suitable username and password. I have assumed that the camera is on /dev/video0, you can test this with:

$ v4l2-ctl -d /dev/video0 -D

1	$ v4l2-ctl -d /dev/video0 -D

and look for a line such as Driver version: 5.10.17, if this is 0.0.0 then try a different device, /dev/video1, /dev/video2 etc.

On a successful load it will tell you the connection:

2021-07-01 10:07:39,251 [NOTICE] - /home/pi/v4l2rtspserver/inc/V4l2RTSPServer.h:81
        Play this stream using the URL "rtsp://192.168.2.33:8555/unicast"

1 2	2021-07-01 10:07:39,251 [NOTICE] - /home/pi/v4l2rtspserver/inc/V4l2RTSPServer.h:81 Play this stream using the URL "rtsp://192.168.2.33:8555/unicast"

Now on your ‘remote’ computer open VLC and choose Media > Open Network Stream and place the given stream address into the network URL, you will then be asked for the username and password. For me it took less than five seconds for an image to appear, there is a fairly high latency on the image shown, the picture lags by about a second from reality.

Using OpenCV

You can access the stream using Python scripts and OpenCV on your ‘remote’ computer for AI/Machine Learning. For me this is a Debian Linux box with FFmpeg as OpenCV uses this to access the stream.

#!/bin/env python

import os
import cv2

# if the script doesn't work, uncomment the following, OpenCV may be 
# defaulting to TCP when we are wanting to use UDP.
#os.environ["OPENCV_FFMPEG_CAPTURE_OPTIONS"] = "rtsp_transport;udp"

# replace user:password with your username and password
rtspUrl = "rtsp://user:password@192.168.2.33:8555/unicast"

cap = cv2.VideoCapture(rtspUrl)  

#Check if camera was opened correctly
if not (cap.isOpened()):
    print("Could not open video device")

#Set the resolution
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)

while(True):
    ret, frame = cap.read()
    cv2.imshow('VIDEO', frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

#!/bin/env python

import os

import cv2

# if the script doesn't work, uncomment the following, OpenCV may be

# defaulting to TCP when we are wanting to use UDP.

#os.environ["OPENCV_FFMPEG_CAPTURE_OPTIONS"] = "rtsp_transport;udp"

# replace user:password with your username and password

rtspUrl = "rtsp://user:password@192.168.2.33:8555/unicast"

cap = cv2.VideoCapture(rtspUrl)

#Check if camera was opened correctly

if not (cap.isOpened()):

print("Could not open video device")

#Set the resolution

cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)

cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)

while(True):

ret, frame = cap.read()

cv2.imshow('VIDEO', frame)

if cv2.waitKey(1) & 0xFF == ord('q'):

break

cap.release()

cv2.destroyAllWindows()

You can check OpenCV is working with FFmpeg with:

$ python -c "import cv2; print(cv2.getBuildInformation())"

1	$ python -c "import cv2; print(cv2.getBuildInformation())"

and looking in the output for FFMPEG saying YES:

 Video I/O:
    DC1394:                      NO
    FFMPEG:                      YES
      avcodec:                   YES (58.109.100)
      avformat:                  YES (58.61.100)
      avutil:                    YES (56.60.100)
      swscale:                   YES (5.8.100)
      avresample:                NO
    GStreamer:                   NO
    v4l/v4l2:                    YES (linux/videodev2.h)

Video I/O:

DC1394: NO

FFMPEG: YES

avcodec: YES (58.109.100)

avformat: YES (58.61.100)

avutil: YES (56.60.100)

swscale: YES (5.8.100)

avresample: NO

GStreamer: NO

v4l/v4l2: YES (linux/videodev2.h)

Links and Sources

V4L Installation: https://www.linux-projects.org/uv4l/installation/
RTSP Server https://github.com/mpromonet/v4l2rtspserver

Computer, linux, Raspberry Pi

Copying and Resizing a Raspberry Pi SD Card

21st June 2020 Karl

The Micro SD Card I use in a Raspberry PI ran out of space so here is how I copied the contents of the 15GB drive to a new 64GB card and resized the partition. I used a separate computer running Debian and as the machine does not have a monitor or keyboard attached this will be being completed through the bash command line using SSH.

1. Making a copy of the SD Card.

Insert the old card into your computer, if the computer attempts to mount the drive then unmount it. We need to find which mount point has been used, do this with the lsblk command:

$ lsblk
NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
sda      8:0    0   477G  0 disk
├─sda1   8:1    0   512M  0 part /boot/efi
├─sda2   8:2    0 468.9G  0 part /
└─sda3   8:3    0   7.6G  0 part [SWAP]
sdb      8:16   0   477G  0 disk
└─sdb1   8:17   0   477G  0 part /mnt/external_ssd
sdc      8:32   0   1.8T  0 disk
└─sdc1   8:33   0   1.8T  0 part /data
sdd      8:48   0   3.7T  0 disk
└─sdd1   8:49   0   3.7T  0 part /mnt/external_hdd
sde      8:64   1  14.9G  0 disk
├─sde1   8:65   1  43.8M  0 part
└─sde2   8:66   1  14.8G  0 part

$ lsblk

NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT

sda 8:0 0 477G 0 disk

├─sda1 8:1 0 512M 0 part /boot/efi

├─sda2 8:2 0 468.9G 0 part /

└─sda3 8:3 0 7.6G 0 part [SWAP]

sdb 8:16 0 477G 0 disk

└─sdb1 8:17 0 477G 0 part /mnt/external_ssd

sdc 8:32 0 1.8T 0 disk

└─sdc1 8:33 0 1.8T 0 part /data

sdd 8:48 0 3.7T 0 disk

└─sdd1 8:49 0 3.7T 0 part /mnt/external_hdd

sde 8:64 1 14.9G 0 disk

├─sde1 8:65 1 43.8M 0 part

└─sde2 8:66 1 14.8G 0 part

The device sde matches our SD card. So we will use that. The dd command is used to create the ISO image, I am creating the file in my home directory:

$ cd ~
$ sudo dd status=progress if=/dev/sde of=raspberry_cnc.iso

1 2	$ cd ~ $ sudo dd status=progress if=/dev/sde of=raspberry_cnc.iso

once complete, check that the records match:

31116288+0 records in
31116288+0 records out
15931539456 bytes (16 GB, 15 GiB) copied, 464.124 s, 34.3 MB/s

31116288+0 records in

31116288+0 records out

15931539456 bytes (16 GB, 15 GiB) copied, 464.124 s, 34.3 MB/s

Swap the SD cards and check the mount point again:

$ lsblk
NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
[snip]
sde      8:64   1  59.5G  0 disk
└─sde1   8:65   1  59.5G  0 part

$ lsblk

NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT

[snip]

sde 8:64 1 59.5G 0 disk

└─sde1 8:65 1 59.5G 0 part

Now copy the iso image to the new card:

$ sudo dd status=progress if=raspberry_cnc.iso of=/dev/sde

1	$ sudo dd status=progress if=raspberry_cnc.iso of=/dev/sde

this can take a while, the write speed is rather slow:

31116288+0 records in
31116288+0 records out
15931539456 bytes (16 GB, 15 GiB) copied, 3023.22 s, 5.3 MB/s

31116288+0 records in

31116288+0 records out

15931539456 bytes (16 GB, 15 GiB) copied, 3023.22 s, 5.3 MB/s

and lsblk shows us the new partitions:

$ lsblk
NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
[snip]
sde      8:64   1  59.5G  0 disk
├─sde1   8:65   1  43.8M  0 part
└─sde2   8:66   1  14.8G  0 part

$ lsblk

NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT

[snip]

sde 8:64 1 59.5G 0 disk

├─sde1 8:65 1 43.8M 0 part

└─sde2 8:66 1 14.8G 0 part

2. Resizing the partition

The copied partition is now the same size as the original. If you have space remaining, the new card can be put back in the Pi and use the raspi-config utility, and using the Expand Filesystem option in the Advanced Settings section. However if the drive is completely full you won’t be able to login as there won’t be enough space available for the temporary files created at login, to get round this you can use parted to resize, start with:

$ sudo parted /dev/sde

1	$ sudo parted /dev/sde

if you get the following message:

Warning: Unable to open /dev/sde read-write (Read-only file system).  /dev/sde has been opened read-only.

1	Warning: Unable to open /dev/sde read-write (Read-only file system). /dev/sde has been opened read-only.

then quit from parted, if you are using a full size SD Card, check the Write Protect tab on the side of the card and try again, otherwise try:

$ sudo hdparm -r0 /dev/sde

/dev/sde:
 setting readonly to 0 (off)
 readonly      =  0 (off)

$ sudo hdparm -r0 /dev/sde

/dev/sde:

setting readonly to 0 (off)

readonly = 0 (off)

If problem persists try formatting the new card in a camera, as these have a simple file system, and write the ISO image again.

We need to resize the larger partition /dev/sde2 with the ext4 file system, the smaller is used to boot the Pi and can be ignored. In parted, list the partitions with the print command:

$ sudo parted /dev/sde
(parted) print
Model: Generic- USB3.0 CRW -SD (scsi)
Disk /dev/sde: 63.9GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags:

Number  Start   End     Size    Type     File system  Flags
 1      4194kB  50.1MB  45.9MB  primary  fat32        lba
 2      50.3MB  15.9GB  15.9GB  primary  ext4

$ sudo parted /dev/sde

(parted) print

Model: Generic- USB3.0 CRW -SD (scsi)

Disk /dev/sde: 63.9GB

Sector size (logical/physical): 512B/512B

Partition Table: msdos

Disk Flags:

Number Start End Size Type File system Flags

1 4194kB 50.1MB 45.9MB primary fat32 lba

2 50.3MB 15.9GB 15.9GB primary ext4

Using resizepart set the new size, I set this to larger than the 15GB but smaller than the unallocated space, this to save me having to accurately work out the remaining space manually:

(parted) resizepart 2
End?  [15.9GB]? 40GB

1 2	(parted) resizepart 2 End? [15.9GB]? 40GB

Now update the boundaries to grow and resize the partition into the freshly allocated space:

$ sudo /sbin/e2fsck -f /dev/sde2
$ sudo /sbin/resize2fs /dev/sde2

1 2	$ sudo /sbin/e2fsck -f /dev/sde2 $ sudo /sbin/resize2fs /dev/sde2

Now boot the Pi with the new card, login and use the raspi-config utility then in Advanced Options choose Expand Filesystem and follow the onscreen instructions. Once rebooted you should now be set to fill up your new card.

Links and Sources

RPi Resize Flash Partitions https://elinux.org/RPi_Resize_Flash_Partitions
Parted Guide https://www.tecmint.com/parted-command-to-create-resize-rescue-linux-disk-partitions/

APPLE, Computer, linux, Programming, Raspberry Pi

Extracting MP3 audio from video files

29th July 2018 Karl

Here is a small Bash script that converts any supported ffmpeg video format; such as .MKV, .MP4 or .MOV and extracts the audio to an .MP3 file, It will also split that MP3 file into chunks and put them in a convenient directory. You will need to install ffmpeg and mp3splt for your particular platform.

Example Usage:

./mkv2mp3 "big fat file.mkv"

1	./mkv2mp3 "big fat file.mkv"

This uses ffmpeg to convert “big fat file.mkv” to “big fat file.mp3” and then uses mp3splt to create a directory “big fat file” containing the files 01 – big fat file.mp3, 02 – big fat file.mp3, etc. The MP3 files will be encoded at 128k Constant Bit Rate and each file will be around 50 minutes in length. To install in Debian/Ubuntu use: sudo apt-get install ffmpeg mp3splt

#!/bin/bash
INFILE=$1
BITRATE="128k"
LENGTH="50.0"

FILENAME=$(basename "$INFILE" | cut -d. -f1)
if [[ -z "${FILENAME// }" ]]; then
   echo "filename missing"
   exit 1
fi

echo "$FILENAME"
ffmpeg -i "$INFILE" -vn -acodec libmp3lame -b:a "$BITRATE" "$FILENAME".mp3
mp3splt -t "$LENGTH" -d "$FILENAME" -a -o @n+-+@f "$FILENAME".mp3

#!/bin/bash

INFILE=$1

BITRATE="128k"

LENGTH="50.0"

FILENAME=$(basename "$INFILE" | cut -d. -f1)

if [[ -z "${FILENAME// }" ]]; then

echo "filename missing"

exit 1

echo "$FILENAME"

ffmpeg -i "$INFILE" -vn -acodec libmp3lame -b:a "$BITRATE" "$FILENAME".mp3

mp3splt -t "$LENGTH" -d "$FILENAME" -a -o @n+-+@f "$FILENAME".mp3

mp3splt can find the audio in a quiet region near where the split is desired rather than midway through a word, this should make for much cleaner playback across tracks.

Alternative Method

This script gives the same results but uses ffmpeg to split the large MP3 file and then adds track numbering metadata using id3v2. To install in Debian/Ubuntu use: sudo apt-get install ffmpeg id3v2

#!/bin/bash
INFILE="$1"
BITRATE="128k"
LENGTH="3000"    # 50 minutes in seconds

FILENAME=$(basename "$INFILE" | cut -d. -f1)
if [[ -z "${FILENAME// }" ]]; then
   echo "filename missing"
   exit 1
fi

echo "$FILENAME"
MP3FILE="$FILENAME".mp3
ffmpeg -y -i "$INFILE" -vn -acodec libmp3lame -b:a "$BITRATE" "$MP3FILE"

OUTDIR="$FILENAME"
mkdir "$OUTDIR"

ffmpeg -y -i "$MP3FILE" -vn -f segment -segment_time "$LENGTH" -c copy "$OUTDIR"/%02d-"$MP3FILE"

TRACK=1
IFS=$'\n'
FILES=($(find "$OUTDIR" -name "*.mp3" | sort -n))
for file in "${FILES[@]}"; do
  TN=$(printf %02d $TRACK)
  id3v2 --track "$TN" --TIT2 "$FILENAME" "$file"
  TRACK=$((TRACK+1))
done

#!/bin/bash

INFILE="$1"

BITRATE="128k"

LENGTH="3000" # 50 minutes in seconds

FILENAME=$(basename "$INFILE" | cut -d. -f1)

if [[ -z "${FILENAME// }" ]]; then

echo "filename missing"

exit 1

echo "$FILENAME"

MP3FILE="$FILENAME".mp3

ffmpeg -y -i "$INFILE" -vn -acodec libmp3lame -b:a "$BITRATE" "$MP3FILE"

OUTDIR="$FILENAME"

mkdir "$OUTDIR"

ffmpeg -y -i "$MP3FILE" -vn -f segment -segment_time "$LENGTH" -c copy "$OUTDIR"/%02d-"$MP3FILE"

TRACK=1

IFS=$'\n'

FILES=($(find "$OUTDIR" -name "*.mp3" | sort -n))

for file in "${FILES[@]}"; do

TN=$(printf %02d $TRACK)

id3v2 --track "$TN" --TIT2 "$FILENAME" "$file"

TRACK=$((TRACK+1))

done

Creating an Audiobook

Taking this further, I was thinking that it would be nice to have these converted into the M4B Audiobook format for use on my elderly iPod. The script below assumes that you have processed the files as above and have added metadata tags using a tool like mp3tag (yes I know this is for Windows).

To complete this we need to: Combine the multiple MP3 files into one big file, or read the original big file then convert that to M4B format at 96K bit and add chapter marks every ten minutes. For this I have used ffmpeg v3.2.12 and libmp4v2 (for the mp4chaps utility), to install in Debian/Ubuntu use: sudo apt-get install libmp4v2-dev mp4v2-utils ffmpeg

This script works best from a single MP3 file rather than from those that have been re-combined back into a single file, recombining the files caused ffmpeg to exclaim “invalid packet size” and “invalid data” errors. It is able to tell the difference between a directory and a single MP3 and processes the file accordingly, don’t forget to add metadata tags and cover art before you run the script.

#!/bin/bash
INFILE="$1"

BITRATE="96k"
MP3TITLE=""
MP3ARTIST=""
MP3ALBUM=""
MP3COMMENT=""
MP3YEAR=""
MP3PERFORMER=""

####
####  FUNCTIONS
####

function setMP3variables() {
  TAG="$1"
  VALUE="$2"

  case "$TAG" in
    title)
      MP3TITLE="$VALUE"
      ;;
    artist)
      MP3ARTIST="$VALUE"
      ;;
    comment)
      MP3COMMENT="$VALUE"
      ;;
    album_artist)
      MP3PERFORMER="$VALUE"
      ;;
    album)
      MP3ALBUM="$VALUE"
      ;;
    date)
      MP3YEAR="$VALUE"
      ;;
   esac
}

## get the tag text from the metadata
## if the line contains an equals (=) then split by the first equals.
function getMP3tags() {
  MP3METADATA="$1"
  while read -r line
  do
    case "$line" in
      *=*)
        TAG=${line%%"="*}
        VALUE=${line#*"="}
        setMP3variables "$TAG" "$VALUE"
        ;;
    esac
  done < "$MP3METADATA"

  if [[ ! -z "${MP3TITLE// }" ]]; then
    OUTFILE="$MP3TITLE".mp3
    M4BFILE="$MP3TITLE".m4b
  fi
}

####
####   BEGINS
####

FILENAME=$(basename "$INFILE" | cut -d. -f1)
if [[ -z "${FILENAME// }" ]]; then
   echo "filename missing"
   exit 1
fi
OLDIFS=$IFS
OUTFILE="$FILENAME"_out.mp3
M4BFILE="${OUTFILE:0:-4}".m4b
METADATA="${OUTFILE:0:-4}".metadata
JPGFILE="${OUTFILE:0:-4}".jpg


## check if input is a diretory
if [ -d "$INFILE" ]; then
  # get the name of the first MP3 file in the directory
  FIRSTFILE=$(find "$INFILE" -name "*.mp3" | sort -n | head -1)
  FIRSTFILE=$(basename "$FIRSTFILE")

  if [[ -z "${FIRSTFILE// }" ]]; then
    echo "no mp3 files in directory"
    exit 1
  fi

  ## save the MP3 tag metadata from the first file
  ffmpeg -y -i "$INFILE/$FIRSTFILE" -f ffmetadata "$METADATA"
  ## save out the cver art image
  ffmpeg -y -i "$INFILE/$FIRSTFILE" -an -vcodec copy "$JPGFILE"
  ## process the tag metadata - put it into the $MP3* strings, set $OUTFILE and $LOGFILE from the title
  getMP3tags "$METADATA"

  ## make a bar seperated list of the MP3 files that are to be combined
  MP3FILES=""
  IFS=$'\n'
  FILES=($(find "$INFILE" -name "*.mp3" | sort -n))
  for files in "${FILES[@]}"; do
    MP3FILES+="$files|"
  done
  MP3FILES=${MP3FILES:0:-1}

  ## combine all the MP3 files into one big file
  ## $OUTFILE is set using either the $FILENAME or $MP3TITLE if that has been used
  ffmpeg -y -i "concat:$MP3FILES" -vn -vsync 2 -acodec copy "$OUTFILE"
else
  ## process a single MP3 file
  ## save the MP3 tag metadata from the first file
  ffmpeg -y -i "$INFILE" -f ffmetadata "$METADATA"
  ffmpeg -y -i "$INFILE" -an -vcodec copy "$JPGFILE"
  ## process the tag metadata - put it into the $MP3* strings, set $OUTFILE and $LOGFILE from the title
  getMP3tags "$METADATA"
  #ffmpeg -y -i "$INFILE" -vn -vsync 2 -acodec copy "$OUTFILE"
  OUTFILE="$INFILE"
fi

## if there is a cover image, these are are the options for adding it back in
WITHJPG=()
if [ -e "$JPGFILE" ]; then
   IFS=$OLDIFS
   WITHJPG=(-i "$JPGFILE" -metadata:s:v comment="Cover (front)")
fi

## create the audiobook M4B file
## and write the metadata into the output file
ffmpeg -y -i "$OUTFILE" -i "$METADATA" "${WITHJPG[@]}" -map_metadata 1 -id3v2_version 3 -acodec aac -b:a "$BITRATE" -strict -2 -f mp4 "$M4BFILE"
## add the chapters every 10 minutes
mp4chaps -e 600 "$M4BFILE"

## tidy up
rm "$MP3METADATA"
if [ -e "$JPGFILE" ]; then
   rm "$JPGFILE"
fi
#rm "$OUTFILE"
echo "finished"

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

#!/bin/bash

INFILE="$1"

BITRATE="96k"

MP3TITLE=""

MP3ARTIST=""

MP3ALBUM=""

MP3COMMENT=""

MP3YEAR=""

MP3PERFORMER=""

####

#### FUNCTIONS

####

function setMP3variables() {

TAG="$1"

VALUE="$2"

case "$TAG" in

title)

MP3TITLE="$VALUE"

;;

artist)

MP3ARTIST="$VALUE"

;;

comment)

MP3COMMENT="$VALUE"

;;

album_artist)

MP3PERFORMER="$VALUE"

;;

album)

MP3ALBUM="$VALUE"

;;

date)

MP3YEAR="$VALUE"

;;

esac

}

## get the tag text from the metadata

## if the line contains an equals (=) then split by the first equals.

function getMP3tags() {

MP3METADATA="$1"

while read -r line

case "$line" in

*=*)

TAG=${line%%"="*}

VALUE=${line#*"="}

setMP3variables "$TAG" "$VALUE"

;;

esac

done < "$MP3METADATA"

if [[ ! -z "${MP3TITLE// }" ]]; then

OUTFILE="$MP3TITLE".mp3

M4BFILE="$MP3TITLE".m4b

}

####

#### BEGINS

####

FILENAME=$(basename "$INFILE" | cut -d. -f1)

if [[ -z "${FILENAME// }" ]]; then

echo "filename missing"

exit 1

OLDIFS=$IFS

OUTFILE="$FILENAME"_out.mp3

M4BFILE="${OUTFILE:0:-4}".m4b

METADATA="${OUTFILE:0:-4}".metadata

JPGFILE="${OUTFILE:0:-4}".jpg

## check if input is a diretory

if [ -d "$INFILE" ]; then

# get the name of the first MP3 file in the directory

FIRSTFILE=$(find "$INFILE" -name "*.mp3" | sort -n | head -1)

FIRSTFILE=$(basename "$FIRSTFILE")

if [[ -z "${FIRSTFILE// }" ]]; then

echo "no mp3 files in directory"

exit 1

## save the MP3 tag metadata from the first file

ffmpeg -y -i "$INFILE/$FIRSTFILE" -f ffmetadata "$METADATA"

## save out the cver art image

ffmpeg -y -i "$INFILE/$FIRSTFILE" -an -vcodec copy "$JPGFILE"

## process the tag metadata - put it into the $MP3* strings, set $OUTFILE and $LOGFILE from the title

getMP3tags "$METADATA"

## make a bar seperated list of the MP3 files that are to be combined

MP3FILES=""

IFS=$'\n'

FILES=($(find "$INFILE" -name "*.mp3" | sort -n))

for files in "${FILES[@]}"; do

MP3FILES+="$files|"

done

MP3FILES=${MP3FILES:0:-1}

## combine all the MP3 files into one big file

## $OUTFILE is set using either the $FILENAME or $MP3TITLE if that has been used

ffmpeg -y -i "concat:$MP3FILES" -vn -vsync 2 -acodec copy "$OUTFILE"

else

## process a single MP3 file

## save the MP3 tag metadata from the first file

ffmpeg -y -i "$INFILE" -f ffmetadata "$METADATA"

ffmpeg -y -i "$INFILE" -an -vcodec copy "$JPGFILE"

## process the tag metadata - put it into the $MP3* strings, set $OUTFILE and $LOGFILE from the title

getMP3tags "$METADATA"

#ffmpeg -y -i "$INFILE" -vn -vsync 2 -acodec copy "$OUTFILE"

OUTFILE="$INFILE"

## if there is a cover image, these are are the options for adding it back in

WITHJPG=()

if [ -e "$JPGFILE" ]; then

IFS=$OLDIFS

WITHJPG=(-i "$JPGFILE" -metadata:s:v comment="Cover (front)")

## create the audiobook M4B file

## and write the metadata into the output file

ffmpeg -y -i "$OUTFILE" -i "$METADATA" "${WITHJPG[@]}" -map_metadata 1 -id3v2_version 3 -acodec aac -b:a "$BITRATE" -strict -2 -f mp4 "$M4BFILE"

## add the chapters every 10 minutes

mp4chaps -e 600 "$M4BFILE"

## tidy up

rm "$MP3METADATA"

if [ -e "$JPGFILE" ]; then

rm "$JPGFILE"

#rm "$OUTFILE"

echo "finished"

When encoding to the M4B using a re-combined file I saw a few of these errors from ffmpeg:

[mp3 @ 0x7fffc3bc9ea0] Header missing
Error while decoding stream #0:0: Invalid data found when processing input

1 2	[mp3 @ 0x7fffc3bc9ea0] Header missing Error while decoding stream #0:0: Invalid data found when processing input

These appear to be caused by the mp3splt program from when the original MP3 file was being split into 50 minute chunks, but I can’t hear any effect on the output.

Lots of information about the file can be gotten using mediainfo, to install in Debian/Ubuntu use: sudo apt-get install mediainfo, example use:

mediainfo --fullscan "big fat file.m4b"

1	mediainfo --fullscan "big fat file.m4b"

Links and References

ffmpeg, encode AAC: https://trac.ffmpeg.org/wiki/Encode/AAC
ArchLinux audiobook howto

Computer, Hardware, Interesting, linux, Raspberry Pi

Bluetooth Low Energy (BLE) on the Raspberry Pi

14th May 2017 Karl 4 Comments

Bluetooth Low Energy – BLE – Bluetooth 4.0 is an industry-standard wireless protocol built for the Internet of Things – IoT, it is designed to provide connectivity for devices operating from low capacity power sources such as coin cell batteries.

Raspberry Pi2 with ASUS USB-BT400 Bluetooth 4.0 Dongle

In this introduction to BLE I’ll be configuring a Raspberry Pi2 computer to talk to a smart watch. We will be installing the latest version of BlueZ from source, enabling BLE support. This is not a tutorial on decoding the data from the watch I am just using it as an example, although I may write about decoding it in a future posting.

I am using a ASUS USB-BT400 Bluetooth 4.0 Dongle on a Raspberry Pi2 but this will work on any computer with a Debian based distribution. Your dongle must be BLE/Bluetooth 4.0 capable otherwise this won’t work. I am using an ID107HR activity tracker with pedometer and heart rate monitor, randomly chosen from the list of cheap ones available on Amazon. While using the Pi to talk to the the watch make sure Bluetooth on the phone is off as it can only connect to one device at a time.

The current distribution of Raspbian – jessie on the Raspberry Pi comes with version 5.23 of the BlueZ Bluetooth stack that’s rather old, dating from September 2014 which lacks many of the features we will be needing. The current version 5.44 of the BlueZ has many changes in the package with many familiar components such as hcitool and gatttool being depreciated, so I will be ignoring those and using the available commands, bluetoothctl, on the terminal.

Installing BlueZ

With Raspbian – jessie installed we will need to update the Pi make sure some packages are installed and then installing the latest version of BlueZ. But first, remove the installed version 5.23 of BlueZ:

$ sudo apt-get --purge remove bluez
$ sudo apt-get autoremove

1 2	$ sudo apt-get --purge remove bluez $ sudo apt-get autoremove

Next, perform the traditional housekeeping updates then install the build tools and USB libraries. Those parts that are installed already will be automatically skipped.

$ sudo apt-get update
$ sudo apt-get upgrade
$ sudo apt-get install build-essential
$ sudo apt-get install -y libusb-dev libdbus-1-dev libglib2.0-dev libudev-dev libical-dev libreadline-dev

$ sudo apt-get update

$ sudo apt-get upgrade

$ sudo apt-get install build-essential

$ sudo apt-get install -y libusb-dev libdbus-1-dev libglib2.0-dev libudev-dev libical-dev libreadline-dev

Now, download the source code, at time of writing the current stable release is version 5.44, check the BlueZ site for the latest version.

$ cd ~
$ wget http://www.kernel.org/pub/linux/bluetooth/bluez-5.44.tar.xz
$ tar xf bluez-5.44.tar.xz
$ cd bluez-5.44/

$ cd ~

$ wget http://www.kernel.org/pub/linux/bluetooth/bluez-5.44.tar.xz

$ tar xf bluez-5.44.tar.xz

$ cd bluez-5.44/

Inside the BlueZ directory, configure, make (this takes a while), and install. The experimental option adds BLE support and enabling the library allows for python use later on:

$ ./configure --enable-experimental --enable-library
$ make
$ sudo make install

$ ./configure --enable-experimental --enable-library

$ make

$ sudo make install

Configuring and Starting BlueZ

At this stage we will need to check that the installation worked and that we can see your bluetooth dongle. With your bluetooth dongle in a USB port you should see it on your list of USB devices, here you see mine as device ID: 0b05:17cb ASUSTek Computer, Inc.:

$ lsusb
Bus 001 Device 006: ID 0b05:17cb ASUSTek Computer, Inc. 
Bus 001 Device 004: ID 046d:c52e Logitech, Inc. 
Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp. SMSC9512/9514 Fast Ethernet Adapter
Bus 001 Device 002: ID 0424:9514 Standard Microsystems Corp. 
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

$ lsusb

Bus 001 Device 006: ID 0b05:17cb ASUSTek Computer, Inc.

Bus 001 Device 004: ID 046d:c52e Logitech, Inc.

Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp. SMSC9512/9514 Fast Ethernet Adapter

Bus 001 Device 002: ID 0424:9514 Standard Microsystems Corp.

Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

You will also need to enable the experimental services, edit the file /lib/systemd/system/bluetooth.service and in the [Service] section change the ExecStart line to end with –experimental:

ExecStart=/usr/local/libexec/bluetooth/bluetoothd --experimental

1	ExecStart=/usr/local/libexec/bluetooth/bluetoothd --experimental

Start the bluetooth service, and while we are at it enable it to load on boot:

$ sudo systemctl start bluetooth
$ sudo systemctl enable bluetooth

1 2	$ sudo systemctl start bluetooth $ sudo systemctl enable bluetooth

Once started, check the status of the bluetooth daemon with:

$ sudo systemctl status bluetooth
● bluetooth.service - Bluetooth service
   Loaded: loaded (/lib/systemd/system/bluetooth.service; enabled)
   Active: active (running) since Sat 2017-05-06 19:54:28 BST; 54s ago
     Docs: man:bluetoothd(8)
 Main PID: 10407 (bluetoothd)
   Status: "Running"
   CGroup: /system.slice/bluetooth.service
           └─10407 /usr/local/libexec/bluetooth/bluetoothd --experimental

May 06 19:54:27 raspberrypi bluetoothd[10407]: Bluetooth daemon 5.44
May 06 19:54:28 raspberrypi systemd[1]: Started Bluetooth service.
May 06 19:54:28 raspberrypi bluetoothd[10407]: Starting SDP server
May 06 19:54:28 raspberrypi bluetoothd[10407]: Bluetooth management interface 1.14 initialized

$ sudo systemctl status bluetooth

● bluetooth.service - Bluetooth service

Loaded: loaded (/lib/systemd/system/bluetooth.service; enabled)

Active: active (running) since Sat 2017-05-06 19:54:28 BST; 54s ago

Docs: man:bluetoothd(8)

Main PID: 10407 (bluetoothd)

Status: "Running"

CGroup: /system.slice/bluetooth.service

└─10407 /usr/local/libexec/bluetooth/bluetoothd --experimental

May 06 19:54:27 raspberrypi bluetoothd[10407]: Bluetooth daemon 5.44

May 06 19:54:28 raspberrypi systemd[1]: Started Bluetooth service.

May 06 19:54:28 raspberrypi bluetoothd[10407]: Starting SDP server

May 06 19:54:28 raspberrypi bluetoothd[10407]: Bluetooth management interface 1.14 initialized

Should you need to, the service can be stopped and prevented from loading on boot with:

$ sudo systemctl stop bluetooth
$ sudo systemctl disable bluetooth

1 2	$ sudo systemctl stop bluetooth $ sudo systemctl disable bluetooth

Finally, you may want to enable auto-power on for the device, to do so create this bluetooth config file:

$ sudo mkdir /etc/bluetooth
$ sudo nano /etc/bluetooth/main.conf

1 2	$ sudo mkdir /etc/bluetooth $ sudo nano /etc/bluetooth/main.conf

and add these two lines:

[Policy]
AutoEnable=true

1 2	[Policy] AutoEnable=true

You should restart the Pi at this point and check that the daemon has loaded properly with sudo systemctl status bluetooth

Testing BlueZ

Start the bluetooth controller, you should see your dongles MAC address and alias:

$ sudo bluetoothctl 
[NEW] Controller 5C:F3:70:80:8A:A6 raspberrypi [default]

1 2	$ sudo bluetoothctl [NEW] Controller 5C:F3:70:80:8A:A6 raspberrypi [default]

for first time use, try scanning to find your watch, if it doesn’t appear it is out of range, its battery is flat, or your dongle does not support BLE, here you can see it as ID107 HR:

[bluetooth]# power on
Changing power on succeeded
[CHG] Controller 5C:F3:70:80:8E:FB Powered: yes
[bluetooth]# scan on
Discovery started
[CHG] Controller 5C:F3:70:80:8E:FB Discovering: yes
[NEW] Device C5:E8:FB:BF:F2:6C ID107 HR
[CHG] Device C5:E8:FB:BF:F2:6C RSSI: -63
[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Key: 0x001c
[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0x02
[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0x00
[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0xc5
[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0xe8
[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0xfb
[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0xbf
[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0xf2
[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0x6c
[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0xe3
[CHG] Device C5:E8:FB:BF:F2:6C AdvertisingFlags: 0x00
...etc...
[bluetooth]# scan off

[bluetooth]# power on

Changing power on succeeded

[CHG] Controller 5C:F3:70:80:8E:FB Powered: yes

[bluetooth]# scan on

Discovery started

[CHG] Controller 5C:F3:70:80:8E:FB Discovering: yes

[NEW] Device C5:E8:FB:BF:F2:6C ID107 HR

[CHG] Device C5:E8:FB:BF:F2:6C RSSI: -63

[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Key: 0x001c

[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0x02

[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0x00

[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0xc5

[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0xe8

[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0xfb

[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0xbf

[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0xf2

[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0x6c

[CHG] Device C5:E8:FB:BF:F2:6C ManufacturerData Value: 0xe3

[CHG] Device C5:E8:FB:BF:F2:6C AdvertisingFlags: 0x00

...etc...

[bluetooth]# scan off

bluetoothctl remembers your devices, so when you next use the program the watch appears on the list at the start. The controller has a number of options, these can be seen with help command. You can use show to view the status of your dongle:

[bluetooth]# show
Controller 5C:F3:70:80:8A:A6
	Name: raspberrypi
	Alias: raspberrypi
	Class: 0x000000
	Powered: no
	Discoverable: no
	Pairable: yes
	UUID: Generic Attribute Profile (00001801-0000-1000-8000-00805f9b34fb)
	UUID: A/V Remote Control        (0000110e-0000-1000-8000-00805f9b34fb)
	UUID: PnP Information           (00001200-0000-1000-8000-00805f9b34fb)
	UUID: Generic Access Profile    (00001800-0000-1000-8000-00805f9b34fb)
	UUID: A/V Remote Control Target (0000110c-0000-1000-8000-00805f9b34fb)
	Modalias: usb:v1D6Bp0246d052C
	Discovering: no

[bluetooth]# show

Controller 5C:F3:70:80:8A:A6

Name: raspberrypi

Alias: raspberrypi

Class: 0x000000

Powered: no

Discoverable: no

Pairable: yes

UUID: Generic Attribute Profile (00001801-0000-1000-8000-00805f9b34fb)

UUID: A/V Remote Control (0000110e-0000-1000-8000-00805f9b34fb)

UUID: PnP Information (00001200-0000-1000-8000-00805f9b34fb)

UUID: Generic Access Profile (00001800-0000-1000-8000-00805f9b34fb)

UUID: A/V Remote Control Target (0000110c-0000-1000-8000-00805f9b34fb)

Modalias: usb:v1D6Bp0246d052C

Discovering: no

The list of UUID’s show the services supported by the Dongle. Now we can power the dongle on, set the agent – this manages the connection, and then connect to the watch on which the bluetooth symbol will appear. Once connected there will be a pause then you will see a list of attributes supported by the watch, it is advertising the services available:

[bluetooth]# power on
Changing power on succeeded
[CHG] Controller 5C:F3:70:80:8A:A6 Powered: yes
[bluetooth]# agent on
Agent registered
[bluetooth]# default-agent
Default agent request successful
[bluetooth]# connect C5:E8:FB:BF:F2:6C
Attempting to connect to C5:E8:FB:BF:F2:6C
[CHG] Device C5:E8:FB:BF:F2:6C Connected: yes
Connection successful
[NEW] Primary Service
	/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service0008
	00001801-0000-1000-8000-00805f9b34fb
	Generic Attribute Profile
[NEW] Characteristic
	/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service0008/char0009
	00002a05-0000-1000-8000-00805f9b34fb
	Service Changed
[NEW] Descriptor
	/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service0008/char0009/desc000b
	00002902-0000-1000-8000-00805f9b34fb
	Client Characteristic Configuration
[NEW] Primary Service
	/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c
	00000af0-0000-1000-8000-00805f9b34fb
	Unknown
[NEW] Characteristic
	/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000d
	00000af6-0000-1000-8000-00805f9b34fb
	Unknown
[NEW] Characteristic
	/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f
	00000af7-0000-1000-8000-00805f9b34fb
	Unknown
[NEW] Descriptor
	/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f/desc0011
	00002902-0000-1000-8000-00805f9b34fb
	Client Characteristic Configuration
[NEW] Characteristic
	/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char0012
	00000af2-0000-1000-8000-00805f9b34fb
	Unknown
[NEW] Descriptor
	/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char0012/desc0014
	00002902-0000-1000-8000-00805f9b34fb
	Client Characteristic Configuration
[NEW] Characteristic
	/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char0015
	00000af1-0000-1000-8000-00805f9b34fb
	Unknown
[CHG] Device C5:E8:FB:BF:F2:6C UUIDs: 00000af0-0000-1000-8000-00805f9b34fb
[CHG] Device C5:E8:FB:BF:F2:6C UUIDs: 00001800-0000-1000-8000-00805f9b34fb
[CHG] Device C5:E8:FB:BF:F2:6C UUIDs: 00001801-0000-1000-8000-00805f9b34fb
[CHG] Device C5:E8:FB:BF:F2:6C ServicesResolved: yes
[ID107 HR]#

[bluetooth]# power on

Changing power on succeeded

[CHG] Controller 5C:F3:70:80:8A:A6 Powered: yes

[bluetooth]# agent on

Agent registered

[bluetooth]# default-agent

Default agent request successful

[bluetooth]# connect C5:E8:FB:BF:F2:6C

Attempting to connect to C5:E8:FB:BF:F2:6C

[CHG] Device C5:E8:FB:BF:F2:6C Connected: yes

Connection successful

[NEW] Primary Service

/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service0008

00001801-0000-1000-8000-00805f9b34fb

Generic Attribute Profile

[NEW] Characteristic

/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service0008/char0009

00002a05-0000-1000-8000-00805f9b34fb

Service Changed

[NEW] Descriptor

/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service0008/char0009/desc000b

00002902-0000-1000-8000-00805f9b34fb

Client Characteristic Configuration

[NEW] Primary Service

/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c

00000af0-0000-1000-8000-00805f9b34fb

Unknown

[NEW] Characteristic

/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000d

00000af6-0000-1000-8000-00805f9b34fb

Unknown

[NEW] Characteristic

/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f

00000af7-0000-1000-8000-00805f9b34fb

Unknown

[NEW] Descriptor

/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f/desc0011

00002902-0000-1000-8000-00805f9b34fb

Client Characteristic Configuration

[NEW] Characteristic

/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char0012

00000af2-0000-1000-8000-00805f9b34fb

Unknown

[NEW] Descriptor

/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char0012/desc0014

00002902-0000-1000-8000-00805f9b34fb

Client Characteristic Configuration

[NEW] Characteristic

/org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char0015

00000af1-0000-1000-8000-00805f9b34fb

Unknown

[CHG] Device C5:E8:FB:BF:F2:6C UUIDs: 00000af0-0000-1000-8000-00805f9b34fb

[CHG] Device C5:E8:FB:BF:F2:6C UUIDs: 00001800-0000-1000-8000-00805f9b34fb

[CHG] Device C5:E8:FB:BF:F2:6C UUIDs: 00001801-0000-1000-8000-00805f9b34fb

[CHG] Device C5:E8:FB:BF:F2:6C ServicesResolved: yes

[ID107 HR]#

and now that we have connected we can ask for some info:

[ID107 HR]# info C5:E8:FB:BF:F2:6C
Device C5:E8:FB:BF:F2:6C
	Name: ID107 HR
	Alias: ID107 HR
	Appearance: 0x0341
	Paired: no
	Trusted: no
	Blocked: no
	Connected: yes
	LegacyPairing: no
	UUID: Unknown                   (00000af0-0000-1000-8000-00805f9b34fb)
	UUID: Generic Access Profile    (00001800-0000-1000-8000-00805f9b34fb)
	UUID: Generic Attribute Profile (00001801-0000-1000-8000-00805f9b34fb)
	ManufacturerData Key: 0x001c
	ManufacturerData Value: 0x02
	ManufacturerData Value: 0x00
	ManufacturerData Value: 0xc5
	ManufacturerData Value: 0xe8
	ManufacturerData Value: 0xfb
	ManufacturerData Value: 0xbf
	ManufacturerData Value: 0xf2
	ManufacturerData Value: 0x6c
	ManufacturerData Value: 0xe3
[ID107 HR]#

[ID107 HR]# info C5:E8:FB:BF:F2:6C

Device C5:E8:FB:BF:F2:6C

Name: ID107 HR

Alias: ID107 HR

Appearance: 0x0341

Paired: no

Trusted: no

Blocked: no

Connected: yes

LegacyPairing: no

UUID: Unknown (00000af0-0000-1000-8000-00805f9b34fb)

UUID: Generic Access Profile (00001800-0000-1000-8000-00805f9b34fb)

UUID: Generic Attribute Profile (00001801-0000-1000-8000-00805f9b34fb)

ManufacturerData Key: 0x001c

ManufacturerData Value: 0x02

ManufacturerData Value: 0x00

ManufacturerData Value: 0xc5

ManufacturerData Value: 0xe8

ManufacturerData Value: 0xfb

ManufacturerData Value: 0xbf

ManufacturerData Value: 0xf2

ManufacturerData Value: 0x6c

ManufacturerData Value: 0xe3

[ID107 HR]#

These UUID’s are used to describe the sevices available on the device, some are pre-defined and can be found in the a href=”https://www.bluetooth.com/specifications/gatt/characteristics” target=”_blank” rel=”noopener noreferrer”>GATT schema, others are vendor specific and unless they publicly release these, decoding can become rather difficult. There are four types of attribute:

Services – collections of characteristics and relationships to other services that encapsulate the behavior of part of a device
Characteristics – attribute types that contain a single logical value
Descriptors – defined attributes that describe a characteristic value
Declarations – defined GATT profile attribute types

Each attribute is identified by a 128 bit ID, for example, one of the characteristics from the list above: 00002902-0000-1000-8000-00805f9b34fb, the first eight bits are used as an unique identifier: 00002902 and are shown as UUID’s: 0x2902. Data is contained in services, each service has a number of characteristics that may contain further descriptions depending on the requirement of the characteristic. You can see how the data is mapped out in this chart:

A spreadsheet with the watch data reformatted and tastefully coloured to illustrates this. Observe the Service URL column, it looks a lot like a directory structure:

Here we see two services /service0008 and /service000c looking further into the second service: /service000c we see that it has four characteristics, and to of those have descriptors. We can interrogate the characteristics and descriptors to glean further information by selecting the attribute and reading, like so:

[ID107 HR]# select-attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f
[ID107 HR:/service000c/char000f]# read
Attempting to read /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x02
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0xa0
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x23
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x01
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x19
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x92
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00
[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00
  02 a0 23 00 00 00 01 00 00 00 19 00 00 00 92 00  ..#.............
  00 00 00                                         ...

[ID107 HR]# select-attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f

[ID107 HR:/service000c/char000f]# read

Attempting to read /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f

[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x02

[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0xa0

[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x23

[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00

[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x01

[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00

[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x19

[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00

[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x92

[CHG] Attribute /org/bluez/hci0/dev_C5_E8_FB_BF_F2_6C/service000c/char000f Value: 0x00

02 a0 23 00 00 00 01 00 00 00 19 00 00 00 92 00 ..#.............

00 00 00 ...

Which is all very nice, but not particularly helpful as the manufacturer has chosen to use custom, proprietary, UUID’s for the watch. We don’t know the instructions to send to have the watch realease its data.

Those Scripting BlueZ

Inevitably, you’ll be wanting to automate connections. This becomes easy with the automation scripting language expect. Install, then make a script file:

$ sudo apt-get install expect
$ cd ~
$ nano bttest
$ chmod +x bttest

$ sudo apt-get install expect

$ cd ~

$ nano bttest

$ chmod +x bttest

In this example the script forgets the watch, finds the watch, connects to the watch, gets some info and then disconnects:

#!/usr/bin/expect -f

set timeout 10
set prompt ".*#"
set usrpasswd ""
set address "C5:E8:FB:BF:F2:6C"

## execute blutetoothctl
spawn sudo bluetoothctl 
expect -re ".*password.*" 
send "$usrpasswd\r"

## forget about the device - if connected previously
expect -re $prompt
send "remove $address\r"
expect -re $prompt
sleep 3

## switch on the dongle
send "power on\r"
expect "Changing power on succeeded"
expect -re $prompt

## scan for devices 
send "scan on\r"
expect -re $prompt
sleep 5
send "scan off\r"
expect -re $prompt

## set the agent
send "agent on\r"
expect "Agent registered"
send "default-agent\r"
expect -re $prompt
sleep 2

## connect to watch
send "connect $address\r"
expect -re $prompt

## get some info
send "info $address\r"
expect -re $prompt

## disconnect
send "disconnect $address\r"
sleep 2
expect -re "\[bluetooth\]#"

## bye
send "exit\r"

#!/usr/bin/expect -f

set timeout 10

set prompt ".*#"

set usrpasswd ""

set address "C5:E8:FB:BF:F2:6C"

## execute blutetoothctl

spawn sudo bluetoothctl

expect -re ".*password.*"

send "$usrpasswd\r"

## forget about the device - if connected previously

expect -re $prompt

send "remove $address\r"

expect -re $prompt

sleep 3

## switch on the dongle

send "power on\r"

expect "Changing power on succeeded"

expect -re $prompt

## scan for devices

send "scan on\r"

expect -re $prompt

sleep 5

send "scan off\r"

expect -re $prompt

## set the agent

send "agent on\r"

expect "Agent registered"

send "default-agent\r"

expect -re $prompt

sleep 2

## connect to watch

send "connect $address\r"

expect -re $prompt

## get some info

send "info $address\r"

expect -re $prompt

## disconnect

send "disconnect $address\r"

sleep 2

expect -re "\[bluetooth\]#"

## bye

send "exit\r"

in the script, send sends a command, don’t forget to add the carriage return – \r and expect is used to wait for a response within the timeout period, here it is set to 10 seconds. expect -re is using regex when looking for a reply, otherwise it uses a literal string. So much more can be done with expect and there are many tutorials, such as this one written by FluidBank.

More Bluetooth Data

For analysing bluetooth data a couple of very useful tools are available, Wireshark and Android data logging. I will go through the installation but not look at the data in any detail, this posting is getting a bit long. This Section is in two parts, installing Wireshark and Android Debug Bridge.

Sniffing with the Shark
Wireshark is a network and bluetooth packet sniffer, it shows you network and bluetooth traffic occurring on your Pi. Here is a quick installation method for a reasonably new version of Wireshark (v2.2.4) from the backports, answer yes to the question “Should non-superusers be able to capture packets?”:

$ sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 7638D0442B90D010
$ sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 8B48AD6246925553
$ echo 'deb http://httpredir.debian.org/debian jessie-backports main contrib non-free' | sudo tee -a /etc/apt/sources.list.d/jessie-backports.list
$ sudo apt-get update
$ sudo sudo apt-get -t jessie-backports install wireshark wireshark-dev libwireshark-dev

$ sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 7638D0442B90D010

$ sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 8B48AD6246925553

$ echo 'deb http://httpredir.debian.org/debian jessie-backports main contrib non-free' | sudo tee -a /etc/apt/sources.list.d/jessie-backports.list

$ sudo apt-get update

$ sudo sudo apt-get -t jessie-backports install wireshark wireshark-dev libwireshark-dev

and if you get a message about permissions, reconfigure the package and answer yes:

$ sudo dpkg-reconfigure wireshark-common

1	$ sudo dpkg-reconfigure wireshark-common

Start Wireshark and double click your bluetooth device on the list, in my case bluetooth0. There is not much to see as Wireshark will only see traffic between the watch and the Pi:

Android Debug Bridge – ADB
For Anroid 4.2.2 and above, activate developer mode on the phone, go to Settings, tap About Phone and at the bottom of the list tap Build Number three times. Back in the main settings page Developer Options has appeared, tap developer and turn USB debugging On. With the phone plugged into a USB port a little Android head should appear in the information bar at the top-left of the screen. To begin we will need to install some udev rules written by Nicolas Bernaerts:

$ sudo wget -O /etc/udev/rules.d/51-android.rules https://raw.githubusercontent.com/NicolasBernaerts/ubuntu-scripts/master/android/51-android.rules
$ sudo chmod a+r /etc/udev/rules.d/51-android.rules
$ sudo service udev restart

$ sudo wget -O /etc/udev/rules.d/51-android.rules https://raw.githubusercontent.com/NicolasBernaerts/ubuntu-scripts/master/android/51-android.rules

$ sudo chmod a+r /etc/udev/rules.d/51-android.rules

$ sudo service udev restart

Install the android tools, confirm that you have at least version 1.0.31, and start ADB

$ sudo apt-get install android-tools-adb android-tools-fastboot
$ adb version
Android Debug Bridge version 1.0.31
$ adb devices
* daemon not running. starting it now on port 5037 *
* daemon started successfully *
List of devices attached 
064be417008eef9f	offline

$ sudo apt-get install android-tools-adb android-tools-fastboot

$ adb version

Android Debug Bridge version 1.0.31

$ adb devices

* daemon not running. starting it now on port 5037 *

* daemon started successfully *

List of devices attached

064be417008eef9f offline

At this point on the phone an allow USB debugging dialog will appear, give permission and always trust to authorise it. ADB will now show the device as a device:

$ adb devices
List of devices attached 
064be417008eef9f	device

$ adb devices

List of devices attached

064be417008eef9f device

If the device list is empty, with everything plugged in good and proper and the phone setup in developer mode, start your diagnosis by checking udev; open another terminal window and view logging with udevadm monitor –environment and reload with sudo udevadm control –reload I’m not entirely sure what I did to get it from ‘not working’ to ‘working’. If all else fails elevate yourself to root.

Data Capture
With ADB now setup we can capture the Bluetooth data being exchanged. With bluetooth off, in the Developer Settings find Enable Bluetooth HCI snoop log and turn it On. In the smartwatch app synchronise with your watch, once complete turn Bluetooth off manually – this is to minimise the amount of captured data. Don’t forget to turn logging off on the phone when done. To find where the log file has been stored and copy the file from the phone to the Pi use:

$ adb shell "cat /etc/bluetooth/bt_stack.conf | grep FileName"
BtSnoopFileName=/sdcard/btsnoop_hci.log
$ adb pull /sdcard/btsnoop_hci.log ~/

$ adb shell "cat /etc/bluetooth/bt_stack.conf | grep FileName"

BtSnoopFileName=/sdcard/btsnoop_hci.log

$ adb pull /sdcard/btsnoop_hci.log ~/

We can now use Wireshark to read the log file…

Wireshark reading the Android Bluetooth Log

This wasn’t quite the posting I originally had in mind, I wanted to decode the data from the watch for my own use, making something more useful, impressive graphs and charts, than that provided by the Android App VeryFit 2.0 but as the manufacturer has chosen to use proprietary GATT codes it makes the job that much harder. It may be much simpler to just buy an expensive FitBit and download the data from them. But with writing this I now know a few things that were previously unknown, and I hope that this has provided some light to your BlueZ (a pun!, right at the end!).

Links and Sources

Bluetooth Low Energy Description
ID107HR activity tracker review
BlueZ – Official Linux Bluetooth protocol stack
List of GATT Services
Raspbian for the Raspberry Pi
Adafuit: Install bluez on the Raspberry Pi
ArchLinux Wiki: Bluetooth
Bluetooth audio paired but not connect? – Very useful BlueZ guide
Getting Started with Bluetooth Low Energy: Tools and Techniques for Low-Power Networking – ISBN: 1491949511

Computer, linux, Raspberry Pi

How-To: Raspberry Pi as a 3G/4G Router

16th August 2014 Karl 37 Comments

Update: 15 April 2016 – Added information about which IP address to use and assigning static IP addresses for printers and servers

Recently I have needed to find an emergency alternative to my broadband due to the regional wide area network, Digital Region, being shut down, and the ISP Origin making a mess of getting all their cutomers onto ASDL. To get quickly back onto the internet, I have bought an ZTE MF823 4G Mobile Broadband Dongle as supplied by the badly named ‘three’ mobile phone company. As I have my own internal wired network, with multiple computers and ‘things’ there is a need to have something more sophisticated than just plugging the dongle into a single PC.

Here is my recipe for setting up a Raspberry Pi as a router with an ZTE MF283 Dongle. In this setup all the computers are on a wired Ethernet connection using a switch for the network. The Pi has Raspbian Debian Wheezy installed (June 2014) with all the latest updates made. For testing, the dongle is plugged into the USB port via a powered hub, and the Pi connected to a switch with another PC running Linux Mint.

Which IP addresses to use?

In this How-To I am using the IP address range 192.168.2.xxx this is to avoid conflict with the cable router which uses the 192.168.1.xxx range (the DHCP server is switched off on the router). IPv4 addresses are split into three different ranges, the 192.168.xxx.xxx range – 192.168.0.0 to 192.168.255.255 gives a possible 65,536 addresses but for your home it is unlikely you’ll have more than 255 network devices, so we can simplify things by limiting the address range used to 192.168.2.xxx and avoid the troublesome world of subnet masking.

192.168.xxx.xxx is used as its been designated for use on private networks by the Internet Assigned Numbers Authority this is a well established convention and is best practice. Two other IPv4 address ranges are available for larger private networks: 172.16.0.0-172.31.255.255 and 10.0.0.0-10.255.255.255 with 1,048,576 and 16,777,216 available addresses respectively, the most suitable network class should be chosen for your network.

Setup the Dongle

This USB dongle has its own built in dialer so you do not need ppp or wvdial installed, it appears as a USB ethernet device on the Raspberry Pi. You will need a powered USB hub as the dongle can draw more power than the Pi can provide, the symptoms of too much of power being drawn will be the Pi behaving erratically or restarting unexpectedly.

With the dongle plugged in, check that it is recognised by the Pi with lsusb, it can be seen here as ‘ZTE WCDMA Technologies MSM’:

$ lsusb
Bus 001 Device 002: ID 0424:9512 Standard Microsystems Corp.
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp.
Bus 001 Device 004: ID 1a40:0201 Terminus Technology Inc. FE 2.1 7-port Hub
Bus 001 Device 005: ID 046d:c52e Logitech, Inc.
Bus 001 Device 006: ID 1a40:0101 Terminus Technology Inc. 4-Port HUB
Bus 001 Device 007: ID 19d2:1405 ZTE WCDMA Technologies MSM

$ lsusb

Bus 001 Device 002: ID 0424:9512 Standard Microsystems Corp.

Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp.

Bus 001 Device 004: ID 1a40:0201 Terminus Technology Inc. FE 2.1 7-port Hub

Bus 001 Device 005: ID 046d:c52e Logitech, Inc.

Bus 001 Device 006: ID 1a40:0101 Terminus Technology Inc. 4-Port HUB

Bus 001 Device 007: ID 19d2:1405 ZTE WCDMA Technologies MSM

The device ID is 19d2. and 1405 is the mode, this should be 1405 – CDC ethernet. If it is not, try removing the micro-SD card and rebooting the Pi, the device modes available are:

1225 – Default mode. USB Mass Storage Device + CD-ROM + card reader.
1403 – Modem mode. RNDIS + Mass Storage Device.
1405 – CDC ethernet
0016 – Download mode

As the dongle also has a Mass Storage Device the Raspberry may not switch to CDC ethernet. If the mode does not change, try the following with usb-modeswitch:
$ sudo apt-get install usb-modeswitch $ sudo usb_modeswitch -v 0x19d2 -p 0x1405 -d
I did not have to change the mode as it was correct already, and it didn’t change when I tried setting it as a Mass Storage device, I have not explored this any further.

When first plugged in the dongle was recognised as a ethernet device but it did not obtain an IP address:

$ ifconfig
usb0     Link encap:Ethernet HWaddr 36:4b:53:b7:e3:6e
         UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
         RX packets:0 errors:0 dropped:0 overruns:0 frame:0
         TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
         collisions:0 txqueuelen:1000
         RX bytes:0 (0.0 B) TX bytes:0 (0.0 B)

$ ifconfig

usb0 Link encap:Ethernet HWaddr 36:4b:53:b7:e3:6e

UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1

RX packets:0 errors:0 dropped:0 overruns:0 frame:0

TX packets:0 errors:0 dropped:0 overruns:0 carrier:0

collisions:0 txqueuelen:1000

RX bytes:0 (0.0 B) TX bytes:0 (0.0 B)

if this is the case with you, add the following two lines to the end of sudo nano /etc/network/interfaces:
auto usb0 iface usb0 inet dhcp
the dongle provides its own address to the computer. Reboot, and you should see the obtained address:

usb0    Link encap:Ethernet HWaddr 36:4b:53:b7:e3:6e
        inet addr:192.168.0.185 Bcast:192.168.0.255 Mask:255.255.255.0
        UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
        RX packets:40 errors:0 dropped:4 overruns:0 frame:0
        TX packets:15 errors:0 dropped:0 overruns:0 carrier:0
        collisions:0 txqueuelen:1000
        RX bytes:4443 (4.3 KiB) TX bytes:1382 (1.3 KiB)

usb0 Link encap:Ethernet HWaddr 36:4b:53:b7:e3:6e

inet addr:192.168.0.185 Bcast:192.168.0.255 Mask:255.255.255.0

UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1

RX packets:40 errors:0 dropped:4 overruns:0 frame:0

TX packets:15 errors:0 dropped:0 overruns:0 carrier:0

collisions:0 txqueuelen:1000

RX bytes:4443 (4.3 KiB) TX bytes:1382 (1.3 KiB)

The address 192.168.0.185 is now the internet address of the computer the dongle always assigns this address, there is also a useful web status page on http://192.168.0.1

Configuring the network

first of all enable ip4 forwarding, edit the file sudo nano /etc/sysctl.conf and uncomment the line:
net.ipv4.ip_forward=1
this will enable forwarding on reboot, you can also enable IP forwarding immediately with:
$ sudo sysctl -w net.ipv4.ip_forward=1

We now need to give the Pi a static IP address on the internal network. Edit sudo nano /etc/network/interfaces so you end up with a file that looks like this:

auto lo
iface lo inet loopback

auto eth0
iface eth0 inet static
address 192.168.2.1
netmask 255.255.255.0

auto usb0
iface usb0 inet dhcp

auto lo

iface lo inet loopback

auto eth0

iface eth0 inet static

address 192.168.2.1

netmask 255.255.255.0

auto usb0

iface usb0 inet dhcp

this gives the Pi a static IP address of 192.168.2.1.

DHCP

The next stage is to give the other computers on your network an IP address, this is done with a dhcp server:
$ sudo apt-get install isc-dhcp-server
you will need to configure dhcp sudo nano /etc/dhcp/dhcpd.conf, here is mine:

default-lease-time 600;
max-lease-time 7200;
ddns-update-style none;

# If this DHCP server is the official DHCP server for the local
# network, the authoritative directive should be uncommented.
authoritative;

log-facility local7;

subnet 192.168.2.0 netmask 255.255.255.0 {
  range 192.168.2.50 192.168.2.150;
  option broadcast-address 192.168.2.255;
  option routers 192.168.2.1;
  option subnet-mask 255.255.255.0;
  default-lease-time 600;
  max-lease-time 7200;
  option domain-name "fibble.local";
  option domain-name-servers 208.67.222.222, 208.67.220.220;
  interface eth0;
}
# give your network printer and file server a static IP addresses
host printer1 {
   hardware ethernet 08:00:2b:4c:59:23;
   fixed-address 192.168.2.45;
}
host fileserver {
   hardware ethernet 12:20:cb:3c:32:4d;
   fixed-address 192.168.2.40;
}

default-lease-time 600;

max-lease-time 7200;

ddns-update-style none;

# If this DHCP server is the official DHCP server for the local

# network, the authoritative directive should be uncommented.

authoritative;

log-facility local7;

subnet 192.168.2.0 netmask 255.255.255.0 {

range 192.168.2.50 192.168.2.150;

option broadcast-address 192.168.2.255;

option routers 192.168.2.1;

option subnet-mask 255.255.255.0;

default-lease-time 600;

max-lease-time 7200;

option domain-name "fibble.local";

option domain-name-servers 208.67.222.222, 208.67.220.220;

interface eth0;

}

# give your network printer and file server a static IP addresses

host printer1 {

hardware ethernet 08:00:2b:4c:59:23;

fixed-address 192.168.2.45;

}

host fileserver {

hardware ethernet 12:20:cb:3c:32:4d;

fixed-address 192.168.2.40;

}

This will assign IP addresses in the range 192.168.2.50 to 192.168.2.150 to any computer connected to your network. I have used Open DNS for the Domain name Servers, if you wish to use google’s use:
option domain-name-servers 8.8.8.8, 8.8.4.4;instead.

I have also given my network printer a static IP address, it is still assigned by the DHCP server but never changes, the same would apply to any file servers and the like, I would assign static devices addresses that are outside your dynamically assigned range. Reboot the Pi and then your test computer.

Your test computer should now have an IP address (192.168.2.51), and the gateway point to the Pi (92.168.2.1):

$ ifconfig
eth0      Link encap:Ethernet  HWaddr 2c:6f:63:8c:21:5f
          inet addr:192.168.2.51  Bcast:192.168.2.255  Mask:255.255.255.0
          inet6 addr: fe80::1e6f:65ff:fe89:216f/64 Scope:Link
          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
          RX packets:24232 errors:0 dropped:0 overruns:0 frame:0
          TX packets:15622 errors:0 dropped:0 overruns:0 carrier:0
          collisions:0 txqueuelen:1000
          RX bytes:15146663 (15.1 MB)  TX bytes:2571110 (2.5 MB)
$ route
Kernel IP routing table
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
default         192.168.2.1     0.0.0.0         UG    0      0        0 eth0
192.168.2.0     *               255.255.255.0   U     1      0        0 eth0

$ ifconfig

eth0 Link encap:Ethernet HWaddr 2c:6f:63:8c:21:5f

inet addr:192.168.2.51 Bcast:192.168.2.255 Mask:255.255.255.0

inet6 addr: fe80::1e6f:65ff:fe89:216f/64 Scope:Link

UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1

RX packets:24232 errors:0 dropped:0 overruns:0 frame:0

TX packets:15622 errors:0 dropped:0 overruns:0 carrier:0

collisions:0 txqueuelen:1000

RX bytes:15146663 (15.1 MB) TX bytes:2571110 (2.5 MB)

$ route

Kernel IP routing table

Destination Gateway Genmask Flags Metric Ref Use Iface

default 192.168.2.1 0.0.0.0 UG 0 0 0 eth0

192.168.2.0 * 255.255.255.0 U 1 0 0 eth0

Accessing The Internet

The final part is to have the incoming traffic on the the Ethernet port eth0, go out on the dongle usb0. This is achieved with iptables, a firewall and traffic router. Install with:
$ sudo apt-get install iptables
and you need to setup Network Address Translation, NAT and forwarding. This short bash script clears any old settings before applying the new rules:

#!/bin/bash
LAN="eth0"
WAN="usb0"

# flush tables
iptables -F
iptables -t nat -F

# apply routing
iptables -t nat -A POSTROUTING -o $WAN -j MASQUERADE
iptables -A FORWARD -i $WAN -o $LAN -m state --state RELATED,ESTABLISHED -j ACCEPT
iptables -A FORWARD -i $LAN -o $WAN -j ACCEPT

# make ZTE web interface available
iptables -t nat -A PREROUTING -p tcp --dport 2525 -j DNAT --to-destination 192.168.0.1:80

#!/bin/bash

LAN="eth0"

WAN="usb0"

# flush tables

iptables -F

iptables -t nat -F

# apply routing

iptables -t nat -A POSTROUTING -o $WAN -j MASQUERADE

iptables -A FORWARD -i $WAN -o $LAN -m state --state RELATED,ESTABLISHED -j ACCEPT

iptables -A FORWARD -i $LAN -o $WAN -j ACCEPT

# make ZTE web interface available

iptables -t nat -A PREROUTING -p tcp --dport 2525 -j DNAT --to-destination 192.168.0.1:80

Where LAN is your internal network, and WAN is the internet. The final line allows you access to the Dongle’s built in web status page from any browser on your internal network, just use: http://192.168.2.1:2525

Save the file in your home directory as ~/ipt.sh, make it executable and run the script.
$ chmod +x ~/ipt.sh $ sudo ~/ipt.sh
From your test computer, you will now be able to access the internet.

Finally, you now need to have iptables reload when you start the Pi. Export the iptables settings to a file with:
$ sudo sh -c "iptables-save > /etc/iptables.ipv4.nat"
and create a file sudo nano /etc/network/if-up.d/iptables with the following contents:

#!/bin/bash
/sbin/iptables-restore < /etc/iptables.ipv4.nat

1 2	#!/bin/bash /sbin/iptables-restore < /etc/iptables.ipv4.nat

and make it executable sudo chmod +x /etc/network/if-up.d/iptables

after a reboot you can see your iptables with sudo iptables -L and sudo iptables -t nat -L and you can see web traffic passing through the router with sudo tcpdump -i any -nn port 80.

Adding a Proxy Server

This is optional, but a transparent proxy server and cache may reduce the amount of traffic on your 3G/4G connection, mileage varies and the amount of data cached was less than I thought it would be, I also found that my Humax Freesat box really didn’t like the proxy server and wouldn’t update its TV schedules while it was on. I have used squid3 for this.
sudo apt-get install squid3
Update the squid3 configuration /etc/squid3/squid.conf so it has the following. The original is rather large, so you may want to make a copy and create a new one:

http_port 3128 transparent

refresh_pattern ^ftp:           1440    20%     10080
refresh_pattern ^gopher:        1440    0%      1440
refresh_pattern -i (/cgi-bin/|\?) 0     0%      0
refresh_pattern .               0       20%     4320

acl manager url_regex -i ^cache_object:// +i ^https?://[^/]+/squid-internal-mgr/

acl localnet src 192.168.2.0/24
acl localhost src 127.0.0.1/32

acl SSL_ports port 443
acl Safe_ports port 80          # http
acl Safe_ports port 21          # ftp
acl Safe_ports port 443         # https
acl Safe_ports port 70          # gopher
acl Safe_ports port 210         # wais
acl Safe_ports port 1025-65535  # unregistered ports
acl Safe_ports port 280         # http-mgmt
acl Safe_ports port 488         # gss-http
acl Safe_ports port 591         # filemaker
acl Safe_ports port 777         # multiling http
acl CONNECT method CONNECT

http_access allow manager localhost
http_access allow manager all
http_access deny manager
http_access deny !Safe_ports
http_access deny CONNECT !SSL_ports
http_access allow localhost
http_access allow localnet
http_access deny all

cache allow all
cache_mem 128 MB
cache_dir ufs /var/spool/squid3 5000 16 256

http_port 3128 transparent

refresh_pattern ^ftp: 1440 20% 10080

refresh_pattern ^gopher: 1440 0% 1440

refresh_pattern -i (/cgi-bin/|\?) 0 0% 0

refresh_pattern . 0 20% 4320

acl manager url_regex -i ^cache_object:// +i ^https?://[^/]+/squid-internal-mgr/

acl localnet src 192.168.2.0/24

acl localhost src 127.0.0.1/32

acl SSL_ports port 443

acl Safe_ports port 80 # http

acl Safe_ports port 21 # ftp

acl Safe_ports port 443 # https

acl Safe_ports port 70 # gopher

acl Safe_ports port 210 # wais

acl Safe_ports port 1025-65535 # unregistered ports

acl Safe_ports port 280 # http-mgmt

acl Safe_ports port 488 # gss-http

acl Safe_ports port 591 # filemaker

acl Safe_ports port 777 # multiling http

acl CONNECT method CONNECT

http_access allow manager localhost

http_access allow manager all

http_access deny manager

http_access deny !Safe_ports

http_access deny CONNECT !SSL_ports

http_access allow localhost

http_access allow localnet

http_access deny all

cache allow all

cache_mem 128 MB

cache_dir ufs /var/spool/squid3 5000 16 256

then restart squid3
sudo /etc/init.d squid3 restart
add the following iptables rule to redirect all traffic on port 80 to squid3:
iptables -t nat -A PREROUTING -i eth0 -p tcp --dport 80 -j REDIRECT --to-port 3128
you should now be able to watch the web traffic being processed through squid3 with:
sudo tail /var/log/squid3/access.log -f
finish off by exporting your iptables again, so they are reloaded on reboot:
sudo sh -c "iptables-save > /etc/iptables.ipv4.nat"

Pi 4G Router — Raspberry Pi as 4G Router

References and sources:

Computer, Hardware, Raspberry Pi

Recording Sound on the Raspberry Pi

11th August 2013 Karl 16 Comments

The Raspberry Pi does not have a microphone socket, which is inconvenient when you wish to record sound. To fix this you will need a USB Sound Card, for which I bought a Creative Sound Blaster Play! for about £20 and a short USB extension lead as the sound card is slightly too large and blocks the other USB port.

With the latest Raspbian “wheezy” installed on a Pi Model B with 512Mb of RAM and the overclocking set to High in raspi-config, here is a recipe for getting your Raspberry Pi to record sound from the command line. For the test setup I connected my iPod to the microphone port of the sound card, plugged everything in and powered up.

After logging into the Pi, check that the computer can see the card, use lsusb to find it, here the card is highlighted in blue:

$ lsusb

Bus 001 Device 002: ID 0424:9512 Standard Microsystems Corp.

Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

Bus 001 Device 003: ID 0424:ec00 Standard Microsystems Corp.

Bus 001 Device 004: ID 046d:c52e Logitech, Inc.

Bus 001 Device 005: ID 041e:30d3 Creative Technology, Ltd Sound Blaster Play!

remember that different makes of card will have different names and ID’s

Your user will need to be in the audio group, check this with groups <username>:

$ groups pi pi : pi adm dialout cdrom sudo audio video plugdev games users netdev input if not, then add them with:$ sudo usermod -a -G audio <username>

There is/was an issue with the Pi’s USB port that meant it can/could become overwhelmed¹ with data which causes popping and bubbling noises to be included in your recordings, this can be fixed with an update of the Pi’s firmware:

$ sudo apt-get update $ sudo apt-get upgrade $ sudo apt-get install rpi-update $ sudo rpi-update

The Raspbian image already has the alsa-utils for sound already installed, the programs I am using for recording and playback are:

alsamixer – GUI for setting the recording and playback levels
amixer – Command Line for setting the recording and playback levels
alsactl – for saving the settings set in alsamixer or amixer to use again after a reboot
arecord – For recording the sound
aplay – For playing back your recording

All of these programs have a –help option.

There are two methods for setting up the the microphone port on the card, the first is alsamixer:

$ alsamixerPress F6: Select Sound Card, and choose yours from the list, the bcm2835 ALSA is the on-board sound, for me the one to pick was: USB Device 0x41e:0x30d3 and take a note of the card number, in my case: 1. Now select the Mic and increase the volume to 52, or the first white blob, you’ll need to change it later, but its a good place to start. The Auto Gain Control wants to be off, select the gain control and press M to toggle so it displays [MM] for mute. Press Esc to exit and save the settings with:$ sudo alsactl store 1 where 1 is the card number.

Alternatively, you can use amixer. First find your sound card, in amixer there does not appear to be a method of listing the available cards, but on a Raspberry Pi I guess it will always be card 1, you can list the cards current status with:

$ amixer --card 1 contents numid=1,iface=MIXER,name='Mic Playback Switch' ; type=BOOLEAN,access=rw------,values=1 : values=off numid=2,iface=MIXER,name='Mic Playback Volume' ; type=INTEGER,access=rw---R--,values=1,min=0,max=32,step=0 : values=21 | dBminmax-min=0.00dB,max=47.81dB numid=5,iface=MIXER,name='Mic Capture Switch' ; type=BOOLEAN,access=rw------,values=1 : values=on numid=6,iface=MIXER,name='Mic Capture Volume' ; type=INTEGER,access=rw---R--,values=1,min=0,max=16,step=0 : values=7 | dBminmax-min=0.00dB,max=23.81dB numid=7,iface=MIXER,name='Auto Gain Control' ; type=BOOLEAN,access=rw------,values=1 : values=on numid=3,iface=MIXER,name='Speaker Playback Switch' ; type=BOOLEAN,access=rw------,values=1 : values=on numid=4,iface=MIXER,name='Speaker Playback Volume' ; type=INTEGER,access=rw---R--,values=2,min=0,max=151,step=0 : values=52,52 | dBminmax-min=-28.37dB,max=0.06dB
So I want to turn the Auto Gain Control off, and the recording volume to 14:$ amixer -c 1 cset numid=7,iface=MIXER,name='Auto Gain Control' 0 numid=7,iface=MIXER,name='Auto Gain Control' ; type=BOOLEAN,access=rw------,values=1 : values=off $ amixer -c 1 cset numid=6,iface=MIXER,name='Mic Capture Volume' 14 numid=6,iface=MIXER,name='Mic Capture Volume' ; type=INTEGER,access=rw---R--,values=1,min=0,max=16,step=0 : values=14 | dBminmax-min=0.00dB,max=23.81dB
again, store the settings so that they will be used again on a reboot:$ sudo alsactl store 1

Now we are ready to do a test recording, first check that arecord will see your card:

$ arecord -l **** List of CAPTURE Hardware Devices **** card 1: U0x41e0x30d3 [USB Device 0x41e:0x30d3], device 0: USB Audio [USB Audio] Subdevices: 1/1 Subdevice #0: subdevice #0
and now for a ten second test recording, this will create a file called rectest.vav in your home directory. Remember to set the Device (-D plughw:1) number to the right card (card 1):

arecord -D plughw:1 --duration=10 -f cd -vv ~/rectest.wav the –vv option displays extra information on the screen as well as a volume meter, this should be peaking at around 95% on the loudest sounds, if it is at 100% all a lot of the time then you are probably recording distortion. Playback the recording with aplay:

aplay ~/rectest.wav

the default settings will play the wav fie through the TV if it is connected by HDMI, To playback through the USB sound card set the device to the card number, like in arecord:

aplay -D plughw:1 ~/rectest.wav

Congratulations, you now have a fully working Pi Recording Device. Remember to experiment with the volume levels, too high and your recording will sound distorted.

References:

Raspberry Pi Usb Audio fix (10 May 2013)

Computer, Hardware, Interesting, Raspberry Pi

Can a Pi Raspberry?

9th August 2012 Karl 2 Comments

The Raspberry Pi is a small computer, and as such an obvious but important question occurred to me, and despite Google, I was unable to find an answer. So using science, LEGO, a balloon, and a compressed air supply I set out to discover if the Raspberry Pi could indeed blow a raspberry.

To embark on this scientific discovery, first, I needed to be able to control a motor, for this I built a dual relay board that can be switched using a couple of the Pi’s GPIO pins:

Here is the circuit diagram:

LEGO PF Motor Controller v3 - Circuit — LEGO PF Motor Controller v3 – Circuit

And the Python source code:

#! /usr/bin/python
 
from time import sleep
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
 
PARP_ON  = 23
PARP_OFF = 24
 
# Set up the GPIO channels
GPIO.setup(PARP_ON, GPIO.OUT)
GPIO.setup(PARP_OFF, GPIO.OUT)
 
def parpON():
 
    GPIO.output(PARP_ON, True)
    sleep(0.4)
    GPIO.output(PARP_ON, False)
    return
 
def parpOFF():
 
    GPIO.output(PARP_OFF, True)
    sleep(0.4)
    GPIO.output(PARP_OFF, False)
    return
 
if __name__ == "__main__":
    print "The Incredible Pi Raspberry Machine";
 
    for i in range(0,5):
        print "parp ",i
        parpON()
        sleep(2)
        parpOFF()
        sleep(0.7)
 
    GPIO.output(PARP_ON, False)
    GPIO.output(PARP_OFF, False)

#! /usr/bin/python

from time import sleep

import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)

PARP_ON = 23

PARP_OFF = 24

# Set up the GPIO channels

GPIO.setup(PARP_ON, GPIO.OUT)

GPIO.setup(PARP_OFF, GPIO.OUT)

def parpON():

GPIO.output(PARP_ON, True)

sleep(0.4)

GPIO.output(PARP_ON, False)

return

def parpOFF():

GPIO.output(PARP_OFF, True)

sleep(0.4)

GPIO.output(PARP_OFF, False)

return

if __name__ == "__main__":

print "The Incredible Pi Raspberry Machine";

for i in range(0,5):

print "parp ",i

parpON()

sleep(2)

parpOFF()

sleep(0.7)

GPIO.output(PARP_ON, False)

GPIO.output(PARP_OFF, False)

To which I connected a large LEGO PF motor. This is used to switch the pneumatic valves via a clutch cog and a large cog. I used a 9v power supply for this, but a PF Battery box can be used, cut an PF extension lead in half, use the light grey side for the motor, and the dark grey end to connect to the battery box. My compressed air supply operates at 2bar / 30 psi, it was built to work with LEGO pneumatics, I found that anything much above that pressure would cause the pipes to pop off the connectors.

Obviously I needed something that would make a sound. For this, a balloon (the sausage type), a small pop bottle, and some more LEGO were suffice. The air is injected into the bottle trough a couple of holes at the rear.

I would like to say thanks to the people on the Raspberry Pi forum for their advice on the electronics: http://www.raspberrypi.org/phpBB3/ and further reading about LEGO PF motors can be found here: http://www.philohome.com/pf/pf.htm, and the raspberry http://en.wikipedia.org/wiki/Blowing_a_raspberry

Computer, Raspberry Pi

Using the GPIO as a Normal User on the Raspberry Pi

29th June 2012 Karl

In one of my previous posts I mentioned setting the ownership of the /sys/class/gpio to dialout using /etc/rc.local. This worked up to a point, however entries are created in the gpio when you start using them and they retain the original root group permissions, which means you are required to run your code as root. As this is bad practice I have been looking for ways to get around this, so far setting a udev rule has proved futile.

However, I have found a tool called GPIO Admin and they have also written a Python GPIO API for it, simply install the software, add your user to the gpio group and you have access to the header without having to use root. They have written the API for Python 3, but I have found it will work in Python 2.7 (so far, with the version I downloaded on 29 June 2012, its still in development). The Flask framework has not been updated to work in Python 3.

Computer, Raspberry Pi

Python and Apache on the Raspberry Pi using the Flask Framework

23rd June 2012 Karl 8 Comments

From reading the Raspberry Pi forum, I see many are wanting to control their hardware projects from the web. Here I will show a method of integrating Python with the Apache web server, and allowing the Apache server access to the GPIO and UART ports without having to run it as root, if you have PHP already installed, both will run in the same environment. For this I am using am using Debian from here: http://www.raspberrypi.org/archives/1435, on a freshly installed SD card.

Part One: Installation, configuration and testing

As root, install the following packages:
# apt-get update
# apt-get upgrade
# apt-get install apache2 libapache2-mod-wsgi python-setuptools python-flask

edit your virtual host in /etc/apache2/sites-enabled, here I have added the wsgi components to the default host 000-default.

<VirtualHost *:80>
ServerAdmin webmaster@localhost
 
#WSGIDaemonProcess pywsgi:80 processes=2 threads=15 display-name=%{GROUP}
#WSGIProcessGroup pywsgi:80
#WSGIScriptAlias /wsgi/ /var/www/
 
DocumentRoot /var/www
<Directory />
Options FollowSymLinks
AllowOverride None
</Directory>
<Directory /var/www/>
Options Indexes FollowSymLinks MultiViews ExecCGI
AllowOverride None
Order allow,deny
allow from all
 
WSGIScriptReloading On
Addhandler wsgi-script .py
</Directory>
 
TypesConfig /etc/apache2/mime.types
DirectoryIndex index.php index.htm index.html index.py
AccessFileName .htaccess
 
ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
<Directory "/usr/lib/cgi-bin">
AllowOverride None
Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
Order allow,deny
Allow from all
</Directory>
 
ErrorLog ${APACHE_LOG_DIR}/error.log
 
# Possible values include: debug, info, notice, warn, error, crit,
# alert, emerg.
LogLevel warn
 
CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

ServerAdmin webmaster@localhost

#WSGIDaemonProcess pywsgi:80 processes=2 threads=15 display-name=%{GROUP}

#WSGIProcessGroup pywsgi:80

#WSGIScriptAlias /wsgi/ /var/www/

DocumentRoot /var/www

Options FollowSymLinks

AllowOverride None

</Directory>

Options Indexes FollowSymLinks MultiViews ExecCGI

AllowOverride None

Order allow,deny

allow from all

WSGIScriptReloading On

Addhandler wsgi-script .py

</Directory>

TypesConfig /etc/apache2/mime.types

DirectoryIndex index.php index.htm index.html index.py

AccessFileName .htaccess

ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/

AllowOverride None

Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch

Order allow,deny

Allow from all

</Directory>

ErrorLog ${APACHE_LOG_DIR}/error.log

# Possible values include: debug, info, notice, warn, error, crit,

# alert, emerg.

LogLevel warn

CustomLog ${APACHE_LOG_DIR}/access.log combined

</VirtualHost>

Parts easily missed are setting ExecCGI on the Options and adding index.py to the DirectoryIndex. Note that I have set the wsgi to identify python by the extension .py, normally .wsgi is used, I think this is some kind of tradition, or old charter, or something.

Set permissions:
Apache on Debian runs as the user www-data, for access to the serial port and GPIO on the Raspberry Pi you will need to add that user to the relevant groups. Do not run apache as root, while this is not so important when on the Pi it is good practice to avoid.

Edit /etc/rc.local and add these two lines to the end of the file:
chgrp -R dialout /sys/class/gpio
chmod -R g+rw /sys/class/gpio
when you reboot the computer, group permissions will be set to dialout on the gpio

add www-data to the dialout group
# usermod -a -G dialout www-data

Update: the /etc/rc.local method does not work, instead I have found found a tool called GPIO Admin and they have also written a Python GPIO API for it. Currently it is under development, but once installed add apache to the gpio group:
# usermod -a -G gpio www-data
and the web server will have access to the gpio pins

enable the module (it may of been enabled when installed) and restart apache
# a2enmod wsgi
# /etc/init.d/apache2 restart

To test your wsgi installation place the following file into your apache root directory /var/www as myinfo.py and load it using your web browser, http://<pi’s ip address>/myinfo.py .

##
##   display environment variables in mod_wsgi - shows if wsgi, flask etc is working
##
 
from flask import Flask, request, make_response
import sys
application = Flask(__name__)
 
def showEnv(environ):
 
    version = sys.version
 
    o = "<table>"
    o += "<tr>"
    o += "<td>Python version</td>"
    o += "<td>"+str(version)+"</td>"
    for key in environ:
       o += "<tr>"
       o += "<td>"+str(key)+"</td>"
       o += "<td>"+str(environ[key])+"</td>"
       o += "</tr>\n"
    o += "</table>"
    return o
 
def WSerrorTextHTML(txt):
    err = "<p>ERROR!</p>"
    err += "<pre>"+ txt + "</pre>"
    return err
 
@application.route('/', methods=['POST', 'GET'])
def indexApp():
 
    try:
        env = request.environ
        output = 'Hello World!<hr>'
 
        if not env['mod_wsgi.process_group']:
            output += 'EMBEDDED MODE<hr>'
        else:
            output += 'DAEMON MODE<hr>'
 
        output += showEnv(env) + "<hr>"
        output += str(request.method) + "<hr>"
        output += str(__name__)
        return output
    except:
        import traceback
        response = make_response(WSerrorTextHTML(traceback.format_exc()))
        response.headers['Content-Type'] = 'text/html'
        return response
 
    return "<p>something wrong!</p>"
 
if __name__ == "__main__":
    application.run()

## display environment variables in mod_wsgi - shows if wsgi, flask etc is working

from flask import Flask, request, make_response

import sys

application = Flask(__name__)

def showEnv(environ):

version = sys.version

o = "<table>"

o += "<tr>"

o += "<td>Python version</td>"

o += "<td>"+str(version)+"</td>"

for key in environ:

o += "<tr>"

o += "<td>"+str(key)+"</td>"

o += "<td>"+str(environ[key])+"</td>"

o += "</tr>\n"

o += "</table>"

return o

def WSerrorTextHTML(txt):

err = "<p>ERROR!</p>"

err += "<pre>"+ txt + "</pre>"

return err

@application.route('/', methods=['POST', 'GET'])

def indexApp():

try:

env = request.environ

output = 'Hello World!<hr>'

if not env['mod_wsgi.process_group']:

output += 'EMBEDDED MODE<hr>'

else:

output += 'DAEMON MODE<hr>'

output += showEnv(env) + "<hr>"

output += str(request.method) + "<hr>"

output += str(__name__)

return output

except:

import traceback

response = make_response(WSerrorTextHTML(traceback.format_exc()))

response.headers['Content-Type'] = 'text/html'

return response

return "<p>something wrong!</p>"

if __name__ == "__main__":

application.run()

Part 2: Using The Flask Framework
Here I have made a simple demonstration of how to use Flask, it consists of a wrapper, demo.py, the actual program coreDemo.py and some html to process, demo.html. It does not show how to use the GPIO or UART. The wrapper is used to capture error messages and conveniently display them in the web browser. Again save these files into your apache root directory, /var/www and load it using your web browser, http://<pi’s ip address>/demo.py

demo.py:

##
##  filename: demo.py
##
##  this is a wrapper for your main program, its primary purpose is to
##  manage error messages and output your HTML, XML or JSON as required
##
 
from flask import Flask, request, make_response
application = Flask(__name__)
 
import traceback
import os
import sys
CURRENTDIR = os.path.dirname(os.path.abspath(__file__))
if CURRENTDIR not in sys.path:
    sys.path.append(CURRENTDIR)
   
def wsErrorTextHTML(txt):
    ## displays the python error on the web page - useful for debugging
    ## but on a live system would have it save the error to a database and give the user an error number
    err = "<p>ERROR!</p>"
    err += "<pre>"+ txt + "</pre>"
    return err
 
@application.errorhandler(500)
def internalServerError(error):
    err = "<p>ERROR! 500</p>"
    err += "<pre>"+ str(error) + "</pre>"
    err += "<pre>"+ str(traceback.format_exc()) + "</pre>"
    return err
 
@application.route('/', methods=['POST', 'GET'])
def indexApp():
   
    try:
        ##
        ## ...your code goese here...
        ## I normally create a seperate 'core' application, in this case demoCore.py
        ##
        from demoCore import DemoCore
        demoCore = DemoCore()
        htmlData = demoCore.index(request)
 
        ## output your html code
        response = make_response(htmlData)
        response.headers['Content-Type'] = 'text/html'
        return response
    except:
        ## for when you get an error message
        response = make_response(wsErrorTextHTML(traceback.format_exc()))
        response.headers['Content-Type'] = 'text/html'
        return response
 
    response = make_response("unkown!")
    response.headers['Content-Type'] = 'text/html'
    return response
 
if __name__ == "__main__":
    application.debug = True
    application.run()

## filename: demo.py

## this is a wrapper for your main program, its primary purpose is to

## manage error messages and output your HTML, XML or JSON as required

from flask import Flask, request, make_response

application = Flask(__name__)

import traceback

import os

import sys

CURRENTDIR = os.path.dirname(os.path.abspath(__file__))

if CURRENTDIR not in sys.path:

sys.path.append(CURRENTDIR)

def wsErrorTextHTML(txt):

## displays the python error on the web page - useful for debugging

## but on a live system would have it save the error to a database and give the user an error number

err = "<p>ERROR!</p>"

err += "<pre>"+ txt + "</pre>"

return err

@application.errorhandler(500)

def internalServerError(error):

err = "<p>ERROR! 500</p>"

err += "<pre>"+ str(error) + "</pre>"

err += "<pre>"+ str(traceback.format_exc()) + "</pre>"

return err

@application.route('/', methods=['POST', 'GET'])

def indexApp():

try:

## ...your code goese here...

## I normally create a seperate 'core' application, in this case demoCore.py

from demoCore import DemoCore

demoCore = DemoCore()

htmlData = demoCore.index(request)

## output your html code

response = make_response(htmlData)

response.headers['Content-Type'] = 'text/html'

return response

except:

## for when you get an error message

response = make_response(wsErrorTextHTML(traceback.format_exc()))

response.headers['Content-Type'] = 'text/html'

return response

response = make_response("unkown!")

response.headers['Content-Type'] = 'text/html'

return response

if __name__ == "__main__":

application.debug = True

application.run()

demoCore.py:

##
##  filename: demoCore.py
##
 
import os
CURRENTDIR = os.path.dirname(__file__)
BASEDIR    = os.path.dirname(CURRENTDIR)
 
import datetime
 
class DemoCore():
 
    def index(self,request):
        ## reads an html file and does things with it
        ## there are better ways, but they are more complicated
 
        if request.form.get('submitBtn', None) == "submit":
            data = request.form
        else:
            data = "<p>no output recieved</p>"
 
        html = self.showDemoHTML(data)
        return html
 
    def showDemoHTML(self,data):
        ## reads an html file and does things with it
        ## there are better ways, but they are more complicated
 
        today = datetime.datetime.today()
        aDate = datetime.datetime.strftime(today,"%Y-%m-%d %H:%I:%S")
 
        f = open(CURRENTDIR +"/demo.html")
        html = f.read()
        html = html.replace("%TodaysDate%",aDate)
        html = html.replace("%PythonOutput%",str(data))
 
        return html
 
if __name__ == "__main__":
    print "Hello World";
</pre>

## filename: demoCore.py

import os

CURRENTDIR = os.path.dirname(__file__)

BASEDIR = os.path.dirname(CURRENTDIR)

import datetime

class DemoCore():

def index(self,request):

## reads an html file and does things with it

## there are better ways, but they are more complicated

if request.form.get('submitBtn', None) == "submit":

data = request.form

else:

data = "<p>no output recieved</p>"

html = self.showDemoHTML(data)

return html

def showDemoHTML(self,data):

## reads an html file and does things with it

## there are better ways, but they are more complicated

today = datetime.datetime.today()

aDate = datetime.datetime.strftime(today,"%Y-%m-%d %H:%I:%S")

f = open(CURRENTDIR +"/demo.html")

html = f.read()

html = html.replace("%TodaysDate%",aDate)

html = html.replace("%PythonOutput%",str(data))

return html

if __name__ == "__main__":

print "Hello World";

</pre>

demo.html:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>Python/Flask/mod_wsgi Form Demo</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  </head>
 
  <!-- filename: demo.html -->
 
  <body>
      <form action="" method="post" name="form1" id="form1">
          <p>Python/Flask/mod_wsgi Form Demo</p>
          <p>Showing how python can work with apache</p>
          <table>
              <tr>
                  <td style="text-align: right;">Date:</td>
                  <td>%TodaysDate%</td>
              </tr>
              <tr>
                  <td style="text-align: right;">Select:</td>
                  <td>
                      <select name="select">
                          <option value="a1">One</option>
                          <option value="a2">Two</option>
                          <option value="a3">Three</option>
                      </select>
                  </td>
              </tr>
              <tr>
                  <td style="text-align: right;" valign="top">Text</td>
                  <td>
                      <textarea name="text" style="width: 220px; height: 100px;"></textarea>
                  </td>
              </tr>
              <tr>
                  <td colspan="2" style="text-align: right;">
                      <input type="submit" name="submitBtn" value="submit" />
                  </td>
              </tr>
          </table>
          <hr />
          <p>Python Output:</p>
          <div><pre>%PythonOutput%</pre></div>
      </form>
  </body>
</html>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>

<head>

<title>Python/Flask/mod_wsgi Form Demo</title>

</head>

<body>

<p>Python/Flask/mod_wsgi Form Demo</p>

<p>Showing how python can work with apache</p>

<table>

<tr>

<td>%TodaysDate%</td>

</tr>

<tr>

<td style="text-align: right;">Select:</td>

<td>

<option value="a3">Three</option>

</select>

</td>

</tr>

<tr>

<td>

</td>

</tr>

<tr>

</td>

</tr>

</table>

<hr />

<p>Python Output:</p>

<div><pre>%PythonOutput%</pre></div>

</form>

</body>

</html>

Now all you have to do is open the port 80 forwarding on your router, and everyone in the world can make your little buzzer project make noises at two in the morning.

Setup The PI

Setup Windows for SSH

Setup VS Code

Links and Sources

Installation

Configuration

Connecting

Using OpenCV

Links and Sources

1. Making a copy of the SD Card.

2. Resizing the partition

Links and Sources

Alternative Method

Creating an Audiobook

Links and References

Installing BlueZ

Configuring and Starting BlueZ

Testing BlueZ

Those Scripting BlueZ

More Bluetooth Data

Links and Sources

Which IP addresses to use?

Setup the Dongle

Configuring the network

DHCP

Accessing The Internet

Adding a Proxy Server

References and sources:

COMPUTERS, ROBOTS AND PHOTOGRAPHY