Embedded Systems Learning Academy - User contributions [en]

ADC Interface with Ultrasonic Proximity Sensor

2012-11-15T18:54:25Z

Charley: Created page with " == Overview == The LV-MaxSonar-EZ0 ultrasonic sensor interfaces with your microcontroller using an ADC interface. The microcontroller on your development board is equipped w..."

== Overview ==

The LV-MaxSonar-EZ0 ultrasonic sensor interfaces with your microcontroller using an ADC
interface. The microcontroller on your development board is equipped with an analog-to-digital
converter. This converts an analog signal (continuous voltage that varies over time) into
corresponding digital values (discrete integers that approximate the input voltage). For example,
let’s say that a 12-bit ADC operates on 3.3V, which is the case for your SJSU One development
board. This means that a voltage range between 0V and 3.3V can be divided into 212
or 4096 discrete steps. If the ADC is returning an integer value of 2048, you can calculate that a sensor
connected to the ADC is outputting a voltage of 1.65 volts.

== Pin Connections ==

The ultrasonic sensor has 7 pins. We will connect 3 of them to your board:
# Use a red wire to connect Pin “+5” on the sensor to Pin “3.3V” on your board.
# Use a black wire to connect Pin “GND” on the sensor to Pin “Gnd” on your board.
# Use another color wire to connect Pin “AN” on the sensor to Pin “A0-4” on your board.

== Source Code Description ==

Add <code>#include “adc0.h”</code> to the top of your main.c. This gives you access to the ADC
functions.

Your microcontroller has 80 pins but many more features. Therefore, one pin can do many
different things. We will need to tell it to internally connect pin P1.30 to the ADC
hardware as opposed to some other hardware. To do this we will need to write the
appropriate value to a Pin Select Register:

<code>LPC_PINCON->PINSEL3 |= (3 << 28);</code>

A function has been written to initialize ADC functionality. This function can be called
by:

<code>adc0_initialize();</code>

Now, you can read values from the ADC with a call to:

<code>adc0_getReading(4);</code>

The “4” represents that we are reading values from ADC channel 4. Your board has multiple
ADC channels. For example, the light sensor is connected to channel 2, so we can’t use
that one.

== Sample Code ==

<syntaxhighlight lang = "c">
#include “adc0.h”

int main(void)
{
int reading;

LPC_PINCON->PINSEL3 |= (3 << 28); // ADC-4 is on P1.30, select this as ADC0.4
adc0_initialize(); // Initialize ADC
reading = adc0_getReading(4); // Read current value of ADC-4
printf("\nADC Reading: %d", reading);

return 0;
}
</syntaxhighlight>


== Remaining Work ==

Your job is to turn the integer values you receive from ADC into numbers that are more
useful. Do this by converting the ADC value into a voltage value. Next, convert the
voltage value into a distance measurement value. The conversion rate needed to convert
voltage to inches/centimeters is in the sensor data sheet, which I will leave for you to
find.

== Adding a second ADC type sensor ==

It is possible to connect a second sensor that uses ADC to your board using ADC Channel
5. This will require a different pin select code so ask a TA for assistance.

Sensor Interfaces

2012-11-15T18:52:27Z

Charley:

This page lists the interface hints for various different sensors and peripherals.

* [[PING))) Ultrasonic Sensor]]
* [[TSOP IR Detector]]

 
== SJ-One Board Interfaces ==
* [[ADC Interface with Ultrasonic Proximity Sensor]]
*: This shows you how to use an '''A'''nalog to '''D'''igital '''C'''onverter with a Proximity Sensor example.
* [[PWM Motor Controller Interface]]
* [[GPIO Interface]]
*: This shows you how to use '''G'''eneral '''P'''urpose pins for '''I'''nput or '''O'''utput

Sensor Interfaces

2012-11-15T18:46:44Z

Charley:

This page lists the interface hints for various different sensors and peripherals.

* [[PING))) Ultrasonic Sensor]]
* [[TSOP IR Detector]]

 
== SJ-One Board Interfaces ==
* [[ADC Interface MaxBotics Proximity Sensor]]
* [[PWM Motor Controller Interface]]
* [[GPIO Interface]]
*: This shows you how to use '''G'''eneral '''P'''urpose pins for '''I'''nput or '''O'''utput

ES101 - Lesson 11 : State Machine and Board IO

2012-11-02T19:34:39Z

Charley:

== Objective ==
The objective of this lab is to learn how to design a state machine.

== State Machine Design ==
State machine design can be easily constructed by considering what you want to do based on a certain system state. For example, you might want consider building a state machine for an obstacle-avoidance robot, which acts differently based on if it detects an obstacle or not. In other words, you might have a state to avoid an obstacle, and another state to follow a light-source if there is an obstacle in the way. This helps separate the functionality of what should happen when an obstacle is in the way, and what should happen if an obstacle is not in the way.

Each state should contain meaningful code that should be executed in that state. Furthermore, state transition code should be put in place that provides a way out of the current state to the next state/

== ENUM ==
The enum provides a way to assign names to a sequence of integer values. For example, if a state machine contains two unique states, you should use an <code>enum</code> to declare the names, and the compiler guarantees that the names have a unique identifier. The alternative is to declare separate variables set to a different value, but this approach uses more unnecessary memory and is error-prone.


<syntaxhighlight lang="c">
// Auto-set the identifiers of the variables
enum{stateSTART, stateEND, stateSENSOR};

// Manually set the identifiers of the variables
enum{stateSTART = 1, stateEND = 2, stateSENSOR = 3};
</syntaxhighlight>


The enumerator variables can be automatically assigned a value, or the value can be manually chosen. In either case, unique values should be set for enumerator variables. An enumerator does not have to be used just for a state machine design, but it can be used anytime when you need to simply set unique identifiers to certain names.

==Switch Statement==

The C/C++ programming languages feature switch/case statements. This is similar to using a series of if/else statements. However, it is easier to read and write code using switch/case statements in some situations such as for a state machine design.

 

<syntaxhighlight lang="c">
// Test the "currentState" variable with one of the cases given below
switch(currentState)
{
case stateSTART:
i = 0;
break;
case stateEND:
i = 0;
break;
case stateSENSOR:
i = 2;
break;
default:
i = 3;
}
</syntaxhighlight>

 

As seen by the previous figure, the switch/case statements look elegant, and are easier to read compared to if/else statements had they been used instead. The variable inside the round brackets <code>(currentState)</code> is what is being compared to the other cases. Each statement has a colon (:) at the end. Also, each case ends with a break. Forgetting to include the break will force the code to go to the next state without comparison. For example, if <code>currentState</code> was equal to <code>stateSTART</code> and there was no <code>break</code> statement at the end of the <code>stateSTART</code> case, the code would continue without <code>currentState</code> comparison with <code>stateEND</code> and execute the code inside the <code>stateEND</code> case as well. This may appear to be a programming flaw, however, the switch/case statements were designed this way and some complex designs omit the break statements on purpose.

The <code>default</code> case should be the last case, it is for the case if the variable <code>currentState</code> does not match any of the case statements, and this case does not have the <code>break statement</code>. The default case should be used to indicate an error state or unexpected state fault.

==Static Declaration of Variables==

So far, you have learned how to locally declare variables inside a function, but sometimes, you want to declare the local variables as static so their values are preserved across multiple calls to the same function.

 

<syntaxhighlight lang="c">
void foo()
{
int i = 0;
i++;
printf("Value of i = %i\n", i);
}
int main(void)
{
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
}
</syntaxhighlight>

 

In the code above, whenever <code>foo()</code> is called, it declares a new variable called <code>i</code> and sets it to 0. Then it increments by 1 and prints it out. Whenever <code>main()</code> calls it, <code>foo()</code> does the same thing, and each time it sets <code>i</code> as 1 and when it exits, the variable <code>i</code> goes out of scope.

 

<syntaxhighlight lang="c">
void foo()
{
static int i = 0;
i++;
printf("Value of i = %i\n", i);
}
int main(void)
{
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
}
</syntaxhighlight>

 

In the code above, the result is different because the variable <code>i</code> is declared as <code>static int</code>. It should be observed that the variable <code>i</code> is only declared once, and the function <code>foo()</code> preserves the value of <code>i</code> over repeated function calls. For this assignment, if your state machine is enclosed in a function called <code>stateMachine()</code>, the please decide which variables should preserve their value, and declare them as static. Declaring a static variable is a better programming practice than declaring a global variable which would be visible to the entire program.

==Assignment==
Build the state machine given in the next figure. Enclose your state machine inside a function and call the function every 100ms from your <code>main()</code> function. You will notice that the SENSOR state goes to IDLE state upon Button#1, and using the same button, the IDLE state transitions to SENSOR state. First, answer the question in the "Questions" section of this document.

[[File:stateMachine10.png|600px|center|State Machine Design]]

Whenever the state is changed, print on the screen what state the system is in. The statement should only print once - not every time the state machine function is called.

==Sample Code==
 

<syntaxhighlight lang="c">
void myStateMachine()
{
// Use typedef to create a new variable type called States
typedef enum {start, end} States; // Name your states inside { and }
static States currentState = start; // Initialize static variable of States

switch(currentState)
{
case start:
// Check if button 0 is pressed in this state and transition out of this state
if( /*button 0 is pressed */)
{
currentState = end;
printf("Current state: END. Press Button 1 to go to START");
}
break;
case end:
// Check if button 0 is pressed in this state and transition out of this state
if( /*button 1 is pressed */)
{
currentState = start;
printf("Current state: START. Press Button 0 to go to END");
}
break;
default:
printf("State machine ERROR!\n");
}
}
</syntaxhighlight>

 

==Questions==
# Describe the behavior you see if you press and hold Button#1 for longer than 100ms in the SENSOR state.

ES101 - Lesson 11 : State Machine and Board IO

2012-11-02T19:18:31Z

Charley:

== Objective ==
The objective of this lab is to learn how to design a state machine.

== State Machine Design ==
State machine design can be easily constructed by considering what you want to do based on a certain system state. For example, you might want consider building a state machine for an obstacle-avoidance robot, which acts differently based on if it detects an obstacle or not. In other words, you might have a state to avoid an obstacle, and another state to follow a light-source if there is an obstacle in the way. This helps separate the functionality of what should happen when an obstacle is in the way, and what should happen if an obstacle is not in the way.

Each state should contain meaningful code that should be executed in that state. Furthermore, state transition code should be put in place that provides a way out of the current state to the next state/

== ENUM ==
The enum provides a way to assign names to a sequence of integer values. For example, if a state machine contains two unique states, you should use an <code>enum</code> to declare the names, and the compiler guarantees that the names have a unique identifier. The alternative is to declare separate variables set to a different value, but this approach uses more unnecessary memory and is error-prone.


<syntaxhighlight lang="c">
// Auto-set the identifiers of the variables
enum{stateSTART, stateEND, stateSENSOR};

// Manually set the identifiers of the variables
enum{stateSTART = 1, stateEND = 2, stateSENSOR = 3};
</syntaxhighlight>


The enumerator variables can be automatically assigned a value, or the value can be manually chosen. In either case, unique values should be set for enumerator variables. An enumerator does not have to be used just for a state machine design, but it can be used anytime when you need to simply set unique identifiers to certain names.

==Switch Statement==

The C/C++ programming languages feature switch/case statements. This is similar to using a series of if/else statements. However, it is easier to read and write code using switch/case statements in some situations such as for a state machine design.

 

<syntaxhighlight lang="c">
// Test the "currentState" variable with one of the cases given below
switch(currentState)
{
case stateSTART:
i = 0;
break;
case stateEND:
i = 0;
break;
case stateSENSOR:
i = 2;
break;
default:
i = 3;
}
</syntaxhighlight>

 

As seen by the previous figure, the switch/case statements look elegant, and are easier to read compared to if/else statements had they been used instead. The variable inside the round brackets <code>(currentState)</code> is what is being compared to the other cases. Each statement has a colon (:) at the end. Also, each case ends with a break. Forgetting to include the break will force the code to go to the next state without comparison. For example, if <code>currentState</code> was equal to <code>stateSTART</code> and there was no <code>break</code> statement at the end of the <code>stateSTART</code> case, the code would continue without <code>currentState</code> comparison with <code>stateEND</code> and execute the code inside the <code>stateEND</code> case as well. This may appear to be a programming flaw, however, the switch/case statements were designed this way and some complex designs omit the break statements on purpose.

The <code>default</code> case should be the last case, it is for the case if the variable <code>currentState</code> does not match any of the case statements, and this case does not have the <code>break statement</code>. The default case should be used to indicate an error state or unexpected state fault.

==Static Declaration of Variables==

So far, you have learned how to locally declare variables inside a function, but sometimes, you want to declare the local variables as static so their values are preserved across multiple calls to the same function.

 

<syntaxhighlight lang="c">
void foo()
{
int i = 0;
i++;
printf("Value of i = %i\n", i);
}
int main(void)
{
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
}
</syntaxhighlight>

 

In the code above, whenever <code>foo()</code> is called, it declares a new variable called <code>i</code> and sets it to 0. Then it increments by 1 and prints it out. Whenever <code>main()</code> calls it, <code>foo()</code> does the same thing, and each time it sets <code>i</code> as 1 and when it exits, the variable <code>i</code> goes out of scope.

 

<syntaxhighlight lang="c">
void foo()
{
static int i = 0;
i++;
printf("Value of i = %i\n", i);
}
int main(void)
{
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
}
</syntaxhighlight>

 

In the code above, the result is different because the variable <code>i</code> is declared as <code>static int</code>. It should be observed that the variable <code>i</code> is only declared once, and the function <code>foo()</code> preserves the value of <code>i</code> over repeated function calls. For this assignment, if your state machine is enclosed in a function called <code>stateMachine()</code>, the please decide which variables should preserve their value, and declare them as static. Declaring a static variable is a better programming practice than declaring a global variable which would be visible to the entire program.

==Assignment==
Build the state machine given in the next figure. Enclose your state machine inside a function and call the function every 100ms from your <code>main()</code> function. You will notice that the SENSOR state goes to IDLE state upon Button#1, and using the same button, the IDLE state transitions to SENSOR state. First, answer the question in the "Questions" section of this document.

[[File:stateMachine10.png|600px|center|State Machine Design]]

Whenever the state is changed, print on the screen what state the system is in. The statement should only print once - not every time the state machine function is called.

==Questions==
# Describe the behavior you see if you press and hold Button#1 for longer than 100ms in the SENSOR state.

ES101 - Lesson 11 : State Machine and Board IO

2012-11-02T19:18:02Z

Charley:

== Objective ==
The objective of this lab is to learn how to design a state machine.

== State Machine Design ==
State machine design can be easily constructed by considering what you want to do based on a certain system state. For example, you might want consider building a state machine for an obstacle-avoidance robot, which acts differently based on if it detects an obstacle or not. In other words, you might have a state to avoid an obstacle, and another state to follow a light-source if there is an obstacle in the way. This helps separate the functionality of what should happen when an obstacle is in the way, and what should happen if an obstacle is not in the way.

Each state should contain meaningful code that should be executed in that state. Furthermore, state transition code should be put in place that provides a way out of the current state to the next state/

 

== ENUM ==
The enum provides a way to assign names to a sequence of integer values. For example, if a state machine contains two unique states, you should use an <code>enum</code> to declare the names, and the compiler guarantees that the names have a unique identifier. The alternative is to declare separate variables set to a different value, but this approach uses more unnecessary memory and is error-prone.


<syntaxhighlight lang="c">
// Auto-set the identifiers of the variables
enum{stateSTART, stateEND, stateSENSOR};

// Manually set the identifiers of the variables
enum{stateSTART = 1, stateEND = 2, stateSENSOR = 3};
</syntaxhighlight>


The enumerator variables can be automatically assigned a value, or the value can be manually chosen. In either case, unique values should be set for enumerator variables. An enumerator does not have to be used just for a state machine design, but it can be used anytime when you need to simply set unique identifiers to certain names.

==Switch Statement==

The C/C++ programming languages feature switch/case statements. This is similar to using a series of if/else statements. However, it is easier to read and write code using switch/case statements in some situations such as for a state machine design.

 

<syntaxhighlight lang="c">
// Test the "currentState" variable with one of the cases given below
switch(currentState)
{
case stateSTART:
i = 0;
break;
case stateEND:
i = 0;
break;
case stateSENSOR:
i = 2;
break;
default:
i = 3;
}
</syntaxhighlight>

 

As seen by the previous figure, the switch/case statements look elegant, and are easier to read compared to if/else statements had they been used instead. The variable inside the round brackets <code>(currentState)</code> is what is being compared to the other cases. Each statement has a colon (:) at the end. Also, each case ends with a break. Forgetting to include the break will force the code to go to the next state without comparison. For example, if <code>currentState</code> was equal to <code>stateSTART</code> and there was no <code>break</code> statement at the end of the <code>stateSTART</code> case, the code would continue without <code>currentState</code> comparison with <code>stateEND</code> and execute the code inside the <code>stateEND</code> case as well. This may appear to be a programming flaw, however, the switch/case statements were designed this way and some complex designs omit the break statements on purpose.

The <code>default</code> case should be the last case, it is for the case if the variable <code>currentState</code> does not match any of the case statements, and this case does not have the <code>break statement</code>. The default case should be used to indicate an error state or unexpected state fault.

==Static Declaration of Variables==

So far, you have learned how to locally declare variables inside a function, but sometimes, you want to declare the local variables as static so their values are preserved across multiple calls to the same function.

 

<syntaxhighlight lang="c">
void foo()
{
int i = 0;
i++;
printf("Value of i = %i\n", i);
}
int main(void)
{
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
}
</syntaxhighlight>

 

In the code above, whenever <code>foo()</code> is called, it declares a new variable called <code>i</code> and sets it to 0. Then it increments by 1 and prints it out. Whenever <code>main()</code> calls it, <code>foo()</code> does the same thing, and each time it sets <code>i</code> as 1 and when it exits, the variable <code>i</code> goes out of scope.

 

<syntaxhighlight lang="c">
void foo()
{
static int i = 0;
i++;
printf("Value of i = %i\n", i);
}
int main(void)
{
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
}
</syntaxhighlight>

 

In the code above, the result is different because the variable <code>i</code> is declared as <code>static int</code>. It should be observed that the variable <code>i</code> is only declared once, and the function <code>foo()</code> preserves the value of <code>i</code> over repeated function calls. For this assignment, if your state machine is enclosed in a function called <code>stateMachine()</code>, the please decide which variables should preserve their value, and declare them as static. Declaring a static variable is a better programming practice than declaring a global variable which would be visible to the entire program.

==Assignment==
Build the state machine given in the next figure. Enclose your state machine inside a function and call the function every 100ms from your <code>main()</code> function. You will notice that the SENSOR state goes to IDLE state upon Button#1, and using the same button, the IDLE state transitions to SENSOR state. First, answer the question in the "Questions" section of this document.

[[File:stateMachine10.png|600px|center|State Machine Design]]

Whenever the state is changed, print on the screen what state the system is in. The statement should only print once - not every time the state machine function is called.

==Questions==
# Describe the behavior you see if you press and hold Button#1 for longer than 100ms in the SENSOR state.

ES101 - Lesson 11 : State Machine and Board IO

2012-11-02T19:01:11Z

Charley:

== Objective ==
The objective of this lab is to learn how to design a state machine.

== State Machine Design ==
State machine design can be easily constructed by considering what you want to do based on a certain system state. For example, you might want consider building a state machine for an obstacle-avoidance robot, which acts differently based on if it detects an obstacle or not. In other words, you might have a state to avoid an obstacle, and another state to follow a light-source if there is an obstacle in the way. This helps separate the functionality of what should happen when an obstacle is in the way, and what should happen if an obstacle is not in the way.

Each state should contain meaningful code that should be executed in that state. Furthermore, state transition code should be put in place that provides a way out of the current state to the next state/

 

== ENUM ==
The enum provides a way to assign names to a sequence of integer values. For example, if a state machine contains two unique states, you should use an <code>enum</code> to declare the names, and the compiler guarantees that the names have a unique identifier. The alternative is to declare separate variables set to a different value, but this approach uses more unnecessary memory and is error-prone.

<syntaxhighlight lang="c">
// Auto-set the identifiers of the variables
enum{stateSTART, stateEND, stateSENSOR};

// Manually set the identifiers of the variables
enum{stateSTART = 1, stateEND = 2, stateSENSOR = 3};
</syntaxhighlight>

The enumerator variables can be automatically assigned a value, or the value can be manually chosen. In either case, unique values should be set for enumerator variables. An enumerator does not have to be used just for a state machine design, but it can be used anytime when you need to simply set unique identifiers to certain names.

==Switch Statement==

The C/C++ programming languages feature switch/case statements. This is similar to using a series of if/else statements. However, it is easier to read and write code using switch/case statements in some situations such as for a state machine design.

<syntaxhighlight lang="c">
// Test the "currentState" variable with one of the cases given below
switch(currentState)
{
case stateSTART:
i = 0;
break;
case stateEND:
i = 0;
break;
case stateSENSOR:
i = 2;
break;
default:
i = 3;
}
</syntaxhighlight>

As seen by the previous figure, the switch/case statements loog elegant, and are easier to read compared to if/else statements had they been used instead. The variable inside the round brackets <code>(currentState)</code> is what is being compared to the other cases. Each statement has a colon (:) at the end. Also, each case ends with a break. Forgetting to include the break will force the code to go to the next state without comparison. For example, if <code>currentState</code> was equal to <code>stateSTART</code> and there was no <code>break</code> statement at the end of the <code>stateSTART</code> case, the code would continue without <code>currentState</code> comparison with <code>stateEND</code> and execute the code inside the <code>stateEND</code> case as well. This may appear to be a programming flaw, however, the switch/case statements were designed this way and some complex designs omit the break statements on purpose.

The <code>default</code> case should be the last case, it is for the case if the variable <code>currentState</code> does not match any of the case statements, and this case does not have the <code>break statement</code>. The default case should be used to indicate an error state or unexpected state fault.

==Static Declaration of Variables==

So far, you have learned how to locally declare variables inside a function, but sometimes, you want to declare the local variables as static so their values are preserved across multiple calls to the same function.

<syntaxhighlight lang="c">
void foo()
{
int i = 0;
i++;
printf("Value of i = %i\n", i);
}
int main(void)
{
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
}
</syntaxhighlight>

In the code above, whenever <code>foo()</code> is called, it declares a new variable called <code>i</code> and sets it to 0. Then it increments by 1 and prints it out. Whenever <code>main()</code> calls it, <code>foo()</code> does the same thing, and each time it sets <code>i</code> as 1 and when it exits, the variable <code>i</code> goes out of scope.

<syntaxhighlight lang="c">
void foo()
{
static int i = 0;
i++;
printf("Value of i = %i\n", i);
}
int main(void)
{
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
}
</syntaxhighlight>

In the code above, the result is different because the variable <code>i</code> is declared as <code>static int</code>. It should be observed that the variable <code>i</code> is only declared once, and the function <code>foo()</code> preserves the value of <code>i</code> over repeated function calls. For this assignment, if your state machine is enclosed in a function called <code>stateMachine()</code>, the please decide which variables should preserve their value, and declare them as static. Declaring a static variable is a better programming practice than declaring a global variable which would be visible to the entire program.

==Assignment==
Build the state machine given in the next figure. Enclose your state machine inside a function and call the function every 100ms from your <code>main()</code> function. You will notice that the SENSOR state goes to IDLE state upon Button#1, and using the same button, the IDLE state transitions to SENSOR state. First, answer the question in the "Questions" section of this document.

[[File:stateMachine10.png|600px|center|State Machine Design]]

Whenever the state is changed, print on the screen what state the system is in. The statement should only print once - not every time the state machine function is called.

==Questions==
# Describe the behavior you see if you press and hold Button#1 for longer than 100ms in the SENSOR state.

File:StateMachine10.png

2012-11-02T18:57:31Z

Charley: State Machine Design

State Machine Design

ES101 - Lesson 11 : State Machine and Board IO

2012-11-02T18:44:18Z

Charley:

== Objective ==
The objective of this lab is to learn how to design a state machine.

== State Machine Design ==
State machine design can be easily constructed by considering what you want to do based on a certain system state. For example, you might want consider building a state machine for an obstacle-avoidance robot, which acts differently based on if it detects an obstacle or not. In other words, you might have a state to avoid an obstacle, and another state to follow a light-source if there is an obstacle in the way. This helps separate the functionality of what should happen when an obstacle is in the way, and what should happen if an obstacle is not in the way.

Each state should contain meaningful code that should be executed in that state. Furthermore, state transition code should be put in place that provides a way out of the current state to the next state/

 

== ENUM ==
The enum provides a way to assign names to a sequence of integer values. For example, if a state machine contains two unique states, you should use an <code>enum</code> to declare the names, and the compiler guarantees that the names have a unique identifier. The alternative is to declare separate variables set to a different value, but this approach uses more unnecessary memory and is error-prone.

<syntaxhighlight lang="c">
// Auto-set the identifiers of the variables
enum{stateSTART, stateEND, stateSENSOR};

// Manually set the identifiers of the variables
enum{stateSTART = 1, stateEND = 2, stateSENSOR = 3};
</syntaxhighlight>

The enumerator variables can be automatically assigned a value, or the value can be manually chosen. In either case, unique values should be set for enumerator variables. An enumerator does not have to be used just for a state machine design, but it can be used anytime when you need to simply set unique identifiers to certain names.

==Switch Statement==

The C/C++ programming languages feature switch/case statements. This is similar to using a series of if/else statements. However, it is easier to read and write code using switch/case statements in some situations such as for a state machine design.

<syntaxhighlight lang="c">
// Test the "currentState" variable with one of the cases given below
switch(currentState)
{
case stateSTART:
i = 0;
break;
case stateEND:
i = 0;
break;
case stateSENSOR:
i = 2;
break;
default:
i = 3;
}
</syntaxhighlight>

As seen by the previous figure, the switch/case statements loog elegant, and are easier to read compared to if/else statements had they been used instead. The variable inside the round brackets <code>(currentState)</code> is what is being compared to the other cases. Each statement has a colon (:) at the end. Also, each case ends with a break. Forgetting to include the break will force the code to go to the next state without comparison. For example, if <code>currentState</code> was equal to <code>stateSTART</code> and there was no <code>break</code> statement at the end of the <code>stateSTART</code> case, the code would continue without <code>currentState</code> comparison with <code>stateEND</code> and execute the code inside the <code>stateEND</code> case as well. This may appear to be a programming flaw, however, the switch/case statements were designed this way and some complex designs omit the break statements on purpose.

The <code>default</code> case should be the last case, it is for the case if the variable <code>currentState</code> does not match any of the case statements, and this case does not have the <code>break statement</code>. The default case should be used to indicate an error state or unexpected state fault.

==Static Declaration of Variables==

So far, you have learned how to locally declare variables inside a function, but sometimes, you want to declare the local variables as static so their values are preserved across multiple calls to the same function.

<syntaxhighlight lang="c">
void foo()
{
int i = 0;
i++;
printf("Value of i = %i\n", i);
}
int main(void)
{
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
}
</syntaxhighlight>

In the code above, whenever <code>foo()</code> is called, it declares a new variable called <code>i</code> and sets it to 0. Then it increments by 1 and prints it out. Whenever <code>main()</code> calls it, <code>foo()</code> does the same thing, and each time it sets <code>i</code> as 1 and when it exits, the variable <code>i</code> goes out of scope.

<syntaxhighlight lang="c">
void foo()
{
static int i = 0;
i++;
printf("Value of i = %i\n", i);
}
int main(void)
{
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
foo(); // Prints: Value of i = 1
}
</syntaxhighlight>

In the code above, the result is different because the variable <code>i</code> is declared as <code>static int</code>. It should be observed that the variable <code>i</code> is only declared once, and the function <code>foo()</code> preserves the value of <code>i</code> over repeated function calls. For this assignment, if your state machine is enclosed in a function called <code>stateMachine()</code>, the please decide which variables should preserve their value, and declare them as static. Declaring a static variable is a better programming practice than declaring a global variable which would be visible to the entire program.

==Assignment==
Build the state machine given in the next figure. Enclose your state machine inside a function and call the function every 100ms from your <code>main()</code> function. You will notice that the SENSOR state goes to IDLE state upon Button#1, and using the same button, the IDLE state transitions to SENSOR state. First, answer the question in the "Questions" section of this document.

Add image here

Whenever the state is changed, print on the screen what state the system is in. The statement should only print once - not every time the state machine function is called.

==Questions==
# Describe the behavior you see if you press and hold Button#1 for longer than 100ms in the SENSOR state.

ES101 - Lesson 11 : State Machine and Board IO

2012-11-02T18:33:55Z

Charley:

ES101 - Lesson 11 : State Machine and Board IO

2012-11-02T02:21:27Z

Charley:

ES101 - Lesson 11 : State Machine and Board IO

2012-11-02T01:52:50Z

Charley:

ES101 - Lesson 11 : State Machine and Board IO

2012-11-02T01:46:20Z

Charley: Created page with "== Objective == The objective of this lab is to learn how to design a state machine. == State Machine Design == State machine design can be easily constructed by considering ..."

ES101 - Lesson 8 : Functions with Pass-By-Reference

2012-10-16T21:45:09Z

Charley:

== Objective ==
You will learn the basics of pointers, which are used in combination with the functions.

Pass-by-value type of functions pass just the value of the variables into a function, but with a simple change, you can use functions that accept pass-by-reference type of variables. This is a very powerful concept that will allow your functions to change the values outside of its scope.

== Pass By Reference ==
Pass by reference provides a mean to provide input to functions by specifying a memory location, which allows the function to modify caller's variables. In other words, instead of just merely giving a value, you pass the pointer of variable(s), and the pointer points to the memory address where the data is stored. The values are then accessed by using the * operator inside the function, which is called the dereference operator. Students often get confused with & and * symbols. & refers to the memory address whereas as * refers to a value stored at this memory address.

<syntaxhighlight lang="c">
// Declare foobar() that takes pointers of int and float
void foobar(int *intInput, float *fpInput);

int main(void)
{
// We can no longer do this since we have to provide
// addresses of some variable
foobar(1, 1.2); // ERROR!
foobar(anInt, aFloat); // ERROR!

// Pass variable addresses to foobar()
int anInt = 1;
float aFloat = 2.3;
foobar(&anInt, &aFloat);

// After function call to foobar(): anInt and aFloat are zero
printf("Variables now: %i, %f\n", anInt, aFloat);
}

void foobar(int *intInput, float *fpInput)
{
// intInput and fpInput are addresses, so to read/write
// the values at these addresses, we must use * (dereference)
// operator
printf("Input was: %i, %f\n", *intInput, *fpInput);

// Modify the inputs:
*intInput = 0;
*fpInput = 0;
}
</syntaxhighlight>

Similar to how you provided address to <code>scanf</code> function, you must provide address of variables to <code>foobar()</code>, when calling the function otherwise a compiler error will be encountered as seen by first two calls to <code>foobar()</code> in the figure above. The third call to <code>foobar()</code> shows correct function call, which passes addresses of <code>anInt</code> and <code>aFloat</code> variables. The <code>main()</code> function called <code>foobar()</code> with values as 1 and 2.3, and, after <code>foobar()</code> returns, the values of the variables are set to 0 by <code>foobar()</code>.

==Passing Arrays to a Function==
Passing arrays to a function is not much different than passing a pointer. This is because to pass an array to a function, you actually still pass the address of its first element. Arrays usually consist of large number of elements; therefore, passing array pass-by-value would be time consuming because each elements needs to copied. To address this issue, the address of first element of the array is passed to functions (pass-by-reference). See the examples below for illustration.

<syntaxhighlight lang="c">
void getName(char *charArray);
float getAverageOfFloatingPointArray(float *floatArray, int elements);

int main(void)
{
char userName[50];
getName(userName);
printf("Your name is: %s\n", userName);

float samples[4] = {1.1, 2.2, 3.3, 4.4};
float average = getAverageOfFloatingPointArray(samples, 4);
printf("Average = %f\n", average);
}

void getName(char *charArray)
{
printf("Enter your name: ");
// No & symbol needed since the pointer is already the address
scanf("%s", charArray);
}

float getAverageOfFloatingPointArray(float *floatArray, int elements)
{
int i = 0;
float sum = 0;
for(i = 0; i < elements; i++)
{
sum += floatArray[i];
}

float average = sum / elements;
return average;
}
</syntaxhighlight>

Notice that when <code>main()</code> calls the <code>getName()</code> and <code>getAverageOfFloatingPointArray()</code> functions, it just passes the arrays without the & operator; this is because the array name itself is the address of the first element of the array. The one problem is that <code>getAverageOfFloatingPointArray()</code> will not know how big the array is, so another parameter, <code>elements</code>, is given, such that this function can know how many elements there are in the array. Again, this is similar to pass-by-reference, except how the arrays are passed. One last thing to note is that when the <code>getName()</code> function tried to do <code>scanf</code>, it did not need to pass the address of <code>charArray</code>, because the <code>charArray</code> is the address to begin with. Furthermore, notice that the <code>floatArray</code> was accessed simply by using index locations.

==Assignment==
# Build the following functions and use meaningful names for each function.
#*1a. A function asks to input an integer, scans it and returns the input data.
#*1b. A function asks to input a floating-point number, scans it and returns the input data.
#*1c. A function that takes a char pointer to a char array, asks for the user‟s first name, and stores it into the array using the pointer.
#*1d. A function that takes two integer pointers and swaps the numbers.
# Ask the user to input two integers using the function built in 1a, swap them using your swap function, and print the values on the screen.
# Declare an array of 5 floating point numbers, ask the user to input five floating point numbers by calling the function in 1b five times, and store the value to the five index locations of the floating-point array. Create a function that can calculate the average of floating-point array and returns the average. Using this function, get the average of the user input and print it out.
# Ask the user to input their name using the function built in 1c and print the name using a for loop in capital letters.

==Questions==
Answer the following questions to complete the lab.
# Although pass-by-reference can be used to substitute all pass-by-value functions, why is pass-by-value be considered safer?
# When passing an integer array to a function, why do you also need to pass the number of elements in that array?

ES101 - Lesson 8 : Functions with Pass-By-Reference

2012-10-16T18:36:45Z

Charley:

== Objective ==
You will learn the basics of pointers, which are used in combination with the functions.

Pass-by-value type of functions pass just the value of the variables into a function, but with a simple change, you can use functions that accept pass-by-reference type of variables. This is a very powerful concept that will allow your functions to change the values outside of its scope.

== Pass By Reference ==
Pass by reference provides a mean to provide input to functions by specifying a memory location, which allows the function to modify caller's variables. In other words, instead of just merely giving a value, you pass the pointer of variable(s), and the pointer points to the memory address where the data is stored. The values are then accessed by using the * operator inside the function, which is called the dereference operator. Students often get confused with & and * symbols. & refers to the memory address whereas as * refers to a value stored at this memory address.

<syntaxhighlight lang="c">
// Declare foobar() that takes pointers of int and float
void foobar(int *intInput, float *fpInput);

int main(void)
{
// We can no longer do this since we have to provide
// addresses of some variable
foobar(1, 1.2); // ERROR!
foobar(anInt, aFloat); // ERROR!

// Pass variable addresses to foobar()
int anInt = 1;
float aFloat = 2.3;
foobar(&anInt, &aFloat);

// After function call to foobar(): anInt and aFloat are zero
printf("Variables now: %i, %f\n", anInt, aFloat);
}

void foobar(int *intInput, float *fpInput)
{
// intInput and fpInput are addresses, so to read/write
// the values at these addresses, we must use * (dereference)
// operator
printf("Input was: %i, %f\n", *intInput, *fpInput);

// Modify the inputs:
*intInput = 0;
*fpInput = 0;
}
</syntaxhighlight>

Similar to how you provided address to <code>scanf</code> function, you must provide address of variables to <code>foobar()</code>, when calling the function otherwise a compiler error will be encountered as seen by first two calls to <code>foobar()</code> in the figure above. The third call to <code>foobar()</code> shows correct function call, which passes addresses of <code>anInt</code> and <code>aFloat</code> variables. The <code>main()</code> function called <code>foobar()</code> with values as 1 and 2.3, and, after <code>foobar()</code> returns, the values of the variables are set to 0 by <code>foobar()</code>.

==Passing Arrays to a Function==
Passing arrays to a function is not much different than passing a pointer. This is because to pass an array to a function, you actually still pass the address of its first element. Arrays usually consist of large number of elements; therefore, passing array pass-by-value would be time consuming because each elements needs to copied. To address this issue, the address of first element of the array is passed to functions (pass-by-reference). See the examples below for illustration.

<syntaxhighlight lang="c">
void getName(char *charArray);
float getAverageOfFloatingPointArray(float *floatArray, int elements);

int main(void)
{
char userName[50];
getName(userName);
printf("Your name is: %s\n", userName);

float samples[4] = {1.1, 2.2, 3.3, 4.4};
float average = getAverageOfFloatingPointArray(samples, 4);
printf("Average = %f\n", average);
}

void getName(char *charArray)
{
printf("Enter your name: ");
// No & symbol needed since the pointer is already the address
scanf("%s", charArray);
}

float getAverageOfFloatingPointArray(float *floatArray, int elements)
{
int i = 0;
float sum = 0;
for(i = 0; i < elements; i++)
{
sum += floatArray[i];
}

float average = sum / elements;
return average;
}
</syntaxhighlight>

Notice that when main() calls the <code>getName()</code> and <code>getAverageOfFloatingPointArray()</code> functions, it just passes the arrays without the & operator; this is because the array name itself is the address of the first element of the array. The one problem is that <code>getAverageOfFloatingPointArray()</code> will not know how big the array is, so another parameter, <code>elements</code>, is given, such that this function can know how many elements there are in the array. Again, this is similar to pass-by-reference, except how the arrays are passed. One last thing to note is that when the <code>getName()</code> function tried to do <code>scanf</code>, it did not need to pass the address of <code>charArray</code>, because the <code>charArray</code> is the address to begin with. Furthermore, notice that the <code>floatArray</code> was accessed simply by using index locations.

==Assignment==
# Build the following functions and use meaningful names for each function.
#* A function asks to input an integer, scans it and returns the input data.
#* A function asks to input a floating-point number, scans it and returns the input data.
#* A function that takes a char pointer to a char array, asks for the user‟s first name, and stores it into the array using the pointer.
#* A function that takes two integer pointers and swaps the numbers.
# Ask the user to input two integers using the function built in 1a, swap them using your swap function, and print the values on the screen.
# Declare an array of 5 floating point numbers, ask the user to input five floating point numbers by calling the function in 1b five times, and store the value to the five index locations of the floating-point array. Create a function that can calculate the average of floating-point array and returns the average. Using this function, get the average of the user input and print it out.
# Ask the user to input their name using the function built in 1c and print the name using a for loop in capital letters.

==Questions==
Answer the following questions to complete the lab.
# Although pass-by-reference can be used to substitute all pass-by-value functions, why is pass-by-value be considered safer?
# When passing an integer array to a function, why do you also need to pass the number of elements in that array?

ES101 - Lesson 8 : Functions with Pass-By-Reference

2012-10-16T18:31:59Z

Charley:

== Objective ==
You will learn the basics of pointers, which are used in combination with the functions.

Pass-by-value type of functions pass just the value of the variables into a function, but with a simple change, you can use functions that accept pass-by-reference type of variables. This is a very powerful concept that will allow your functions to change the values outside of its scope.

== Pass By Reference ==
Pass by reference provides a mean to provide input to functions by specifying a memory location, which allows the function to modify caller's variables. In other words, instead of just merely giving a value, you pass the pointer of variable(s), and the pointer points to the memory address where the data is stored. The values are then accessed by using the * operator inside the function, which is called the dereference operator. Students often get confused with & and * symbols. & refers to the memory address whereas as * refers to a value stored at this memory address.

<syntaxhighlight lang="c">
// Declare foobar() that takes pointers of int and float
void foobar(int *intInput, float *fpInput);

int main(void)
{
// We can no longer do this since we have to provide
// addresses of some variable
foobar(1, 1.2); // ERROR!
foobar(anInt, aFloat); // ERROR!

// Pass variable addresses to foobar()
int anInt = 1;
float aFloat = 2.3;
foobar(&anInt, &aFloat);

// After function call to foobar(): anInt and aFloat are zero
printf("Variables now: %i, %f\n", anInt, aFloat);
}

void foobar(int *intInput, float *fpInput)
{
// intInput and fpInput are addresses, so to read/write
// the values at these addresses, we must use * (dereference)
// operator
printf("Input was: %i, %f\n", *intInput, *fpInput);

// Modify the inputs:
*intInput = 0;
*fpInput = 0;
}
</syntaxhighlight>

Similar to how you provided address to <code>scanf</code> function, you must provide address of variables to <code>foobar()</code>, when calling the function otherwise a compiler error will be encountered as seen by first two calls to <code>foobar()</code> in the figure above. The third call to <code>foobar()</code> shows correct function call, which passes addresses of <code>anInt</code> and <code>aFloat</code> variables. The <code>main()</code> function called <code>foobar()</code> with values as 1 and 2.3, and, after <code>foobar()</code> returns, the values of the variables are set to 0 by <code>foobar()</code>.

==Passing Arrays to a Function==
Passing arrays to a function is not much different than passing a pointer. This is because to pass an array to a function, you actually still pass the address of its first element. Arrays usually consist of large number of elements; therefore, passing array pass-by-value would be time consuming because each elements needs to copied. To address this issue, the address of first element of the array is passed to functions (pass-by-reference). See the examples below for illustration.

<syntaxhighlight lang="c">
void getName(char *charArray);
float getAverageOfFloatingPointArray(float *floatArray, int elements);

int main(void)
{
char userName[50];
getName(userName);
printf("Your name is: %s\n", userName);

float samples[4] = {1.1, 2.2, 3.3, 4.4};
float average = getAverageOfFloatingPointArray(samples, 4);
printf("Average = %f\n", average);
}

void getName(char *charArray)
{
printf("Enter your name: ");
// No & symbol needed since the pointer is already the address
scanf("%s", charArray);
}

float getAverageOfFloatingPointArray(float *floatArray, int elements)
{
int i = 0;
float sum = 0;
for(i = 0; i < elements; i++)
{
sum += floatArray[i];
}

float average = sum / elements;
return average;
}
</syntaxhighlight>

Notice that when main() calls the <code>getName()</code> and <code>getAverageOfFloatingPointArray()</code> functions, it just passes the arrays without the & operator; this is because the array name itself is the address of the first element of the array. The one problem is that <code>getAverageOfFloatingPointArray()</code> will not know how big the array is, so another parameter, <code>elements</code>, is given, such that this function can know how many elements there are in the array. Again, this is similar to pass-by-reference, except how the arrays are passed. One last thing to note is that when the <code>getName()</code> function tried to do <code>scanf</code>, it did not need to pass the address of <code>charArray</code>, because the <code>charArray</code> is the address to begin with. Furthermore, notice that the <code>floatArray</code> was accessed simply by using index locations.

ES101 - Lesson 8 : Functions with Pass-By-Reference

2012-10-16T18:28:22Z

Charley:

ES101 - Lesson 8 : Functions with Pass-By-Reference

2012-10-16T18:20:48Z

Charley:

ES101 - Lesson 8 : Functions with Pass-By-Reference

2012-10-16T18:17:35Z

Charley:

ES101 - Lesson 8 : Functions with Pass-By-Reference

2012-10-16T18:08:32Z

Charley: Created page with "== Objective == You will learn the basics of pointers, which are used in combination with the functions. Pass-by-value type of functions pass just the value of the variables ..."