I used the motor control and optical encoder stuff from my plotter to control it for the video.

Here’s a video of what I’ve got so far:

The movable part slides up and down a pair of stainless steel rods. There’s a bit of slack, but that might go away when I tighten everything up properly.

The X and Y axes will use skate bearings on aluminium angle.

This is my latest project. Converting a broken Brother MFC-425CN into a small plotter. I used the paper feed mechanism and the printer head with the optical encoders and stripped everything else out of the printer. There are a lot of gears and stuff that are used for cleaning the print heads and pumping away ink. There’s also a second paper feed for picking up the next sheet of paper from the paper tray these prevent the motor from running the same speed both ways.

The up/down movement of the pen is controlled with a small solenoid. Black tape and copper wire are used to hold everything together. The rubber band is to stop the pen jiggling.

A PIC18F2550 decodes the optical encoders to detect which way they are moving and keeps a track of the absolute position of the head and paper feed. The origin is the position everything is in when the usb plug is inserted. There’s a IR and photo diode underneath the print head that the printer uses to detect the paper.  I should write a routine to find the position of the corner of the paper and set this to the origin every time a new program is run.

One of the optical encoder was acting up. Based on the PCB from the printer I should have been able to use a pair of 10K pull-ups and put the outputs directly into the microcontroller. I should have measured the voltage at a few points on the original PCB while it was running before I destroyed it. I’m always too quick to destroy stuff. Another problem with the encoders is quickly decoding the position. When things are moving too quickly the microcontroller can’t keep up.

Driving the motors is done with a pair of h-bridges I built for a different project. These aren’t shown in the schematic because they aren’t very good. I’m might get a pair of motor driver ICs.

The computer software loads a G-Code file and sends movement commands to the plotter. The plotter sends back it’s new position at the end of each command. This lets the computer know when it can send the next command. The software uses the RS274NGC G-code interpreter.  This can be downloaded from http://code.google.com/p/rs274ngc/, it makes using G-Code a lot easier. I wasn’t sure how to handle the Z-Axis because the solenoid only has two positions, up and down. So it takes positive values as down and negative or zero values as up.

There’s a bit of pixelation in the drawings. It’s really difficult to keep the speed of the motors constant. If I try to use PWM on them they whine and wont move.

Printers are a great source for parts. This printer had

• 2 DC motors
• 2 stepper motors
• A rotary and a linear optical encoder
• ~10 photo gap detector thingies
• A 350×6mm stainless steel rod
• Lots and lots of springs
• Nylon gears
• 2 belts
• A 30v DC power supply
• A phone keypad that shouldn’t be two hard to separate from the rest of the electronics

All for $1.

I’ve got another two almost identical Epson printers. I want to use the parts from those to make a simple CNC machine for my next project. Next up for this project though is creating a PCB and tiding everything up.

It’s based on http://robseward.com/misc/RNG2/. The voltage is read using the ADC on a 18F2550 and the bits of the voltage are XORed together to create a single random bit. Von Neumann’s algorithm is used to remove bias which reduces the number of bits by 4 times, I’m not sure if this is necessary I’ll check it out tomorrow. The resulting bits are saved up in a buffer and then sent to the computer over usb. The digital to analog conversion really slows things down. I’m getting about 500 B/s. I might see if I can do it digitally.

Here are the results on 12MB of random data that took over 6 hours to generate.

http://www.cacert.at/cgi-bin/rngresults

I’m not sure why it came close to failing that one test. It’s listed as “Potentially deterministic”.

This is the schematic I used:

Schematic

And the relevant part of the code:

if(currentbyte < 64)
{
  randompair = 0;

  if(currentbit == 0)
    USB_Out_Buffer[currentbyte] = 0;

  for(i = 0; i < 2; i++)
  {
    Delay10TCYx(10);
    ConvertADC();
    while( BusyADC() );
    randombit = ReadADC();

    for(j = 1; j < 10; j++)
      randombit ^= (randombit >> j) & 1;  //Messy, the assembly created to do this is too long.

    randompair <<= 1;
    randompair |= randombit & 1;
  }

  if(randompair == 2)
  {
    USB_Out_Buffer[currentbyte] |= 1 << currentbit;
    currentbit++;
  }
  else if(randompair == 1)
    currentbit++;

  if(currentbit == 8){
    currentbit = 0;
    currentbyte++;                    
  }
}

if(mUSBUSARTIsTxTrfReady() && currentbyte == 64)
{
  putUSBUSART(USB_Out_Buffer, 64);
  currentbyte = 0;
}

Don’t try and port mcc18 code to hitech’s pic18 compiler. I tried without any success even trying to use examples other people had ported didn’t work at all.

Instead use Microchip’s MpLab C18 compiler under wine. Wine is a wrapper that lets you run Windows programs in Linux. Install wine using your package manager. There are some How To’s on the net for getting the c18 compiler to work with wine but I think they are old and they have many unnecessary steps. All I needed to do was install arial32.exe(search Google, download, right click “Open with wine…”) and download and install the latest MpLab C18 compiler.

When you select the C18 compiler in piklab use “configure toolchains” to tell piklab where to find everything. These are the paths I used:

Executable Directory :~/.wine/dosdevices/c:/MCC18/bin/
Header directory :~/.wine/dosdevices/c:/MCC18/h/
Linker directory :~/.wine/dosdevices/c:/MCC18/bin/LKR/
Library directory :~/.wine/dosdevices/c:/MCC18/lib/

Under “Configure compilation” there are a few things to change. piklab thinks the linker files for mplink are called <devicename>.lkr. To fix this change the linker configuration to Custom then change %LKR_NAME to %DEVICE_g.lkr.

The linker also needs _CRUNTIME defined so that it includes the correct libraries. Not sure why this isn’t defined already. Look in the .lkr files to see what I mean. You get errors like this if it isn’t:

Error – could not find definition of symbol ‘FSR2L’ in file ‘./mouse.o’.

Anyway just add /u_CRUNTIME to the linker parameters.

The usb examples that come with the Microchip Applications Library require a few extra c files to be compiled before they’ll run. If you don’t include these you’ll probably get an error like this:

Error – could not find definition of symbol ‘USBDeviceTasks’ in file ‘./mouse.o’.

They should be in

/home/<username>/.wine/dosdevices/c:/Microchip Solutions/Microchip/Usb

Just copy the relevant files into your project directory and add them to your piklab project.

If you try to compile one of the usb examples for the 18F2550 the HardwareProfile.h file wont find a demo board it can use. I renamed “HardwareProfile – PICDEM FSUSB.h” to “HardwareProfile.h” and got rid of all references to Port D.

If you’ve gotten this far you should be able to build the project and program your micro-controller. The pickit 2 programmer included with piklab doesn’t seem to work. I do get this warning saying it might not:

Connecting PICkit2 Firmware 2.x on USB Port with device 18F2550…
Firmware version is 2.32.0
The firmware version (2.32.0) is higher than the version tested with piklab (2.10.0). You may experience problems.

Instead I use pk2cmd. You can set up Piklab to program your chip using pk2cmd by selecting “Custom Programmer”

I hope this info is helpful to anyone else. If it is let me know.

Here’s a pic demonstrating it working. A 300w power supply being used to light an LED

It really isn’t that difficult. I followed the guide to make it here:

http://www.wikihow.com/Convert-a-Computer-ATX-Power-Supply-to-a-Lab-Power-Supply

The motors are controlled using two h-bridges. I’ve used BD139 and BD140 transistors. They can handle a continuous current of 1.5A. That will be enough for the toy motors I am using.

A PIC16F505 Microchip microcontroller is the brains behind my robot. It’s a pretty limited chip. It has room for 1024 12-bit instructions and 72 bytes of RAM. I’ll replace it once I need some extra functionality. I started writing the code in C but I had lots of problems with it. Certain math functions seem to freeze up and I kept getting confusing errors. So I’m re-writing it in assembly using gputils.

As you can see, there isn’t much to it. Eight transistors to control two motors with a few diodes and resistors and the microcontroller. The container has lots of room to add a big PCB later. In the top right corner you can see a capacitor with the battery leads connected to it. That’s the power switch. When I want to turn it on I plug that into the breadboard. It’s a bit crude, I’ll probably plug it in the wrong way or in the wrong place and fry everything knowing my luck.

I have a few plans for this little robot in the future. I want to give it more brains than any lunch box should ever have. It’ll be able to create maps and mark locations of interest. I’ll attempt to make it appear curious so when it finds something it hasn’t seen before it will keep going back until it isn’t new anymore. Hopefully I’ll make more than one and have them communicate via beeps or flashy lights. Then they can follow each other around and have twice as much fun.

I also want it to be able to recharge itself by homing in on a charging station that sends out a beacon.

I only had a 8-bit “random” number generator when I videoed this. So It repeats itself twice in that short time.

Our robot was too slow and the gearbox fell apart during one of the six events. It was also the event that ours was going to do well in. Line following a spiral in and out. We made it half way. Only one team completed it properly. It’s a pity.

These robots are really really dumb. All the can do is crudely follow a line and back up and turn when they run into an obstacle.

I think our robot was the best looking. It has personality

• Heart rate monitor, using IR light to detect pulse. I’m not sure how well this works yet.
• Logging to a microSD card. They are really cheap now, a 2GB card would store a lot of stats I imagine. The FAT file system isn’t too complex and it means no fancy software is needed to capture the log.
• Output via morse code, if I don’t need to take it out of my pocket to get the time I shouldn’t lose it.
• Cycling cadence and speed.
• Tactile output, silent.

I’ll probably be building it in this order. So by the end of the week I should have some photos and oscilloscope screen captures showing something that resembles a pulse.