eLinux.org - User contributions [en]

ECE497 Beagle VNS

2012-11-14T04:16:45Z

Geislekj: /* Conclusions */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we are able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encod the recording into a mp3 file and send it via an email attachment to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use, who to send the email message too, as well as what text to populate the subject and body field with.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The node.js server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]
[[File:BeagleVNS_Door_Bell.jpg|thumb|right|A door bell button is a good idea]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email, and that we have been working under Python 2.7 and did not need to modify our code for version 3.0 syntax.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*'''Node.js'''

::Node.js is a tool for quickly make web or browser based interfaces for networking with the beagle or any comparable platform.

:: Installation instructions can be found here: [[ECE497 Notes on node.js | ECE497 Notes on node.js]]

== Install Instructions ==

::In order to run this application the ALSA library must be installed.
::Node.js is an optional installation if you would like a web interface for changing the email preferences file.

::No other installation is required. The application developed is available on a git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your '''home directory''' to get up and running first before modifying anything for your own application. Otherwise the program will not work. Follow the github section below to download the repository.

::To download the code for the Beagle VNS run the following code:

beagle$ '''cd'''
beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Restart the Network'''
:::If you cannot grab an ip address from a dns server when the A5 image initially boots up. Run the following command in order to restart the network service

beagle$ '''/etc/init.d/networking restart'''

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Beagle VNS Application'''

::: In order to run the Beagle VNS Application you will need go to the C-Programs Directory

beagle$ '''cd ~/BeagleBoardVNS/C-Program/'''

::: Once you are in this directory, you will need to compile the application.

beagle$ '''make clean; make'''

::: Now you can run the application. There is currently only a debug version of the application. This verision will print out debug information which is helpful to see what is going on.

beagle$ '''./beagleVNSApp_DEBUG'''

::: You can also start the node.js server to edit the configuration file. Simply run the command below in the BeagleBoardVNS destroyer and then point your browser to the beaglebone's port 8081 with a URL or host name, i.e: beagleVNS.local:8081

beagle$ '''node BeagleBoardVNS.js'''

::: Note that you can change your host name by editing this file: /etc/hostname. For example:

beagle$ '''nano /etc/hostname'''

== Highlights ==

[http://www.youtube.com/watch?v=k7yUmo1zc0Q BeagleVNS YouTube Video Demo]

[http://www.youtube.com/embed/k7yUmo1zc0Q BeagleVNS YouTube Video Demo]

== Theory of Operation ==

[[File:BeagleVNSDiagram.jpg|640px|thumb|right|BeagleBone]]

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::If you run the C-Program the audio collection will work. However, the web interface is a separate service you will need to start.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio or achieve files locally
# Capture video along with audio or capture image upon button press
# Voice-To-Text using Google Voice API
# Low Power Mode for longer battery life using interupts
# Release alsa device for other aplications when not in use
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Overall, we currently have a working version of the Beagle VNS. There are two separate parts to the project. The Beagle C-Program records the audio and sends an email with an mp3 attachment. There is also a web interface which will allow a user to change the default sender and recipient email address. Some cool additions to the project would be to be able to take an video and audio message, as well as incorporate a wireless driver.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-14T04:15:14Z

Geislekj: /* Install Instructions */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we are able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encod the recording into a mp3 file and send it via an email attachment to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use, who to send the email message too, as well as what text to populate the subject and body field with.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The node.js server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]
[[File:BeagleVNS_Door_Bell.jpg|thumb|right|A door bell button is a good idea]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email, and that we have been working under Python 2.7 and did not need to modify our code for version 3.0 syntax.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*'''Node.js'''

::Node.js is a tool for quickly make web or browser based interfaces for networking with the beagle or any comparable platform.

:: Installation instructions can be found here: [[ECE497 Notes on node.js | ECE497 Notes on node.js]]

== Install Instructions ==

::In order to run this application the ALSA library must be installed.
::Node.js is an optional installation if you would like a web interface for changing the email preferences file.

::No other installation is required. The application developed is available on a git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your '''home directory''' to get up and running first before modifying anything for your own application. Otherwise the program will not work. Follow the github section below to download the repository.

::To download the code for the Beagle VNS run the following code:

beagle$ '''cd'''
beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Restart the Network'''
:::If you cannot grab an ip address from a dns server when the A5 image initially boots up. Run the following command in order to restart the network service

beagle$ '''/etc/init.d/networking restart'''

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Beagle VNS Application'''

::: In order to run the Beagle VNS Application you will need go to the C-Programs Directory

beagle$ '''cd ~/BeagleBoardVNS/C-Program/'''

::: Once you are in this directory, you will need to compile the application.

beagle$ '''make clean; make'''

::: Now you can run the application. There is currently only a debug version of the application. This verision will print out debug information which is helpful to see what is going on.

beagle$ '''./beagleVNSApp_DEBUG'''

::: You can also start the node.js server to edit the configuration file. Simply run the command below in the BeagleBoardVNS destroyer and then point your browser to the beaglebone's port 8081 with a URL or host name, i.e: beagleVNS.local:8081

beagle$ '''node BeagleBoardVNS.js'''

::: Note that you can change your host name by editing this file: /etc/hostname. For example:

beagle$ '''nano /etc/hostname'''

== Highlights ==

[http://www.youtube.com/watch?v=k7yUmo1zc0Q BeagleVNS YouTube Video Demo]

[http://www.youtube.com/embed/k7yUmo1zc0Q BeagleVNS YouTube Video Demo]

== Theory of Operation ==

[[File:BeagleVNSDiagram.jpg|640px|thumb|right|BeagleBone]]

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::If you run the C-Program the audio collection will work. However, the web interface is a separate service you will need to start.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio or achieve files locally
# Capture video along with audio or capture image upon button press
# Voice-To-Text using Google Voice API
# Low Power Mode for longer battery life using interupts
# Release alsa device for other aplications when not in use
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Overall, we currently have a working version of the Beagle VNS. There are two separate parts to the project. The Beagle C-Program records the audio and sends an email with an mp3 attachment. There is also a web interface which will allow a user to change the default sender and recipient email address. Some cool additions the the project would be to be able to take an video and audio message, as well as incorporate a wireless driver.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-14T04:14:39Z

Geislekj:

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we are able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encod the recording into a mp3 file and send it via an email attachment to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use, who to send the email message too, as well as what text to populate the subject and body field with.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The node.js server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]
[[File:BeagleVNS_Door_Bell.jpg|thumb|right|A door bell button is a good idea]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email, and that we have been working under Python 2.7 and did not need to modify our code for version 3.0 syntax.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*'''Node.js'''

::Node.js is a tool for quickly make web or browser based interfaces for networking with the beagle or any comparable platform.

:: Installation instructions can be found here: [[ECE497 Notes on node.js | ECE497 Notes on node.js]]

== Install Instructions ==

::In order to run this application the ALSA library must be installed.
::NodeJS is an optional installation if you would like a web interface for changing the email preferences file.

::No other installation is required. The application developed is available on a git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your '''home directory''' to get up and running first before modifying anything for your own application. Otherwise the program will not work. Follow the github section below to download the repository.

::To download the code for the Beagle VNS run the following code:

beagle$ '''cd'''
beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Restart the Network'''
:::If you cannot grab an ip address from a dns server when the A5 image initially boots up. Run the following command in order to restart the network service

beagle$ '''/etc/init.d/networking restart'''

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Beagle VNS Application'''

::: In order to run the Beagle VNS Application you will need go to the C-Programs Directory

beagle$ '''cd ~/BeagleBoardVNS/C-Program/'''

::: Once you are in this directory, you will need to compile the application.

beagle$ '''make clean; make'''

::: Now you can run the application. There is currently only a debug version of the application. This verision will print out debug information which is helpful to see what is going on.

beagle$ '''./beagleVNSApp_DEBUG'''

::: You can also start the node.js server to edit the configuration file. Simply run the command below in the BeagleBoardVNS destroyer and then point your browser to the beaglebone's port 8081 with a URL or host name, i.e: beagleVNS.local:8081

beagle$ '''node BeagleBoardVNS.js'''

::: Note that you can change your host name by editing this file: /etc/hostname. For example:

beagle$ '''nano /etc/hostname'''

== Highlights ==

[http://www.youtube.com/watch?v=k7yUmo1zc0Q BeagleVNS YouTube Video Demo]

[http://www.youtube.com/embed/k7yUmo1zc0Q BeagleVNS YouTube Video Demo]

== Theory of Operation ==

[[File:BeagleVNSDiagram.jpg|640px|thumb|right|BeagleBone]]

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::If you run the C-Program the audio collection will work. However, the web interface is a separate service you will need to start.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio or achieve files locally
# Capture video along with audio or capture image upon button press
# Voice-To-Text using Google Voice API
# Low Power Mode for longer battery life using interupts
# Release alsa device for other aplications when not in use
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Overall, we currently have a working version of the Beagle VNS. There are two separate parts to the project. The Beagle C-Program records the audio and sends an email with an mp3 attachment. There is also a web interface which will allow a user to change the default sender and recipient email address. Some cool additions the the project would be to be able to take an video and audio message, as well as incorporate a wireless driver.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T17:50:46Z

Geislekj: /* User Instructions */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have been able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encoding the recording into a mp3 file and send it via an email message to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use and where to send the email message.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The nodejs server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

== Install Instructions ==

::In order to run this application the ALSA library must be installed.
::NodeJS is an optional installation if you would like a web interface for changing the email preferences file.

::No other installation is required. The application developed is available on a git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your '''home directory''' to get up and running first before modifying anything for your own application. Otherwise the program will not work. Follow the github section below to download the repository.

::To download the code for the Beagle VNS run the following code:

beagle$ '''cd'''
beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Restart the Network'''
:::If you cannot grab an ip address from a dns server when the A5 image initially boots up. Run the following command in order to restart the network service

beagle$ '''/etc/init.d/networking restart'''

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Beagle VNS Application'''

::: In order to run the Beagle VNS Application you will need go to the C-Programs Directory

beagle$ '''cd ~/BeagleBoardVNS/C-Program/'''

::: Once you are in this directory, you will need to compile the application.

beagle$ '''make clean; make'''

::: Now you can run the application. There is currently only a debug version of the application. This verision will print out debug information which is helpful to see what is going on.

beagle$ '''./beagleVNSApp_DEBUG'''

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::If you run the C-Program the audio collection will work. However, the web interface is a separate service you will need to start.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio files
# Capture video along with audio
# Voice-To-Text
# Low Power Mode for longer battery life
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Overall, we currently have a working version of the Beagle VNS. There are two separate parts to the project. The Beagle C-Program records the audio and sends an email with an mp3 attachment. There is also a web interface which will allow a user to change the default sender and recipient email address. Some cool additions the the project would be to be able to take an video and audio message, as well as incorporate a wireless driver.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T17:43:28Z

Geislekj: /* User Instructions */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have been able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encoding the recording into a mp3 file and send it via an email message to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use and where to send the email message.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The nodejs server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

== Install Instructions ==

::In order to run this application the ALSA library must be installed.
::NodeJS is an optional installation if you would like a web interface for changing the email preferences file.

::No other installation is required. The application developed is available on a git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your '''home directory''' to get up and running first before modifying anything for your own application. Otherwise the program will not work. Follow the github section below to download the repository.

::To download the code for the Beagle VNS run the following code:

beagle$ '''cd'''
beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Restart the Network'''
:::If you cannot grab an ip address from a dns server when the A5 image initially boots up. Run the following command in order to restart the network service

beagle$ '''/etc/init.d/networking restart'''

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::If you run the C-Program the audio collection will work. However, the web interface is a separate service you will need to start.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio files
# Capture video along with audio
# Voice-To-Text
# Low Power Mode for longer battery life
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Overall, we currently have a working version of the Beagle VNS. There are two separate parts to the project. The Beagle C-Program records the audio and sends an email with an mp3 attachment. There is also a web interface which will allow a user to change the default sender and recipient email address. Some cool additions the the project would be to be able to take an video and audio message, as well as incorporate a wireless driver.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T17:40:36Z

Geislekj: /* Install Instructions */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have been able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encoding the recording into a mp3 file and send it via an email message to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use and where to send the email message.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The nodejs server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

== Install Instructions ==

::In order to run this application the ALSA library must be installed.
::NodeJS is an optional installation if you would like a web interface for changing the email preferences file.

::No other installation is required. The application developed is available on a git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your '''home directory''' to get up and running first before modifying anything for your own application. Otherwise the program will not work. Follow the github section below to download the repository.

::To download the code for the Beagle VNS run the following code:

beagle$ '''cd'''
beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::If you run the C-Program the audio collection will work. However, the web interface is a separate service you will need to start.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio files
# Capture video along with audio
# Voice-To-Text
# Low Power Mode for longer battery life
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Overall, we currently have a working version of the Beagle VNS. There are two separate parts to the project. The Beagle C-Program records the audio and sends an email with an mp3 attachment. There is also a web interface which will allow a user to change the default sender and recipient email address. Some cool additions the the project would be to be able to take an video and audio message, as well as incorporate a wireless driver.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T17:40:08Z

Geislekj: /* Software */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have been able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encoding the recording into a mp3 file and send it via an email message to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use and where to send the email message.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The nodejs server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

== Install Instructions ==

::In order to run this application the ALSA library must be installed.
::NodeJS is an optional installation if you would like a web interface for changing the email preferences file.

::No other installation is required. The application developed is available on a git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your '''home directory''' to get up and running first before modifying anything for your own application. Otherwise the program will not work. Follow the github section below to download the repository.

*'''github'''

::To download the code for the Beagle VNS run the following code:

beagle$ '''cd'''
beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::If you run the C-Program the audio collection will work. However, the web interface is a separate service you will need to start.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio files
# Capture video along with audio
# Voice-To-Text
# Low Power Mode for longer battery life
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Overall, we currently have a working version of the Beagle VNS. There are two separate parts to the project. The Beagle C-Program records the audio and sends an email with an mp3 attachment. There is also a web interface which will allow a user to change the default sender and recipient email address. Some cool additions the the project would be to be able to take an video and audio message, as well as incorporate a wireless driver.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T17:39:47Z

Geislekj: /* Install Instructions */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have been able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encoding the recording into a mp3 file and send it via an email message to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use and where to send the email message.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The nodejs server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

== Install Instructions ==

::In order to run this application the ALSA library must be installed.
::NodeJS is an optional installation if you would like a web interface for changing the email preferences file.

::No other installation is required. The application developed is available on a git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your '''home directory''' to get up and running first before modifying anything for your own application. Otherwise the program will not work. Follow the github section below to download the repository.

*'''github'''

::To download the code for the Beagle VNS run the following code:

beagle$ '''cd'''
beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::If you run the C-Program the audio collection will work. However, the web interface is a separate service you will need to start.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio files
# Capture video along with audio
# Voice-To-Text
# Low Power Mode for longer battery life
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Overall, we currently have a working version of the Beagle VNS. There are two separate parts to the project. The Beagle C-Program records the audio and sends an email with an mp3 attachment. There is also a web interface which will allow a user to change the default sender and recipient email address. Some cool additions the the project would be to be able to take an video and audio message, as well as incorporate a wireless driver.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T17:39:05Z

Geislekj: /* Install Instructions */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have been able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encoding the recording into a mp3 file and send it via an email message to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use and where to send the email message.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The nodejs server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

== Install Instructions ==

::In order to run this application the ALSA library must be installed.
::NodeJS is an optional installation if you would like a web interface for changing the email preferences file.

::No other installation is required. The application developed is available on a git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your '''home directory''' to get up and running first before modifying anything for your own application. Otherwise the program will not work. Follow the github section below to download the repository.

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

::To download the code for the Beagle VNS run the following code:

beagle$ '''cd'''
beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::If you run the C-Program the audio collection will work. However, the web interface is a separate service you will need to start.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio files
# Capture video along with audio
# Voice-To-Text
# Low Power Mode for longer battery life
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Overall, we currently have a working version of the Beagle VNS. There are two separate parts to the project. The Beagle C-Program records the audio and sends an email with an mp3 attachment. There is also a web interface which will allow a user to change the default sender and recipient email address. Some cool additions the the project would be to be able to take an video and audio message, as well as incorporate a wireless driver.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T17:28:44Z

Geislekj: /* Software */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have been able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encoding the recording into a mp3 file and send it via an email message to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use and where to send the email message.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The nodejs server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

== Install Instructions ==

*'''Install Instructions'''

::Currently as long as the arecord libraries are installed and nodejs is install, no other installation is required. The app file will use files that are contained in the git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your home directory to get up and running first before modifying anything for your own application.

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::If you run the C-Program the audio collection will work. However, the web interface is a separate service you will need to start.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio files
# Capture video along with audio
# Voice-To-Text
# Low Power Mode for longer battery life
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Overall, we currently have a working version of the Beagle VNS. There are two separate parts to the project. The Beagle C-Program records the audio and sends an email with an mp3 attachment. There is also a web interface which will allow a user to change the default sender and recipient email address. Some cool additions the the project would be to be able to take an video and audio message, as well as incorporate a wireless driver.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T17:28:00Z

Geislekj: /* Software */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have been able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encoding the recording into a mp3 file and send it via an email message to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use and where to send the email message.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The nodejs server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

::To download the code for the Beagle VNS run the following code:

beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*GStreamer

::GStreamer is an application that allows the user to capture video from a camera for multiple types of solutions. For this project, it is being used to capture an image of the person leaving a message.

::Instructions to install GStreamer is still in the process of being developed.

== Install Instructions ==

*'''Install Instructions'''

::Currently as long as the arecord libraries are installed and nodejs is install, no other installation is required. The app file will use files that are contained in the git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your home directory to get up and running first before modifying anything for your own application.

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::If you run the C-Program the audio collection will work. However, the web interface is a separate service you will need to start.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio files
# Capture video along with audio
# Voice-To-Text
# Low Power Mode for longer battery life
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Overall, we currently have a working version of the Beagle VNS. There are two separate parts to the project. The Beagle C-Program records the audio and sends an email with an mp3 attachment. There is also a web interface which will allow a user to change the default sender and recipient email address. Some cool additions the the project would be to be able to take an video and audio message, as well as incorporate a wireless driver.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T17:26:56Z

Geislekj: /* User Instructions */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have been able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encoding the recording into a mp3 file and send it via an email message to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use and where to send the email message.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The nodejs server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

::To download the code for the Beagle VNS run the following code:

beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*GStreamer

::GStreamer is an application that allows the user to capture video from a camera for multiple types of solutions. For this project, it is being used to capture an image of the person leaving a message.

::Instructions to install GStreamer is still in the process of being developed.

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::If you run the C-Program the audio collection will work. However, the web interface is a separate service you will need to start.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio files
# Capture video along with audio
# Voice-To-Text
# Low Power Mode for longer battery life
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Overall, we currently have a working version of the Beagle VNS. There are two separate parts to the project. The Beagle C-Program records the audio and sends an email with an mp3 attachment. There is also a web interface which will allow a user to change the default sender and recipient email address. Some cool additions the the project would be to be able to take an video and audio message, as well as incorporate a wireless driver.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T17:13:27Z

Geislekj: /* Conclusions */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have been able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encoding the recording into a mp3 file and send it via an email message to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use and where to send the email message.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The nodejs server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

::To download the code for the Beagle VNS run the following code:

beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*GStreamer

::GStreamer is an application that allows the user to capture video from a camera for multiple types of solutions. For this project, it is being used to capture an image of the person leaving a message.

::Instructions to install GStreamer is still in the process of being developed.

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

Send To (Separated by a comma):
Files (Separated by a comma):
Send From: beagle497@gmail.com #Must use this email for now
Subject:
Message:

*'''Install Instructions'''

::Currently as long as the arecord libraries are installed and nodejs is install, no other installation is required. The app file will use files that are contained in the git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your home directory to get up and running first before modifying anything for your own application.

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::If you run the C-Program the audio collection will work. However, the web interface is a separate service you will need to start.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio files
# Capture video along with audio
# Voice-To-Text
# Low Power Mode for longer battery life
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Overall, we currently have a working version of the Beagle VNS. There are two separate parts to the project. The Beagle C-Program records the audio and sends an email with an mp3 attachment. There is also a web interface which will allow a user to change the default sender and recipient email address. Some cool additions the the project would be to be able to take an video and audio message, as well as incorporate a wireless driver.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T17:04:11Z

Geislekj: /* Work Breakdown */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have been able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encoding the recording into a mp3 file and send it via an email message to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use and where to send the email message.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The nodejs server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

::To download the code for the Beagle VNS run the following code:

beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*GStreamer

::GStreamer is an application that allows the user to capture video from a camera for multiple types of solutions. For this project, it is being used to capture an image of the person leaving a message.

::Instructions to install GStreamer is still in the process of being developed.

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

Send To (Separated by a comma):
Files (Separated by a comma):
Send From: beagle497@gmail.com #Must use this email for now
Subject:
Message:

*'''Install Instructions'''

::Currently as long as the arecord libraries are installed and nodejs is install, no other installation is required. The app file will use files that are contained in the git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your home directory to get up and running first before modifying anything for your own application.

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::If you run the C-Program the audio collection will work. However, the web interface is a separate service you will need to start.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio files
# Capture video along with audio
# Voice-To-Text
# Low Power Mode for longer battery life
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting. Need More Cake Want to discuss alsa limitations that prevented more advanced recording methods.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T17:02:18Z

Geislekj: /* Executive Summary */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have been able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encoding the recording into a mp3 file and send it via an email message to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use and where to send the email message.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The nodejs server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

::To download the code for the Beagle VNS run the following code:

beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*GStreamer

::GStreamer is an application that allows the user to capture video from a camera for multiple types of solutions. For this project, it is being used to capture an image of the person leaving a message.

::Instructions to install GStreamer is still in the process of being developed.

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

Send To (Separated by a comma):
Files (Separated by a comma):
Send From: beagle497@gmail.com #Must use this email for now
Subject:
Message:

*'''Install Instructions'''

::Currently as long as the arecord libraries are installed and nodejs is install, no other installation is required. The app file will use files that are contained in the git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your home directory to get up and running first before modifying anything for your own application.

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::This is a c program that exist in the C-Program Directory.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio files
# Capture video along with audio
# Voice-To-Text
# Low Power Mode for longer battery life
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting. Need More Cake Want to discuss alsa limitations that prevented more advanced recording methods.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T16:59:03Z

Geislekj: /* Future Work */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have have been able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encoding the recording into a mp3 file and send it via an email message to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use and where to send the email message.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The nodejs server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

::To download the code for the Beagle VNS run the following code:

beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*GStreamer

::GStreamer is an application that allows the user to capture video from a camera for multiple types of solutions. For this project, it is being used to capture an image of the person leaving a message.

::Instructions to install GStreamer is still in the process of being developed.

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

Send To (Separated by a comma):
Files (Separated by a comma):
Send From: beagle497@gmail.com #Must use this email for now
Subject:
Message:

*'''Install Instructions'''

::Currently as long as the arecord libraries are installed and nodejs is install, no other installation is required. The app file will use files that are contained in the git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your home directory to get up and running first before modifying anything for your own application.

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::This is a c program that exist in the C-Program Directory.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio files
# Capture video along with audio
# Voice-To-Text
# Low Power Mode for longer battery life
# Authentication
# Wireless Communication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting. Need More Cake Want to discuss alsa limitations that prevented more advanced recording methods.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T16:58:28Z

Geislekj: /* Future Work */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have have been able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encoding the recording into a mp3 file and send it via an email message to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use and where to send the email message.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The nodejs server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

::To download the code for the Beagle VNS run the following code:

beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*GStreamer

::GStreamer is an application that allows the user to capture video from a camera for multiple types of solutions. For this project, it is being used to capture an image of the person leaving a message.

::Instructions to install GStreamer is still in the process of being developed.

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

Send To (Separated by a comma):
Files (Separated by a comma):
Send From: beagle497@gmail.com #Must use this email for now
Subject:
Message:

*'''Install Instructions'''

::Currently as long as the arecord libraries are installed and nodejs is install, no other installation is required. The app file will use files that are contained in the git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your home directory to get up and running first before modifying anything for your own application.

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::This is a c program that exist in the C-Program Directory.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface to manage audio files
# Capture video along with audio
# Voice-To-Text
# Low Power Mode for longer battery life
# Authentication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting. Need More Cake Want to discuss alsa limitations that prevented more advanced recording methods.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T16:57:52Z

Geislekj: /* Python */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have have been able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encoding the recording into a mp3 file and send it via an email message to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use and where to send the email message.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The nodejs server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

::To download the code for the Beagle VNS run the following code:

beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*GStreamer

::GStreamer is an application that allows the user to capture video from a camera for multiple types of solutions. For this project, it is being used to capture an image of the person leaving a message.

::Instructions to install GStreamer is still in the process of being developed.

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

Send To (Separated by a comma):
Files (Separated by a comma):
Send From: beagle497@gmail.com #Must use this email for now
Subject:
Message:

*'''Install Instructions'''

::Currently as long as the arecord libraries are installed and nodejs is install, no other installation is required. The app file will use files that are contained in the git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your home directory to get up and running first before modifying anything for your own application.

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::This is a c program that exist in the C-Program Directory.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

This is the Python script that is used to email a message with an attachment.

<pre>

import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()

</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface using HTML and NodeJS
# Web Interface to manage audio files
# Capture video along with audio
# Voice-To-Text
# Low Power Mode for longer battery life
# Authentication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting. Need More Cake Want to discuss alsa limitations that prevented more advanced recording methods.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T16:55:50Z

Geislekj: /* C */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Grading Template ==
I'm using the following template to grade. Each slot is 10 points.
0 = Missing, 5=OK, 10=Wow!

<pre style="color:red">
10 Executive Summary (Looks good. Be sure to keep it up to date)
00 Installation Instructions (I suggest putting the Hardware section before the software)
05 User Instructions (How do I make sendmail work on my Bone?)
00 Highlights (Not done yet)
00 Theory of Operation (ditto)
10 Work Breakdown
00 Future Work
00 Conclusions
00 Demo
00 Late
Comments: I'm looking forward to seeing the completed project.

Score: 25/100
</pre>

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have have been able to successfully capture audio while a user presses and holds a button. Once the button is released, there is a python script that will encoding the recording into a mp3 file and send it via an email message to a predetermined email address. We have also developed a web interface that will allow a user to change the preferences for what email account to use and where to send the email message.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we have a functioning project that consist of a C program, python script, bash script, and nodejs webserver. The C program controls how the audio is recorded. The python script controls sending emails with attachments. The bash script is in charge of moving the audio file, converting it to mp3, and firing the python script. The nodejs server controlls the preference file for the python script.

== Hardware ==
[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.png|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

::To download the code for the Beagle VNS run the following code:

beagle$ '''git clone git://github.com/geislekj/BeagleBoardVNS.git'''

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer alsa-dev alsa-utils'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*GStreamer

::GStreamer is an application that allows the user to capture video from a camera for multiple types of solutions. For this project, it is being used to capture an image of the person leaving a message.

::Instructions to install GStreamer is still in the process of being developed.

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ '''arecord -D plughw:0,0 | aplay'''

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ '''arecord -D plughw:0,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3'''

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

Send To (Separated by a comma):
Files (Separated by a comma):
Send From: beagle497@gmail.com #Must use this email for now
Subject:
Message:

*'''Install Instructions'''

::Currently as long as the arecord libraries are installed and nodejs is install, no other installation is required. The app file will use files that are contained in the git repository. The python script does not need any additional packages, and the javascript libraries are also located in the repository.

::For simplicity and clarity when reading and understanding the code, as well as some limitations with using mix of C, Python, and bash scripts, there exists some hard-coded references dependencies. As such, we suggest cloning the repo to your home directory to get up and running first before modifying anything for your own application.

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

This device is intended to record audio messages from students when professors are out of their office. The device will sit outside a professors office and will have a microphone and user button attached. A student who wishes to leave a message will press and hold the button then begin speaking, when the student has finished speaking they will release the button. The software will then save the audio file and then send the file as a mp3 to the user specified email.

As a user the professor will be able to modify the default preferences such as email to send to and the message that they receive.

The system consists of a C program that will need to be started and checks for the button press. When it picks up that the button has been pressed it collects audio until the button is released. The system then calls on a python mail client script passing in the location of the newly created audio file. The python script then reads from the user preferences and sends an email accordingly.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
:::Passing capture video on to Ruffin
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google voice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending complete
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom & Ruffin
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is complete it is in the C-Program Directory
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::This is a c program that exist in the C-Program Directory.

== Code ==

=== C ===

The following C application is used to collect audio from the Playstation Eye and then write it to a file when a gpio button is being pressed. Once the pgio button is released, the program runs a bash file that will encode the raw audio into mp3 and email it.

<pre>

/*
* main.c
*
*/

// Standard Linux headers
#include <stdio.h> // Always include this header
#include <stdlib.h> // Always include this header
#include <signal.h> // Defines signal-handling functions (i.e. trap Ctrl-C)
#include <fcntl.h> // Defines open, read, write methods
#include <unistd.h> // Defines close and sleep methods
//#include <string.h> // Defines memcpy
#include <alsa/asoundlib.h> // ALSA includes

// Application headers
#include "debug.h"
//#include "audio_thread.h"
#include "gpio.h"
#include "audio_input_output.h" // Audio driver input and output functions

//* ALSA and Mixer devices **
#define SOUND_DEVICE "plughw:0,0" // This uses line in
//#define SOUND_DEVICE "plughw:1,0" // This uses the PS EYE mikes

//* Output file name **
#define OUTFILE "/tmp/audio.raw"

//* The sample rate of the audio codec **
#define SAMPLE_RATE 8000

//* The gain (0-100) of the left channel **
#define LEFT_GAIN 100

//* The gain (0-100) of the right channel **
#define RIGHT_GAIN 100

//* Parameters for audio thread execution **
#define BLOCKSIZE 48000

// Success and failure definitions for the thread
#define AUDIO_THREAD_SUCCESS ( ( void * ) 0 )
#define AUDIO_THREAD_FAILURE ( ( void * ) - 1 )

// The levels of initialization for initMask
#define INPUT_ALSA_INITIALIZED 0x1
#define INPUT_BUFFER_ALLOCATED 0x2
#define OUTPUT_FILE_OPENED 0x4

// Thread environment definition (i.e. what it needs to operate)
typedef struct audio_thread_env
{
int quit; // Thread will run as long as quit = 0
int button;
} audio_thread_env;

// Global audio thread environment
audio_thread_env audio_env = {0};

/* Store previous signal handler and call it */
void (*pSigPrev)(int sig);

// Callback called when SIGINT is sent to the process (Ctrl-C)
void signal_handler(int sig)
{
DBG( "Ctrl-C pressed, cleaning up and exiting..\n" );
audio_env.quit = 1;

if( pSigPrev != NULL )
(*pSigPrev)( sig );
}

//*****************************************************************************
//* main
//*****************************************************************************
int main( int argc, char *argv[] )
{

// Variables and definitions
// *************************

// button values
int button = 16;
int bButton = 1;
int bValue = 0;
int recording = 0;
button = (bButton*32)+button;
audio_env.button = button;
exportgpio(button);

// led light
int led = 17;
int bled = 1;
led = (bled*32)+led;
exportgpio(led);

//SET DIRECTION
setdirection(button,1);
setdirection(led,0);

//turn off led
gpioWrite(led,1);

// Thread parameters and return value
void * status = AUDIO_THREAD_SUCCESS; // < see above
unsigned int initMask = 0x0; // Used to only cleanup items that were init'd

// Input and output driver variables
snd_pcm_uframes_t exact_bufsize;
snd_pcm_t *pcm_capture_handle;

FILE * outfile = NULL; // Output file pointer (i.e. handle)
int blksize = BLOCKSIZE; // Raw input or output frame size
char *inputBuffer = NULL; // Input buffer for driver to read into

// Setup audio input device
// ************************

// Open an ALSA device channel for audio input
exact_bufsize = blksize/BYTESPERFRAME;

if( audio_io_setup( &pcm_capture_handle, SOUND_DEVICE, SAMPLE_RATE,
SND_PCM_STREAM_CAPTURE, &exact_bufsize ) == AUDIO_FAILURE )
{
ERR( "Audio_input_setup failed in audio_thread_fxn\n\n" );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
DBG( "exact_bufsize = %d\n", (int) exact_bufsize);

// Record that input OSS device was opened in initialization bitmask
initMask |= INPUT_ALSA_INITIALIZED;

blksize = exact_bufsize*BYTESPERFRAME;
// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Allocated input audio buffer of size %d to address %p\n", blksize,inputBuffer );

// Record that the input buffer was allocated in initialization bitmask
initMask |= INPUT_BUFFER_ALLOCATED;

// Thread Execute Phase -- perform I/O and processing
// **************************************************

while(1){
//Gets the button value
//printf("Button:%d",bValue);
bValue = gpioRead(button);

// Read capture buffer from ALSA input device
if( snd_pcm_readi(pcm_capture_handle, inputBuffer, blksize/BYTESPERFRAME) < 0 )
{
snd_pcm_prepare(pcm_capture_handle);
}

//Starts to record audio
if(bValue && !recording){
printf("Button Pushed");
recording = 1;

// Open a file for record
outfile = fopen(OUTFILE, "w");

if( outfile == NULL )
{
ERR( "Failed to open file %s\n", OUTFILE );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

DBG( "Opened file %s with FILE pointer = %p\n", OUTFILE, outfile );

// Record that input OSS device was opened in initialization bitmask
initMask |= OUTPUT_FILE_OPENED;

// Processing loop
DBG( "Entering audio_thread_fxn processing loop\n" );
gpioWrite(led,0);
}

//saves to file while recording.
if(bValue && recording){
if( fwrite( inputBuffer, sizeof( char ), blksize, outfile ) < blksize )
{
ERR( "Error writing the data to FILE pointer %p\n", outfile );
status = AUDIO_THREAD_FAILURE;
goto cleanup;
}
}

// Sends the audio on button release
if(!bValue && recording){
printf("Button Released");
gpioWrite(led,1);

DBG( "Closing output file at FILE ptr %p\n", outfile );
fclose( outfile );

DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );

// Create input buffer to read into from OSS input device
if( ( inputBuffer = malloc( blksize ) ) == NULL )
{
ERR( "Failed to allocate memory for input block (%d)\n", blksize );
status = AUDIO_THREAD_FAILURE;
goto cleanup ;
}

//runs a script that will take the raw file saved and encode it to mp3 useing lame and send via email.
system("~/BeagleBoardVNS/BeagleVNSScript");

//reset recording flag
recording = 0;
}
}

// Thread Delete Phase -- free up resources allocated by this file
// ***************************************************************

cleanup:

DBG( "Starting audio thread cleanup to return resources to system\n" );

// Close the audio drivers
// ***********************
// - Uses the initMask to only free resources that were allocated.
// - Nothing to be done for mixer device, as it was closed after init.

// Close input OSS device
if( initMask & INPUT_ALSA_INITIALIZED )
if( audio_io_cleanup( pcm_capture_handle ) != AUDIO_SUCCESS )
{
ERR( "audio_input_cleanup() failed for file descriptor %d\n", (int) pcm_capture_handle );
status = AUDIO_THREAD_FAILURE;
}

// Free allocated buffers
// **********************

// Free input buffer
if( initMask & INPUT_BUFFER_ALLOCATED )
{
DBG( "Freeing audio input buffer at location %p\n", inputBuffer );
free( inputBuffer );
DBG( "Freed audio input buffer at location %p\n", inputBuffer );
}

// Return from audio_thread_fxn function
// *************************************

// Return the status at exit of the thread's execution
DBG( "Audio thread cleanup complete. Exiting audio_thread_fxn\n" );
}

</pre>

=== Python ===

<pre>
import smtplib, os, sys
#from getpass import getpass
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders
from PREFERENCES import *

#def send_mail(send_files=""):
if __name__ == '__main__':
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.
print sys.argv[1]
send_to = SEND_TO
files = sys.argv[1]

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = SEND_FROM
subject = SUBJECT

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = MESSAGE

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password=PASSWORD
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

#if __name__ == '__main__':
# send_mail()</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface using HTML and NodeJS
# Web Interface to manage audio files
# Capture video along with audio
# Voice-To-Text
# Low Power Mode for longer battery life
# Authentication

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting. Need More Cake Want to discuss alsa limitations that prevented more advanced recording methods.

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-13T16:50:14Z

Geislekj: /* Work Breakdown */

ECE497 Beagle VNS

2012-11-13T16:47:16Z

Geislekj: /* Theory of Operation */

ECE497 Beagle VNS

2012-11-13T16:30:37Z

Geislekj: /* Software */

ECE497 Beagle VNS

2012-11-13T16:22:26Z

Geislekj: /* Executive Summary */

ECE497 Beagle VNS

2012-11-08T03:58:59Z

Geislekj: /* User Instructions */

ECE497 Beagle VNS

2012-11-08T03:58:32Z

Geislekj: /* User Instructions */

ECE497 Beagle VNS

2012-11-08T03:21:00Z

Geislekj: /* Software */

ECE497 Beagle VNS

2012-11-08T03:20:37Z

Geislekj: /* Software */

ECE497 Beagle VNS

2012-11-08T03:16:34Z

Geislekj:

ECE497 Beagle VNS

2012-11-08T03:15:31Z

Geislekj:

ECE497 Contributions and Project Status

2012-11-06T17:32:47Z

Geislekj:

[[Category:ECE497 |Contributions]]
{{YoderHead}}

== Fall 2012 ==

=== Project Status ===

Please edit this page and add your project to this list. Copy my [[ECE497 Project Template]] to your own eLinux page and include the title of your project in the name of the page.

Please make the list alphabetical by family name.

Take a look at what you and others have contributed.

{|
|-
! Name
! Contributions
! Project
! git repository
|-
| [[User:atniptw | Tom Atnip]]
| [[Special:Contributions/atniptw|contrib]]
| [[ECE497 Beagle VNS | Beagle VNS]]
| [https://github.com/atniptw/ atniptw]
|-
| [[User:larmorgs | Greg Larmore]]
| [[Special:Contributions/larmorgs|contrib]]
| [[ECE497 SPI Project | SPI Project]]
| [https://github.com/larmorgs Greg Larmore]
|-
| [[User:jessebrannon | Jesse Brannon]]
|
| [[ECE497 Project Rover | Rover]]
| [https://github.com/brannojs/ brannojs]
|-
| [[User:Xinyu1991 | Xinyu Cheng]]
| [[Special:Contributions/Xinyu1991|contrib]]
| [[ECE497_Project:_Kinect | Kinect]]
| [https://github.com/xinyu1991/ Xinyu Cheng]
|-
| [[User:correlbn | Bryan Correll]]
| [[Special:Contributions/correlbn|contrib]]
| [[BeagleBone PRU | BeagleBone PRU]]
| [https://github.com/correlbn/My-Beagle-Project/ Correlbn]
|-
| [[User:draneaw | Alex Drane]]
|
| [[ECE497 draneaw Project | My Beagle Project]]
| [https://github.com/draneaw/My-Beagle-Project draneaw]
|-
| [[User:duganje | Josh Dugan]]
| [[Special:Contributions/duganje|contrib]]
| [[ECE497 Project: XBee|XBee]]
| [https://github.com/duganje/ duganje]
|-
| [[User:Geislekj | Kevin Geisler]]
| [[Special:Contributions/geislekj|contrib]]
| [[ECE497 Beagle VNS | Beagle VNS]]
| [https://github.com/geislekj/ geislekj]
|
|-
| [[User:chris.good | Christopher A Good]]
| [[Special:Contributions/Chris.good|contrib]]
| [[ECE497 Project RoverGUI | RoverGUI]]
| [https://github.com/goodca/ goodca]
|
|-
| [[User:hansenrl | Ross Hansen]]
| [[Special:Contributions/hansenrl|contrib]]
| [[ECE497 Project Rover | Rover]]
| [https://github.com/hansenrl/ Hansenrl]
|
|-
| [[User:jungeml | Michael Junge]]
| [[Special:Contributions/jungeml|contrib]]
| [[ECE497 Project Rover | Rover]]
| [https://github.com/jungeml/ Jungeml]
|-
|
|-
| [[User:Lix | Xia Li]]
| [[Special:Contributions/Lix|contrib]]
| [[ECE497 Project: Kinect | Kinect]]
| [https://github.com/1984xiali/ xiali]
|-
| [[User:mmoravec | Matthew Moravec]]
| [[Special:Contributions/mmoravec|contrib]]
| [[ECE497 Project: XBee|XBee]]
| [https://github.com/mmoravec/ mmoravec]
|-
| [[User:ngop | Peter Ngo]]
| [[Special:Contributions/ngop|contrib]]
| [[BeagleBone PRU | BeagleBone PRU]]
| [https://github.com/ngop/ ngop]
|
|-
| [[User:shinnsm|Stephen Shinn]]
| [[Special:Contributions/shinnsm|contrib]]
| [[ECE497 Project: XBee|XBee]]
| [https://github.com/shinnsm shinnsm]
|-
| [[User:Yoder | Mark A. Yoder]]
| [[Special:Contributions/Yoder | contrib]]
| [[ECE497 Project Template | My Beagle Project]]
| [https://github.com/MarkAYoder MarkAYoder]
|-
| [[User:Popenhjc | James Popenhagen]]
| [[Special:Contributions/Popenhjc|contrib]]
| [[BeagleBone PRU | BeagleBone PRU]]
| [https://github.com/popenhjc/ popenhjc]
|-
| [[User:Whiteer | Elias White]]
|
| [[ECE497 SLAM via ROS | My Beagle Project]]
| [https://github.com/whiteer whiteer]
|-
| [[User:ruff | Ruffin White]]
| [[Special:Contributions/ruff|contrib]]
| [[ECE497 Beagle VNS | Beagle VNS]]
| [https://github.com/ruffsl/ ruffsl]
|
|-
| [[User:Richarsm | Sean Richardson]]
| [[Special:Contributions/Richarsm|contrib]]
| [[ECE497 SPI Project | SPI Project]]
| [https://github.com/seanrich Sean Richardson]
|-
| [[User:Millerap | Andrew Miller]]
| [[Special:Contributions/Millerap|contrib]]
| [[BeagleBone PRU | BeagleBone PRU]]
| [https://github.com/millerap millerap]
|-|
| [[User:Astroricks | Yue Zhang]]
|
| [[ECE497 Yue Zhang Project | My Beagle Project]]
| [https://github.com/Astroricks/Beagle-Project Yue Zhang]
|-
| [[User:Lobdeljt | John Lobdell]]
|
| [[ECE 497 lobdeljt Project | My Beagle Project]]
| [https://github.com/jtlobdell jtlobdell]
|-
|
|}

== Winter 2011-2012 ==

=== Contributions ===

# [[Special:Contributions/Yuming | Yuming Cao]]
# [[Special:Contributions/Yifei | Yifei Li]]
# [[Special:Contributions/Harrisgw | Greg Harrison]]
# [[Special:Contributions/mac | Jack Ma]]
# [[Special:Contributions/Gemini91 | Guanqun Wang]]
# [[Special:Contributions/Yanj | Mona Yan]]
# [[Special:Contributions/Yoder | Mark A. Yoder]]
# [[Special:Contributions/Yuhasmj | Michael Yuhas]]
# [[Special:Contributions/Ziyi Zhang | Ziyi Zhang]]
# [[Special:Contributions/Zitnikdj | David Zitnik]]
# [[Special:Contributions/Zitnikdj | Alex Drane]]
# [[Special:Contributions/jessebrannon | Jesse Brannon]]
# [[Special:Contributions/larmorgs | Greg Larmore]]
# [[Special:Contributions/jungeml | Michael Junge]]
# [[Special:Contributions/millerap | Andrew Miller]]
# [[Special:Contributions/correlbn | Bryan Correll]]

=== Project Status ===

# [[User:Yoder | Mark A. Yoder]], [[ECE497 Project Template | My Beagle Project]]
# [[user:Yanj|Mona Yan]] and [[user:Harrisgw| Greg Harrison]], [[PS EYE QT PROJECT | Playstation Eye Audio with Qt]]
# [[user:Caogecym | Yuming Cao]] and [[user:Ziyi Zhang | Ziyi Zhang]], [[Node.js Weather Station]]
# [[user:Yifei| Yifei Li]] and [[user:Gemini91| Guanqun Wang]], [[ Kinect Project | Play games using Kinect on Beagleboard]]
# [[user:Yuhasmj| Michael J. Yuhas]] and [[user:mac | Jack Ma]], [[ Multiple Partitions via U-boot | Multiple Partitions via U-boot ]]
# [[user:Zitnikdj| David Zitnik]], [[ ECE497 Project: Twitter Java Application | Twitter Java Application ]]

{{YoderFoot}}

ECE497 Contributions and Project Status

2012-11-06T17:31:18Z

Geislekj:

[[Category:ECE497 |Contributions]]
{{YoderHead}}

== Fall 2012 ==

=== Project Status ===

Please edit this page and add your project to this list. Copy my [[ECE497 Project Template]] to your own eLinux page and include the title of your project in the name of the page.

Please make the list alphabetical by family name.

Take a look at what you and others have contributed.

{|
|-
! Name
! Contributions
! Project
! git repository
|-
| [[User:atniptw | Tom Atnip]]
|
| [[ECE497 Beagle VNS | Beagle VNS]]
| [https://github.com/atniptw/ atniptw]
|-
| [[User:larmorgs | Greg Larmore]]
| [[Special:Contributions/larmorgs|contrib]]
| [[ECE497 SPI Project | SPI Project]]
| [https://github.com/larmorgs Greg Larmore]
|-
| [[User:jessebrannon | Jesse Brannon]]
|
| [[ECE497 Project Rover | Rover]]
| [https://github.com/brannojs/ brannojs]
|-
| [[User:Xinyu1991 | Xinyu Cheng]]
| [[Special:Contributions/Xinyu1991|contrib]]
| [[ECE497_Project:_Kinect | Kinect]]
| [https://github.com/xinyu1991/ Xinyu Cheng]
|-
| [[User:correlbn | Bryan Correll]]
| [[Special:Contributions/correlbn|contrib]]
| [[BeagleBone PRU | BeagleBone PRU]]
| [https://github.com/correlbn/My-Beagle-Project/ Correlbn]
|-
| [[User:draneaw | Alex Drane]]
|
| [[ECE497 draneaw Project | My Beagle Project]]
| [https://github.com/draneaw/My-Beagle-Project draneaw]
|-
| [[User:duganje | Josh Dugan]]
| [[Special:Contributions/duganje|contrib]]
| [[ECE497 Project: XBee|XBee]]
| [https://github.com/duganje/ duganje]
|-
| [[User:Geislekj | Kevin Geisler]]
| [[Special:Contributions/geislekj|contrib]]
| [[ECE497 Beagle VNS | Beagle VNS]]
| [https://github.com/geislekj/ geislekj]
|
|-
| [[User:chris.good | Christopher A Good]]
| [[Special:Contributions/Chris.good|contrib]]
| [[ECE497 Project RoverGUI | RoverGUI]]
| [https://github.com/goodca/ goodca]
|
|-
| [[User:hansenrl | Ross Hansen]]
| [[Special:Contributions/hansenrl|contrib]]
| [[ECE497 Project Rover | Rover]]
| [https://github.com/hansenrl/ Hansenrl]
|
|-
| [[User:jungeml | Michael Junge]]
| [[Special:Contributions/jungeml|contrib]]
| [[ECE497 Project Rover | Rover]]
| [https://github.com/jungeml/ Jungeml]
|-
|
|-
| [[User:Lix | Xia Li]]
| [[Special:Contributions/Lix|contrib]]
| [[ECE497 Project: Kinect | Kinect]]
| [https://github.com/1984xiali/ xiali]
|-
| [[User:mmoravec | Matthew Moravec]]
| [[Special:Contributions/mmoravec|contrib]]
| [[ECE497 Project: XBee|XBee]]
| [https://github.com/mmoravec/ mmoravec]
|-
| [[User:ngop | Peter Ngo]]
| [[Special:Contributions/ngop|contrib]]
| [[BeagleBone PRU | BeagleBone PRU]]
| [https://github.com/ngop/ ngop]
|
|-
| [[User:shinnsm|Stephen Shinn]]
| [[Special:Contributions/shinnsm|contrib]]
| [[ECE497 Project: XBee|XBee]]
| [https://github.com/shinnsm shinnsm]
|-
| [[User:Yoder | Mark A. Yoder]]
| [[Special:Contributions/Yoder | contrib]]
| [[ECE497 Project Template | My Beagle Project]]
| [https://github.com/MarkAYoder MarkAYoder]
|-
| [[User:Popenhjc | James Popenhagen]]
| [[Special:Contributions/Popenhjc|contrib]]
| [[BeagleBone PRU | BeagleBone PRU]]
| [https://github.com/popenhjc/ popenhjc]
|-
| [[User:Whiteer | Elias White]]
|
| [[ECE497 SLAM via ROS | My Beagle Project]]
| [https://github.com/whiteer whiteer]
|-
| [[User:ruff | Ruffin White]]
|
| [[ECE497 Beagle VNS | Beagle VNS]]
| [https://github.com/ruffsl/ ruffsl]
|
|-
| [[User:Richarsm | Sean Richardson]]
| [[Special:Contributions/Richarsm|contrib]]
| [[ECE497 SPI Project | SPI Project]]
| [https://github.com/seanrich Sean Richardson]
|-
| [[User:Millerap | Andrew Miller]]
| [[Special:Contributions/Millerap|contrib]]
| [[BeagleBone PRU | BeagleBone PRU]]
| [https://github.com/millerap millerap]
|-|
| [[User:Astroricks | Yue Zhang]]
|
| [[ECE497 Yue Zhang Project | My Beagle Project]]
| [https://github.com/Astroricks/Beagle-Project Yue Zhang]
|-
| [[User:Lobdeljt | John Lobdell]]
|
| [[ECE 497 lobdeljt Project | My Beagle Project]]
| [https://github.com/jtlobdell jtlobdell]
|-
|
|}

== Winter 2011-2012 ==

=== Contributions ===

# [[Special:Contributions/Yuming | Yuming Cao]]
# [[Special:Contributions/Yifei | Yifei Li]]
# [[Special:Contributions/Harrisgw | Greg Harrison]]
# [[Special:Contributions/mac | Jack Ma]]
# [[Special:Contributions/Gemini91 | Guanqun Wang]]
# [[Special:Contributions/Yanj | Mona Yan]]
# [[Special:Contributions/Yoder | Mark A. Yoder]]
# [[Special:Contributions/Yuhasmj | Michael Yuhas]]
# [[Special:Contributions/Ziyi Zhang | Ziyi Zhang]]
# [[Special:Contributions/Zitnikdj | David Zitnik]]
# [[Special:Contributions/Zitnikdj | Alex Drane]]
# [[Special:Contributions/jessebrannon | Jesse Brannon]]
# [[Special:Contributions/larmorgs | Greg Larmore]]
# [[Special:Contributions/jungeml | Michael Junge]]
# [[Special:Contributions/millerap | Andrew Miller]]
# [[Special:Contributions/correlbn | Bryan Correll]]

=== Project Status ===

# [[User:Yoder | Mark A. Yoder]], [[ECE497 Project Template | My Beagle Project]]
# [[user:Yanj|Mona Yan]] and [[user:Harrisgw| Greg Harrison]], [[PS EYE QT PROJECT | Playstation Eye Audio with Qt]]
# [[user:Caogecym | Yuming Cao]] and [[user:Ziyi Zhang | Ziyi Zhang]], [[Node.js Weather Station]]
# [[user:Yifei| Yifei Li]] and [[user:Gemini91| Guanqun Wang]], [[ Kinect Project | Play games using Kinect on Beagleboard]]
# [[user:Yuhasmj| Michael J. Yuhas]] and [[user:mac | Jack Ma]], [[ Multiple Partitions via U-boot | Multiple Partitions via U-boot ]]
# [[user:Zitnikdj| David Zitnik]], [[ ECE497 Project: Twitter Java Application | Twitter Java Application ]]

{{YoderFoot}}

User:Geislekj

2012-11-06T17:29:13Z

Geislekj:

{{GeislekjHead}}

* Computer Science Major, Class of 2013
* Robotics Minor
* Electrical Engineering Minor

== Projects ==
[[ECE497 Beagle VNS | Beagle VNS]]

== Mini-projects ==
*[[Sparkfun:_Large_Piezo_Vibration_Sensor_-_With_Mass]]

== Github Repo ==

[[http://github.com/geislekj/ECE497 github]]

[[Category:ECE497 |Ug]]

ECE497 Beagle VNS

2012-11-02T16:05:55Z

Geislekj:

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have a method for capturing audio for a specified amount of time and encoding that recording into a mp3 file. We also have python script that allows the user to send email messages to another email by running a script. We also have a working external power source for the beagle.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we are looking at creating a c program that will record the audio while the button is being pressed. Once the button has been released the program will encode the raw audio into mp3 format, and then attach it via an email and send it to the owner of the Beagle VNS system.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

::To download the code for the Beagle VNS run the following code:

beagle$ '''git clone https://github.com/geislekj/BeagleBoardVNS.git'''

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*GStreamer

::GStreamer is an application that allows the user to capture video from a camera for multiple types of solutions. For this project, it is being used to capture an image of the person leaving a message.

::Instructions to install GStreamer is still in the process of being developed.

== Hardware ==

[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|320px|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.jpg|320px|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ arecord -D plughw:1,0 | aplay

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ arecord -D plughw:2,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

Send To (Separated by a comma):
Files (Separated by a comma):
Send From: beagle497@gmail.com #Must use this email for now
Subject:
Message:

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

Give a high level overview of the structure of your software. Are you using GStreamer? Show a diagram of the pipeline. Are you running multiple tasks? Show what they do and how they interact.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google vouice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending, google is blocking attachments however
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is still being developed
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::Making c file for initializing GPIOs, interrupts and start up scripts for VNS server

== Code ==

=== Python ===

<pre>
import smtplib, os
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders

def send_mail():
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.

send_to = raw_input("Send To (Separated by a comma): ")
files = raw_input("Files (Separated by a comma): ")

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = raw_input("Send From: ")
subject = raw_input("Subject: ")

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = raw_input("Message: ")

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password="beagleece497"
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

if __name__ == '__main__':
send_mail()</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface using HTML and NodeJS

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting. Need More Cake

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-02T16:04:05Z

Geislekj: /* Work Breakdown */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

Team members:[[User:atniptw | Tom Atnip]],[[User:Geislekj | Kevin Geisler]],[[user:Ruff | Ruffin White]]

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have a method for capturing audio for a specified amount of time and encoding that recording into a mp3 file. We also have python script that allows the user to send email messages to another email by running a script. We also have a working external power source for the beagle.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we are looking at creating a c program that will record the audio while the button is being pressed. Once the button has been released the program will encode the raw audio into mp3 format, and then attach it via an email and send it to the owner of the Beagle VNS system.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

::To download the code for the Beagle VNS run the following code:

beagle$ '''git clone https://github.com/geislekj/BeagleBoardVNS.git'''

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*GStreamer

::GStreamer is an application that allows the user to capture video from a camera for multiple types of solutions. For this project, it is being used to capture an image of the person leaving a message.

::Instructions to install GStreamer is still in the process of being developed.

== Hardware ==

[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|320px|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.jpg|320px|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ arecord -D plughw:1,0 | aplay

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ arecord -D plughw:2,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

Send To (Separated by a comma):
Files (Separated by a comma):
Send From: beagle497@gmail.com #Must use this email for now
Subject:
Message:

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

Give a high level overview of the structure of your software. Are you using GStreamer? Show a diagram of the pipeline. Are you running multiple tasks? Show what they do and how they interact.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1.''' Acquire Hardware - Ruffin
:::Done
'''2.''' Set up project page - Tom & Kevin
:::Page made and updated
'''3.''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4.''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
'''5.''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6.''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google vouice accounts
'''7.''' Create an email script to send email with attachments - Tom
:::Email sending, google is blocking attachments however
'''8.''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9.''' Capture an image using GStreamer - Kevin & Tom
:::This is still being developed
'''10.''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is still being developed
'''11.''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::Making c file for initializing GPIOs, interrupts and start up scripts for VNS server

== Code ==

=== Python ===

<pre>
import smtplib, os
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders

def send_mail():
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.

send_to = raw_input("Send To (Separated by a comma): ")
files = raw_input("Files (Separated by a comma): ")

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = raw_input("Send From: ")
subject = raw_input("Subject: ")

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = raw_input("Message: ")

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password="beagleece497"
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

if __name__ == '__main__':
send_mail()</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface using HTML and NodeJS

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting. Need More Cake

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-02T16:03:39Z

Geislekj: /* Work Breakdown */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

Team members:[[User:atniptw | Tom Atnip]],[[User:Geislekj | Kevin Geisler]],[[user:Ruff | Ruffin White]]

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have a method for capturing audio for a specified amount of time and encoding that recording into a mp3 file. We also have python script that allows the user to send email messages to another email by running a script. We also have a working external power source for the beagle.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we are looking at creating a c program that will record the audio while the button is being pressed. Once the button has been released the program will encode the raw audio into mp3 format, and then attach it via an email and send it to the owner of the Beagle VNS system.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

::To download the code for the Beagle VNS run the following code:

beagle$ '''git clone https://github.com/geislekj/BeagleBoardVNS.git'''

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*GStreamer

::GStreamer is an application that allows the user to capture video from a camera for multiple types of solutions. For this project, it is being used to capture an image of the person leaving a message.

::Instructions to install GStreamer is still in the process of being developed.

== Hardware ==

[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|320px|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.jpg|320px|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ arecord -D plughw:1,0 | aplay

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ arecord -D plughw:2,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

Send To (Separated by a comma):
Files (Separated by a comma):
Send From: beagle497@gmail.com #Must use this email for now
Subject:
Message:

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

Give a high level overview of the structure of your software. Are you using GStreamer? Show a diagram of the pipeline. Are you running multiple tasks? Show what they do and how they interact.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

'''1''' Acquire Hardware - Ruffin
:::Done
'''2''' Set up project page - Tom & Kevin
:::Page made and updated
'''3''' Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
'''4''' Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
'''5''' Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
'''6''' Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google vouice accounts
'''7''' Create an email script to send email with attachments - Tom
:::Email sending, google is blocking attachments however
'''8''' Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
'''9''' Capture an image using GStreamer - Kevin & Tom
:::This is still being developed
'''10''' Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is still being developed
'''11''' Putting all the pieces together - Tom, Kevin, & Ruffin
:::Making c file for initializing GPIOs, interrupts and start up scripts for VNS server

== Code ==

=== Python ===

<pre>
import smtplib, os
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders

def send_mail():
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.

send_to = raw_input("Send To (Separated by a comma): ")
files = raw_input("Files (Separated by a comma): ")

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = raw_input("Send From: ")
subject = raw_input("Subject: ")

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = raw_input("Message: ")

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password="beagleece497"
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

if __name__ == '__main__':
send_mail()</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface using HTML and NodeJS

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting. Need More Cake

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-02T16:02:40Z

Geislekj: /* Work Breakdown */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

Team members:[[User:atniptw | Tom Atnip]],[[User:Geislekj | Kevin Geisler]],[[user:Ruff | Ruffin White]]

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have a method for capturing audio for a specified amount of time and encoding that recording into a mp3 file. We also have python script that allows the user to send email messages to another email by running a script. We also have a working external power source for the beagle.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we are looking at creating a c program that will record the audio while the button is being pressed. Once the button has been released the program will encode the raw audio into mp3 format, and then attach it via an email and send it to the owner of the Beagle VNS system.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

::To download the code for the Beagle VNS run the following code:

beagle$ '''git clone https://github.com/geislekj/BeagleBoardVNS.git'''

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*GStreamer

::GStreamer is an application that allows the user to capture video from a camera for multiple types of solutions. For this project, it is being used to capture an image of the person leaving a message.

::Instructions to install GStreamer is still in the process of being developed.

== Hardware ==

[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|320px|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.jpg|320px|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ arecord -D plughw:1,0 | aplay

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ arecord -D plughw:2,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

Send To (Separated by a comma):
Files (Separated by a comma):
Send From: beagle497@gmail.com #Must use this email for now
Subject:
Message:

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

Give a high level overview of the structure of your software. Are you using GStreamer? Show a diagram of the pipeline. Are you running multiple tasks? Show what they do and how they interact.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

1 Acquire Hardware - Ruffin
:::Done
2 Set up project page - Tom & Kevin
:::Page made and updated
3 Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
4 Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
5 Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
6 Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google vouice accounts
7 Create an email script to send email with attachments - Tom
:::Email sending, google is blocking attachments however
8 Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
9 Capture an image using GStreamer - Kevin & Tom
:::This is still being developed
10 Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is still being developed
11 Putting all the pieces together - Tom, Kevin, & Ruffin
:::Making c file for initializing GPIOs, interrupts and start up scripts for VNS server

== Code ==

=== Python ===

<pre>
import smtplib, os
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders

def send_mail():
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.

send_to = raw_input("Send To (Separated by a comma): ")
files = raw_input("Files (Separated by a comma): ")

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = raw_input("Send From: ")
subject = raw_input("Subject: ")

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = raw_input("Message: ")

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password="beagleece497"
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

if __name__ == '__main__':
send_mail()</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface using HTML and NodeJS

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting. Need More Cake

{{BeagleVNSFoot}}

ECE497 Beagle VNS

2012-11-02T16:01:01Z

Geislekj: /* Software */

[[Category:ECE497 |Project]]
{{BeagleVNSHead}}
[[File:BeagleVNS.png|thumb|]]

Team members:[[User:atniptw | Tom Atnip]],[[User:Geislekj | Kevin Geisler]],[[user:Ruff | Ruffin White]]

== Executive Summary ==

[[File:WhereIsYoder.png|thumb|Where is Dr. Yoder?]]
[[File:WhereIsYoder2.png|thumb|I'll leave him a message]]

We wanted a way for students to be able to leave audio (and possibly video) messages for professors when they are out of their office. Using a BeagleBoard Bone, we plan to connect a wireless USB device and a PlayStation Eye to achieve this. Students will be able to walk up to the device and press a button to record their message which will then be available for the professor.

At this time, we have a method for capturing audio for a specified amount of time and encoding that recording into a mp3 file. We also have python script that allows the user to send email messages to another email by running a script. We also have a working external power source for the beagle.

The wireless usb adapter does not work at this time. We are still trying to get recompile the kernel to install and enable the driver for this wireless adapter.

Overall we are looking at creating a c program that will record the audio while the button is being pressed. Once the button has been released the program will encode the raw audio into mp3 format, and then attach it via an email and send it to the owner of the Beagle VNS system.

== Software ==

*'''Angstrom A5 Image'''

::In order to use the camera drivers for the playstation eye you will need to install the A5 image on the beagle bone. To do this you will need to download the A5 image. Then you will need to install this image on the sd card of the BeagleBone using the instructions bases on [http://elinux.org/EBC_Exercise_03_Installing_a_Beagle_OS| ECE 497 Exercise 03 Installing a Beagle OS].

*'''github'''

::In order to use the project code for the Beagle VNS, you will need github installed in order to download the code. If you do not have github there are instruction on how to install it on the [[EBC Exercise 16 git |ECE Exercise 16]] web page.

::To download the code for the Beagle VNS run the following code:

beagle$ '''git clone https://github.com/geislekj/BeagleBoardVNS.git'''

*'''Python'''

::Python is natively installed on the Beagle operating system. However it is important to note that the program will be using a python script to send email.

*'''ALSA'''

::The project uses ALSA drivers in order to record audio from a microphone device.

::In order to download the ALSA drivers you will need to run the following commands:

beagle$ '''opkg update'''
beagle$ '''opkg install alsa-utils-aplay alsa-utils-amixer'''

*'''Lame'''

::Lame is a audio encoder that will take raw audio and convert it into an mp3 format.

::To install the lame onto the beagle board you will need to run the following command.

beagle$ '''opkg install lame'''

*GStreamer

::GStreamer is an application that allows the user to capture video from a camera for multiple types of solutions. For this project, it is being used to capture an image of the person leaving a message.

::Instructions to install GStreamer is still in the process of being developed.

== Hardware ==

[[File:BeagleBone_256x249.jpg|320px|thumb|right|BeagleBone]]
[[File:PlayStation-Eye.png|320px|thumb|right|PlayStation Eye]]
[[File:Belkin_N150_Micro_Wireless_USB_Adapter.jpg|320px|thumb|right|Belkin N150 Micro Wireless USB Adapter]]

*BeagleBone

::This project is design primarily for the BeagleBone, but could be implemented on any other Beagle Board given the proper driver installation for the USB hardware and available GPIOs. The BeagleBone is applicable for this project due to is small size, low power consumption, and networking capabilities. Make sure to use the A5 image of Ångström as the A6 image is still buggy with respect to audio/video capturing, as well as using the USB WiFi drivers.

::Further BeagleBone documentation can be found on the official [http://beagleboard.org Beagle Board] website.

::This device can be found available [https://www.adafruit.com/products/513 here]

*Camera

::In this project tutorial, we will be using the [http://en.wikipedia.org/wiki/PlayStation_Eye PlayStation Eye] as the audio and video source to recod messages and capture face images. The PlayStation Eye is very compatible with the A5 image of Ångström and used in many other Beagle embedded Linux projects.

::This device can be found available [http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html here]

*Wifi dongle

::Here we would like to use a WiFi dongle to easily connect to surrounding wireless networks for ease of installation and placement in the remote stretches of hallways and doorframes. We will need we will need network connectivity to transmit e-mails and recording attachments over to an available e-mail server account. In particularly we are using the [http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter].

::Although this device is not natively supported with the stock A5 image of Ångström, a brief tutorial has already been made on how to compile and install the device drivers for this particular wireless USB adapter: [http://embeddedgeeks.wordpress.com/2012/01/03/belkin-micro-wifi-usb-dongle-on-the-beagleboard/ Belkin Micro Wi-Fi USB dongle on the BeagleBoard]

*Battery Pack and USB Hub

::To again better a ease installation and quick deployment for our system we are using a battery pack to provide power for the BeagleBone, the WiFi dongle and the USB camera. Due to the hottest limitations of the Beagle bones single USB port, in addition to the limited amount of current that the single USB port can provide, we will also use a USB hub with power adapter to solve both issues.

::Specific products we are using included [http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger] and [http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

*Doorbell

::In order for the end user to trigger the recording sequence, we will implement a traditional mechanical momentary pushbutton that will connect to the BeagleBone’s GPIO using the enabled internal pull-up resistors.

*LED

::As a simple display, our project will utilize a simple LED as an indicator for the user that the audio is currently being recorded and that a face capture will be taken.

== User Instructions ==

*'''Basic Command Line Examples'''

:: In order to give you a feel to how the program is capturing and sending emails. Here is a short run down of how the program works

:*'''Audio Capture'''

::: In order to capture audio, the project uses arecord. This application allows you to grab audio from a microphone that is attached to your device and save to the current directory in a raw format.

:::Here is an example command that allows you to record audio and then pipe the audio into aplay to instantaneously hear feedback:

beagle$ arecord -D plughw:1,0 | aplay

:::In order to encode the audio into mp3 format, you will need to pipe the audio into lame instead of aplay.

:::Here is an example of this:

beagle$ arecord -D plughw:2,0 -r 16000 -f S16_LE -c 2 -t raw -d 3 | lame -s 16 -r - blackbird.mp3

::: For more information about ALSA and how to use many of its interesting features visit [http://www.lvr.com/access_usb_devices_from_linux.htm | Jan Axelson's Lakeview Research web page]

:*'''Email Script'''

::: A python mail client that prompts the user for information to send an email with optional attachments.

python smtp-mail-client-attachments.py

Send To (Separated by a comma):
Files (Separated by a comma):
Send From:
Subject:
Message:

== Highlights ==

Here is where you brag about what your project can do.

Include a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

Give a high level overview of the structure of your software. Are you using GStreamer? Show a diagram of the pipeline. Are you running multiple tasks? Show what they do and how they interact.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

# Acquire Hardware - Ruffin
:::Done
# Set up project page - Tom & Kevin
:::Page made and updated
# Get USB wireless to work - Kevin & Ruffin
:::This is not working at this time for A6 image
# Get PlayStation Eye to work - Tom
:::Audio working, need to use A5 image
# Get BeagleBoard Bone to run off a battery pack - Ruffin
:::Done
# Register an email for the BeagleBoard - Ruffin
:::Google acound made, along with Gmail and Google vouice accounts
# Create an email script to send email with attachments - Tom
:::Email sending, google is blocking attachments however
# Encode the raw audio from ALSA into mp3 format - Kevin
:::Able to record on bone, use lame to convert file, and SCP to send to PC and listen to the recording
# Capture an image using GStreamer - Kevin & Tom
:::This is still being developed
# Create a C program to capture the audio and listen for GPIO inputs - Kevin & Ruffin
:::This is still being developed
# Putting all the pieces together - Tom, Kevin, & Ruffin
:::Making c file for initializing GPIOs, interrupts and start up scripts for VNS server

== Code ==

=== Python ===

<pre>
import smtplib, os
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email.MIMEText import MIMEText
from email.Utils import COMMASPACE, formatdate
from email import Encoders

def send_mail():
#This version promts the user to specify recipient, files,
#subject, and message. The version for incorperating in the
#notifier will need to read from a preferences file that
#should be modifiable by the user.

send_to = raw_input("Send To (Separated by a comma): ")
files = raw_input("Files (Separated by a comma): ")

send_to=send_to.split(',')
files=filter(None, files.split(','))

#Make sure that we are working with a list
assert type(send_to)==list
assert type(files)==list

send_from = raw_input("Send From: ")
subject = raw_input("Subject: ")

#Create a message object that we will be sending
msg = MIMEMultipart()
msg['From'] = send_from
msg['To'] = COMMASPACE.join(send_to)
msg['Date'] = formatdate(localtime=True)
msg['Subject'] = subject

text = raw_input("Message: ")

msg.attach( MIMEText(text) )

#Attach files to message
for f in files:
part = MIMEBase('application', "octet-stream")
part.set_payload( open(f,"rb").read() )
Encoders.encode_base64(part)
part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(f))
msg.attach(part)

#Open up a connection to the gmail servers on port 587
server = smtplib.SMTP('smtp.gmail.com',587) #port 465 or 587
server.ehlo()
server.starttls()
server.ehlo()
#password = getpass()
password="beagleece497"
server.login(send_from, password)
server.sendmail(send_from,",".join(send_to),msg.as_string())
server.close()

if __name__ == '__main__':
send_mail()</pre>

== Future Work ==

Suggest addition things that could be done with this project.

# Web Interface using HTML and NodeJS

== Parts ==

[http://beagleboard.org/bone Beagle Bone]

[http://us.playstation.com/ps3/accessories/playstation-eye-camera-ps3.html PlayStation Eye]

[http://www.belkin.com/us/p/P-F7D1102 Belkin N150 Micro Wireless USB Adapter]

[http://www.duracell.com/en-US/product/instant-usb-charger.jspx Duracell Instant USB Charger]

[http://www.radioshack.com/product/index.jsp?productId=2476717 Gigaware® USB 4-Port Hub]

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting. Need More Cake

{{BeagleVNSFoot}}

User:Geislekj

2012-11-02T04:59:23Z

Geislekj:

Sparkfun: Large Piezo Vibration Sensor - With Mass

2012-11-02T04:55:45Z

Geislekj:

{{GeislekjHead}}
[[Category:ECE497]]
[[Category:SparkFun]]

<pre style="color:red">
Overview: 1, Nice overview, but a close up picture of the device would help.
Wiring: 1, What op-amp are you using? A schematic of your actual circuit would be a big help.
Code: 2
git: 2
Demo: 2
Total: 8/10
Comments: Good start, but more specific details are needed.
</pre>

__TOC__

==Overview==

The [http://dlnmh9ip6v2uc.cloudfront.net/images/products/9/1/9/7/09197-02-L.jpg Large Piezo Vibration Sensor] is a basic piezo sensor which is often used for flex, touch, vibration and shock measurements. This sensor acts like a small capacitor which discharges up to +/-90V when the film moves back and forth. Some common uses this type of sensor are for impact sensing or as a flexible switch. A larger scale example are piezo sensors that are laid within the road for use of traffic signals.

This sensor can be purchased at [https://www.sparkfun.com/products/9197 SparkFun].

The [https://www.sparkfun.com/datasheets/Sensors/Flex/MSI-techman.pdf Technical Manual] and [http://dlnmh9ip6v2uc.cloudfront.net/datasheets/Sensors/ForceFlex/LDT_Series.pdf datasheet] can also be found on Sparkfun's website.

[[File:PiezoCircuit.PNG|thumb |alt=Example alt text |This is and example circuit layout of the piezo vibration sensor using an op amp and the beagle board.]]
==Usage==

Since the piezo sensor acts like a small capacitor, you can connect on a bread board as such. However an additional resistor is needed in order affect the low frequency of measurement. This is called the "loading effect". Additionally, if the signal from the piezo sensor is too low an op amp may be necessary.

More specific information and circuit diagrams can be found in the [https://www.sparkfun.com/datasheets/Sensors/Flex/MSI-techman.pdf Technical Manual] on pages 36-40.

==Beagle Bone Usage==

The value being read from the piezo sensor will be a voltage up to +/-0.5V. This means that an analog pin must be used to read the value from the sensor. The voltage being supplied to the sensor affects how much sensitivity you will receive. Look in the technical manual to find a desired voltage that will work for you. For the example below, I simply used a 5V source.

[[File:Piezo-breadboard-layout.jpg|thumb |alt=Example alt text |This is a picture of the layout of the piezo vibration sensor using an op amp and the beagle board.]]

==Reading the Analog Signal==

You can simply read the value of the piezo sensor from the terminal by reading the contents of a file in the /sys/devices/platform/omap/tsc/ain# directory. The # is 1 + the number of the analog pin you selected as your analog input. However this method will not allow you to accurately see the change of voltage as the film moves. To do this you will need to write a c program to print the values to the terminal repeatably or plot the voltage over time. The sample code below shows a simple program to print the voltage of the sensor to the screen.

==Sample Code==
The following code can be found on [https://github.com/geislekj/ECE497/tree/master/miniProject2 git hub].

<pre>
/**************************************
Example Program for the Large Piezo Vibration Sensor - With Mass

This will display the value of the AIN0 Pin directly to the terminal repeatively.

wrtten by Kevin Geisler, 23-Sept-2012
***************************************/
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

#define SYSFS_AIN1_DIR "/sys/devices/platform/omap/tsc/ain2"

FILE *fp;

int readanalog(){
if ((fp = fopen(SYSFS_AIN1_DIR, "r")) == NULL)
{
printf("Cannot open value file.\n");
exit(1);
}

//Set pointer to begining of the file
rewind(fp);
//Write our value of "0" to the file
char inString[10];
fgets(&inString, 10, fp);
fflush(fp);
// printf("...value set to 0...\n");
fclose(fp);
// printf(inString);
return atoi(&inString);
}

int main(int argc, char** argv)
{

//Run an infinite loop - will require Ctrl-C to exit this program
while(1)
{
printf("%d\n",readanalog());
usleep(100000);

}
return 0;
}
</pre>

Sparkfun: Large Piezo Vibration Sensor - With Mass

2012-11-02T04:55:25Z

Geislekj:

{{GeislerHead}}
[[Category:ECE497]]
[[Category:SparkFun]]

<pre style="color:red">
Overview: 1, Nice overview, but a close up picture of the device would help.
Wiring: 1, What op-amp are you using? A schematic of your actual circuit would be a big help.
Code: 2
git: 2
Demo: 2
Total: 8/10
Comments: Good start, but more specific details are needed.
</pre>

__TOC__

==Overview==

The [http://dlnmh9ip6v2uc.cloudfront.net/images/products/9/1/9/7/09197-02-L.jpg Large Piezo Vibration Sensor] is a basic piezo sensor which is often used for flex, touch, vibration and shock measurements. This sensor acts like a small capacitor which discharges up to +/-90V when the film moves back and forth. Some common uses this type of sensor are for impact sensing or as a flexible switch. A larger scale example are piezo sensors that are laid within the road for use of traffic signals.

This sensor can be purchased at [https://www.sparkfun.com/products/9197 SparkFun].

The [https://www.sparkfun.com/datasheets/Sensors/Flex/MSI-techman.pdf Technical Manual] and [http://dlnmh9ip6v2uc.cloudfront.net/datasheets/Sensors/ForceFlex/LDT_Series.pdf datasheet] can also be found on Sparkfun's website.

[[File:PiezoCircuit.PNG|thumb |alt=Example alt text |This is and example circuit layout of the piezo vibration sensor using an op amp and the beagle board.]]
==Usage==

Since the piezo sensor acts like a small capacitor, you can connect on a bread board as such. However an additional resistor is needed in order affect the low frequency of measurement. This is called the "loading effect". Additionally, if the signal from the piezo sensor is too low an op amp may be necessary.

More specific information and circuit diagrams can be found in the [https://www.sparkfun.com/datasheets/Sensors/Flex/MSI-techman.pdf Technical Manual] on pages 36-40.

==Beagle Bone Usage==

The value being read from the piezo sensor will be a voltage up to +/-0.5V. This means that an analog pin must be used to read the value from the sensor. The voltage being supplied to the sensor affects how much sensitivity you will receive. Look in the technical manual to find a desired voltage that will work for you. For the example below, I simply used a 5V source.

[[File:Piezo-breadboard-layout.jpg|thumb |alt=Example alt text |This is a picture of the layout of the piezo vibration sensor using an op amp and the beagle board.]]

==Reading the Analog Signal==

You can simply read the value of the piezo sensor from the terminal by reading the contents of a file in the /sys/devices/platform/omap/tsc/ain# directory. The # is 1 + the number of the analog pin you selected as your analog input. However this method will not allow you to accurately see the change of voltage as the film moves. To do this you will need to write a c program to print the values to the terminal repeatably or plot the voltage over time. The sample code below shows a simple program to print the voltage of the sensor to the screen.

==Sample Code==
The following code can be found on [https://github.com/geislekj/ECE497/tree/master/miniProject2 git hub].

<pre>
/**************************************
Example Program for the Large Piezo Vibration Sensor - With Mass

This will display the value of the AIN0 Pin directly to the terminal repeatively.

wrtten by Kevin Geisler, 23-Sept-2012
***************************************/
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

#define SYSFS_AIN1_DIR "/sys/devices/platform/omap/tsc/ain2"

FILE *fp;

int readanalog(){
if ((fp = fopen(SYSFS_AIN1_DIR, "r")) == NULL)
{
printf("Cannot open value file.\n");
exit(1);
}

//Set pointer to begining of the file
rewind(fp);
//Write our value of "0" to the file
char inString[10];
fgets(&inString, 10, fp);
fflush(fp);
// printf("...value set to 0...\n");
fclose(fp);
// printf(inString);
return atoi(&inString);
}

int main(int argc, char** argv)
{

//Run an infinite loop - will require Ctrl-C to exit this program
while(1)
{
printf("%d\n",readanalog());
usleep(100000);

}
return 0;
}
</pre>

User:Geislekj

2012-11-02T04:53:22Z

Geislekj:

{{GeislekjHead}}

* Computer Science Major, Class of 2013
* Robotics Minor
* Electrical Engineering Minor

== Projects ==
Project topics I'm interested in:
* Autonomous Robots or Drones

== Mini-projects ==

[[Category:ECE497]]

Template:GeislekjHead

2012-11-02T04:52:33Z

Geislekj: Created page with "thumb‎ '''Embedded Linux Class''' Kevin Geisler [http://Rose-Hulman.edu ''RHIT'']"

[[File:RoseLogo96.png|150px|thumb‎]] '''Embedded Linux Class''' [[User:geislekj | Kevin Geisler]] [http://Rose-Hulman.edu ''RHIT'']

ECE497 Beagle VNS

2012-11-02T04:49:04Z

Geislekj: /* Future Work */

ECE497 Beagle VNS

2012-11-02T04:48:07Z

Geislekj: /* Work Breakdown */

ECE497 Beagle VNS

2012-11-02T04:47:26Z

Geislekj: /* Work Breakdown */

ECE497 Beagle VNS

2012-11-02T04:46:46Z

Geislekj: /* Work Breakdown */

ECE497 Beagle VNS

2012-11-02T04:40:04Z

Geislekj: /* User Instructions */

ECE497 Beagle VNS

2012-11-02T04:23:03Z

Geislekj: /* Software */

ECE497 Beagle VNS

2012-11-02T04:09:47Z

Geislekj: /* Software */

ECE497 Beagle VNS

2012-11-02T04:06:54Z

Geislekj: /* Software */

ECE497 Beagle VNS

2012-11-02T03:56:05Z

Geislekj: /* Executive Summary */