lightweight airplane design -凯发k8网页登录

defining vehicle geometry

the geometry of this lightweight aircraft is from reference 1. the original design objective for this geometry was a four-seat general aviation aircraft that was safe, simple to fly, and easily maintainable with specific mission and performance constraints. for more details on these constraints, see reference 1.

potential performance requirements for this aircraft include:

for the aircraft flight control, rate of climb is the design requirement and assumed to be greater than 2 meters per second (m/s) at 2,000 meters.

figure 1: lightweight four-seater monoplane [1].

determining vehicle aerodynamic characteristics

the aircraft's geometrical configuration determines its aerodynamic characteristics, and therefore its performance and handling qualities. once you choose the geometric configuration, you can obtain the aerodynamic characteristics by means of:

while wind tunnel tests and flight tests provide high-fidelity results, they are expensive and time- consuming, because they must be performed on the actual hardware. it is best to use these methods when the aircraft's geometry is finalized. note: analytical prediction is a quicker and less expensive way to estimate aerodynamic characteristics in the early stages of design.

in this example, we will use digital datcom, a popular software program, for analytical prediction. the u.s. air force developed it as a digital version of its data compendium (datcom). this software is publicly available.

to start, create a digital datcom input file that defines the geometric configuration of our aircraft and the flight conditions that we will need to obtain the aerodynamic coefficients.

 $fltcon nmach=4.0,mach(1)=0.1,0.2,0.3,0.35$                                    
 $fltcon nalt=8.0,alt(1)=1000.0,3000.0,5000.0,7000.0,9000.0,                    
   11000.0,13000.0,15000.0$                                                      
 $fltcon nalpha=10.,alschd(1)=-16.0,-12.0,-8.0,-4.0,-2.0,0.0,2.0,               
   alschd(8)=4.0,8.0,12.0,loop=2.0$                                              
 $optins sref=225.8,cbarr=5.75,blref=41.15$                                     
 $synths xcg=7.9,zcg=-1.4,xw=6.1,zw=0.0,aliw=1.1,xh=20.2,                       
    zh=0.4,alih=0.0,xv=21.3,zv=0.0,vertup=.true.$                                
 $body nx=10.0,                                                                 
    x(1)=-4.9,0.0,3.0,6.1,9.1,13.3,20.2,23.5,25.9,                               
    r(1)=0.0,1.0,1.75,2.6,2.6,2.6,2.0,1.0,0.0$                                   
 $wgplnf chrdtp=4.0,sspne=18.7,sspn=20.6,chrdr=7.2,savsi=0.0,chstat=0.25,       
    twista=-1.1,sspndd=0.0,dhdadi=3.0,dhdado=3.0,type=1.0$                       
 $htplnf chrdtp=2.3,sspne=5.7,sspn=6.625,chrdr=0.25,savsi=11.0,                 
    chstat=1.0,twista=0.0,type=1.0$                                              
 $vtplnf chrdtp=2.7,sspne=5.0,sspn=5.2,chrdr=5.3,savsi=31.3,                    
    chstat=0.25,twista=0.0,type=1.0$                                             
 $symflp ndelta=5.0,delta(1)=-20.,-10.,0.,10.,20.,phete=.0522,                  
    chrdfi=1.3,                                                                  
    chrdfo=1.3,spanfi=.1,spanfo=6.0,ftype=1.0,cb=1.3,tc=.0225,                   
    phetep=.0391,ntype=1.$                                                       
naca-w-4-0012                                                                   
naca-h-4-0012                                                                   
naca-v-4-0012                                                                   
caseid skyhogg body-wing-horizontal tail-vertical tail config                   
damp                                                                            
next case                                                                       

digital datcom provides the vehicle's aerodynamic stability and control derivatives and coefficients at specified flight conditions. flight control engineers can gain insight into the vehicle's performance and handling characteristics by examining stability and control derivatives. we must import this data into the matlab® technical computing environment for analysis. normally, this is a manual process.

with the aerospace toolbox software, we can bring multiple digital datcom output files into the matlab technical computing environment with just one command. there is no need for manual input. each digital datcom output is imported into the matlab technical computing environment as a cell array of structures, with each structure corresponding to a different digital datcom output file. after importing the digital datcom output, we can run multiple configurations through digital datcom and compare the results in the matlab technical computing environment.

in our model, we need to check whether the vehicle is inherently stable. to do this, we can use figure 2 to check whether the pitching moment described by the corresponding coefficient, cm, provides a restoring moment for the aircraft. a restoring moment returns the aircraft angle of attack to zero.

in configuration 1 (figure 2), cm is negative for some angles of attack less than zero. this means that this configuration will not provide a restoring moment for those negative angles of attack and will not provide the flight characteristics that are desirable. configuration 2 fixes this problem by moving the center of gravity rearward. shifting the center of gravity produces a cm that provides a restoring moment for all negative angles of attack.

figure 2: visual analysis of digital datcom pitching moment coefficients.

creating flight vehicle simulation

once we determine aerodynamic stability and control derivatives, we can build an open-loop plant model to evaluate the aircraft longitudinal dynamics. once the model is complete, we can show it to colleagues, including those who do not have simulink® software, by using simulink® report generator™ software to export the model to a web view. a web view is an interactive html replica of the model that lets you navigate model hierarchy and check the properties of subsystems, blocks, and signals.

a typical plant model includes the following components:

we can implement most of this functionality using aerospace blockset™ blocks. this model highlights subsystems containing aerospace blockset blocks in orange. it highlights aerospace blockset blocks in red.

figure 3: top level of lightweight aircraft model

we begin by building a plant model using a 3dof block from the equations of motion library in the aerospace blockset library (figure 4). this model will help us determine whether the flight vehicle is longitudinally stable and controllable. we design our subsystem to have the same interface as a six degrees-of-freedom (dof) version. when we are satisfied with three dof performance, stability, and controllability, we can implement the six dof version, iterating on the other control surface geometries until we achieve the desired behavior from the aircraft.

figure 4: equations of motion implemented using 3dof euler block from the aerospace blockset library.

to calculate the aerodynamic forces and moments acting on our vehicle, we use a digital datcom forces and moments block from the aerospace blockset library (figure 5). this block uses a structure that aerospace toolbox creates when it imports aerodynamic coefficients from digital datcom.

for some digital datcom cases, dynamic derivative have values for only the first angle of attack. the missing data points can be filled with the values for the first angle of attack, since these derivatives are independent of angle of attack. to see example code of how to fill in missing data in digital datcom data points, you can examine the function.

figure 5: aerodynamic forces and moments implemented in part with the aerospace blockset digital datcom forces and moment block.

we also use aerospace blockset blocks to create actuator, sensor, and environment models (figures 6, 7, and 8, respectively). note: in addition to creating the following parts of the model, we use standard aerospace blockset blocks to ensure that we convert from body axes to wind axes and back correctly.

figure 6: implementation of actuator models using aerospace blockset blocks.

figure 7: implementation of flight sensor model using aerospace blockset blocks.

figure 8: environmental effects of wind, atmosphere, and gravity using aerospace blockset blocks.

designing flight control laws

once we have created the simulink plant model, we design a longitudinal controller that commands elevator position to control altitude. the traditional two-loop feedback control structure chosen for this design (figure 9) has an outer loop for controlling altitude (compensator c1 in yellow) and an inner loop for controlling pitch angle (compensator c2 in blue). figure 10 shows the corresponding controller configuration in our simulink model.

figure 9: structure of the longitudinal controller.

figure 10: longitudinal controller in simulink model.

with simulink® control design™ software, we can tune the controllers directly in simulink using a range of tools and techniques.

using the simulink control design interface, we set up the control problem by specifying:

using this information, simulink control design software automatically computes linear approximations of the model and identifies feedback loops to be used in the design. to design the controllers for the inner and outer loops, we use root locus and bode plots for the open loops and a step response plot for the closed-loop response (figure 11).

figure 11: design plots before controller tuning.

we then interactively tune the compensators for the inner and outer loops using these plots. because the plots update in real time as we tune the compensators, we can see the coupling effects that these changes have on other loops and on the closed-loop response.

to make the multi-loop design more systematic, we use a sequential loop closure technique. this technique lets us incrementally take into account the dynamics of the other loops during the design process. with simulink control design, we configure the inner loop to have an additional loop opening at the output of the outer loop controller (c1 in figure 12). this approach decouples the inner loop from the outer loop and simplifies the inner-loop controller design. after designing the inner loop, we design the outer loop controller. figure 13 shows the resulting tuned compensator design at the final trimmed operating point.

figure 12: block diagram of inner loop, isolated by configuring an additional loop opening.

figure 13: design plots at trim condition after controller tuning.

you can tune the controller in simulink control design software in several ways. for example:

after you specify frequency domain requirements, such as gain margin and phase margin and time domain requirements, simulink design optimization software automatically tunes controller parameters to satisfy those requirements. once we have developed an acceptable controller design, the control blocks in the simulink model are automatically updated. see the examples getting started with the control system designer (control system toolbox) in control systems toolbox examples and (simulink control design) in simulink control design examples for more information on tuning controllers.

we can now run our nonlinear simulation with flight control logic and check that the controller performance is acceptable. figure 15 shows the results from a closed-loop simulation of our nonlinear simulink model for a requested altitude increase from 2,000 meters to 2,050 meters starting from a trimmed operating point. although a pilot requests a step change in altitude, the actual controller altitude request rate is limited to provide a comfortable and safe ride for the passengers.

figure 14: the final check is to run nonlinear simulation with our controller design and check that altitude (purple) tracks altitude request (yellow) in the stable and acceptable fashion.

we can now use these simulation results to determine whether our aircraft design meets its performance requirements. the requirement called for the climb rate to be above 2 m/s. as we can see, the aircraft climbed from 2,000 to 2,050 meters in less than 20 seconds, providing a climb rate higher than 2.5 m/s. therefore, this particular geometric configuration and controller design meets our performance requirements.

in addition to traditional time plots, we can visualize simulation results using the aerospace blockset interface to flightgear (figure 15).

figure 15: visualizing simulation results using the aerospace blockset interface to flightgear.

we can also use the aerospace toolbox interface to flightgear to play back matlab data using either simulation results or actual flight test data.

completing the design process

the next steps involve

because these steps are not the focus of this example, we will not describe them here. instead, we will simply mention that they can all be streamlined and simplified using the appropriate tools, such as embedded coder®, simulink® real-time™, and aerospace toolbox software.

summary

in this example we showed how to:

this approach enables you to determine the optimal geometrical configuration of your vehicle and estimate its performance and handling qualities well before any hardware is built, reducing design costs and eliminating errors. in addition, using a single tool chain helps facilitate communication among different groups and accelerates design time.

references

[1] cannon, m, gabbard, m, meyer, t, morrison, s, skocik, m, woods, d. "swineworks d-200 sky hogg design proposal." aiaa®/general dynamics corporation team aircraft design competition, 1991-1992.

[2] turvesky, a., gage, s., and buhr, c., , matlab® digest, january 2007.

[3] turvesky, a., gage, s., and buhr, c., "model-based design of a new lightweight aircraft", aiaa paper 2007-6371, aiaa modeling and simulation technologies conference and exhibit, hilton head, south carolina, aug. 20-23, 2007.