The source code will be Open-Source and will be hosted on Google Code, you can get code for quad copter here:

http://code.google.com/p/picquadcontroller/source/browse/#svn/trunk

As usual I like to start with a video demo, it's basically me controlling the tilt of the quad using a RC controller:

This is a PID feedback algorithm and a "Simplified Kalman Filter" as  described in my other articles.

First of all there's a a RCGroups thread where I first introduced the project

http://www.rcgroups.com/forums/showthread.php?t=1235360

You'll find some specs there and I will put some material here  as well.

Here is Revision 0.1 of schematic (what I started with):

PicQuadControllerRev01.pdf

The major parts list is as follows:

MCU:  DSPIC33FJ128MC802  (http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en532302)

Sensors: 5DOF Acc_Gyro ( http://gadgetgangster.com/213 )  + 1Dof Pololu LIST300AL-BREAKOUT (http://www.pololu.com/catalog/product/765).

Motor Drivers:  Power N-Channel Mosfets (Many choices -Low Rds(on) and rated for the current , I used  IRLR8743 ). Schottky diodes to protect against back-EMF ( I used SS2H10-E3/52T )

Frame , motors propellers: I picked a ready platform that was on sale Dragandfly IV Frame these are actually brushed motors same ones as used in Esky helicopters.

I did some tests on the lift force potential of this frame+motors+props, and was surprise to find out it performed better than some entry-level brushless motors. The lift force of this platform is up to 2.25 lbs.  The results of lift-force experiments are compiled in this spreadheet: MotorLiftPower.pdf.

How I measured the lift force ?  I didn't have any fancy equipment so I simply fixed the quad in a vise and weighted  it it at different throttle levels – the difference in weight gave me the lift power.

For testing just one motor, I used a string attached to the weight:

I built a test rig out of wood for testing the tilt balancing algorithm as you see in the video.

Here are some close-ups of the motor drivers. You'll  see the Mosfets and the Schottky diodes, also note the extra solder added to support the high currents that will flow through those traces ( up to 5A per motor !).

Finally here is a view on the top of the board ( notice the PIC , the switching regulator  ,  Acc_Gyro 5DOF IMU and single axes Gyro breakout , from top-left to bottom right).

This is it for now hope to bring you more interesting stuff on this and other projects if time allows  !

//starlino//

It is basically a customization of Mouse emulation demo that Microchip bundles with their USB Framework.

The code responsible for enabling/disabling mouse emulation is triggered by a timer interrupt like so:

        OpenTimer0( TIMER_INT_ON &
                 T0_16BIT              &
                 T0_SOURCE_INT         &
                T0_PS_1_256);

                     ………….

        //These are your actual interrupt handling routines.

        #pragma interrupt YourHighPriorityISRCode
        void YourHighPriorityISRCode()
        {
                //Check which interrupt flag caused the interrupt.
                //Service the interrupt
                //Clear the interrupt flag
                //Etc.
        #if defined(USB_INTERRUPT)
                USBDeviceTasks();
        #endif
       
                if(INTCONbits.TMR0IF){
                        counter_s++;
                        //to interrupt every 1s we need to count FOSC / 4/ 256  = 46875 ticks (0xB71B)
                        //to count these ticks till overflow we need to set TMR0 to  0xFFFF – 0xB71B = 0x48E4
                       
                        TMR0H = 0×48; //will write to TMR0H buffer
                        TMR0L = 0xE4; //will write actual TMR0L / TMR0H 

                        INTCONbits.TMR0IF = 0;
                }

        }       //This return will be a "retfie fast", since this is in a #pragma interrupt section

       ……………..

       INTCONbits.TMR0IE = 0;  //disable Timer0 interrupt
        if(emulate_mode && counter_s > 3){      // seconds on
                counter_s = 0;
                emulate_mode = 0;
        }else if (!emulate_mode && counter_s > 60){     //seconds off
                counter_s = 0;
                emulate_mode = 1;
        }
        INTCONbits.TMR0IE = 1;

For full source code see:

http://code.google.com/p/usbthumb/source/browse/#svn/trunk/UsbThumbMousePrank

UsbThumb is an open-hardware platform, anyone can build their own:

http://code.google.com/p/usbthumb/source/browse/#svn/trunk/Hardware

or pick up a prebuilt SMT version of UsbThumb here: http://www.gadgetgangster.com/303

In order to upload a new firmware to USBThumb you need to enter the bootloader mode. This is done by connecting the  VPP pin to ground during the time when device is plugged into the USB port.

This can achieved by placing a jumper wire or a 1K resistor (recommended) between GND and VPP pin.

GND pin is number 1, and VPP is number 5. Make sure you do not confuse VPP with the nearby VDD(pin number 4) or you will get a short !!! To be safe use a 1K or 10K resistor instead of the wire. Wire/resistor can be held by the spring action, it only needs to make contact during a split second while the device is plugged. If you plan on making frequent firmware updates , soldering a header is recommended.

Before plugging the device to USB port,  start the "USB HID Bootloader" application (it is installed as part of the Microchip USB Framework, look in C:\Microchip Solutions\USB Device – Bootloaders\HID – Bootloader), a copy is placed here for download:

HIDBootLoader.zip

Next insert the USBThumb into the USB port (with the VPP and GND pins connected) , you should see a "Device attached." message in the USB HID Bootloader window.

Next steps are simple:

1. Click on “Open Hex File” button and select the new firmware .HEX file you want to load
2. Click on “Program/Verify” and wait for the process to complete
3. Unplug the device from USB port. Remove the jumber wire/resistor between GND and VPP pin.
4. Plug the device back and verify the new firmware is working (it depends on firmware and what you expect it to do).

The pictures below illustrate the above steps:

A custom PIC firmware  comes preloaded on the
"USBThumb Propeller Programmer" available on GadgetGangster.com, it allows you to use USBThumb as a Propeller Programmer but also as USB to Serial converter.

USBThumb (loaded with USBThumbSerial firmware)  is detected on your computer as a standard  CDC Modem device and works on all modern operating systems (Windows, Mac os , Linux).

On Windows you might be asked for driver path once you attach the device, simply use the driver part of the Microchip's USB Framework (it can be found in C:\Microchip Solutions\USB Device – CDC – Serial Emulator\inf\win2k_winxp ) , and I am including a copy for direct download here:

microchip_cdc_win2k_winxp.zip

On Windows you can identify USBThumb's COM port number from Device Manager:

On Mac OS, once you attach the device  you will get a prompt "A new network interface has been detected". Look in the /dev folder. You should see it as "/dev/tty.usbmodem411" or similar.

PropellerTool can scan all available ports and find the one that has a propeller chip attached. So the above step might not be necessary, however if you already know the COM port of USBThumb you can specify it explicitly.

In the PropellerTool go to  Edit > Preferences>Operation and update the "Serial Port Search" to the port number of USBThumb (COM15 in my example). In the "Propeller Reset Signal" choose DTR.

Next attach the USBThumb to your Propeller development board, USBThumb's serial  4-pin connector is pin compatible with PropPlug. The pins are marked as follows RX,TX,RST,GND.

To test the communication with the propeller board press F7.

If you experience problems make sure the port is not open by any other software (like for example the propeller terminal software)

In some rare cases if you computer power supply is too noisy, to ensure greater stability you can place a 18pF filtering capacitor between pins 24 (RB5)  and 25 (RB6). See picture below:

You can solder the capacitor permanently between these pins, or if you're planning to use USBThumb for other projects and you have soldered sockets to the board simply insert the capacitor in the socket between pins 24 and 25. You only need to take this step if you have intermittent problems with PropellerTool not detecting the Propeller chip.

Release Notes / Change Log:

——————————————
2009-09-25
Config Utility Version 1.0.0
Device Firmware Version 1.5
——————————————

- device supports a wide range of accelerometers and gyroscopes
- implements smoothing filtering algorithm
- implements algorithm for combining gyroscope and accelerometer data
- HID USB interface makes the device compatible virtually with all modern operating systems (Mac,Windows,Linux)
- configuration utility (for Windows only for now)
- adjustable smoothing and scale factor for outputs
- configurable sensibility for accelerometer and gyroscope (can be set per axis)
- configurable midpoint (0g voltage) for accelerometer (can be set per axis)
- auto-find gyroscope midpoint (0 deg/s voltage)
- you can use separate accelerometer/gyroscopes for different axis
- Z axis not implemented in this release
- configurable analog input ports AN0-AN5 for each axis (please note 18F2550 does not have AN5 input , but 18F4550 does)
- ability to invert axis
- capture output and raw adc data into a comma separated values file (.csv)
- charting feature of all inputs/outputs
- graphical display of output and buttons
- supports up to 8 buttons
- configuration is stored in device EEPROM
- it is possible to use accelerometer alone on any axis (1, 2 or 3-axis) in this case set Smoothing to 0-10 value
- it is possible to gyro alone on any axis (1,2 or 3 axis) in this case set Smoothing to 100-255 , please note that the output will snap to middle after a while since gyro only provides rate information
- it is possible to use to use gyro and accelerometer on any axis (RECOMMENDED) in this case set smoothing to 20-100 value
- you can use multiple accelerometers or gyroscopes
- you can orient gyro or accelerometer as you like (but aligned to 90 degrees increments)
- you can connect your gyro and accelerometer outputs to any of the AN0-AN4 ports (for PIC18F2550).

Suggested Circuit Schematic

Below is a new suggested schematic , using a 2-axis Gyroscope and an a 2-axis Accelerometer. As mentioned above the new firmware and configuration utility is very flexible regarding the way the gyro and accelerometer are connected (this is one of the features requested , to be able to use device with various MEMS sensors).

Configuration Utility

Here is a screen shot of the configuration utility, please note that I am using the gyro just for one output axis (X), thus I set smoothing to 50 as recommended in release notes above. The other axis (Y) uses just accelerometer data so Smoothing is set to 5. Device automatically detected the Gyro midpoint to be 1.35V , you must hold device still for at least 1s to let it calibrate when you plug it in. The Gyro axis is also inverted due to the way it is mounted in the case.

Hardware Setup

My old accelerometer-only device , got modified to make space for a gyro. Here is how it all fit inside the case:

Demo

Finally here is a new demo with another game I found to work well with this device PURE. In this game you can actually use the FORWARD/BACK tilt (Y axis of the device), besides the usual LEFT/RIGHT (X axis) I demonstrated in the TMNations demos (see my first usb gamepad article).

Downloads

Configuration Utility Setup (Windows XP/Vista) StarlinoGamepadConfigSetup_100.exe

PIC18F2550 Firmware 18Fx550_USB_GAMEPAD_GYRO_15.hex (right click on the link and choose Save Link/Target As if HEX file opens in browser).

I will continue to edit this article , please let me know what questions/suggestions you have in the comments area below. I will try to update this page and design based on your feedback.

//starlino//

TRISAbits.TRISA2 = 1;  //make switch pin an input
WPUAbits.WPUA2 = 1;    //turn on the pull-up on switch pin
TRISBbits.TRISB5 = 0;  //make led pin an output

You could just right something like this, that allows you to change later on the PIN assigned for a specific function:

#define pinSwitch(f)       f(A,2)        //Declare Switch pin RA2
#define pinLed(f)          f(B,5)        //Declar Led pin RB5
_TRIS(pinSwitch) = 1; //make pin an input
_WPU(pinSwitch) = 1;  // turn on internal pull-up on switch pin
_TRIS(pinLed) = 0;    // make led pin an output

If you're interested how you can simplify your PIC/AVR C code then read on ….

—————–

I started working with MCUs using Basic Stamps 2. My first programs where written in PBASIC. I enjoyed the simplicity of this language but soon moved on to C. One particular thing that I was missing in the C enviroment was the ability to define a pin at the begining of the program and then perform various operations on it. (Make it an input or output, toggle the pin, read its level, output a high or low signal). PIC Microcontrollers make use of several registers to perform these operations, and if you change your pin you need to update all your lines of code that perform these operation.

To illustrate let's take a simple example. Let's say you have a button and a led, you'd like to create a simple application that will turn on the led when a momentary switch is pressed. The hardware setup will be very simple: the led is connected to an output pin of MCU (with a resitor in series to avoid burning the led); the switch is connected to another pin with an optional external pull-up resistor (some PIC and AVR can use an internal pull-up). Please note when the switch is pressed it will output 0 (LOW) and when it is not pressed it will output 1 (HIGH) due to the pull-up resistor.

 [VDD 5V]  
   |
  [RESISTOR 10K]
   |
P1 —-[SWITCH] — [GND]

P2 —-[RESISTOR ~ 200Ohm] —[LED]—[GND]

Now here is the PBASIC code:

pinSwitch  PIN 1
pinLed     PIN 2

INPUT  pinSwitch
OUTPUT pinLed

main:

 IF pinSwitch = 0 THEN
  HIGH pinLed
 ELSE
  LOW pinLed
 ENDIF

GOTO main

If you ever need to change the pins, let's say you want to swap the pins for led and switch all you need to change is the first two lines of code:

pinSwitch  PIN 2
pinLed     PIN 1

All the remaining PBASIC code remains the same.

Now let's look at the C18/C30 code for the PIC microcontroller. Hardware setup is similar except we're going to use the internal pull-up.

RA2—-[SWITCH] — [GND]

RB5 —-[RESISTOR ~ 200Ohm] —[LED]—[GND]

To accomplish same thing we'd have to write something like this in C:

TRISAbits.TRISA2 = 1; //make switch pin an input
WPUAbits.WPUA2 = 1; //turn on the pull-up
TRISBbits.TRISB5 = 0; //make led pin an output

while(1){
  PORTBbits.RB5 =  ! PORTAbits.RA2;
}

Now if you would need to swap the pins  you'd have to update pretty much every line of  C code. This is very inconvenient !!! This is why I came up with following macros for C18/C30 :

//———————————————————————
// MACROS FOR EASY PIN HANDLING IN PIC C18/C30
//———————————————————————
#define _TRIS(pin)            pin(_TRIS_F)
#define _TRIS_F(alpha,bit)    (TRIS ## alpha ## bits.TRIS ## alpha ## bit)
#define _PORT(pin)            pin(_PORT_F)
#define _PORT_F(alpha,bit)    (PORT ## alpha ## bits.R ## alpha ## bit)
#define _LAT(pin)            pin(_LAT_F)
#define _LAT_F(alpha,bit)    (LAT ## alpha ## bits.LAT ## alpha ## bit)
#define _WPU(pin)            pin(_WPU_F)
#define _WPU_F(alpha,bit)    (WPU ## alpha ## bits.WPU ## alpha ## bit)

//———————————————————————
// USAGE
//———————————————————————

#define pinSwitch(f)       f(A,2)        //Switch, INPUT , pin RA2
#define pinLed(f)          f(B,5)        //Led, OUTPUT , pin RB5

_TRIS(pinSwitch) = 1; //make pin an input
_WPU(pinSwitch) = 1; // turn on internal pull-up
_TRIS(pinLed) = 0; // make pin an output

while(1){ 
 _PORT(pinLed) = ! _PORT(pinSwitch)
}

This code is much better. If you need to swap the pins all you need to do is update two lines of code:

#define pinSwitch(f)       f(B,5)        //Switch, INPUT, pin RB5
#define pinLed(f)          f(A,2)        //Led, OUTPUT,  pin RA2

The rest of the code remains the same. The only confusing thing in this code might be the macro definitions. I have arrived at them through many trials and errors. Each pin is defined as a  macro function with a single parameter f   – which is another macro  function which we'd like to apply to this pin. Possible values for f are PORT_F , TRIS_F, LAT_F , WPU_F.

Here is an example how compiler interprets these statements: 

_PORT(pinLed)  =>    pinLed (PORT_F)   =>  PORT_F( B, 5)  =>  PORTBbits.RB5

Now moving on to AVR controllers. I am using gcc-avr compiler (Windows version). I came up with following macros that seem to work in this compiler:

// MACROS FOR EASY PIN HANDLING FOR ATMEL GCC-AVR
//these macros are used indirectly by other macros , mainly for string concatination
#define _SET(type,name,bit)            type ## name  |= _BV(bit)   
#define _CLEAR(type,name,bit)        type ## name  &= ~ _BV(bit)       
#define _TOGGLE(type,name,bit)        type ## name  ^= _BV(bit)   
#define _GET(type,name,bit)            ((type ## name >> bit) &  1)
#define _PUT(type,name,bit,value)    type ## name = ( type ## name & ( ~ _BV(bit)) ) | ( ( 1 & (unsigned char)value ) << bit )

//these macros are used by end user
#define OUTPUT(pin)            _SET(DDR,pin)   
#define INPUT(pin)            _CLEAR(DDR,pin)   
#define HIGH(pin)            _SET(PORT,pin)
#define LOW(pin)            _CLEAR(PORT,pin)   
#define TOGGLE(pin)            _TOGGLE(PORT,pin)   
#define READ(pin)            _GET(PIN,pin)

/*
    BASIC STAMPS STYLE COMMANDS FOR ATMEL GCC-AVR

    Usage Example:
    ———————————————–
    #define pinLed B,5  //define pins like this

    OUTPUT(pinLED);     //compiles as DDRB |= (1<<5);
    HIGH(pinLed);         //compiles as PORTB |= (1<<5);
    ———————————————–
*/

As a bonus, below are some macros for calculating MIN/MAX or translating a value to a different range, something similar to the map()  function that is already built-in into Arduino.

#define MIN(A,B)  (((A)<(B)) ? (A) : (B) )
#define MAX(A,B)  (((A)>(B)) ? (A) : (B) )
#define PUT_IN_RANGE(V,VMIN,VMAX) MAX(VMIN,MIN(VMAX,V))
#define MAP_TO_RANGE(V,VMIN0,VMAX0,VMIN1,VMAX1) ( (VMIN1) +  ( (V) – (VMIN0) ) * ( (VMAX1) – (VMIN1) ) / ( (VMAX0) – (VMIN0) ) )

Now , what do you do when you need your pin to actually be stored as a variable (it updates at run-time, or you might want to pass it as a parameter to a function). Let's say you would like to have 4 pins and perform some actions on those pins in bulk as well as define those pins are defined at run time ? The answer is pointers. Here I will illustrate with an example for C30 that you can adapt to your needs:

volatile unsigned int * tris_ptr[4];
unsigned char* pin_bit[4];

//define our pins as  RA2 , RA3 , RB5 , RB7 at run time

tris_ptr[0] = &TRISA;  pin_bit[0] = 2;  //RA2
tris_ptr[1] = &TRISA;  pin_bit[1] = 3;  //RA3

tris_ptr[3] = &TRISB;  pin_bit[2] = 5;  //RB5
tris_ptr[4] = &TRISB;  pin_bit[3] = 7;  //RB7

int i;

//perform bulk operations on pins

for(i=0;i<4;i++)
  if(i % 2){
   (*tris_ptr[i]) |= 1<<tris_bit[i];    //set bit, make odd pins INPUT 
  else
   (*tris_ptr[i]) ^=  !(1U<<tris_bit[i]); //clear bit, make even pins OUTPUT

In the same way you could define  port_ptr[] , lat_ptr[] , wpu_ptr[] arrays and perform operations on those ports. Even more smarter would be to group all these in a structure, and then create a single array of these structures. Using macros you could simplify assignment to these arrays in one simple statement. (I leave this as a homework for you) !

I hope you'll find this article usefull. If you have any comments or suggestions do not hesitate to leave a comment below !

Happy coding !

//starlino//