Mohammad

Ardumouse: Arduino Micromouse

Mohammad — Sun, 28 Feb 2010 21:14:53 +0000

Micromouse is an event where small robot mice solve a 16×16 maze. The maze is made up of a 16 by 16 grid of cells, each 180 mm square with walls 50 mm high. The mice are completely autonomous robots that must find their way from a predetermined starting position to the central area of the maze unaided. The mouse will need to keep track of where it is, discover walls as it explores, map out the maze and detect when it has reached the goal. Having reached the goal, the mouse will typically perform additional searches of the maze until it has found an optimal route from the start to the center. Once the optimal route has been found, the mouse will run that route in the shortest possible time.

Here’s an example of how it works:

I was working for last couple of months to build one like this, and finally came up with the the following:

Ardumouse v.1

Ardumouse v.2

Ardumouse v.3 (Final Version)

I’ve been programming it to follow right wall and it worked perfectly:

Ardumouse: Arduino Micromouse – Right Wall Follower
Uploaded by reefat. – Discover more science and tech videos.

Here’s another video that shows how the micromouse sends debug information to a remote computer through wireless:

Ardumouse: Arduino Micromouse – Wireless Debugger
Uploaded by reefat. – Technology reviews and science news videos.

And this the birth place of the micromouse, my bedroom. Don’t mind, it’s a little messy:

Arduino Based Wireless Joypad

Mohammad — Thu, 15 Jan 2009 02:59:55 +0000

I was thinking about designing a Wireless Joypad to control my Robot, and finally came up with an idea to make it out of a cheap Gigaware PS2 Joypad found at Radioshack, which was only $9.99. It has:

2 Joysticks
1 8-way D-Pad (Direction Pad)
8 Action Buttons, and
4 Extra Buttons (Select, Start, Macro, Mode)

So, I was searching on web, how to interface this PS2 Controller with Arduino, and finally found an Arduino compatible library called PSX Library. I used it with my Arduino and it didn’t work. I guess, it didn’t work because this library was for PlayStation 1, but my controller was PS2 compatible. So, I gave up this idea of using any library. It’s the time for me to come up with my own library.

Thereafter, I cut off the PS2 connector along with the long cable. This will be wireless, so why bother with this annoying cable/connector? This time I am not using any circuitry inside the Joypad. The only things I need are the Push Buttons, LEDs and the Joystick Potentiometer. Then I figured out the schematic of the two joysticks:

The approximate value for each Potentiometer is 5.2K. So, those 4 points will be used as Arduino Analog Input ( Pin 1 to 4 respectively). There was not really enough space inside the joypad, that’s why I had to use wire wrap wires to solder the connectors of buttons, potentiometers and LEDs. I was able to solder only 8 buttons, out of all 16; because the other 8 were so compact that they were almost impossible to solder. This 8 buttons and 2 LEDs will be connected to 10 Digital I/O pins on Arduino.

Here’re some pictures of the Modified Joypad, the Arduino board, and the Transmitter and Receiver modules:

I found some reference article on how to interface these RF Modules with Microcontroller. Here they are:

Running TX433 and RX433 RF modules with AVR microcontrollers
KLP/KLPA Module Walkthrough by Sparkfun
Implementing RF Modules

So, I followed the first reference (Running TX433 … …), and it worked without any problem. By the way, that example module was using 4-Bytes Packet Transmission Protocol at 1200 bps. I modified the code for Arduino, and as it worked with 2400 bps (because my RF Modules were little faster, 4800 bps).

My joypad has 2 joysticks and each of them has 2-axis (X and Y). So, it gives 4 analog inputs to the microcontroller and each input has a resolution of 1024 (0 to 1023), which requires 2 byes (integer) for each. And 2 joysticks needs 8 bytes (4 x 2 bytes). The 8 push buttons can be represented as 1 byte (1 bit for each button). The data transmission packet itself has 1 Synchronization byte, 1 address byte, and 1 Checksum word (2 bytes). So the length of the complete packet is 13 (8+1+1+1+2) bytes.

This time my code went real crazy. I tried to keep it clean and well-commented almost everything I could. As there are two separate circuits: the transmitter (joypad itself) and the receiver (Arduino Duemilanove); so there will be two separate scripts. But, I made the WirelessDataPacket class common for both. Here are both sketch source files:

Transmitter Sketch Source

Receiver Sketch Source

Everything was working cool when I was using 4-Bytes Transmission Protocol (as mentioned in the example reference). But when I am using 13-Bytes Packet, it became a lot slower and more than 50% (approximate) data is losing at the time of transmission.

I calculate the speed this way,

2400 bps = (2400/8) bytes per second = 300 Bps

300 Bps = (300/13) packets per second = 23 pps

Arduino uses 16.0000 MHz crystal (instead of 9.216 or 11.0592 or 18.432 MHz etc.) which can produce 0.1% error (ref: AVR BAUD Rate Calculator). And including some other circumstances (hardware+software) 5% error is acceptable. But for my case, the error rate is so huge that the transmission is breaking up and becomes too much slow. I guess, this can improve if the BAUD Rate of the RF Modules can be improvised and some other programming technique (which I don’t know yet) can me implemented.

Differential Drive Robot – ver.2

Mohammad — Sun, 21 Sep 2008 02:49:35 +0000

Hi everyone, this is the improved version of my previous Differential Drive Robot. I didn’t think about any name yet; but will figure out one soon. Anyway, this improved prototype has an IR Rangefinder attached to it which can detect distance of any object in front of it within a range of 10cm to 80cm. And an extra servo is added to this new version to rotate the sensor left or right. Let’s take a closer look at the new prototype.

Whenever the robot faces an obstacle in front of it, it looks left and right, and thinks about which side has enough space to go for. Then it turns to that side and moves forward. Check out the following video to see how the robot moves.

My First Differential Drive Robot – ver.1

Mohammad — Tue, 16 Sep 2008 22:32:43 +0000

I think, I am running too fast. After building the ATmega motherboard, I didn’t take more than 1 day to build the whole robot. This was just for testing purpose (not even experimental; you can say pre-experimental). At this very moment, I didn’t have any mechanical tool to build up a nice-looking handsome robot. I just got a box came with my NiMH battery charger, and just convert it to the chassis of my very first robot. Here is a close shot of my ghetto bot:

The only task I assigned (programmed) to it was avoiding obstacle. Meaning, it can detect stuff ahead on its way, and avoids those roadblocks. Very simple, isn’t it? This is enough as the first program. I have some other plans to work with. And I will keep posting about my baby robot. So stay keep-in-touch and don’t forget to check the video:

ATmega AVR Development Board

Mohammad — Sun, 14 Sep 2008 22:26:16 +0000

Today I have just completed building the brain of my Robot, the MCU Board using ATmega8 AVR Microcontroller. This MCU Board can be powered by 6V Adapter or 5 1.2V NiMH Rechargable Batteries. ATmega8 AVR runs on 5V, and thet’s the reason I used National Semiconductor’s Low Dropout Voltage Regulator LM2940T.

For programming the AVR, I am using AVRISP mkII In-System Programmer and AVR Studio Development IDE. The MCU Board has two I/O Ports – 8-Bit PORTD and 6-Bit PORTB, and 6-channel ADC. For PORTD and PORTB headers, the Vcc can be selected as either 5V or 6V, using the two yellow jumpers (red-marked). The board also provides 5V output headers to power up external device(s).

Supported AVRs: ATmega8, ATmega48, ATmega88, ATmega168.

Analog to Digital Converter Demo – Sensor Interfacing

Mohammad — Fri, 22 Aug 2008 22:04:58 +0000

This is a simple demo for Analog to Digital Converter. Here I am using National Semiconductor ADC0804, which is a very common 8-bit A/D Converter, compatible with any 8-bit Microprocessor or Microcontroller. In this project I am using a CDS Photocell as an Analog Sensor which is the primary input for the ADC. Based on the input voltage on Pin 6, ADC converts it to digital signal which is an 8-Bit data between 0 and 255. This 8-bit data is then passed through these 8-lines and captured by the USBMicro Interfacing Device, which is plugged into my laptop. This USBMicro is very useful for I/O interfacing through the USB port.

Download VB.6 Source ADC-Demo-VB.6.zip
Download VB.NET Source ADC-Demo-VB.NET.zip

The First 8051 Microcontroller Project – LED Blinking

Mohammad — Wed, 20 Aug 2008 21:22:18 +0000

The first “Hello World!” project I prefer for Microcontroller is LED Blinking. I have used ATMEL’s 89C51 (40-pins DIP) 8051 architecture microcontroller which is ideal for first time learning MCU Chip. I used my previously made 5V Regulator to supply uninterrupted regulated DC voltage. The program is very simple and straight forward, that uses a delay procedure that loops for 255 x 256 = 65536 times and produce loop based software delay.

		org		0000h
loop:
		mov		b, #0FFh
		acall		delay
		clr		p1.0
		mov		b, #0FFh
		acall		delay
		mov		p1, #0FFh

		ajmp		loop

delay:
		djnz		acc, delay
		mov		acc, #0FFh
		djnz		b, delay
		ret
end

Simple 5V Regulated Power Supply For Digital Circuits

Mohammad — Wed, 20 Aug 2008 21:09:40 +0000

This circuit is a small +5V power supply, which is useful when experimenting with digital electronics. Small inexpensive wall adapter with variable output voltage are available from any electronics shop and supermarket. Those adapters are easily available, but usually their voltage regulation is very poor, which makes them not very usable for digital circuit experimenter unless a better regulation can be achieved in some way. The following circuit is the answer to the problem

This circuit can give +5V output at about 150 mA current, but it can be increased to 1A when good cooling is added to 7805 regulator chip. The circuit has over overload and thermal protection.

I have just made one which you see in the picture above where I have added two header pins so that it can be easily plugged onto a solderless breadboard.

Rotary Camera Using Stepper Motor

Mohammad — Thu, 14 Aug 2008 20:43:20 +0000

This is a simple stepper motor controller which rotates a small wireless camera attached to it. This uses the same circuit of the previous project. The only difference is that the camera moves only if the Right or Left arrow key is pressed from keyboard. In the previous project the stepper motor used to rotate anti-clock wise. Here I change the code little bit to rotate is clockwise. I just simple reversed the step sequence. So for clockwise rotation the step sequence is:

STEP-1 0001 5STEP-2 1001 4STEP-3 1000 6STEP-4 1010 2STEP-5 0010 10STEP-6 0110 8STEP-7 0100 9STEP-8 0101 1

Here I used a wireless camera which sends A/V Signals at 2.4GHz frequency and on the other hand, the receiver receives it sends it to PC as video streams using an additional USB Capturing device named EasyCap.

The video capturing program is written in VB.NET using a 3rd Party Class names iCam which uses avicap32.dll to work with the video captured by the camera.

Here is the live demonstration of this project:

Stepper Motor Demo

Mohammad — Thu, 14 Aug 2008 19:51:08 +0000

This is my first stepper motor project where the I have used NIPPON PF35T-48L4 unipolar motor which I controlled from a PC through the Parallel Port (LPT1, DB25). I simply used a ULN2003A IC which uses 7 Darlington Transistor Array to amplify the input current comming from the port. This 16-pin IC is capable to take TTL input and the output load may have high voltage upto 50V. I wrote small program in Visual Basic 6 using inpout32.dll driver.

Here is a screenshot for the unipolar stepper motor and the driver IC ULN2003A:

It is recommended to connect a 6.2V zener diode between the power supply and VDD (Pin 9) on the chip, to absorb reverse (or “back”) EMF from the magnetic field collapsing when motor coils are switched off.

To rotate the motor anti-clock wise, the step sequence sent to the parallel port is as follows:

STEP-1 0001 1STEP-2 1001 9STEP-3 1000 8STEP-4 1010 10STEP-5 0010 2STEP-6 0110 6STEP-7 0100 4STEP-8 0101 5

Here is the live video of how the motor rotates: