During my presentation I talked about the project concept to initial development to the current status of Ellie. I also demoed the usage of Ellie and how to configure the system while it is running. This was honestly one of my favorite presentations I have ever done. A couple of video clips of my presentation have been edited together and you can view that below. Unfortunately, most of the usage demos didn’t get filmed, but more videos and demos will be released soon.

Jam3 at FITC 2012 Awards

On another note, Jam3 managed to take home a total of 4 FITC awards for our work in the past year. It was a great night where all the office employees came out to celebrate. We took home the awards for Technical Excellence (bear71.nfb.ca), Self Promotion (jam3.com), Visual Design (jam3.com) and our Senior Designer took home the Best Canadian Designer Website award.

If you have any questions, concerns and or comments please feel free to contact me anytime either on Twitter or by e-mail (fisher.matt@gmail.com).

I would like to also thank Shawn and the rest of the FITC crew for putting on another epic event.

Be sure to also checkout the Opening Titles for FITC Amsterdam 2012.

The In’s and Out’s of jQuery Mobile

• http://labs.fisherinnovation.com/fitc/presentation/
• http://labs.fisherinnovation.com/fitc/amsterdam/

Getting Acquainted with jQuery

• http://labs.fisherinnovation.com/jquery/

Heating Homes With Distributed Computing

• http://mydatafurnace.com/

I will be posting a lot more regarding this project very soon so be sure to stay tuned.

Ellie – Proof of Concept from Matt Fisher on Vimeo.

Be sure to get your ticket for the event if you haven’t already. Vist the FITC Amsterdam site to get all the information you need.

http://labs.fisherinnovation.com/fitc/presentation/

More work like this can always be found in the Labs section of this site, so be sure to go and see if there is anything else you may be interested in.

You can also download the source for the presentation easily from it’s GitHub repo – https://github.com/fisherinnovation/Mobile-Cross-Browser-Sexiness-with-jQuery-Mobile

The presentation and the conference were a hit! The room was packed and people even had to sit on the floor to just see the show. I was even happier when I received a tweet from the jQuery founder himself John Resig:

All in all, I had a great time, met some great new people and learned a lot of new things. How could anyone complain about that.

Jam3 is known for work that is elaborate and visual, so collaborating with the very talented Dean West to transform our process into a series of over the top, epic photos was natural. Each person depicted in the Process collection is employed at Jam3. This is an important representation, as our people are the most integral part of the wonderful work that we produce.

Our Process collection aims to attract the people who understand the concept; who get our creative style and who want to be a part of the worlds we create.

Read more on the Jam3 Blog.

Interested? Of course you are. It’s always best to start learning by checking out the man page for screen.

Installing screen is easy, if your on a system like Ubuntu or Debian run the command sudo apt-get install screen or find it in your favorite application package installer. If your on OS X you may already have it installed.

Once screen is installed, start up a new screen session by just typing screen in the command line.

You should notice a fresh window appear possibly with a message from the application telling you what is going on. For leaning sake, lets run a simple command to show how this system works. In the new screen window that has started type ls to simply list the current directory contents. Now with that command done and the output visible, hit CMD+A and then D. You should be brought back to the original command line you had open and ran screen from. You should also see that the screen [detached] - what has happened is that your screen session (aka. the command line you wrote ls into) has been put into the background and is waiting for you to reattach it. This is where the power comes in, but you need to be able to reopen that command line again to make it actually useful. So just type screen -r and hit enter. You should be brought back into your screen session that your ran ls from. Behold the POWER! Type exit in the command line to close out this screen session for good now.

The next step in screen mastery is setting up a configuration to your liking. By default screen reads it’s configuration from a .screenrc file in your home directory. So lets create one now, we will use my personal config as a starter – open up the text editor of your choice and write the following to .screenrc in your home directory (source is also on Gist).

hardstatus alwayslastline
hardstatus string '%{= kG}[ %{G}%H %{g}][%= %{= kw}%?%-Lw%?%{r}(%{W}%n*%f%t%?(%u)%?%{r})%{w}%?%+Lw%?%?%= %{g}][%{B} %m-%d %{W}%c %{g}]'

Close the file and fire up a new screen session by typing screen again. You should notice some fancy footer on the bottom of the window now. Most likely in the centre it says (0*$bash), this is the screen label for this current screen. Try hitting CTRL+A and then C. This should open up another command line inside the same screen session or effectly (1*$bash). Now you can multitask like a mad-man and easily switch back and fourth between multiple command lines in the same screen session that can be closed and re-open at any time. To shuffle to the next command line in the list hit CTRL+A and then N. Do it again and back you go to the other window.

By now you should have a understanding of the power of this application. I use it everyday and love showing command line new comers it as they usually have to pick their jaw off the floor when they realize what it will do for them. Be sure to read into the man pages for a ton more configurations to set to your liking!

Presentation Deatils

Screens 2011 will be hosted in Toronto Ontario this year on November 14th and 15th. More information here.

See you there!

Overview

The goal of this post is to setup point to point wireless communication between your Arduino and your computer. The Arduino will be remotely controlled via Serial commands sent via the XBee modules.

Hardware Used

In this demo I am using the following setup,

• Arduino compatible micro controller – http://www.arduino.cc/
• XBee Explorer Regulated – http://www.sparkfun.com/products/9132
• XBee Explorer USB – http://www.sparkfun.com/products/8687
• Small servo – http://www.sparkfun.com/products/9065
• 2 x XBee 1mW Chip Antenna (Any XBee, these are just the cheap ones) – http://www.sparkfun.com/products/8664

Part 1 – Putting it all Together

As with most Arduino projects, the first thing we need to do is wire up our project. Thankfully, because we are using SparkFun’s XBee Explorer boards, this is relatively painless.

XBee Explorer USB

So with that point in mind, let start with the easiest step. To allow your computer to talk to the remote Arduino, you will need a XBee connected to your computer. As mentioned, the SparkFun XBee Explorer USB board makes this super simple. Take one of your XBee modules and connect it to the Explorer USB board. With a USB cable at hand connect it to the board and just put this setup aside for now. We will be using it once we have loaded code to the Arduino and are ready to test. As a side note – since I use this Explorer USB all the time, I put a piece of Velcro on the back of it as well as another piece of Velcro on the back of my laptop. This is just to make my setup less cluttered with cables everywhere.

The next step in the setup process is getting our Arduino setup with our other XBee module.

Part 2 – Writing the Code

Here is the Arduino code I used for this demo. This demo is very simple, as it just prints the numbers 0 to 100 every second. As you can see, it is as simple as sending the data via the Serial.print command.

void setup()
{
  Serial.begin(9600);
} 
 
void loop()
{
  delay(1000);
 
  for(int a = 0; a < 100; a++)
  {
    Serial.print(a);
    Serial.print(" ");
  }
  Serial.println();
}

One thing to note about loading code to the Arduino while using XBee’s. Since the XBee uses the RX and TX of the Arduino, you must disconnect / turn off the connection to the XBee while loading code to the board. In my case, since I am use the SparkFun XBee Shield, I can simple move the small switch on the shield from “DLINE” to “UART”.

Part 3 – Testing the Project

Arduino Serial Output

Once this sample code snippet it added to the Arduino, disconnect the Arduino and reconnect it to a external power source (not on the computer you want to wirelessly connect to). Grab the XBee Explorer we set aside earlier and plug it into your computer.

Make sure the correct COM port is selected in the Arduino IDE and then fire open the Serial Monitor. If you haven’t already – make sure that Arduino is externally powered and if everything is working properly, you should see the numbers (0 – 100) appearing on a new line every one second. Congrats, you got your computer listening to your Arduino, wirelessly!

Part 4 – Something More Practical

Here is a code snippet from when I was testing code for my ground antenna for my FI-AUAV. The commands are for pan and tilt control on the antenna mount allowing me to track the position of the UAV in real-time. The commands are sent to the Arduino on the antenna, parsed and then the servo rotation of the antenna is updated.

The commands are PP000# and TT000#. Where PP is pan, 000 is the rotation amount for that servo to rotate to and # is the end line identifier. TT is for tilt control.

#include Servo.h
 
#define BufferLength 16
#define LineEnd '#'
 
Servo pan;
Servo tilt;
char inputBuffer[BufferLength];
 
void setup()
{
   Serial.begin(9600);
 
   pan.attach(9);
   tilt.attach(10); 
 
   Serial.println("Ready for input!");
}
 
void loop()
{
  int inputLength = 0;
 
  do
  {
    while (!Serial.available());
    inputBuffer[inputLength] = Serial.read();
  } while (inputBuffer[inputLength] != LineEnd && ++inputLength < BufferLength);
 
  inputBuffer[inputLength] = 0;
 
  HandleCommand(inputBuffer, inputLength);
} 
 
void HandleCommand(char* input, int length)
{
  Serial.println(input);
 
  if (length < 2)    {     return;   }         int value = 0;         if (length > 2)
  {
    value = atoi(&input[2]);
  }
 
  int* command = (int*)input;
 
  switch(*command)
  {
    case 'PP':
     pan.write(value);
    break;
 
    case 'TT':
     tilt.write(value);
    break;
 
    default:
    break;
  }
}

The is a simple interpretation of the current code I am using, but this version of the code can easily be implemented in many other robotic platforms.

Final note: To power the XBee and two servos you will need to power the Arduino with something like a 9-12VDC power supply as most traditional 5V supplies won’t have the power to run everything.

Feel free to leave a comment if you have a question. Good luck with your wireless projects!

crontab -e

Once your crontab editor is open, add the following line of code to the end of the file.

# This will run a backup from source to destination at 4:00am everyday.
0 4 * * * rsync -a --delete source/ destination/

The following code requires some edits to work properly on your system so lets look at exactly what this is doing first. Any line starting with a # are full line comments, so the first line is just documentation on what this cronjob is. The second line is where the magic happens. Crontab formatting may look at little weird if you haven’t seen it before but once you understand what is what, it will all make sense.

The initial numbers and asterisks in the second line are the time declaration for our cron job. Since cron jobs can be run in intervals we need to specify what that interval is. Lets look at how to do that.

*     *     *   *    *        command to be executed
-     -     -   -    -
|     |     |   |    |
|     |     |   |    +----- day of week (0 - 6) (Sunday=0)
|     |     |   +------- month (1 - 12)
|     |     +--------- day of        month (1 - 31)
|     +----------- hour (0 - 23)
+------------- min (0 - 59)

Finally, with the time, we need a script to call which will perform our back. Since the command to do this with rsync is relativly small, we can just add the command right on to the crontab rather then reference it in separate file.

rsync -a --delete source/ destination/

Replacing the “source” and “destination” references and replacing them with your own is all that is needed to do a differential rsync backup. This means that only new files that haven’t already been backed up yet are sent to the second drive.