Posts tagged ‘Electronics’

Introducing the_stalker: controlling a camera using Dwengo

I finally found time to play with some electronics again this weekend, so I decided to dismantle my old camera and try to control it from my Dwengo board. A simple plan, so let’s go ahead! The camera is a cheap Aiptek DV3300 camera / camcorder which was my trusted companion for many years and with which some of Overimpe’s best underground heist, crime and weird psychedelic space-time-travelling movies were shot.

First I had to disassemble the camera, which went fairly easy (some screws and some careful pulling here and there). Once inside the camera, I saw that the plastic buttons on the outside just pushed some standard pushbuttons on the inside. After measuring the voltages when pressed / released, the various buttons seem to just pull a line to ground upon being pushed.

Because the buttons are placed fairly close to each other, and my soldering skills are a bit rusty, I decided to start with just controlling two buttons: the power switch and the shutter button. This would allow the microcontroller to start the camera, take a picture (or record a video), and power off the camera. So I soldered two wires to the buttons, put a big blob of hot glue on it (see picture below) and guided the wires to the bottom of the camera, where I could make them come out of the camera through the removed screw of the tripod.

Below you see the re-assembled camera, with some wires coming out of it at the bottom.

And below is the entire test setup. The Dwengo microcontroller board on the right listens on a serial interface (connected to a laptop) for commands telling it to power on the camera and to start recording. Once these commands are received, a pin on the PIC microcontroller is pulled HIGH. This pin will make a transistor go into saturation and connect the camera line (power or record) to ground for a few seconds. This simulates a button on the camera being pushed.

For those interested, the breadboard layout is shown below (click on it to open a larger version). I only included one line in the schema, because the second line is basically the same circuit duplicated. More information about how the circuit works can be found on this excellent site.

And a video as final proof that it works ūüôā

The code can be found on github. It is really, really ugly code though, because I had a LOT of problems getting it to run ok (I think something is wrong with my Pinguino bootloader). The code will be cleaned up in future commits though.

The next steps for this project will be to move from a breadboard to a soldered circuit and maybe use Bluetooth instead of a serial cable. I think in the end I will try to embed the circuit in a bird-house in my garden to spy on those shady birds, and trigger the video recording with a motion detector (when a bird enters the house). I’m not sure about that yet though, any ideas are welcome ūüôā

PS: Thanks to the Dwengo people who gave me a free Dwengo starterkit plus as a gift in appreciation of my blog! So if you do a cool project with the Dwengo board, be sure to write about it ūüėČ

July 11, 2011 at 10:16 pm 1 comment

Creating a custom Fritzing part for the Dwengo board

A problem I always have with my robots is they end up as a messy spaghetti monster with lots of wires leading to hidden places on the robot. When (purely hypothetically) the robot bumps into a wall some wires get loose and I have to figure out what was connected to what again.

I should keep some documentation on my robot. I wanted to do this with Fritzing, a cool open-source program for drawing breadboard-prototypes and more. Lots of parts are already available in Fritzing, like an Arduino, a servo, chips, and so on. As the Dwengo board was not yet available as a Fritzing part, I created it myself.

A Fritzing part is composed of SVG vector graphics: one for the breadboard layout, one for the schematic layout, one for the PCB layout, and one for the icon. These graphics can be created in InkScape. I never worked with InkScape before, so I had a hard time drawing the breadboard layout. The easiest way to create the layout was to take a photograph of the board, then import that in Inkscape, and draw over it. I reused the svg images from the existing Fritzing core parts to create the final layout.

Because Fritzing has to know which part of the image is a connector where wires can start and end, one has to create connectors. This is done by creating rectangles with the names connectorXterminal and connectorXpin (where X is the connector number). In the schematic and PCB layout, the same connector have to exist with the same name. This way, Fritzing can keep the three layouts in sync, so if you create a prototype in the breadboard view, you immediately get a schematic view and a PCB view.

For the SVG files of the schematic view and the PCB view, I started from a header row (for the schematic view) and from a regular chip (for the PCB). Once these were done, I created the part in Fritzing:

In the parts editor, you can label all the connector pins and give them a description. You can also add and remove connectors if necessary. As you can see from the image, I created connector pins for the Dwengo connector on the left, and for the driver chip output on the right. The pin labels mention the PIC pin number and the corresponding Pinguino pin number (see https://kr3l.files.wordpress.com/2009/12/pinguino.gif).

Download the Fritzing part.

Now that the part is created, the fun can start :-). It only takes about 5 minutes to redraw my robot schematic in Fritzing. One problem I had was that the Bluesmirf component doesn’t exist in Fritzing, but I used a “mystery component” with 5 pins instead. The resulting prototype is shown below:

As you can see, this is a nice and ¬†easy way of creating a breadboard prototype of your project.¬†You can download this diagram from its Fritzing projects page. Fritzing features a lot more cool features, like automatically create a parts list, create an etchable PCB layout or Gerber files as a Pdf, …, which help you in sharing your project with others and in going from a prototype on a breadboard to a real product on a PCB!

January 8, 2011 at 10:10 pm 4 comments

Using Android as robot remote control

The flea market car / robot saga continues… Controlling the robot from my laptop via Bluetooth was cool
, but running after the robot with the laptop in my hands kind of diminished the James Bond – feeling of it. Therefore, I decided that my first application I would create for my brand new Android smartphone would be a remote control for the robot!

Luckily, the online developer information (available at http://developer.android.com), provides a wealth of information for getting started. What was more, I actually found a sample application there, called BluetoothChat, that almost did exactly what I wanted to do. The BluetoothChat application makes a connection to a Bluetooth device (this will be the robot) and it allows to send text to it once connected (the text will be the robot commands).

Google provides a complete development environment for developing Android applications, which can be downloaded at http://developer.android.com/sdk/index.html. Just follow the instructions over there to install the platform and create a “hello world” application. Connecting your phone over USB to the development computer allows you to debug / run the application on the phone. On my Ubuntu laptop, I have to restart the adb server as root after connecting the phone via USB:

(while in folder /android-sdk-linux_86/tools)
./adb kill-server
sudo ./adb start-server
./adb devices

Now let’s skip to the application. I wanted to change a few things to the BluetoothChat application:

  • actually get it connected to a Bluetooth device, because this wasn’t working right away.. ūüė¶
  • after connecting to the robot over Bluetooth, I wanted to automatically start my PING – PONG handshake (Android says “PING” and the robot answers with “PONG”, which indicates the connection is established¬†successfully¬†and the robot should start listening for commands)
  • Instead of typing the commands in the text field I wanted some big buttons (forward, backward, left, right, …)

Connecting the BluetoothChat example to a Bluetooth device

I first tried connecting the BluetoothChat Android application to Bluetooth on my laptop, but it didn’t work. Whatever I tried, I always got a “service discovery failed” exception on the following line of code in BluetoothChatService.java:

tmp = device.createRfcommSocketToServiceRecord(MY_UUID);

After a long time trying to solve this, I found this site, which suggested to change the line of code to this code:

Method m = device.getClass().getMethod("createRfcommSocket", new Class[] {int.class});
tmp = (BluetoothSocket) m.invoke(device, 1);

And this worked! Also, note that you have to connect at 57600 baud to the Android Bluetooth.

Do a handshake once connected

Once connected to the BlueSMIRF on the robot, the following should happen:

  • Android sends “PING\n” to robot
  • Robot receives this and sends “PONG\r\n” to Android
  • Android receives this, and knows the connection is succesfully established.
  • Now Android can send commands like “D,70,1” to set the servo to 70¬į and the drive motor to forward motion.

I changed the run() method of the ConnectedThread to do the handshake once connected: see code.

Big buttons that send commands to the robot

And now for the fun part.. I wanted to change the layout to have nine big buttons which would send the robot in a certain direction:

I used the example at this site to create the big button layout. Once a button is pressed, it will send a command over Bluetooth to the robot which will make it ride in that direction:

        mBRButton = (Button) findViewById(R.id.button_br);

        mBRButton.setOnClickListener(new OnClickListener() {

            public void onClick(View v) {

                // Send a message using content of the edit text widget

                String message = "D," + right + "," + backward + "\r\n";

                sendMessage(message);

            }

        });

And now a little movie to prove that it works!

The source code can be downloaded here.

edit: latest version of code is now available via https://github.com/kr3l/rommelrubot

 

September 4, 2010 at 5:18 pm 14 comments

Time for a new steering system

My last post was about putting Bluetooth in a flea market toy car in order to control it remotely from my laptop. One problem I had with the car was the amount of current it drew. Unexpectedly, it turned out to be the steering that drew most of the current. I thought the steering was done by a servo motor, but apparently they put a regular DC motor in it to turn the weels. A piece of plastic stops the turning and basically the motor stalls everytime you steer, and so draws the maximum amount of power..

To reduce the power-demands of the car I cut out the steering DC motor (and all the plastic around it) and glued in a servo.

Now to make the servo turn the weels, I used some good old Lego bricks. The flat one with the dents is glued to the thing that used to make the weels turn. Than I used a gear wheel glued to (God, I love hot-glue!) the servo, which makes the flat brick move. Because the servo sometimes turns too much (it’s a cheap one so not always that accurate), I cut most dents from the gear wheel. This assures that no damage is done if the gear wheel turns too much..

August 15, 2010 at 9:34 pm Leave a comment

Putting Bluetooth into a flea market toy car

On the flea market here in Ghent a few weeks ago, I bought myself a toy car with a wired remote control. Feeling destructive, I immediately removed the hood of the car, opened up the remote control and measured how the car could be controlled. It turns out there are four wires from the remote to the car. Two of them control the forward / backward motion by setting 5V or -5V across them. The two other wires control the left / right motion of the front wheels, again by setting 5V across them.

Next I soldered header pins to the wires of the car so I can control them through the L293D driver chip of my Dwengo board. Next I added the Bluesmirf module (as explained in a previous post) and taped everything together using Duct tape.

After some programming and some tweaking (putting the battery pack above the steering wheels so they have more grip) I got my car driving across the appartment ūüôā

edit: latest version of code is now available via https://github.com/kr3l/rommelrubot

May 29, 2010 at 8:39 pm Leave a comment

Using Dwengo board as a Pinguino

The Pinguino project is a relatively new project that tries to build an Arduino-like project with a PIC processor. The project comes with a nice and simple IDE and a bootloader so programs can be placed on the PIC very easy.  I found the Dwengo board I own is compatible with the Tiny-4550 Pinguino board, so it is possible to use the Pinguino IDE and bootloader with the Dwengo board. 

Here are the steps I followed on my Ubuntu (Karmic) machine to get things fired up:

  • Install wxPython as explained here
  • Download the latest Pinguino IDE from the hackinglab dowload index. Extract the archive. Run the IDE by running the pinguinobetax.py Python script from the terminal. Put sudo before it to run it with administrator rights, because otherwise you’ll get a ”Could not change device” error! The IDE looks like this:

  • With the PIC18F4550 we need the second version of the bootloader (see Pinguino tutorial site). It can be dowloaded here. To put the bootloader on your PIC, I used xwisp, which is a Windows program (I ran it in a Virtualbox virtual machine).
  • Once the bootloader is on your PIC, connect your board via a USB cable to your PC. Hold the reset button and the “up” button on your board, then release the reset button. The bootloader program knows you want to place a program on it now.
  • Open up the Pinguino IDE and type e.g. this program in it:
// Testing input with Pinguino
// jean-pierre MANDON 2008
// modified kr3l for DWENGO
#define PIC18F4550
void setup() 
{
pinMode(0,INPUT);         //button
pinMode(21,OUTPUT);    //led
}
void loop() 
{
if (digitalread(0)) digitalWrite(21,HIGH);
else digitalWrite(21,LOW);
}
The pin numbers used here are as in the Tiny-4550 schematic:
so pin 21 as used in the program is actually pin 19 of the PIC processor.
  • press the compile button, then the “put program on pinguino” button. The program starts running after a few seconds. If you press the center button one of the leds will go off.

I think the Pinguino project is a really cool initiative and I hope they keep working on it. More experiments will be conducted soon!

December 31, 2009 at 3:35 pm 1 comment


Feeds

Articles to be written…

Twitter – kr3l

my del.icio.us

RSS Google Reader Shared Stuff

  • An error has occurred; the feed is probably down. Try again later.

RSS Listening to..

  • An error has occurred; the feed is probably down. Try again later.