All language subtitles for final_620bc5e171959a01acee9889_259068.mp3

Speaker1:
Hello, my name is Carlos Osorio.

I'm an application engineer at the math
works.

And this is part two of the power
differential equation becomes a robot

seminar. So in this section, we're going to
focus on modeling actuators and modeling

sensors in general, how to model any kind of
linear or nonlinear component and bring and

connect this to your model.

In part one, which hopefully you guys have
watched with, discussed how to create dynamic

models of three dimensional mechanisms.

So once we have the mechanics in order to
move this robot, we need to apply some talks

for which we're going to need motors.

So if those motors are going to have some
effect, some dynamic effect on my mechanism,

I better have mathematical models of those
of those dynamics included in my model.

So for that, where we're going to use this
signaling and let me go back to my MATLAB,

for those of you that don't see me link very
much or having you simulating signaling

starts by typing, simply link on the command
line or by using this icon here.

This is the this is the signaling icon right
here.

So you can just click on that.

And what that would do is it would open the
simulant library browser.

What you're seeing is the base signaling
product right now.

All these are libraries of graphical blocks
that have mathematics already already defined

for them. Signaling is a full fledged
dynamic simulator, so it allows you to create

linear nonlinear.

This continuous, discontinuous models and do
very complicated constructs, which are full

fledged programming language.

So there is lots of capability.

So I'm going to let me open.

I have a little template that I want to use.

So what we're going to do is we're going to
try to create, in this example, a model of a

DC motor. And I have here on the side a
little bit of a mathematical first principles

implementation of the dynamics of a DC
motor.

There's an electrical side and there's a
mechanical side.

So I have kickoffs law doing the dynamic
balance of the electrical side and Newton's

law doing the mechanical balance on this
side here.

So there's the equations are the response of
this motor is going to be a function of the

inductance, the resistances, the friction or
the.

In this case, I have like a little bit of
damping the inertia, the and because there's

a connection between the electrical and the
mechanical side here, I know that the back

EMF voltage is going to be proportional to
the speed of the motor, to the mechanical

rotational speed of the motor and the actual
torque, the electrical torque.

The electromagnetic torque is going to be
proportional to the current circulating

through the armature of the motor.

So this is the system of equations for this
particular case that we want to build.

So how do we do this with signalling?

So I'm going to bring in some blocks.

I just want to keep that on the side so we
can guide ourselves.

So we're going to need some integrators
because we are doing differential equations.

We're going to need in my sync, but I'm
going to need like an oscilloscope to look at

things. I'm going to bring in from my
sources library knowledge that you have all

kinds of like noise generators, sine
generators, random signal generators.

I'm going to bring in a step and I need I'm
going to need some, some from the

mathematical operations, like I'm going to
need some summation blocks because there are

things adding and subtracting, and I'm going
to need a gain to multiply things.

So the way you work on signaling is
basically connecting blocks.

That's how you program in signaling.

So I can connect this step to this scope.

Signaling already has embedded in it the
numerical solvers.

So all I need to do to run a simulation and
the scope will be like a very simple

laboratory scope.

In this case, the horizontal axis is time,
so we're going to run a simulation for 10

seconds, which is the default.

But you can put whatever number you want.

If I press play, what you're going to see
the simulation do is the scope.

Show me is whatever signal is feeding into
the scope, which is a step.

As you can see a time equal one goes to one
remains constant.

How does he know to do that?

Every single block has a parameterization
chart like this, so the default in this case

was a time equal one go from zero to one,
which is what we are seeing on this scope.

But if we want to start out in some dynamics,
all I need to do is let me put an integrator

here. So now what is going to happen is
you're going to see the constant signal that

is coming out of the step is going to be
integrated and the integral of a constant is

going to be a first order dynamic.

So like a line in this case.

So you press play and now you see a line at
time equal one, the signal becomes a constant

guessing. Agreed it becomes a line.

So in this particular case, I am going to
need a couple of integrators, so let me put

another one. Now, what is going to happen
here is that I'm going to be feeding a

constant gets integrated as a first order
like a line and then if you integrate a line

now you will have quadratic behavior.

So I want you to notice that I just put a
couple of silly blocks together.

But really, what the tool is doing for me is
it's solving a second order differential

equation. If this signal was instead of
coming from a stab was coming from an

accelerometer outside, for example, I used
that measurement of an acceleration.

If you integrate an acceleration, you will
have a velocity.

If you integrate a velocity, you have a
position, for example.

I'm going to use that.

Actually, I'm going to disconnect them for a
little bit.

And what I am going to have is so if this
integrator is going to be for my velocity

equation, I have an angular velocity
equation.

I'm going to say that what I'm going to be
feeding to it is the omega T.

And what is going to come out of the
integration will be omega.

So that will be my speed.

And I'm going to use this integrator for
this for the current.

So what I'm going to feed here is the ADT.

And what is going to come out of the
integrator then is I.

So I have to first order differential
equations.

I need to integrators.

So now it's all disconnected.

So let's look at the first one here.

It's I'm doing a balance of voltages
business, so I'm saying did't is going to be

the sum of all the voltages.

So this let's assume this step is my
external voltage.

So I have a V in the applied.

For example, I'm going to bring my summation
block here.

Let me make it a little bigger because I
need three terms.

One is positive and the other two are
negative, so I'm going to construct it that

way. Minus plus minus that opens three
ports.

So the middle one is going to be my VNE
minus.

Let's do our times.

I first minus our times.

I I don't have our time side yet, but I have
AI here so I can actually grab AI and bring

it back here. And this has to be multiplied
by a proportional volume.

So for by R. So this coefficient will be R.

So what I have just constructed is I
multiply by our time, by VN minus our times.

I maybe I want to construct minus the back
MF voltage, but the MF voltage, I know is

proportional to the speed and the speed is
not yet connected.

But it's going to be from. He's going to be
coming from here so I can just pull that one

back and then put another gain on this.

That will be that k mf gain.

Let me make it a little bigger so we can
still see it.

Yeah, so what I have is on mega time scale,
IMF will give me the third term here.

So what I have just constructed is the right
hand side of this equation the minus Bachmann

voltage minus our time psi that is supposed
to be, according to this equation, equal to L

Times DADT.

And I have the ID here.

So the only thing I need to connect this
before is let me bring another game here.

Let make sure it connects, right?

And what I need to do is that some of
voltages, if I divide it by the inductance.

If I drive I the index, so some of voltages
divided by L will give me DADT and by closing

this loop, the way I just did is I
essentially have built this first first order

differential equation.

Yeah. Now notice on the second equation.

On the second equation, I have again the sum
of two things.

So let me bring in my some block here and
one is positive, one is negative.

So I need to change this to plus minus oops.

Plus minus.

And the first term is the talk.

Talk, the talk is proportional to the
current and the current is what is coming out

of here, so I need another one of those
gains.

Let me give myself a little more space here.

So what I need is another one of those
games.

Let me copy and paste this one here.

Let me flip it. So there will be the current
multiply by K.M.

in this case, that's the third constant
care.

So that's its current multiply by K.M.

will give me the talk, the talk talk minus
the friction talk, which is proportional to

the speed. Oops.

Sorry, I should do this to make it look a
little cleaner.

Let me make minus plus here.

So the plus element is the talk and the
minus element will be coming from this side,

from the speech.

So that will be the speed is here and I'm
going to drag and drop it back there and it's

proportional to the speed.

So what I need is another one of these gains
and I need that to be CF Kiev.

So what I just constructed here, same idea as
I showed you a second ago.

No, it's like that summation bloc is giving
me the sum of talk minus the friction torque.

So this is equal to J.

The Omega TT.

So before I connect them, I have to replace
one of these blocks again.

But instead of one over omega, what I'm
going to use sorry one on my l.

What I'm going to use is one over G, so I
guess I have from nothing constructed

essentially a set of two interconnected
first order differential equations in

smelling. Of course you have.

If I have veiled the model, what I want to
do is run it to see what the dynamic effects

are when I press play here.

Let me press play.

This is not going to work, of course, but I
am doing this on purpose because I want to

show you that signaling has a little
debugger that is, in this case, is telling me

that it doesn't know what any of those
parameters are.

So signaling is very powerful, but I cannot
do magic.

So I just define the model where I put our
sales JS, but I never told anybody what those

were. So what I want to emphasize now is
just to connect.

I could obviously go into each one of these
blocks and set up a number and then link

would solve the equations with that number.

But what I want to emphasize is the
connection of signaling to MATLAB.

So I'm going to go back to MATLAB here and
actually I have somewhere here in my command

history a set of parameters that I have
already defined, like J.K RL.

So I'm going to just pick them from my
history and press enter.

So that will run that again and fill up my
my workspace, my MATLAB workspace right now.

So now all those parameters are in my MATLAB
workspace.

So what is going to happen with MATLAB with
signalling now is when I press play is going

to find a variable here is going to say I
don't know what R is, but let me go check if

MATLAB knows what areas.

If MATLAB knows what areas, let me use that
number.

So when I press play, you're going to see
the full dynamic behavior of a DC motor.

In this case, what you're seeing is a time
equal one.

There's a step voltage being applied to the
motor and what you see, the speed is ramping

up. This is a this is a measurement of the
motor speed in this case.

So the speed is ramping up until it reaches
some steady state equilibrium here.

So hopefully, this gives you a sense for the
kind of equations that you can do with

signalling now. Maybe somebody will say,
well, but what if my friction is not just a

damping, it's some kind of a cooling
friction.

For example, there are blocks that allow you
to very easily add discontinuity so I can.

There's an actual Coulomb and this friction
block.

So let me put it there and take out the game
from before.

And all of a sudden, my pretty linear model
has become a non linear model.

Maybe I want my or my resistor is very
important for the phenomena that I'm starting

is that my resistor is changing with
temperature so I can delete that constant

value of the resistance and maybe go into my
lookup tables library.

I'm bringing one of these one dimensional
lookup tables.

Let me flip it and I can place it in.

If I can fit it, I can place it in there,
for example.

No, and now all of a sudden I can bring in.

Maybe I have some experimental data that
shows me the variation.

I have some equation or some shape that
shows me the variation of the value of the

resistance with current, for example, more
current, more he'd more like, maybe the

resistance efficiency changes so I can have.

I can have all kinds of very complicated
models that can be built with fundamental

components in signaling once you put them
all together.

One of the key things about simulation link
is the idea of reusability.

You can grab whatever algorithm you have and
do what is called create subsystems.

So I just created a little box, a little
graphical box where inside that box, if I go

inside, there's the equation or the
algorithmic thing that it just created.

I can. Actually, this is this is the speed of
the motor and this here is the voltage coming

in, voltage coming in.

Not is that not is that as I'm changing,
this immediately changes the box.

No, this will be, let me call it, something
more relevant instead of just default

subsystem, my DC motor, for example.

Now, once I have created this, I can not
only put a I can not only, for example, put a

mask on it, I can create a mask and put
little icons on it.

More important than that, actually, I can
perform it twice it.

So, for example, I can set up armature
armature resistance resistance.

That is associated inside with that
variable.

Ah, I'm just going to do one for the sake of
argument here, OK?

And now when I double click on the blog
instead of opening the mall, it would open a

parameterization chart where you can put
help.

You can put documentation and you can set up
whatever parameters you want to set for the

model that is inside.

Once I have that, I can actually copy and
paste it as many saw.

If my device has many motors like, it's the
case for the robot.

Once I create one component, all I need.

All I need to do reproduce it.

It's just like copy and paste it as many
times as I need.

So this is a very brief introduction to
signaling.

Let me go to my script here, because now
what I want to show you is similarly offers

you as an enormous amount of flexibility to
do models.

So, for example, I have here three
subsystems feeding into one oscilloscope when

I press play here.

What you're going to see is there are three
mathematical models of a DC motor.

The same thing that I just did before all
three models I want you to notice are giving

me the same result when I double click on
the top one.

Well, it's the same thing.

I just bailed in front of you, but well, a
little prettier because I had a little more

time. But it's essentially the what we call
a first principle implementation using

fundamental mathematics for this model.

Now I want you to compare that with the
second implementation, which is now going

down the libraries in signaling and using
some of those advanced libraries to to create

physical components.

So I am using a protocol simsek here where
you see now I have resistors, inductors,

inertial blocks, dumping blocks.

Instead of having to deal with mathematical
equations, I can build electrical circuits

that look like electrical circuits or
mechanical circuits that look like mechanical

circuits. Now this is all.

Let me show you here.

So similarly, the base product is here now.

I can go down under the same stack heading
SIM Scape comes with this foundation library,

which noted, I want you to know this has
multiple domains, multiple physical domains.

So there's hydraulic component mechanical
components.

For example, if I go to the rotational
alignments, you will see springs and dampers

and friction and inertia or on the
electrical domain, you will see resistors,

capacitors, inductors.

So all I need to do to build these models is
use this component directly.

Now I can. This is this this.

These are basic libraries that give you some
fundamental basic components, but there are

additional libraries, and we talked about
some mechanics in the previous recording

where is our three dimensional mechanical
modeling tool?

But we have a hydraulics and an advanced
hydraulics modeling tool and an advanced

electronics modeling tool.

So for example, if I go into my electronics
modeling tool and I look at my actuators

library, you will see there are because ADC
Motors is such a common component we have

already DC Motors already has one simple
single component.

There's all kinds of little electric motors,
several motors, stepper motors, all kinds of

motors already implemented.

So as opposed to the basic libraries where
you have some elementary components that

allow you to build more complex systems in
the in the advanced libraries you have now

there's P.W. driver blocks.

Each bridge amplifier blocks.

There is all kinds of semiconductor devices,
so you can model transistor level things.

For example, there is all kinds of
electrical sensors already model for you, and

this is one of the important things about
the soundscape language.

So slim escape by itself comes with this
library, this basic, fundamental libraries.

But since escape is not only those facing
those fundamental libraries, it's so let me

bring in our rotational spring.

For example, you can parameter tries your
element.

There's a there's documentation associated
to every block that will take you to the

equations that are being used for each
component.

But also, I want you to notice that there is
a little hyperlink here that says View Source

for rotational spring.

So if I click on that, what that is going to
do is it is going to open the file that the

file that is actually defining the
component.

This is our MATLAB based, object oriented
program.

So soundscape is not only the blocks, it's
also this physical modeling language that

allows you to create your own custom
components.

Notice that it's not a function file, it's
not a script.

It's a component called spring in this case,
and there are tutorials that explain step by

step how to program in this language.

But the most important part is like getting
to the equation section on the methods where

you're defining the functionality of this
component.

In this case, the talk is defined as the
spring rate multiply by the angle.

It's a linear spring.

Maybe I want a component that is a
non-linear spring like a cubic spring, all I

would need to do is do angle cube, for
example, and all of a sudden, well, of course

I would save it as a different component,
but I can rebuild this block and create my

own nonlinear cubic spring, for example.

So this language gives you the flexibility to
create an any series of mathematical of of

physical components from any domain that you
wish, really.

So there are some domains defined here, but
you not only can create individual

components, you can also start creating your
own basic domain.

So if you want to define, I don't know,
maybe optics, for example, you define the

domain and you can start creating blocks
using that domain.

And all of this domains connect to each
other directly.

So in this example I had, I have first
principle implementation of a motor.

I have a physical component implementation
of a motor, and there was a third block in

which I am using straight out the same
electronics model.

So this these are multiple ways or multiple
levels of detail in which you can use to

implement the component.

So let me let me close this.

And let me go back to my slides.

So I just showed you how the flexibility
that simulation can simulate combined can

offer you to create mathematical models
directly from physical components.

You can create your own custom physical
components or only or use the fundamental

mathematics of signaling to essentially
create a mathematical model of whatever it is

that you that you want.

You can bring in experimental data and
create using the System ID toolbox, for

example, create black box models based on
input output relationships, for example.

And we're going to talk in a second about how
you can bring in experimental data to

parameterized properly these models.

But first, I want to mention the flexibility
of of switching levels of fidelity in a

particular model. So let me go to my to my
script here.

Let me help in this model here.

So what I have here is an implementation of
a DC motor using some electronic components,

so there is this DC motor from the same
electronics library and I have actually added

power amplifier model.

If I go in here you see a driver and an air
bridge amplifier.

These two are running right now in what is
called average mode for simulation speed.

So even though this is a thousand hertz bw
am, I am using an average implementation of

both of this both the bridge and the driver
in average mode, and that is going to give me

very fast simulation speed.

And notice that I can combine these physical
components with signalling components.

So I have the same capacities as to peers
and peers.

This means signaling to physical signal,
physical signal back to signal, link and

granted, I am using very simple signaling
blocks here, just steps and scopes.

But this is how you would connect this to
controllers, for example, or controller

designing, signaling or mathematical
elements, for example.

In this example, I am running just a quick
simulation where I have a constant duty cycle

that is being applied to the motor.

And you see the speed of the motor ramping
up, reaching equilibrium and at some point is

coming down. And that is because I am
actually applying a load, talking to the

shaft of the motor.

So I have a torque source here and a step
load that is changing at one second.

At one second. I am kind of grabbing hold of
that shaft and putting a torque on it.

Now you can see the effect on the current to
the current goes up four to respond in

response to that torque.

But what I wanted to show you is this little
component here has a little config

configurable subsystem.

This is one of the constructs that similarly
has, so this means that this block is

associated to some particular library.

So if I right click on this block and follow
the link, there is a library that I've made

using a configurable some system component.

So there's a template that is part of
standard signaling libraries and notice that

there's three models associated with that
component.

So by setting this this way, what this does
is it actually if I look into if I right

click on this, this will give me a menu
option that says block choice so I can pick

from an average voltage implementation to a
a full volume switching version of these

devices. So if I look inside, this would
look this would look this less the same as

the one I had before. But now the P, both
the volume and the amplifier are in P.W.

And so that means that I'm going to run a
simulation that is using the full switching

implementations. Or I can even go to what I
call hear an implementation version.

So if I go inside, you will see how now what
I would be using is a full detail

implementation, transistor level
implementation of the electronics of my age

bridge. And so I have multiple transverse
transistors and a full electronic

implementation. So with a drop of a menu,
you can actually switch your simulation model

from us from a simplified version to a more
complex version or to a more detailed version

based on whatever it is that I'm trying to
study.

Let me close that.

Go back to my slides here.

This is what I mentioned before, the ability
to use signaling to use signaling and the

fact that signaling is running on MATLAB to
do optimization, for example, the tool that

I'm going to show you is called signaling
design optimization.

Let me go to my script here, and where I'm
going to open is I have another model here.

So this is again the same this motor with
the power amplifier.

And what I am running in this model.

Let me press play to see what is happening.

What I'm running in this model is I'm
comparing two signals in the scope.

I'm comparing the output of the model, which
is the orange line, and this blue line is

coming from an experimental test.

So I run. I have the robot right here so I
could run some experimental tests and capture

some real data.

This is the result of inputting a square
voltage into the motor, and I'm comparing the

simulation results with what my experimental
data is doing.

And of course, my parameter guesses for the
motor.

The armature resistance inductance
apparently are not very good because my

orange is very far away from the blue so I
can manually go in and say, Well, maybe the

resistance is larger, maybe the inertia is
smaller, but even on a simple point like

this, this could become really cumbersome.

And now imagine if you have something where
you have 200 parameters, that will be almost

impossible. So think about this as an
optimization problem.

There is an error between what I want my
orange, where I want my orange line to be and

the blue line. So if I define a cost
function that penalizes that error and can

play with those parameters to minimize that
error, then I will have the right result.

So from the tools menu, if you have the
simulate design optimization product, you

have an option for call parameter
estimation.

What I'm going to do is I'm going to open it
directly from here because I have the my

optimization project already loaded up.

And what I want to stress is that what I am
doing is straight on seemingly taking

advantage of the fact that this tool is not
only very good for modeling things, but it

also running on MATLAB and MATLAB has all
kinds of very powerful numerical optimization

tools, algorithmic tools.

So what this is going to do is instead of me
having to write a script to do the same

command and do multiple loops, this is
setting the optimization automatically for

me. So it's one test data vector where I
define the input output data.

If you have if I was doing this for real, I
would probably have many, many more tests

test data sets.

So you can pick some for for the estimation,
pick some for validation.

This is just that blue line that you saw on
the simulation.

It's my experimentally measured velocity.

In this case, you defined the variables from
the model that that are going to be used for

the optimization. You can constrain them to
the region where you want the optimizer to

search. In this case, I am just doing brute
force.

Essentially, I'm just telling the tool that
the parameters have to be positive, but I'm

not giving them much information and then I
can proceed to the estimation.

Here you will see the data sets won.

In this case, we have just one what
parameters I have.

I have my minimum and maximum.

If I have information from the manufacturer
that tells me the armature resistance is in a

certain range, for example, or tells me the
armature resistance is forearms plus minus 10

percent tolerance, then that would define
the range where I want this tool to work.

And once I have all that set up, all I need
to do is set up a proceed to the estimation

when I hit start here.

What is going to happen is the tool is
automatically setting up this optimization

problem using underneath the MATLAB
optimization toolbox.

I want you to notice that what is happening
here is behind this.

Behind all of these plots.

The simulation model is being run many, many
times is being used as part of the cost

function. So this tool connects
automatically to the parallel computing

toolbox, for example.

So if you have a model that takes a long
time to run or we are doing this for many

parameters and you want to speed up this
process, you can by by clicking a switch, you

can make use of multiple cores in your
computer and run multiple simulations at the

same time, for example.

This is giving me a progress view.

So the gray line is my experimental data.

The blue line is where my model is
currently.

And here I am, seeing how the tool is
changing all the parameters in this case,

five parameters at the same time as opposed
to me changing this by hand.

This is actually checking sensitivity in
each directionality and approaching that

sweet spot as fast as it possibly can and is
doing a gradient optimization in this case.

Notice that after four iterations, I am
already where I want to be for what I'm going

to be using this motor.

This model is going to be used to do
controls later, so I need to have.

I need to make sure that my motor matches
the actual motors that I have in my robot, at

least as close as I. Possibly make sure of.

Actually, this was stopping a little bit,
but what I'm going to do is I'm going to just

stop it here. Yes, because we're almost
there, really.

So I can now I have a once it finishes.

Yes, here here you can see the cost function
started at two point twenty four and it's

it's gone down to 0.23.

You have control over the tolerances, how
many iterations you want to do when you want

to stop. So you have this is, after all,
MATLAB.

So you have access to different algorithms
and parallel options.

As I was mentioning before, the point here
is once I have my model, my motor permit

tries to match to my actual motor.

I can just save this with this part with the
right parameters into a library.

So this is one of the reusability
characteristics of sawmilling.

So when I started here, I said, Well, this
is the basic simulant product, but if you go

down here, those are all our own products to
MyLink.