eLinux.org - User contributions [en]

ECE497 Project: Node.js Weather Station

2012-02-19T06:58:23Z

Ziyi Zhang: /* User Instructions */

[[Category:ECE497]]

Team members: [[user:Caogecym | Yuming Cao]], [[user:Ziyi Zhang | Ziyi Zhang]]

== Executive Summary ==

Our project aims to implement the emerging nodejs technique (the server side javascript) as a lightweight web server on the beagleboard and accomplish a series of remote monitoring and control of hardware pins like gpio/led/i2c on the beagleboard. We also tried to make our web server send automatic email when temperature goes too high. There are a lot of things we can do on the nodejs web server, but we try to make it related to our beagleboard hardware interface.

The automatic email sender is not working correctly. More work needs to be done to set a proper configuration to the SMTP server 'postfix'.

This turns out to be a very fun application-level project and Node.js is really a very friendly, easy-to-use emerging technology that should be promoted to wider industry use.

== Installation Instructions ==
1. Here's our [https://github.com/ github] path that includes everything useful to our project: [https://github.com/caoy1/Project https://github.com/caoy1/Project].

2. Additional packages installed via '''opkg''':

* install nodejs
<pre>
opkg update
opkg install nodejs
opkg install nodejs-dev
</pre>

* install node package manager
<pre>
curl http://npmjs.org/install.sh | sh
</pre>

* install socket.io module
<pre>
npm install socket.io
</pre>

* install binary module
<pre>
npm install binary
</pre>

* install mailer module
<pre>
npm install mailer
</pre>

* install SMTP server postfix
Go to [http://postfix.energybeam.com/source/index.html] download the source of postfix, then unzip the .gz file, then run 'make', then run
<pre>
sh postfix-install
</pre>

* Here's the guideline to install Cloud9 easily: [https://github.com/jadonk/cloud9/blob/master/README.md]

== User Instructions ==

Go to our github address above, our final work resides in the "/Project/new" [https://github.com/caoy1/Project/tree/master/new directory]. Pull everything out in that folder, then go into this "new" directory on your host computer, executes the index.js program, then you are good to go:
<pre>
node index.js
</pre>
On the console, "Server has started" will be printed out.
Fire up any of your browser, and visit the beagleboard's IP address:3001(port number). Currently the address is:
<pre>
http://137.112.101.67:3001
</pre>
The webpage will show up and the temperature is real-time updated. You can also select the LED toggle mode on the page, and when you hit "select", the LED light on the board will toggle in the way you specify on the page.

== Highlights ==

Remote monitoring parameters like room temperature, if sensors are equipped on board, and control hardware pins on board, at anywhere, anytime, when you have access to the Internet.

== Theory of Operation ==
To build a web server, we need, in essence, both client side and server side scripts. Client side scripts mainly just involve ordinary javascripts that can be embedded in HTML file; while at the server-side, we adopt the emerging node.js, which is a really simple server side script that accomplishes equivalent tasks like ASP, PHP will do, but with even simpler implementation details.
== Work Breakdown ==
1. We've already successfully using JavaScript read and write data to the linux gpio file.
<pre>
fs.writeFileSync("/sys/class/leds/beagleboard::usr0/trigger", "heartbeat");
</pre>

<pre>
fs.writeFileSync("/sys/class/gpio/export", ""+5);
</pre>

2. Even though we can access to the gpio in the above way, we still need to find someway to access the I2C information. In the I2C exercises, from the C code provided in exercise 5, we can think of the following two options:

a) To translate tons of the C codes into JavaScript...including rewriting the union structures like i2c_smbus_write_byte() and i2c_smbus_read_byte(), which requires far more knowledge in understanding how to translate the underlying hardware detail into upper-level script languages...

b) Try to run the ./myi2c excutable file directly inside nodjs script...

* It seems that the second way is easier... We've already found a ActiveXObject.run method... We're working on this... turns out this does not work for some reason.

* At last we successfully excute the ./myi2c file inside our javascript using the following code, the big idea is create another child process to handle it:

<pre>
var exec = require('child_process').exec,
child;
child = exec('./myi2c',
function (error, stdout, stderr) {
console.log('stdout:', stdout);
console.log('stderr:', stderr);
if (error !== null) {
console.log('exec error:', error);
}
});
</pre>

And the terminal will show the temperature.

3. Now we are going to working on how to show this temperature information on the website so that we can visit it from any place!!!

* I've successfully done it!!! The pics are already uploaded to the github. Check the following code:
<pre>
var fs = require("fs");
var http = require("http");

try {
http.createServer(function(request, response) {

response.writeHead(200, {"Content-Type": "text/plain"});
var exec = require('child_process').exec, child;
child = exec('./myi2c',
function (error, stdout, stderr) {
response.write(stdout);
console.log('stdout:', stdout);
console.log('stderr:', stderr);
response.end();
if(error != null) {
console.log('exec error:', error);
}
}
);
}).listen(8888);
} catch(ex3) {
console.log("sb");
}
</pre>

4. The next thing we will do is to refresh the website every other time...

* We are now able to load html file inside nodejs scripts so that we can put normal HTML stuff inside the web page and load it from server scripts. The following code snippet can accomplish this (borrowed and modified based on Jadon's code):
<pre>
function loadHTMLFile(uri, res, temp) {
var filename = path.join(process.cwd(), uri);
path.exists(
filename,
function(exists) {
if(!exists) {
res.writeHead(404, {"Content-Type": "text/plain"});
res.write("404 Not Found\n");
res.end();
return;
}

fs.readFile(
filename,
encoding='utf8',
function(err, file) {
if(err) {
res.writeHead(500, {"Content-Type": "text/plain"});
res.write(err + "\n");
res.end();
return;
}
res.writeHead(200, {"Content-Type": "text/html"});
var str = ("" + file).replace("", temp);
res.write(str);
res.end();
}
);
}
);
}
</pre>
And outside the above function, the main routine, we have similar code as listed in 3, but insert the function call:
<pre>
child = exec('./myi2c',
function (error, stdout, stderr) {
console.log('stdout:', stdout);
console.log('stderr:', stderr);
loadHTMLFile('/index.html', response, stdout);
if(error != null) {
console.log('exec error:', error);
}
}
);
</pre>
* Now we can update the temperature information on the website, both triggered by a button on the page, and by just automatically refreshing the temperature value whenever the temperature changes. Here is the simple client script for accomplishing this:
<pre>
<html>
<head>
<script language="javascript">
setInterval("document.forms[0].submit()",5000);
</script>
</head>
<body>
<center>
<h1>Welcome to the world of Node.js</h1>

<p>Here is the demo of the weather station.</p>
<h2>Current temperature:</h2>
<pre>
<span id="temperature output"></span>
<form action = "/test.js" method="post">
<input type="submit" value="get temperature">
</form>
</center>
</body>
</html>
</pre>

5. Now we are trying to do something fancy! We want to send the user an automatic warning email when the temperature is too high. Here's the Javascript code using node.js mailer module. This code use SMTP server to send email to the destination.

<pre>
var email = require('mailer');

email.SMTP = {
host: 'smtp.gmail.com',
port: 587,
ssl: false,
use_authentication: false,
}

email.send({
to : "caoy1@rose-hulman.edu",
from : "obama@whitehouse.gov",
subject : "I love beagleboard!",
body: "Hello beagle world.",
},

function(err, result) {
if(err) {
console.log(err);
}
});
</pre>

* However, the configuration on our beagle has some problem. The server has no response to mailer's request. We've tried telnet localhost 587, and connection can be connected. This means the 587 port is already opened. Then I tried the same code under my ubuntu system, it turns out everything works fine, the caoy1@rose-hulman.edu can receive the e-mail, except some client-side warning error when running the mail.js file. I think the reason it works on ubuntu is because when installing postfix, there's an automatic configuration step, which doesn't exist on our beagle installation. So there must be some problem with the postfix configuration of beagleboard. I've tried to copy all the configuration files under /etc/postfix to our beagleboard, but there's just the same problem. If I have more time, or someone else who's interested in continuing this project, I suggest you have some research on the configuration thing. Everytime you make some config changes, just run
<pre>
postfix reload
</pre>
to apply the change.

5. Our next goal is to toggle LED via web page, whose control flow structure is essentially similar to the i2c communications, plus, we have already learned the way to write to the led pin via nodejs script(see note1 above).
* Before actually doing that, let's first organize our code in a more hierarchical and reasonable way.Thanks to Mr. Manuel Kiessling's excellent introductory tutorial "[http://www.nodebeginner.org The Node Beginner Book]", which gives a pretty decent explanation on how a formal web server architecture should be constructed using nodejs. Basically, we should maintain an index.js that starts all of our code, have a server.js to actually create the server and listen on the port for any posts from the client side, and pass the request and response to the router.js to handle different requests. In requestHandlers.js, each function then does the real work based on the request information and execute corresponding server responses.
* The following is what's in index.js:
<pre>
var server = require("./server");
var router = require("./router");
var requestHandlers = require("./requestHandlers");

var handle = {}
handle["/"] = requestHandlers.i2c;
handle["/led"] = requestHandlers.led;
handle["/i2c"] = requestHandlers.i2c;

server.start(router.route, handle);
</pre>
* And we abstract the server.js to be a general form so that it is independent of what will actually be done at the server, such details are left for requestHandlers.js to accomplish:
<pre>
var http = require("http");
var url = require("url");
var sys = require('sys');
var fs = require('fs');
var path = require('path');
var events = require('events');

function start(route, handle) {
function onRequest(request, response){
var pathname = url.parse(request.url).pathname;
route(handle, pathname, response, request);
}

http.createServer(onRequest).listen(3001);
console.log("Server has started.");
}

exports.start = start;
</pre>
* router.js gets the request's pathname and call different functions according to different request url:
<pre>
function route(handle, pathname, response, request) {
console.log("About to route a request for " + pathname);
if (typeof handle[pathname] === 'function') {
handle[pathname](response, request);
} else {
console.log("No request handler found for " + pathname);
response.writeHead(404, {"Content-Type": "text/plain"});
response.write("404 Not found");
response.end();
}
}

exports.route = route;
</pre>
* In requestHandlers.js, we need two functions, one for handle i2c request, another for led toggling request:
<pre>
function i2c(response, request) {
var uri = url.parse(request.url).pathname;
...//same as described above, including calling loadHTMLFile function that's also in requestHandlers.js
}

function led(response, request) {
...//details in below
}
</pre>

6. Now it's time for us to think about how to toggle LED via web page. Turns out it's very similar to how i2c works. However, this time we need to not only parse the uri of the request, but also get the posted data from the request, parse them and write them into the appropriate file system. The event-driven nodejs utilizes "addListener" function to achieve the task, with parameter "data" to receive the data and "end" to handle and process them. The data received(in type of string) should be converted to object class by the "querystring" module.

On the client side, we use exclusive radio button to allow user to choose the toggle mode of LED:
<pre>
<form action = "/led" method="post" size="30">
<input type="radio" name="mode" value="nand-disk" >nand-disk
<input type="radio" name="mode" value="mmc0" />mmc0
<input type="radio" name="mode" value="heartbeat" >heartbeat
<input type="radio" name="mode" value="none" >none
<input type="submit" value="Select" onclick="xmlhttpPost()">
</form>
</pre>
The corresponding javascript just submits this form to /led, which then be handled by router to execute led() function:
<pre>
function xmlhttpPost() {
documents.forms[1].submit();
}
</pre>
The following is the server side function code in requestHandlers.js:
<pre>
var qs = require('querystring');
var url = require('url');
var sys = require('sys');
var fs = require('fs');
var path = require('path');
function led(response, request) {
var postData = "";
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " received.");

request.setEncoding("utf8");

request.addListener("data", function(postDataChunk) {
postData += postDataChunk;
console.log("Received POST data chunk '"+
postDataChunk + "'.");
});

request.addListener("end", function() {
var ledtype = qs.parse(postData);
console.log(ledtype.mode);
fs.writeFileSync("/sys/class/leds/beagleboard::usr0/trigger", ledtype.mode);
});
}
</pre>
Another thing to notice is, in order for this requestHandler for led.js not to jump to a brand new web page but stay on the current one, the normal "request.end()" code, which indicates the completion of an intact .js page, should be left out.

7. Eventually we did a little bit beautification on the html page --- somehow CSS does not work as intended, we simply change some font and color of the output to make it a bit neater.

== Conclusions ==

This project dabbles in the possibility of setting a web-server written in nodejs on the embedded environment and accomplishes the proposed idea of interacting with underlying hardware pins and system via upper-level user interface. nodejs is very simple and easy to implement, its non-blocking, event-driven and single-threaded mechanism is exactly suitable for the embedded system and our project gives a good instance of its application. Our demo system can be scaled up with far more features in remote monitoring and smart control industry. If, for example, the nodemailer can work well on the Angstrom (apparently it's working on Ubuntu, but somehow does not seem to be compatible with Angstrom), or other embedded Linux distribution, it can become as powerful as intelligent agent in monitoring various parameters, like temperature, moisture, so on so forth.

ECE497 Project: Node.js Weather Station

2012-02-19T06:55:36Z

Ziyi Zhang:

[[Category:ECE497]]

Team members: [[user:Caogecym | Yuming Cao]], [[user:Ziyi Zhang | Ziyi Zhang]]

== Executive Summary ==

Our project aims to implement the emerging nodejs technique (the server side javascript) as a lightweight web server on the beagleboard and accomplish a series of remote monitoring and control of hardware pins like gpio/led/i2c on the beagleboard. We also tried to make our web server send automatic email when temperature goes too high. There are a lot of things we can do on the nodejs web server, but we try to make it related to our beagleboard hardware interface.

The automatic email sender is not working correctly. More work needs to be done to set a proper configuration to the SMTP server 'postfix'.

This turns out to be a very fun application-level project and Node.js is really a very friendly, easy-to-use emerging technology that should be promoted to wider industry use.

== Installation Instructions ==
1. Here's our [https://github.com/ github] path that includes everything useful to our project: [https://github.com/caoy1/Project https://github.com/caoy1/Project].

2. Additional packages installed via '''opkg''':

* install nodejs
<pre>
opkg update
opkg install nodejs
opkg install nodejs-dev
</pre>

* install node package manager
<pre>
curl http://npmjs.org/install.sh | sh
</pre>

* install socket.io module
<pre>
npm install socket.io
</pre>

* install binary module
<pre>
npm install binary
</pre>

* install mailer module
<pre>
npm install mailer
</pre>

* install SMTP server postfix
Go to [http://postfix.energybeam.com/source/index.html] download the source of postfix, then unzip the .gz file, then run 'make', then run
<pre>
sh postfix-install
</pre>

* Here's the guideline to install Cloud9 easily: [https://github.com/jadonk/cloud9/blob/master/README.md]

== User Instructions ==

Go to our github address above, our final work resides in the "new" folder. Pull everything out in that folder, then go into this "new" directory on your host computer, executes the index.js program, then you are good to go:
<pre>
node index.js
</pre>
On the console, "Server has started" will be printed out.
Fire up any of your browser, and visit the beagleboard's IP address:3001(port number). Currently the address is:
<pre>
http://137.112.101.67:3001
</pre>
The webpage will show up and the temperature is real-time updated. You can also select the LED toggle mode on the page, and when you hit "select", the LED light on the board will toggle in the way you specify on the page.
== Highlights ==

Remote monitoring parameters like room temperature, if sensors are equipped on board, and control hardware pins on board, at anywhere, anytime, when you have access to the Internet.

== Theory of Operation ==
To build a web server, we need, in essence, both client side and server side scripts. Client side scripts mainly just involve ordinary javascripts that can be embedded in HTML file; while at the server-side, we adopt the emerging node.js, which is a really simple server side script that accomplishes equivalent tasks like ASP, PHP will do, but with even simpler implementation details.
== Work Breakdown ==
1. We've already successfully using JavaScript read and write data to the linux gpio file.
<pre>
fs.writeFileSync("/sys/class/leds/beagleboard::usr0/trigger", "heartbeat");
</pre>

<pre>
fs.writeFileSync("/sys/class/gpio/export", ""+5);
</pre>

2. Even though we can access to the gpio in the above way, we still need to find someway to access the I2C information. In the I2C exercises, from the C code provided in exercise 5, we can think of the following two options:

a) To translate tons of the C codes into JavaScript...including rewriting the union structures like i2c_smbus_write_byte() and i2c_smbus_read_byte(), which requires far more knowledge in understanding how to translate the underlying hardware detail into upper-level script languages...

b) Try to run the ./myi2c excutable file directly inside nodjs script...

* It seems that the second way is easier... We've already found a ActiveXObject.run method... We're working on this... turns out this does not work for some reason.

* At last we successfully excute the ./myi2c file inside our javascript using the following code, the big idea is create another child process to handle it:

<pre>
var exec = require('child_process').exec,
child;
child = exec('./myi2c',
function (error, stdout, stderr) {
console.log('stdout:', stdout);
console.log('stderr:', stderr);
if (error !== null) {
console.log('exec error:', error);
}
});
</pre>

And the terminal will show the temperature.

3. Now we are going to working on how to show this temperature information on the website so that we can visit it from any place!!!

* I've successfully done it!!! The pics are already uploaded to the github. Check the following code:
<pre>
var fs = require("fs");
var http = require("http");

try {
http.createServer(function(request, response) {

response.writeHead(200, {"Content-Type": "text/plain"});
var exec = require('child_process').exec, child;
child = exec('./myi2c',
function (error, stdout, stderr) {
response.write(stdout);
console.log('stdout:', stdout);
console.log('stderr:', stderr);
response.end();
if(error != null) {
console.log('exec error:', error);
}
}
);
}).listen(8888);
} catch(ex3) {
console.log("sb");
}
</pre>

4. The next thing we will do is to refresh the website every other time...

* We are now able to load html file inside nodejs scripts so that we can put normal HTML stuff inside the web page and load it from server scripts. The following code snippet can accomplish this (borrowed and modified based on Jadon's code):
<pre>
function loadHTMLFile(uri, res, temp) {
var filename = path.join(process.cwd(), uri);
path.exists(
filename,
function(exists) {
if(!exists) {
res.writeHead(404, {"Content-Type": "text/plain"});
res.write("404 Not Found\n");
res.end();
return;
}

fs.readFile(
filename,
encoding='utf8',
function(err, file) {
if(err) {
res.writeHead(500, {"Content-Type": "text/plain"});
res.write(err + "\n");
res.end();
return;
}
res.writeHead(200, {"Content-Type": "text/html"});
var str = ("" + file).replace("", temp);
res.write(str);
res.end();
}
);
}
);
}
</pre>
And outside the above function, the main routine, we have similar code as listed in 3, but insert the function call:
<pre>
child = exec('./myi2c',
function (error, stdout, stderr) {
console.log('stdout:', stdout);
console.log('stderr:', stderr);
loadHTMLFile('/index.html', response, stdout);
if(error != null) {
console.log('exec error:', error);
}
}
);
</pre>
* Now we can update the temperature information on the website, both triggered by a button on the page, and by just automatically refreshing the temperature value whenever the temperature changes. Here is the simple client script for accomplishing this:
<pre>
<html>
<head>
<script language="javascript">
setInterval("document.forms[0].submit()",5000);
</script>
</head>
<body>
<center>
<h1>Welcome to the world of Node.js</h1>

<p>Here is the demo of the weather station.</p>
<h2>Current temperature:</h2>
<pre>
<span id="temperature output"></span>
<form action = "/test.js" method="post">
<input type="submit" value="get temperature">
</form>
</center>
</body>
</html>
</pre>

5. Now we are trying to do something fancy! We want to send the user an automatic warning email when the temperature is too high. Here's the Javascript code using node.js mailer module. This code use SMTP server to send email to the destination.

<pre>
var email = require('mailer');

email.SMTP = {
host: 'smtp.gmail.com',
port: 587,
ssl: false,
use_authentication: false,
}

email.send({
to : "caoy1@rose-hulman.edu",
from : "obama@whitehouse.gov",
subject : "I love beagleboard!",
body: "Hello beagle world.",
},

function(err, result) {
if(err) {
console.log(err);
}
});
</pre>

* However, the configuration on our beagle has some problem. The server has no response to mailer's request. We've tried telnet localhost 587, and connection can be connected. This means the 587 port is already opened. Then I tried the same code under my ubuntu system, it turns out everything works fine, the caoy1@rose-hulman.edu can receive the e-mail, except some client-side warning error when running the mail.js file. I think the reason it works on ubuntu is because when installing postfix, there's an automatic configuration step, which doesn't exist on our beagle installation. So there must be some problem with the postfix configuration of beagleboard. I've tried to copy all the configuration files under /etc/postfix to our beagleboard, but there's just the same problem. If I have more time, or someone else who's interested in continuing this project, I suggest you have some research on the configuration thing. Everytime you make some config changes, just run
<pre>
postfix reload
</pre>
to apply the change.

5. Our next goal is to toggle LED via web page, whose control flow structure is essentially similar to the i2c communications, plus, we have already learned the way to write to the led pin via nodejs script(see note1 above).
* Before actually doing that, let's first organize our code in a more hierarchical and reasonable way.Thanks to Mr. Manuel Kiessling's excellent introductory tutorial "[http://www.nodebeginner.org The Node Beginner Book]", which gives a pretty decent explanation on how a formal web server architecture should be constructed using nodejs. Basically, we should maintain an index.js that starts all of our code, have a server.js to actually create the server and listen on the port for any posts from the client side, and pass the request and response to the router.js to handle different requests. In requestHandlers.js, each function then does the real work based on the request information and execute corresponding server responses.
* The following is what's in index.js:
<pre>
var server = require("./server");
var router = require("./router");
var requestHandlers = require("./requestHandlers");

var handle = {}
handle["/"] = requestHandlers.i2c;
handle["/led"] = requestHandlers.led;
handle["/i2c"] = requestHandlers.i2c;

server.start(router.route, handle);
</pre>
* And we abstract the server.js to be a general form so that it is independent of what will actually be done at the server, such details are left for requestHandlers.js to accomplish:
<pre>
var http = require("http");
var url = require("url");
var sys = require('sys');
var fs = require('fs');
var path = require('path');
var events = require('events');

function start(route, handle) {
function onRequest(request, response){
var pathname = url.parse(request.url).pathname;
route(handle, pathname, response, request);
}

http.createServer(onRequest).listen(3001);
console.log("Server has started.");
}

exports.start = start;
</pre>
* router.js gets the request's pathname and call different functions according to different request url:
<pre>
function route(handle, pathname, response, request) {
console.log("About to route a request for " + pathname);
if (typeof handle[pathname] === 'function') {
handle[pathname](response, request);
} else {
console.log("No request handler found for " + pathname);
response.writeHead(404, {"Content-Type": "text/plain"});
response.write("404 Not found");
response.end();
}
}

exports.route = route;
</pre>
* In requestHandlers.js, we need two functions, one for handle i2c request, another for led toggling request:
<pre>
function i2c(response, request) {
var uri = url.parse(request.url).pathname;
...//same as described above, including calling loadHTMLFile function that's also in requestHandlers.js
}

function led(response, request) {
...//details in below
}
</pre>

6. Now it's time for us to think about how to toggle LED via web page. Turns out it's very similar to how i2c works. However, this time we need to not only parse the uri of the request, but also get the posted data from the request, parse them and write them into the appropriate file system. The event-driven nodejs utilizes "addListener" function to achieve the task, with parameter "data" to receive the data and "end" to handle and process them. The data received(in type of string) should be converted to object class by the "querystring" module.

On the client side, we use exclusive radio button to allow user to choose the toggle mode of LED:
<pre>
<form action = "/led" method="post" size="30">
<input type="radio" name="mode" value="nand-disk" >nand-disk
<input type="radio" name="mode" value="mmc0" />mmc0
<input type="radio" name="mode" value="heartbeat" >heartbeat
<input type="radio" name="mode" value="none" >none
<input type="submit" value="Select" onclick="xmlhttpPost()">
</form>
</pre>
The corresponding javascript just submits this form to /led, which then be handled by router to execute led() function:
<pre>
function xmlhttpPost() {
documents.forms[1].submit();
}
</pre>
The following is the server side function code in requestHandlers.js:
<pre>
var qs = require('querystring');
var url = require('url');
var sys = require('sys');
var fs = require('fs');
var path = require('path');
function led(response, request) {
var postData = "";
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " received.");

request.setEncoding("utf8");

request.addListener("data", function(postDataChunk) {
postData += postDataChunk;
console.log("Received POST data chunk '"+
postDataChunk + "'.");
});

request.addListener("end", function() {
var ledtype = qs.parse(postData);
console.log(ledtype.mode);
fs.writeFileSync("/sys/class/leds/beagleboard::usr0/trigger", ledtype.mode);
});
}
</pre>
Another thing to notice is, in order for this requestHandler for led.js not to jump to a brand new web page but stay on the current one, the normal "request.end()" code, which indicates the completion of an intact .js page, should be left out.

7. Eventually we did a little bit beautification on the html page --- somehow CSS does not work as intended, we simply change some font and color of the output to make it a bit neater.

== Conclusions ==

This project dabbles in the possibility of setting a web-server written in nodejs on the embedded environment and accomplishes the proposed idea of interacting with underlying hardware pins and system via upper-level user interface. nodejs is very simple and easy to implement, its non-blocking, event-driven and single-threaded mechanism is exactly suitable for the embedded system and our project gives a good instance of its application. Our demo system can be scaled up with far more features in remote monitoring and smart control industry. If, for example, the nodemailer can work well on the Angstrom (apparently it's working on Ubuntu, but somehow does not seem to be compatible with Angstrom), or other embedded Linux distribution, it can become as powerful as intelligent agent in monitoring various parameters, like temperature, moisture, so on so forth.

ECE497 Project: Node.js Weather Station

2012-02-19T06:34:56Z

Ziyi Zhang: /* Work Breakdown */

[[Category:ECE497]]

Team members: [[user:Caogecym | Yuming Cao]], [[user:Ziyi Zhang | Ziyi Zhang]]

== Executive Summary ==

Our project aims to implement the emerging nodejs technique (the server side javascript) as a lightweight web server on the beagleboard and accomplish a series of remote monitoring and control of hardware pins like gpio/led/i2c on the beagleboard. We also tried to make our web server send automatic email when temperature goes too high. There are a lot of things we can do on the nodejs web server, but we try to make it related to our beagleboard hardware interface.

The automatic email sender is not working correctly. More work needs to be done to set a proper configuration to the SMTP server 'postfix'.

End with a two sentence conclusion.

The sentence count is approximate and only to give an idea of the expected length.

== Installation Instructions ==
1. Here's our [https://github.com/ github] path that includes everything useful to our project: [https://github.com/caoy1/Project https://github.com/caoy1/Project].

2. Additional packages installed via '''opkg''':

* install nodejs
<pre>
opkg update
opkg install nodejs
opkg install nodejs-dev
</pre>

* install node package manager
<pre>
curl http://npmjs.org/install.sh | sh
</pre>

* install socket.io module
<pre>
npm install socket.io
</pre>

* install binary module
<pre>
npm install binary
</pre>

* install mailer module
<pre>
npm install mailer
</pre>

* install SMTP server postfix
Go to [http://postfix.energybeam.com/source/index.html] download the source of postfix, then unzip the .gz file, then run 'make', then run
<pre>
sh postfix-install
</pre>

* Here's the guideline to install Cloud9 easily: [https://github.com/jadonk/cloud9/blob/master/README.md]

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

== Highlights ==

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

Consider including 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.

To build a web server, we need, in essence, both client side and server side scripts. Client side scripts mainly just involve ordinary javascripts that can be embedded in HTML file; while at the server-side, we adopt the emerging node.js, which is a really simple server side script that accomplishes equivalent tasks like ASP, PHP will do, but with even simpler implementation details.
== Work Breakdown ==
1. We've already successfully using JavaScript read and write data to the linux gpio file.
<pre>
fs.writeFileSync("/sys/class/leds/beagleboard::usr0/trigger", "heartbeat");
</pre>

<pre>
fs.writeFileSync("/sys/class/gpio/export", ""+5);
</pre>

2. Even though we can access to the gpio in the above way, we still need to find someway to access the I2C information. In the I2C exercises, from the C code provided in exercise 5, we can think of the following two options:

a) To translate tons of the C codes into JavaScript...including rewriting the union structures like i2c_smbus_write_byte() and i2c_smbus_read_byte(), which requires far more knowledge in understanding how to translate the underlying hardware detail into upper-level script languages...

b) Try to run the ./myi2c excutable file directly inside nodjs script...

* It seems that the second way is easier... We've already found a ActiveXObject.run method... We're working on this... turns out this does not work for some reason.

* At last we successfully excute the ./myi2c file inside our javascript using the following code, the big idea is create another child process to handle it:

<pre>
var exec = require('child_process').exec,
child;
child = exec('./myi2c',
function (error, stdout, stderr) {
console.log('stdout:', stdout);
console.log('stderr:', stderr);
if (error !== null) {
console.log('exec error:', error);
}
});
</pre>

And the terminal will show the temperature.

3. Now we are going to working on how to show this temperature information on the website so that we can visit it from any place!!!

* I've successfully done it!!! The pics are already uploaded to the github. Check the following code:
<pre>
var fs = require("fs");
var http = require("http");

try {
http.createServer(function(request, response) {

response.writeHead(200, {"Content-Type": "text/plain"});
var exec = require('child_process').exec, child;
child = exec('./myi2c',
function (error, stdout, stderr) {
response.write(stdout);
console.log('stdout:', stdout);
console.log('stderr:', stderr);
response.end();
if(error != null) {
console.log('exec error:', error);
}
}
);
}).listen(8888);
} catch(ex3) {
console.log("sb");
}
</pre>

4. The next thing we will do is to refresh the website every other time...

* We are now able to load html file inside nodejs scripts so that we can put normal HTML stuff inside the web page and load it from server scripts. The following code snippet can accomplish this (borrowed and modified based on Jadon's code):
<pre>
function loadHTMLFile(uri, res, temp) {
var filename = path.join(process.cwd(), uri);
path.exists(
filename,
function(exists) {
if(!exists) {
res.writeHead(404, {"Content-Type": "text/plain"});
res.write("404 Not Found\n");
res.end();
return;
}

fs.readFile(
filename,
encoding='utf8',
function(err, file) {
if(err) {
res.writeHead(500, {"Content-Type": "text/plain"});
res.write(err + "\n");
res.end();
return;
}
res.writeHead(200, {"Content-Type": "text/html"});
var str = ("" + file).replace("", temp);
res.write(str);
res.end();
}
);
}
);
}
</pre>
And outside the above function, the main routine, we have similar code as listed in 3, but insert the function call:
<pre>
child = exec('./myi2c',
function (error, stdout, stderr) {
console.log('stdout:', stdout);
console.log('stderr:', stderr);
loadHTMLFile('/index.html', response, stdout);
if(error != null) {
console.log('exec error:', error);
}
}
);
</pre>
* Now we can update the temperature information on the website, both triggered by a button on the page, and by just automatically refreshing the temperature value whenever the temperature changes. Here is the simple client script for accomplishing this:
<pre>
<html>
<head>
<script language="javascript">
setInterval("document.forms[0].submit()",5000);
</script>
</head>
<body>
<center>
<h1>Welcome to the world of Node.js</h1>

<p>Here is the demo of the weather station.</p>
<h2>Current temperature:</h2>
<pre>
<span id="temperature output"></span>
<form action = "/test.js" method="post">
<input type="submit" value="get temperature">
</form>
</center>
</body>
</html>
</pre>

5. Now we are trying to do something fancy! We want to send the user an automatic warning email when the temperature is too high. Here's the Javascript code using node.js mailer module. This code use SMTP server to send email to the destination.

<pre>
var email = require('mailer');

email.SMTP = {
host: 'smtp.gmail.com',
port: 587,
ssl: false,
use_authentication: false,
}

email.send({
to : "caoy1@rose-hulman.edu",
from : "obama@whitehouse.gov",
subject : "I love beagleboard!",
body: "Hello beagle world.",
},

function(err, result) {
if(err) {
console.log(err);
}
});
</pre>

* However, the configuration on our beagle has some problem. The server has no response to mailer's request. We've tried telnet localhost 587, and connection can be connected. This means the 587 port is already opened. Then I tried the same code under my ubuntu system, it turns out everything works fine, the caoy1@rose-hulman.edu can receive the e-mail, except some client-side warning error when running the mail.js file. I think the reason it works on ubuntu is because when installing postfix, there's an automatic configuration step, which doesn't exist on our beagle installation. So there must be some problem with the postfix configuration of beagleboard. I've tried to copy all the configuration files under /etc/postfix to our beagleboard, but there's just the same problem. If I have more time, or someone else who's interested in continuing this project, I suggest you have some research on the configuration thing. Everytime you make some config changes, just run
<pre>
postfix reload
</pre>
to apply the change.

5. Our next goal is to toggle LED via web page, whose control flow structure is essentially similar to the i2c communications, plus, we have already learned the way to write to the led pin via nodejs script(see note1 above).
* Before actually doing that, let's first organize our code in a more hierarchical and reasonable way.Thanks to Mr. Manuel Kiessling's excellent introductory tutorial "[http://www.nodebeginner.org The Node Beginner Book]", which gives a pretty decent explanation on how a formal web server architecture should be constructed using nodejs. Basically, we should maintain an index.js that starts all of our code, have a server.js to actually create the server and listen on the port for any posts from the client side, and pass the request and response to the router.js to handle different requests. In requestHandlers.js, each function then does the real work based on the request information and execute corresponding server responses.
* The following is what's in index.js:
<pre>
var server = require("./server");
var router = require("./router");
var requestHandlers = require("./requestHandlers");

var handle = {}
handle["/"] = requestHandlers.i2c;
handle["/led"] = requestHandlers.led;
handle["/i2c"] = requestHandlers.i2c;

server.start(router.route, handle);
</pre>
* And we abstract the server.js to be a general form so it is independent of what will actually be done at the server, such details is left for requestHandlers.js to accomplish:
<pre>
var http = require("http");
var url = require("url");
var sys = require('sys');
var fs = require('fs');
var path = require('path');
var events = require('events');

function start(route, handle) {
function onRequest(request, response){
var pathname = url.parse(request.url).pathname;
route(handle, pathname, response, request);
}

http.createServer(onRequest).listen(3001);
console.log("Server has started.");
}

exports.start = start;
</pre>
* router.js gets the request's pathname and call different functions according to different request url:
<pre>
function route(handle, pathname, response, request) {
console.log("About to route a request for " + pathname);
if (typeof handle[pathname] === 'function') {
handle[pathname](response, request);
} else {
console.log("No request handler found for " + pathname);
response.writeHead(404, {"Content-Type": "text/plain"});
response.write("404 Not found");
response.end();
}
}

exports.route = route;
</pre>
* In requestHandlers.js, we need two functions, one for handle i2c request, another for led toggling request:
<pre>
function i2c(response, request) {
var uri = url.parse(request.url).pathname;
...//same as described above, including calling loadHTMLFile function that's also in requestHandlers.js
}

function led(response, request) {
...//details in below
}
</pre>

6. Now it's time for us to think about how to toggle LED via web page. Turns out it's very similar to how i2c works. However, this time we need to not only parse the uri of the request, but also get the posted data from the request, parse them and write them into the appropriate file system. The event-driven nodejs utilizes "addListener" function to achieve the task, with parameter "data" to receive the data and "end" to handle and process them. The data received(in type of string) should be converted to object class by the "querystring" module.

On the client side, we use exclusive radio button to allow user to choose the toggle mode of LED:
<pre>
<form action = "/led" method="post" size="30">
<input type="radio" name="mode" value="nand-disk" >nand-disk
<input type="radio" name="mode" value="mmc0" />mmc0
<input type="radio" name="mode" value="heartbeat" >heartbeat
<input type="radio" name="mode" value="none" >none
<input type="submit" value="Select" onclick="xmlhttpPost()">
</form>
</pre>
The corresponding javascript just submits this form to /led, which then be handled by router to execute led() function:
<pre>
function xmlhttpPost() {
documents.forms[1].submit();
}
</pre>
The following is the server side function code in requestHandlers.js:
<pre>
var qs = require('querystring');
var url = require('url');
var sys = require('sys');
var fs = require('fs');
var path = require('path');
function led(response, request) {
var postData = "";
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " received.");

request.setEncoding("utf8");

request.addListener("data", function(postDataChunk) {
postData += postDataChunk;
console.log("Received POST data chunk '"+
postDataChunk + "'.");
});

request.addListener("end", function() {
var ledtype = qs.parse(postData);
console.log(ledtype.mode);
fs.writeFileSync("/sys/class/leds/beagleboard::usr0/trigger", ledtype.mode);
});
}
</pre>
Another thing to notice is, in order for this requestHandler for led.js not to jump to a brand new web page but stay on the current one, the normal "request.end()" code, which indicates the completion of an intact .js page, should be left out.

7. Eventually we did a little bit beautification on the html page --- somehow CSS does not work as intended, we simply change some font and color of the output to make it a bit neater.

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

ECE497 Project: Node.js Weather Station

2012-02-19T06:34:13Z

Ziyi Zhang:

[[Category:ECE497]]

Team members: [[user:Caogecym | Yuming Cao]], [[user:Ziyi Zhang | Ziyi Zhang]]

== Executive Summary ==

Our project aims to implement the emerging nodejs technique (the server side javascript) as a lightweight web server on the beagleboard and accomplish a series of remote monitoring and control of hardware pins like gpio/led/i2c on the beagleboard. We also tried to make our web server send automatic email when temperature goes too high. There are a lot of things we can do on the nodejs web server, but we try to make it related to our beagleboard hardware interface.

The automatic email sender is not working correctly. More work needs to be done to set a proper configuration to the SMTP server 'postfix'.

End with a two sentence conclusion.

The sentence count is approximate and only to give an idea of the expected length.

== Installation Instructions ==
1. Here's our [https://github.com/ github] path that includes everything useful to our project: [https://github.com/caoy1/Project https://github.com/caoy1/Project].

2. Additional packages installed via '''opkg''':

* install nodejs
<pre>
opkg update
opkg install nodejs
opkg install nodejs-dev
</pre>

* install node package manager
<pre>
curl http://npmjs.org/install.sh | sh
</pre>

* install socket.io module
<pre>
npm install socket.io
</pre>

* install binary module
<pre>
npm install binary
</pre>

* install mailer module
<pre>
npm install mailer
</pre>

* install SMTP server postfix
Go to [http://postfix.energybeam.com/source/index.html] download the source of postfix, then unzip the .gz file, then run 'make', then run
<pre>
sh postfix-install
</pre>

* Here's the guideline to install Cloud9 easily: [https://github.com/jadonk/cloud9/blob/master/README.md]

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

== Highlights ==

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

Consider including 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.

To build a web server, we need, in essence, both client side and server side scripts. Client side scripts mainly just involve ordinary javascripts that can be embedded in HTML file; while at the server-side, we adopt the emerging node.js, which is a really simple server side script that accomplishes equivalent tasks like ASP, PHP will do, but with even simpler implementation details.
== Work Breakdown ==
1. We've already successfully using JavaScript read and write data to the linux gpio file.
<pre>
fs.writeFileSync("/sys/class/leds/beagleboard::usr0/trigger", "heartbeat");
</pre>

<pre>
fs.writeFileSync("/sys/class/gpio/export", ""+5);
</pre>

2. Even though we can access to the gpio in the above way, we still need to find someway to access the I2C information. In the I2C exercises, from the C code provided in exercise 5, we can think of the following two options:

a) To translate tons of the C codes into JavaScript...including rewriting the union structures like i2c_smbus_write_byte() and i2c_smbus_read_byte(), which requires far more knowledge in understanding how to translate the underlying hardware detail into upper-level script languages...

b) Try to run the ./myi2c excutable file directly inside nodjs script...

* It seems that the second way is easier... We've already found a ActiveXObject.run method... We're working on this... turns out this does not work for some reason.

* At last we successfully excute the ./myi2c file inside our javascript using the following code, the big idea is create another child process to handle it:

<pre>
var exec = require('child_process').exec,
child;
child = exec('./myi2c',
function (error, stdout, stderr) {
console.log('stdout:', stdout);
console.log('stderr:', stderr);
if (error !== null) {
console.log('exec error:', error);
}
});
</pre>

And the terminal will show the temperature.

3. Now we are going to working on how to show this temperature information on the website so that we can visit it from any place!!!

* I've successfully done it!!! The pics are already uploaded to the github. Check the following code:
<pre>
var fs = require("fs");
var http = require("http");

try {
http.createServer(function(request, response) {

response.writeHead(200, {"Content-Type": "text/plain"});
var exec = require('child_process').exec, child;
child = exec('./myi2c',
function (error, stdout, stderr) {
response.write(stdout);
console.log('stdout:', stdout);
console.log('stderr:', stderr);
response.end();
if(error != null) {
console.log('exec error:', error);
}
}
);
}).listen(8888);
} catch(ex3) {
console.log("sb");
}
</pre>

4. The next thing we will do is to refresh the website every other time...

* We are now able to load html file inside nodejs scripts so that we can put normal HTML stuff inside the web page and load it from server scripts. The following code snippet can accomplish this (borrowed and modified based on Jadon's code):
<pre>
function loadHTMLFile(uri, res, temp) {
var filename = path.join(process.cwd(), uri);
path.exists(
filename,
function(exists) {
if(!exists) {
res.writeHead(404, {"Content-Type": "text/plain"});
res.write("404 Not Found\n");
res.end();
return;
}

fs.readFile(
filename,
encoding='utf8',
function(err, file) {
if(err) {
res.writeHead(500, {"Content-Type": "text/plain"});
res.write(err + "\n");
res.end();
return;
}
res.writeHead(200, {"Content-Type": "text/html"});
var str = ("" + file).replace("", temp);
res.write(str);
res.end();
}
);
}
);
}
</pre>
And outside the above function, the main routine, we have similar code as listed in 3, but insert the function call:
<pre>
child = exec('./myi2c',
function (error, stdout, stderr) {
console.log('stdout:', stdout);
console.log('stderr:', stderr);
loadHTMLFile('/index.html', response, stdout);
if(error != null) {
console.log('exec error:', error);
}
}
);
</pre>
* Now we can update the temperature information on the website, both triggered by a button on the page, and by just automatically refreshing the temperature value whenever the temperature changes. Here is the simple client script for accomplishing this:
<pre>
<html>
<head>
<script language="javascript">
setInterval("document.forms[0].submit()",5000);
</script>
</head>
<body>
<center>
<h1>Welcome to the world of Node.js</h1>

<p>Here is the demo of the weather station.</p>
<h2>Current temperature:</h2>
<pre>
<span id="temperature output"></span>
<form action = "/test.js" method="post">
<input type="submit" value="get temperature">
</form>
</center>
</body>
</html>
</pre>

5. Now we are trying to do something fancy! We want to send the user an automatic warning email when the temperature is too high. Here's the Javascript code using node.js mailer module. This code use SMTP server to send email to the destination.

<pre>
var email = require('mailer');

email.SMTP = {
host: 'smtp.gmail.com',
port: 587,
ssl: false,
use_authentication: false,
}

email.send({
to : "caoy1@rose-hulman.edu",
from : "obama@whitehouse.gov",
subject : "I love beagleboard!",
body: "Hello beagle world.",
},

function(err, result) {
if(err) {
console.log(err);
}
});
</pre>

* However, the configuration on our beagle has some problem. The server has no response to mailer's request. We've tried telnet localhost 587, and connection can be connected. This means the 587 port is already opened. Then I tried the same code under my ubuntu system, it turns out everything works fine, the caoy1@rose-hulman.edu can receive the e-mail, except some client-side warning error when running the mail.js file. I think the reason it works on ubuntu is because when installing postfix, there's an automatic configuration step, which doesn't exist on our beagle installation. So there must be some problem with the postfix configuration of beagleboard. I've tried to copy all the configuration files under /etc/postfix to our beagleboard, but there's just the same problem. If I have more time, or someone else who's interested in continuing this project, I suggest you have some research on the configuration thing. Everytime you make some config changes, just run
<pre>
postfix reload
</pre>
to apply the change.

5. Our next goal is to toggle LED via web page, whose control flow structure is essentially similar to the i2c communications, plus, we have already learned the way to write to the led pin via nodejs script(see note1 above).
* Before actually doing that, let's first organize our code in a more hierarchical and reasonable way.Thanks to Mr. Manuel Kiessling's excellent introductory tutorial "[http://www.nodebeginner.org The Node Beginner Book]", which gives a pretty decent explanation on how a formal web server architecture should be constructed using nodejs. Basically, we should maintain an index.js that starts all of our code, have a server.js to actually create the server and listen on the port for any posts from the client side, and pass the request and response to the router.js to handle different requests. In requestHandlers.js, each function then does the real work based on the request information and execute corresponding server responses.
* The following is what's in index.js:
<pre>
var server = require("./server");
var router = require("./router");
var requestHandlers = require("./requestHandlers");

var handle = {}
handle["/"] = requestHandlers.i2c;
handle["/led"] = requestHandlers.led;
handle["/i2c"] = requestHandlers.i2c;

server.start(router.route, handle);
</pre>
* And we abstract the server.js to be a general form so it is independent of what will actually be done at the server, such details is left for requestHandlers.js to accomplish:
<pre>
var http = require("http");
var url = require("url");
var sys = require('sys');
var fs = require('fs');
var path = require('path');
var events = require('events');

function start(route, handle) {
function onRequest(request, response){
var pathname = url.parse(request.url).pathname;
route(handle, pathname, response, request);
}

http.createServer(onRequest).listen(3001);
console.log("Server has started.");
}

exports.start = start;
</pre>
* router.js gets the request's pathname and call different functions according to different request url:
<pre>
function route(handle, pathname, response, request) {
console.log("About to route a request for " + pathname);
if (typeof handle[pathname] === 'function') {
handle[pathname](response, request);
} else {
console.log("No request handler found for " + pathname);
response.writeHead(404, {"Content-Type": "text/plain"});
response.write("404 Not found");
response.end();
}
}

exports.route = route;
</pre>
* In requestHandlers.js, we need two functions, one for handle i2c request, another for led toggling request:
<pre>
function i2c(response, request) {
var uri = url.parse(request.url).pathname;
...//same as described above, including calling loadHTMLFile function that's also in requestHandlers.js
}

function led(response, request) {
...//details in below
}
</pre>

6. Now it's time for us to think about how to toggle LED via web page. Turns out it's very similar to how i2c works. However, this time we need to not only parse the uri of the request, but also get the posted data from the request, parse them and write them into the appropriate file system. The event-driven nodejs utilizes "addListener" function to achieve the task, with parameter "data" to receive the data and "end" to handle and process them. The data received(in type of string) should be converted to object class by the "querystring" module.

On the client side, we use exclusive radio button to allow user to choose the toggle mode of LED:
<pre>
<form action = "/led" method="post" size="30">
<input type="radio" name="mode" value="nand-disk" >nand-disk
<input type="radio" name="mode" value="mmc0" />mmc0
<input type="radio" name="mode" value="heartbeat" >heartbeat
<input type="radio" name="mode" value="none" >none
<input type="submit" value="Select" onclick="xmlhttpPost()">
</form>
</pre>
The corresponding javascript just submits this form to /led, which then be handled by router to execute led() function:
<pre>
function xmlhttpPost() {
documents.forms[1].submit();
}
</pre>
The following is the server side function code in requestHandlers.js:
<pre>
var qs = require('querystring');
var url = require('url');
var sys = require('sys');
var fs = require('fs');
var path = require('path');
function led(response, request) {
var postData = "";
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " received.");

request.setEncoding("utf8");

request.addListener("data", function(postDataChunk) {
postData += postDataChunk;
console.log("Received POST data chunk '"+
postDataChunk + "'.");
});

request.addListener("end", function() {
var ledtype = qs.parse(postData);
console.log(ledtype.mode);
fs.writeFileSync("/sys/class/leds/beagleboard::usr0/trigger", ledtype.mode);
});
}
</pre>
Another thing to notice is, in order for this requestHandler for led.js not to jump to a brand new web page but stay on the current one, the normal "request.end()" code, which indicates the completion of an intact .js page, should be left out.
7. Eventually we did a little bit beautification on the html page --- somehow CSS does not work as intended, we simply change some font and color of the output to make it a bit neater.
== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

ECE497 Project: Node.js Weather Station

2012-02-19T06:32:01Z

Ziyi Zhang:

[[Category:ECE497]]

Team members: [[user:Caogecym | Yuming Cao]], [[user:Ziyi Zhang | Ziyi Zhang]]

== Executive Summary ==

Our project aims to implement the emerging nodejs technique (the server side javascript) as a lightweight web server on the beagleboard and accomplish a series of remote monitoring and control of hardware pins like gpio/led/i2c on the beagleboard. We also tried to make our web server send automatic email when temperature goes too high. There are a lot of things we can do on the nodejs web server, but we try to make it related to our beagleboard hardware interface.

The automatic email sender is not working correctly. More work needs to be done to set a proper configuration to the SMTP server 'postfix'.

End with a two sentence conclusion.

The sentence count is approximate and only to give an idea of the expected length.

== Installation Instructions ==
1. Here's our [https://github.com/ github] path that includes everything useful to our project: [https://github.com/caoy1/Project https://github.com/caoy1/Project].

2. Additional packages installed via '''opkg''':

* install nodejs
<pre>
opkg update
opkg install nodejs
opkg install nodejs-dev
</pre>

* install node package manager
<pre>
curl http://npmjs.org/install.sh | sh
</pre>

* install socket.io module
<pre>
npm install socket.io
</pre>

* install binary module
<pre>
npm install binary
</pre>

* install mailer module
<pre>
npm install mailer
</pre>

* install SMTP server postfix
Go to [http://postfix.energybeam.com/source/index.html] download the source of postfix, then unzip the .gz file, then run 'make', then run
<pre>
sh postfix-install
</pre>

* Here's the guideline to install Cloud9 easily: [https://github.com/jadonk/cloud9/blob/master/README.md]

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

== Highlights ==

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

Consider including 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.

To build a web server, we need, in essence, both client side and server side scripts. Client side scripts mainly just involve ordinary javascripts that can be embedded in HTML file; while at the server-side, we adopt the emerging node.js, which is a really simple server side script that accomplishes equivalent tasks like ASP, PHP will do, but with even simpler implementation details.
== Work Breakdown ==
1. We've already successfully using JavaScript read and write data to the linux gpio file.
<pre>
fs.writeFileSync("/sys/class/leds/beagleboard::usr0/trigger", "heartbeat");
</pre>

<pre>
fs.writeFileSync("/sys/class/gpio/export", ""+5);
</pre>

2. Even though we can access to the gpio in the above way, we still need to find someway to access the I2C information. In the I2C exercises, from the C code provided in exercise 5, we can think of the following two options:

a) To translate tons of the C codes into JavaScript...including rewriting the union structures like i2c_smbus_write_byte() and i2c_smbus_read_byte(), which requires far more knowledge in understanding how to translate the underlying hardware detail into upper-level script languages...

b) Try to run the ./myi2c excutable file directly inside nodjs script...

* It seems that the second way is easier... We've already found a ActiveXObject.run method... We're working on this... turns out this does not work for some reason.

* At last we successfully excute the ./myi2c file inside our javascript using the following code, the big idea is create another child process to handle it:

<pre>
var exec = require('child_process').exec,
child;
child = exec('./myi2c',
function (error, stdout, stderr) {
console.log('stdout:', stdout);
console.log('stderr:', stderr);
if (error !== null) {
console.log('exec error:', error);
}
});
</pre>

And the terminal will show the temperature.

3. Now we are going to working on how to show this temperature information on the website so that we can visit it from any place!!!

* I've successfully done it!!! The pics are already uploaded to the github. Check the following code:
<pre>
var fs = require("fs");
var http = require("http");

try {
http.createServer(function(request, response) {

response.writeHead(200, {"Content-Type": "text/plain"});
var exec = require('child_process').exec, child;
child = exec('./myi2c',
function (error, stdout, stderr) {
response.write(stdout);
console.log('stdout:', stdout);
console.log('stderr:', stderr);
response.end();
if(error != null) {
console.log('exec error:', error);
}
}
);
}).listen(8888);
} catch(ex3) {
console.log("sb");
}
</pre>

4. The next thing we will do is to refresh the website every other time...

* We are now able to load html file inside nodejs scripts so that we can put normal HTML stuff inside the web page and load it from server scripts. The following code snippet can accomplish this (borrowed and modified based on Jadon's code):
<pre>
function loadHTMLFile(uri, res, temp) {
var filename = path.join(process.cwd(), uri);
path.exists(
filename,
function(exists) {
if(!exists) {
res.writeHead(404, {"Content-Type": "text/plain"});
res.write("404 Not Found\n");
res.end();
return;
}

fs.readFile(
filename,
encoding='utf8',
function(err, file) {
if(err) {
res.writeHead(500, {"Content-Type": "text/plain"});
res.write(err + "\n");
res.end();
return;
}
res.writeHead(200, {"Content-Type": "text/html"});
var str = ("" + file).replace("", temp);
res.write(str);
res.end();
}
);
}
);
}
</pre>
And outside the above function, the main routine, we have similar code as listed in 3, but insert the function call:
<pre>
child = exec('./myi2c',
function (error, stdout, stderr) {
console.log('stdout:', stdout);
console.log('stderr:', stderr);
loadHTMLFile('/index.html', response, stdout);
if(error != null) {
console.log('exec error:', error);
}
}
);
</pre>
* Now we can update the temperature information on the website, both triggered by a button on the page, and by just automatically refreshing the temperature value whenever the temperature changes. Here is the simple client script for accomplishing this:
<pre>
<html>
<head>
<script language="javascript">
setInterval("document.forms[0].submit()",5000);
</script>
</head>
<body>
<center>
<h1>Welcome to the world of Node.js</h1>

<p>Here is the demo of the weather station.</p>
<h2>Current temperature:</h2>
<pre>
<span id="temperature output"></span>
<form action = "/test.js" method="post">
<input type="submit" value="get temperature">
</form>
</center>
</body>
</html>
</pre>

5. Now we are trying to do something fancy! We want to send the user an automatic warning email when the temperature is too high. Here's the Javascript code using node.js mailer module. This code use SMTP server to send email to the destination.

<pre>
var email = require('mailer');

email.SMTP = {
host: 'smtp.gmail.com',
port: 587,
ssl: false,
use_authentication: false,
}

email.send({
to : "caoy1@rose-hulman.edu",
from : "obama@whitehouse.gov",
subject : "I love beagleboard!",
body: "Hello beagle world.",
},

function(err, result) {
if(err) {
console.log(err);
}
});
</pre>

* However, the configuration on our beagle has some problem. The server has no response to mailer's request. We've tried telnet localhost 587, and connection can be connected. This means the 587 port is already opened. Then I tried the same code under my ubuntu system, it turns out everything works fine, the caoy1@rose-hulman.edu can receive the e-mail, except some client-side warning error when running the mail.js file. I think the reason it works on ubuntu is because when installing postfix, there's an automatic configuration step, which doesn't exist on our beagle installation. So there must be some problem with the postfix configuration of beagleboard. I've tried to copy all the configuration files under /etc/postfix to our beagleboard, but there's just the same problem. If I have more time, or someone else who's interested in continuing this project, I suggest you have some research on the configuration thing. Everytime you make some config changes, just run
<pre>
postfix reload
</pre>
to apply the change.

5. Our next goal is to toggle LED via web page, whose control flow structure is essentially similar to the i2c communications, plus, we have already learned the way to write to the led pin via nodejs script(see note1 above).
* Before actually doing that, let's first organize our code in a more hierarchical and reasonable way.Thanks to Mr. Manuel Kiessling's excellent introductory tutorial "[http://www.nodebeginner.org The Node Beginner Book]", which gives a pretty decent explanation on how a formal web server architecture should be constructed using nodejs. Basically, we should maintain an index.js that starts all of our code, have a server.js to actually create the server and listen on the port for any posts from the client side, and pass the request and response to the router.js to handle different requests. In requestHandlers.js, each function then does the real work based on the request information and execute corresponding server responses.
* The following is what's in index.js:
<pre>
var server = require("./server");
var router = require("./router");
var requestHandlers = require("./requestHandlers");

var handle = {}
handle["/"] = requestHandlers.i2c;
handle["/led"] = requestHandlers.led;
handle["/i2c"] = requestHandlers.i2c;

server.start(router.route, handle);
</pre>
* And we abstract the server.js to be a general form so it is independent of what will actually be done at the server, such details is left for requestHandlers.js to accomplish:
<pre>
var http = require("http");
var url = require("url");
var sys = require('sys');
var fs = require('fs');
var path = require('path');
var events = require('events');

function start(route, handle) {
function onRequest(request, response){
var pathname = url.parse(request.url).pathname;
route(handle, pathname, response, request);
}

http.createServer(onRequest).listen(3001);
console.log("Server has started.");
}

exports.start = start;
</pre>
* router.js gets the request's pathname and call different functions according to different request url:
<pre>
function route(handle, pathname, response, request) {
console.log("About to route a request for " + pathname);
if (typeof handle[pathname] === 'function') {
handle[pathname](response, request);
} else {
console.log("No request handler found for " + pathname);
response.writeHead(404, {"Content-Type": "text/plain"});
response.write("404 Not found");
response.end();
}
}

exports.route = route;
</pre>
* In requestHandlers.js, we need two functions, one for handle i2c request, another for led toggling request:
<pre>
function i2c(response, request) {
var uri = url.parse(request.url).pathname;
...//same as described above, including calling loadHTMLFile function that's also in requestHandlers.js
}

function led(response, request) {
...//details in below
}
</pre>

6. Now it's time for us to think about how to toggle LED via web page. Turns out it's very similar to how i2c works. However, this time we need to not only parse the uri of the request, but also get the posted data from the request, parse them and write them into the appropriate file system. The event-driven nodejs utilizes "addListener" function to achieve the task, with parameter "data" to receive the data and "end" to handle and process them. The data received(in type of string) should be converted to object class by the "querystring" module.
On the client side, we use exclusive radio button to allow user to choose the toggle mode of LED:
<pre>
<form action = "/led" method="post" size="30">
<input type="radio" name="mode" value="nand-disk" >nand-disk
<input type="radio" name="mode" value="mmc0" />mmc0
<input type="radio" name="mode" value="heartbeat" >heartbeat
<input type="radio" name="mode" value="none" >none
<input type="submit" value="Select" onclick="xmlhttpPost()">
</form>
</pre>
The corresponding javascript just submits this form to /led, which then be handled by router to execute led() function:
<pre>
function xmlhttpPost() {
documents.forms[1].submit();
}
</pre>
The following is the server side function code in requestHandlers.js:
<pre>
var qs = require('querystring');
var url = require('url');
var sys = require('sys');
var fs = require('fs');
var path = require('path');
function led(response, request) {
var postData = "";
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " received.");

request.setEncoding("utf8");

request.addListener("data", function(postDataChunk) {
postData += postDataChunk;
console.log("Received POST data chunk '"+
postDataChunk + "'.");
});

request.addListener("end", function() {
var ledtype = qs.parse(postData);
console.log(ledtype.mode);
fs.writeFileSync("/sys/class/leds/beagleboard::usr0/trigger", ledtype.mode);
});
}
</pre>
Another thing to notice is, in order for this requestHandler for led.js not to jump to a brand new web page but stay on the current one, the normal "request.end()" code, which indicates the completion of an intact .js page, should be left out.
== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

ECE497 Project: Node.js Weather Station

2012-02-19T06:20:16Z

Ziyi Zhang:

[[Category:ECE497]]

Team members: [[user:Caogecym | Yuming Cao]], [[user:Ziyi Zhang | Ziyi Zhang]]

== Executive Summary ==

Our project aims to implement the emerging nodejs technique (the server side javascript) as a lightweight web server on the beagleboard and accomplish a series of remote monitoring and control of hardware pins like gpio/led/i2c on the beagleboard. We also tried to make our web server send automatic email when temperature goes too high. There are a lot of things we can do on the nodejs web server, but we try to make it related to our beagleboard hardware interface.

The automatic email sender is not working correctly. More work needs to be done to set a proper configuration to the SMTP server 'postfix'.

End with a two sentence conclusion.

The sentence count is approximate and only to give an idea of the expected length.

== Installation Instructions ==
1. Here's our [https://github.com/ github] path that includes everything useful to our project: [https://github.com/caoy1/Project https://github.com/caoy1/Project].

2. Additional packages installed via '''opkg''':

* install nodejs
<pre>
opkg update
opkg install nodejs
opkg install nodejs-dev
</pre>

* install node package manager
<pre>
curl http://npmjs.org/install.sh | sh
</pre>

* install socket.io module
<pre>
npm install socket.io
</pre>

* install binary module
<pre>
npm install binary
</pre>

* install mailer module
<pre>
npm install mailer
</pre>

* install SMTP server postfix
Go to [http://postfix.energybeam.com/source/index.html] download the source of postfix, then unzip the .gz file, then run 'make', then run
<pre>
sh postfix-install
</pre>

* Here's the guideline to install Cloud9 easily: [https://github.com/jadonk/cloud9/blob/master/README.md]

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

== Highlights ==

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

Consider including 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.

To build a web server, we need, in essence, both client side and server side scripts. Client side scripts mainly just involve ordinary javascripts that can be embedded in HTML file; while at the server-side, we adopt the emerging node.js, which is a really simple server side script that accomplishes equivalent tasks like ASP, PHP will do, but with even simpler implementation details.
== Work Breakdown ==
1. We've already successfully using JavaScript read and write data to the linux gpio file.
<pre>
fs.writeFileSync("/sys/class/leds/beagleboard::usr0/trigger", "heartbeat");
</pre>

<pre>
fs.writeFileSync("/sys/class/gpio/export", ""+5);
</pre>

2. Even though we can access to the gpio in the above way, we still need to find someway to access the I2C information. In the I2C exercises, from the C code provided in exercise 5, we can think of the following two options:

a) To translate tons of the C codes into JavaScript...including rewriting the union structures like i2c_smbus_write_byte() and i2c_smbus_read_byte(), which requires far more knowledge in understanding how to translate the underlying hardware detail into upper-level script languages...

b) Try to run the ./myi2c excutable file directly inside nodjs script...

* It seems that the second way is easier... We've already found a ActiveXObject.run method... We're working on this... turns out this does not work for some reason.

* At last we successfully excute the ./myi2c file inside our javascript using the following code, the big idea is create another child process to handle it:

<pre>
var exec = require('child_process').exec,
child;
child = exec('./myi2c',
function (error, stdout, stderr) {
console.log('stdout:', stdout);
console.log('stderr:', stderr);
if (error !== null) {
console.log('exec error:', error);
}
});
</pre>

And the terminal will show the temperature.

3. Now we are going to working on how to show this temperature information on the website so that we can visit it from any place!!!

* I've successfully done it!!! The pics are already uploaded to the github. Check the following code:
<pre>
var fs = require("fs");
var http = require("http");

try {
http.createServer(function(request, response) {

response.writeHead(200, {"Content-Type": "text/plain"});
var exec = require('child_process').exec, child;
child = exec('./myi2c',
function (error, stdout, stderr) {
response.write(stdout);
console.log('stdout:', stdout);
console.log('stderr:', stderr);
response.end();
if(error != null) {
console.log('exec error:', error);
}
}
);
}).listen(8888);
} catch(ex3) {
console.log("sb");
}
</pre>

4. The next thing we will do is to refresh the website every other time...

* We are now able to load html file inside nodejs scripts so that we can put normal HTML stuff inside the web page and load it from server scripts. The following code snippet can accomplish this (borrowed and modified based on Jadon's code):
<pre>
function loadHTMLFile(uri, res, temp) {
var filename = path.join(process.cwd(), uri);
path.exists(
filename,
function(exists) {
if(!exists) {
res.writeHead(404, {"Content-Type": "text/plain"});
res.write("404 Not Found\n");
res.end();
return;
}

fs.readFile(
filename,
encoding='utf8',
function(err, file) {
if(err) {
res.writeHead(500, {"Content-Type": "text/plain"});
res.write(err + "\n");
res.end();
return;
}
res.writeHead(200, {"Content-Type": "text/html"});
var str = ("" + file).replace("", temp);
res.write(str);
res.end();
}
);
}
);
}
</pre>
And outside the above function, the main routine, we have similar code as listed in 3, but insert the function call:
<pre>
child = exec('./myi2c',
function (error, stdout, stderr) {
console.log('stdout:', stdout);
console.log('stderr:', stderr);
loadHTMLFile('/index.html', response, stdout);
if(error != null) {
console.log('exec error:', error);
}
}
);
</pre>
* Now we can update the temperature information on the website, both triggered by a button on the page, and by just automatically refreshing the temperature value whenever the temperature changes. Here is the simple client script for accomplishing this:
<pre>
<html>
<head>
<script language="javascript">
setInterval("document.forms[0].submit()",5000);
</script>
</head>
<body>
<center>
<h1>Welcome to the world of Node.js</h1>

<p>Here is the demo of the weather station.</p>
<h2>Current temperature:</h2>
<pre>
<span id="temperature output"></span>
<form action = "/test.js" method="post">
<input type="submit" value="get temperature">
</form>
</center>
</body>
</html>
</pre>

5. Now we are trying to do something fancy! We want to send the user an automatic warning email when the temperature is too high. Here's the Javascript code using node.js mailer module. This code use SMTP server to send email to the destination.

<pre>
var email = require('mailer');

email.SMTP = {
host: 'smtp.gmail.com',
port: 587,
ssl: false,
use_authentication: false,
}

email.send({
to : "caoy1@rose-hulman.edu",
from : "obama@whitehouse.gov",
subject : "I love beagleboard!",
body: "Hello beagle world.",
},

function(err, result) {
if(err) {
console.log(err);
}
});
</pre>

* However, the configuration on our beagle has some problem. The server has no response to mailer's request. We've tried telnet localhost 587, and connection can be connected. This means the 587 port is already opened. Then I tried the same code under my ubuntu system, it turns out everything works fine, the caoy1@rose-hulman.edu can receive the e-mail, except some client-side warning error when running the mail.js file. I think the reason it works on ubuntu is because when installing postfix, there's an automatic configuration step, which doesn't exist on our beagle installation. So there must be some problem with the postfix configuration of beagleboard. I've tried to copy all the configuration files under /etc/postfix to our beagleboard, but there's just the same problem. If I have more time, or someone else who's interested in continuing this project, I suggest you have some research on the configuration thing. Everytime you make some config changes, just run
<pre>
postfix reload
</pre>
to apply the change.

5. Our next goal is to toggle LED via web page, whose control flow structure is essentially similar to the i2c communications, plus, we have already learned the way to write to the led pin via nodejs script(see note1 above).
* Before actually doing that, let's first organize our code in a more hierarchical and reasonable way.Thanks to Mr. Manuel Kiessling's excellent introductory tutorial "[http://www.nodebeginner.org The Node Beginner Book]", which gives a pretty decent explanation on how a formal web server architecture should be constructed using nodejs. Basically, we should maintain an index.js that starts all of our code, have a server.js to actually create the server and listen on the port for any posts from the client side, and pass the request and response to the router.js to handle different requests. In requestHandlers.js, each function then does the real work based on the request information and execute corresponding server responses.
* The following is what's in index.js:
<pre>
var server = require("./server");
var router = require("./router");
var requestHandlers = require("./requestHandlers");

var handle = {}
handle["/"] = requestHandlers.i2c;
handle["/led"] = requestHandlers.led;
handle["/i2c"] = requestHandlers.i2c;

server.start(router.route, handle);
</pre>
* And we abstract the server.js to be a general form so it is independent of what will actually be done at the server, such details is left for requestHandlers.js to accomplish:
<pre>
var http = require("http");
var url = require("url");
var sys = require('sys');
var fs = require('fs');
var path = require('path');
var events = require('events');

function start(route, handle) {
function onRequest(request, response){
var pathname = url.parse(request.url).pathname;
route(handle, pathname, response, request);
}

http.createServer(onRequest).listen(3001);
console.log("Server has started.");
}

exports.start = start;
</pre>
* router.js gets the request's pathname and call different functions according to different request url:
<pre>
function route(handle, pathname, response, request) {
console.log("About to route a request for " + pathname);
if (typeof handle[pathname] === 'function') {
handle[pathname](response, request);
} else {
console.log("No request handler found for " + pathname);
response.writeHead(404, {"Content-Type": "text/plain"});
response.write("404 Not found");
response.end();
}
}

exports.route = route;
</pre>
* In requestHandlers.js, we need two functions, one for handle i2c request, another for led toggling request:
<pre>
var qs = require('querystring');
var url = require('url');
var sys = require('sys');
var fs = require('fs');
var path = require('path');

function i2c(response, request) {
var uri = url.parse(request.url).pathname;
...//same as described above, including calling loadHTMLFile function that's also in requestHandlers.js
}

function led(response, request) {
...//details in below
}
</pre>

6. Now it's time for us to think about how to toggle LED via web page.
== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

ECE497 Project: Node.js Weather Station

2012-02-19T05:26:23Z

Ziyi Zhang:

ECE497 Project: Node.js Weather Station

2012-02-17T22:25:44Z

Ziyi Zhang:

ECE497 Project: Node.js Weather Station

2012-02-17T22:19:37Z

Ziyi Zhang:

ECE497 Project: Node.js Weather Station

2012-02-17T22:18:52Z

Ziyi Zhang:

ECE497 Project: Node.js Weather Station

2012-02-17T22:09:50Z

Ziyi Zhang:

ECE497 Project: Node.js Weather Station

2012-02-17T22:00:08Z

Ziyi Zhang:

ECE497 Project: Node.js Weather Station

2012-02-13T17:34:17Z

Ziyi Zhang:

ECE497 Project: Node.js Weather Station

2012-02-12T02:39:31Z

Ziyi Zhang:

[[Category:ECE497]]

Team members: [[user:Caogecym | Yuming Cao]], [[user:Ziyi Zhang | Ziyi Zhang]]

== Executive Summary ==

Give two sentence intro to the project.

Give two sentences telling what works.

Give two sentences telling what isn't working.

End with a two sentence conclusion.

The sentence count is approximate and only to give an idea of the expected length.

== Installation Instructions ==

Give step by step instructions on how to install your project on the SPEd2 image.

* Include your [https://github.com/ github] path as a link like this: [https://github.com/caoy1/Project https://github.com/caoy1/Project].
* Include any additional packages installed via '''opkg'''.

0. install nodejs
<pre>
opkg update
opkg install nodejs
opkg install nodejs-dev
</pre>

1. install node package manager
<pre>
curl http://npmjs.org/install.sh | sh
</pre>

2. install socket.io module
<pre>
npm install socket.io
</pre>

3. install binary module
<pre>
npm install binary
</pre>

* Include kernel mods.
* If there is extra hardware needed, include links to where it can be obtained.
* Here's the guideline to install Cloud9 easily: [https://github.com/jadonk/cloud9/blob/master/README.md]
== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

== Highlights ==

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

Consider including 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.
* Here's the code of how node.js will interact with beagleboard hardware
<pre>
var myStream = fs.createReadStream(
'/dev/input/event2',
{
'bufferSize': 16
}
);
myStream.addListener('data', myListener);
myStream.addListener('error', function(error) {
sys.puts("Read error: " + error);
});
</pre>

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.
*Even though we can access to the gpio in the above way, we still need to find someway to access to the I2C information. In the I2C exercises, we just use the I2C tool, which is not enough for our project...

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

EBC Exercise 22 Cross-Compiling

2012-01-20T01:06:10Z

Ziyi Zhang:

[[Category:ECE497]]
[[Category: BeagleBoard]]

This class is about developing software for embedded Linux. So far we have been doing all of our development on the Beagle. This works well for small (and not so small) programs. However, we are now moving into kernel development and that's best done on a more powerful host computer. [[EBC_Exercise_01_Using_bitbake_for_Kernel_and_U-boot | Here]] you learned how to download and install the cross-compilers and the source for kernel and u-boot. Now we'll use those tools.

First we'll check everything by compiling the Hello World program, then we'll try the kernel and u-boot.

== Cross-compiling Hello World ==

Listing 2-4 on page 29 of the text is an embedded version of Hello World. If you've set up your git repository you will find it in '''helloWorld.c''' when you do a''' git pull'''. Compile and run it on your host to be sure it works.

host$ '''gcc helloWorld.c'''
host$ '''./a.out'''
Hello, World! Main is executing at 0x400524
This address (0x7fff8260bdf8) is in our stack frame
This address (0x601038) is in our bss section
This address (0x601020) is in our data section

Now that you know it's working, let's cross compile it. First set the paths to find the cross-compilers. Put the following in a file, call it ~/.oe/'''crossCompileEnv.sh'''. Make sure the path is correct for your system. This is for a 32-bit linux.

# add cross tools to your path
export ARM_TOOLCHAIN_PATH=~/BeagleBoard/oe/build/tmp-angstrom_2010_x-eglibc/sysroots/i686-linux/usr/bin/armv7a-angstrom-linux-gnueabi
PATH=$PATH:$ARM_TOOLCHAIN_PATH/..
PATH=$ARM_TOOLCHAIN_PATH:$PATH
export ARCH=arm
export CROSS_COMPILE=arm-angstrom-linux-gnueabi-

Here it is for 64-bit

# add cross tools to your path
export ARM_TOOLCHAIN_PATH=~/BeagleBoard/oe/build/tmp-angstrom_2010_x-eglibc/sysroots/x86_64-linux/usr/bin/armv7a-angstrom-linux-gnueabi
PATH=$PATH:$ARM_TOOLCHAIN_PATH/..
PATH=$ARM_TOOLCHAIN_PATH:$PATH
export ARCH=arm
export CROSS_COMPILE=arm-angstrom-linux-gnueabi-

Now ''source'' the file and compile again. (Note: you only have to source once per terminal session.)
host$ '''source ~/.oe/crossCompileEnv.sh'''
host$ '''${CROSS_COMPILE}gcc helloWorld.c'''
host$ '''file a.out'''
a.out: ELF 32-bit LSB executable, ARM, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.16, not stripped

The '''file''' command tells what's in the file. In this case we have an ARM executable. Success! Now copy to your Beagle and run

host$ '''scp a.out root@beagle:.'''
host$ '''ssh root@beagle ./a.out'''
Hello, World! Main is executing at 0x8374
This address (0xbeb32d4c) is in our stack frame
This address (0x10650) is in our bss section
This address (0x10648) is in our data section

The '''scp''' copies a.out to the beagle and the '''ssh''' runs the a.out on the beagle. Notice the address are very different from the host version.

== Finding the Kernel and Installing It ==

After doing [[EBC_Exercise_01_Using_bitbake_for_Kernel_and_U-boot#Finding_the_Correct_Kernel | this]] exercise you have a Beagle kernel on your host computer. Let's see if it works.

Once compiled the kernel is put in a file called '''uImage'''. You may have seen it in the FAT partition on your SD card. Let's find it on your host. One way to find it is

host$ '''cd ~/BeagleBoard/oe'''
host$ '''find . -name "*uImage*" | grep 2.6.32 | grep boot'''

We are looking for uImage, but we only want the 2.6.32 version. The last grep file the file in the '''boot''' directory. Several lines are printed, but the one I'm interested in is:
''./build/tmp-angstrom_2010_x-eglibc/work/beagleboard-angstrom-linux-gnueabi/linux-omap-psp-2.6.32-r110b+gitr5fc29e7b2a76a64a739f857858ef0b98294aa155/git''/arch/arm/boot/uImage

The first part of the path (in italics) is the path to the kernel. Check it out.

host$ '''cd build/tmp-angstrom_2010_x-eglibc/work/beagleboard-angstrom-linux-gnueabi/linux-omap-psp-2.6.32-r110b+gitr5fc29e7b2a76a64a739f857858ef0b98294aa155/git'''
host$ '''ls -F'''
arch/ drivers/ Kbuild modules.order samples/ usr/
block/ firmware/ kernel/ Module.symvers scripts/ virt/
COPYING fs/ lib/ net/ security/ vmlinux*
CREDITS include/ MAINTAINERS patches/ sound/ vmlinux.o
crypto/ init/ Makefile README System.map
Documentation/ ipc/ mm/ REPORTING-BUGS tools/

We'll be learning what's in many of these over the next couple of weeks. Remember this location. Let's find uImage.

host$ '''cd arch/arm/boot; ls -shF'''
total 13M
4.0K bootp/ 6.3M Image* 4.0K Makefile 3.0M zImage*
4.0K compressed/ 4.0K install.sh 3.0M uImage
host$ '''ls -l uImage'''
-rw-r--r-- 1 beagle beagle 3144300 2011-12-08 01:02 uImage

It should have the date that you did the bitbake. Let's see if it runs on the Beagle
host$ '''scp uImage root@beagle:.'''
host$ '''ssh root@beagle'''
beagle$ '''cd /boot; ls -F'''
total 18M
4.0K MLO@
372K Module.symvers-2.6.32
1.4M System.map-2.6.32
80K config-2.6.32
4.0K u-boot.bin@
0 uImage@
3.1M uImage-2.6.32
8.9M vmlinux-2.6.32
beagle$ '''ls -l uImage'''
lrwxrwxrwx 1 www-data www-data 13 May 12 2011 uImage -> uImage-2.6.32

So the uImage that is there is a symbolic link to '''uImage-2.6.32'''. Let's save the working uImage in a difference file and copy our new uImage in.

beagle$ '''mv uImage-2.6.32 uImage-2.6.32.orig'''
beagle$ '''mv ~/uImage uImage-2.6.32'''

And then reboot.
beagle$ '''shutdown -r now'''

After a couple of minutes your should be back and running again. Check and see if you are really running the new kernel.
beagle$ '''uname -a'''
Linux beagleboard 2.6.32 #3 PREEMPT Thu Dec 8 01:02:13 EST 2011 armv7l GNU/Linux

It worked! That's the date I compiled mine on.

== Installing a New U-boot ==

While we're at it, let's install a new U-boot. Note: The new U-boot isn't working for me.

host$ '''cd ~/BeagleBoard/oe/build/tmp-angstrom_2010_x-eglibc/work/beagleboard-angstrom-linux-gnueabi/'''
host$ '''ls -F'''
linux-3.0.9-r110a/
linux-omap-psp-2.6.32-r110b+gitr5fc29e7b2a76a64a739f857858ef0b98294aa155/
shadow-4.1.4.3-r5/
u-boot-2011.09-r4/

There's the U-boot directory.

host$ cd u-boot-2011.09-r4/git/; ls -F
api/ COPYING fs/ mkconfig* post/ tools/
arch/ CREDITS include/ mmc_spl/ README u-boot*
board/ disk/ lib/ nand_spl/ rules.mk '''u-boot.bin'''
boards.cfg doc/ MAINTAINERS net/ snapshot.commit u-boot.lds
common/ drivers/ MAKEALL* onenand_ipl/ spl/ u-boot.map
config.mk examples/ Makefile patches/ System.map u-boot.srec

The file we want is right on the top level.

host$ '''scp u-boot.bin root@beagle:.'''
host$ '''ssh -X root@beagle'''
beagle$ '''cd /media/mmcblk0p1/; ls -F'''
MLO* u-boot.bin.broken* uEnv.txt*
U-BOOT.BIN* UIMAGE* uEnv/

Here we've changed to the FAT partition which is where u-boot lives. Back it up and install the new one.

beagle$ '''mv U-BOOT-BIN u-boot-bin.orig'''
beagle$ '''mv ~/.u-boot-bin .'''
beagle$ '''shutdown -r now'''

You should now see the new u-boot running. However I was unable to get the 2.6.32 kernel to boot.

== Compile via make ==

When you use bitbake it sets up all the paths to use the correct cross compilers. You can also build the kernel or u-boot by using '''make''' if you set the paths like we did above.

If you haven't already, ''source'' the file and ''cd'' to the kernel directory and try a ''make''.

host$ '''source ~/.oe/crossCompileEnv.sh'''
host$ '''cd ~/BeagleBoard/oe/build/tmp-angstrom_2010_x-eglibc/work/beagleboard-angstrom-linux-gnueabi/linux-omap-psp-2.6.32-r110b+gitr5fc29e7b2a76a64a739f857858ef0b98294aa155/git'''
host$ '''make xconfig'''

([[EBC Exercise 13 Configuring the Kernel]] has details on configuring the kernel.)

To make the kernel run

host$ '''make uImage'''

Now, follow the instructions above to install your freshly compiled kernel.

ECE497 Project Ideas

2011-12-06T22:01:09Z

Ziyi Zhang: /* Mini Project Ideas */

[[Category:ECE497]]
[[Category:BeagleBoard]]

We have both mini projects and projects in ECE497.

'''Mini projects''' involved finding something interested in the Beagle world and installing it to your beagle and demoing it to the class. You would also create a wiki page documenting what you did to get it installed. Often you may find multiple efforts do to something, for example there are a few efforts to port Android on the Beagle. Your task is to figure out which one should be used. Generally mini projects won't require you to write new code; however they are the background work that may lead to a full project. You should do a couple mini projects for the class. Generally they are done alone, but working in pairs is OK. These will be about 1/3 of your grade and should be done in the first 5 weeks or so.

Only one '''full project''' is done for the class and it's done with a team of 3 or 4. These projects can take a mini project (or a whole new idea) and add to it. The goal is to have your work contribute to the open source world. Any code is generated will be kept on [https://github.com/ github] and a [http://bitbake.berlios.de/manual/ bitbake receipt] will be created to automatically download and create the object files.

What follows are

; Places to look for project ideas: Feel free to add your own suggestions.
; Mini Project ideas: Add your own suggestions, and do some of them. Mark the ones you've done.
; Full Project ideas: ditto.

== Sources for Project Ideas ==

Here are some links where you'll find ideas for your project.
* [http://wiki.omap.com/index.php/ETechDays_Community_Lightning_Talks ETechDays Community Lightning Talks], this is a one-day web-based conference where many project ideas are presented. One of our 2009-2010 senior design projects was found here.
* [http://beagleboard.org/project Official list of Beagle Projects], there are many Beagle specific projects listed here. Many are inactive. ''List your project here once it running.''
* [http://www.youtube.com/watch?v=Mk1xjbA-ISE Augmented Reality Project], here's an idea that I think we can do on the Beagle. Rather than using augmented reality glasses, I'd suggest we use a [http://focus.ti.com/dlpdmd/docs/dlpdiscovery.tsp?sectionId=60&tabId=2235 TI DLP pico projector]. [http://www.hitlabnz.org/wiki/EmbeddedAR Here's] AR running on the Beagle.
* [http://code.google.com/p/0xdroid/ Android], this is one of a couple of efforts to port [http://source.android.com/ Google's Android OS] to the Beagle.
* [[BeagleBoard/Ideas-2009]] Google summer code ideas 2009.

== Mini Project Ideas ==

{| border="1" cellspacing="0" cellpadding="5"
! Suggestor
! Implementor
! Description
! Link
|-
| Mark A. Yoder
|
| Work up an example of controlling the PWM registers from the shell.
| [http://esdw.wordpress.com/2010/03/25/a-useful-tool-devmem2/ PWM via the shell]
|-
| Mark A. Yoder
|
| Weather Station
| [http://dominion.thruhere.net/koen/cms/using-the-beaglebone-as-a-weatherstation Ultrasonic weather]
|-
| Mark A. Yoder
|
| Interface the BeagleBoard with an SRF08 Ultrasonic Ranger over I2C
| [http://yetanotherhackersblog.wordpress.com/2011/04/07/interfacing-the-beagleboard-with-an-srf08-ultrasonic-ranger-over-i2c Ultrasonic Ranger]
|-
| Mark A. Yoder
|
| Compile the PowerVR examples
| [http://www.imgtec.com/powervr/insider/sdkdownloads/index.asp PowerVR Insider SDK Downloads]
|-
| Mark A. Yoder
|
| Work up some GStreamer PS EYE Demos
| [http://www.electronsonradio.com/2011/06/playstation-eye-gstreamer-examples GStreamer PS EYE Demos] and [http://www.ridgerun.com/blog/?p=224 RidgeRun]
|-
| Mark A. Yoder
| Douglas Selby
| Get TI' embedded speech recognizer installed and demo the examples.
| [https://gforge.ti.com/gf/project/tiesr TI Embedded Speech Recognizer]
|-
| Mark A. Yoder
|
| Demo last year's TI speech project. I have a microphone amplifier and mike you can use.
| [[ECE597 Project pyWikiReader]]
|-
| Mark A. Yoder
| Stephen Mayhew
| Find who is doing what with Kinect on the Beagle and install and run it.
| [http://www.google.com/webhp?rlz=1C1GPCK_enUS392US392&sourceid=chrome-instant&ie=UTF-8&ion=1#hl=en&sugexp=ldymls&xhr=t&q=beagleboard+kinect&cp=0&qe=YmVhZ2xlYm9hcmQga2lu&qesig=9qrD0rFfjWfujRRGmkB_Bw&pkc=AFgZ2tn-cylx0f71PasgBKOazjBQY3VK712RWQ7DueEjQNAdbOHr6BCgUd9xdyXyPe8TWErkesrQ246vygwImnAS5mIzCG2-5g&pf=p&sclient=psy&rlz=1C1GPCK_enUS392US392&site=webhp&source=hp&aq=0&aqi=&aql=&oq=beagleboard+kin&pbx=1&bav=on.2,or.&fp=3e817b7ec5d13467&ion=1 Google - beagleboard kinect]
|-
| Mark A. Yoder
|
| I have several [http://en.wikipedia.org/wiki/PlayStation_Eye Sony PlayStation Eye web cams] and I have examples of how to pull video from them via V4L2 ([[ECE497 DaVinci Workshop Labs]]). The Eye also has a 4 microphone array. I don't know how to get audio from it. Figure out how. This may expand to a full project if there is no solution out there.
| [http://www.google.com/webhp?rlz=1C1GPCK_enUS392US392&sourceid=chrome-instant&ie=UTF-8&ion=1#hl=en&sugexp=ldymls&xhr=t&q=beagleboard+playstation+eye+microphone+array&cp=0&qe=YmVhZ2xlYm9hcmQgcGxheXN0YXRpb24gZXllIG1pY3JvcGhvbmUgYXJyYXk&qesig=Sdh5Ru_jodwYydoeTls1GA&pkc=AFgZ2tmwB41tQwF7XwrJPqFnf0NRO911bMCrbnU1HR9Vm6-Pg0sH8LvbJZsKwjKRUpoin4cZlwLIngZw8OC7dyanjcJCG4N_kg&pf=p&sclient=psy&rlz=1C1GPCK_enUS392US392&site=webhp&aq=f&aqi=&aql=&oq=beagleboard+playstation+eye+microphone+array&pbx=1&bav=on.2,or.&fp=3e817b7ec5d13467&ion=1 Google - beagleboard playstation eye microphone array]
|-
| Mark A. Yoder
|
| Find some examples of how to use '''cmem'''. CMEM is an API and library for managing one or more blocks of physically contiguous memory. It also provides address translation services (e.g. virtual to physical translation) and user-mode cache management APIs. It's used for managing the shared memory between the ARM and the DSP on the processor. I've been unable to find examples of how to use it.
| [http://processors.wiki.ti.com/index.php/CMEM_Overview CMEM Overview]
|-
| Mike Lester
|
| Connect to your beagleboard using ethernet over USB. This allows your beagleboard to share the host computer's internet connection and allow you to connect via VNC/ssh without the need for an external router/switch. This should make development much easier.
| [[BeagleBoardBeginners#Connect_with_your_beagleboard_using_VNC_and_ethernet_over_USB | VNC]]
|-
| Brian Hulette
|
| Experiment with audio synthesis and/or sampling/processing. You could either synthesize and play a few tones to generate a song, or have the Beagle sample an audio signal then process and output it to create a sort of effects pedal.
|
|-
| David McGinnis
| David McGinnis
| Look into connecting the beagleboard to a phone or headphones using bluetooth. This could involve either outputting audio and taking in audio from a bluetooth headset, allowing you to have audio I/O with the beagleboard, or could involve connecting with phones automatically as they come into range of the beagleboard, allowing for an automatic attendence registration system, among other things.
|
|-
| David Bliss
| David Bliss
| Get a video stream from a PS Eye, and identify the relevant device files.
| [http://en.wikipedia.org/wiki/PlayStation_Eye#cite_note-Linux_support-32 PlayStation_Eye#cite_note-Linux_support-32]
|
|-
| William Gerth
| William Gerth
| Explore the possibility of implementing OpenAOS on the Beagle, to make a portable media player and etc.
| http://www.openaos.org/
|-
| Joel Carlson
|
| Lacking a serial port and don't have a USB-serial converter? Why not find a way to make the BeagleBoard boot over a USB console connection?
| [http://itgen.blogspot.com/2011/03/beagleboard-xm-u-boot-without-serial.html BeagleBoard XM U-boot without Serial]
|-
| Joel Carlson
| Joel Carlson
| Depending on what one is working on, it might be useful to mount the BeagleBoard root filesystem over NFS. The link to the right does that using a USB-Ethernet connection, but one that just runs over an Ethernet cable would be nice.
| [http://elinux.org/Mount_BeagleBoard_Root_Filesystem_over_NFS_via_USB Mount BeagleBoard Root Filesystem over NFS via USB]
Here's an example of mounting dfs/afs on the Beagle

[[ECE497 Mounting dfs/afs in Linux]]
|-
| Lei Liu
| Lei Liu
| Build communication with FPGA via USB port.
|
|-
| Aaron Bamberger
| Aaron Bamberger
| Play around with the BeagleBoard's various SPI and I2C ports, and get it to talk to some simple SPI and I2C peripherals, such as a 7-Segment display driver or small LCD panel
|
|-
| Jay Dial
| Jay Dial
| Look into the parallel computing possibilities of the BeagleBoard. See how difficult it would be to get two BeagleBoards to communicate properly for parallel computing.
| [http://antipastohw.blogspot.com/2010/09/how-to-make-beagleboard-elastic-r.html How to make a BeagleBoard Elastic R Beowulf Cluster]
|-
| Randy Billingsley
| Randy Billingsley
| Configure wlan on the beagle board using a wireless usb adapter
|
|-
| Mike Fuson
| Mike Fuson
| Get XBMC working on the beagle.
| [http://elinux.org/BeagleBoard/GSoC/2010_Projects/XBMC XBMC wiki page]
|
|-
| Sam Allen
|
| Port Android to beagle
| It's done. Check out [http://code.google.com/p/rowboat/ this].
|-
| Mark A. Yoder
|
| Change the splash screen to a Rose logo when the Beagle starts up
| [http://blog.bizmobiletech.com/?p=253&utm_source=feedburner&utm_medium=twitter&utm_campaign=Feed%3A+BeagleBoard+%28BeagleBoard.org%29 How to Change Angstrom Boot logo in beagleboard]
|-
| Mark A. Yoder
| Ziyi Zhang
| Do remote debugging with Eclipse. My page needs updating.
| [[ECE497 Installing the Eclipse IDE]]
|-
| Mark A. Yoder
|
| Investigate Eigen. Eigen is a C++ template library for linear algebra: matrices, vectors, numerical solvers, and related algorithms. Explicit vectorization is performed for SSE 2/3/4, ARM NEON, and AltiVec instruction sets, with graceful fallback to non-vectorized code. This means it should run fast on the Beagle. How fast does it run? Has anyone used it on the Beagle?
| [http://eigen.tuxfamily.org/index.php?title=Main_Page eigen.tuxfamily.org]
|-
| Mark A. Yoder
|
| Find what libraries are available for the DSP side of the DM 3730 and write some examples that use them.
| [http://focus.ti.com/docs/toolsw/folders/print/sprc265.html C64x+ DSP Library (DSPLIB)]
[http://focus.ti.com/docs/toolsw/folders/print/sprc092.html DSPLIB]
[http://focus.ti.com/docs/toolsw/folders/print/sprc094.html IMGLIB]
|-
| Mark A. Yoder
|
| Convert the OSS labs to use the new ALSA drivers
| [http://www.alsa-project.org/main/index.php/Tutorials_and_Presentations ALSA Tutorials]
|-
| Mark A. Yoder
|
| Dig into the DSS drivers. The OMAP display subsystem supports rotation and mirroring, but the '''mirror''' and '''rotate''' files in '''/sys/devices/platform/omapdss/display''' ''X'' don't work. Find the code that implements them see if you can figure out what's wrong.
| [http://elinux.org/BeagleBoardFAQ#.22DSS2.22_display_driver_for_.3E.3D_2.6.29 dss2]
|}

== Full Projects ==

=== Winter 2011-2012 ===

{| border="1" cellspacing="0" cellpadding="5"
! Team Members
! Project Title
! Description
|-
| Mark A. Yoder
| [http://e2e.ti.com/blogs_/b/dlp_mems_blog/archive/2011/05/13/3d-structured-light-using-dlp-technology.aspx 3D Structured Light using DLP® Technology]
| Create 3D maps using a DLP pico and the Beagle.
|-
| Mark A. Yoder
| [http://m.matrixsynth.com/2011/06/beagleboard-synth-proof-of-concept.htm Beagle Midi]
| Make the Beagle synthesize midi files.
|-
| Mark A. Yoder
| [http://www.sakoman.com/OMAP/an-overiew-of-omap3-power-management-with-2639-pm.html Beagle Power Management]
| Work up some power management demos.
|}

=== 2011 ===
Edit this page to add projects you would like to do. If you aren't in the class, add ideas you would like to see done by class members.

{| border="1" cellspacing="0" cellpadding="5"
! Team Members
! Project Title
! Description
|-
| Mark A. Yoder
| [https://gforge.ti.com/gf/project/tiesr TI Embedded Speech Recognizer]
| Port TI's fixed-point speech recognizer to the DSP. It currently runs on the ARM.
|-
| Mark A. Yoder
| Kinect
| [http://hackaday.com/2010/11/15/rendering-a-3d-environment-from-kinect-video/ Here] and [http://gamerfront.net/2010/12/with-a-second-kinect-you-can-map-out-your-bedroom-in-3d/4644 here] are some interesting things people are doing with Kinects. Maybe we could port it to the Beagle.
|-
| Mike Lester
| Accelerometer-based auto-leveled projection
| Several projects have been started to add [http://matthsu-abacus.blogspot.com/2009/11/build-3-axis-accelerometer-on.html accelerometer support] to the BeagleBoard. This project would involve getting an accelerometer installed and working, perhaps using a [http://elinux.org/BeagleBoard_Trainer trainer board], as well the [http://focus.ti.com/general/docs/gencontent.tsp?contentId=52770 TI Pico Projector]. The orientation data from the accelerometer would be used to rotate, skew, keystone the projected image in order to keep it level and normalized.
|-
| Aaron Bamberger
| Kinect Based 3d Scanner
| Build some sort of motorized gantry that allows the Kinect to be rotated around (and possibly from top to bottom) of an arbitrary object. The motors would be controlled using the BeagleBoard's I2C or SPI interfaces. Use libfreenect to capture depth information from every side of the object as the Kinect rotates around the object. Use this data and OpenGL to build a 3d model of the scanned object
|-
| Mark A. Yoder
| Port winDSK6 to the Beagle
| [http://www.ece.wisc.edu/~morrow/software/ winDSK6] is a Windows program that talks to a TI 'C6711 DSK and performs many interesting audio effects. This project would implement the code running on the Windows side on the ARM. The ARM could capture a frame of audio and send it to the DSP for processing. The ARM could then send the processed audio to the speakers. [http://processors.wiki.ti.com/index.php/C6Run c6run] would be used to interact with the DSP.
|-
| David Bliss
| Automated Die Tester
| Make a device that can roll a die, and keep statistics on how random the die is. The build can either be very complex, or very simple, depending on how you define "rolling a die". The software doesn't necessarily have to know what the numbers mean, it just has to be able to uniquely identify the sides.
|-
| Stephen Mayhew
| Set-Playing System
| Set is a relatively simple card game that lends itself nicely to image recognition and computer play. The layout is not very structured, and the game play is pretty simple. This project would incorporate image recognition, projection of possible moves (using the pico projector), and maybe even speech synthesis, and recognition. For example, if someone didn't know how to play Set, then the board could take them through a tutorial, asking questions of the user as it went along ("If I have these 2 cards, what 3rd card would make a set?"). This would make for an interesting demo at conferences.
|-
| Michael Fuson
Jay Dial
| Spectrum Analyzer
|Create a real-time audio Spectrum analyzer on the BeagleBoard. [http://elinux.org/ECE497_Project_Spectrum_Analyzer Project Page]
|}

=== 2010 ===

{| border="1" cellspacing="0" cellpadding="5"
! Team Members
! Project Title
! Description
|-
| Yannick Polius
| [[ECE597 Project pyWikiReader | pyWikiReader]]
| This project is mostly software, with the hardware element being the use of the dsp. The idea is to tie together three technologies: speech recognition, speech synthesis, and internet access in order to create an interface capable of orating information to the user based on a vocal command. The implementation I have in mind is to use the Pocket Sphinx speech recognition engine to first understand what the user wants through speech, such as "Rose-Hulman". Once the speech is translated, the software can execute a Wikipedia search to pull said item's page. Most of the important info is contained within the introductory paragraph, so the software will take only that chunk and feed it into the Flite speech synthesis engine. The end result is a simple machine with "mother box" like usability, that is, no interaction besides what is natural to the user (speaking) should be necessary to retrieve the information.
|-
| Paul Morrison <br> Steven Stark
| [[ECE597 3D Chess | 3D Chess with Networking]]
| This project would simulate a hand-held chess game, and the game would allow two player games using two beagleboards over a network connection. The graphics would use the beagle's PowerVR SGX for hardware accelerated graphics by using OpenGL. In addition to 3D graphics and networking, a third portion of the project would be to optimize the boot time because a chess computer should start up quickly.
|-
| Tom Most <br> David Baty <br> Mark Jacobson
| [[ECE597: Sumo Robot|Sumo Robot]]
| The goal of this project is to create a robot capable of competing in the 3.0 kg weight class of a sumo competition ([http://www.youtube.com/watch?v=V3OR_sHrOJM an example]). This would have minor hardware and electronics elements, but would focus on communication with sensors using the BeagleBoard and the Linux kernel. At minimum, this involves sensors to detect the edge of the ring and the opposing robot. This would likely be implemented using Sharp IR rangefinders, a ultrasonic rangefinders, and ideally a camera. [http://circ.mtco.com/competitions/2010/rules/sumo Sumo rules].
|-
|Brian Embry <br> Jessica Lipscomb <br> Paul Banister
| [[ECE597 Network based MP3 player]]
| Network based mp3 player. The Beagle will be programmed using a custom, protocol for transferring files from a network based server (x86 pc) to a Beagle. Speakers will be attached to the Beagle, where the file will be played back. Possible extensions are a LCD for displaying id3 tag information, and buttons for user interaction (next track, previous track, etc.) on the GPIO interface.
|-
|[[user:routhcr | Chris Routh]] <br> [[user:collinjc | J. Cody Collins]] <br> [[user:jacksogc | Greg Jackson]] [[user:Xinkeqiong | Keqiong Xin]]
| [[ECE597: Auto HUD]]
| Use the beagle board to run image recognition on a camera feed located inside a car, and then signaling to the driver via a pico projector various objects of interest.
|-
| Adam Jesionowski<br>Qiang Jiang
| [[ECE597_Adding_Sense_to_Beagle|Adding Sense to Beagle]] (See [[BeagleBoard/GSoC/Ideas]])
| Sensory aware applications are becoming more mainstream with the release of the Apple iPhone. This project would combine both HW and SW to add sensory awareness to beagle. First, additional modules such as GPS, 3-axis accelerometers, Gyroscopes, Temperature Sensors, Humidity Sensors, Pressure Sensors, etc, would be added to beagle to compliment the microphone input in order to allow sensing of the real world environment. Then SW APIs would need to be layered on top to allow easy access to the sensory data for use by applications.
|-
| Mitch Garvin <br> Matt Luke <br> Elliot Simon <br> Jian Li
| [[ECE597 Interactive Pong|Interactive Pong]]
| Run classic pong, projecting the screen and using a camera to track user's hands for input.
|}

EBC Exercise 07 Notes on Installing Ubuntu in VMware Player

2011-11-29T01:25:52Z

Ziyi Zhang:

[[Category:ECE497]]

Note: I haven't updated this for 2011.

It's pretty much agreed that if you are going to develop for embedded Linux, you should do it in Linux. The problem is many have some form of Windows OS installed. Here are step by step instructions on how to install a virtual machine running Ubuntu Linux on your Windows box.

== Configuring VMware Player ==

First we'll set up the virtual hard drive, then we'll get the virtual machine software. The hard drive is set up using some third party software.
#Go to [http://sourceforge.net/projects/vmmanager here] and get '''VMmanager''',
#install and run it.
#Select "Creat a new virtual machine"
#Select Operating System: Linux
#Below Select: Ubuntu Linux
#Project name: Ubuntu 9.10
#Tab RAM: 1024M (Make this as big as possible, but no more than 1/2 your laptop's RAM)
#Tab Hard Disk: Unselect "Allocate all disk space now" We'll make the hard drive bigger in a moment. This is working around a small bug that requires all the disk space to be present when you create the machine, even if you don't allocate it all at the beginning.
#Keep Selected "Split into 2GB files"
#Tab Ethernet: Ethernet 0, NAT, Ethernet 1 Bridged
#Tab Adapters: Select USB, COM1 COM2 and Sound Adapter
#Tab Finish: Click "Ok" pick a file name. It should quickly say it is finished.
#Quit VMmagager
Here are videos for [http://www.rose-hulman.edu/~yoder/eLinux/videos/Install_VMmanager.swf installing] and [http://www.rose-hulman.edu/~yoder/eLinux/videos/Run_VMmanager.swf running] VMmanager.

# Restart VMmanager
# Select "Modify an existing virtual machine"
# Select the machine you just saved.
# Tab Hard Drive
# Select "Unlock"
# Enter ''40960''
# Tab Finish, if it says "the size of the hard disk is too large" and indicates the maximum hard disk you can have is 8 GB, go to 'vmmanager.ini' file and change the paramter 'maxHDsize' defined within it. You may change this parameter within the range from 100 MB up to 972800 MB.

# Click "Ok". It should quickly say it is finished.
Here is a video of [http://www.rose-hulman.edu/~yoder/eLinux/videos/Run_VMmanager2.swf running]] VMmanager the second time.

== Installing VMware Player ==

Now we can get the VMware player and install it.
# Get the [http://www.vmware.com/download/player/download.html VMware player]. I got version 2.5.3 for Windows 32-bit and 64-bit (.exe).
# Install it

== Getting Ubuntu and installing it ==

Note: At the time I'm editing these I can't get to either the lug site or the csse ftp site.
--may

==== Manually Installing with ISO ====
Next get the Ubunutu image and install it in the machine. I'm using 10.4 LTS since it's required by some of the TI tools.

#You can get the Ubuntu iso image [http://www.ubuntu.com/ here]; however it's faster for Rose students to get a copy locally from [http://lug.rose-hulman.edu/mirror/ubuntu-releases/ lug] or [ftp://ftp.csse.rose-hulman.edu/ubuntu-releases/ csse]. If you aren't sure which iso to get, look for '''ubuntu-9.10-desktop-i386.iso'''.
#Click on the vm you created above (*.vmx). The VMware Player should start.
#Click on the CD icon on the bottom right.
#Select Disconnect.
#Click on the CD icon again and select "Connect to disk image file (iso):"
#Select the Ubuntu '''iso''' file you downloaded.
#On the top left the window select the menu '''VMware Player:Troubleshoot:Reset'''. The VMware Player should find the iso image and start the Unbuntu install.
#Select: Load Ubuntu
[http://www.rose-hulman.edu/~yoder/eLinux/videos/Install_Ubuntu.swf Here]is a 3 minute demo.

Hint 1: You may have to hit ctrl-G to get the VM to listen to your keyboard.

Hint 2: It won't see your mouse at first, so use the keyboard.

Hint 3: Ctrl-Alt will release the mouse for outside the VM.

#Answer questions for your location.
#Select "Erase and use the entire disk"
#Answer the rest of the questions.
#Select install and wait a while. My install took about half an hour.
#Restart the system when asked to. You may be asked about ejecting the CD-ROM. I clicked '''No'''.

#Once Ubuntu is running you can right-click on the CD-ROM image and unmount it.
#Go to the CD-ROM icon on the bottom right and disconnect from the iso image.
#The Update Manager may appear. Go ahead and have it update everything. It took 15 minutes on my system.

==== Downloading VMWare Appliance ====
{{caution}} If you have downloaded the Ubuntu disk and installed it, these directions do not apply to you.

VMPlanet provides premade virtual hard disks that can simply be imported into vmware player. This will simply save the install, but probably will use more internet bandwidth then downloading and installing the iso.

See [http://vmplanet.net/node/106 VMPlanet Ubuntu 9.10]

== Installing VMWare Tools ==
Now that you have your Ubuntu image loaded and updated, it is important to install VMWare Tools. This will allow for much more natural mouse synchronization, speed improvements, and copy/paste support between host and guest OS's.

*If you are running the VMWare Appliance, this may not be necessary.

The Ubuntu wiki has by far the best directions on how to do this
[https://help.ubuntu.com/community/VMware/Tools Ubuntu VMWare Tools]

ECE497 Editing a Wiki

2011-11-24T18:28:04Z

Ziyi Zhang:

[[Category:ECE497]]

Here is a wiki you can practice editing. Before you can edit it you will have to create an login. Pick something that will make it easy for me to identify you as part of my class. Then just add your name and date on the end of the table.

You can get help here: [[Help:Contents]].

If you need help with syntax check out the [[Editing Quickstart Guide|eLinux guide]] or the [http://en.wikipedia.org/wiki/Wikipedia:Cheatsheet Wikipedia Cheetsheet].

{|
! Name
! Date
|-
| [[user:Yoder | Mark A. Yoder]]
| 21-Nov-2011
|-
|-
| [[user:Yuming | Yuming Cao]]
| 21-Nov-2011
|-
|-
| [[user:Yuhasmj | Michael Yuhas]]
| 21-Nov-2011
|-
| [[user:Yifei | Yifei Li]]
| 22-Nov-2011
|-
| [[user:Ziyi Zhang | Ziyi Zhang]]
| 24-Nov-2011
|-
|}

ECE497 Contributions and Project Status

2011-11-21T22:07:09Z

Ziyi Zhang:

[[Category:ECE497]]

Please edit this page and add your user name, alphabetically by last name, to this list.

Take a look at what you and others have contributed.

# [[Special:Contributions/YourUserName| YourName]]
# [[Special:Contributions/Yoder | Mark A. Yoder]]
# [[Special:Contributions/Yuming | Yuming Cao]]
# [[Special:Contributions/Ziyi Zhang | Ziyi Zhang]]

ECE497 Contributions and Project Status

2011-11-21T22:06:41Z

Ziyi Zhang:

User:Ziyi Zhang

2011-11-21T22:03:49Z

Ziyi Zhang:

Ziyi Zhang

Master in Electrical and Computer Engineering

Hi,everyone!

This is Ziyi(Ziggy) Zhang from this course.

Look forward to getting to learn interesting stuff and having fun in this class!

[[Category:ECE497]]

User:Ziyi Zhang

2011-11-21T22:01:19Z

Ziyi Zhang:

User:Ziyi Zhang

2011-11-21T21:58:42Z

Ziyi Zhang:

User:Ziyi Zhang

2011-11-21T21:57:56Z

Ziyi Zhang:

User:Ziyi Zhang

2011-11-21T21:57:09Z

Ziyi Zhang:

User:Ziyi Zhang

2011-11-21T21:52:24Z

Ziyi Zhang:

Ziyi Zhang

Master in Electrical and Computer Engineering

Hi,everyone!

This is Ziyi(Ziggy) Zhang from this course.

Look forward to getting to learn interesting stuff and having fun in this class!

User:Ziyi Zhang

2011-11-21T21:50:26Z

Ziyi Zhang: Undo revision 76370 by Ziyi Zhang (talk)

Ziyi Zhang

Master in Electrical and Computer Engineering

User:Ziyi Zhang

2011-11-21T21:50:11Z

Ziyi Zhang: Blanked the page

User:Ziyi Zhang

2011-11-21T21:48:43Z

Ziyi Zhang:

Ziyi Zhang

Master in Electrical and Computer Engineering

User:Ziyi Zhang

2011-11-21T21:41:40Z

Ziyi Zhang: Created page with "Hi,everyone! This is Ziyi(Ziggy) Zhang from this course. Look forward to getting to learn interesting stuff and having fun in this class!"

Hi,everyone! This is Ziyi(Ziggy) Zhang from this course. Look forward to getting to learn interesting stuff and having fun in this class!