Friday, September 16, 2011

Arduino

Greetings

Sorry for the long hiatus in posting. I had no time to create anything, what with all final exams of grade 11, and didn't have my kits for the entirety of the summer vacations. In any case, I ma back now.

A technology that has now interested me is Arduino.  Arduino is an open-source electronic prototyping platform, which comes with an AVR ATmega328  microprocessor, 14 digital input/output pins (of which 6 can be used as PWM outputs), 6 analog inputs, a 16 MHz crystal oscillator, a USB connection, a power jack, an ICSP header, and a reset button.The micro controller can be programmed using the Arduino programming language, which is based on Wiring. Wiring is pretty much C/C++, but with two mandatory functions that have to be defied to run the program: loop() and run().

Once I got my hands on an Arduino, I immediately borrowed a seven-segment-display, which has 6 input pins and 2 ground pins. After  connecting these input pins with six digital input/output pins on the board, I connected the two round pins to the ground on the Arduino. Then I got a simple push button, and connected it to +5V., ground and one of the input/output pin on the board. So, whenever I pressed the button, +5V would be sent to the digital input/output pin, which I could detect.

Then I created a simple program, which would define the state of the LEDs in the seven segment display, to display a certain digit. For example, for the digit 1, the state would be defined as

0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0

which means that only 2 leads from the seven segment displays must be give power and in this case it is leads 4 and 6. There is also code in the program to increment numbers by and roll back to 0, when he number is 9, whenever the button is pressed.

I don't have a schematic of my circuit, but I did manage to take some pics. Here you go:

View from the top. Notice the 7 resistors.

Another view
And here is the fully annotated code. You will need the Arduino software to compile it.

Link to the code (.pde file)

This is not the end.

Friday, April 29, 2011

Pocket Solver

Greetings.

For the past few days, I have been busy working on an iPhone Application. I will let you know the details later, but first let me narrate my journey in the mysterious and interesting world of iPhone application development.
    Being a generally Windows/Linux guy, I had no way to get my hands on a Mac. I wasn't willing to spend in the excess of $600 for a Mac(Mini). But thanks to the hacker community, I had a cheaper option. I used VMware Workstation and bought a copy of Mac OS 10.6. Then I proceeded to create a .iso file of the 10.6. Using a preconfigured Virtual Machine along with with custom built audio and video drivers and my Mac OS 10.6, I was able to run 10.6 on a virtual machine on Windows! I will create a blog post explaining how to do this, but tutorials can be found online.
    Once I got my "Mac" up and running, it was only a short while before I downloaded Xcode and the iOS SDK and started working on my app. It is a simple app that solves math equation AND outputs the full written solution. It is thus called Pocket Solver. It is a free application that my company Affordable Software Solutions released.  You can download it later find out about its features. Until then, here are some pics.





Anyway, this post is not to discuss the various features of my app or to promote it. Okay, maybe a little. But in this post, I will share some of the algorithms I  came up with to solve linear equations in two and three variables that will make your life much easier (if your life consists of solving linear equations...)

1) Linear Equation in two variables

Suppose you have a system of two equations that are in the form:

ax  + by = c    
dx + ey = f

then your x value will be equal to:

((c*d)-(f*a))/((b*d)-(e*a))

and your y value will be equal to:

(c*d-(x*b*d))/(a*d)

where x = ((c*d)-(f*a))/((b*d)-(e*a)).

looks complex, doesn't it?  All these algorithms actually do is eliminate the y variable and solve for x, and solve for y by substituting the newly found value of x in the equation.

If that didn't explode your head, here is another one...

2) Linear Equation in three variables

Suppose you have a system of three equations that are in the form:

ax  + by + cz = d    
ex  + fy + gz = h    
ix  + jy + kz = l 

Let us create six variables that contain a certain series of functions that we will use the most.
Let

    ae1 = (b*e)-(f*a)
    be1 = (c*e)-(g*a)
    ce1 = (d*e)-(h*a)   
    ae2 = (b*i)-(j*a)
    be2 = (c*i)-(k*a)
    ce2 = (d*i)-(l*a)

Now we will use these substitutions to find out the values of x, y and z.

So now, your z value will be equal to:

((ce1*ae2)-(ce2*ae1))/((be1*ae2)-(be2*ae1))

and your y value will be equal to:

((ce1-(z*be1))/ae1)

where z is equal to the equation above.

And your x value will be equal to:

(d-(z*c)-(b*((ce1-(z*be1))/ae1)))/a

where z can be found using the first equation.

Once again, I systematically eliminate x, create two equations with only y and z variables, eliminate y, find the value of z, substitute for z in one of the two newly created equations and find y, and substitute for y and z in the given equation and find x.

Wow, that was a lot! I am sure that you can further simply the algorithms, but  I haven't tried to do so. I encourage you to tinker with the algorithms, simplify them and make them more elegant. You have permission to use this algorithms in your projects, but with proper credit given to Aravind Rao.

This is not the end....





Tuesday, April 12, 2011

CyclopsNXT

Greetings

It has been a long time since I posted any of my creations. This is because for the past few days, I had been working on possibly my most entertaining project to date: A NXT cyclops that can track faces! Before I get started, here are some pics.


Front View, base and cam

Side view, cam holder in detail

Gearing to turn the camera

I see you!

So to make this creation, I used the OpenCV wrapper for Java (JavaCV), Lejos as well as Java SE. This creations consists of two motors. One motor drives a set of gears which can tilt the camera up or down. Another set of gears rotates a geared base CW or CCW, which in turn rotates the camera. The camera itself is connected to a terminal, which is the only wired connection to an external terminal in the whole project. You can use Bluetooth webcams and do away with wires. The geared base, rotating motor and the NXT brick all sit on a pretty sturdy base, which rests on four wheels. The whole project is about 20x15x20 cm. So basically the camera has four degrees of freedom. So what does this project achieve and how does it do that? I wanted for a long time to be able to build a robot that could track objects in real time and this robot does just that. The camera gets input from the environment and sends it to the computer for processing. A Java/JavaCV program running on the computer processes this input video and draws a rectangle on all detected faces (program works with only one face though).
       Now a method in the program computes the distance of the edges of the box around the face to the edges of the video frame. If the distance from the left edge of the box to the left edge of the frame is different by more than 80px compared to the distance from the right edge of the box to the right edge of the frame, the JavaCV program on the computer sends a command to the NXT Brick to either turn left or right, so as to position the face in the center of the video frame. The same works in the y axis, where the distances from the top and bottom edges of the box around the face to the top and bottom edges of the video frame are compared. Again if the difference is more than 60px, the JavaCV program sends a command to the NXT to tilt the camera up or down depending on the scenario.
       So that is pretty much how the program works. I have posted links to the code below, from both the NXT and the Computer. It is annotated and licensed under the MIT OSI License. Feel free to go over the coed and edit it. Hopefully it is educational. If you are having problems building the robot itself, send me a message, and I can help you out.  I have posted pics above that can guide you. Oh and a huge thanks to Nashruddin whose blog taught me how to program face recognition in OpenCV! And finally here is a video showing the robot in action.



*LINKS*
Code on the NXT
Code on the computer
Classifier to detect faces, must be in the folder from which comp.class is running.

This is not the end...

Sunday, March 20, 2011

Open CVhat I can do!

Greetings:

I have decided to take a short break from Lego building(let us just say that I stepped on one too many Lego bricks) and decided to learn something new. I always wanted to incorporate vision in my programs, so I decided to learn a little bit of OpenCV. I actually want to use OpenCV with Lego Mindstorms, but since I am using OpenCV for c++, I would have to use JNI to get my LeJOS Mindstorms to successfully communicate with my C++ OpenCV program. (EDIT: I just found out that a Java Wrapper for OpenCV exists, so I may be able to give my Mindstorms "vision" after all!) Anyway, What I really was interested in was to use OpenCV to track eyeball movement. I will tell you why in the next post. Now how OpenCV tracks face and eye movements is relatively complex. I do not understand all of it, just enough to make my small eye tracking program work. Pretty much the face detection algorithm scans an image for Haar like Features, and if the image satisfies the condition of having a face, the algorithm further subdivides the face into many categories. For example in a typical face, the eye is darker than the cheek, and so when the algorithm compares the intensities of the pixels that make up the eye and cheek, it finds the difference in intensities and is able to distinguish between the eye and a cheek in a face.
          This is a very watered down explanation of what is *really* happening behind the scenes, and in reality, the face and eye detection algorithms in openCV are clunky at best without proper optimization. So I decided to create  small c++ program that takes in input from a webcam ans tracks the face and eyes in real time. It also superimposes images over the face. Face detection was pretty much straightforward. But the eye detection algorithm required further optimization. How it worked was that it all eyes that it discovered in an image(or video frame) it would store in a array. But the problem was that it detected 6-7 eyes at once! Now I only have 2 eyes(4 with glasses, but that not the point), so I had to make the algorithm pick only two eye objects from all that it had discovered. The optimization that I used was to pick the two eye objects with the largest area, and see how their x and y coordinates match up relative to themselves and the face(This is better explained in the annotated code posted below). After hours of tinkering, I have a created a program that tracks human eyes with movement in all 3 dimensions with ~85% accuracy in real time. It is good enough to start out with, but I figure I will have to do much more of optimization if I want to carry out a certain project(more on this later).
              I have posted the links to the annotated code below which explains how my optimizations work. They are no work of art, but they work satisfactorily. Also here is short video of the eye tracking in progress in real time.


Link to download the folder with code, .exe, classifiers and the other good stuff.

This is not the end......

Saturday, March 12, 2011

Mindstorms liquid dispenser

Greetings

Here is a simple project that I had been working on for quite some time. It is a Mindstorms powered liquid dispenser. Essentially it is a simple liquid dispenser that works on the principal of a diaphragm pump. Here are some pics which will describe the apparatus better than I ever can hope to by writing
Side View

Front View

Rear View

Close up of the water delivery system

        So the principle behind the dispenser is simple. A small compressor is driven directly by two NXT motors, converting circular motion to linear motion needed to compress the air in the compressor( think pistons.) The compressed air gets pushed into an airtight water container via a small rubber tube. As the air gets pushed in, the pressure gets increased inside the container. Now there is a secondary rubber tube with one end inside the water and the other end connected to the nozzle through which water is dispensed. When the pressure inside the container increases, water gets pushed out of the container through the non air carrying tube into the open, via the nozzle. Therefore it is very important for the water container to be absolutely air tight to be able to maintain a constant pressure through expulsion of water.
        The design of the project too is nothing too complex, although it was made to make space use as efficient as possible. In the back, a small rectangular platform houses the water container, secured by two elastic restrainers. Right after that are the two motors in an upright position, directly driving the compressor. The NXT brick is situated right in front of these motors. Finally in the front is the push handle with touch sensor, along with a nozzle. Whenever the push handle is pressed, the touch sensor is also pressed, which causes the NXT to drive the motors, leading to flow of water through the nozzle. The handle returns back in place due to rubber bands. I designed the whole front setup to mimic and actual water dispenser.
        There is not a lot of programming involved in this project. The NXT runs the motors whenever the touch sensor is pressed. However, a lot of other sensors could be used. For example, the motors could start running whenever a cup is placed in the platform, with input provided to the NXT by an ultrasonic sensor. Or using a sound sensor, water could be dispensed by clapping of the hands and stopped again by doing the same. Like the Mindstorms motto, the possibilities are indeed endless!
        I have included links for the code for the NXT down below. There are three different files, one for using a touch sensor as input, the others for using a sound sensor and ultrasonic sensors as inputs. The code in all files is annotated. To compile and run these files, use the nxjc and nxj commands. If you are unsure on how to do this, here is a link that can help you out. As for the model itself, I might upload an LDD file of the model in the near future. In the mean time, you can look at the video below of the Mindstorms water dispenser in action and try to build your own version.




Link to the NXT program with the Touch Sensor
Link to the NXT program with the Sound Sensor
Link to the NXT program with the Ultrasonic Sensor

This is not the end.....

Wednesday, March 2, 2011

The NXT step

Greetings

For a long time, I wanted to use my programming abilities in robotics. I wanted to create a robot and program it myself to respond to stimuli, unlike the pre-programmed ones that were available in the market. This meant that I had to buy motors, PC boards, micro-controllers, switches and sensors independently, assemble them and then program them.  While I searched the net to buy these parts (A lot of companies did not ship to the Middle East, where I used to live), I started getting disheartened because of the nonavailability of the most basic micro-controllers and motors.
                Fortunately for me, Lego and MIT released the Lego Mindstorms Kit. While the NXT-G programming language was sufficient, Visual Programming lacked a certain something that had drawn me to textual programming languages. When the good guys at LeJOS released LeJOS v0.85, I immediately flashed my NXT to that version(The latest version at the time of writing is 0.90, refer to this page to see how to flash your NXT and get the LeJOS environment running on your computer) and began coding in sweet, sweet Java. I had always been fascinated by remote controlled cars, so the first thing I set out to do was to create a program to control my NXT vehicle via input from the keyboard. To do this, I created a small GUI based Java program(send.java) which acted as the control center. The program had a command log, connect, disconnect, shutdown and options(The options button has no functionality currently) buttons, and a text area to receive the input form the keyboard. The program sent commands from the keyboard to the NXT(running rec.java) via Bluetooth. The NXT acts as a slave(The main thread is pretty much stopped from executing, until a Bluetooth connection opens) and waits for input from the computer and acts accordingly. My program works in a simple manner. When I press the top arrow key, the key-code of that key specified by Java is sent to the NXT and the NXT knows to move forward, and so on. The idea is simple in concept, but it does have a few problems. One of the problems is that in this model, the sending of two commands simultaneously is a bit of a hassle. Right now, the robot can turn or move, but not at the same time. One possible solution would be to multiply the key-codes of the two arrows and  return the product as input for the NXT because for the key-codes 37, 38, 39, 40, the product of any two numbers is different from the product of any two other numbers in the set(note that the same cannot be said for addition.) In any case, the program does the work of successfully sending commands to the NXT, albeit not with a lot of options. This is just a test program, and I am working on another one with greater functionality(one that has a working options button!)
                 In any case I will put the files that run on the NXT and on the computer up for download. Please note that to run these files, you should have LeJOS installed on both the NXT and the Computer. The files to be run on the NXT will be called rec.java and the file to run on the computer will be called send.java.Here is what you have to do. Open up command prompt and and navigate to the folder where you have placed the two files. Then type in the following commands:

nxjc rec.java              (compile the rec.java file)
nxj rec                    (upload the rec.class file to the NXT)
Now go the NXT and execute the rec.nxj file. Go back to command prompt.
nxjpcc send.java           (compile send.java)
nxjpc send                 (run send.class, AFTER starting rec.nxj on the NXT)

I have once again annotated the code, explaining how and why it works. Please edit the code, add your own functionality and experiment with it. I am once again releasing the code under the MIT license.  You can use any NXT car creation you want to test out the program, but the model has to turn via a difference in the speeds of the different sets of wheels, like in a tank. I used the 30 minute model from Lego Mindstorms for testing purposes, here is a link to the instructions to build a similar model. You can replace the tracks with wheels if you want. Also, here is a video of the program and the NXT in action.

Here are the links for the two.java files. I have not created any JARs as they are really not needed.

rec.java (On the NXT)
send.java (On the computer)

This is not the end.......

Friday, February 25, 2011

What more can you ASCII for?

Greetings

I am not the artistic type, but that does not mean that I do not appreciate art. While I do like art created by others, I sometimes wish that I too was gifted with artistic abilities. Once again, using the awesome powers of Java, I was able to realize this dream. Using simple Java code, I created an image to ASCII converter program which takes an image and outputs a text file with ASCII characters, which looks like the input image when viewed all at once. In this post I will explain the basic principle behind computer generated ASCII art, and how to implement it using Java. I will release my own code for the program that I built, the program itself and a short video of the program in action. From now on, I will release all my code under the Open Source Initiative (OSI) MIT License (MIT), because the license is clean, short and easy to understand. Before I explain the principle behind ASCII art, here are some of the ASCII art created by the program: 
That's me!!

The Simpsons are ASCIIfied!
p-51 Mustang- A classic

The principle behind ASCII art is easy to understand. An image can be thought of as an 2 dimension array with rows and columns that correspond to the width and height of the image (In reality, it is more complex than that but this is a good enough understanding for the time being). Each cell in this array holds a pixel. When all these pixels are viewed together at once, you get an image. So a 400x400 image has 400 rows and 400 columns, and has 160000 pixels. Now to convert an image to text, the program has to iterate through all the pixels, get its RGB value, convert it to its gray scale value, and append a suitable ASCII character. Java has a class called the BufferedImage class, which has the methods necessary to obtain the RGB values of a pixel. Now once the RGB values(ranging from 0 to 255) of the pixel is obtained, there is a simple formula to convert it to a gray scale value. Simply take ~30% of the Red Value,  ~59% of the Green value and ~11% of the blue value and add them up together to a value ranging from 0 to 255, 0 being the darkest and 255 being the brightest. Don't worry, the BufferedImage class has the necessary methods to obtain these values,which you can see in my annotated code posted below.This value is your gray scale value. Generally gray scale value range from 0 to 1 with decimals in between, but there is no reason for them to be between 0 and 255. You could divide it by 255 to range it from 0 to 1, but why the extra hassle? After obtaining the gray scale values, the creative part begins. As you know, some ASCII characters appear darker than the others. For example, # appears darker than 0.So what the program does is obtain the gray scale value of each pixel, and according to the value, append an ASCII character to the text file. For example, if the gray scale value is in between 180 and 200(very bright), it appends a ".", and if it is 50 and 70(very dark), it appends  a "#". Currently there are nine different ASCII characters that the program chooses from to append. However, I urge you to edit the code and experiment by adding more characters, changing the existing characters, etc. For a detailed explanation, read the comments in my code which explain the function and workings of each method. The results are stored in a file called result.txt, and when viewing the results in a text editor, choose a small bold mono-spaced font, with word wrapping DISABLED. I recommend choosing images not bigger than 600x600 as the task will become more and more resource intensive with bigger images. While the current program does have an area where the results are appended, for spectacular results, open up the result.txt file and choose the best font and size to view the art. I find that Prestige Std Elite and OCR A work really well, almost giving the illusion of colors. This program is only a test, and soon I will be releasing code to a program with better GUI, more options and ultimately more robust. But until then, here is a small video below which runs you through the code of the program and explains how the program works. 


And finally here are the links to the code of the program and the actual program and the Netbeans Project. Please go through the code, experiment with it and hope you learn something out of this.


This is not the end

Aravind Rao