Posts | Comments

Planet Arduino

Archive for the ‘FPV’ Category

If you’re going to be flying around a FPV-capable aircraft, be it a quadcopter or a fixed-wing plane, you shouldn’t be surprised if bystanders want to take a turn wearing your googles. Of course we hope that you’re good enough flying line of sight that you don’t need to be wearing the googles to stay airborne, but it does make it harder to pull off the sort of tricks and maneuvers that your audience wants to see. So if you want to put on a good show, the audience really needs their own display.

Unfortunately, as avid FPV flier [Michael Delaney] discovered, even the “cheap” ones will run you at least $100 USD. So he did what any self-respecting hacker would do, he set out to build his own. Using a collection of off the shelf components he was able to build a very impressive monitor that lets the viewer see through the eyes of his quadcopter at less than half the cost of commercially available offerings. Though even if he hadn’t manged to beat the cost of a turn-key monitor, we think it would have been more than worth it for this piece of highly customized gear.

At the heart of the monitor is a Boscam RX5808 5.8 GHz receiver, which is controlled by an Arduino Pro Mini. The video output from the receiver is sent to a 4.2″ TFT screen intended for the Raspberry Pi, and on the backside of the laser-cut wooden enclosure there’s a 128 x 64 I2C OLED to display the currently selected channel and diagnostic information.

An especially nice touch for this project is the custom PCB used to tie all the components together. [Michael] could have taken the easy route and sent the design out for fabrication, but instead went with the traditional method of etching his own board in acid. Though he did modernize the process a bit by using a laser and pre-sensitized copper clad board, a method that seems to be gaining in popularity as laser engravers become a more common component of the hacker’s arsenal.

We’ve previously covered using the RX5808 and Arduino combo to create a spectrum analyzer, in case you want to do more than just watch your friends do powerloops.

A good robot is always welcome around here at Hackaday, and user [igorfonseca83]’browser-controlled ‘bot s is no exception. Felines beware.

[igorfonseca83] — building on another project he’s involved in — used simple materials for the robot itself, but you could use just about anything. His goal for this build was to maximize accessibility in terms of components and construction using common tools.

An Arduino Uno gets two D/C motors a-driving using an H-bridge circuit — granting independent control the wheels — an ESP8266 enabling WiFi access, with power provided by a simple 5V USB power bank. [igorfonseca83] is using an Android smartphone to transmit audio and video data; though this was mostly for convenience on his part, a Raspberry Pi and camera module combo as another great option!

A few workarounds notwithstanding — considering some components in this particular configuration do not directly connect to each other — a bunch of code, set up of a website to act as a controller that accesses the IP address of the ESP8266, and an app installed on the audio/video streaming smartphone later, and you have a cat-stalking robot ready to rock. There are, of course, other uses for fpv robots, but with arguably less entertaining results.

[via and Instructables]

Filed under: Android Hacks, Arduino Hacks, robots hacks

Follow your cat with FPV camera and Arduino Leonardo

arduino, camera, Featured, FPV, leonardo, Robot Commenti disabilitati su Follow your cat with FPV camera and Arduino Leonardo 


After the Bike Tachometer we posted back in September, Nikus  shared with us a new Instructable to show you how to build remote-controlled tank using a first person view (FPV) camera and Arduino Leonardo:

At the beginning I build only RC tank without FPV camera but when I was driving it in the house I have not seen where it is. So I came up with that I will add to it the camera mounted on a 2 servos. The range is about 100m, you can also ride with it at home. With this tank you can see what your cat is doing when you’re not looking. You can see it on a video :D

Watch it in action and follow the tutorial:



The Stig Goes FPV cool hat

FPV, stig, the stig, top gear Commenti disabilitati su The Stig Goes FPV cool hat 

Published on Jun 10, 2013
Learn more about FatShark here:

iBcrazy stops by and shares the results of his Long Range System (LRS) shootout!
More details about this episode here:

Learn more about FPV Frequencies:

How we capture Air to air video:

Special thanks to Jeremiah (of Stone Blue Airlines) for helping us in the studio on this episode!!

Thanks for watching!

Small FPV Setup 2.4Ghz

FPV, light weight Commenti disabilitati su Small FPV Setup 2.4Ghz 

200 mW TX on a 120mAh Lipo runs about 30 mins. Total weight with Lipoly 6.2 Grams, only 3.6 Grams with a 5V regulator so it runs of the main battery. The image is not great on a single Lipo cell. I will try it connected to a spare port on the RX see what the signal is like.

Very small FPV camera and TX

With this camera you need to block out the light from the back of this camera of the PCB tracks show in the video feed. It needs a light enclosure for the whole assembly, nice and thin so it won't drag too much on top of a wing of where ever.The wires on the camera are a little fragile so I potted them in hot glue so they don't fatigue.

This 2.4Ghz 200mW AV transmitter is perfect for FPV applications. This unit offers a great low cost AV solution for your micro FPV models.
Input Voltage: DC 3.7-5V 
Consumption current: 220mA 
Working Frequency: 2.4G 
Channel: 4CHS 
Output Power: 200mW 
Video input / video modulation: 1 Vp-p(FM) 
Audio input / audio modulation: 1 Vp-p(FM) 
Audio carrier: 6.0M 
Weight: 2.7g 
Dimension: 17.8*18.2*4.5mm 
Color: Silver
Transmission distance (Open Space): 50M~150M 
Operating Temperature: -10deg C ~ +55deg C
Channels: 2414, 2432, 2450, 2468

This 420TVL Micro Camera with LED is perfect for FPV applications. The included LED ring provides visibility in dark conditions. This unit is a great low cost option for your FPV model.
Pixel: 400000 
Resolution: 420 lines
Illumination: 0.1 LUX
Lens: 2.78mm
Angle: 62 degrees
Power: 3.5~5V DC
Voltage: 100mA
Red = positive
Black = negative
Yellow = video
White = LED 
Weight: 2g

2.4Ghz AV FPV Receiver (Arduino Compatible)

This module is a 2.4Ghz band micro-power radio communications receiver, generally used to transfer audio and / or video in Arduino applications.
Designed around a low-power integrated VCO, PLL and a broadband FM video demodulator using a FM sound carrier frequency. This module complies with CE - FCC leakage requirements.

The applications for this module are vast and only limited by your imagination. This unit can also be used as a great low cost 2.4ghz Micro FPV solution.


2.4Ghz wideband FM A/V receiver

Small footprint


Low power consumption: 110mA

Operating voltage: 3.7-5v
Receiver Sensitivity: -90dBm
Channels: 2414, 2432, 2450, 2468
Dimensions: 36 x 23.5 x 6mm


Yellow Plane 2 Near Completion

coroflute, coroplast, Corriboard, FPV, scratch built, twinboard Commenti disabilitati su Yellow Plane 2 Near Completion 

Yellow Plane 2 Near Completion  

Wing Loading         15 oz/ft² 
Motor Power           410 W
Power/Mass            267 Watts/Kg

Fuselage Mass  1040 mm
Wing Span          1200 mm
Wing Chord          280 mm
Take off Mass   1536 Grams


Yellow Plane 2 with Inverted V Tail

arduino, Flying, FPV, gallery, gyro, plane, RC, remote control, Remote Control (Invention), stability, training, xBee Commenti disabilitati su Yellow Plane 2 with Inverted V Tail 


[nickatredbox] keeps up to date with the improvements of his project [yellow plane]. As you can find on this blog, the project is evolving week by week. Let’s see what’s today submission

1200 mm Wing space
280 mm cord
14% Clark Y
Target AUW 1300 Grams

Missing battery and camera box have a design which should weigh 140 grams empty.
The assembly shown below weighs 684 Grams no motor or electronics.
Electronics shown weigh 110 grams ESC Arduino board, Xbee, antenna and Gyro board
Motor & prop another 120 Gram

Here you have a [video]  and there you can follow the project on the [website]

New Code
Kalman Filter

This is the code in the main loop UpdateServos()

    unsigned long msDelta = LastMicros - micros();
    LastMicros = micros();
    //Measure time since last cycle
    double dt = (double)msDelta / 1000000.0;
    // The angle should be in degrees and the rate should be in degrees per second and the delta time in seconds    
    double X_Angle = (double)AnIn[0];
    double X_Rate = (double)AnIn[4];
    double Kalman_X = kalman[0].getAngle(X_Angle, X_Rate, dt);
    double Y_Angle = (double)AnIn[1];
    double Y_Rate = (double)AnIn[5];
    double Kalman_Y = kalman[1].getAngle(Y_Angle, Y_Rate, dt);
    double Z_Angle = (double)AnIn[2];
    double Z_Rate = (double)AnIn[6];
    double Kalman_Z = kalman[2].getAngle(Z_Angle, Z_Rate, dt);

/* Copyright (C) 2012 Kristian Lauszus, TKJ Electronics. All rights reserved.

 This software may be distributed and modified under the terms of the GNU
 General Public License version 2 (GPL2) as published by the Free Software
 Foundation and appearing in the file GPL2.TXT included in the packaging of
 this file. Please note that GPL2 Section 2[b] requires that all works based
 on this software must also be made publicly available under the terms of
 the GPL2 ("Copyleft").

 Contact information

 Kristian Lauszus, TKJ Electronics
 Web      :
 e-mail   :

#ifndef _Kalman_h
#define _Kalman_h

class Kalman {
    Kalman() {
        /* We will set the varibles like so, these can also be tuned by the user */
        Q_angle = 0.001;
        Q_bias = 0.003;
        R_measure = 0.03;
        bias = 0; // Reset bias
        P[0][0] = 0; // Since we assume tha the bias is 0 and we know the starting angle (use setAngle), the error covariance matrix is set like so - see:
        P[0][1] = 0;
        P[1][0] = 0;
        P[1][1] = 0;
    // The angle should be in degrees and the rate should be in degrees per second and the delta time in seconds
    double getAngle(double newAngle, double newRate, double dt) {
        // KasBot V2  -  Kalman filter module -
        // Modified by Kristian Lauszus
        // See my blog post for more information:
        // Discrete Kalman filter time update equations - Time Update ("Predict")
        // Update xhat - Project the state ahead
        /* Step 1 */
        rate = newRate - bias;
        angle += dt * rate;
        // Update estimation error covariance - Project the error covariance ahead
        /* Step 2 */
        P[0][0] += dt * (dt*P[1][1] - P[0][1] - P[1][0] + Q_angle);
        P[0][1] -= dt * P[1][1];
        P[1][0] -= dt * P[1][1];
        P[1][1] += Q_bias * dt;
        // Discrete Kalman filter measurement update equations - Measurement Update ("Correct")
        // Calculate Kalman gain - Compute the Kalman gain
        /* Step 4 */
        S = P[0][0] + R_measure;
        /* Step 5 */
        K[0] = P[0][0] / S;
        K[1] = P[1][0] / S;
        // Calculate angle and bias - Update estimate with measurement zk (newAngle)
        /* Step 3 */
        y = newAngle - angle;
        /* Step 6 */
        angle += K[0] * y;
        bias += K[1] * y;
        // Calculate estimation error covariance - Update the error covariance
        /* Step 7 */
        P[0][0] -= K[0] * P[0][0];
        P[0][1] -= K[0] * P[0][1];
        P[1][0] -= K[1] * P[0][0];
        P[1][1] -= K[1] * P[0][1];
        return angle;
    void setAngle(double newAngle) { angle = newAngle; }; // Used to set angle, this should be set as the starting angle
    double getRate() { return rate; }; // Return the unbiased rate
    /* These are used to tune the Kalman filter */
    void setQangle(double newQ_angle) { Q_angle = newQ_angle; };
    void setQbias(double newQ_bias) { Q_bias = newQ_bias; };
    void setRmeasure(double newR_measure) { R_measure = newR_measure; };
    /* variables */
    double Q_angle; // Process noise variance for the accelerometer
    double Q_bias; // Process noise variance for the gyro bias
    double R_measure; // Measurement noise variance - this is actually the variance of the measurement noise
    double angle; // The angle calculated by the Kalman filter - part of the 2x1 state matrix
    double bias; // The gyro bias calculated by the Kalman filter - part of the 2x1 state matrix
    double rate; // Unbiased rate calculated from the rate and the calculated bias - you have to call getAngle to update the rate
    double P[2][2]; // Error covariance matrix - This is a 2x2 matrix
    double K[2]; // Kalman gain - This is a 2x1 matrix
    double y; // Angle difference - 1x1 matrix
    double S; // Estimate error - 1x1 matrix


New parts
Turnigy L3010C-1300kv (420w)

H-KING 50A Fixed Wing Brushless Speed Controller
ZIPPY Compact 2700mAh 3S 25C Lipo Pack
HobbyKing 929MG Metal Gear Servo 2.2kg/ 12.5g/ 0.10sec


1200 mm Wing span
280 mm cord
14% Clark Y
Length 950 mm

 AUW 1521 Grams Wing loading 14.83 oz/ft²  power to weight 270 Watts A Kg should perform much better than Yellow plane one.

Missing battery and camera box have a design which should weigh 140 grams empty.
The assembly shown below weighs 684 Grams no motor or electronics.
Electronics shown weigh 110 grams ESC Arduino board, Xbee, antenna and Gyro board
Motor and prop another 120 Gram

The code with the mixing and stability feedback, all looks Ok on the bench

void UpdateServos()

//Digital inputs TX code helper
//TxVal[8] |= (digitalRead(5) << 0);//joy 2 push
//TxVal[8] |= (digitalRead(6) << 1);//pb
//TxVal[8] |= (digitalRead(7) << 2);//slide
//TxVal[8] |= (digitalRead(8) << 3);//toggle

//Throttle TxVal[1]
//Rotary pot TxVal[2]
//Joy 1 X TxVal[3]
//Joy 1 Y TxVal[4]
//Joy 2 X TxVal[5]
//Joy 2 Y TxVal[6]
//rssi TxVal[7]
//digital TxVal[8]
//micros() TxVal[9]

//Use the pot as the gain for all channels for now
float GainPot = (float)(TxVal[2]) * 0.001f;

//Get the target values from the TX
int PitchTarg = (TxVal[3] / 10);
int RollTarg = (TxVal[4] / 10);
int YawTarg = (TxVal[6] / 10);

//Prime the Target WOZ values
if(PitchTargWOZ == 9999)
PitchTargWOZ = PitchTarg;

if(RollTargWOZ == 9999)
RollTargWOZ = RollTarg;

if(YawTargWOZ == 9999)
YawTargWOZ = YawTarg;

//Get the Centered target values
float PitchTargCentred = (float)(PitchTarg - PitchTargWOZ);
float RollTargCentred = (float)(RollTarg - RollTargWOZ);
float YawTargCentred = (float)(YawTarg - YawTargWOZ);

//Calculate gains
float PitchGain = GainPot * 1.0f;
float RollGain = GainPot * 1.0f;
float YawGain = GainPot * 1.0f;

//Get Gyro values
float PitchGyro = (float)(AnIn[2] - AnInWOZ[2]);
float RollGyro = (float)(AnIn[1] - AnInWOZ[1]);
float YawGyro = (float)(AnIn[0] - AnInWOZ[0]);

//Calc P error
float PitchError = (float)PitchTargCentred + PitchGyro;
float RollError = (float)RollTargCentred + RollGyro;
float YawError = (float)YawTargCentred + YawGyro;

//Apply gains
int PitchTrim = (int)(PitchError * PitchGain);
int RollTrim = (int)(RollError * RollGain);
int YawTrim = (int)(YawError * YawGain);

//Constaring trim authority
PitchTrim = constrain(PitchTrim, -30, 30);
RollTrim = constrain(RollTrim, -30, 30);
YawTrim = constrain(YawTrim, -30, 30);

//Dump the trim value
if((TxVal[9] & 0x4) == 0)
PitchTrim = 0;
RollTrim = 0;
YawTrim = 0;

//Calc flap anglke
int Flaps = 0;

//Apply flaps
if((TxVal[9] & 0x8) == 0)
Flaps = -25;

val = TxVal[1] / 10;
val = map(val, 1, 179, 30, 179);
val = constrain(val, 1, 165); // scale it to use it with the servo (value between 0 and 180)
servo[0].write(val); // sets the servo position according to the scaled value

//Vee tail

//Left Elevator Joy 1 Y TxVal[4]
val = (YawTarg + YawTrim) + (PitchTargCentred + PitchTrim);
val = constrain(val, 15, 165);
val = map(val, 0, 179, 135, 45); // scale it to use it with the servo (value between 0 and 180)
servo[1].write(val); // sets the servo position according to the scaled value

//Right Elevator Joy 1 Y TxVal[4]
val = (YawTarg + YawTrim) - (PitchTargCentred + PitchTrim);
val = constrain(val, 15, 165);
val = map(val, 0, 179, 135, 45); // scale it to use it with the servo (value between 0 and 180)
servo[2].write(val); // sets the servo position according to the scaled value

//Left Flaperon
val = 90 + (RollTargCentred + Flaps) + RollTrim;
val = constrain(val, 15, 165);
val = map(val, 0, 179, 165, 15); // scale it to use it with the servo (value between 0 and 180)
servo[3].write(val); // sets the servo position according to the scaled value

//Right Flaperon
val = 90 + (RollTargCentred - Flaps) + RollTrim;
val = constrain(val, 15, 165);
val = map(val, 0, 179, 165, 15); // scale it to use it with the servo (value between 0 and 180)
servo[4].write(val); // sets the servo position according to the scaled value

//Joy 2 x nose Wheel
val = (TxVal[6] / 10);
val = map(val, 0, 179, 55, 125);
servo[5].write(val); // sets the servo position according to the scaled value


14% Clark Y more or les given the limitations of the Coroplast

Found out why the maiden flight ended with Issac Newton attacking my plane. The pilot said it seemed to loose power as she turned into the wind, and he was flat out for whole flight due to the excessive weight of all that Corriboard, I have a lighter air frame in the works 1300 Grams wing loading 12.53 oz/ft², 250 Watts per Kilo Please see the spreadsheet. I think its highly likely she just ran out of juice?

This is why I suspect the battery state

Turnigy Accucel-6 50W 6A Balancer/Charger

Input Voltage: 11~17v
Circuit power: Max Charge: 50W / Max Discharge: 5W
Charge Current Range: .1~6.0A
Ni-MH/NiCd cells: 1~15
Li-ion/Poly cells: 1~6
Pb battery voltage: 2~20v

Some how or other my charger was set to a max CAPA of 200mAh so my batteries were never charged. My wife helpfully pointed out that I should have read the manual (Here is the manual) but that just isn't the bloke way, why do girls not get that?

Maiden flight of Yellow Plane flown by a local pilot Richard to avoid instant crash I would cause. A little tail heavy but flew pretty well on a gusty day, I'm told control was good. Ended in a crash but not too badly damaged, learned a lot. I'm just chuffed if flew looks pretty good on such a windy, which is pretty standard for the south island this time of year.

My scratch built FPV platform. Took around 30 hours to build mostly Corriboard with some ply, aluminium and carbon fiber spars. Total material cost around 50 US$. Got a DT700 (see tests data here) which hopefully will be an adequate power source. Its a modular design based around an armature, so wings and tail etc are bolted on and can be exchanged for testing parts and ideas. Have a pair of KM3 wings and the Corriboard ones shown below.

Please see the spread sheet here Yellow Plane Data 

More Links
The RX Build
Power Tests
More Test Data
Xbee's and Arduinos
Controller using Tiny CLR
Xbee Helpers

Based around a stiff wooden armature and two aluminium tail spars the wings are removable for transportation. According to my calculations the wing loading is 15.5 Oz/Ft² at a flight weight of 1700 Grams. A glass fiber nose has been molded and is curing now which is around 80 grams, which will contain the FPV gear and the main battery.

Home brew Arduino Xbee remote control 

  • Newsletter

    Sign up for the PlanetArduino Newsletter, which delivers the most popular articles via e-mail to your inbox every week. Just fill in the information below and submit.

  • Like Us on Facebook