Taking the same configuration I had in the original Androcade I added support to the arduino program to allow for an analog joystick to control the up/down/left/right. This was pretty straight forward, instead of triggering a serial send via a button I just looked to the value of the analog input and triggered based on thresholds.

The device is a little large at this point because of having to stack a few shields on top of each other but, it works great! The next plan would be to shrink down the prototype into something that fits into your hands. I’ve had a couple ideas – like taking an existing controller and replacing the insides with an Arduino mini but that’s left for another time.

Androcade Handheld

Here are some of the details of the build:

Hardware:

• Arduino UNO
• Bluetooth serial shield – (I used the following from iteadstudio)
• Joystick shield – ( here is the one I used from iteadstudio)

The software on the Arduino side is very simple. I listen for a button push or the analog threshold to be reached and send out a serial command. The serial data is then sent through the bluetooth device out to the Android software.

On the Android side I have created software the reads the serial data and sends out keyboard characters to the system.

I vividly remember the days of putting my hard earned quarters into the latest video game at the the local arcade (Machine Shed). Disparately tying to get my initials on the high score board, hearing that familiar knock when someone got that extra game on the pinball machine…

Well it’s not the 1980′s anymore and those great games of the past have been replaced by XBox live and mobile handsets.

I’m not one to shy away from the latest in new technology, in fact, I welcome every new piece of techno-wizardry that comes my way. Although, I do miss the look of that retro-joystick and the familiar feel of the plastic button under my fingers. So out of my need to recapture some of my youth (maybe a bit of a stretch) and my love of new technology I set out to create a simple retro gaming controller for the Android platform.

Here’s a video preview of the final project:

Androcade Preview

Project Investigation

I wanted the project to meet a certain set of criteria:

1. The controller had to work seamlessly with almost every Android device. This was the biggest hurdle as there is so many different devices to have to support…
2. It had to be simple to use. Sometimes easier said than done.
3. It had to support a joystick and at least 3 buttons.

Seems simple enough, right?

I started to investigate different ways to build my device. I began my journey down the path of using the Android ADK. This is a great development environment that allows you to use your Android device to interact with physical hardware. It is based on the Arduino which I was already familiar with! After further investigation I found that even though this platform was great it did not meet my needs, for a couple of reasons.

1. It needs a physical connection with the device. I wanted to avoid having to plug in the Android device to my controller.
2. It needs to be supported by whatever program is running on the Android device. In other words it was not a simple task to send commands to other Android programs using this platform.

So I scrapped the whole ADK idea, but, I did like the idea of using the Arduino for the input device. I already knew how to program it, it was simple to use and provided a great platform to prototype with. So I decided that this was the route to go for interacting with the controller.

My next task was to find a way for the Arduino to communicate with the Android device. After eliminating USB the next logical solution was Bluetooth.

I set out to find a inexpensive shield for the Arduino that would allow bluetooth communication to my Android device. Combing the internet I found several bluetooth shields for the Arduino but, they all cost around $40-$60 and being thrifty (OK – I’ll admit it… I’m cheap!) I wanted a less expensive solution.

After more searching I found what I think is the perfect solution! I found a $20 bluetooth shield that acts as a serial communication device. The product can be found here:

http://iteadstudio.com/store/index.php?main_page=product_info&cPath=18&products_id=307 

This device will work perfectly for my needs! I would simply send different characters over the serial port from the Arduino to the Android device and interrupt those commands on the Android to control games.

The next thing I had to figure out was how I was going to accept those commands from the bluetooth shield and send them to the games on the Android.

After a little searching and reading I settled upon writing a IME (Input Method Editor) for the Android that would take in the commands over bluetooth and send them out to the system as keyboard commands. This will work perfectly as a lot of the games that I wanted to play supported using the keyboard as an input device!

Read Part 2 of the ANDROCADE build

Writing the Software

This was the most involved piece of the entire build. I had to write essentially two different programs, one for the Arduino to interact with the buttons and one for the Android that would receive the bluetooth commands and send them out as keyboard commands.

I hate to disappoint anyone reading this but, I’m not going to get into great detail about the code and it is not publicly available – yet… I still need to clean it up and test some more before I decide what to do with it. I will however give an overview of what I did.

Interfacing with the Arduino

This is actually the simplest part. The controls are just buttons that open and close a loop to a digital pin on the Arduino. The Arduino senses the change and sends out a serial command based on which pin was triggered. Each of the buttons was connected to a digital pin via a pull up resistor. When the button is pushed the pin goes low and the software sends out a serial command based on the which pin was triggered. Here is a simple example to show what I’m talking about:

That’s essentially what I did for the Arduino code. The nice thing about this is that the bluetooth shield takes care of the hard part of sending the serial command out to the Android.

Android Code

The code for the Android side of things is a little more complicated. The program consists of a few components put together:

1. Input method service
2. Bluetooth service
3. Preference activity

The preference activity is where the user interacts with the program. This allows you to enable the bluetooth, find the and select the bluetooth device, active the input method, and configure the key commands.

The real work comes in the input method service and the bluetooth service. These are the programs that talk with the bluetooth shield and then send the commands out to the system as keyboard commands.

The bluetooth service is a background program that handles all the bluetooth communication. It will essentially run separate threads to threads to connect and communicate with the bluetooth device. There is a handler that is passed to the bluetooth service which then sends data back to the input method service letting it know what commands to send to the system.

There is a great bluetooth example that Google has on it’s developer site http://developer.android.com/resources/samples/BluetoothChat/index.html

This is a bluetooth chat program and it has all the necessary code for you to create your own bluetooth programs.

The most important service in the Android code is the input method service. This is the program that sends out the keyboard commands based on th input from the bluetooth device. An input method editor or IME is basically a keyboard on the Android platform. To write one you extend the InputMethodService and override some supplied methods.

The nice thing about this for me was that I did not have to create any screen elements for my “keyboard”. This type of service has methods for displaying a view which is your keyboard but, since I did not want to display a user interface all I had to do was process the commands from the bluetooth service and send out key commands.

To find out more about creating an IME here is the developer page from Google: http://developer.android.com/resources/articles/creating-input-method.html

Read Part 3 of the ANDROCADE Build

Controller Design

The next phase was to design something to house the controls. I first gravitated to building a mini-arcade cabinet. These are really cool! They are just scaled down versions of the real arcade cabinets. After toying with a few designs I wasn’t happy with the way they were turning out.

What I didn’t like about the arcade design was the fact that I wanted to use any type of android device from tablets to phones. The arcade would have to be rather large to accommodate tablets in both landscape and portrait mode but, then it would be overbearing for a phone sitting in the large cabinet.

I also wanted to convey the idea that this is an Android specific controller – I’m a big Android fan and since this was designed specifically for that platform it had to scream Android!

I sat down and tried to tap my artistic side, which is very limited by the way, and come up with a unique controller design. After a few failed attempts I hit on the idea of using the Android mascot Andy as the base for my controller. I sketched out a few designs on paper to see if the idea was viable and from what I could see on paper – I had my design!

Next was out to the garage to try and put together the first prototype. I broke out the trusty power tools and started making saw dust fly. In the midst of all the measuring, cutting, drilling, sanding and painting I realized that I did not take any pictures of the build process… sorry.

After all the saw dust had cleared and the paint had dried I was left with one last task before I could call it complete – it needed a name. Reaching into the depths of my creativity (I didn’t have far to reach…) I dubbed the new controller ANDROCADE!!

Here are some final build pictures:

Testing the ANDROCADE

After final assembly I had to get the answers to a few questions that need to be answered after every creation. The first one being does it work? Yes, it does! I was able to turn it on and start up the configuration and after a few minutes I was playing games! The down side is that a lot of games that are on mobile devices do not support keyboard input – damn those silly touch screens…

Needless to say I was able to find games that do support keyboard input and the controller has worked flawlessly!

The next thing I wanted to do was give the controller a workout. Enter my teenage boys. After giving them a 30 second run down on how it works they put it through it paces. I think that it was a success because the only thing that stopped them from playing was a dead battery on my tablet!

Conclusion

You thought that we’d never get here…

It’s been really fun building this project – it’s always nice to see something go from an idea to reality. I will continue to improve upon the ANDROCADE device as there are always ways to improve a project!

I will try to update my site with more information as I make changes or improvements.

I’m also open to answer questions about the build as time permits leave a comment below or drop me an email at androcade at gmail dot com. I’ll do my best to get back to you!

Thanks for visiting!!

There were three states that I was interested in notifying the users of my app about:

1. Is WiFi available on the device
2. Is the WiFi enabled
3. Is the WiFi connected to an access point

One of the features in Android is the concept of listeners. These are classes that allow your app to receive and process events based on the state of something on the device. For example there are listeners that allow you to monitor GPS updates or accelerometer changes. So the off I went to search for a listener for WiFi changes… well to my surprise there is no listener for WiFi state.

Not to be discouraged I set off in search of an alternative and that’s where the BroadcastReceiver comes into play. Android has a concept of sending off intent actions which you can register to receive. This is perfect for our situation as we can register for the broadcasts related to the WiFi state and within our receiver we can update our application.

Here is the code to create a receiver class and register it to receive WiFi state changes:

One thing with BroadcastReceivers you need to be aware of is that they should be registered in the onResume() method and unregistered in the onPause() method. According to the documentation your application will not receive the broadcast if it is paused so unregistering the receiver helps with system overhead.

Another thing that is specific to broadcast receivers it that you need to know is that a receiver is only valid for the duration of the call to its onReceive() method. This means that you should not do any asynchronous work from within that method. Instead if you need to you can launch a service or send notifications through the notification manager.

NOTE: The broadcast intents that we receive for the different WiFi states have extras along with them that you can access to determine the different states of the WiFi connection. I have chosen to use a different method of testing states.

With that being said if you remember we wanted to check three states.

The first one is only needed to be checked on the start of our applicaiton. If the WiFi is not available on this device the I doubt it will become available at a later time. We simply create a WifiManager object and check if it is null – if it is then the device has no WiFi.

The second one is if the WiFi is enabled. Here we use the same WifiManager object and if it is not null we check to see if the WiFi is enabled.

The last piece is to check if we have connectivity to an actual wireless access point. Remember that even though the wireless is enabled it may not be connected and we will not be able to send data.

This is a little more involved as we have to iterate through an array to find the WiFi connection then we can determine it’s state.

First we get a ConnecticityManager and with that we retrieve a NetworkInfo array. We then iterate this array looking for the NetworkInfo object for the WiFI after that we check if that object is connected, if so, we are ready to send data!

There you have it. With this you should be able to detect the state of the WiFi!

The documentation in the developers area does not show any information for the method getIPAddress() all it states is that it returns an int? I was not sure that this would give me what I needed – maybe I would have to parse the number to return a logical display of the IP.

Well… after a few hours of trying different ways to display the number and looking at different ways that others have tried, I could not come up with a way to display the number returned by this method.

Back to searching for another way to do this. I abandon looking through the Android docs for a way and moved on to just look at how others have done this through Java calls – and wouldn’t you know I found a way.

By simply iterating over the network interfaces I was  able to get the IP that I was looking for. I can’t take full credit for this code as others have done this before me. One thing I need to remeber is that if there is not a way directly in the Android implementation – there might just be a simple Java method to solve my issue!

Here is the code that I used to get my local IP:

I soon learned that having a good grasp on the life-cycle of an activity was critical. Making an efficient application and knowing when to save critical data related to your activities state, let alone restoring your application to a particular state is all a part of the activity life-cycle.

There is a lot of different articles and information available on the internet about the life-cycles of activities. The Google documentation has good information on this as well. But I’m always better at understanding things if I see them for myself.

So I decided that I would write a simple activity that prints out debug statements each time one of the functions of the life-cycle was executed! Then I would be able to see exactly what is happening during each phase and when each function occurs during different situations.

It’s a very simple application, there is literally nothing that it does except print out debug statements on activity changes. Set up a filter in your LogCat called LIFECYCLE to get a clean output of just teh debug statements from this activity.

A couple of things that I found helpful were knowing if the bundle that was passed into the onCreate method had was null or not. This helped me determine when data was being saved and passed back to the activity.

Another item to note is the onRetainNonConfigurationInstance this function can come in handy in situations where you need to retain an object between destroying and re-creating your application. This can be used instead of passing items through a bundle or writing objects out to files or even re-querying a database. The thing you need to remember about this function is when it is called and why. The documentation states that this function is not guaranteed to be called and is only called when configuration changes take place (i.e. screen rotations) – it is not designed for any persistant data storage but is very helpful in retaining objects between activity changes. If you look closely at this function you can save just about anything from threads, network connections, and even images in memory.

Load up the code below and play around, rotate the screen, go to the home screen, start a new activity, click the back button. All these will help you get a better understanding of where and when you should perform certain clean up and data saving routines within the activity life-cycle.

Here’s the code for the whole application put this in the main activity class:

In my search for a great editing package I’ve come across a real gem. Paint.NET (sorry mac users – windows only) This software has everything and then some.

The interface is extremely intuitive everything is laid out simply allowing you to easily find the tools you need. It has a thumbnail interface allowing you work with multiple images.

One of the things that is lacking in most imaging programs is layers. This feature makes Paint.NET a step above the competition. Having multiple layers allows you to create some amazing effects.

Another great thing about this program is the active community. If you have a question or are looking for a technique on how to create a certain effect – there are hundreds of users that will answer your questions. They also have a huge set of tutorials created by the community allowing you to get up to speed fast on some of the more advances techniques.

One of the other great features of the program is the effects. You can achieve very professional results with just a few clicks with the effects interfaces.  Developers from all over have contributed some amazing features to the program through their plug-in feature and the greatest thing about them is they are all free!

If your interested in some great imaging software – check out Paint.NET!

Everything is working great with with the software set up! It easily detects motion and takes pictures of the events. When we last posted about this I was in the process of adding notification to the software. I was able to add a couple of simple yet fun features to notify us when the software has detected motion.

I wanted a way to let us know when something was detected when we were at home so we could walk over to the computer and see what it caught. What better way to do that then to have the software send us a text message! Most carries have a way for you to send a text message by simply emailing your phone number using the carrier specific email address. After some brief searching I found that my carrier uses this format: yourphonenumber @ vtext.com sending an email to this address triggers their system to send a text message to your phone. NOTE: You will be charged for these if you don’t have an unlimited text plan be careful!

All I had to do now is add some code to send out the message after detection. Luckily .NET has some simple libraries to allow you to send out emails – so with just a few simple lines of code I was able to send an email that generates a text message whenever motion is detected. Here is the email code:

This works great I added a boolean to the code that is turned on and off by a menu choice allowing us to activate and de-activate the sending of messages when we want. It works great – my son gets really excited when he gets a text message that a new motion was detected!

That just wasn’t enough – there was something missing…

After my son and I discussed it we decided that we needed a way to see the images after they were captured but, without having to go to the computer to see them.

Since we already had the ability to send out email – we thought why not email the pictures to us so we can view them on our phones from anywhere!! Needless to say we changed the code once again and added the ability to send out an email with the images attached to it.

A couple of things to note are that attaching large amounts of photos to am email can make it very large depending on the size of the photos and some email providers won’t accept emails that large also, the processing time can be a hog and delay the rest of the program. To fix these we designed it to only attach the first five images that it collects and we also have it run on a separate thread so the program can go along it’s merry way as the email is processed and sent!

If your wondering about the attachments – it’s simple just add them to the

Message

object like this

msg.Attachment.Add(path to file)

.

As for the threading, once again, .NET makes it easy to create simple threading with the

BackgroundWorker

object. I will leave this for another day as this post is already way too long.

One last thing… After all the fun we’ve had with the motion detection we have decided to change things up so we can do time-lapse! We think it would be really neat to see how things happen over time. So stay tuned for some fun with time-lapse coming in some later posts!

The cameras have 25m of cable, some infrared leds (night vision), and an s-video out. It runs off a wall wart for power (I’m thinking about swapping this for batteries) so it’s limited to where we can put it. I’m using a USB EasyCAP device to take the s-video and bring it into the computer.

Time to do a little research and since I’m familiar with C# I figured I’d start looking for examples of software to use. I had a few criteria that I was looking for:

• Had to use C#
• Had to be able to save files to disc
• Should be event driven
• Had to support my video input
• Had to be simple…

After about a half hour looking at different examples and rummaging through some source code I came across this one on codeproject – Motion Detection Algorythms. Even though it is a little old it fits all my criteria perfectly. It uses the AForge.NET Framework which is very actively worked on which allows me access to great documentation. I was able to download this and get it compiled and running in about a half hour!

Right away I noticed that the orginal source code saves the images to an AVI file when it senses motion. I just wanted to take still pictures and save them to disc whenever motion is detected. Since the AForge framework is so simple I was able to modify the code to write out bitmaps instead of avi files. Here is what I added… (this is just a simple fun program so alot of error checking and proper coding was skipped)

The camera control has a callback event that triggers on each frame, so originally the code would check to see if it was supposed to capture and if it was then it would write an avi file – here’s what I changed the callback function to:

This gave me a bitmap image that was uniquely named from the date/time and saved it to a folder called images that is in the same directory as the program. The saveInterval variable was also added. This allowed me to not have to save every frame when the motion was triggered. At 20-30 frames per second it was creating a lot of files that I didn’t need. I have been setting this to 10 or 20 and it seems to work for me (you can eliminate it to capture every frame if you want).

I almost forgot… one other thing that I changed was to eliminate the red lines that get drawn around the items that are detected. I didn’t care to see what was being detected – I just wanted clean images. In the file MotionDetector3Optimized.cs all I had to do was comment out one line.

So now we had a functioning program and it was collecting the images just like we wanted.

It was late and we wanted to see if the night vision part of the camera would work. So we set out the camera way out in the back yard (as far as the cable would reach out the window). Underneath the camera we placed some peanut butter on a rock and then went to bed.

The next morning we woke up and to our surprise we had some images – yes they are mice (we live out in a rural area). It was pretty neat to see the images and it was fun to get everything working together.

I created these animated gifs with the images we captured.

Even though we had a working system I wanted to try some other things with the software – I wanted to be able to know when it captured motion and be able to see the images on my phone. So in part two of this post I will show you how we are now notified by text message and sent an email with the pictures (I’m looking at having them upload to a web site as well) I’m also working on a larger array of infrared lights to hopefully get better pictures! Stay Tuned!!!