Medien Wiki - User contributions [en]

GMU:Actors, Traces, Collectives/SS17/Tracking

2017-06-24T14:33:57Z

Veja6203:

<syntaxhighlight lang="javaScript">

import processing.video.*;
Capture video;
int x, y;
Mover [] mover = new Mover [20];

void setup() {

size(640, 480);
video = new Capture(this, width, height);
video.start();
for (int i = 0; i < mover.length; i++) {
mover [i]=new Mover ();
}
}

void draw() {
if (video.available()) {
video.read();
image(video, 0, 0, width, height);
int brightestX = 0; // X-coordinate of the brightest video pixel
int brightestY = 0; // Y-coordinate of the brightest video pixel
float brightestValue = 0; // Brightness of the brightest video pixel
video.loadPixels();
int index = 0;
for (int y = 0; y < video.height; y++) {
for (int x = 0; x < video.width; x++) {
int pixelValue = video.pixels[index];
float pixelBrightness = brightness(pixelValue);
if (pixelBrightness > brightestValue) {
brightestValue = pixelBrightness;
brightestY = y;
brightestX = x;
}
index++;
}
}
for (int j = 0; j < mover.length; j++) {
// Update the position
mover[j].update(brightestX, brightestY);
// Display the Mover
mover[j].display();
}
}
}

// The Nature of Code
// Daniel Shiffman
// http://natureofcode.com

class Mover {

// The Mover tracks position, velocity, and acceleration
PVector position;
PVector velocity;
PVector dir;
// The Mover's maximum speed
float topspeed;

Mover() {
// Start in the center
position = new PVector(random(width),random(height));
velocity = new PVector(0,0);
topspeed = 5;
}

void update(float x, float y) {

// Compute a vector that points from position to mouse
PVector mouse = new PVector(x,y);
PVector dir = PVector.sub(mouse,position);

// Set magnitude of acceleration
dir.setMag(0.3);

// Velocity changes according to acceleration
velocity.add(dir);

// Limit the velocity by topspeed
velocity.limit(topspeed);
// position changes by velocity
position.add(velocity);
}

void display() {
stroke(0);
strokeWeight(2);
//fill(127);
//ellipse(position.x,position.y,48,48);
line (position.x,position.y, position.x+velocity.x,position.y+velocity.y);
}

}
</syntaxhighlight>

GMU:Actors, Traces, Collectives/SS17/Tracking

2017-06-24T14:28:33Z

Veja6203:

<syntaxhighlight lang="javaScript">

import processing.video.*;
Capture video;
int x, y;
Mover [] mover = new Mover [20];

void setup() {

size(640, 480);
video = new Capture(this, width, height);
video.start();
for (int i = 0; i < mover.length; i++) {
mover [i]=new Mover ();
}
}

void draw() {
if (video.available()) {
video.read();
image(video, 0, 0, width, height);
int brightestX = 0; // X-coordinate of the brightest video pixel
int brightestY = 0; // Y-coordinate of the brightest video pixel
float brightestValue = 0; // Brightness of the brightest video pixel
video.loadPixels();
int index = 0;
for (int y = 0; y < video.height; y++) {
for (int x = 0; x < video.width; x++) {
int pixelValue = video.pixels[index];
float pixelBrightness = brightness(pixelValue);
if (pixelBrightness > brightestValue) {
brightestValue = pixelBrightness;
brightestY = y;
brightestX = x;
}
index++;
}
}
for (int j = 0; j < mover.length; j++) {
// Update the position
mover[j].update(brightestX, brightestY);
// Display the Mover
mover[j].display();
}
}
}

// The Nature of Code
// Daniel Shiffman
// http://natureofcode.com

class Mover {

// The Mover tracks position, velocity, and acceleration
PVector position;
PVector velocity;
PVector dir;
// The Mover's maximum speed
float topspeed;

Mover() {
// Start in the center
position = new PVector(width/2,height/2);
velocity = new PVector(0,0);
topspeed = 5;
}

void update(float x, float y) {

// Compute a vector that points from position to mouse
PVector mouse = new PVector(x,y);
PVector dir = PVector.sub(mouse,position);

// Set magnitude of acceleration
dir.setMag(0.3);

// Velocity changes according to acceleration
velocity.add(dir);

// Limit the velocity by topspeed
velocity.limit(topspeed);
// position changes by velocity
position.add(velocity);
}

void display() {
stroke(0);
strokeWeight(2);
//fill(127);
//ellipse(position.x,position.y,48,48);
line (position.x,position.y, position.x+velocity.x,position.y+velocity.y);
}

}
</syntaxhighlight>

GMU:Actors, Traces, Collectives/SS17/Schachbrettmuster Array

2017-06-10T12:59:03Z

Veja6203:

<syntaxhighlight lang="javaScript">
int [][] rectPos;

void setup () {
size (800, 800);
noLoop();

rectPos = new int [width/20][height/20];
}

void draw() {

for (int j = 0; j < height /20; j ++) {
for (int i =0; i < width/20; i ++) {

rectPos [i][j] = rectPos [i][j] + 20*i;

if (i%2==0&&j%2==0) {
fill(0);
}else if(i%2!=0&&j%2!=0){
fill(0);
}else{
fill (255);
}
rect (i*20, j*20, 20, 20 );
}
}
}
</syntaxhighlight>

GMU:Actors, Traces, Collectives/SS17/Schachbrettmuster Array

2017-06-10T12:58:30Z

Veja6203: Created page with "<syntaxhighlight lang=javaScript> int [][] rectPos; void setup () { size (800, 800); noLoop(); rectPos = new int [width/20][height/20]; } void draw() { for (int j..."

<syntaxhighlight lang=javaScript>
int [][] rectPos;

void setup () {
size (800, 800);
noLoop();

rectPos = new int [width/20][height/20];
}

void draw() {

for (int j = 0; j < height /20; j ++) {
for (int i =0; i < width/20; i ++) {

rectPos [i][j] = rectPos [i][j] + 20*i;

if (i%2==0&&j%2==0) {
fill(0);
}else if(i%2!=0&&j%2!=0){
fill(0);
}else{
fill (255);
}
rect (i*20, j*20, 20, 20 );
}
}
}
</syntaxhighlight lang=javaScript>

GMU:Actors, Traces, Collectives/SS17

2017-06-10T12:57:23Z

Veja6203:

Einführung ins Programmieren anhand von graphischen Beispielen

[[:Category:Werkmodul|Werkmodul]] 
''Lehrender:'' [[Max Neupert]] 
''Punkte:'' 6 [[ECTS]], 4 [[SWS]] 
''Termine:'' 2017-06 jeweils Fr-So 9.-11., 23.-25. von 10 bis 18:30 
''Ort:'' [[Marienstraße 7b]], Seminarraum 204 
''Erstes Treffen:'' 2017-06-09 
[https://www.uni-weimar.de/qisserver/rds?state=verpublish&status=init&vmfile=no&publishid=34713&moduleCall=webInfo&publishConfFile=webInfo&publishSubDir=veranstaltung Im VLV]

==Kursbeschreibung==
Anhand von aufeinander aufbauenden praktischen Übungen werden Grundkonzepte des Programmierens eingeführt.

Die Übungsergebnisse sind überwiegend grafischer Natur und führen von einfachen Bewegungsspuren über L-Systeme und einer klassischen Schwarmsimulation (Craig Reynold's Boids) zur Live-Verarbeitung von Kameradaten.

Die Veranstaltung wird Java (Processing) oder JavaScript (P5.js) verwenden.
Kurssprache ist deutsch.
Die Veranstaltung richtet sich primär an ProgrammieranfängerInnen

Inhalte sind u.a.:

* [[Punkt]]
* Variablen
* Kontrollstrukturen (If/Then/Else, Schleifen)
** [[/if Bedingung/]] und Abfrage ob gerade oder ungerade (Modulo)
** Übung: [[/Kariert/]]
** Übung: [[/Schachbrettmuster/]] [[/Schachbrettmuster_Array/]]
* [[/Funktionen/]]
* [[/Zufall/]] + Vektorgrafik-Export
* Grundlagen Objektorientierung
* Grundlagen Rekursion
* Grundlagen Lineare Algebra für Grafikprogrammierung
* Einfachste Algorithmen (Bubblesort)
* Tracking von Bewegungen mit Background-Substraction

==Teilnehmer==
===Bestätigt===
# Paul Hermann
# Benjamin Griesch
# Christian Doeller
# Corinna Thamm
# Maria Schween
# Denis Polec
# Grit Lieder
# Julius Baars

==Ablauf==
Wir folgen grob Daniel Shiffmans Buch [http://natureofcode.com/book/introduction/ The Nature of Code] und dem Buch [http://www.generative-gestaltung.de/code Generative Gestaltung]

==Links==
[[Processing/Links]]

[[Category:Werkmodul]]
[[Category:SS17]]
[[Category:Max Neupert]]
[[Category:Processing]]

GMU:Actors, Traces, Collectives/SS17

2017-05-01T19:49:16Z

Veja6203: /* Bestätigt */

Einführung ins Programmieren anhand von graphischen Beispielen

[[:Category:Werkmodul|Werkmodul]] 
''Lehrender:'' [[Max Neupert]] 
''Punkte:'' 6 [[ECTS]], 4 [[SWS]] 
''Termine:'' 2017-06 jeweils Fr-So 9.-11., 23.-25. von 10 bis 18:30 
''Ort:'' [[Marienstraße 7b]], Seminarraum 204 
''Erstes Treffen:'' 2017-06-09 
[https://www.uni-weimar.de/qisserver/rds?state=verpublish&status=init&vmfile=no&publishid=34713&moduleCall=webInfo&publishConfFile=webInfo&publishSubDir=veranstaltung Im VLV]

==Kursbeschreibung==
Anhand von aufeinader aufbauenden praktischen Übungen werden Grundkonzepte des Programmierens eingeführt.

Die Übungsergebnisse sind überwiegend grafischer Natur und führen von einfachen Bewegungsspuren über L-Systeme und einer klassischen Schwarmsimulation (Craig Reynold's Boids) zur Live-Verarbeitung von Kameradaten.

Die Veranstaltung wird entweder Java (Processing) oder Javascript (P5.js) verwenden.
Kurssprache ist deutsch.
Die Veranstaltung richtet sich primär an ProgrammieranfängerInnen

Inhalte sind u.a.:

* Variablen
* Kontrollstrukturen (If/Then/Else, Schleifen)
* Funktionen
* Grundlagen Objektorientierung
* Grundlagen Rekursion
* Grundlagen Lineare Algebra für Grafikprogrammierung
* Einfachste Algorithmen (Bubblesort)
* Tracking von Bewegungen mit Background-Substraction

==Teilnehmer==
===Bestätigt===
# Paul Hermann
# Benjamin Griesch
# Christian Doeller
#
#
#
#
#
#
#
#
#
#
#
#

===Anmeldungen===
* Tommy Neuwirth
* Thu-Trang Da
* Corinna Thamm
* Denis Polec
* Julius Baars
* Paul Hermann
* Grit Lieder

[[Category:Werkmodul]]
[[Category:SS17]]
[[Category:Max Neupert]]
[[Category:Processing]]

GMU:Actors, Traces, Collectives/SS17

2017-05-01T19:48:57Z

Veja6203: /* Anmeldungen */

Einführung ins Programmieren anhand von graphischen Beispielen

[[:Category:Werkmodul|Werkmodul]] 
''Lehrender:'' [[Max Neupert]] 
''Punkte:'' 6 [[ECTS]], 4 [[SWS]] 
''Termine:'' 2017-06 jeweils Fr-So 9.-11., 23.-25. von 10 bis 18:30 
''Ort:'' [[Marienstraße 7b]], Seminarraum 204 
''Erstes Treffen:'' 2017-06-09 
[https://www.uni-weimar.de/qisserver/rds?state=verpublish&status=init&vmfile=no&publishid=34713&moduleCall=webInfo&publishConfFile=webInfo&publishSubDir=veranstaltung Im VLV]

==Kursbeschreibung==
Anhand von aufeinader aufbauenden praktischen Übungen werden Grundkonzepte des Programmierens eingeführt.

Die Übungsergebnisse sind überwiegend grafischer Natur und führen von einfachen Bewegungsspuren über L-Systeme und einer klassischen Schwarmsimulation (Craig Reynold's Boids) zur Live-Verarbeitung von Kameradaten.

Die Veranstaltung wird entweder Java (Processing) oder Javascript (P5.js) verwenden.
Kurssprache ist deutsch.
Die Veranstaltung richtet sich primär an ProgrammieranfängerInnen

Inhalte sind u.a.:

* Variablen
* Kontrollstrukturen (If/Then/Else, Schleifen)
* Funktionen
* Grundlagen Objektorientierung
* Grundlagen Rekursion
* Grundlagen Lineare Algebra für Grafikprogrammierung
* Einfachste Algorithmen (Bubblesort)
* Tracking von Bewegungen mit Background-Substraction

==Teilnehmer==
===Bestätigt===
# Paul Hermann
# Benjamin Griesch
#
#
#
#
#
#
#
#
#
#
#
#
#

===Anmeldungen===
* Tommy Neuwirth
* Thu-Trang Da
* Corinna Thamm
* Denis Polec
* Julius Baars
* Paul Hermann
* Grit Lieder

[[Category:Werkmodul]]
[[Category:SS17]]
[[Category:Max Neupert]]
[[Category:Processing]]

GMU:StateMachine

2017-03-28T14:08:42Z

Veja6203: /* Structure */

How can we tell a machine how to react to different situations and stimuli ?

== Introduction ==

The state machine is an important concept in theoretical Computer Science. 
The following article explains how this concept can be used to program and organize different actions of simple robots.

Apparently there are:

* '''different reactions (outputs)'''
—> a robot can for instance move forward and backward, it can turn right or left and it can stand still.

* '''different stimuli (inputs)'''
—> a robot can for instance sense an obstacle (a wall), a human, …

* '''different situations (states)'''
—> a robot can for instance be looking for a power plug, it can be running away from an opponent or it can be in resting mode.

We can imagine that only one possible output (action) is not enough to react to a diversity of inputs (stimuli) - 
It might be a good idea to move towards the closest wall if we are looking for a power plug. At the same time this would be rather bad if we are being chased by a prosecutor. 
We can also imagine that a suitable program can easily get quite complex and messy. 
Furthermore there is a good chance that some important relations between situations and reactions get lost in the programming process.

So how can we make the whole thing a bit clearer?

==Structure==

A good way to deal with the possible complexity of such a program is to draw a corresponding diagram.

There is another useful concept in theoretical Computer Science that can help us doing that: 
It says that it is enough to conduct only one predefined action (output) in reaction to the current situation (state) and to then look at the input data in order to analyze and decide the next situation (and so forth..). 
This kind of action pattern ([https://en.wikipedia.org/wiki/Moore_machine Moore Machine]) can be used in order to disassemble, restructure and consequently simplify similar sequences of much higher complexity ([https://en.wikipedia.org/wiki/Mealy_machine Mealy Machine]).

And how can we use this strategy for our diagram?

We simply need to write down and structure the following things:

* every possible situation (state)
—> hungry, looking for food, eating, ..

* the particular conditions in which the situation (state) is changed
—> if sleeping and getting hungry -> looking for food, if looking for food and food has been found -> eating, ..

* a list that includes every situation (state) in connection to one specific action (output) that is carried out as soon as the corresponding state arrives
—> looking for food / move around, eating / stop, ..

 

==Example: developing the control mechanism of an autonomous vacuum cleaner==

All of the above will become much clearer if we look at an practical example of an autonomous vacuum cleaner robot. 
Step by step we will think of everything the robot has to do, put it in the right order and draw an appropriate diagram.

1) Turned on

The robot stands still and waits for further instructions. 
It is now in standby mode.

[[File:diagramStateMachine1.jpg]]

2) On / Off - button pushed

The robot starts to clean the room. 
It moves forward and activates the air pump.

[[File:diagramStateMachine2.jpg]]

3) Approaching a wall

The robot would bump into the next wall if it would only be able to move forward. 
It therefore needs a function that recognizes walls and makes the robot turn around.

[[File:diagramStateMachine3.jpg]]

4) Turning around

So far the robot turns randomly in any direction. 
We have to define a parameter that tells the robot if it turned enough in order to continue cleaning. 
This parameter can be a time delay, a certain amount of wheel revolutions or the value of a (distance, ..) sensor.

[[File:diagramStateMachine4.jpg]]

5) Turned off

The final missing part is the off-button.

[[File:diagramStateMachine5.jpg]]

 

==Writing the Program==

Translating our diagram into a functional program is a relatively simple task.

'''Step 1:''' saving the current state into a variable

First of all we need a variable that saves the current state. It represents our State Machines memory. 
The most suitable type for such a variable is in this case an "[https://en.wikipedia.org/wiki/Enumerated_type enum]". 
This enum assigns different names to values:

[[File:robot_enum.jpg]]

Note (enum + Processing): the definition of an enum has to be saved in a separate file (tab) with an .java extension. ([http://stackoverflow.com/questions/13370090/enums-in-processing-2-0 more info] )

'''Step 2:''' choosing alternative actions

Now we need something that executes different code depending on the current state. 
For this purpose we will have a closer look at the [https://www.arduino.cc/en/Reference/SwitchCase switch/case] statement. 
It operates similar to an if-condition whereas it can choose from more than two (if… else..) alternatives. 
It could for instance run over and over again in the main loop-function of our program:

[[File:robot_Loop1.jpg]]

'''Step 3:''' defining the practical behavior of each state

From now on it makes sense to use functions (aggregation of code) in order to keep a clean overview of our program. 
Each function includes the particular code that defines the behavior of a certain state. 
The internal structure of these functions is always the same:

1) conduct actions that fit to the particular state. (turn motors on / off, start a timer, ..) 
2) read input data (sensors, timer, ..) that provides information about the next possible state 
3) decide the next state

The third part can be done quite comfortably by giving back the new "state" - value in form of the functions "return" - value into the main loop.

This is an example of how the "standby"-state could look like:

[[File:robot_standbyfunc.jpg]]

'''Step 4:''' assembling everything

We can now call each particular function in the appropriate part of the switch/case statement. 
The functions return value is saved in the state variable for the next loop.

[[File:robot_Loop2.jpg]]

'''Step 5:''' extending the program

This kind of program structure can easily be extended by additional states without disturbing the overall clarity. 
Therefore it makes sense to begin with a simple structure and to then add functions that are more complex.

GMU:StateMachine

2017-03-28T14:08:15Z

Veja6203:

How can we tell a machine how to react to different situations and stimuli ?

== Introduction ==

The state machine is an important concept in theoretical Computer Science. 
The following article explains how this concept can be used to program and organize different actions of simple robots.

Apparently there are:

* '''different reactions (outputs)'''
—> a robot can for instance move forward and backward, it can turn right or left and it can stand still.

* '''different stimuli (inputs)'''
—> a robot can for instance sense an obstacle (a wall), a human, …

* '''different situations (states)'''
—> a robot can for instance be looking for a power plug, it can be running away from an opponent or it can be in resting mode.

We can imagine that only one possible output (action) is not enough to react to a diversity of inputs (stimuli) - 
It might be a good idea to move towards the closest wall if we are looking for a power plug. At the same time this would be rather bad if we are being chased by a prosecutor. 
We can also imagine that a suitable program can easily get quite complex and messy. 
Furthermore there is a good chance that some important relations between situations and reactions get lost in the programming process.

So how can we make the whole thing a bit clearer?

==Structure==

A good way to deal with the possible complexity of such a program is to draw a corresponding diagram.

There is another useful concept in theoretical Computer Science that can help us doing that: 
It says that it is enough to conduct only one predefined action (output) in reaction to the current situation (state) and to then look at the input data in order to analyze and decide the next situation (and so forth..). 
This kind of action pattern ([https://en.wikipedia.org/wiki/Moore_machine Moore Machine]) can be used in order to disassemble, restructure and consequently simplify similar sequences of much higher complexity ([https://en.wikipedia.org/wiki/Mealy_machine Mealy Machine]).

And how can we use this strategy for our diagram?

We simply need to write down and structure the following things:

* every possible situation (state)
—> hungry, looking for food, eating, ..

* the particular conditions in which the situation (state) is changed
—> if sleeping and getting hungry -> looking for food, if looking for food and food has been found -> eating, ..

- a list that includes every situation (state) in connection to one specific action (output) that is carried out as soon as the corresponding state arrives
—> looking for food / move around, eating / stop, ..

 

==Example: developing the control mechanism of an autonomous vacuum cleaner==

All of the above will become much clearer if we look at an practical example of an autonomous vacuum cleaner robot. 
Step by step we will think of everything the robot has to do, put it in the right order and draw an appropriate diagram.

1) Turned on

The robot stands still and waits for further instructions. 
It is now in standby mode.

[[File:diagramStateMachine1.jpg]]

2) On / Off - button pushed

The robot starts to clean the room. 
It moves forward and activates the air pump.

[[File:diagramStateMachine2.jpg]]

3) Approaching a wall

The robot would bump into the next wall if it would only be able to move forward. 
It therefore needs a function that recognizes walls and makes the robot turn around.

[[File:diagramStateMachine3.jpg]]

4) Turning around

So far the robot turns randomly in any direction. 
We have to define a parameter that tells the robot if it turned enough in order to continue cleaning. 
This parameter can be a time delay, a certain amount of wheel revolutions or the value of a (distance, ..) sensor.

[[File:diagramStateMachine4.jpg]]

5) Turned off

The final missing part is the off-button.

[[File:diagramStateMachine5.jpg]]

 

==Writing the Program==

Translating our diagram into a functional program is a relatively simple task.

'''Step 1:''' saving the current state into a variable

First of all we need a variable that saves the current state. It represents our State Machines memory. 
The most suitable type for such a variable is in this case an "[https://en.wikipedia.org/wiki/Enumerated_type enum]". 
This enum assigns different names to values:

[[File:robot_enum.jpg]]

Note (enum + Processing): the definition of an enum has to be saved in a separate file (tab) with an .java extension. ([http://stackoverflow.com/questions/13370090/enums-in-processing-2-0 more info] )

'''Step 2:''' choosing alternative actions

Now we need something that executes different code depending on the current state. 
For this purpose we will have a closer look at the [https://www.arduino.cc/en/Reference/SwitchCase switch/case] statement. 
It operates similar to an if-condition whereas it can choose from more than two (if… else..) alternatives. 
It could for instance run over and over again in the main loop-function of our program:

[[File:robot_Loop1.jpg]]

'''Step 3:''' defining the practical behavior of each state

From now on it makes sense to use functions (aggregation of code) in order to keep a clean overview of our program. 
Each function includes the particular code that defines the behavior of a certain state. 
The internal structure of these functions is always the same:

1) conduct actions that fit to the particular state. (turn motors on / off, start a timer, ..) 
2) read input data (sensors, timer, ..) that provides information about the next possible state 
3) decide the next state

The third part can be done quite comfortably by giving back the new "state" - value in form of the functions "return" - value into the main loop.

This is an example of how the "standby"-state could look like:

[[File:robot_standbyfunc.jpg]]

'''Step 4:''' assembling everything

We can now call each particular function in the appropriate part of the switch/case statement. 
The functions return value is saved in the state variable for the next loop.

[[File:robot_Loop2.jpg]]

'''Step 5:''' extending the program

This kind of program structure can easily be extended by additional states without disturbing the overall clarity. 
Therefore it makes sense to begin with a simple structure and to then add functions that are more complex.

GMU:StateMachine

2017-03-28T14:07:02Z

Veja6203: /* Writing the Program */

How can we tell a machine how to react to different situations and stimuli ?

== Introduction ==

The state machine is an important concept in theoretical Computer Science. 
The following article explains how this concept can be used to program and organize different actions of simple robots.

Apparently there are:

* '''different reactions (outputs)'''
—> a robot can for instance move forward and backward, it can turn right or left and it can stand still.

* '''different stimuli (inputs)'''
—> a robot can for instance sense an obstacle (a wall), a human, …

* '''different situations (states)'''
—> a robot can for instance be looking for a power plug, it can be running away from an opponent or it can be in resting mode.

We can imagine that only one possible output (action) is not enough to react to a diversity of inputs (stimuli) - 
It might be a good idea to move towards the closest wall if we are looking for a power plug. At the same time this would be rather bad if we are being chased by a prosecutor. 
We can also imagine that a suitable program can easily get quite complex and messy. 
Furthermore there is a good chance that some important relations between situations and reactions get lost in the programming process.

So how can we make the whole thing a bit clearer?

==Structure==

A good way to deal with the possible complexity of such a program is to draw a corresponding diagram.

There is another useful concept in theoretical Computer Science that can help us doing that: 
It says that it is enough to conduct only one predefined action (output) in reaction to the current situation (state) and to then look at the input data in order to analyze and decide the next situation (and so forth..). 
This kind of action pattern ([https://en.wikipedia.org/wiki/Moore_machine Moore Machine]) can be used in order to disassemble, restructure and consequently simplify similar sequences of much higher complexity ([https://en.wikipedia.org/wiki/Mealy_machine Mealy Machine]).

And how can we use this strategy for our diagram?

We simply need to write down and structure the following things:

* every possible situation (state)
—> hungry, looking for food, eating, ..

* the particular conditions in which the situation (state) is changed
—> if sleeping and getting hungry -> looking for food, if looking for food and food has been found -> eating, ..

- a list that includes every situation (state) in connection to one specific action (output) that is carried out as soon as the corresponding state arrives
—> looking for food / move around, eating / stop, ..

 

==Example: developing the control mechanism of an autonomous vacuum cleaner==

All of the above will become much clearer if we look at an practical example of an autonomous vacuum cleaner robot. 
Step by step we will think of everything the robot has to do, put it in the right order and draw an appropriate diagram.

1) Turned on

The robot stands still and waits for further instructions. 
It is now in standby mode.

[[File:diagramStateMachine1.jpg]]

2) On / Off - button pushed

The robot starts to clean the room. 
It moves forward and activates the air pump.

[[File:diagramStateMachine2.jpg]]

3) Approaching a wall

The robot would bump into the next wall if it would only be able to move forward. 
It therefore needs a function that recognizes walls and makes the robot turn around.

[[File:diagramStateMachine3.jpg]]

4) Turning around

So far the robot turns randomly in any direction. 
We have to define a parameter that tells the robot if it turned enough in order to continue cleaning. 
This parameter can be a time delay, a certain amount of wheel revolutions or the value of a (distance, ..) sensor.

[[File:diagramStateMachine4.jpg]]

5) Turned off

The final missing part is the off-button.

[[File:diagramStateMachine5.jpg]]

 

==Writing the Program==

Translating our diagram into a functional program is a relatively simple task.

'''Step 1:''' saving the current state into a variable

First of all we need a variable that saves the current state. It represents our State Machines memory. 
The most suitable type for such a variable is in this case an „[https://en.wikipedia.org/wiki/Enumerated_type enum]“. 
This enum assigns different names to values:

[[File:robot_enum.jpg]]

Note (enum + Processing): the definition of an enum has to be saved in a separate file (tab) with an .java extension. ([http://stackoverflow.com/questions/13370090/enums-in-processing-2-0 more info] )

'''Step 2:''' choosing alternative actions

Now we need something that executes different code depending on the current state. 
For this purpose we will have a closer look at the [https://www.arduino.cc/en/Reference/SwitchCase switch/case] statement. 
It operates similar to an if-condition whereas it can choose from more than two (if… else..) alternatives. 
It could for instance run over and over again in the main loop-function of our program:

[[File:robot_Loop1.jpg]]

'''Step 3:''' defining the practical behavior of each state

From now on it makes sense to use functions (aggregation of code) in order to keep a clean overview of our program. 
Each function includes the particular code that defines the behavior of a certain state. 
The internal structure of these functions is always the same:

1) conduct actions that fit to the particular state. (turn motors on / off, start a timer, ..) 
2) read input data (sensors, timer, ..) that provides information about the next possible state 
3) decide the next state

The third part can be done quite comfortably by giving back the new „state“ - value in form of the functions „return“ - value into the main loop.

This is an example of how the „standy“-state could look like:

[[File:robot_standbyfunc.jpg]]

'''Step 4:''' assembling everything

We can now call each particular function in the appropriate part of the switch/case statement. 
The functions return value is saved in the state variable for the next loop.

[[File:robot_Loop2.jpg]]

'''Step 5:''' extending the program

This kind of program structure can easily be extended by additional states without disturbing the overall clarity. 
Therefore it makes sense to begin with a simple structure and to then add functions that are more complex.

GMU:StateMachine

2017-03-28T14:05:37Z

Veja6203:

How can we tell a machine how to react to different situations and stimuli ?

== Introduction ==

The state machine is an important concept in theoretical Computer Science. 
The following article explains how this concept can be used to program and organize different actions of simple robots.

Apparently there are:

* '''different reactions (outputs)'''
—> a robot can for instance move forward and backward, it can turn right or left and it can stand still.

* '''different stimuli (inputs)'''
—> a robot can for instance sense an obstacle (a wall), a human, …

* '''different situations (states)'''
—> a robot can for instance be looking for a power plug, it can be running away from an opponent or it can be in resting mode.

We can imagine that only one possible output (action) is not enough to react to a diversity of inputs (stimuli) - 
It might be a good idea to move towards the closest wall if we are looking for a power plug. At the same time this would be rather bad if we are being chased by a prosecutor. 
We can also imagine that a suitable program can easily get quite complex and messy. 
Furthermore there is a good chance that some important relations between situations and reactions get lost in the programming process.

So how can we make the whole thing a bit clearer?

==Structure==

A good way to deal with the possible complexity of such a program is to draw a corresponding diagram.

There is another useful concept in theoretical Computer Science that can help us doing that: 
It says that it is enough to conduct only one predefined action (output) in reaction to the current situation (state) and to then look at the input data in order to analyze and decide the next situation (and so forth..). 
This kind of action pattern ([https://en.wikipedia.org/wiki/Moore_machine Moore Machine]) can be used in order to disassemble, restructure and consequently simplify similar sequences of much higher complexity ([https://en.wikipedia.org/wiki/Mealy_machine Mealy Machine]).

And how can we use this strategy for our diagram?

We simply need to write down and structure the following things:

* every possible situation (state)
—> hungry, looking for food, eating, ..

* the particular conditions in which the situation (state) is changed
—> if sleeping and getting hungry -> looking for food, if looking for food and food has been found -> eating, ..

- a list that includes every situation (state) in connection to one specific action (output) that is carried out as soon as the corresponding state arrives
—> looking for food / move around, eating / stop, ..

 

==Example: developing the control mechanism of an autonomous vacuum cleaner==

All of the above will become much clearer if we look at an practical example of an autonomous vacuum cleaner robot. 
Step by step we will think of everything the robot has to do, put it in the right order and draw an appropriate diagram.

1) Turned on

The robot stands still and waits for further instructions. 
It is now in standby mode.

[[File:diagramStateMachine1.jpg]]

2) On / Off - button pushed

The robot starts to clean the room. 
It moves forward and activates the air pump.

[[File:diagramStateMachine2.jpg]]

3) Approaching a wall

The robot would bump into the next wall if it would only be able to move forward. 
It therefore needs a function that recognizes walls and makes the robot turn around.

[[File:diagramStateMachine3.jpg]]

4) Turning around

So far the robot turns randomly in any direction. 
We have to define a parameter that tells the robot if it turned enough in order to continue cleaning. 
This parameter can be a time delay, a certain amount of wheel revolutions or the value of a (distance, ..) sensor.

[[File:diagramStateMachine4.jpg]]

5) Turned off

The final missing part is the off-button.

[[File:diagramStateMachine5.jpg]]

 

==Writing the Program==

Translating our diagram into a functional program is a relatively simple task.

'''Step 1:''' saving the current state into a variable

First of all we need a variable that saves the current state. It represents our State Machines memory. 
The most suitable type for such a variable is in this case an „[https://en.wikipedia.org/wiki/Enumerated_type enum]“. 
This enum assigns different names to values:

[[File:robot_enum.jpg]]

Note (enum + Processing): the definition of an enum has to be saved in a separate file (tab) with an .java extension. ([http://stackoverflow.com/questions/13370090/enums-in-processing-2-0 more info] )

'''Step 2:''' choosing alternative actions

Now we need something that executes different code depending on the current state. 
For this purpose we will have a closer look at the [https://www.arduino.cc/en/Reference/SwitchCase switch/case] statement. 
It operates similar to an if-condition whereas it can choose from more than two (if… else..) alternatives. 
It could for instance run over and over again in the main loop-function of our program:

[[File:robot_Loop1.jpg]]

'''Step 3:''' defining the practical behavior of each state

From now on it makes sense to use functions (aggregation of code) in order to keep a clean overview of our program. 
Each function includes the particular code that defines the behavior of a certain state. 
The internal structure of these functions is always the same:

1) conduct actions that fit to the particular state. (turn motors on / off, start a timer, ..)
2) read input data (sensors, timer, ..) that provides information about the next possible state
3) decide the next state

The third part can be done quite comfortably by giving back the new „state“ - value in form of the functions „return“ - value into the main loop.

This is an example of how the „standy“-state could look like:

[[File:robot_standbyfunc.jpg]]

'''Step 4:''' assembling everything

We can now call each particular function in the appropriate part of the switch/case statement. 
The functions return value is saved in the state variable for the next loop.

[[File:robot_Loop2.jpg]]

'''Step 5:''' extending the program

This kind of program structure can easily be extended by additional states without disturbing the overall clarity. 
Therefore it makes sense to begin with a simple structure and to then add functions that are more complex.

GMU:Functions and Classes (Arduino)

2017-03-28T14:02:08Z

Veja6203:

GMU:Functions and Classes (Arduino)

2017-03-28T13:53:38Z

Veja6203: /* More Information */

GMU:Functions and Classes (Arduino)

2017-03-28T13:53:01Z

Veja6203:

GMU:Functions and Classes (Arduino)

2017-03-28T13:50:22Z

Veja6203: /* More Information */

GMU:Functions and Classes (Arduino)

2017-03-28T13:50:06Z

Veja6203: /* Organizing classes in separate files */

GMU:Functions and Classes (Arduino)

2017-03-28T13:49:46Z

Veja6203: /* Organizing classes in separate files */

GMU:Functions and Classes (Arduino)

2017-03-28T13:47:48Z

Veja6203: /* Organizing classes in separate files */

GMU:Functions and Classes (Arduino)

2017-03-28T13:46:38Z

Veja6203: /* Organizing classes in separate files */

GMU:Functions and Classes (Arduino)

2017-03-28T13:45:40Z

Veja6203: /* More details on the concept */

GMU:Functions and Classes (Arduino)

2017-03-28T13:45:17Z

Veja6203: /* Organizing classes in separate files */

GMU:Functions and Classes (Arduino)

2017-03-28T13:45:05Z

Veja6203: /* Organizing classes in separate files */

GMU:Functions and Classes (Arduino)

2017-03-28T13:44:38Z

Veja6203: /* Organizing classes in separate files */

File:NewTabARDU.jpg

2017-03-28T13:44:35Z

Veja6203: File uploaded with MsUpload

File uploaded with MsUpload

GMU:Functions and Classes (Arduino)

2017-03-28T11:48:12Z

Veja6203: /* A complete example */

File:OOPARD8.jpg

2017-03-28T11:48:09Z

Veja6203: File uploaded with MsUpload

File uploaded with MsUpload

GMU:Functions and Classes (Arduino)

2017-03-28T11:42:11Z

Veja6203: /* A complete example */

==Motivation==

Soon after starting to write the program for your robot you will encounter some typical problems:

* clarity: the bigger the program gets the harder it is to keep the general overview
* decoupling: you only want to change a certain part of the program without influencing all the rest
* recyclability: there are several similar parts in your robot for which you would like to reuse particular sections of your code

These problems reach back to the beginning of programming and their solution is an art and a science at the same time.
It generally helps a lot to separate your program into single subunits that are relatively independent from each other.

==Example: Controlling Motors==

The [http://arduino.cc/de/Reference/FunctionDeclaration function] is an enormous useful tool that can help you structuring your code. Functions allow you to sum up several operations under the same command. This command can be called again and again without knowing about or duplicating the included code.

Here is an example for a function for setting the speed of a motor that is connected to an H-bridge:

[[File:OOPARD1.jpg]]

Now (and for every prospective motor movement) we only need to write one single line in order to for instance setting the left wheels speed:

[[File:OOPARD2.jpg]]

This already saves us a lot of typing –
But one thing still seems quite laborious: we have to know the exact pin numbers every time we want to change the speed.

Imagine a program in which similar function calls are distributed all over.
In case of a hardware update you would have to find every single function call and change the parameters manually.
This effort could surely be spent for more useful things..

It would be ideal to find a way of calling a certain function that only offers the most useful parameters (like setting the speed) and which handles technical details (switching pins on and off) internally.

 

==Possible solution: Data and code in one package – „Classes“ and „Objects“==

C++ (and also Arduino) provides a specific feature that can solve our problem: Classes and Objects

A Class predefines common qualities of a group of Objects.
It for instance determines that every motor has the possibility to exert a certain amount of throttle.
The corresponding program could look like this:

[[File:OOPARD3.jpg]]

Now the computer knows that there is a class called „Motor“.
This class (class) provides a function called „setThrottle“ that is called as an argument by using a number (int) and that does not return anything (void).

===Classes are Data-types===

We can use our „Motor“ - class the same way we are using other data - types (int, long, float).
The following lines use that quality in order to implement two motors:
 
 

[[File:OOPARD4.jpg]]

 
 

===Calling inner functions of a class (Methods)===

Imagine we want to drive the left motor with full throttle whereas the right motor should stop completely.
This can be expressed as follows:

[[File:OOPARD5.jpg]]

A positive side effect: your program gains readability by picking distinct names for your Objects and Methods.

 

===Classes can contain other variables that can only be accessed „internally“===

How do the Objects „leftMotor“ and „rightMotor“ know which pins they want to switch on and off?

Until now our „Motor“ class is quite abstract since it does not contain this information.
A class that should conduct practical actions needs further variables (concrete pin numbers) and lines of code that describe what to do exactly.
We can simply include both things in the class definition:

[[File:OOPARD6.jpg]]

How do we include the pin numbers into the Object if they are not visible from the outside?
We simply write a „setup“ Function for the class:

[[File:OOPARD7.jpg]]

 
 

==A complete example ==

In order to construct a complete example we only have to include the „speed“-Function (see description above):

// Defining a class for motor control
class MotoMamaMotor {

private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; //Every MotoMamaMotor type Object has its own forwardPin
int reversePin;
int throttlePin;

public: // the following qualities and methods are visible from the outside.
// This setup-Function has to be called before using the motor control
void setup(int newForwardPin, int newReversePin, int newThrottlePin) {
// we remember the pins for future use
forwardPin = newForwardPin;
reversePin = newReversePin;
throttlePin = newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin, LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin, OUTPUT);
pinMode(reversePin, OUTPUT);
pinMode(throttlePin, OUTPUT);
}

// this Function allows to control the motor speed
void setThrottle (int newThrottle) {
if (newThrottle > 0) { // should it spin forwards or backwards?
// spin forwards
digitalWrite(reversePin, LOW);
digitalWrite(forwardPin, HIGH);
} else {
// spin backwards
digitalWrite(forwardPin, LOW);
digitalWrite(reversePin, HIGH);
}
// adjust the speed:
analogWrite(throttlePin, newThrottle);
}
};

// create two separate MotoMamaMotor type Objects (leftMotor, rightMotor). They can be used as normal variables.
MotoMamaMotor leftMotor;
MotoMamaMotor rightMotor;

void setup() { // this is our „main“ setup Function
leftMotor.setup(3, 4, 5); // assign the pin numbers for each motor in the setup Function: setup(int newForwardPin, int newReversePin, int newThrottlePin)
rightMotor.setup(6, 7, 8);
};

void loop() { // this is our „main“ loop Function where concrete actions are executed. For example:
// Start backwards, slow down and accelerate forwards
for (int i = -255, i <= 255; i++) {
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
// Start forwards, slow down and accelerate backwards
for (int i = 255, i >= -255; i--) {
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
};

==Organizing classes in separate files==

We can improve our program structure by putting classes in separate files.

1)
Click on the arrow in the right corner in order to add a new file.
Select „new Tab“.

----BILD----

2)
Enter a filename at the bottom of the window.
It must end with .h !
In our case I suggest the name motorControl.h.

3)
Enter the first line:

''
#include „Arduino.h“
''

This line „links“ the file to the Arduino-specific features.
Now we can include the code of our class.

4)
Go back to your main file.
Now you have to „link“ the new file to your main file in order to use the features of our class.
Include the following line in the top of your main file

''
#include „MotorControl.h“
''

and write the rest of your program as usual.

==More details on the concept==

Classes can build up on each other (inheritance)

In the beginning we promised that it is possible to replace different motor drivers without changing the rest of the program.
Classes can indeed include other Objects in the form of „member variables“.

C++ allows class declarations and the code for included Functions to be be placed in different files.
If you want to know more about that you can read this article about creating libraries in Arduino: [http://arduino.cc/en/Hacking/LibraryTutorial http://arduino.cc/en/Hacking/LibraryTutorial ]

GMU:Functions and Classes (Arduino)

2017-03-28T11:38:49Z

Veja6203: /* Classes can contain other variables that can only be accessed „internally“ */

==Motivation==

Soon after starting to write the program for your robot you will encounter some typical problems:

* clarity: the bigger the program gets the harder it is to keep the general overview
* decoupling: you only want to change a certain part of the program without influencing all the rest
* recyclability: there are several similar parts in your robot for which you would like to reuse particular sections of your code

These problems reach back to the beginning of programming and their solution is an art and a science at the same time.
It generally helps a lot to separate your program into single subunits that are relatively independent from each other.

==Example: Controlling Motors==

The [http://arduino.cc/de/Reference/FunctionDeclaration function] is an enormous useful tool that can help you structuring your code. Functions allow you to sum up several operations under the same command. This command can be called again and again without knowing about or duplicating the included code.

Here is an example for a function for setting the speed of a motor that is connected to an H-bridge:

[[File:OOPARD1.jpg]]

Now (and for every prospective motor movement) we only need to write one single line in order to for instance setting the left wheels speed:

[[File:OOPARD2.jpg]]

This already saves us a lot of typing –
But one thing still seems quite laborious: we have to know the exact pin numbers every time we want to change the speed.

Imagine a program in which similar function calls are distributed all over.
In case of a hardware update you would have to find every single function call and change the parameters manually.
This effort could surely be spent for more useful things..

It would be ideal to find a way of calling a certain function that only offers the most useful parameters (like setting the speed) and which handles technical details (switching pins on and off) internally.

 

==Possible solution: Data and code in one package – „Classes“ and „Objects“==

C++ (and also Arduino) provides a specific feature that can solve our problem: Classes and Objects

A Class predefines common qualities of a group of Objects.
It for instance determines that every motor has the possibility to exert a certain amount of throttle.
The corresponding program could look like this:

[[File:OOPARD3.jpg]]

Now the computer knows that there is a class called „Motor“.
This class (class) provides a function called „setThrottle“ that is called as an argument by using a number (int) and that does not return anything (void).

===Classes are Data-types===

We can use our „Motor“ - class the same way we are using other data - types (int, long, float).
The following lines use that quality in order to implement two motors:
 
 

[[File:OOPARD4.jpg]]

 
 

===Calling inner functions of a class (Methods)===

Imagine we want to drive the left motor with full throttle whereas the right motor should stop completely.
This can be expressed as follows:

[[File:OOPARD5.jpg]]

A positive side effect: your program gains readability by picking distinct names for your Objects and Methods.

 

===Classes can contain other variables that can only be accessed „internally“===

How do the Objects „leftMotor“ and „rightMotor“ know which pins they want to switch on and off?

Until now our „Motor“ class is quite abstract since it does not contain this information.
A class that should conduct practical actions needs further variables (concrete pin numbers) and lines of code that describe what to do exactly.
We can simply include both things in the class definition:

[[File:OOPARD6.jpg]]

How do we include the pin numbers into the Object if they are not visible from the outside?
We simply write a „setup“ Function for the class:

[[File:OOPARD7.jpg]]

 
 

==A complete example ==

In order to construct a complete example we only have to include the „speed“-Function (see description above):

''
// Defining a class for motor control

class MotoMamaMotor {

private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; //Every MotoMamaMotor type Object has its own forwardPin
int reversePin;
int throttlePin;

public: // the following qualities and methods are visible from the outside.
// This setup-Function has to be called before using the motor control
void setup(int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}

// this Function allows to control the motor speed
void setThrottle (int newThrottle){
if (newThrottle>0){ // should it spin forwards or backwards?
// spin forwards
digitalWrite(reversePin,LOW);
digitalWrite(forwardPin,HIGH);
}else{
// spin backwards
digitalWrite(forwardPin,LOW);
digitalWrite(reversePin,HIGH);
}
// adjust the speed:
analogWrite(throttlePin, newThrottle);
}
};

// create two separate MotoMamaMotor type Objects (leftMotor, rightMotor). They can be used as normal variables.
MotoMamaMotor leftMotor;
MotoMamaMotor rightMotor;

void setup(){ // this is our „main“ setup Function
leftMotor.setup(3,4,5); // assign the pin numbers for each motor in the setup Function: setup(int newForwardPin, int newReversePin, int newThrottlePin)
rightMotor.setup(6,7,8);
};

void loop(){ // this is our „main“ loop Function where concrete actions are executed. For example:
// Start backwards, slow down and accelerate forwards
for (int i =-255, i<=255;i++){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
// Start forwards, slow down and accelerate backwards
for (int i =255, i>=-255;i--){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
};
''

==Organizing classes in separate files==

We can improve our program structure by putting classes in separate files.

1)
Click on the arrow in the right corner in order to add a new file.
Select „new Tab“.

----BILD----

2)
Enter a filename at the bottom of the window.
It must end with .h !
In our case I suggest the name motorControl.h.

3)
Enter the first line:

''
#include „Arduino.h“
''

This line „links“ the file to the Arduino-specific features.
Now we can include the code of our class.

4)
Go back to your main file.
Now you have to „link“ the new file to your main file in order to use the features of our class.
Include the following line in the top of your main file

''
#include „MotorControl.h“
''

and write the rest of your program as usual.

==More details on the concept==

Classes can build up on each other (inheritance)

In the beginning we promised that it is possible to replace different motor drivers without changing the rest of the program.
Classes can indeed include other Objects in the form of „member variables“.

C++ allows class declarations and the code for included Functions to be be placed in different files.
If you want to know more about that you can read this article about creating libraries in Arduino: [http://arduino.cc/en/Hacking/LibraryTutorial http://arduino.cc/en/Hacking/LibraryTutorial ]

GMU:Functions and Classes (Arduino)

2017-03-28T11:38:26Z

Veja6203: /* Classes can contain other variables that can only be accessed „internally“ */

==Motivation==

Soon after starting to write the program for your robot you will encounter some typical problems:

* clarity: the bigger the program gets the harder it is to keep the general overview
* decoupling: you only want to change a certain part of the program without influencing all the rest
* recyclability: there are several similar parts in your robot for which you would like to reuse particular sections of your code

These problems reach back to the beginning of programming and their solution is an art and a science at the same time.
It generally helps a lot to separate your program into single subunits that are relatively independent from each other.

==Example: Controlling Motors==

The [http://arduino.cc/de/Reference/FunctionDeclaration function] is an enormous useful tool that can help you structuring your code. Functions allow you to sum up several operations under the same command. This command can be called again and again without knowing about or duplicating the included code.

Here is an example for a function for setting the speed of a motor that is connected to an H-bridge:

[[File:OOPARD1.jpg]]

Now (and for every prospective motor movement) we only need to write one single line in order to for instance setting the left wheels speed:

[[File:OOPARD2.jpg]]

This already saves us a lot of typing –
But one thing still seems quite laborious: we have to know the exact pin numbers every time we want to change the speed.

Imagine a program in which similar function calls are distributed all over.
In case of a hardware update you would have to find every single function call and change the parameters manually.
This effort could surely be spent for more useful things..

It would be ideal to find a way of calling a certain function that only offers the most useful parameters (like setting the speed) and which handles technical details (switching pins on and off) internally.

 

==Possible solution: Data and code in one package – „Classes“ and „Objects“==

C++ (and also Arduino) provides a specific feature that can solve our problem: Classes and Objects

A Class predefines common qualities of a group of Objects.
It for instance determines that every motor has the possibility to exert a certain amount of throttle.
The corresponding program could look like this:

[[File:OOPARD3.jpg]]

Now the computer knows that there is a class called „Motor“.
This class (class) provides a function called „setThrottle“ that is called as an argument by using a number (int) and that does not return anything (void).

===Classes are Data-types===

We can use our „Motor“ - class the same way we are using other data - types (int, long, float).
The following lines use that quality in order to implement two motors:
 
 

[[File:OOPARD4.jpg]]

 
 

===Calling inner functions of a class (Methods)===

Imagine we want to drive the left motor with full throttle whereas the right motor should stop completely.
This can be expressed as follows:

[[File:OOPARD5.jpg]]

A positive side effect: your program gains readability by picking distinct names for your Objects and Methods.

 

===Classes can contain other variables that can only be accessed „internally“===

How do the Objects „leftMotor“ and „rightMotor“ know which pins they want to switch on and off?

Until now our „Motor“ class is quite abstract since it does not contain this information.
A class that should conduct practical actions needs further variables (concrete pin numbers) and lines of code that describe what to do exactly.
We can simply include both things in the class definition:

[[File:OOPARD6.jpg]]

How do we include the pin numbers into the Object if they are not visible from the outside?
We simply write a „setup“ Function for the class:

[[File:OOPARD7.jpg]]

==A complete example ==

In order to construct a complete example we only have to include the „speed“-Function (see description above):

''
// Defining a class for motor control

class MotoMamaMotor {

private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; //Every MotoMamaMotor type Object has its own forwardPin
int reversePin;
int throttlePin;

public: // the following qualities and methods are visible from the outside.
// This setup-Function has to be called before using the motor control
void setup(int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}

// this Function allows to control the motor speed
void setThrottle (int newThrottle){
if (newThrottle>0){ // should it spin forwards or backwards?
// spin forwards
digitalWrite(reversePin,LOW);
digitalWrite(forwardPin,HIGH);
}else{
// spin backwards
digitalWrite(forwardPin,LOW);
digitalWrite(reversePin,HIGH);
}
// adjust the speed:
analogWrite(throttlePin, newThrottle);
}
};

// create two separate MotoMamaMotor type Objects (leftMotor, rightMotor). They can be used as normal variables.
MotoMamaMotor leftMotor;
MotoMamaMotor rightMotor;

void setup(){ // this is our „main“ setup Function
leftMotor.setup(3,4,5); // assign the pin numbers for each motor in the setup Function: setup(int newForwardPin, int newReversePin, int newThrottlePin)
rightMotor.setup(6,7,8);
};

void loop(){ // this is our „main“ loop Function where concrete actions are executed. For example:
// Start backwards, slow down and accelerate forwards
for (int i =-255, i<=255;i++){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
// Start forwards, slow down and accelerate backwards
for (int i =255, i>=-255;i--){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
};
''

==Organizing classes in separate files==

We can improve our program structure by putting classes in separate files.

1)
Click on the arrow in the right corner in order to add a new file.
Select „new Tab“.

----BILD----

2)
Enter a filename at the bottom of the window.
It must end with .h !
In our case I suggest the name motorControl.h.

3)
Enter the first line:

''
#include „Arduino.h“
''

This line „links“ the file to the Arduino-specific features.
Now we can include the code of our class.

4)
Go back to your main file.
Now you have to „link“ the new file to your main file in order to use the features of our class.
Include the following line in the top of your main file

''
#include „MotorControl.h“
''

and write the rest of your program as usual.

==More details on the concept==

Classes can build up on each other (inheritance)

In the beginning we promised that it is possible to replace different motor drivers without changing the rest of the program.
Classes can indeed include other Objects in the form of „member variables“.

C++ allows class declarations and the code for included Functions to be be placed in different files.
If you want to know more about that you can read this article about creating libraries in Arduino: [http://arduino.cc/en/Hacking/LibraryTutorial http://arduino.cc/en/Hacking/LibraryTutorial ]

File:OOPARD6.jpg

2017-03-28T11:38:23Z

Veja6203: Veja6203 uploaded a new version of File:OOPARD6.jpg

File uploaded with MsUpload

GMU:Functions and Classes (Arduino)

2017-03-28T11:37:10Z

Veja6203: /* Classes can contain other variables that can only be accessed „internally“ */

==Motivation==

Soon after starting to write the program for your robot you will encounter some typical problems:

* clarity: the bigger the program gets the harder it is to keep the general overview
* decoupling: you only want to change a certain part of the program without influencing all the rest
* recyclability: there are several similar parts in your robot for which you would like to reuse particular sections of your code

These problems reach back to the beginning of programming and their solution is an art and a science at the same time.
It generally helps a lot to separate your program into single subunits that are relatively independent from each other.

==Example: Controlling Motors==

The [http://arduino.cc/de/Reference/FunctionDeclaration function] is an enormous useful tool that can help you structuring your code. Functions allow you to sum up several operations under the same command. This command can be called again and again without knowing about or duplicating the included code.

Here is an example for a function for setting the speed of a motor that is connected to an H-bridge:

[[File:OOPARD1.jpg]]

Now (and for every prospective motor movement) we only need to write one single line in order to for instance setting the left wheels speed:

[[File:OOPARD2.jpg]]

This already saves us a lot of typing –
But one thing still seems quite laborious: we have to know the exact pin numbers every time we want to change the speed.

Imagine a program in which similar function calls are distributed all over.
In case of a hardware update you would have to find every single function call and change the parameters manually.
This effort could surely be spent for more useful things..

It would be ideal to find a way of calling a certain function that only offers the most useful parameters (like setting the speed) and which handles technical details (switching pins on and off) internally.

 

==Possible solution: Data and code in one package – „Classes“ and „Objects“==

C++ (and also Arduino) provides a specific feature that can solve our problem: Classes and Objects

A Class predefines common qualities of a group of Objects.
It for instance determines that every motor has the possibility to exert a certain amount of throttle.
The corresponding program could look like this:

[[File:OOPARD3.jpg]]

Now the computer knows that there is a class called „Motor“.
This class (class) provides a function called „setThrottle“ that is called as an argument by using a number (int) and that does not return anything (void).

===Classes are Data-types===

We can use our „Motor“ - class the same way we are using other data - types (int, long, float).
The following lines use that quality in order to implement two motors:
 
 

[[File:OOPARD4.jpg]]

 
 

===Calling inner functions of a class (Methods)===

Imagine we want to drive the left motor with full throttle whereas the right motor should stop completely.
This can be expressed as follows:

[[File:OOPARD5.jpg]]

A positive side effect: your program gains readability by picking distinct names for your Objects and Methods.

 

===Classes can contain other variables that can only be accessed „internally“===

How do the Objects „leftMotor“ and „rightMotor“ know which pins they want to switch on and off?

Until now our „Motor“ class is quite abstract since it does not contain this information.
A class that should conduct practical actions needs further variables (concrete pin numbers) and lines of code that describe what to do exactly.
We can simply include both things in the class definition:

[[OOPARD6.jpg]]

How do we include the pin numbers into the Object if they are not visible from the outside?
We simply write a „setup“ Function for the class:

[[File:OOPARD7.jpg]]

==A complete example ==

In order to construct a complete example we only have to include the „speed“-Function (see description above):

''
// Defining a class for motor control

class MotoMamaMotor {

private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; //Every MotoMamaMotor type Object has its own forwardPin
int reversePin;
int throttlePin;

public: // the following qualities and methods are visible from the outside.
// This setup-Function has to be called before using the motor control
void setup(int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}

// this Function allows to control the motor speed
void setThrottle (int newThrottle){
if (newThrottle>0){ // should it spin forwards or backwards?
// spin forwards
digitalWrite(reversePin,LOW);
digitalWrite(forwardPin,HIGH);
}else{
// spin backwards
digitalWrite(forwardPin,LOW);
digitalWrite(reversePin,HIGH);
}
// adjust the speed:
analogWrite(throttlePin, newThrottle);
}
};

// create two separate MotoMamaMotor type Objects (leftMotor, rightMotor). They can be used as normal variables.
MotoMamaMotor leftMotor;
MotoMamaMotor rightMotor;

void setup(){ // this is our „main“ setup Function
leftMotor.setup(3,4,5); // assign the pin numbers for each motor in the setup Function: setup(int newForwardPin, int newReversePin, int newThrottlePin)
rightMotor.setup(6,7,8);
};

void loop(){ // this is our „main“ loop Function where concrete actions are executed. For example:
// Start backwards, slow down and accelerate forwards
for (int i =-255, i<=255;i++){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
// Start forwards, slow down and accelerate backwards
for (int i =255, i>=-255;i--){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
};
''

==Organizing classes in separate files==

We can improve our program structure by putting classes in separate files.

1)
Click on the arrow in the right corner in order to add a new file.
Select „new Tab“.

----BILD----

2)
Enter a filename at the bottom of the window.
It must end with .h !
In our case I suggest the name motorControl.h.

3)
Enter the first line:

''
#include „Arduino.h“
''

This line „links“ the file to the Arduino-specific features.
Now we can include the code of our class.

4)
Go back to your main file.
Now you have to „link“ the new file to your main file in order to use the features of our class.
Include the following line in the top of your main file

''
#include „MotorControl.h“
''

and write the rest of your program as usual.

==More details on the concept==

Classes can build up on each other (inheritance)

In the beginning we promised that it is possible to replace different motor drivers without changing the rest of the program.
Classes can indeed include other Objects in the form of „member variables“.

C++ allows class declarations and the code for included Functions to be be placed in different files.
If you want to know more about that you can read this article about creating libraries in Arduino: [http://arduino.cc/en/Hacking/LibraryTutorial http://arduino.cc/en/Hacking/LibraryTutorial ]

File:OOPARD7.jpg

2017-03-28T11:37:06Z

Veja6203: File uploaded with MsUpload

File uploaded with MsUpload

File:OOPARD6.jpg

2017-03-28T11:37:03Z

Veja6203: File uploaded with MsUpload

File uploaded with MsUpload

GMU:Functions and Classes (Arduino)

2017-03-28T11:31:46Z

Veja6203: /* Calling inner functions of a class (Methods) */

==Motivation==

Soon after starting to write the program for your robot you will encounter some typical problems:

* clarity: the bigger the program gets the harder it is to keep the general overview
* decoupling: you only want to change a certain part of the program without influencing all the rest
* recyclability: there are several similar parts in your robot for which you would like to reuse particular sections of your code

These problems reach back to the beginning of programming and their solution is an art and a science at the same time.
It generally helps a lot to separate your program into single subunits that are relatively independent from each other.

==Example: Controlling Motors==

The [http://arduino.cc/de/Reference/FunctionDeclaration function] is an enormous useful tool that can help you structuring your code. Functions allow you to sum up several operations under the same command. This command can be called again and again without knowing about or duplicating the included code.

Here is an example for a function for setting the speed of a motor that is connected to an H-bridge:

[[File:OOPARD1.jpg]]

Now (and for every prospective motor movement) we only need to write one single line in order to for instance setting the left wheels speed:

[[File:OOPARD2.jpg]]

This already saves us a lot of typing –
But one thing still seems quite laborious: we have to know the exact pin numbers every time we want to change the speed.

Imagine a program in which similar function calls are distributed all over.
In case of a hardware update you would have to find every single function call and change the parameters manually.
This effort could surely be spent for more useful things..

It would be ideal to find a way of calling a certain function that only offers the most useful parameters (like setting the speed) and which handles technical details (switching pins on and off) internally.

 

==Possible solution: Data and code in one package – „Classes“ and „Objects“==

C++ (and also Arduino) provides a specific feature that can solve our problem: Classes and Objects

A Class predefines common qualities of a group of Objects.
It for instance determines that every motor has the possibility to exert a certain amount of throttle.
The corresponding program could look like this:

[[File:OOPARD3.jpg]]

Now the computer knows that there is a class called „Motor“.
This class (class) provides a function called „setThrottle“ that is called as an argument by using a number (int) and that does not return anything (void).

===Classes are Data-types===

We can use our „Motor“ - class the same way we are using other data - types (int, long, float).
The following lines use that quality in order to implement two motors:
 
 

[[File:OOPARD4.jpg]]

 
 

===Calling inner functions of a class (Methods)===

Imagine we want to drive the left motor with full throttle whereas the right motor should stop completely.
This can be expressed as follows:

[[File:OOPARD5.jpg]]

A positive side effect: your program gains readability by picking distinct names for your Objects and Methods.

 

===Classes can contain other variables that can only be accessed „internally“===

How do the Objects „leftMotor“ and „rightMotor“ know which pins they want to switch on and off?

Until now our „Motor“ class is quite abstract since it does not contain this information.
A class that should conduct practical actions needs further variables (concrete pin numbers) and lines of code that describe what to do exactly.
We can simply include both things in the class definition:

''
class MotoMamaMotor {
...
private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; // c
int reversePin;
int throttlePin;
...
};
''

How do we include the pin numbers into the Object if they are not visible from the outside?
We simply write a „setup“ Function for the class:

''
class MotoMamaMotor {
private:
...
public: // we want the setup-function to be accessible from the outside.
void setup (int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}
...
};
''

==A complete example ==

In order to construct a complete example we only have to include the „speed“-Function (see description above):

''
// Defining a class for motor control

class MotoMamaMotor {

private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; //Every MotoMamaMotor type Object has its own forwardPin
int reversePin;
int throttlePin;

public: // the following qualities and methods are visible from the outside.
// This setup-Function has to be called before using the motor control
void setup(int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}

// this Function allows to control the motor speed
void setThrottle (int newThrottle){
if (newThrottle>0){ // should it spin forwards or backwards?
// spin forwards
digitalWrite(reversePin,LOW);
digitalWrite(forwardPin,HIGH);
}else{
// spin backwards
digitalWrite(forwardPin,LOW);
digitalWrite(reversePin,HIGH);
}
// adjust the speed:
analogWrite(throttlePin, newThrottle);
}
};

// create two separate MotoMamaMotor type Objects (leftMotor, rightMotor). They can be used as normal variables.
MotoMamaMotor leftMotor;
MotoMamaMotor rightMotor;

void setup(){ // this is our „main“ setup Function
leftMotor.setup(3,4,5); // assign the pin numbers for each motor in the setup Function: setup(int newForwardPin, int newReversePin, int newThrottlePin)
rightMotor.setup(6,7,8);
};

void loop(){ // this is our „main“ loop Function where concrete actions are executed. For example:
// Start backwards, slow down and accelerate forwards
for (int i =-255, i<=255;i++){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
// Start forwards, slow down and accelerate backwards
for (int i =255, i>=-255;i--){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
};
''

==Organizing classes in separate files==

We can improve our program structure by putting classes in separate files.

1)
Click on the arrow in the right corner in order to add a new file.
Select „new Tab“.

----BILD----

2)
Enter a filename at the bottom of the window.
It must end with .h !
In our case I suggest the name motorControl.h.

3)
Enter the first line:

''
#include „Arduino.h“
''

This line „links“ the file to the Arduino-specific features.
Now we can include the code of our class.

4)
Go back to your main file.
Now you have to „link“ the new file to your main file in order to use the features of our class.
Include the following line in the top of your main file

''
#include „MotorControl.h“
''

and write the rest of your program as usual.

==More details on the concept==

Classes can build up on each other (inheritance)

In the beginning we promised that it is possible to replace different motor drivers without changing the rest of the program.
Classes can indeed include other Objects in the form of „member variables“.

C++ allows class declarations and the code for included Functions to be be placed in different files.
If you want to know more about that you can read this article about creating libraries in Arduino: [http://arduino.cc/en/Hacking/LibraryTutorial http://arduino.cc/en/Hacking/LibraryTutorial ]

GMU:Functions and Classes (Arduino)

2017-03-28T11:31:27Z

Veja6203: /* Classes are Data-types */

==Motivation==

Soon after starting to write the program for your robot you will encounter some typical problems:

* clarity: the bigger the program gets the harder it is to keep the general overview
* decoupling: you only want to change a certain part of the program without influencing all the rest
* recyclability: there are several similar parts in your robot for which you would like to reuse particular sections of your code

These problems reach back to the beginning of programming and their solution is an art and a science at the same time.
It generally helps a lot to separate your program into single subunits that are relatively independent from each other.

==Example: Controlling Motors==

The [http://arduino.cc/de/Reference/FunctionDeclaration function] is an enormous useful tool that can help you structuring your code. Functions allow you to sum up several operations under the same command. This command can be called again and again without knowing about or duplicating the included code.

Here is an example for a function for setting the speed of a motor that is connected to an H-bridge:

[[File:OOPARD1.jpg]]

Now (and for every prospective motor movement) we only need to write one single line in order to for instance setting the left wheels speed:

[[File:OOPARD2.jpg]]

This already saves us a lot of typing –
But one thing still seems quite laborious: we have to know the exact pin numbers every time we want to change the speed.

Imagine a program in which similar function calls are distributed all over.
In case of a hardware update you would have to find every single function call and change the parameters manually.
This effort could surely be spent for more useful things..

It would be ideal to find a way of calling a certain function that only offers the most useful parameters (like setting the speed) and which handles technical details (switching pins on and off) internally.

 

==Possible solution: Data and code in one package – „Classes“ and „Objects“==

C++ (and also Arduino) provides a specific feature that can solve our problem: Classes and Objects

A Class predefines common qualities of a group of Objects.
It for instance determines that every motor has the possibility to exert a certain amount of throttle.
The corresponding program could look like this:

[[File:OOPARD3.jpg]]

Now the computer knows that there is a class called „Motor“.
This class (class) provides a function called „setThrottle“ that is called as an argument by using a number (int) and that does not return anything (void).

===Classes are Data-types===

We can use our „Motor“ - class the same way we are using other data - types (int, long, float).
The following lines use that quality in order to implement two motors:
 
 

[[File:OOPARD4.jpg]]

 
 

===Calling inner functions of a class (Methods)===

Imagine we want to drive the left motor with full throttle whereas the right motor should stop completely.
This can be expressed as follows:

[[File:OOPARD5.jpg]]

A positive side effect: your program gains readability by picking distinct names for your Objects and Methods.

 
 

===Classes can contain other variables that can only be accessed „internally“===

How do the Objects „leftMotor“ and „rightMotor“ know which pins they want to switch on and off?

Until now our „Motor“ class is quite abstract since it does not contain this information.
A class that should conduct practical actions needs further variables (concrete pin numbers) and lines of code that describe what to do exactly.
We can simply include both things in the class definition:

''
class MotoMamaMotor {
...
private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; // c
int reversePin;
int throttlePin;
...
};
''

How do we include the pin numbers into the Object if they are not visible from the outside?
We simply write a „setup“ Function for the class:

''
class MotoMamaMotor {
private:
...
public: // we want the setup-function to be accessible from the outside.
void setup (int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}
...
};
''

==A complete example ==

In order to construct a complete example we only have to include the „speed“-Function (see description above):

''
// Defining a class for motor control

class MotoMamaMotor {

private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; //Every MotoMamaMotor type Object has its own forwardPin
int reversePin;
int throttlePin;

public: // the following qualities and methods are visible from the outside.
// This setup-Function has to be called before using the motor control
void setup(int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}

// this Function allows to control the motor speed
void setThrottle (int newThrottle){
if (newThrottle>0){ // should it spin forwards or backwards?
// spin forwards
digitalWrite(reversePin,LOW);
digitalWrite(forwardPin,HIGH);
}else{
// spin backwards
digitalWrite(forwardPin,LOW);
digitalWrite(reversePin,HIGH);
}
// adjust the speed:
analogWrite(throttlePin, newThrottle);
}
};

// create two separate MotoMamaMotor type Objects (leftMotor, rightMotor). They can be used as normal variables.
MotoMamaMotor leftMotor;
MotoMamaMotor rightMotor;

void setup(){ // this is our „main“ setup Function
leftMotor.setup(3,4,5); // assign the pin numbers for each motor in the setup Function: setup(int newForwardPin, int newReversePin, int newThrottlePin)
rightMotor.setup(6,7,8);
};

void loop(){ // this is our „main“ loop Function where concrete actions are executed. For example:
// Start backwards, slow down and accelerate forwards
for (int i =-255, i<=255;i++){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
// Start forwards, slow down and accelerate backwards
for (int i =255, i>=-255;i--){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
};
''

==Organizing classes in separate files==

We can improve our program structure by putting classes in separate files.

1)
Click on the arrow in the right corner in order to add a new file.
Select „new Tab“.

----BILD----

2)
Enter a filename at the bottom of the window.
It must end with .h !
In our case I suggest the name motorControl.h.

3)
Enter the first line:

''
#include „Arduino.h“
''

This line „links“ the file to the Arduino-specific features.
Now we can include the code of our class.

4)
Go back to your main file.
Now you have to „link“ the new file to your main file in order to use the features of our class.
Include the following line in the top of your main file

''
#include „MotorControl.h“
''

and write the rest of your program as usual.

==More details on the concept==

Classes can build up on each other (inheritance)

In the beginning we promised that it is possible to replace different motor drivers without changing the rest of the program.
Classes can indeed include other Objects in the form of „member variables“.

C++ allows class declarations and the code for included Functions to be be placed in different files.
If you want to know more about that you can read this article about creating libraries in Arduino: [http://arduino.cc/en/Hacking/LibraryTutorial http://arduino.cc/en/Hacking/LibraryTutorial ]

GMU:Functions and Classes (Arduino)

2017-03-28T11:30:48Z

Veja6203: /* Calling inner functions of a class (Methods) */

==Motivation==

Soon after starting to write the program for your robot you will encounter some typical problems:

* clarity: the bigger the program gets the harder it is to keep the general overview
* decoupling: you only want to change a certain part of the program without influencing all the rest
* recyclability: there are several similar parts in your robot for which you would like to reuse particular sections of your code

These problems reach back to the beginning of programming and their solution is an art and a science at the same time.
It generally helps a lot to separate your program into single subunits that are relatively independent from each other.

==Example: Controlling Motors==

The [http://arduino.cc/de/Reference/FunctionDeclaration function] is an enormous useful tool that can help you structuring your code. Functions allow you to sum up several operations under the same command. This command can be called again and again without knowing about or duplicating the included code.

Here is an example for a function for setting the speed of a motor that is connected to an H-bridge:

[[File:OOPARD1.jpg]]

Now (and for every prospective motor movement) we only need to write one single line in order to for instance setting the left wheels speed:

[[File:OOPARD2.jpg]]

This already saves us a lot of typing –
But one thing still seems quite laborious: we have to know the exact pin numbers every time we want to change the speed.

Imagine a program in which similar function calls are distributed all over.
In case of a hardware update you would have to find every single function call and change the parameters manually.
This effort could surely be spent for more useful things..

It would be ideal to find a way of calling a certain function that only offers the most useful parameters (like setting the speed) and which handles technical details (switching pins on and off) internally.

 

==Possible solution: Data and code in one package – „Classes“ and „Objects“==

C++ (and also Arduino) provides a specific feature that can solve our problem: Classes and Objects

A Class predefines common qualities of a group of Objects.
It for instance determines that every motor has the possibility to exert a certain amount of throttle.
The corresponding program could look like this:

[[File:OOPARD3.jpg]]

Now the computer knows that there is a class called „Motor“.
This class (class) provides a function called „setThrottle“ that is called as an argument by using a number (int) and that does not return anything (void).

===Classes are Data-types===

We can use our „Motor“ - class the same way we are using other data - types (int, long, float).
The following lines use that quality in order to implement two motors:
 
 

[[File:OOPARD4.jpg]]

 
 

===Calling inner functions of a class (Methods)===

Imagine we want to drive the left motor with full throttle whereas the right motor should stop completely.
This can be expressed as follows:

[[File:OOPARD5.jpg]]

A positive side effect: your program gains readability by picking distinct names for your Objects and Methods.

 
 

===Classes can contain other variables that can only be accessed „internally“===

How do the Objects „leftMotor“ and „rightMotor“ know which pins they want to switch on and off?

Until now our „Motor“ class is quite abstract since it does not contain this information.
A class that should conduct practical actions needs further variables (concrete pin numbers) and lines of code that describe what to do exactly.
We can simply include both things in the class definition:

''
class MotoMamaMotor {
...
private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; // c
int reversePin;
int throttlePin;
...
};
''

How do we include the pin numbers into the Object if they are not visible from the outside?
We simply write a „setup“ Function for the class:

''
class MotoMamaMotor {
private:
...
public: // we want the setup-function to be accessible from the outside.
void setup (int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}
...
};
''

==A complete example ==

In order to construct a complete example we only have to include the „speed“-Function (see description above):

''
// Defining a class for motor control

class MotoMamaMotor {

private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; //Every MotoMamaMotor type Object has its own forwardPin
int reversePin;
int throttlePin;

public: // the following qualities and methods are visible from the outside.
// This setup-Function has to be called before using the motor control
void setup(int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}

// this Function allows to control the motor speed
void setThrottle (int newThrottle){
if (newThrottle>0){ // should it spin forwards or backwards?
// spin forwards
digitalWrite(reversePin,LOW);
digitalWrite(forwardPin,HIGH);
}else{
// spin backwards
digitalWrite(forwardPin,LOW);
digitalWrite(reversePin,HIGH);
}
// adjust the speed:
analogWrite(throttlePin, newThrottle);
}
};

// create two separate MotoMamaMotor type Objects (leftMotor, rightMotor). They can be used as normal variables.
MotoMamaMotor leftMotor;
MotoMamaMotor rightMotor;

void setup(){ // this is our „main“ setup Function
leftMotor.setup(3,4,5); // assign the pin numbers for each motor in the setup Function: setup(int newForwardPin, int newReversePin, int newThrottlePin)
rightMotor.setup(6,7,8);
};

void loop(){ // this is our „main“ loop Function where concrete actions are executed. For example:
// Start backwards, slow down and accelerate forwards
for (int i =-255, i<=255;i++){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
// Start forwards, slow down and accelerate backwards
for (int i =255, i>=-255;i--){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
};
''

==Organizing classes in separate files==

We can improve our program structure by putting classes in separate files.

1)
Click on the arrow in the right corner in order to add a new file.
Select „new Tab“.

----BILD----

2)
Enter a filename at the bottom of the window.
It must end with .h !
In our case I suggest the name motorControl.h.

3)
Enter the first line:

''
#include „Arduino.h“
''

This line „links“ the file to the Arduino-specific features.
Now we can include the code of our class.

4)
Go back to your main file.
Now you have to „link“ the new file to your main file in order to use the features of our class.
Include the following line in the top of your main file

''
#include „MotorControl.h“
''

and write the rest of your program as usual.

==More details on the concept==

Classes can build up on each other (inheritance)

In the beginning we promised that it is possible to replace different motor drivers without changing the rest of the program.
Classes can indeed include other Objects in the form of „member variables“.

C++ allows class declarations and the code for included Functions to be be placed in different files.
If you want to know more about that you can read this article about creating libraries in Arduino: [http://arduino.cc/en/Hacking/LibraryTutorial http://arduino.cc/en/Hacking/LibraryTutorial ]

File:OOPARD5.jpg

2017-03-28T11:30:31Z

Veja6203: File uploaded with MsUpload

File uploaded with MsUpload

GMU:Functions and Classes (Arduino)

2017-03-28T11:28:19Z

Veja6203: /* Classes are Data-types */

==Motivation==

Soon after starting to write the program for your robot you will encounter some typical problems:

* clarity: the bigger the program gets the harder it is to keep the general overview
* decoupling: you only want to change a certain part of the program without influencing all the rest
* recyclability: there are several similar parts in your robot for which you would like to reuse particular sections of your code

These problems reach back to the beginning of programming and their solution is an art and a science at the same time.
It generally helps a lot to separate your program into single subunits that are relatively independent from each other.

==Example: Controlling Motors==

The [http://arduino.cc/de/Reference/FunctionDeclaration function] is an enormous useful tool that can help you structuring your code. Functions allow you to sum up several operations under the same command. This command can be called again and again without knowing about or duplicating the included code.

Here is an example for a function for setting the speed of a motor that is connected to an H-bridge:

[[File:OOPARD1.jpg]]

Now (and for every prospective motor movement) we only need to write one single line in order to for instance setting the left wheels speed:

[[File:OOPARD2.jpg]]

This already saves us a lot of typing –
But one thing still seems quite laborious: we have to know the exact pin numbers every time we want to change the speed.

Imagine a program in which similar function calls are distributed all over.
In case of a hardware update you would have to find every single function call and change the parameters manually.
This effort could surely be spent for more useful things..

It would be ideal to find a way of calling a certain function that only offers the most useful parameters (like setting the speed) and which handles technical details (switching pins on and off) internally.

 

==Possible solution: Data and code in one package – „Classes“ and „Objects“==

C++ (and also Arduino) provides a specific feature that can solve our problem: Classes and Objects

A Class predefines common qualities of a group of Objects.
It for instance determines that every motor has the possibility to exert a certain amount of throttle.
The corresponding program could look like this:

[[File:OOPARD3.jpg]]

Now the computer knows that there is a class called „Motor“.
This class (class) provides a function called „setThrottle“ that is called as an argument by using a number (int) and that does not return anything (void).

===Classes are Data-types===

We can use our „Motor“ - class the same way we are using other data - types (int, long, float).
The following lines use that quality in order to implement two motors:
 
 

[[File:OOPARD4.jpg]]

 
 

===Calling inner functions of a class (Methods)===

Imagine we want to drive the left motor with full throttle whereas the right motor should stop completely.
This can be expressed as follows:

''// the objetcs name „leftMotor“ and the herein implemented function „setThrottle“ are separated by a dot.
leftMotor.setThrottle(255);
rightMotor.setThrottle(0);
''

A positive side effect: your program gains readability by picking distinct names for your Objects and Methods.

===Classes can contain other variables that can only be accessed „internally“===

How do the Objects „leftMotor“ and „rightMotor“ know which pins they want to switch on and off?

Until now our „Motor“ class is quite abstract since it does not contain this information.
A class that should conduct practical actions needs further variables (concrete pin numbers) and lines of code that describe what to do exactly.
We can simply include both things in the class definition:

''
class MotoMamaMotor {
...
private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; // c
int reversePin;
int throttlePin;
...
};
''

How do we include the pin numbers into the Object if they are not visible from the outside?
We simply write a „setup“ Function for the class:

''
class MotoMamaMotor {
private:
...
public: // we want the setup-function to be accessible from the outside.
void setup (int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}
...
};
''

==A complete example ==

In order to construct a complete example we only have to include the „speed“-Function (see description above):

''
// Defining a class for motor control

class MotoMamaMotor {

private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; //Every MotoMamaMotor type Object has its own forwardPin
int reversePin;
int throttlePin;

public: // the following qualities and methods are visible from the outside.
// This setup-Function has to be called before using the motor control
void setup(int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}

// this Function allows to control the motor speed
void setThrottle (int newThrottle){
if (newThrottle>0){ // should it spin forwards or backwards?
// spin forwards
digitalWrite(reversePin,LOW);
digitalWrite(forwardPin,HIGH);
}else{
// spin backwards
digitalWrite(forwardPin,LOW);
digitalWrite(reversePin,HIGH);
}
// adjust the speed:
analogWrite(throttlePin, newThrottle);
}
};

// create two separate MotoMamaMotor type Objects (leftMotor, rightMotor). They can be used as normal variables.
MotoMamaMotor leftMotor;
MotoMamaMotor rightMotor;

void setup(){ // this is our „main“ setup Function
leftMotor.setup(3,4,5); // assign the pin numbers for each motor in the setup Function: setup(int newForwardPin, int newReversePin, int newThrottlePin)
rightMotor.setup(6,7,8);
};

void loop(){ // this is our „main“ loop Function where concrete actions are executed. For example:
// Start backwards, slow down and accelerate forwards
for (int i =-255, i<=255;i++){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
// Start forwards, slow down and accelerate backwards
for (int i =255, i>=-255;i--){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
};
''

==Organizing classes in separate files==

We can improve our program structure by putting classes in separate files.

1)
Click on the arrow in the right corner in order to add a new file.
Select „new Tab“.

----BILD----

2)
Enter a filename at the bottom of the window.
It must end with .h !
In our case I suggest the name motorControl.h.

3)
Enter the first line:

''
#include „Arduino.h“
''

This line „links“ the file to the Arduino-specific features.
Now we can include the code of our class.

4)
Go back to your main file.
Now you have to „link“ the new file to your main file in order to use the features of our class.
Include the following line in the top of your main file

''
#include „MotorControl.h“
''

and write the rest of your program as usual.

==More details on the concept==

Classes can build up on each other (inheritance)

In the beginning we promised that it is possible to replace different motor drivers without changing the rest of the program.
Classes can indeed include other Objects in the form of „member variables“.

C++ allows class declarations and the code for included Functions to be be placed in different files.
If you want to know more about that you can read this article about creating libraries in Arduino: [http://arduino.cc/en/Hacking/LibraryTutorial http://arduino.cc/en/Hacking/LibraryTutorial ]

GMU:Functions and Classes (Arduino)

2017-03-28T11:28:00Z

Veja6203: /* Classes are Data-types */

==Motivation==

Soon after starting to write the program for your robot you will encounter some typical problems:

* clarity: the bigger the program gets the harder it is to keep the general overview
* decoupling: you only want to change a certain part of the program without influencing all the rest
* recyclability: there are several similar parts in your robot for which you would like to reuse particular sections of your code

These problems reach back to the beginning of programming and their solution is an art and a science at the same time.
It generally helps a lot to separate your program into single subunits that are relatively independent from each other.

==Example: Controlling Motors==

The [http://arduino.cc/de/Reference/FunctionDeclaration function] is an enormous useful tool that can help you structuring your code. Functions allow you to sum up several operations under the same command. This command can be called again and again without knowing about or duplicating the included code.

Here is an example for a function for setting the speed of a motor that is connected to an H-bridge:

[[File:OOPARD1.jpg]]

Now (and for every prospective motor movement) we only need to write one single line in order to for instance setting the left wheels speed:

[[File:OOPARD2.jpg]]

This already saves us a lot of typing –
But one thing still seems quite laborious: we have to know the exact pin numbers every time we want to change the speed.

Imagine a program in which similar function calls are distributed all over.
In case of a hardware update you would have to find every single function call and change the parameters manually.
This effort could surely be spent for more useful things..

It would be ideal to find a way of calling a certain function that only offers the most useful parameters (like setting the speed) and which handles technical details (switching pins on and off) internally.

 

==Possible solution: Data and code in one package – „Classes“ and „Objects“==

C++ (and also Arduino) provides a specific feature that can solve our problem: Classes and Objects

A Class predefines common qualities of a group of Objects.
It for instance determines that every motor has the possibility to exert a certain amount of throttle.
The corresponding program could look like this:

[[File:OOPARD3.jpg]]

Now the computer knows that there is a class called „Motor“.
This class (class) provides a function called „setThrottle“ that is called as an argument by using a number (int) and that does not return anything (void).

===Classes are Data-types===

We can use our „Motor“ - class the same way we are using other data - types (int, long, float).
The following lines use that quality in order to implement two motors:
 
 

[[File:OOPARD4.jpg]]

===Calling inner functions of a class (Methods)===

Imagine we want to drive the left motor with full throttle whereas the right motor should stop completely.
This can be expressed as follows:

''// the objetcs name „leftMotor“ and the herein implemented function „setThrottle“ are separated by a dot.
leftMotor.setThrottle(255);
rightMotor.setThrottle(0);
''

A positive side effect: your program gains readability by picking distinct names for your Objects and Methods.

===Classes can contain other variables that can only be accessed „internally“===

How do the Objects „leftMotor“ and „rightMotor“ know which pins they want to switch on and off?

Until now our „Motor“ class is quite abstract since it does not contain this information.
A class that should conduct practical actions needs further variables (concrete pin numbers) and lines of code that describe what to do exactly.
We can simply include both things in the class definition:

''
class MotoMamaMotor {
...
private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; // c
int reversePin;
int throttlePin;
...
};
''

How do we include the pin numbers into the Object if they are not visible from the outside?
We simply write a „setup“ Function for the class:

''
class MotoMamaMotor {
private:
...
public: // we want the setup-function to be accessible from the outside.
void setup (int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}
...
};
''

==A complete example ==

In order to construct a complete example we only have to include the „speed“-Function (see description above):

''
// Defining a class for motor control

class MotoMamaMotor {

private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; //Every MotoMamaMotor type Object has its own forwardPin
int reversePin;
int throttlePin;

public: // the following qualities and methods are visible from the outside.
// This setup-Function has to be called before using the motor control
void setup(int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}

// this Function allows to control the motor speed
void setThrottle (int newThrottle){
if (newThrottle>0){ // should it spin forwards or backwards?
// spin forwards
digitalWrite(reversePin,LOW);
digitalWrite(forwardPin,HIGH);
}else{
// spin backwards
digitalWrite(forwardPin,LOW);
digitalWrite(reversePin,HIGH);
}
// adjust the speed:
analogWrite(throttlePin, newThrottle);
}
};

// create two separate MotoMamaMotor type Objects (leftMotor, rightMotor). They can be used as normal variables.
MotoMamaMotor leftMotor;
MotoMamaMotor rightMotor;

void setup(){ // this is our „main“ setup Function
leftMotor.setup(3,4,5); // assign the pin numbers for each motor in the setup Function: setup(int newForwardPin, int newReversePin, int newThrottlePin)
rightMotor.setup(6,7,8);
};

void loop(){ // this is our „main“ loop Function where concrete actions are executed. For example:
// Start backwards, slow down and accelerate forwards
for (int i =-255, i<=255;i++){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
// Start forwards, slow down and accelerate backwards
for (int i =255, i>=-255;i--){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
};
''

==Organizing classes in separate files==

We can improve our program structure by putting classes in separate files.

1)
Click on the arrow in the right corner in order to add a new file.
Select „new Tab“.

----BILD----

2)
Enter a filename at the bottom of the window.
It must end with .h !
In our case I suggest the name motorControl.h.

3)
Enter the first line:

''
#include „Arduino.h“
''

This line „links“ the file to the Arduino-specific features.
Now we can include the code of our class.

4)
Go back to your main file.
Now you have to „link“ the new file to your main file in order to use the features of our class.
Include the following line in the top of your main file

''
#include „MotorControl.h“
''

and write the rest of your program as usual.

==More details on the concept==

Classes can build up on each other (inheritance)

In the beginning we promised that it is possible to replace different motor drivers without changing the rest of the program.
Classes can indeed include other Objects in the form of „member variables“.

C++ allows class declarations and the code for included Functions to be be placed in different files.
If you want to know more about that you can read this article about creating libraries in Arduino: [http://arduino.cc/en/Hacking/LibraryTutorial http://arduino.cc/en/Hacking/LibraryTutorial ]

GMU:Functions and Classes (Arduino)

2017-03-28T11:27:17Z

Veja6203: /* Classes are Data-types */

==Motivation==

Soon after starting to write the program for your robot you will encounter some typical problems:

* clarity: the bigger the program gets the harder it is to keep the general overview
* decoupling: you only want to change a certain part of the program without influencing all the rest
* recyclability: there are several similar parts in your robot for which you would like to reuse particular sections of your code

These problems reach back to the beginning of programming and their solution is an art and a science at the same time.
It generally helps a lot to separate your program into single subunits that are relatively independent from each other.

==Example: Controlling Motors==

The [http://arduino.cc/de/Reference/FunctionDeclaration function] is an enormous useful tool that can help you structuring your code. Functions allow you to sum up several operations under the same command. This command can be called again and again without knowing about or duplicating the included code.

Here is an example for a function for setting the speed of a motor that is connected to an H-bridge:

[[File:OOPARD1.jpg]]

Now (and for every prospective motor movement) we only need to write one single line in order to for instance setting the left wheels speed:

[[File:OOPARD2.jpg]]

This already saves us a lot of typing –
But one thing still seems quite laborious: we have to know the exact pin numbers every time we want to change the speed.

Imagine a program in which similar function calls are distributed all over.
In case of a hardware update you would have to find every single function call and change the parameters manually.
This effort could surely be spent for more useful things..

It would be ideal to find a way of calling a certain function that only offers the most useful parameters (like setting the speed) and which handles technical details (switching pins on and off) internally.

 

==Possible solution: Data and code in one package – „Classes“ and „Objects“==

C++ (and also Arduino) provides a specific feature that can solve our problem: Classes and Objects

A Class predefines common qualities of a group of Objects.
It for instance determines that every motor has the possibility to exert a certain amount of throttle.
The corresponding program could look like this:

[[File:OOPARD3.jpg]]

Now the computer knows that there is a class called „Motor“.
This class (class) provides a function called „setThrottle“ that is called as an argument by using a number (int) and that does not return anything (void).

===Classes are Data-types===

We can use our „Motor“ - class the same way we are using other data - types (int, long, float).
The following lines use that quality in order to implement two motors:

[[File:OOPARD4.jpg]]

===Calling inner functions of a class (Methods)===

Imagine we want to drive the left motor with full throttle whereas the right motor should stop completely.
This can be expressed as follows:

''// the objetcs name „leftMotor“ and the herein implemented function „setThrottle“ are separated by a dot.
leftMotor.setThrottle(255);
rightMotor.setThrottle(0);
''

A positive side effect: your program gains readability by picking distinct names for your Objects and Methods.

===Classes can contain other variables that can only be accessed „internally“===

How do the Objects „leftMotor“ and „rightMotor“ know which pins they want to switch on and off?

Until now our „Motor“ class is quite abstract since it does not contain this information.
A class that should conduct practical actions needs further variables (concrete pin numbers) and lines of code that describe what to do exactly.
We can simply include both things in the class definition:

''
class MotoMamaMotor {
...
private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; // c
int reversePin;
int throttlePin;
...
};
''

How do we include the pin numbers into the Object if they are not visible from the outside?
We simply write a „setup“ Function for the class:

''
class MotoMamaMotor {
private:
...
public: // we want the setup-function to be accessible from the outside.
void setup (int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}
...
};
''

==A complete example ==

In order to construct a complete example we only have to include the „speed“-Function (see description above):

''
// Defining a class for motor control

class MotoMamaMotor {

private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; //Every MotoMamaMotor type Object has its own forwardPin
int reversePin;
int throttlePin;

public: // the following qualities and methods are visible from the outside.
// This setup-Function has to be called before using the motor control
void setup(int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}

// this Function allows to control the motor speed
void setThrottle (int newThrottle){
if (newThrottle>0){ // should it spin forwards or backwards?
// spin forwards
digitalWrite(reversePin,LOW);
digitalWrite(forwardPin,HIGH);
}else{
// spin backwards
digitalWrite(forwardPin,LOW);
digitalWrite(reversePin,HIGH);
}
// adjust the speed:
analogWrite(throttlePin, newThrottle);
}
};

// create two separate MotoMamaMotor type Objects (leftMotor, rightMotor). They can be used as normal variables.
MotoMamaMotor leftMotor;
MotoMamaMotor rightMotor;

void setup(){ // this is our „main“ setup Function
leftMotor.setup(3,4,5); // assign the pin numbers for each motor in the setup Function: setup(int newForwardPin, int newReversePin, int newThrottlePin)
rightMotor.setup(6,7,8);
};

void loop(){ // this is our „main“ loop Function where concrete actions are executed. For example:
// Start backwards, slow down and accelerate forwards
for (int i =-255, i<=255;i++){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
// Start forwards, slow down and accelerate backwards
for (int i =255, i>=-255;i--){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
};
''

==Organizing classes in separate files==

We can improve our program structure by putting classes in separate files.

1)
Click on the arrow in the right corner in order to add a new file.
Select „new Tab“.

----BILD----

2)
Enter a filename at the bottom of the window.
It must end with .h !
In our case I suggest the name motorControl.h.

3)
Enter the first line:

''
#include „Arduino.h“
''

This line „links“ the file to the Arduino-specific features.
Now we can include the code of our class.

4)
Go back to your main file.
Now you have to „link“ the new file to your main file in order to use the features of our class.
Include the following line in the top of your main file

''
#include „MotorControl.h“
''

and write the rest of your program as usual.

==More details on the concept==

Classes can build up on each other (inheritance)

In the beginning we promised that it is possible to replace different motor drivers without changing the rest of the program.
Classes can indeed include other Objects in the form of „member variables“.

C++ allows class declarations and the code for included Functions to be be placed in different files.
If you want to know more about that you can read this article about creating libraries in Arduino: [http://arduino.cc/en/Hacking/LibraryTutorial http://arduino.cc/en/Hacking/LibraryTutorial ]

File:OOPARD4.jpg

2017-03-28T11:26:56Z

Veja6203: File uploaded with MsUpload

File uploaded with MsUpload

GMU:Functions and Classes (Arduino)

2017-03-28T11:25:16Z

Veja6203: /* Classes are Data-types */

==Motivation==

Soon after starting to write the program for your robot you will encounter some typical problems:

* clarity: the bigger the program gets the harder it is to keep the general overview
* decoupling: you only want to change a certain part of the program without influencing all the rest
* recyclability: there are several similar parts in your robot for which you would like to reuse particular sections of your code

These problems reach back to the beginning of programming and their solution is an art and a science at the same time.
It generally helps a lot to separate your program into single subunits that are relatively independent from each other.

==Example: Controlling Motors==

The [http://arduino.cc/de/Reference/FunctionDeclaration function] is an enormous useful tool that can help you structuring your code. Functions allow you to sum up several operations under the same command. This command can be called again and again without knowing about or duplicating the included code.

Here is an example for a function for setting the speed of a motor that is connected to an H-bridge:

[[File:OOPARD1.jpg]]

Now (and for every prospective motor movement) we only need to write one single line in order to for instance setting the left wheels speed:

[[File:OOPARD2.jpg]]

This already saves us a lot of typing –
But one thing still seems quite laborious: we have to know the exact pin numbers every time we want to change the speed.

Imagine a program in which similar function calls are distributed all over.
In case of a hardware update you would have to find every single function call and change the parameters manually.
This effort could surely be spent for more useful things..

It would be ideal to find a way of calling a certain function that only offers the most useful parameters (like setting the speed) and which handles technical details (switching pins on and off) internally.

 

==Possible solution: Data and code in one package – „Classes“ and „Objects“==

C++ (and also Arduino) provides a specific feature that can solve our problem: Classes and Objects

A Class predefines common qualities of a group of Objects.
It for instance determines that every motor has the possibility to exert a certain amount of throttle.
The corresponding program could look like this:

[[File:OOPARD3.jpg]]

Now the computer knows that there is a class called „Motor“.
This class (class) provides a function called „setThrottle“ that is called as an argument by using a number (int) and that does not return anything (void).

===Classes are Data-types===

We can use our „Motor“ - class the same way we are using other data - types (int, long, float).
The following lines use that quality in order to implement two motors:

[[File:OOPARD4.jpg]]

===Calling inner functions of a class (Methods)===

Imagine we want to drive the left motor with full throttle whereas the right motor should stop completely.
This can be expressed as follows:

''// the objetcs name „leftMotor“ and the herein implemented function „setThrottle“ are separated by a dot.
leftMotor.setThrottle(255);
rightMotor.setThrottle(0);
''

A positive side effect: your program gains readability by picking distinct names for your Objects and Methods.

===Classes can contain other variables that can only be accessed „internally“===

How do the Objects „leftMotor“ and „rightMotor“ know which pins they want to switch on and off?

Until now our „Motor“ class is quite abstract since it does not contain this information.
A class that should conduct practical actions needs further variables (concrete pin numbers) and lines of code that describe what to do exactly.
We can simply include both things in the class definition:

''
class MotoMamaMotor {
...
private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; // c
int reversePin;
int throttlePin;
...
};
''

How do we include the pin numbers into the Object if they are not visible from the outside?
We simply write a „setup“ Function for the class:

''
class MotoMamaMotor {
private:
...
public: // we want the setup-function to be accessible from the outside.
void setup (int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}
...
};
''

==A complete example ==

In order to construct a complete example we only have to include the „speed“-Function (see description above):

''
// Defining a class for motor control

class MotoMamaMotor {

private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; //Every MotoMamaMotor type Object has its own forwardPin
int reversePin;
int throttlePin;

public: // the following qualities and methods are visible from the outside.
// This setup-Function has to be called before using the motor control
void setup(int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}

// this Function allows to control the motor speed
void setThrottle (int newThrottle){
if (newThrottle>0){ // should it spin forwards or backwards?
// spin forwards
digitalWrite(reversePin,LOW);
digitalWrite(forwardPin,HIGH);
}else{
// spin backwards
digitalWrite(forwardPin,LOW);
digitalWrite(reversePin,HIGH);
}
// adjust the speed:
analogWrite(throttlePin, newThrottle);
}
};

// create two separate MotoMamaMotor type Objects (leftMotor, rightMotor). They can be used as normal variables.
MotoMamaMotor leftMotor;
MotoMamaMotor rightMotor;

void setup(){ // this is our „main“ setup Function
leftMotor.setup(3,4,5); // assign the pin numbers for each motor in the setup Function: setup(int newForwardPin, int newReversePin, int newThrottlePin)
rightMotor.setup(6,7,8);
};

void loop(){ // this is our „main“ loop Function where concrete actions are executed. For example:
// Start backwards, slow down and accelerate forwards
for (int i =-255, i<=255;i++){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
// Start forwards, slow down and accelerate backwards
for (int i =255, i>=-255;i--){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
};
''

==Organizing classes in separate files==

We can improve our program structure by putting classes in separate files.

1)
Click on the arrow in the right corner in order to add a new file.
Select „new Tab“.

----BILD----

2)
Enter a filename at the bottom of the window.
It must end with .h !
In our case I suggest the name motorControl.h.

3)
Enter the first line:

''
#include „Arduino.h“
''

This line „links“ the file to the Arduino-specific features.
Now we can include the code of our class.

4)
Go back to your main file.
Now you have to „link“ the new file to your main file in order to use the features of our class.
Include the following line in the top of your main file

''
#include „MotorControl.h“
''

and write the rest of your program as usual.

==More details on the concept==

Classes can build up on each other (inheritance)

In the beginning we promised that it is possible to replace different motor drivers without changing the rest of the program.
Classes can indeed include other Objects in the form of „member variables“.

C++ allows class declarations and the code for included Functions to be be placed in different files.
If you want to know more about that you can read this article about creating libraries in Arduino: [http://arduino.cc/en/Hacking/LibraryTutorial http://arduino.cc/en/Hacking/LibraryTutorial ]

GMU:Functions and Classes (Arduino)

2017-03-28T11:22:44Z

Veja6203: /* Possible solution: Data and code in one package – „Classes“ and „Objects“ */

==Motivation==

Soon after starting to write the program for your robot you will encounter some typical problems:

* clarity: the bigger the program gets the harder it is to keep the general overview
* decoupling: you only want to change a certain part of the program without influencing all the rest
* recyclability: there are several similar parts in your robot for which you would like to reuse particular sections of your code

These problems reach back to the beginning of programming and their solution is an art and a science at the same time.
It generally helps a lot to separate your program into single subunits that are relatively independent from each other.

==Example: Controlling Motors==

The [http://arduino.cc/de/Reference/FunctionDeclaration function] is an enormous useful tool that can help you structuring your code. Functions allow you to sum up several operations under the same command. This command can be called again and again without knowing about or duplicating the included code.

Here is an example for a function for setting the speed of a motor that is connected to an H-bridge:

[[File:OOPARD1.jpg]]

Now (and for every prospective motor movement) we only need to write one single line in order to for instance setting the left wheels speed:

[[File:OOPARD2.jpg]]

This already saves us a lot of typing –
But one thing still seems quite laborious: we have to know the exact pin numbers every time we want to change the speed.

Imagine a program in which similar function calls are distributed all over.
In case of a hardware update you would have to find every single function call and change the parameters manually.
This effort could surely be spent for more useful things..

It would be ideal to find a way of calling a certain function that only offers the most useful parameters (like setting the speed) and which handles technical details (switching pins on and off) internally.

 

==Possible solution: Data and code in one package – „Classes“ and „Objects“==

C++ (and also Arduino) provides a specific feature that can solve our problem: Classes and Objects

A Class predefines common qualities of a group of Objects.
It for instance determines that every motor has the possibility to exert a certain amount of throttle.
The corresponding program could look like this:

[[File:OOPARD3.jpg]]

Now the computer knows that there is a class called „Motor“.
This class (class) provides a function called „setThrottle“ that is called as an argument by using a number (int) and that does not return anything (void).

===Classes are Data-types===

We can use our „Motor“ - class the same way we are using other data - types (int, long, float).
The following lines use that quality in order to implement two motors:

''Motor leftMotor; // declare an object of the type „Motor“ called „leftMotor“
Motor rightMotor; // declare another object of the type „Motor“ called „rightMotor“
''

===Calling inner functions of a class (Methods)===

Imagine we want to drive the left motor with full throttle whereas the right motor should stop completely.
This can be expressed as follows:

''// the objetcs name „leftMotor“ and the herein implemented function „setThrottle“ are separated by a dot.
leftMotor.setThrottle(255);
rightMotor.setThrottle(0);
''

A positive side effect: your program gains readability by picking distinct names for your Objects and Methods.

===Classes can contain other variables that can only be accessed „internally“===

How do the Objects „leftMotor“ and „rightMotor“ know which pins they want to switch on and off?

Until now our „Motor“ class is quite abstract since it does not contain this information.
A class that should conduct practical actions needs further variables (concrete pin numbers) and lines of code that describe what to do exactly.
We can simply include both things in the class definition:

''
class MotoMamaMotor {
...
private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; // c
int reversePin;
int throttlePin;
...
};
''

How do we include the pin numbers into the Object if they are not visible from the outside?
We simply write a „setup“ Function for the class:

''
class MotoMamaMotor {
private:
...
public: // we want the setup-function to be accessible from the outside.
void setup (int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}
...
};
''

==A complete example ==

In order to construct a complete example we only have to include the „speed“-Function (see description above):

''
// Defining a class for motor control

class MotoMamaMotor {

private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; //Every MotoMamaMotor type Object has its own forwardPin
int reversePin;
int throttlePin;

public: // the following qualities and methods are visible from the outside.
// This setup-Function has to be called before using the motor control
void setup(int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}

// this Function allows to control the motor speed
void setThrottle (int newThrottle){
if (newThrottle>0){ // should it spin forwards or backwards?
// spin forwards
digitalWrite(reversePin,LOW);
digitalWrite(forwardPin,HIGH);
}else{
// spin backwards
digitalWrite(forwardPin,LOW);
digitalWrite(reversePin,HIGH);
}
// adjust the speed:
analogWrite(throttlePin, newThrottle);
}
};

// create two separate MotoMamaMotor type Objects (leftMotor, rightMotor). They can be used as normal variables.
MotoMamaMotor leftMotor;
MotoMamaMotor rightMotor;

void setup(){ // this is our „main“ setup Function
leftMotor.setup(3,4,5); // assign the pin numbers for each motor in the setup Function: setup(int newForwardPin, int newReversePin, int newThrottlePin)
rightMotor.setup(6,7,8);
};

void loop(){ // this is our „main“ loop Function where concrete actions are executed. For example:
// Start backwards, slow down and accelerate forwards
for (int i =-255, i<=255;i++){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
// Start forwards, slow down and accelerate backwards
for (int i =255, i>=-255;i--){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
};
''

==Organizing classes in separate files==

We can improve our program structure by putting classes in separate files.

1)
Click on the arrow in the right corner in order to add a new file.
Select „new Tab“.

----BILD----

2)
Enter a filename at the bottom of the window.
It must end with .h !
In our case I suggest the name motorControl.h.

3)
Enter the first line:

''
#include „Arduino.h“
''

This line „links“ the file to the Arduino-specific features.
Now we can include the code of our class.

4)
Go back to your main file.
Now you have to „link“ the new file to your main file in order to use the features of our class.
Include the following line in the top of your main file

''
#include „MotorControl.h“
''

and write the rest of your program as usual.

==More details on the concept==

Classes can build up on each other (inheritance)

In the beginning we promised that it is possible to replace different motor drivers without changing the rest of the program.
Classes can indeed include other Objects in the form of „member variables“.

C++ allows class declarations and the code for included Functions to be be placed in different files.
If you want to know more about that you can read this article about creating libraries in Arduino: [http://arduino.cc/en/Hacking/LibraryTutorial http://arduino.cc/en/Hacking/LibraryTutorial ]

GMU:Functions and Classes (Arduino)

2017-03-28T11:22:13Z

Veja6203: /* Possible solution: Data and code in one package „Classes“ and „Objects“ */

==Motivation==

Soon after starting to write the program for your robot you will encounter some typical problems:

* clarity: the bigger the program gets the harder it is to keep the general overview
* decoupling: you only want to change a certain part of the program without influencing all the rest
* recyclability: there are several similar parts in your robot for which you would like to reuse particular sections of your code

These problems reach back to the beginning of programming and their solution is an art and a science at the same time.
It generally helps a lot to separate your program into single subunits that are relatively independent from each other.

==Example: Controlling Motors==

The [http://arduino.cc/de/Reference/FunctionDeclaration function] is an enormous useful tool that can help you structuring your code. Functions allow you to sum up several operations under the same command. This command can be called again and again without knowing about or duplicating the included code.

Here is an example for a function for setting the speed of a motor that is connected to an H-bridge:

[[File:OOPARD1.jpg]]

Now (and for every prospective motor movement) we only need to write one single line in order to for instance setting the left wheels speed:

[[File:OOPARD2.jpg]]

This already saves us a lot of typing –
But one thing still seems quite laborious: we have to know the exact pin numbers every time we want to change the speed.

Imagine a program in which similar function calls are distributed all over.
In case of a hardware update you would have to find every single function call and change the parameters manually.
This effort could surely be spent for more useful things..

It would be ideal to find a way of calling a certain function that only offers the most useful parameters (like setting the speed) and which handles technical details (switching pins on and off) internally.

 

==Possible solution: Data and code in one package – „Classes“ and „Objects“==

C++ (and also Arduino) provides a specific feature that can solve our problem: Classes and Objects

A Class predefines common qualities of a group of Objects.
It for instance determines that every motor has the possibility to exert a certain amount of throttle.
The corresponding program could look like this:

[[File:OOPARD3]]

Now the computer knows that there is a class called „Motor“.
This class (class) provides a function called „setThrottle“ that is called as an argument by using a number (int) and that does not return anything (void).

===Classes are Data-types===

We can use our „Motor“ - class the same way we are using other data - types (int, long, float).
The following lines use that quality in order to implement two motors:

''Motor leftMotor; // declare an object of the type „Motor“ called „leftMotor“
Motor rightMotor; // declare another object of the type „Motor“ called „rightMotor“
''

===Calling inner functions of a class (Methods)===

Imagine we want to drive the left motor with full throttle whereas the right motor should stop completely.
This can be expressed as follows:

''// the objetcs name „leftMotor“ and the herein implemented function „setThrottle“ are separated by a dot.
leftMotor.setThrottle(255);
rightMotor.setThrottle(0);
''

A positive side effect: your program gains readability by picking distinct names for your Objects and Methods.

===Classes can contain other variables that can only be accessed „internally“===

How do the Objects „leftMotor“ and „rightMotor“ know which pins they want to switch on and off?

Until now our „Motor“ class is quite abstract since it does not contain this information.
A class that should conduct practical actions needs further variables (concrete pin numbers) and lines of code that describe what to do exactly.
We can simply include both things in the class definition:

''
class MotoMamaMotor {
...
private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; // c
int reversePin;
int throttlePin;
...
};
''

How do we include the pin numbers into the Object if they are not visible from the outside?
We simply write a „setup“ Function for the class:

''
class MotoMamaMotor {
private:
...
public: // we want the setup-function to be accessible from the outside.
void setup (int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}
...
};
''

==A complete example ==

In order to construct a complete example we only have to include the „speed“-Function (see description above):

''
// Defining a class for motor control

class MotoMamaMotor {

private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; //Every MotoMamaMotor type Object has its own forwardPin
int reversePin;
int throttlePin;

public: // the following qualities and methods are visible from the outside.
// This setup-Function has to be called before using the motor control
void setup(int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}

// this Function allows to control the motor speed
void setThrottle (int newThrottle){
if (newThrottle>0){ // should it spin forwards or backwards?
// spin forwards
digitalWrite(reversePin,LOW);
digitalWrite(forwardPin,HIGH);
}else{
// spin backwards
digitalWrite(forwardPin,LOW);
digitalWrite(reversePin,HIGH);
}
// adjust the speed:
analogWrite(throttlePin, newThrottle);
}
};

// create two separate MotoMamaMotor type Objects (leftMotor, rightMotor). They can be used as normal variables.
MotoMamaMotor leftMotor;
MotoMamaMotor rightMotor;

void setup(){ // this is our „main“ setup Function
leftMotor.setup(3,4,5); // assign the pin numbers for each motor in the setup Function: setup(int newForwardPin, int newReversePin, int newThrottlePin)
rightMotor.setup(6,7,8);
};

void loop(){ // this is our „main“ loop Function where concrete actions are executed. For example:
// Start backwards, slow down and accelerate forwards
for (int i =-255, i<=255;i++){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
// Start forwards, slow down and accelerate backwards
for (int i =255, i>=-255;i--){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
};
''

==Organizing classes in separate files==

We can improve our program structure by putting classes in separate files.

1)
Click on the arrow in the right corner in order to add a new file.
Select „new Tab“.

----BILD----

2)
Enter a filename at the bottom of the window.
It must end with .h !
In our case I suggest the name motorControl.h.

3)
Enter the first line:

''
#include „Arduino.h“
''

This line „links“ the file to the Arduino-specific features.
Now we can include the code of our class.

4)
Go back to your main file.
Now you have to „link“ the new file to your main file in order to use the features of our class.
Include the following line in the top of your main file

''
#include „MotorControl.h“
''

and write the rest of your program as usual.

==More details on the concept==

Classes can build up on each other (inheritance)

In the beginning we promised that it is possible to replace different motor drivers without changing the rest of the program.
Classes can indeed include other Objects in the form of „member variables“.

C++ allows class declarations and the code for included Functions to be be placed in different files.
If you want to know more about that you can read this article about creating libraries in Arduino: [http://arduino.cc/en/Hacking/LibraryTutorial http://arduino.cc/en/Hacking/LibraryTutorial ]

File:OOPARD3.jpg

2017-03-28T11:22:08Z

Veja6203: File uploaded with MsUpload

File uploaded with MsUpload

GMU:Functions and Classes (Arduino)

2017-03-28T11:13:46Z

Veja6203: /* Example: Controlling Motors */

==Motivation==

Soon after starting to write the program for your robot you will encounter some typical problems:

* clarity: the bigger the program gets the harder it is to keep the general overview
* decoupling: you only want to change a certain part of the program without influencing all the rest
* recyclability: there are several similar parts in your robot for which you would like to reuse particular sections of your code

These problems reach back to the beginning of programming and their solution is an art and a science at the same time.
It generally helps a lot to separate your program into single subunits that are relatively independent from each other.

==Example: Controlling Motors==

The [http://arduino.cc/de/Reference/FunctionDeclaration function] is an enormous useful tool that can help you structuring your code. Functions allow you to sum up several operations under the same command. This command can be called again and again without knowing about or duplicating the included code.

Here is an example for a function for setting the speed of a motor that is connected to an H-bridge:

[[File:OOPARD1.jpg]]

Now (and for every prospective motor movement) we only need to write one single line in order to for instance setting the left wheels speed:

[[File:OOPARD2.jpg]]

This already saves us a lot of typing –
But one thing still seems quite laborious: we have to know the exact pin numbers every time we want to change the speed.

Imagine a program in which similar function calls are distributed all over.
In case of a hardware update you would have to find every single function call and change the parameters manually.
This effort could surely be spent for more useful things..

It would be ideal to find a way of calling a certain function that only offers the most useful parameters (like setting the speed) and which handles technical details (switching pins on and off) internally.

 

==Possible solution: Data and code in one package „Classes“ and „Objects“==

C++ (and also Arduino) provides a specific feature that can solve our problem: Classes and Objects

A Class predefines common qualities of a group of Objects.
It for instance determines that every motor has the possibility to exert a certain amount of throttle.
The corresponding program could look like this:

''class Motor{
public: // the following qualities and methods are visible from the outside.
void setThrottle(int newThrottle); // every motor has the possibility to exert trottle.
}''

Now the computer knows that there is a class called „Motor“.
This class (class) provides a function called „setThrottle“ that is called as an argument by using a number (int) and that does not return anything (void).

===Classes are Data-types===

We can use our „Motor“ - class the same way we are using other data - types (int, long, float).
The following lines use that quality in order to implement two motors:

''Motor leftMotor; // declare an object of the type „Motor“ called „leftMotor“
Motor rightMotor; // declare another object of the type „Motor“ called „rightMotor“
''

===Calling inner functions of a class (Methods)===

Imagine we want to drive the left motor with full throttle whereas the right motor should stop completely.
This can be expressed as follows:

''// the objetcs name „leftMotor“ and the herein implemented function „setThrottle“ are separated by a dot.
leftMotor.setThrottle(255);
rightMotor.setThrottle(0);
''

A positive side effect: your program gains readability by picking distinct names for your Objects and Methods.

===Classes can contain other variables that can only be accessed „internally“===

How do the Objects „leftMotor“ and „rightMotor“ know which pins they want to switch on and off?

Until now our „Motor“ class is quite abstract since it does not contain this information.
A class that should conduct practical actions needs further variables (concrete pin numbers) and lines of code that describe what to do exactly.
We can simply include both things in the class definition:

''
class MotoMamaMotor {
...
private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; // c
int reversePin;
int throttlePin;
...
};
''

How do we include the pin numbers into the Object if they are not visible from the outside?
We simply write a „setup“ Function for the class:

''
class MotoMamaMotor {
private:
...
public: // we want the setup-function to be accessible from the outside.
void setup (int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}
...
};
''

==A complete example ==

In order to construct a complete example we only have to include the „speed“-Function (see description above):

''
// Defining a class for motor control

class MotoMamaMotor {

private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; //Every MotoMamaMotor type Object has its own forwardPin
int reversePin;
int throttlePin;

public: // the following qualities and methods are visible from the outside.
// This setup-Function has to be called before using the motor control
void setup(int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}

// this Function allows to control the motor speed
void setThrottle (int newThrottle){
if (newThrottle>0){ // should it spin forwards or backwards?
// spin forwards
digitalWrite(reversePin,LOW);
digitalWrite(forwardPin,HIGH);
}else{
// spin backwards
digitalWrite(forwardPin,LOW);
digitalWrite(reversePin,HIGH);
}
// adjust the speed:
analogWrite(throttlePin, newThrottle);
}
};

// create two separate MotoMamaMotor type Objects (leftMotor, rightMotor). They can be used as normal variables.
MotoMamaMotor leftMotor;
MotoMamaMotor rightMotor;

void setup(){ // this is our „main“ setup Function
leftMotor.setup(3,4,5); // assign the pin numbers for each motor in the setup Function: setup(int newForwardPin, int newReversePin, int newThrottlePin)
rightMotor.setup(6,7,8);
};

void loop(){ // this is our „main“ loop Function where concrete actions are executed. For example:
// Start backwards, slow down and accelerate forwards
for (int i =-255, i<=255;i++){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
// Start forwards, slow down and accelerate backwards
for (int i =255, i>=-255;i--){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
};
''

==Organizing classes in separate files==

We can improve our program structure by putting classes in separate files.

1)
Click on the arrow in the right corner in order to add a new file.
Select „new Tab“.

----BILD----

2)
Enter a filename at the bottom of the window.
It must end with .h !
In our case I suggest the name motorControl.h.

3)
Enter the first line:

''
#include „Arduino.h“
''

This line „links“ the file to the Arduino-specific features.
Now we can include the code of our class.

4)
Go back to your main file.
Now you have to „link“ the new file to your main file in order to use the features of our class.
Include the following line in the top of your main file

''
#include „MotorControl.h“
''

and write the rest of your program as usual.

==More details on the concept==

Classes can build up on each other (inheritance)

In the beginning we promised that it is possible to replace different motor drivers without changing the rest of the program.
Classes can indeed include other Objects in the form of „member variables“.

C++ allows class declarations and the code for included Functions to be be placed in different files.
If you want to know more about that you can read this article about creating libraries in Arduino: [http://arduino.cc/en/Hacking/LibraryTutorial http://arduino.cc/en/Hacking/LibraryTutorial ]

GMU:Functions and Classes (Arduino)

2017-03-28T11:13:00Z

Veja6203: /* Example: Controlling Motors */

==Motivation==

Soon after starting to write the program for your robot you will encounter some typical problems:

* clarity: the bigger the program gets the harder it is to keep the general overview
* decoupling: you only want to change a certain part of the program without influencing all the rest
* recyclability: there are several similar parts in your robot for which you would like to reuse particular sections of your code

These problems reach back to the beginning of programming and their solution is an art and a science at the same time.
It generally helps a lot to separate your program into single subunits that are relatively independent from each other.

==Example: Controlling Motors==

The [http://arduino.cc/de/Reference/FunctionDeclaration function] is an enormous useful tool that can help you structuring your code. Functions allow you to sum up several operations under the same command. This command can be called again and again without knowing about or duplicating the included code.

Here is an example for a function for setting the speed of a motor that is connected to an H-bridge:

[[File:OOPARD1.jpg]]

Now (and for every prospective motor movement) we only need to write one single line in order to for instance setting the left wheels speed:

[[File:OOPARD2.jpg]]

This already saves us a lot of typing –
But one thing still seems quite laborious: we have to know the exact pin numbers every time we want to change the speed.

Imagine a program in which similar function calls are distributed all over.
In case of a hardware update you would have to find every single function call and change the parameters manually.
This effort could surely be spent for more useful things..

It would be ideal to find a way of calling a certain function that only offers the most useful parameters (like setting the speed) and which handles technical details (switching pins on and off) internally.

==Possible solution: Data and code in one package „Classes“ and „Objects“==

C++ (and also Arduino) provides a specific feature that can solve our problem: Classes and Objects

A Class predefines common qualities of a group of Objects.
It for instance determines that every motor has the possibility to exert a certain amount of throttle.
The corresponding program could look like this:

''class Motor{
public: // the following qualities and methods are visible from the outside.
void setThrottle(int newThrottle); // every motor has the possibility to exert trottle.
}''

Now the computer knows that there is a class called „Motor“.
This class (class) provides a function called „setThrottle“ that is called as an argument by using a number (int) and that does not return anything (void).

===Classes are Data-types===

We can use our „Motor“ - class the same way we are using other data - types (int, long, float).
The following lines use that quality in order to implement two motors:

''Motor leftMotor; // declare an object of the type „Motor“ called „leftMotor“
Motor rightMotor; // declare another object of the type „Motor“ called „rightMotor“
''

===Calling inner functions of a class (Methods)===

Imagine we want to drive the left motor with full throttle whereas the right motor should stop completely.
This can be expressed as follows:

''// the objetcs name „leftMotor“ and the herein implemented function „setThrottle“ are separated by a dot.
leftMotor.setThrottle(255);
rightMotor.setThrottle(0);
''

A positive side effect: your program gains readability by picking distinct names for your Objects and Methods.

===Classes can contain other variables that can only be accessed „internally“===

How do the Objects „leftMotor“ and „rightMotor“ know which pins they want to switch on and off?

Until now our „Motor“ class is quite abstract since it does not contain this information.
A class that should conduct practical actions needs further variables (concrete pin numbers) and lines of code that describe what to do exactly.
We can simply include both things in the class definition:

''
class MotoMamaMotor {
...
private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; // c
int reversePin;
int throttlePin;
...
};
''

How do we include the pin numbers into the Object if they are not visible from the outside?
We simply write a „setup“ Function for the class:

''
class MotoMamaMotor {
private:
...
public: // we want the setup-function to be accessible from the outside.
void setup (int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}
...
};
''

==A complete example ==

In order to construct a complete example we only have to include the „speed“-Function (see description above):

''
// Defining a class for motor control

class MotoMamaMotor {

private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; //Every MotoMamaMotor type Object has its own forwardPin
int reversePin;
int throttlePin;

public: // the following qualities and methods are visible from the outside.
// This setup-Function has to be called before using the motor control
void setup(int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}

// this Function allows to control the motor speed
void setThrottle (int newThrottle){
if (newThrottle>0){ // should it spin forwards or backwards?
// spin forwards
digitalWrite(reversePin,LOW);
digitalWrite(forwardPin,HIGH);
}else{
// spin backwards
digitalWrite(forwardPin,LOW);
digitalWrite(reversePin,HIGH);
}
// adjust the speed:
analogWrite(throttlePin, newThrottle);
}
};

// create two separate MotoMamaMotor type Objects (leftMotor, rightMotor). They can be used as normal variables.
MotoMamaMotor leftMotor;
MotoMamaMotor rightMotor;

void setup(){ // this is our „main“ setup Function
leftMotor.setup(3,4,5); // assign the pin numbers for each motor in the setup Function: setup(int newForwardPin, int newReversePin, int newThrottlePin)
rightMotor.setup(6,7,8);
};

void loop(){ // this is our „main“ loop Function where concrete actions are executed. For example:
// Start backwards, slow down and accelerate forwards
for (int i =-255, i<=255;i++){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
// Start forwards, slow down and accelerate backwards
for (int i =255, i>=-255;i--){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
};
''

==Organizing classes in separate files==

We can improve our program structure by putting classes in separate files.

1)
Click on the arrow in the right corner in order to add a new file.
Select „new Tab“.

----BILD----

2)
Enter a filename at the bottom of the window.
It must end with .h !
In our case I suggest the name motorControl.h.

3)
Enter the first line:

''
#include „Arduino.h“
''

This line „links“ the file to the Arduino-specific features.
Now we can include the code of our class.

4)
Go back to your main file.
Now you have to „link“ the new file to your main file in order to use the features of our class.
Include the following line in the top of your main file

''
#include „MotorControl.h“
''

and write the rest of your program as usual.

==More details on the concept==

Classes can build up on each other (inheritance)

In the beginning we promised that it is possible to replace different motor drivers without changing the rest of the program.
Classes can indeed include other Objects in the form of „member variables“.

C++ allows class declarations and the code for included Functions to be be placed in different files.
If you want to know more about that you can read this article about creating libraries in Arduino: [http://arduino.cc/en/Hacking/LibraryTutorial http://arduino.cc/en/Hacking/LibraryTutorial ]

File:OOPARD2.jpg

2017-03-28T11:12:45Z

Veja6203: Veja6203 uploaded a new version of File:OOPARD2.jpg

File uploaded with MsUpload

GMU:Functions and Classes (Arduino)

2017-03-28T11:09:05Z

Veja6203: /* Example: Controlling Motors */

==Motivation==

Soon after starting to write the program for your robot you will encounter some typical problems:

* clarity: the bigger the program gets the harder it is to keep the general overview
* decoupling: you only want to change a certain part of the program without influencing all the rest
* recyclability: there are several similar parts in your robot for which you would like to reuse particular sections of your code

These problems reach back to the beginning of programming and their solution is an art and a science at the same time.
It generally helps a lot to separate your program into single subunits that are relatively independent from each other.

==Example: Controlling Motors==

The [http://arduino.cc/de/Reference/FunctionDeclaration function] is an enormous useful tool that can help you structuring your code. Functions allow you to sum up several operations under the same command. This command can be called again and again without knowing about or duplicating the included code.

Here is an example for a function for setting the speed of a motor that is connected to an H-bridge:

[[File:OOPARD1.jpg]]

[[File:OOPARD2.jpg]]

Now (and for every prospective motor movement) we only need to write one single line in order to for instance setting the left wheels speed:

''setMotorSpeed(speed, leftForwardPin, leftReversePin, leftThrottlePin); // the pin numbers are saved in variables''

This already saves us a lot of typing –
But one thing still seems quite laborious: we have to know the exact pin numbers every time we want to change the speed.

Imagine a program in which similar function calls are distributed all over.
In case of a hardware update you would have to find every single function call and change the parameters manually.
This effort could surely be spent for more useful things..

It would be ideal to find a way of calling a certain function that only offers the most useful parameters (like setting the speed) and which handles technical details (switching pins on and off) internally.

==Possible solution: Data and code in one package „Classes“ and „Objects“==

C++ (and also Arduino) provides a specific feature that can solve our problem: Classes and Objects

A Class predefines common qualities of a group of Objects.
It for instance determines that every motor has the possibility to exert a certain amount of throttle.
The corresponding program could look like this:

''class Motor{
public: // the following qualities and methods are visible from the outside.
void setThrottle(int newThrottle); // every motor has the possibility to exert trottle.
}''

Now the computer knows that there is a class called „Motor“.
This class (class) provides a function called „setThrottle“ that is called as an argument by using a number (int) and that does not return anything (void).

===Classes are Data-types===

We can use our „Motor“ - class the same way we are using other data - types (int, long, float).
The following lines use that quality in order to implement two motors:

''Motor leftMotor; // declare an object of the type „Motor“ called „leftMotor“
Motor rightMotor; // declare another object of the type „Motor“ called „rightMotor“
''

===Calling inner functions of a class (Methods)===

Imagine we want to drive the left motor with full throttle whereas the right motor should stop completely.
This can be expressed as follows:

''// the objetcs name „leftMotor“ and the herein implemented function „setThrottle“ are separated by a dot.
leftMotor.setThrottle(255);
rightMotor.setThrottle(0);
''

A positive side effect: your program gains readability by picking distinct names for your Objects and Methods.

===Classes can contain other variables that can only be accessed „internally“===

How do the Objects „leftMotor“ and „rightMotor“ know which pins they want to switch on and off?

Until now our „Motor“ class is quite abstract since it does not contain this information.
A class that should conduct practical actions needs further variables (concrete pin numbers) and lines of code that describe what to do exactly.
We can simply include both things in the class definition:

''
class MotoMamaMotor {
...
private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; // c
int reversePin;
int throttlePin;
...
};
''

How do we include the pin numbers into the Object if they are not visible from the outside?
We simply write a „setup“ Function for the class:

''
class MotoMamaMotor {
private:
...
public: // we want the setup-function to be accessible from the outside.
void setup (int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}
...
};
''

==A complete example ==

In order to construct a complete example we only have to include the „speed“-Function (see description above):

''
// Defining a class for motor control

class MotoMamaMotor {

private: // the following definitions are only of „internal use“ for the class itself
int forwardPin; //Every MotoMamaMotor type Object has its own forwardPin
int reversePin;
int throttlePin;

public: // the following qualities and methods are visible from the outside.
// This setup-Function has to be called before using the motor control
void setup(int newForwardPin, int newReversePin, int newThrottlePin){
// we remember the pins for future use
forwardPin=newForwardPin;
reversePin=newReversePin;
throttlePin=newThrottlePin;
// and at the same time we initialize the outputs !
digitalWrite(throttlePin,LOW); // so that the motors don’t spin directly from the beginning ..
pinMode(forwardPin,OUTPUT);
pinMode(reversePin,OUTPUT);
pinMode(throttlePin,OUTPUT);
}

// this Function allows to control the motor speed
void setThrottle (int newThrottle){
if (newThrottle>0){ // should it spin forwards or backwards?
// spin forwards
digitalWrite(reversePin,LOW);
digitalWrite(forwardPin,HIGH);
}else{
// spin backwards
digitalWrite(forwardPin,LOW);
digitalWrite(reversePin,HIGH);
}
// adjust the speed:
analogWrite(throttlePin, newThrottle);
}
};

// create two separate MotoMamaMotor type Objects (leftMotor, rightMotor). They can be used as normal variables.
MotoMamaMotor leftMotor;
MotoMamaMotor rightMotor;

void setup(){ // this is our „main“ setup Function
leftMotor.setup(3,4,5); // assign the pin numbers for each motor in the setup Function: setup(int newForwardPin, int newReversePin, int newThrottlePin)
rightMotor.setup(6,7,8);
};

void loop(){ // this is our „main“ loop Function where concrete actions are executed. For example:
// Start backwards, slow down and accelerate forwards
for (int i =-255, i<=255;i++){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
// Start forwards, slow down and accelerate backwards
for (int i =255, i>=-255;i--){
leftMotor.setThrottle(i);
rightMotor.setThrottle(i);
};
};
''

==Organizing classes in separate files==

We can improve our program structure by putting classes in separate files.

1)
Click on the arrow in the right corner in order to add a new file.
Select „new Tab“.

----BILD----

2)
Enter a filename at the bottom of the window.
It must end with .h !
In our case I suggest the name motorControl.h.

3)
Enter the first line:

''
#include „Arduino.h“
''

This line „links“ the file to the Arduino-specific features.
Now we can include the code of our class.

4)
Go back to your main file.
Now you have to „link“ the new file to your main file in order to use the features of our class.
Include the following line in the top of your main file

''
#include „MotorControl.h“
''

and write the rest of your program as usual.

==More details on the concept==

Classes can build up on each other (inheritance)

In the beginning we promised that it is possible to replace different motor drivers without changing the rest of the program.
Classes can indeed include other Objects in the form of „member variables“.

C++ allows class declarations and the code for included Functions to be be placed in different files.
If you want to know more about that you can read this article about creating libraries in Arduino: [http://arduino.cc/en/Hacking/LibraryTutorial http://arduino.cc/en/Hacking/LibraryTutorial ]

File:OOPARD2.jpg

2017-03-28T11:09:03Z

Veja6203: File uploaded with MsUpload

File uploaded with MsUpload