Arduino PWM Brushed DC motor Controller Part 1

It was in my schooling days over 2 decades ago when I first came across PWM (Pulse-Width Modulation). I am fascinated by how efficient it can be utilize in a myriad of power electronics application. The working principle is easy to understand but implementing isn't ... Well, at least to me at that point of time when anything that requires micro-processor is considered  alien technology or witch craft.... After all it was the age of 8086 XT & I was only a poor teenage student without internet & any common interest friends let alone finding any mentor to guide me in the pursuit...

Every now & than over the years,  I encounter numerous literature on microprocessor use in PWM thingy... Not that I'm a genius, but after over a decade of leisure reading, it has came to the point that I just had to have a go at it.

Personally, I consider Arduino is a blessing, it has everything I need to get it done. Without it, I would never had bothered tinkering with micro-controller.

The plan is to build an experimental DC motor controller with
1) Potential meter (POT) as Direction & Speed control dialing nob.
2) Arduino as the micro-controller.
3) ~16kHz PWM frequency to keep the motor running quiet

Here is the code I wrote. Short, but that is all that is required.

#include <avr/interrupt.h>

//Analog Pins Allocation
int POT_pin = 0; //Speed & direction control POT connect to A0

//Digital Pins Allocation
int IN1 = 7;  //Controller IN1 pin connect to D7 Pin
int IN2 = 8;  //Controller IN2 pin to connect D8 Pin
int INH = 9;  //INH1 & INH2 are common & comnect to PWM D9 Pin

// Variables

int Motor_speed = 0;  //Motor speed to achieve balancing

void setup() {

TCCR1A = B11110010;
TCCR1B = B00011001;

TCCR1B = 25;// 00011001
ICR1 = 1023 ; // 10 bit resolution
OCR1A = 511; // vary this value between 0 and 1024 for 10-bit precision
OCR1B = 511; // vary this value between 0 and 1024 for 10-bit precision

pinMode (IN1, OUTPUT);
pinMode (IN2, OUTPUT);
pinMode (INH, OUTPUT);    //PWM Analog
}
void loop()
{
  Motor_speed = map(analogRead(POT_pin),0,1024,-1023,1023);
if (Motor_speed>0)
  {
    digitalWrite(IN1,HIGH);
    digitalWrite(IN2,LOW);
  }
  else
  {
    digitalWrite(IN1,LOW);
    digitalWrite(IN2,HIGH);
  }

  analogWrite(INH,(1023-abs(Motor_speed)));
//the "1023-" is there to correct the actual PWM percentage with respect to the POT

}


The required power electronics will come in Part 2...

Tinkering Accelerometer + Gyro AKA IMU (Part 3)

Now that we know how to read the sensors, we need to make sense of it. Lets have a good look at the sensor datasheet.

ADXL335 3-axis Accelerometer
Accelerometer, measures resultant acceleration acting on the sensor.
This ADXL335 outputs an analogue voltage based on acceleration. Its sensitivity of the ADXL335 is 300mV/g, which means that the output will change by .30v per 9.8m/s² .

The ADXL335 has a ratiometric output, meaning 0g is always around half of the supply voltage Vcc, The datasheet stated that the zero Voltage is typically at 1.5V.

Hence,
Accel  = Vaccel - 1.5V

BUT I prefer to get the actual count reading when the accelerometer is resting on horizontal position

and Sensitivity is typically 0.3V/g, the Arduino ADC gives a 10-bit value based on a 3.3v reference, the gain on the raw ADC value can be calculated by:
Hence,

(1g/0.3V) X (3.3V/1024) =0.01627 g/LSB

Hence,

Position of  the accelerometer = Accel *0.011

IDG500 2-axis Gyro
This gyroscope measures angular rate and return a analogue voltage signal proportional to the rate of rotation. The at the 4.5x, IDG500 has a sensitivity of 9.1mV/°/s, i.e. the output changes 9.1.0mV for every °/s of rotation. Since the Arduino ADC gives a 10-bit value based on a 5v reference, the gain on the raw ADC value can be calculated by:

(1°/s/0.0091V) X (3.3/1024) = 0.354 °/s/LSD


deduct the factory set 1.35V from raw analogue input & multiplying result with 0.354°/s/LSD  will return the angular velocity in degrees-per-second.

Gyro rate =(Gyro_reading - 1.35V)*0.354 deg/sec



Since we are doing discrete maths with our controller, we multiply the known interval between gyro reading which is the loop time; we get the change in angular position in degree

Gyro Angular change = Gyro rate * Loop time

Now we have enough data to measure angular position with the gyro with the following line.

Gyro angle= Gyro angle + Gyro Angular change.

What we had just done is to rationalised both the accelerometer & gyro output to angular position with the same unit of measurement.

It is now convenient to write code to compare the sensors on the same page.

Tinkering Accelerometer + Gyroscope AKA IMU (Part 2)

The IMU is a combo board consisting of 2 sensors.

What good is a sensor if we can not read it.

Here I jury jig a bench top test for reading the sensors.

Hardware involved:-
Arduino Duemilanove
5DOF IMU
some hook-up leads
- 3V3 to IMU Vss & ARef pin
-Gnd to Gnd
- accel X axis to Analog input 0
- accel Y axis to Analog input 2
- gyro X axis(4x output) to Analog input 1
- gyro Y axis(4x output) to Analog input 3
- USB cable

We still need to write some codes to get the job done.

Following  is a simple code which I came  up with



// Reading 5DOF IMU


//Analog Pins

int Xaccel_pin = 0;      //connect accel X axis to Analog input 0
int Yaccel_pin = 2; //connect accel X axis to Analog input 2
int Xgyro_pin = 1; //connect gyro X axis(4x output) to Analog input 1
int Ygyro_pin = 3; //connect gyro Y axis(4x output) to Analog input 3

//Digital Pins

int Xaccel_reading;          //X axis Accelerometer reading
int Yaccel_reading;          //y axis Accelerometer reading

int Xgyro_reading;      //X axis Gyro reading
int Ygyro_reading;      //Y axis Gyro reading

float loop_time = 0.05;
int last_loop = 0;
void setup(){

Serial.begin(9600); // start Serial monitor to print values

pinMode(Xaccel_pin,INPUT);
pinMode(Xgyro_pin,INPUT);
pinMode(Yaccel_pin,INPUT);
pinMode(Ygyro_pin,INPUT);
pinMode(13,OUTPUT);
}

void loop() {
  Xaccel_reading=analogRead(Xaccel_pin);
  Xgyro_reading=analogRead(Xgyro_pin);
  Yaccel_reading=analogRead(Yaccel_pin);
  Ygyro_reading=analogRead(Ygyro_pin);

while((millis()-last_loop)
{
    delay(1);
}
last_loop=millis();

Serial.print("X-Accel: ");
Serial.print(Xaccel_reading);
Serial.print("  ");

Serial.print("X-Gyro: ");
Serial.print(Xgyro_reading);
Serial.print("  ");

Serial.print("YAccel: ");
Serial.print(Yaccel_reading);
Serial.print("  ");

Serial.print("Y-Gyro: ");
Serial.print(Ygyro_reading);
Serial.print("  ");

}

Once loaded, you can see the IMU reading via the "Serial Monitor" or <>

Now that I have IMU readings, the next gargantuan task is to figure out what can I do with them...

Maybe in Part 3 I'll have an answer....

Tinkering Accelerometer + Gyroscope AKA IMU (Part 1)

Its been some time since I fiddle with anything interesting...

The amplifier chassis is fun but just couldn't drag myself to build it as it doesn't arouse any sense of achievement since it never do anything at all...

Dug out this dust covered 5DOF IMU from my hoarder's corner...

I bought this for a song while roaming mindlessly in the deep internet space sometime ago...

Doing something with this will surely beats any amplifier projects.

 
Let me introduce you to this little gem.
It is an analogue output 5DOF(Degree of Freedom) IMU (Inertia Moment Unit) board consisting of 3 axis accelerometer ADXL335 chip by  Analog Devices and  2 axis gyroscope chip IDG500 by InvenSense.

This will save me from soldering 2 multi-legged SMT chip which are about the size of my nostril hair. 

SPECIFICATIONS

Accelerometer

AnalogDevices 

ADXL335

Axis	X, Y, Z
Measuring Range	±3.6g
Non-Linearity	±0.3%
Vcc	3.3V
Sensitivity at Xout, Yout, Zout	270~330mV/g, typically 300mV/g
Zero g Bias Level (Ratiometric) 0g Voltage at Xout, Yout 0g Voltage at Zout	1.35~1.65V, typically 1.5V 1.2~1.8V, typically 1.8V
Frequency Response Bandwidth Xout, Yout Bandwidth Zout	1600Hz 550Hz

Gyrometer

InvenSense 

IDG500

Axis	X, Y
Full-Scale Range Sensitivity	X-OUT & Y-OUT X4.5Out & Y4.5Out X-OUT & Y-OUT X4.5Out & Y4.5Out	±500°/s ±110°/s 2.0mV/°/s 9.1mV/°/s
Frequency Response	140 Hz
Zero-Rate Output Static (Bias)	Factory set 1.35V
Vcc	3.3V

IMU SHIELD

Even though it is a breakout board, This thing is still tiny my my standard! 

To save my sanity & eyesight, I drawn up a PCB as shield for Arduino.

IMU Arduino Shield

By fiddling with the jumper pin, I can choose which ever accelerometer axis Xout,Yout or Zout to A0 pin & Gyro's X-OUT, Y-OUT, Z-OUT, X4.5Out or Y4.5Out to A1 pin just

Others stuff the PCB design to do, 

1) tied up the Vcc to the Arduino ARef pin.

2) add pads & holes so that there is an option to solder or using pin plug to get to the Arduino pinouts.

Word budget is up for this article. In the part 2 of this series of article, I'll dive into reading the IMU which will involve some maths, some coding & some simple point to point wiring.