Connecting from the University network, I often incur into a very annoying issue, that of blocked ports. I have therefore decided to configure a personal VPN (Virtual Private Network) server where to connect to from university and have true freedom of access to whichever service I would need to use.

The configuration is pretty straight forward, starting by installing the Poptop (pptpd) VPN daemon as follows:

# apt-get install ppp pptpd

To specify the local IP address range the VPN server should assign to the client, edit the file /etc/pptpd.conf:

# nano /etc/pptpd.conf

and add the IP range at the bottom of the file:

localip 192.168.1.xxx
remoteip 192.168.1.110-120

Where xxx is the last byte of the RasPi ip of your choice, and 110-120, for instance, the last byte of the custom range of ip assigned to the clients.

To configure the VPN users, proceed as follows:

# nano /etc/ppp/chap-secrets

and add each user with the syntax:

username * password *

Adapt the line above as needed.

Restart the daemon to apply the changes:

# service pptpd restart

Finally, we need to enable IP forwarding:

# nano /etc/sysctl.conf

by adding or uncommenting:

net.ipv4.ip_forward=1

and apply the changes without the need to reboot the machine:

# sysctl -p

Important note: For the VPN server to work, we need to enable on the router IP protocol 47 (GRE) and forward the TCP port 1723 to the RasPi ip address.

Wireless configuration on Raspbian, and for my particular dongle – a Digicom USBWAVE54 – was pretty straight forward. It requires two steps:

• Drivers installation
• Wireless interface configuration

• Drivers installation

  This section is dongle dependent. I had an old Digicom USBWAVE54 Dongle, which is based on a Zydas ZD1211 chipset, so here’s how I proceeded to install the correct drivers for my dongle:
  
  # apt-get install zd1211-firmware

  which will install the zd1211rw kernel module, loaded when needed.

• Wireless interface configuration

  Once the correct drivers have been installed, we can test whether everything is working so far by plugging the dongle in and checking the kernel messages with:
  
  $ dmesg

  To check the available wireless networks around, run:
  
  $ iwlist wlan0 scan

  It’s time now to configure the connection parameters for the WiFi interface. Let’s create the configuration file for your WiFi network of choice:
  
  # nano /etc/wpa.conf

  and put the following data in it:
  
  network={
ssid="YOUR-SSID"
proto=RSN
key_mgmt=WPA-PSK
pairwise=CCMP TKIP
group=CCMP TKIP
psk="WPA-PASSWORD"
}

  change YOUR-SSID and WPA-PASSWORD accordingly.
  If you want to protect your wpa-password from curious eyes, you can use wpa_passphrase to save an encrypted version of it in the config file as follows:
  
  wpa_passphrase YOUR-SSID WPA-PASSWORD >> /etc/wpa.conf

  Now add the following lines in /etc/network/interfaces to use a dynamic IP assigned by dhcp:
  
  allow-hotplug wlan0
auto wlan0
iface wlan0 inet dhcp

  or the following to use a static IP configuration:
  
  allow-hotplug wlan0
auto wlan0
iface wlan0 inet static
  address 192.168.1.xxx
  netmask 255.255.255.0
  network 192.168.1.0
  broadcast 192.168.1.255
  gateway 192.168.1.1

  Where xxx is the last byte of the local ip of your choice.
  Adapt the lines above to your actual network configuration, your router may have a different ip/submask to deal with.
  Then just restart the networking service with:
  
  /etc/init.d/networking restart

Now it’s time to make my old Creative Live! Cam Vista IM (VF0260) Webcam work on the RasPi, I also tried a new Logitech C270 HD Webcam and they both work flawlessly out of the box.
I have tried three softwares for the webcam, which I previously tested on my desktop machine running Fedora and I wanted to try them also on the Pi. These are:

• fswebcam
• motion
• mjpeg-streamer

Let’s now have a look at them.

• fswebcam:

  fswebcam is the simplest and easiest way to have your webcam capture single frames, also programmatically at a specified timer interval. Of course it’s also possible to call fswebcam from a bash script anytime it’s required, but this is another story.
  To install fswebcam simply run:
  
  # apt-get install fswebcam

  One of the nice features of fswebcam is that it’s possible to add a footer to the capture, where you can specify your text of choice.
  For instance, this is the command I ran fswebcam with:
  
  $ fswebcam -r 640x480 -S 15 --flip h --jpeg 95 --shadow --title "SLB Labs" --subtitle "Home" --info "Monitor: Active @ 1 fpm" --save home.jpg -q -l 60

  switches:
  -r: frame resolution width*height
  -S: numbers of frame to skip for the webcam to capture a stable and well illuminated frame
  --flip: frame flipping, in this case horizontal
  --jpeg: jpeg compression quality
  --shadow: adds a drop shadow to the footer text
  --title, --subtitle, --info: different fields of the footer text
  --save: path and file name where to saved the frame to
  -q: leaves the process running in background
  -l: takes a snapshoot every specified number of seconds
  
  Many more options are described in the man pages of fswebcam
  $ man fswebcam

  This is the output frame sample given by the previous command:
  

  Okay, this wasn’t exactly streaming, so let’s get into more serious stuff.

• motion:

  motion is a rather complete surveillance system with no fancy stuff and straight to the point, yet very customizable. Among what it can do, it is capable of motion detection, frame recording, video recording, timelapse.
  Its installation is as simple as usual:
  
  # apt-get install motion

  It comes with a plain web configuration interface, but first of all we need to specify which port motion will run on. Let’s now edit its configuration file:
  
  # nano /etc/motion/motion.conf

  and look for the settings webcontrol_port (default 8080) and stream_port (default 8081), which refers to the web configuration interface and the streaming port, respectively. Change them as needed or simply get aware of their default values.
  To start motion run:
  
  # motion

  You can now access to the web configuration interface by pointing your browser to:
  
  http://RPI-IP:webcontrol_port

  where RPI-IP is the local IP address of your RasPi and webcontrol_port is the same port set in the config file.
  That said, it’s now possible to browse all the available settings.
  Some of them that are worth a mention are:
  width and height: frame dimensions, camera dependent
  framerate: maximum number of frames to be captured per second
  threshold: number of pixels in the image that must change to trigger the motion detection
  quality: compression level for frame capture
  ffmpeg_timelapse: number of seconds between which to take a frame shoot for timelapse recording
  ffmpeg_bps: constant bitrate for video encoding (ignored for timelapses)
  ffmpeg_variable_bitrate: variable bitrate for video encoding (using a variable bitrate is the only way to get decent timelapse videos, this setting is used for both video motion recording and timelapses)
  and of course the different images/video/timelapses paths where to save the captures to are among the settings you might want to customize.
  Another important feature of motion is that it’s possible to execute any particular command anytime an event starts and/or a picture is captured, this is achieved by the setting on_event_start and on_picture_save.
  For instance it’s possible to send an email and upload the saved picture to an ftp server by setting on_event_start and on_picture_save as follows:
  
  on_event_start sendmail -f YOURFROMEMAIL@gmail.com -t YOURTOEMAIL@gmail.com -u \"SUBJECT\" -m \"Movement has been detected on: %d %m %Y. The time of the movement was: %H:%M (Hour:Minute). The Pictures have been uploaded to your FTP account.\" -s smtp.gmail.com:25 -xu YOURGMAIL@gmail.com -xp YOURGMAILPASSWORD
on_picture_save wput ftp://USERNAME:PASSWORD@YOUTFTP.COM %f

  Like said above, the video stream will be available pointing the browser here:
  
  http://RPI-IP:stream_port

• mjpeg-streamer:

  Another streaming software that I tried was mjpeg-streamer, which is not as features complete as motion, but it is perfect if you just need a video stream. It also provides a web interface to display the stream. I couldn’t find a binary version of mjpeg-streamer for arm processor, so I had to compile it myself as follows.
  
  First off we need mjpg-streamer source code from > here < and save it in your folder of choice. I usually save and extract the source packages under /usr/local/src.
  Position yourself whichever folder the archive has been saved into, and extract the archive with the command:
  
  # tar xvzf mjpg-streamer-r63.tar.gz

  In order to compile mjpg-streamer, we need the libjpeg8-dev libraries, so let's install them first:
  
  # apt-get install libjpeg8-dev

  I also needed to create a symbolic link of one header file which, to me, resulted missing:
  
  # ln -s /usr/include/linux/videodev2.h /usr/include/linux/videodev.h

  Now everything should be set to proceed with the compilation process. Switch to mjpg-streamer newly created folder and compile it with:
  
  # cd mjpg-streamer-r63
# CFLAGS+="-O2 -march=armv6 -mfpu=vfp -mfloat-abi=hard" make

  And that's it. To run mpjg-streamer type the following command:
  
  $ export LD_LIBRARY_PATH=.
$ ./mjpg_streamer -i './input_uvc.so -d /dev/video0 -r 640x480 -f 15' -o './output_http.so -w ./www -p 8080'

  switches:
  -i: configure the input section
  -d: device selection, in case of multiple webcams
  -r: frame resolution width*height
  -f: frame per seconds
  -o: configure the output section
  -w: website folder
  -p: port
  
  It's now possible to get access to the web interface at the address:
  
  http://RPI-IP:8080

Now that the system is installed on the SD card and the ssh service has been configured properly, we’re going to take care of the system and firmware updates; few words have to be said about the system partitioning scheme.
The Raspbian installation consist of two partitions: the fat16 boot partition, that contains the firmware needed to the Pi to boot, and the ext4 system partition.

Raspbian is based on Debian, therefore it uses apt as package handling utility. To proceed with a full system update, simply issue the following command:

# apt-get update && apt-get upgrade

If you desire to continue, confirm it with Y when asked by the interactive update process.
The first part of the command will update the packets’ list to the latest version available, whilst the second part of the command will actually download and install the updated packages.
Just a reminder that the downloaded packages will be kept in the apt cache folder located at /var/cache/apt/archives. It’s possible to get rid of such files as follows:

# apt-get clean

The update process could possibly also update the kernel, but for a more up to date copy of the firmware we’ll count on the rpi-update utility.
As mentioned by the instructions found here at the git repository of the project, to install the tool, run the following command as root:

# wget http://goo.gl/1BOfJ -O /usr/bin/rpi-update && chmod +x /usr/bin/rpi-update

this would download and set the permissions to the rpi-update script.
To succesfully run the updater, the package git-core is needed, installing it by:

# apt-get install git-core

Now everything is ready to proceed with the firmware update:

# rpi-update

Let it run for a couple of minutes and if a new version of the firmware is available, it’ll be downloaded to the boot partition and will be available upon reboot.

One more thing to say is about the memory split setting. The Pi is equipped with 256MB of RAM shared between the system and the GPU. It is possible to pick one among the following memory split choices:

SYS/GPU
128/128
192/ 64
224/ 32
240/ 16

copying the relative file located in /boot over the file start.elf.
For instance, to give 240MB to the system and 16MB to the GPU, do as follows:

# cp /boot/arm240_start.elf /boot/start.elf

Reboot the system to make the changes final.

# reboot

By the time I received my RasPi, I didn’t have an usb keyboard yet, so my first concern was about how to use it without the keyboard from the very first boot. It wasn’t clear whether the ssh daemon would be active by default or not, and I’ve also got to know that for some distributions, or even among different updates of the same distribution, its default state changed over time.
I found out that in Raspbian, ssh is installed by default but it’s not configured to start up automatically since the first boot.

Being it a SystemV style OS, I proceeded as follow to enable the ssh daemon at boot.
After plugging the SD card in, and mounting the system partition on the SD card to my Fedora installation, I created the symbolic links for ssh to start at boot time as follows:

# ln -s etc/init.d/ssh etc/rc2.d/S02ssh

and repeated the process for the other runlevels of interest, in my case from 2 to 5.
Now the ssh service would start at boot time and would accept incoming connections.

I could have stopped here with the configuration to be able to access my brand new Pi, but I also wanted to configure the network with a static IP, for my own convenience and ease of NAT rules configuration on the router.
Raspbian comes with the nano text editor, so let’s get into the interface configuration by editing the config file as follows:

# nano etc/network/interfaces

change the iface eth0 inet dhcp line to iface eth0 inet static and add the further details:

  address 192.168.1.xxx
  netmask 255.255.255.0
  network 192.168.1.0
  broadcast 192.168.1.255
  gateway 192.168.1.1

Where xxx is the last byte of the local ip of your choice.
Adapt the lines above to your actual network configuration, your router may have a different ip/submask to deal with.

Now it’s time to boot the Pi and connect to it via ssh:

$ ssh pi@192.168.1.xxx

or if you need to use graphical applications

$ ssh -X pi@192.168.1.xxx

Note that the default pair of user/password for Raspbian is:

user: pi
password: raspberry

Very important note: once you get access to your Pi, do regenerate the SSH keys.
Since Raspbian (and basically all the other distributions) are distributed as prepared images to copy onto the SD card, it is not safe to keep the default SSH keys.
To regenerate the keys proceed as follows:

# rm /etc/ssh/ssh_host_*
# dpkg-reconfigure openssh-server

Download the image:

First step would of course be that to choose and install a linux distribution on the SD card.
I’m personally a RedHat/Fedora user since quite some time but I thought, for the RasPi, to give Debian a go. I decided to install Raspbian “wheezy”, an optimised version of Debian for the Raspberry Pi, and it comes with LXDE as default desktop environment, for those who care about it.
You can download the image from the RaspberryPi Downloads page.
 

Write the image on the SD card:

The Raspbian image, and most likely that of other distributions, comes in some sort of zipped archive, being it zip, gzip, bzip2 and so on. So before proceeding, unzip the image with your tool of choice.

• Writing the image in Linux:

  To write the image in Linux, plug the SD card into the reader, or the SD-to-USB adapter and check the device node with:
  
  $ dmesg | tail

  That will give you the device node associated with the SD card.
  I assume here to obtain /dev/sdb as device node, and /dev/sdb1 as partition node.
  Be sure to unmount the partition before proceeding with the image writing.
  
  # umount /dev/sdb1

  Now to write the image onto the SD card, issue the following command:
  
  # dd bs=1M if=/path/to/the/image/file.img of=/dev/sdb

  Note that the dd command must be issued onto the device node, not onto the partition itself.
  At this point the image will be written to the SD card. Remember to sync any possible buffers with:
  
  $ sync

  When done, remove the SD card and you’re ready to go.

• Writing the image in Windows:

  To write the image in Windows, simply download Win32DiskImager.
  Plug the SD and execute Win32DiskImager. It will let you select the image to write on the card, select the device to write the image to, and you’re done.

It’s been almost one month since I received my Raspberry Pi. I actually received two of them, both on day 18th of July, one from Farnell/Element14 via Royal Mail and the other one from RS Components via DHL, which I got for my friend Giuseppe. So far so good, the little RasPi is behaving very well, and I’m testing its stability keeping it up and running, checking cpu and memory usage.
I installed the system on a Sony 8GB SDHC Class 4 card, which I got along with my Sony HX9V camera, bought in Hong Kong a couple of years ago. I’m surprised by the speed of this sd card, achieving 17.4MB/s in read speed and 11.8MB/s in write speed, checked on the RasPi itself with a dd test.
As PSU I’m using my HTC Legend phone charger, rated 5V/1A, which is flawlessly powering it up, by now, for one good week already.
I plan to write some posts as I go developing stuff with it, hopefully and time permitting, so if you are interested, stay tuned : )

Back from my second round in Hong Kong and I brought back some nice Durian seeds to try to plant. After about two months in the soil, a little plant has come out and in three weeks since then it has grown up to 14 cm already!
Here some more pics of my little growing Durian tree.

 

 

 

HDR Two International Finance Centre (2IFC)
Hong Kong, 2012.04.28.

–
Artwork Copyright © 2012 Salvatore La Bua

This work is released under the terms of:

Creative Commons lincense [by-nc-nd]
Attribution
Non Commercial
No Derivative Works

HDR Horse, Tai Wai, Sha Tin District.
Hong Kong, 2012.04.24.

–
Artwork Copyright © 2012 Salvatore La Bua

This work is released under the terms of:

Creative Commons lincense [by-nc-nd]
Attribution
Non Commercial
No Derivative Works