Blutack

In dedication to one of the most useful things in my room…Blutack

Oh blutack, why art though so awesome? You gotta love these things, they help people like me who’s lousy in fabrication. This post is dedicated to you, since you helped create it.

Pan and tilt system using two servos and the yaw and pitch axes

That’s right! This is just an upgrade to my last video. This time I’m using two servos and utilising two axes(axii?). As I’ve said above this video is dedicated to the almighty blutack, and you’ll understand what I mean when you see the photos below. I was meaning to post earlier but just got off work a couple of hours ago, I just wanted to do something rough before I hit the hay as the goddess of luck and robotics smiled upon me when I asked Ted if he has another servo. I’ve been itching to do this for a while now, and the itch has been cured…for now! Again this is very rough work, this is probably the first time you’ll ever see such a thing as a cardboard bracket with blutack hinges. But I plan to upgrade with sugru soon, if I manage to get my hands with some more of them. Anyway without further ado, Blue the blutack jointed robot(ps please watch videos in 720p or 1080p as it looks horrible on 480p):

20121107-003723.jpg

20121107-003752.jpg


//
// This program interfaces a Wii wii motion plus with the dsPIC using the I2C module
// Pan and tilt using two servos
// Program written by Gian Lorenzo
// Last edited 07/11/2012 1:39AM
//

#include <libpic30.h>
#include <p30f4011.h>
#include <stdio.h>
#include <xc.h>
#include <i2c.h>
#include <math.h>

// Configuration settings
_FOSC(CSW_FSCM_OFF & FRC_PLL16);  // Fosc=16x7.5MHz, Fcy=30MHz
_FWDT(WDT_OFF);                   // Watchdog timer off
_FBORPOR(MCLR_DIS);               // Disable reset pin

// Function prototypes
void setup();								// Configure pins etc
unsigned int read_analog_channel(int n);	// Reading analog channel
void wiimp_init();						// wiimp initialisation/Handshake
void calibrate();
void wiimp_read(unsigned char*);			// Reading data from the Wii wiimp              // Nunchuk data array
void pause(unsigned int ms);				// Pause function(in ms)
void forward();								// Moves the Servo forward
void back();								// Moves the Servo backward

double yawzero=8054.7,pitchzero=7744,rollzero=7745,
yaw,roll,pitch, deltayaw, deltaroll,deltapitch;
unsigned char  wii_data[20],c; 


int main()
{
	unsigned int ax,ay,az;  // Data containers
	setup();				// Set up which pins are which and set up i2c and configs
	pause(1000);			// 1 second startup delay
	wiimp_init();			// Initialise wii motio plus
	pause(1000);
	//calibrate();			// Calibrate for 0
	pause(1000);
	int o = 0;
	
	while(1)
	{
		if(o == 0)	// Get rid of bad readings
		{
			wiimp_read(wii_data);                      
			wiimp_read(wii_data);
			wiimp_read(wii_data);
			wiimp_read(wii_data);
			wiimp_read(wii_data);
			wiimp_read(wii_data);
			wiimp_read(wii_data);
			pause(2000);
			o++;
		}
				
		wiimp_read(wii_data);                       // Read data from nunchuk

		ax = ((wii_data[3] & 0xFC) << 6) + wii_data[0];	// Extract gyroscope yaw byte
		ay = ((wii_data[4] & 0xFC) << 6) + wii_data[1];	// Extract gyroscope roll byte
		az = ((wii_data[5] & 0xFC) << 6) + wii_data[2];	// Extract gyroscope pitch byte
		
		yaw = ax - yawzero;
		roll = ay - rollzero;
		pitch = az - pitchzero;
		
		deltayaw = deltayaw + yaw;
		deltaroll = deltaroll + roll;
		deltapitch = deltapitch + pitch;
		
		
		if (U2STAbits.URXDA == 1)			//recalibration using uart
		{
			c = U2RXREG;
			if (c == 'y')	deltayaw = 0;
			else if(c == 'p')	deltapitch =0;
			else if(c =='r')	deltaroll =0;
			else if(c == 'a')	deltayaw =0;deltapitch=0;deltaroll=0;
		}
		PDC2 = 1410+(deltapitch*0.06083333333333/2);
		PDC1 = 1280-(deltayaw*.06083333333333/2);
		pause(20);
		//printf("%1d\r %1d\r %1d\r\r\n", ax, ay, az);
		printf("%1f\r %1f\r %1f\r\r\n", deltayaw, deltaroll, deltapitch);
	}

    return 0;
}
void forward()
{
	if(PDC1 < 2010)
	{
		PDC1 = PDC1 + 20;
		pause(.5);
	}
}
void back()
{
	if(PDC1 > 550)
	{
		PDC1 = PDC1 - 20;
		pause(.5);
	}
}

void setup()
{
    // Setup UART
	__C30_UART=2;			// Use secondary UART
    U2BRG = 48;            	// 38400 baud @ 30 MIPS
    U2MODEbits.UARTEN = 1; 	// Enable UART

    // Configure D ports as a digital outputs
    LATD = 0;
    TRISD = 0b11110000;

    // Configure analog inputs
    TRISB = 0x01FF;      /* Port B all inputs */
    ADPCFG = 0xFF00;     /* PORTB 0-7 are analog inputs */
    ADCON1 = 0;          /* Manually clear SAMP to end sampling, start conversion*/
    ADCON2 = 0;          /* Voltage reference from AVDD and AVSS */
    ADCON3 = 0x0005;     /* Manual Sample, ADCS=5 -> Tad = 3*Tcy = 0.1us */
    ADCON1bits.ADON = 1; /* Turn ADC ON */

    // Configure PWM
    // PWM period = Tcy * prescale * PTPER = 0.33ns * 64 * 9470 = 20ms
    PWMCON1 = 0x00FF; // Enable all PWM pairs in complementary mode
    PTCON = 0;
    _PTCKPS = 3;      // prescale=1:64 (0=1:1, 1=1:4, 2=1:16, 3=1:64)
    PTPER = 9470;     // 20ms PWM period (15-bit period value)
    PDC1 = 0;         // 0% duty cycle on channel 1 (max is 65536)
    PDC2 = 0;         // 0% duty cycle on channel 2 (max is 65536)
    PDC3 = 0;         // 0% duty cycle on channel 3 (max is 65536)
    PTMR = 0;         // Clear 15-bit PWM timer counter
    _PTEN = 1;        // Enable PWM time base
	
	// Configure I2c
	I2CCONbits.I2CSIDL = 1;	// Stop module in idle mode
	I2CCONbits.A10M = 0;	// 7-bit address
	I2CCONbits.DISSLW = 0;	// slew rate control. Required to be on for 400kHZ
	I2CBRG = 272;			// 272 for 100kHz at FCY = 30MHz formula next line
							// I2CBRG = (((1/rate)-900ns)*FCY)-1
	I2CCONbits.I2CEN = 1;	// Enable i2c
}

void calibrate()
{
	int i=0,o=0;
    for (o=0;o<10;o++)
      {
        wiimp_read(wii_data);
		pause(10);
      }
	wiimp_read(wii_data);
    yawzero=((wii_data[3]>>6)+wii_data[0]);
    rollzero=((wii_data[4]>>6)+wii_data[1]);
    pitchzero=((wii_data[5]>>6)+wii_data[2]);
    for (i=0;i<10;i++)
      {
        wiimp_read(wii_data);
        yawzero=((wii_data[3]>>6)+wii_data[0])+yawzero/2; //average 10 readings
        rollzero=((wii_data[4]>>6)+wii_data[1])+rollzero/2;
        pitchzero=((wii_data[5]>>6)+wii_data[2])+rollzero/2;
      }
	printf("%f %f %f", yawzero,rollzero,pitchzero);
	pause(2000);
}
void wiimp_init(void) 
{
	StartI2C();			// Open I2C bus
	IdleI2C();			// Wait for last command to finish
	MasterWriteI2C(0xA6);// Call device adress 53(Wii wiimp)
	MasterWriteI2C(0xFE);// Handshake protocol for wii wiimp	
	MasterWriteI2C(0x04);
	StopI2C();
	printf("connected\r\n");
}

void wiimp_read(unsigned char* array) 
{
	int idx;	// Counter

	// ---- Request measurement ---- //
	StartI2C();		// Open I2C bus
	IdleI2C();		// Wait for last command to finish
	MasterWriteI2C(0xA4); // Call the adress you want to read from
	MasterWriteI2C(0x00);	
	StopI2C();		// Stop I2C
	pause(10); 	// 3 ms or more required or acquisition goes wrong

	 //Request reading
  	StartI2C();	// Open I2C bus
	IdleI2C();	// Wait for last command to finish
	MasterWriteI2C(0xA5);	// 0XA5 is the read adress of the wii wiimp(52+1)
	IdleI2C();	// Wait for last command to finish
	 //Bytes reception
	for(idx = 0; idx < 5; idx++)
	{
		array[idx] = MasterReadI2C(); 	// Store the values into an array
		AckI2C(); 						// Send an ACK to notify wiimp to send next byte
		IdleI2C();						// Wait for last command to finish
	}
	pause(1);
	array[5] = MasterReadI2C(); 		// Last byte to be read
	NotAckI2C(); IdleI2C();				// Send a NACK to tell wiimp that reading is done
	StopI2C();							// Stop I2C
}

// Analogue input reading
unsigned int read_analog_channel(int channel)
{
    ADCHS = channel;          // Select the requested channel
    ADCON1bits.SAMP = 1;      // start sampling
    __delay32(30);            // 1us delay @ 30 MIPS
    ADCON1bits.SAMP = 0;      // start Converting
    while (!ADCON1bits.DONE); // Should take 12 * Tad = 1.2us
    return ADCBUF0;
}
void pause(unsigned int ms)
{
	__delay32(30000L*ms);	// 1ms Pause = (ms * FCY/1000)
}
Advertisements

Interfacing a Wii motion plus to the dspic30F4011

I’m at it again!

And so after my ventures with I2C and the Wii nunchuck; many prospects of the “mini project” have opened up. While the Wii nunchuck’s accelerometer is great, there’s no harm in trying out new sensors. So far I can think of two applications but they will require a lot of time and work(and money!) to build and so I’ll think about it more. The first one is sort of a crane attached onto a “roof”, Two stepper motors control the x and y coordinates of the plane and the Wii motion plus can control the movement of the actual gripper. The second one is a robot car with a crane on in and works pretty much the same as the one I said there but with wheels and is on the ground. I’m also intrigued into building something aerial but I don’t want to get too ahead of myself.

And so I got my Wii motion plus that’s lying around and got to work into trying to communicate with it. The way it communicates is also through I2C and the code I came up with is pretty much the same as with the nunchuck, only this time around I’m only reading three values as the Wii motion plus is basically a gyroscope.  I’ve got to admit I’m liking this sensor more than the nunchuck, so far anyway. I really wish I had another servo right now, as I can only utilise one axis with one servo. It’s good enough for the demo I suppose.

Gyroscope

So, what makes the wii motion plus sensor work? That could be answered in one word: A gyroscope(ok that’s two ha ha Gian can’t count). But to explain how a gyroscope works can be a bit tricky and I wont even try to explain it too deeply. The image above is one of a toy gyroscope, when I first played with one as a child I was dumbfounded and no one around me could explain how it does what it does. It’s basically constructed with a spinning wheel in the middle and round metal things around it. Without doing anything to it; it does nothing, it’s just a piece of metal. But spin the wheel and the middle and the magic happens, when the wheel is spun it seems to defy gravity as it can support itself sideways and in awkward positions and not lose its orientation. The reason behind this is because the wheel in the middle has angular velocity and will try to repel any force being applied to it. I think this video will explain in better more than I can:

So now you know what a gyroscope does. This little sensor of mine has one inside it and so it will tell me the orientation of my device in 3 axes which are the yaw angle, the roll angle, and the pitch angle. When the orientation is changed: the gyroscope will repel it and this degree of repulsion is sent down as a signal. This can be very useful indeed, so useful that every flying machine nowadays uses one to know its orientation.

Only downside is: it doesn’t know it’s initial orientation. This is the reason why everytime you want to use your wii motion plus on the console you have to put it down a flat surface before you can use it. But A-ha! We have the wii nunchuck which has an accelerometer and will tell us the current pitch of the device and so it’s a great match!

Controlling a servo using the “yaw” angle

As I’ve said I only have one servo at the moment sadly and so I had to choose one variable to use as my “controller”. I used the yaw angle randomly, this is basically the angle that goes “side-to-side” and I just scaled it to the range of the servo. That’s all that there is! Simple as. Now to talk about the I2C communication, and as I’ve said: it’s nearly the same as the wii nunchuck one, only that this sensor has a different I2C address(0x53) when trying to initialise and then it becomes 0x52 or A4 once initialised. This will cause a bit of trouble when both the Wii motion sensor and the nunchuck are being used. But there is a way of deactivating the wii motion plus with code and look at the nunchuck data, but that’s for another post. Six bytes are read from the Wii motion plus and they are as follows:

It can be seen that there are actually two modes in which the sensor operates. One is the slow mode and the other is the fast mode, this is basically when you try and change the orientation quickly or slowly, they will both have different multipliers(4 and 20) and so it has to be taken into account. And another thing is that the data is actually moved 6 bits in and so we have to read from “wii_data[x]>>6” for example. Plenty of useful stuff here if anyone is interested. And without further ado, here’s my short demo:


//
// This program interfaces a Wii wii motion plus with the dsPIC using the I2C module
//
// Program written by Gian Lorenzo
// Last edited 05/11/2012 10:26AM
//

#include <libpic30.h>
#include <p30f4011.h>
#include <stdio.h>
#include <xc.h>
#include <i2c.h>
#include <math.h>

// Configuration settings
_FOSC(CSW_FSCM_OFF & FRC_PLL16);  // Fosc=16x7.5MHz, Fcy=30MHz
_FWDT(WDT_OFF);                   // Watchdog timer off
_FBORPOR(MCLR_DIS);               // Disable reset pin

// Function prototypes
void setup();								// Configure pins etc
unsigned int read_analog_channel(int n);	// Reading analog channel
void wiimp_init();						// wiimp initialisation/Handshake
void calibrate();
void wiimp_read(unsigned char*);			// Reading data from the Wii wiimp              // Nunchuk data array
void pause(unsigned int ms);				// Pause function(in ms)
void forward();								// Moves the Servo forward
void back();								// Moves the Servo backward

double yawzero=8055.5,pitchzero=7612,rollzero=7739,
yaw,roll,pitch, deltayaw, deltaroll,deltapitch;
unsigned char  wii_data[20];

int main()
{
	unsigned int ax,ay,az;  // Data containers
	setup();				// Set up which pins are which and set up i2c and configs
	pause(1000);			// 1 second startup delay
	wiimp_init();			// Initialise wii motio plus
	pause(1000);
	//calibrate();			// Calibrate for 0
	pause(1000);
	int o = 0;

	while(1)
	{
		if(o == 0)	// Get rid of bad readings
		{
			wiimp_read(wii_data);
			wiimp_read(wii_data);
			wiimp_read(wii_data);
			wiimp_read(wii_data);
			wiimp_read(wii_data);
			wiimp_read(wii_data);
			wiimp_read(wii_data);
			pause(1000);
			o++;
		}

		wiimp_read(wii_data);                       // Read data from nunchuk

		ax = ((wii_data[3] & 0xFC) << 6) + wii_data[0];	// Extract gyroscope yaw byte
		ay = ((wii_data[4] & 0xFC) << 6) + wii_data[1];	// Extract gyroscope roll byte
		az = ((wii_data[5] & 0xFC) << 6) + wii_data[2];	// Extract gyroscope pitch byte

		yaw = ax - yawzero;
		roll = ay - rollzero;
		pitch = az - pitchzero;

		deltayaw = deltayaw + yaw;
		deltaroll = deltaroll + roll;
		deltapitch = deltapitch + pitch;
		// Extract gyroscope pitch byte
		PDC1 = 1280-(deltayaw*.06083333333333);
		pause(50);
		//printf("%1d\r %1d\r %1d\r\r\n", ax, ay, az);
		printf("%1f\r %1f\r %1f\r\r\n", deltayaw, deltaroll, deltapitch);
	}

    return 0;
}
void forward()
{
	if(PDC1 < 2010) 	{ 		PDC1 = PDC1 + 20; 		pause(.5); 	} } void back() { 	if(PDC1 > 550)
	{
		PDC1 = PDC1 - 20;
		pause(.5);
	}
}

void setup()
{
    // Setup UART
	__C30_UART=2;			// Use secondary UART
    U2BRG = 48;            	// 38400 baud @ 30 MIPS
    U2MODEbits.UARTEN = 1; 	// Enable UART

    // Configure D ports as a digital outputs
    LATD = 0;
    TRISD = 0b11110000;

    // Configure analog inputs
    TRISB = 0x01FF;      /* Port B all inputs */
    ADPCFG = 0xFF00;     /* PORTB 0-7 are analog inputs */
    ADCON1 = 0;          /* Manually clear SAMP to end sampling, start conversion*/
    ADCON2 = 0;          /* Voltage reference from AVDD and AVSS */
    ADCON3 = 0x0005;     /* Manual Sample, ADCS=5 -> Tad = 3*Tcy = 0.1us */
    ADCON1bits.ADON = 1; /* Turn ADC ON */

    // Configure PWM
    // PWM period = Tcy * prescale * PTPER = 0.33ns * 64 * 9470 = 20ms
    PWMCON1 = 0x00FF; // Enable all PWM pairs in complementary mode
    PTCON = 0;
    _PTCKPS = 3;      // prescale=1:64 (0=1:1, 1=1:4, 2=1:16, 3=1:64)
    PTPER = 9470;     // 20ms PWM period (15-bit period value)
    PDC1 = 0;         // 0% duty cycle on channel 1 (max is 65536)
    PDC2 = 0;         // 0% duty cycle on channel 2 (max is 65536)
    PDC3 = 0;         // 0% duty cycle on channel 3 (max is 65536)
    PTMR = 0;         // Clear 15-bit PWM timer counter
    _PTEN = 1;        // Enable PWM time base

	// Configure I2c
	I2CCONbits.I2CSIDL = 1;	// Stop module in idle mode
	I2CCONbits.A10M = 0;	// 7-bit address
	I2CCONbits.DISSLW = 0;	// slew rate control. Required to be on for 400kHZ
	I2CBRG = 272;			// 272 for 100kHz at FCY = 30MHz formula next line
							// I2CBRG = (((1/rate)-900ns)*FCY)-1
	I2CCONbits.I2CEN = 1;	// Enable i2c
}

void calibrate()
{
	int i=0,o=0;
    for (o=0;o<10;o++)       {         wiimp_read(wii_data); 		pause(10);       } 	wiimp_read(wii_data);     yawzero=((wii_data[3]>>6)+wii_data[0]);
    rollzero=((wii_data[4]>>6)+wii_data[1]);
    pitchzero=((wii_data[5]>>6)+wii_data[2]);
    for (i=0;i<10;i++)       {         wiimp_read(wii_data);         yawzero=((wii_data[3]>>6)+wii_data[0])+yawzero/2; //average 10 readings
        rollzero=((wii_data[4]>>6)+wii_data[1])+rollzero/2;
        pitchzero=((wii_data[5]>>6)+wii_data[2])+rollzero/2;
      }
	printf("%f %f %f", yawzero,rollzero,pitchzero);
	pause(2000);
}
void wiimp_init(void)
{
	StartI2C();			// Open I2C bus
	IdleI2C();			// Wait for last command to finish
	MasterWriteI2C(0xA6);// Call device adress 53(Wii wiimp)
	MasterWriteI2C(0xFE);// Handshake protocol for wii wiimp
	MasterWriteI2C(0x04);
	StopI2C();
	printf("connected\r\n");
}

void wiimp_read(unsigned char* array)
{
	int idx;	// Counter

	// ---- Request measurement ---- //
	StartI2C();		// Open I2C bus
	IdleI2C();		// Wait for last command to finish
	MasterWriteI2C(0xA4); // Call the adress you want to read from
	MasterWriteI2C(0x00);
	StopI2C();		// Stop I2C
	pause(10); 	// 3 ms or more required or acquisition goes wrong

	 //Request reading
  	StartI2C();	// Open I2C bus
	IdleI2C();	// Wait for last command to finish
	MasterWriteI2C(0xA5);	// 0XA5 is the read adress of the wii wiimp(52+1)
	IdleI2C();	// Wait for last command to finish
	 //Bytes reception
	for(idx = 0; idx < 5; idx++)
	{
		array[idx] = MasterReadI2C(); 	// Store the values into an array
		AckI2C(); 						// Send an ACK to notify wiimp to send next byte
		IdleI2C();						// Wait for last command to finish
	}
	pause(1);
	array[5] = MasterReadI2C(); 		// Last byte to be read
	NotAckI2C(); IdleI2C();				// Send a NACK to tell wiimp that reading is done
	StopI2C();							// Stop I2C
}

// Analogue input reading
unsigned int read_analog_channel(int channel)
{
    ADCHS = channel;          // Select the requested channel
    ADCON1bits.SAMP = 1;      // start sampling
    __delay32(30);            // 1us delay @ 30 MIPS
    ADCON1bits.SAMP = 0;      // start Converting
    while (!ADCON1bits.DONE); // Should take 12 * Tad = 1.2us
    return ADCBUF0;
}
void pause(unsigned int ms)
{
	__delay32(30000L*ms);	// 1ms Pause = (ms * FCY/1000)
}

Goodbye PIC, Hello dsPIC!

If I had a penny everytime I see “hello world!” I’d be one penny richer once more. I have been contemplating since the start of summer to create a new blog. But alas, as always, ended up procrastinating until now. It has been a few months since DIT’s ROBOSUMO tournament took place (in which yours truly’s team, participated in and won 2nd place or first loser, whichever you prefer. More of that here) and I have been itching for some time now to delve back into the world of microcontrollers. I originally planned to prepare for one of my upcoming modules; which is robotics, before the semester even started. This is the reason I bought my own materials i.e. PICkit2(which I shall be using all the time for the meantime), a dsPIC microcontroller, an H bridge to control DC motors, different types of sensor i.e. colour sensors and piezoelectric sensors, and many others. But enough about my boring ramblings, onto the show! PS: I shall try to refrain from unnecessary puns or jokes but odd ones might slip and so, I apologize in advance.

First task : DC motor control using Pulse Width Modulation

Materials used:

  • PICkit2 programmer
  • dsPIC30f4011
  • Breadboard and wires
  • Power Supply
  • 2 x DC motors
  • Soldering iron
  • LEDs
  • Various resistors
  • Microswitch
  • Trimmers used as potentiometers

I decided to go and give the dsPIC a test run since this is the chip I shall be using next year. To be honest I still don’t fully understand the difference between a normal PIC and a dsPIC but I have a rough idea, just looking at the pinouts on the datasheets it is clear that the dsPIC has more analogue inputs and way more PWM outputs than the last chip I used for C.A.K.E. which was the PIC16f4620. This will be for my advantage on this task as I will be needing two PWM outputs and three(for now) analogue inputs. Below is a block diagram of the task(click image to enlarge):

So in short : I’m making a sort of independent dimmer switches for two motors. I also forgot to add on the block diagram that I will be putting a microswitch to change the directions the motors are going(I intended for this to be a toggle switch but only a microswitch was available at the time but it does the job with a little software tweaking). So I twist the left pot: the left motor powers up accordingly, I twist the right pot: the right motor powers up, and I press the microswitch: the direction changes.

Pulse Width Modulation

I can’t go on without talking about PWM or Pulse Width modulation. This is a method to control power supplied to a point. By controlling the duty cycle one controls the amount of voltage coming out of a pin of a microcontroller. An analogy I told one of my friends once whilst trying to attempt to explain PWM was: imagine there was a conveyor belt of food and at the end is a fat man that consumes everything in sight, now the conveyor belt is designed to drop 10 cupcakes per second at the mouth of the fat man. Now let’s say that we want to make the fat man a bit thinner by putting him on a diet, that we’ll only give him half of his usual cupcakes i.e. 50% duty cycle, a way of doing this would be to turn off the conveyor belt every 5 seconds for the duration of 5 seconds. by doing this we limit the cupcakes to 50 per 10 seconds instead of the usual 100, the fat man still gets his cupcakes; only not as much so in theory he’d be less fat. This is exactly the same with PWM on the PIC only that instead of having a period of 10 seconds(5 on and 5 off) it will have a much smaller cycle time i.e. it will be doing this a lot lot faster.

Circuit

I haven’t used Inkscape in a good while so apologies if the image is a bit cluttered. As it can be seen on the schematic: the connections of the dsPIC are similar to the connections on a normal PIC, the main differences being the jumper wires connections the AVdd,AVss,Vdd, and Vss pins together, and of course the location of the TX and RX pins. Two trimmers connected up as potentiometers will be used to give a varied voltage signal to the analogue inputs of the dsPIC and this signal will determine the duty cycle that the dsPIC will give the motors. The microswitch is just connected to AN2 for the purpose of changing the directions, I will go into a bit more detail about this later on the program part of the post. The H bridge is connected to a different power supply as to prevent power fluctuations that might reset the pic or a worse case scenario: you draining too much power from the USB port of your computer via the PIC and as a safety feature; windows usually disables the USB port and you end up wasting time trying to enable it again, although there are ways to disable this safety feature, but I’m not here to talk about that. Anyways the H bridge is connected up as such, this is the same H bridge model as the one used on our ROBOSUMO project last year so I am very familiar with it. LEDs are connected both ways as to know which direction the motors are going, I used two sets: two red for backwards, and two green ones for forward(EDIT: The LEDs are actually connected in parallel with pin 2 and 7, and pin 10 and 15 and not across the motors although this might work as well).

The code

The programming environment that I’m going to be using is the MPLABX which is the new version of MPLAB, a C16 compiler is also needed to be able to program this particular MCU. I would like to acknowledge Mr. Ted Burke(www.batchloaf.wordpress.com) as the template I used to write this code are snippets of full codes found on his website(above), the part in particular that would have taken me days if not weeks to write myself would be the “configure pins” part of the program. The ADC part is familiar as I used it last year but of course I learned that off him, too! So go pay his blog a visit. I just edited some of the “setup” he has to suit my own needs.


//
// This program shows how PWM can be used to control two DC motors
// using a dsPIC and a motor driver chip.
// Two potentiometers control two motors independently
// Microswitch changes directions
//
// Setup template written by Ted Burke(batchloaf.wordpress.com)
// Program written by Gian Lorenzo
// Last edited 31/08/2012
//

#include <libpic30.h>
#include <p30f4011.h>
#include <stdio.h>
#include <xc.h>

// Configuration settings
_FOSC(CSW_FSCM_OFF & FRC_PLL16);  // Fosc=16x7.5MHz, Fcy=30MHz
_FWDT(WDT_OFF);                   // Watchdog timer off
_FBORPOR(MCLR_DIS);               // Disable reset pin

// Function prototypes
void setup();
unsigned int read_analog_channel(int n);

int main()
{
    int voltage,voltage2,direction,flag;
    double tmin = 0.0005;
    double tmax = 0.02;

    // Set up which pins are which and activate UART tool
    setup();
    direction = 1;
    while(1)
    {
        voltage = read_analog_channel(0);
        PDC1 = 937509.375 * (tmin + (voltage / 1023.0) * (tmax - tmin));
        voltage2 = read_analog_channel(1);
        PDC2 = 937509.375 * (tmin + (voltage2 / 1023.0) * (tmax - tmin));
        if(direction == 1)
        {
            _LATD0=1;
            _LATD2=0;
            _LATD1=1;
            _LATD3=0;
            __delay32(1000000);
            if(read_analog_channel(2) < 500)
            {
                flag = 1;
            }
            if(flag == 1 && read_analog_channel(2) >500)
            {
                direction = 1-direction;
                flag = 0;
            }
        }
        if(direction == 0)
        {
            _LATD0=0;
            _LATD2=1;
            _LATD1=0;
            _LATD3=1;
            if(read_analog_channel(2) < 500)
            {
                flag = 1;
            }
            if(flag == 1 && read_analog_channel(2) >500)
            {
                direction = 1-direction;
                flag = 0;
            }
        }
    }
    return 0;
}

void setup()
{
    // Setup UART
    U1BRG = 48;            // 38400 baud @ 30 MIPS
    U1MODEbits.UARTEN = 1; // Enable UART

    // Configure D ports as a digital outputs
    LATD = 0;
    TRISD = 0b11110000;

    // Configure analog inputs
    TRISB = 0x01FF;      /* Port B all inputs */
    ADPCFG = 0xFF00;     /* PORTB 0-7 are analog inputs */
    ADCON1 = 0;          /* Manually clear SAMP to end sampling, start conversion*/
    ADCON2 = 0;          /* Voltage reference from AVDD and AVSS */
    ADCON3 = 0x0005;     /* Manual Sample, ADCS=5 -> Tad = 3*Tcy = 0.1us */
    ADCON1bits.ADON = 1; /* Turn ADC ON */

    // Configure PWM
    // PWM period = Tcy * prescale * PTPER = 0.33ns * 64 * 9470 = 20ms
    PWMCON1 = 0x00FF; // Enable all PWM pairs in complementary mode
    PTCON = 0;
    _PTCKPS = 3;      // prescale=1:64 (0=1:1, 1=1:4, 2=1:16, 3=1:64)
    PTPER = 9470;     // 20ms PWM period (15-bit period value)
    PDC1 = 0;         // 0% duty cycle on channel 1 (max is 65536)
    PDC2 = 0;         // 0% duty cycle on channel 2 (max is 65536)
    PDC3 = 0;         // 0% duty cycle on channel 3 (max is 65536)
    PTMR = 0;         // Clear 15-bit PWM timer counter
    _PTEN = 1;        // Enable PWM time base
}

// Analogue input reading
unsigned int read_analog_channel(int channel)
{
    ADCHS = channel;          // Select the requested channel
    ADCON1bits.SAMP = 1;      // start sampling
    __delay32(30);            // 1us delay @ 30 MIPS
    ADCON1bits.SAMP = 0;      // start Converting
    while (!ADCON1bits.DONE); // Should take 12 * Tad = 1.2us
    return ADCBUF0;
}

As I said earlier I had to make a few tweaks to make the microswitch into a toggle one thus the code is a bit longer, even so this is still a real basic task. In the end I got it to work, but talk is cheap so:

If I was any good at fabrication I’d try to make this into a sort of toy crane like contraption, the motors would of course control the horizontal and vertical movements of the arm. Or whenever I figure out how to send commands via UART I can make a toy remote control car, whichever comes first! For the next task I plan on using a sharp rangefinder(another surplus from the ROBOSUMO project, the DC motors and the microswitches are also surplus parts of C.A.K.E.), some colour sensors, and maybe even the piezo electric sensor. Here’s to hoping inspiration for a task breezes towards my direction soon.