Transcript Notes

Cantilever beam--static and dynamic behavior;
extending VHDL to other domains (VHDL-AMS)
Silicon Programming--VHDL-AMS
1
We will look at how a cantilever beam is built in a “typical” MEMS
process--the “MUMPS” process (MultiUser MEMS Process)
there are two structural (polysilicon) layers. Structures can be
made of: first poly by itself, second poly by itself, first poly-second
poly together.
typical layer thickness: ~ 2 microns--"large" (compared to today's
circuit elements)
Silicon Programming--VHDL-AMS
2
u
thickness (t)
length (l)
displacement
(x)
height
(h)
width
(w)
length (l)
cantilever beam-side view
cantilever beam-top view
If u = distance from the beam's
anchor to its end, 0 <= u <= l,
and force F(u) is applied at point
u, the beam will be displaced a
distance x(u). What is x(u)?
Simple cantilever beam,
height h, length l, width w,
thickness t. If the beam is
made of a material with
density p and Young’s
modulus E, then mass m
and moment of inertia I are
given by:
m = pwtl
I = (wt3) / 12
Silicon Programming--VHDL-AMS
3
If a constant force F is applied to the free end of the beam, then its
maximum (static) deflection is given by standard equation for a
maximum deflection of a cantilever beam of constant cross section :
3
FL
D
3EI
where D is the deflection of the free end of the beam, F is the force
applied to the free end, L is the length of the beam, and EI is the
flexural rigidity of the beam (E = Young's modulus).
Silicon Programming--VHDL-AMS
4
If F varies with respect to time s, then we actually
have F = F( s,u) and we seek the dynamic solution
x = x(s,u).
Silicon Programming--VHDL-AMS
5
Method 1. The cantilever beam as a spring. Assume F is a
function of time s alone, applied at the free end of the beam.
F = m x ' ' + B x ' + kx,
where the spring constant k is given by k = (3EI) / (L3)
and the damping coefficient B is given (experimentally) by
B = 2*((mk)1/2) / 5.
Silicon Programming--VHDL-AMS
6
F = m x ' ' + B x ' + kx
can be translated into the electrical domain:
I = C V ' + (1/R) V + (1/L) V(y)dy
where I = current, C = capacitance, R = resistance, L =
inductance, V = voltage.
(This represents a circuit with R,C,L in parallel). So if we use
this form of the equation we can simulate the behavior of the
beam using SPICE.
Silicon Programming--VHDL-AMS
7
Method 2. Finite element analysis.
This is a standard method for dealing numerically
with complex systems. Here we can break the
beam into sections and model the behavior of each
section, keeping them "tied" together at the ends.
This allows us to deal with a force which varies
along the beam length.
Silicon Programming--VHDL-AMS
8
A beam-capacitor system. By
adding an insulated plate on the
base for the beam, we can create a
capacitor. Here the distance (h - x
in the equation above, if we ignore
the plate height) is the distance
between the two capacitor plates.
The equation for the attractive force
at the end of the beam is:
F = (AE0V2) / (2y2),
where A is the area of the capacitor
plate, V is the voltage, E0 is the
permittivity of air (=8.85 x 10-12),
and y is the distance between the
two plates.
Silicon Programming--VHDL-AMS
9
example: VHDL-AMS
(VHDL with Analog and Mixed Signal
extensions)
model of cantilever beam:
entity cantbeam is
end entity cantbeam;
Equations
architecture simple of cantbeam is
quantity x: real;
quantity v: real;
quantity a: real;
quantity F: real;
constant L: real := 20.0E-6;
constant W: real := 10.0E-6;
constant H: real := 1.5E-6;
constant P: real := 2.26E3;
constant M: real := L*W*H*P;
constant Y: real := 170.0E9;
constant IZ: real:= (W*H*H*H)/12.0;
constant Rigidity: real := Y*IZ;
constant k: real := (3.0*Rigidity)/(L*L*L);
constant B: real := 0.4*sqrt(M*K);
begin.
b1: break v => 0.0, a => 0.0, x => 0.0, F => 0.0;
force: F == F1 + F2 + F3;
force1: F1 == M*a;
force2: F2 == k*x;
force3: F3 == B*v;
vel: v == x'dot;
accel: a == v'dot;
end architecture simple;
Silicon Programming--VHDL-AMS
Declarations
10
Cantilever beam actuator:
entity cantbeamactuator is
port(Vin,Length,Width: in real;
deflection,Force: out real);
end entity cantbeamactuator;
architecture simple of cantbeamactuator is
quantity x: real;
quantity Volt: real;
quantity v: real;
quantity a: real;
quantity F: real;
quantity L: real;
quantity W: real;
quantity H: real;
quantity M: real;
quantity IZ: real;
quantity Rigidity: real;
quantity k: real;
constant P: real := 2.26E3;
constant Y: real := 170.0E9;
constant Eo: real:= 8.85E-12;
constant H: real := 1.5E-6;
begin
b1: break Volt => 0.0, a => 0.0, x => 0.0,
F => 0.0;
InputTestBench: Process
File Infile : text OPEN
READ_MODE IS
"cantbeam.in";
VARIABLE linebuf : line;
VARIABLE
vtemp,ltemp,wtemp,htemp
:real;
BEGINWHILE (NOT
(endfile(Infile)))
LOOPreadline(Infile,line
buf);
read(linebuf,vtemp);
Vin <= vtemp;
read(linebuf,ltemp);
Length <= ltemp;
read(linebuf,wtemp);
Width <= wtemp;
WAIT FOR 100 ns;
END LOOP;
END process;
Initialize: Process (Vin,Length,Width)
VARIABLE MASS,MOMENT,RIG,SpringK: real;
BEGIN
Volt := Vin;
L := Length;
W := Width;
MASS := L*W*H*P;
M := MASS;
MOMENT := (W*H*H*H)/12.0;
IZ := MOMENT;
RIG := Y*IZ;
Rigidity := RIG;
B := 0.4*sqrt(M*K);
SpringK := (3.0*Rigidity)/(L*L*L);
k := SpringK;
END process;
Calc_Force: Process
VARIABLE Area, Perm,AttractForce: real;
BEGIN
Area := L*W;
Perm := Eo;
AttractForce:=
(Area*Perm*Volt*Volt)/(2.0*x*x);
F := AttractForce;
END process;
Force_applied: F == F1 + F2 + F3;
force1: F1 == M*a;
force2: F2 == k*x;
force3: F3 == B*v;
vel: v == x'dot;
accel: a == v'dot;
deflection = x;
Force = F;
end architecture simple;
Silicon Programming--VHDL-AMS
11