Writing Functions Robotics Fundamentals

Transcription

MATLAB includes thousands of ready-to-use functions that perform a variety of common

tasks.

But what if we need a custom function for our application?

We can write our own MATLAB function.

Let's see how.

A MATLAB function consists of two parts: the declaration, and the body.

The declaration begins with the keyword, FUNCTION, followed by how we will use, or call, the

function.

This means we provide the output variables, the function name, and the input variables.

In the function body, we provide the set of commands to be executed each time the function

is called.

We use other MATLAB functions in combination with the inputs to create the output variables.

Finally, we mark the end of the function with the keyword, END.

That covers the syntax, but how do we use a custom function?

Let's see how by doing an example.

Suppose we need to sum the first n terms of a geometric series, which is given by this

formula.

The function only has a single output variable, s, which corresponds to the sum.

The brackets are required when there are multiple outputs, but since we only have one output

we can remove them.

Function names follow the same conventions as the naming of MATLAB variables and should

not overlap with existing function names.

Let's call ours geoSum.

To complete the declaration, we'll provide the list of input variables needed to compute

a geometric sum: the common ratio, r, and the number of terms to sum, n.

Next, we include the instructions for computing s in terms of r and n inside the function

body.

It's also good practice to provide comments below the function declaration for our future

reference, or to communicate the intent to others.

Now let's put this function to use.

We can do this two different ways.

If the function will be used in a single code file, we move the definition to the bottom

of the script, and then call geoSum in the code above.

When we run the script, our function is used to calculate the geometric sum.

But what happens if we need our function in other code files or at the command prompt?

Uh oh, red text usually isn't good.

This error occurred because geoSum is currently a local function, meaning we can only use

it in the script where it's defined.

In this case, we need to create a separate code file that contains only the function

definition.

So let's delete the code above.

Lastly, we save our file in the Current Folder, making sure that file name matches the function

name.

Now when we call geoSum at the command prompt, the two input values are passed to the function,

the function body is executed, and the value of the output variable is returned.

And just like that, there's one more function we can call.

Hello, geoSum?

I'd like the sum for r equals one-half and n equals infinity please.

<sigh> Yes, I'll hold.

Troubleshooting Code with the Debugger Microrobotics

Transcription

As we start combining many lines of code

into scripts or functions,

there are more opportunities to introduce mistakes.

Sometimes our code will result in an error message,

or it may produce an output that is

different than we expect.

Oops!

Such errors are often called bugs.

We can locate mistakes and fix errors

using the debugger in MATLAB.

Let's see how using this example.

This code is meant to calculate the total account

balance in interest earned on a vector

of deposits and interest rates for each year.

However, when we run the code

we receive an error message.

Hmm.

There was a problem in line 7 of the code

related to multiplication as referenced

in the error message.

To help determine the cause of the error,

let's run the code again,

but this time pause the execution of the code

at the line where the error occurs.

We do this using a breakpoint.

With the code file open in the MATLAB editor,

let's create a break point by left clicking

on the dash next to line 7.

A red circle is displayed on the line number

indicating that we have set a breakpoint.

Now when we run the file

the command prompt changes to show us

that we are in debug mode,

and new buttons are available

in the MATLAB editor toolstrip.

We also see the current values

of variables in the workspace.

Notice that the loop variable, i, is one,

and variable interest is zero because

the code was stopped before line 7 was executed.

We have two options for continuing code execution.

We could use the "Continue" button

to resume execution until another breakpoint is reached,

an error occurs, or the code runs to completion.

Or we can use the "Step" button to execute

only the current line of code

which is indicated by the green arrow.

Since we don't know where the error is,

let's use the step button to execute line 7

and advance the code one line.

The variable interest is updated and we see

it is a vector of six elements!

We meant for interest to be a scalar value,

so it looks like we might have found our error.

In debug mode, we can type commands to

test possible corrections.

Here, what we meant to do was use the loop variable, i ,

to select a value from the vector rates.

Since we found the error, let's press

the "Quit Debugging" button,

then update and save the code file.

It's important to quit debugging because

we can't save our changes in debug mode.

Notice the breakpoint wasn't removed,

and execution will pause here next time the code is run.

To run the code without stopping,

we removed the breakpoint by left clicking on it.

Now let's run the code and...

oops, another error?

Do you see where the error is?

If not try using the debug tools

to find and fix the mistake.

Set a breakpoint and "Step" or "Continue"

through the code until you find the error.

Pay attention to the dimensions of variables

as the code iterates through the FOR loop.

Writing Functions Robotics Fundamentals

Troubleshooting Code with the Debugger Microrobotics

Next up

Previous

Writing Functions Robotics Fundamentals