This forum uses cookies

Joshua_A · (This post was last modified: 07-May-2021, 10:45 PM by Joshua_A.)

Introduction

It is hard to list the vast number of configurations capable of sustaining flight... and in my opinion the Dragonfly is best: being quite, agile and efficient, its performance is hard to beat [or match, for that matter].
I've alway wanted to -someday- design my own Dragonfly inspired MAV, but was quickly discourage due to the nearly infinite number of possible configurations, and in turn, the project was delayed.
After some time, Festo unveiled there BionicOpter, I liked there design, but 9DOFs (Degrees Of Freedom) for the required articulation was pretty intense, I came up with a few designs that required only 5 DOFs (with the same, or better, flight performance, in theory) over the next few years, but wondered if they would work, so naturally I started to work on the project once again...
After some thought and five large alterations to my initial design, I have finally found a design I believe is sufficient, the rest of this thread will document my progress as I build, fly [hopefully], optimize and redesign the aircraft. Big Grin

Design/Project criteria

1). The flight battery (and any flight related system) will be entirely self-contained in the aircraft.
2). Ultimately using only the four [sets of] wings for lifting thrust and control.
3). Possess the ability to sustain flight in any flight heading and move horizontally without the [needed] change of heading.
4). Use only 5 DOFs for all the required articulation.

Aircraft overview

As mentioned earlier, there are 5 DOFs that ultimately will be used for normal control [Throttle, Yaw, Pitch and Roll] as well as linear movement [moving Forward, Backwards, Left and Right without Pitch/Roll rotation.] and "omniaxis" movement [hovering and linear flight at any angle of attack].

The required DOFs are as follows:
1. Rotation of left/forward wing, servo.
2. Rotation of right/forward wing, servo.
3. Rotation of right/rearward wing, servo.
4. Rotation or left/rearward wing, servo.
5. Wing power/frequency, motor.

And, YES, mixing will be "fun"... Rolleyes

Any questions/comments are appreciate! Smile

Joshua_A · (This post was last modified: 15-Jun-2021, 09:53 PM by Joshua_A.)

Workflow

[A "table of contents" for my research each of the five different categories: Hardware, Software, Electrical, Flight and Uncategorized, for better organization and for an easier browsing. ]

Hardware

Software

Electrical

Flight

Uncategorized

● Started mixing.
● Finished Rotation mode mixing
● Finished Linear mode mixing
● Rubber band model flys!

Joshua_A · (This post was last modified: 09-May-2021, 02:54 AM by Joshua_A.)

Flight data

{No flight data, yet.}

Joshua_A · (This post was last modified: 18-May-2021, 03:00 AM by Joshua_A.)

Because all my stuff has been packed up [moving], I will not be able the work on physical prototype.

So I will instead start mixing...

Given the complexity of the required mixing, conventional software (like Betaflight... ect.) is simply not suited for my application.
Ardupilot might be able, but the system is too "closed" for me and the supported hardware was too heavy.
After some time I found nicholas rehm's dRehm Flight, An Arduino supported flight control software, running on the Teensy 4.0.
I was quiet happy with this discovery and began thinking about mixing.

[I will update this post soon, as I work though a few things... ]

Rotation mode

This flight mode has many parallels with angle/rate mode used on multirotors, since aircraft rotation (and in turn, thrust) is used for both rotational stability and horizontal movement.
In fact, the basic algorithm can still be used, just the mixing will need be to be modified.

Throttle and Yaw mixing is easy...
[Fig. 1]

Unfortunately, since all sets of wings are equally powered, one must use "thrust dumping" to achieve rotation on the horizontal plane (e.g. Pitch and Roll), see figure.
[Fig. 2]

Now note that Rotation on both Pitch and Roll is impossible, instead liner horizontal movement is produced.
[Fig. 3]

This problem alone halted my progress entirely, untill I simply reversed one term (Pitch or Roll), now mixing is as follows.
[Fig. 4]

Now a small oddity becomes apparent: The mixing terms -Roll in this example- (but the same is true for Pitch), are different from left and right (or forward and backwards, respectively), instead of outputting the reciprocal command for the opposite desired action (as in a multirotor, or almost all other aircraft).

So, the mixing must be done in the following way:

Code:
  if(roll < 1500){
     roll_left = 0;
     roll_right = 1;
   }
   if(roll > 1500){
     roll_left = 1;
     roll_right = 0;
   }
 
   Output_X = (roll * roll_left) + (roll * roll_right);

The same can be done for pitch...

Code:
  if(pitch < 1500){
     pitch_forward = 0;
     pitch_rearward = 1;
   }
   if(pitch > 1500){
     pitch_forward = 1;
     pitch_rearward = 0;
   }
 
   Output_X = (pitch * pitch_forward) + (pitch * pitch_rearward);

Note dRehm flight excepts the following data, see Fig. 5
[Fig. 5]

Note: The "Rotation mode" mixing can be used for "angle" or "rate" mode, only the stability loop type needs to changed.

Edit: here's the finished Rotation mode mixing.

Linear mode

Linear horizontal movement with Rotational stability to sustain a fixed angle of attack, yaw and thrust mixing are left unchanged.

First, in order to maintain the desired angle of attack the PID input will have to equal a set variable not related to the movement of the aircraft...

Edit: here's the finished Linear mode mixing.

Omni-mode

First the various angles that are attainable will be constrained to the rotational X axis (pitch) and span from +90-0... Although, I hope to soon accept any angle of attack and Y (roll) axis... {e.g. 3D Omni-mode mixing}

For Roll/Yaw mixing at different AOAs (angles of attack)
[For angles >0 and <90].
*/ The multiple of yaw or roll increase is proportional to the legs of a right angle triangle whos angle is equal to the AOA
/*

Thus:

Code:
  //[Mixing for Yaw]//
  Yaw_multiplier = 100/((TAN(AOA))+1)
  Roll_multiplier = 100/((TAN(90-AOA))+1)
 
  //[Mixing for Roll]//
  Yaw_multiplier = 100/((TAN(90-AOA))+1)
  Roll_multiplier = 100/((TAN(AOA))+1)

[Note: (Yaw_multiplier) + (Roll_multiplier) = %100]

[Note: For simplicity I will only be demonstrating the following terms with the yaw mixing, roll is the reverse of yaw, so theres no need to make things more complex...]

So the equation becomes:

Code:
X = 100/((TAN(AOA))+1);
 
 
   //[Yaw mixing]//
  Yaw_multiplier = X
  Roll_multiplier = 100-X

Now note that:

Code:
Yaw_out = Yaw_multiplier*Yaw_in
 Roll_out = Roll_multiplier*Yaw_in

So the equation becomes:

Code:
 Yaw_out = X*Yaw_in
  Roll_out = (100-X)*Yaw_in

Now to add the Roll mixing ...

Code:
 //[Yaw mixing]//
  Yaw_out = X*Yaw_in
  Roll_out = (100-X)*Yaw_in
 
  //[Roll mixing]//
  Yaw_out = (100-X)*Roll_in
  Roll_out = X*Roll_in

Add to like terms together...

Code:
Yaw_out = (X*Yaw_in)+((100-X)*Roll_in)
 Roll_out = ((100-X)*Yaw_in)+(X*Roll_in)

Finished!

Code:
 X = 100/((TAN(AOA))+1)
  Yaw_out = (X*Yaw_in)+((100-X)*Roll_in)
  Roll_out = ((100-X)*Yaw_in)+(X*Roll_in)

(Well, theres still the 90 degree and 0 degree mixing...)

[ For angle = 90 or = 0]

Code:
  If(AOA == 90) {
      Yaw_out = Roll_in;
      Roll_out = Yaw_in;
 }
   If(AOA == 0) {
     Yaw_out = Yaw_in;
     Roll_out = Roll_in;
 }

Now to add the entire range (0-90 degrees)

Code:
X = 100/((TAN(AOA))+1);
 
    If(AOA == 90) {
      Yaw_out = Roll_in;
      Roll_out = Yaw_in;
 }
   If(AOA == 0) {
     Yaw_out = Yaw_in;
     Roll_out = Roll_in;
 }
   else {
    Yaw_out = (Yaw_in*X) + (Roll_in*(100-X));
    Roll_out = (Roll_in*X) + (Yaw_in*(100-X));
 }

Finally finished!

Joshua_A · 11-May-2021, 09:55 PM

Rotation mode Mixing

Because "Rotation mode" is the flight mode for testing (I certainly wouldn't like to do the maiden flight in Omni-mode Big Grin

) I've decided to finish the entire mixing code for rotation mode, here it goes:

First, when mixing I like to draw a quick workflow:

Note:
> The "+" shows the direction of wing rotation with increased input.
> The wings dump thrust to the left and right or the aircraft.
> "m1" is the motor used for powering the wings.
> s1-4 are the servos, the order is important.
> The wing are placed 90 degrees from another.

>>> mixing for throttle [try to wrap your head around this one Big Grin

]

Code:
m1_command_scaled = thro_des;

>>> mixing for pitch

Code:
int pitch_forward;
 int pitch_rearward;
 
 if(pitch_PID < 1500){
    pitch_forward = 0;
    pitch_rearward = 1;
  }
 
  if(pitch_PID > 1500){
    pitch_forward = 1;
    pitch_rearward = 0;
  }
 
 s1_command_scaled = (pitch_PID * (- pitch_forward));
 s2_command_scaled = (pitch_PID * pitch_forward);
 s3_command_scaled = (pitch_PID * (- pitch_rearward));
 s4_command_scaled = (pitch_PID * pitch_rearward);

>>> mixing for roll

Code:
int roll_left;
 int roll_right;
 
 if(roll_PID < 1500){
    roll_left = 0;
    roll_right = 1;
  }
  if(roll_PID > 1500){
    roll_left = 1;
    roll_right = 0;
  }
 
 s1_command_scaled = (roll_PID * (- roll_left));
 s2_command_scaled = (roll_PID * roll_right);
 s3_command_scaled = (roll_PID * (- roll_right));
 s4_command_scaled = (roll_PID * roll_left);

>>> mixing for yaw

Code:
s1_command_scaled = yaw_PID;
 s2_command_scaled = yaw_PID;
 s3_command_scaled = yaw_PID;
 s4_command_scaled = yaw_PID;

>>>All together now...

Code:
int pitch_forward;
 int pitch_rearward;
 int roll_left;
 int roll_right;
 
 if(pitch_PID < 1500){
     pitch_forward = 0;
     pitch_rearward = 1;
   }
 
   if(pitch_PID > 1500){
     pitch_forward = 1;
     pitch_rearward = 0;
   }
 
 if(roll_PID < 1500){
     roll_left = 0;
     roll_right = 1;
   }
 
   if(roll_PID > 1500){
     roll_left = 1;
     roll_right = 0;
   }
 
 m1_command_scaled = thro_des;
 s1_command_scaled = (pitch_PID * (- pitch_forward)) + (roll_PID * (- roll_left)) + (yaw_PID);
 s2_command_scaled = (pitch_PID * pitch_forward) + (roll_PID * roll_right) + (yaw_PID);
 s3_command_scaled = (pitch_PID * (- pitch_rearward)) + (roll_PID * (- roll_right)) + (yaw_PID);
 s4_command_scaled = (pitch_PID * pitch_rearward) + (roll_PID * roll_left) + (yaw_PID);

Joshua_A · (This post was last modified: 18-May-2021, 02:54 AM by Joshua_A.)

The move has been delayed, again. Rolleyes

If this gose on much longer I'm unpacking my "CADing" computer... Big Grin

Anyway, I got bored and began the mixing for linear mode... just for the fun of it.

Linear mode Mixing

From the flight mode introduction:
Linear mode:

Quote:First, in order to maintain the desired angle of attack the PID input will have to equal a set variable not related to the movement of the aircraft...

Thus the following code will be added to the "getDesState" loop.

Code:
void getDesState() {
 
  if(flight_mode_channel >1300 && <1700){
     roll_des = 0;         // hold to center 
     pitch_des = 0;     // hold to center
       }
 }

Note: later "roll_des" and "pitch_des" will be adjusted for multiaxis flight [Omni-mode], although thats for later... linear mode will be set to zero or center for now, just to make it easier to understand.

For linear "roll" (left and right movement)

Code:
s1_command_scaled = ( -roll_passthru);
 s2_command_scaled = ( -roll_passthru);
 s3_command_scaled = roll_passthru;
 s4_command_scaled = roll_passthru;

For linear "pitch" (forward and rearward movement)

Code:
s1_command_scaled = ( -pitch_passthru);
 s2_command_scaled = pitch_passthru;
 s3_command_scaled = pitch_passthru ;
 s4_command_scaled = ( -pitch_passthru);

Linear mode only [without rotation stability]
[For roll -1 = left]
[For pitch -1 = backwards]

Code:
if(flight_mode_channel >1300 && <1700){
    linear_mode = 1;
 }
 
 s1_command_scaled = ((( -pitch_passthru) + ( -roll_passthru)) * linear_mode) ;
 s2_command_scaled = ((pitch_passthru +  ( -roll_passthru)) * linear_mode);
 s3_command_scaled = ((pitch_passthru + roll_passthru) * linear_mode);
 s4_command_scaled = ((( -pitch_passthru) + roll_passthru) * linear_mode);

All together now.
[rotation mode and linear mode with Rotation stability.]

Code:
int pitch_forward;
 int pitch_rearward;
 int roll_left;
 int roll_right;
 
 if(pitch_PID < 1500){
    pitch_forward = 0;
    pitch_rearward = 1;
  }
 
  if(pitch_PID > 1500){
    pitch_forward = 1;
    pitch_rearward = 0;
  }
 
 if(roll_PID < 1500){
    roll_left = 0;
    roll_right = 1;
  }
 
  if(roll_PID > 1500){
    roll_left = 1;
    roll_right = 0;
  }
 
 if(flight_mode_channel >1300 && <1700){
    linear_mode = 1;
 }
   else {
    linear_mode = 0;
 }
 
 m1_command_scaled = thro_des;
 
 s1_command_scaled = (pitch_PID * (- pitch_forward)) + (roll_PID * (- roll_left)) + (yaw_PID) + ((( -pitch_passthru) + ( -roll_passthru)) * linear_mode) ;
 
 s2_command_scaled = (pitch_PID * pitch_forward) + (roll_PID * roll_right) + (yaw_PID) + ((pitch_passthru +  ( -roll_passthru)) * linear_mode);
 
 s3_command_scaled = (pitch_PID * (- pitch_rearward)) + (roll_PID * (- roll_right)) + (yaw_PID) + ((pitch_passthru + roll_passthru) * linear_mode);
 
 s4_command_scaled = (pitch_PID * pitch_rearward) + (roll_PID * roll_left) + (yaw_PID) + ((( -pitch_passthru) + roll_passthru) * linear_mode);

V-22 · 15-Jun-2021, 03:06 AM

I just came across this wild build on RCG, and was reminded of your project! How i it coming along?

Joshua_A · 15-Jun-2021, 07:10 PM

(15-Jun-2021, 03:06 AM)V-22 Wrote: I just came across this wild build on RCG, and was reminded of your project! How i it coming along?

I am following that thread on RCGs Big Grin

...

I've been busy recently, so there is little process made.

Your right though, it's time for an update:

Rubber band prototypes

Before I invested too much time in the DragonFlight project I thought it wise to construct a few small prototypes to see if my initial ideas were sustainable and to increase my knowledge of vtol Ornithopters in general.

Here's my latest model:
Dragonfly V5

Weight [dry]: 9 grams
Weight [with rubber]: 12 grams
Rubber used: 1/8" x 18"
Thrust/Weight ratio: 1.45/1

There are a few design flaws, I hope to have V6 out soon with the design issues rectified.

[To do] post videos and 3D models.

Joshua_A · 17-Mar-2022, 12:30 AM

Life has been busy, but now it's Spring break!

And it's far past time for an update...

I have now started the design in CAD, although I am not yet finished the "bones" are in place:

Also I have selected the components for the project:
Battery: RDQ series 2s 350 mAh lipo.
Motor: Axis Flying 1404 4510 Kv motor.
Servos: Emax ES9051, 4X.
RX: some micro Spektrum RX with sbus. (I will use an ELRS EP2 RX when I program support for CRSF)
FC: Teensy 4.0 with MPU6050 gyro, running a highly modified version of dRehm flight 1.2 beta.
ESC: I have a few choices, I will go with the lightest version that doesn't smoke up. Big Grin

BEC: 5volt, 2 Amp.

Now I must be off to finish the design...

Joshua_A · 24-May-2022, 11:45 PM

Finishing the designs

After some thought the designs really came together!
The aircraft splits in half, so the gears and bushings can be inserted.

The wings "Flap Box"

Some improvements can be made, though I think the designs will be adequate for now.
Time to print!

Printing

My current Prusa MK2s (with a 0.4mm nozzle) had a hard time printing the tiny gears for the drive train, so I bought a Creality LD-002r and will use Siraya tech blu resin. Although this was not the solution I had been hoping for... the resin took forever to cure, post processing took almost as much time as its FFF counter parts, and the finished parts lacked stiffness. Long story short: I once again returned to the Prusa. Big Grin

All the part are printed in Carbon PETg.

The top and Bottom frame [24 grams].

Motor drive gears.

Secondary drive gears.

Wing "Flap Box".

The top frame posed the only major issue: the Emax ES9051 Servos did not fit as expected. Why, because for some reason Emax has two specification sheets on there site, and I have to use the wrong one... Rolleyes

[The mounting hole distance is 25.1mm, not 23.5mm] After I redesigned the top frame, everything worked as expected.
Every printed part needed some degree of sanding. But all in all the 0.4mm nozzle worked like champ.

next up: Assembly!

Login
Email:
Password:	Lost Password?
	Remember me