Stepper motor controller shield

January 10, 2014 Leave a comment

If you need to control some stepper motors for a 3d printer or a CNC machine, you need a stepper motor driver. Usually, these come with parallel port connectivity and if you don’t have a parallel port on your PC or you want to drive your CNC machine from a Raspberry Pi, then you have the choice of either using a USB to parallel adapter, or you can use a microcontroller.

A friend purchased a chinese stepper driver based on the TB6560 and needed a way to run the steppers from an arduino, so I made a shield for this purpose.

 

 

The design is made in Eagle using the pinout information of the stepper driver from this website.

You can download the schematic and board here.

Arduino powered quadruped update

January 8, 2014 Leave a comment

Long time no see…

I should have written this a long time ago, but things have gotten in the way…

The arduino quad has come a long way since my last post, it’s built and it has gone through a couple of circuit revisions and software variants. I had a lot of problems on the way and I still haven’t fixed most of them.

Anyway, I decided to build it from FR4 which is PCB reinforced fiberglass. I love to build using this material because it’s very strong but still a bit flexible. The disadvantage of course, is the fact that you have to etch the copper off the board before you cut it and a lot of fiberglass dust is created when working with FR4 and that’s not really good for your health.

On to the build

Having a 3d model of the quad made in Solidworks, I made the drawings and printed them out to scale, then cut out the paper parts, marked them on the FR4 and used a coping saw and a dremel with a thin cutoff disc and abrasive cylinders to make and finish my parts. This took about half a day. I went through about 5 coping saw blades because the dremel made a lot of fine dust which made a mess but the saw made courser particles and they were easier to clean up, plus, there’s a smaller chance to screw up with the saw going slowly.

I assembled the servos on to the parts using the screws that came with them and the circular horns. No issues here.

Electronics

I designed the shield for the Arduino in Eagle and made a few mistakes, for example not taking into account the length of the servo wires. I just put all of the headers in a line and some of the wires were stretching a bit when the legs were fully extended.

Another mistake was the method used to supply 5v to the servos. I hadn’t expected them to need more than 1.5A. Biiig mistake. I only put a 7805 voltage regulator on the shield with a big heatsink and, obviously, it didn’t last more than a few seconds. After reading some posts online about supplying power to a lot of servos I found that due to their design, you can’t put more 7805s in parallel because one of them will take most of the load, so basically I had to choose between a UBEC, which is basically a switching regulator, and no regulator at all. The problem with the UBEC was that I didn’t have one and 6 amp UBECs are over my budget, but this would be the most efficient way to get the power down from the LiPo’s ~8V to the 5V I needed. So I decided to take a risk and go without a regulator hoping that 12 servos would cause a big enough voltage drop to not cause problems. Baaad idea! Apparently servos don’t run without smoke in them, and as soon as one of them let the magic smoke out, I decided that I needed another solution to my voltage problem.

After a couple of weeks of pondering whether or not to buy a UBEC, it dawned on me that it would be possible to use a voltage regulator for each of the four legs thus each regulator would have to supply only three servos. The second version of the shield included a header for a Sparkfun Bluesmirf Silver bluetooth module which would allow me to send commands to the quad from a phone or a PC. Naturally, I didn’t account for the thickness of the heatsinks that would be mounted on the 7805s and I had to unsolder two of them, mount them on a single heatsink and run wires to the board… oh well. At least now I have a good power supply (even though some decoupling capacitors would have been a good idea now that I think about it).

Moving on to the main problem of this quad.

The jitter

The jitter is strong in this one… Due to the fact that I’m not using PWM pins on the Arduino because there aren’t enough, after a lot of googling, it turns out that arduino can’t supply a constant signal to the servos and this results in twitching of the servos. Basically, every 20ms you send a high signal to the servo.  The time you hold the signal high determines what angle the servo goes to. The problem is that the arduino isn’t able to produce signals of consistent width. It’s either this or the cheap servos. Or both. If it’s the servos, I’m scrapping the project. Because of this, I haven’t really concentrated on the gait program, the only thing I did was the inverse kinematics.

 

After thinking things over, my conclusion is that dedicated servo hardware is needed. So i found the PCA9685 (datasheet) which is a I2C bus PWM LED driver with 16 channels and 12 bit resolution. This means that I only need two arduino pins to control all of the servos and I can add a few more for sensors or something. By the way, if this fixes the parkinsonian behaviour of my bastard four legged child then I will consider replacing the arduino with a Raspberry Pi which opens up a whole new world of possibilities.

I got the idea to use the PCA9685 seeing that adafruit made a servo driver with it. Because shipping would cost more for me than the board, I ordered the chip from Mouser and plan to use it in the third version of the quad shield using the schematic from the adafruit board. I found it only in a SMD package so this means the quad will get its first double sided PCB. I started designing the shield on circuits.io but before being able to complete it something went wrong and now I can’t edit it nor view it. Half a day down the drain I think.

The third version of the shield will have the PCA9685, two additional servo headers, the bluetooth module header, and if I have room, a voltage divider for measuring battery voltage.

Arduino powered quadruped

October 31, 2012 1 comment

I’ve been meaning for a while to design a quadruped robot and I finally decided to get to work. As soon as I get my hands on some servos the build will commence. Here is a rendering of how I hope it will turn out. The frame and legs will be built out of PCB fiberglass with the copper etched off or out of laser cut plexiglass. Power will be supplied by a 2S 7.4V 1000mA Li-poly battery. The design is for 12 micro-servos which I hope I’ll get from hobbyking.com in the near future.

As soon as I get around to it, I’ll post the Arduino PCB shield schematics and board in Eagle.

Categories: AVR, electronics

Car alarm remote control repurposing

October 27, 2012 1 comment

A while ago, I got hold of a car alarm unit and its two remote control fobs. When i hooked it up to 12V I realized that it didn’t  work, not responding to any of the commands from the two fobs even though their batteries were OK. Naturally, I opened up the unit to start harvesting parts and noticed the RF module within (the one that sticks out perpendicularly ) and I figured it shouldn’t be too hard to use the module with an Arduino.

Basically, my code uses pulse in to see whether incoming pulses are longer than 1000 microseconds and if a pulse is longer than that I consider it a ’1′ and if it’s not, a ’0′. So it constructs a string called ‘codein’ about 75 characters long and then it searches for 25 character pre-defined strings within it (using the substring command) , to see whether a button has been pushed on one of the remotes. If a button push has been recorded then it prints out which one over the serial connection. Oh, and I was lucky and discovered that each remote delivers different codes, meaning that I am able to remotely control 8 channels.

To figure out which codes you need to pre-define for your buttons you can un-comment the lines which display the incoming string. So here’s the code:

// RF module receiver code for Arduino.
// The module is connected to the Arduino havin 3 pins: +5, GND and data. The data pin is connected to
//digital pin 11 on the arduino.

int inpin = 11;
 int onoff = 0;
 int i=0;
 String codein="00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";

//there are about 100 zeros in the initial codein

unsigned long duration;
 void setup()
 {
 Serial.begin(9600);
 Serial.println("setup");
 }

void loop()
 {

for (i = 0; i < 100; i++) {

duration = pulseIn(inpin, HIGH);
 if (duration > 1000)
 {
 codein.setCharAt(i,'1');
 }
 else {
 codein.setCharAt(i,'0');
 }

}
 Serial.println(codein); //uncomment these two lines to figure out your remote codes
 delay(1000); // this is the second line
 for (i=0; i<75; i++){
 if (codein.substring(i,i+25)=="0010100111000110001010000") // substitute remote codes here
 { Serial.println("lock!!!"); if (onoff == 1){onoff = 0;} else {onoff = 1;} // LED toggle on/off
 break;
 }
 if (codein.substring(i,i+25)=="0010100111000110001001000") // and here
 { Serial.println("unlock!!!");
 break;
 }
 if (codein.substring(i,i+25)=="0010100111000110001000100") //and here
 { Serial.println("mute!!!");
 break;
 }
 if (codein.substring(i,i+25)=="0010100111000110001000010") // you get the idea :)
 { Serial.println("ring!!!");
 break;
 }

if (codein.substring(i,i+25)=="0010010110111101111001000")
 { Serial.println("lock2!!!");
 break;
 }
 if (codein.substring(i,i+25)=="0010010110111111111000100")
 { Serial.println("unlock2!!!");
 break;
 }
 if (codein.substring(i,i+25)=="0010001001011011111111100")
 { Serial.println("mute2!!!");
 break;
 }
 if (codein.substring(i,i+25)=="0010010010110111111111000")
 { Serial.println("ring2!!!");
 break;
 }
 }

// this toggles the 13 pin led on or off
 if (onoff == 1) {
 digitalWrite(13,HIGH);
 delay(1000);
 }
 else { digitalWrite(13,LOW);
 delay(1000);}
 }

 

Arduino controlled motorcycle tachometer

July 1, 2012 4 comments

I found a smashed Kawasaki dash in the dump. The speedometer was destroyed, but the tachometer was OK. The first thing I did was connect the tacho to 12v. It had three contact points marked IGN, GND and an unmarked one. I figured that IGN was +12V and the unmarked one was the signal input. So I powered up the tacho and flicked a 12V wire on the unmarked contact. Surprisingly it started indicating about 3000 revs.

I then Google’d a way to output a +12V square wave with the Arduino and I found this:

The next thing I did was hook everything up on a breadboard to test it out:

Using a potentiometer I varied the delay in microseconds for the off time of the signal used to drive the tacho.

I had to fiddle a lot with the Arduino program. I figured out that because I had inserted a Serial.println(val); to print out the value of the delay I was using to modify the signal was adding a bit of a delay. The next thing to be done is to receive some data over the serial port and display it on the tachometer.

Categories: AVR, electronics Tags: , , ,

Finally, I own an oscilloscope!

March 2, 2012 Leave a comment

After a long wait (my whole life), I was able to buy my very own oscilloscope. It’s the DSO 203 (quad). Momentarily, I’m very pleased with it, even though I haven’t used it a lot ( i got it this week), only for basic testing with its own wave generator and some PWM signals from a motor controller. Later this week I hope I’ll have some time to hook it up to my car ignition system because it’s an electronic ignition system to figure out a way to interpret the engine speed for data-logging. Sadly, I only received a single probe but i found MCX connectors on  tme.eu so I’ll be able to DIY my own logic probes at least, or if I get my hands on a BNC probe, changing the connector shouldn’t be too difficult.

DSO quad oscilloscope

The DSO 203

Before the DSO I used the sound card oscilloscope and made my probes with the help of ladyadas’ tutorial and managed not to damage my sound card. The software I used was written by Christian Zeitnitz and it was free. Still, I wanted more mobility and precision because with the sound card scope you need to drop the voltage down to a maximum of 1.5-2V and voltage spikes can damage the sound card.

I bought the Quad from diyertool.com for 200$ including express delivery being the cheapest one I could find. Shipping from Hong Kong took only three days (over the weekend). I was very pleased with that to say the least. Definitely worth the shipping cost.

The DSO looks quite well built, I chose the one with the black aluminium casing and it seems sturdy and worth the money. I recommend it to anyone in need of a cheap, portable and versatile oscilloscope.

Follow

Get every new post delivered to your Inbox.