Tag: tutorial

Software Souls cloned/clonado

cloning! results may vary

cloning! results may vary

I will renew this domain and hosting until 2015 but if something fails the clone is already created.

I have exported this site and imported it at http://softwaresouls2.blogspot.com.es because I will not keep paying any hosting service.

He exportado este sitio y lo he importado en http://softwaresouls2.blogspot.com.es porque no seguiré pagando alojamiento web.

Renovaré el dominio y el alojamiento hasta 2015, pero si algo falla el clon ya está creado.

 

Photos/Fotos:

http://softwaresouls.com/piwigotest/

 

Videos:

www.youtube.com/siempreaprendiendo

 

Software utilities and code examples:

https://app.box.com/s/4hru0gwduus712s93f6a

(III) ¿Cómo empezar a construir y programar robots?

This entry is part 3 of 3 in the series (ES) Creando robots

Herramientas de programación de Arduino, Mindstorms y Bioloid

Tanto Lego Mindstorms como Bioloid de Robotis incluyen herramientas de programación gráfica (se utilizan iconos en lugar de únicamente escribir texto) y Arduino utiliza un editor de texto para los programas. Todos ellos permiten crear el ejecutable y enviarlo al controlador.

Entorno Arduino:

Además del entorno de programación donde editar los programas Arduino ofrece un conjunto de librerías que facilitan mucho la utilización de sensores, servos y otros dispositivos. Muchas de estas librerías para modelos de sensores concretos o servos  ya vienen incorporadas, otras se han de incluir manualmente.

En el editor se escribe el programa utilizando C o C++ (dos potentes, flexibles y muy utilizados lenguajes estándares, especialmente en robótica). El entorno de Arduino, tras unas pequeñas transformaciones, lo compila utilizando el compilador avr-gcc o avr-g++, generando el ejecutable que enviaremos al microcontrolador.

Todo lo que aprendemos de C y/o C++ nos será muy útil, pues se puede utilizar con todos los kits, robots, sistemas operativos y computadores. Y estaresmos, además, aprendiendo la forma de trabajar y herramientas habituales en programación.
ArduinoIDE

Lego Mindstorms NXT-G:

Es ideal para familiarizarse con Mindstorms y para pequeños programas, así como para las primeras pruebas que realicemos con un sensor u otro dispositivo nuevo.

Pero es exclusiva para Mindstorms, bastante fácil de utilizar para programas sencillos, pero, a medida que queramos desarrollar programas con un poco de complejidad, iremos descubriendo problemas y limitaciones (búsquedas en el programa, organizar modularmente, depuración de errores, guardar versiones y poderlas comparar)
NXT-G_EV3

Robotis Roboplus Tasks: (la ayuda, de momento, sólo está en inglés)

Se puede decir exactamente lo mismo que para Mindstorms NXT-G: Fácil de utilizar e ideal para empezar o para programas pequeños y pruebas, pero exclusiva para robots de (en este caso) Robotis. Adoleciendo de los mismos defectos, si queremos realizar programas con un mínimo de complejidad nos encontraremos con los mismos problemas.

Sólo añadiría que mi impresión es que está pensada para escribir pequeños programas que recojan los comandos mandados por el telemando y ejecuten las secuencias de movimiento creadas con Roboplus Motion (la otra utilidad básica de Robotis).
RoboplusTaks

¿A qué me refiero con un poco más de complejidad?

Retomando la propuesta de comportamiento del primer artículo de la serie podemos ver una progresión de menos a más complejidad, de forma progresiva.

El típico vehículo que hacemos que evite obstáculos mediante dos sensores de contacto (ultrasonidos o infrarojos), uno a la derecha y otro a la izquierda.

1.- El programa más sencillo simplemente evita los obstáculos girando unos pocos grados a la izquierda cuando detecte una “colisión” en el sensor derecho, y a la izquierda cuando la detecte en el sensor derecho.

2.- Intentar evitar el obstáculo con las mínimas maniobras posibles, dando el mínimo rodeo,  para seguir el rumbo previo.

Pero si el robot se nos acaba situando en un rincón o en un “callejón sin salida” (ha de girar 180 grados o salir marcha atrás) lo más probable es que nunca logre salir por sus propios medios de ahí, ya que irá de “rebotando” del lado izquierdo al derecho y viceversa hasta que se le agoten las baterías…

3.- Añadimos un poco de “inteligencia” y complejidad. En lugar de girar siempre unos determinados grados fijos vamos a hacer que cuando detecte cierta cantidad de colisiones seguidas (en determinada cantidad de milisegundos o segundos) aumente el número de grados que girará, para así acabar consiguiendo que salga del rincón o del “callejón”.

4.- Ahora el problema es que tras salir del rincón o del “callejón” cuando detecte un obstáculo va a girar mucho más de lo necesario. Pues igual que se lo dimos, grados de más a girar, se lo quitamos; a medida que pasan determinados milisegundos o segundos sin detectar colisiones iremos disminuyendo los grados a girar hasta que lleguen al valor inicial.

Realmente sólo estamos utilizando dos sensores de contacto, medición del tiempo y contador de colisiones, pero ya no es ese sencillo programa inicial.

5.- Otro grado de complejidad, o probablemente más de un grado, sería añadir un sensor de luz que hiciera al robot tender hacia la fuente de luz más intensa, evitando los obtáculos del camino, claro.

A partir de este nivel de complejidad creo que utilizar la herramientas NXT-G o Roboplus Tasks requiere más esfuerzo y nos aparecerán más problemas que utilizando lenguajes estándares como Java, C o C++, así como sus herramientas asociadas.

Creo que una buena continuación serían estos artículos de introducción a la programación

(II) ¿Cómo empezar a construir y programar robots?

This entry is part 2 of 3 in the series (ES) Creando robots

Resumen del anterior artículo

Antes de empezar con la programación resumamos las conclusiones del anterior artículo:

1.- Los conocimientos mínimos para empezar a construir un robot los tiene prácticamente todo el mundo o se pueden conseguir muy fácilmente:

+ electrónica o electricidad (aunque sólo sea saber distinguir voltaje e intensidad),

+mecánica (lo mínimo sería atornillar y destornillar o conectar piezas tipo Lego)

+informática (saber ejecutar un programa en un ordenador)

2.- Un kit basado en Arduino, Lego Mindstorms o Bioloid de Robotis es la forma más fácil, divertida y educativa de empezar.

¿Arduino, Mindstorms o Bioloid?

¿Por dónde queremos empezar y qué kit nos lo ofrece?

– Si queremos construir robots articulados que caminen con dos, cuatro o seis patas Bioloid es ideal, especialmente si además queremos centrarnos en programación.

– Si lo que queremos es construir distintos vehículos con ruedas o cadenas, utilizando distintos sensores para percibir el mundo, Lego Mindstorms es la mejor opción.

– Y si queremos centrarnos en la electrónica y/o programación sin gastar demasiado dinero Arduino o un kit basado en Arduino es nuestra mejor opción.

Empecemos por el kit más barato, kit Arduino. Porque, además, lo que aprenderemos con él nos servirá también para otros kits, especial, aunque no únicamente, respecto programación en C y C++.

Kit con base Arduino

Controlador Arduino

Controlador Arduino

Arduino, explicado de forma sencilla, es un controlador programable de sensores y motores, que

Arduino robot

Robot Arduino 66€

podemos utilizar como “cerebro” de un robot. Podemos empezar consiguiendo un controlador Arduino y posteriormente el resto de elementos.

O bien, conseguir el controlador con un kit que incluya ya todos los elementos necesarios para construir un vehículo robot. Con el kit nos aseguramos que motores, sensores y piezas de la

Robot arduino 40€

Robot arduino 40€

estructura encajarán y se conectarán correctamente, probablemente también nos resulte más barato. En cualquiera de ambos casos terminaremos programando el microcontrolador que incorpora Arduino. Pero Arduino no es sólo hardware, es también un conjunto de utilidades que nos facilitarán muchísimo el trabajo de programar. Y existe además una comunidad muy activa de usuarios donde podremos participar recibiendo y dando ayuda a otras personas.

Guía, ejemplos y manual

Existe bastante documentación en castellano, aquí la referencia a las principales sentencias y funciones y este fantástico manual en castellano creado por Ardumanía. Pero aún hay más:

Conceptos básicos y ejemplos

Guía de instalación y ejecución de primer ejemplo para Windows

Bien, ¿y cómo es en programa sencillo con el lenguaje de programación C?, así se hace parpaderar un LED:

/*
   Parpadeo
   Enciende durante un segundo un LED,y lo apaga durante otro segundo, así continuamente
  */

 // Pin 13 está conectado a un LED en la mayoría de Arduinos
 // asignamos en número de conector pin a la variable led:
 int led = 13;

 // la función setup se ejecuta una sola vez cuando pulsas reset
 void setup() {
   // inicializ el conector pin digital como salida.
   pinMode(led, OUTPUT);
 }

 // la función loop (bucle) se ejecuta una vez tras otra contínuamente
 void loop() {
   digitalWrite(led, HIGH);   // enciende LED (HIGH es nivel alto de voltaje)
   delay(1000);               // espera un segundo
   digitalWrite(led, LOW);    // apaga el LED bajando el voltaje; LOW, significa bajo
   delay(1000);               // espera un segundo
 }

¿Y C++? ¿Y las herramientas de programación que incluyen Robotis, RoboPlus Taks, y Lego Mindstorms, NXT-G? También, pero ya será en el siguiente artículo…

¿Cómo empezar a construir y programar robots?

This entry is part 1 of 3 in the series (ES) Creando robots
Honda Asimo

Honda Asimo

Introducción

Crear robots requiere una gran cantidad de conocimientos distintos y, dependiendo de lo sofisticado que sea el comportamiento o tareas que ha de realizar, puede ser realmente complejo y extremadamente difícil.

Los tres pilares fundamentales de la robótica son la electrónica, la mecánica y la informática; tiene otros, pero con estos tres ya podemos empezar a experimentar.

Además de conocimiento aplicable también necesitamos algunos elementos de los que partir, como motores (u otros actuadores), sensores, una computadora de pequeño tamaño, para evitar peso y consumo eléctrico, (habitualmente una SBC o microcontrolador) y una fuente de energía (batería para que sea autónomo) y algunas piezas que sustenten y mantengan unidos a todos estos elementos en sus movimientos y desplazamientos.

Estos elementos los podemos adquirir (algunos incluso fabricar)  por separado o, para facilitar la entrada a la róbótica, también los podemos adquirir de forma conjunta, como un kit.

Comparte en este foro tus dudas y comentarios

¿Qué necesito para empezar?

Sobre todo, ganas de disfrutar creando y aprendiendo.

* Adquirir unos mínimos y básicos conocimientos de:

+ electrónica o electricidad (aunque sólo sea saber distinguir voltaje e intensidad),

+mecánica (lo mínimo sería atornillar y destornillar o conectar piezas tipo Lego)

+informática (saber ejecutar un programa en un ordenador)

* Conseguir, al menos, microcontrolador (Arduino, por ejemplo), un par de motores, un sensor de distancias, unas pilas, cables y una estructura que lo soporte. El conjunto o kit básico.

Un kit, la mejor opción

Una clara ventaja de empezar con un kit es que puedes empezar YA y dedicarte a la parte fundamental (electrónica, mecánica o informática) que más te interese, porque las demás las tienes ya solucionadas; aunque en cualquier momento puedes ponerte a trabajar en cualquiera de las otras partes. Al comprar el kit, con todo el conjunto de elementos necesarios juntos, el precio además suele ser más barato.

Del más caro y complejo al más barato y sencillo

bioloid_bio_img01Bioloid: 18 potentes servomotores, 4 sensores. Ideal para humanoides, cuadrúpedos, hexápodos e incluso vehículos, y crearles software para que se comporten como seres vivos. Incluye software de programación Roboplus Tasks, también se puede programar en C, y de creación de movimientos Roboplus Motion.

Tiene un precio de unos 1000 euros. Sí, resulta algo caro, pero si dispones del dinero y de suficientes conocimientos de programación o ganas de aprender, creo que lo merece.

NXT Acer Explorer con Acer

NXT Acer Explorer con Acer

Mindstorms: 2 servomotores, 1 motor, 4 sensores. Ideal para mecanismos y vehículos. Muy fácil de utilizar, pero también permite crear robots complejos. Incluye software de programacion NXT-G. Mindstorms NXT es posible programarlo también en Java con Lejos y C/C++ con Osek, pero aún no están disponibles para el nuevo Mindstorms EV3 o son versiones muy preliminares.

Tiene un precio de unos 300 euros, aunque pueda parecer caro frente a otras opciones, su enorme potencial y flexibilidad en todos los aspectos (de construcción, programación y de ampliar su electrónica) lo hacen enormemente interesante.

 

Arduino robot

Robot Arduino

Vehículo basado en Arduino: 2 motores más controlador, o 2 servomotores, y los sensores con los que desees empezar. Es el más sencillo y barato, por unos 4060 euros puedes tener lo mínimo. Ideal para profundizar en electrónica.

Se puede programar con el amigable entorno de programación Arduino.

Es el que tiene un precio más barato y que además lo puedes ir comprando por partes, a medida que vayas necesitándolas. No ofrece tanta flexibilidad como Mindstorms ni capacidad para crear robots articulados como Bioloid, pero realmente se puede aprender mucho más de lo que pueda parecer.

.

¿Y con menos dinero o sin dinero?

Por menos dinero puedes conseguir un microcontrolador tipo Arduino o sus clones, que cuestan poco más de 20 euros.

O, de forma totalmente gratuita, puedes empezar a aprender a programar en C o C++, que será muy útil para luego darle vida al robot.

¿Con qué robot empezar?

Un sencillo vehículo de dos ruedas tractoras y una libre es un buen punto de partida con el que empezar a divertirse aprendiendo.

A modo de sugerencia de un programa sencillo y cómo ir añadiéndole una mínima complejidad de comportamiento. Se puede hacer de muchísimas formas:

El típico vehículo que hacemos que evite obstáculos mediante dos sensores de contacto, uno a la derecha y otro a la izquierda.

1.- El programa más sencillo simplemente evita los obstáculos girando unos pocos grados a la izquierda cuando detecte una “colisión” en el sensor derecho, y a la izquierda cuando la detecte en el sensor derecho.

2.- Se intenta evitar el obstáculo con las mínimas maniobras posibles para seguir el rumbo establecido.

Pero si el robot se nos acaba situando en un rincón o en un “callejón sin salida” (ha de girar 180 grados o salir marcha atrás) lo más probable es que nunca logre salir por sus propios medios de ahí, ya que irá de “rebotando” del lado izquierdo al derecho y viceversa hasta que se le agoten las baterías…

3.- Añadimos un poco de “inteligencia” y complejidad. En lugar de girar siempre unos determinados grados fijos vamos a hacer que cuando detecte cierta cantidad de colisiones seguidas (en determinada cantidad de milisegundos o segundos) aumente el número de grados que girará, para así acabar consiguiendo que salga del rincón o del “callejón”.

4.- Ahora el problema es que tras salir del rincón o del “callejón” cuando detecte un obstáculo va a girar mucho más de lo necesario. Pues igual que se lo dimos, grados de más a girar, se lo quitamos; a medida que pasan determinados milisegundos o segundos sin detectar colisiones iremos disminuyendo los grados a girar hasta que lleguen al valor inicial.

Realmente sólo estamos utilizando dos sensores de contacto, medición del tiempo y contador de colisiones, pero ya no es ese sencillo programa inicial.

Otro paso sería añadir un sensor de luz que hiciera al robot tender hacia la fuente de luz más intensa, evitando los obtáculos del camino, claro.

Y en el siguiente artículo…

Empezando a programar

Aprendiendo a programar con Bioloid, Mindstorms o robot basado en Arduino.

(I) Reading sensors connected to Robotis CM-510

This entry is part 5 of 5 in the series Bioloid C++ tutorial

cm-510 sensorsUsing the Dynamixel SDK instead of RoboPlus Tasks is not possible to query sensors connected to the CM-5xx controller. But, of course, using standard programming languages, like C++, and tools, line QT Creator or Eclipse, with its full featured IDEs and debuggers is a hugue gain.

So I created a firmware for the CM-510 which can be queried and receive commands to itself, including its sensors, or to Dynamyxel devices.

The idea is very simple:

This program running in the CM-510 receives:

– commands or queries to IDs of Dynamixel devices. These are not processed, only redirected to the Dynamixel bus only if it was received by serial port ( serial cable or zigbee). If it was received from the Dynamixel bus nothing is done.

– commands or queries to the CM-510 ID (I chose ID=200), like beep, or to the sensors connected to it. This commands and queries are processed in the CM-510, basically querying the sensors.

In both cases the answer is sent to the connection from which the query or command was received.

After power on the CM-510, you can select the mode with the 4 cursor keys as showed in a terminal connected to its serial port:

“For ‘Toss mode’ press (Up), for ‘Device mode’ (Down), for ‘Device debug mode’ (Left),to start press (Right)”

In the Device mode:

all the receptions and sends are through the Dynamixel bus, the CM-510 is simply another device.

In the Toss mode:

– what is received from the serial connection is sent to the Dynamixel bus or processed in the CM-510 (If sent to its ID)

-what is received from the Dynamixel bus is sent to the serial connection

Finally, the Debug mode:

is like the Device mode, but all the debug messages included in the CM-510 are sent to the serial connection.

A complete sequence with code snippets from the CM-510 program and from the code running in the other computer:

Some C++ code snippets from this example: (C# in the next post)

enum AX12Address  //and functions implemented in the CM-510 program, like
{
	ReadCM510SensorRaw = 1,
        Beep = 8,
	ReadCM510SensorFiltered = 4,
	SetSensorValuesToFilter = 5,
...
}
void doBeep()
{
    cout << "Beep" << endl;
    mySystem.dynamixelCommunication.sendOrder(100, AXS1_Buzzer, (byte) DO, (short) 500);
    usleep (200000);
    mySystem.dynamixelCommunication.sendOrder(200,MyCommunications::Beep short)5);
}

Querying sensor:

void doQuerySensor()
{
    int sensorPort=getSensorPort();
    int value=mySystem.dynamixelCommunication.readSensorValue (200,ReadCM510SensorRaw, sensorPort);
   cout << "the sensor reads: [" << value << "] " << endl << endl << endl;
}

These command and query are processed in the CM-510:

Getting the sensor value:


int executeCM510Function()
{
...
		case F_GET_SENSOR_VALUE_RAW:
			values[1] = getSensorValueRaw(parameters[1]);
			break;

		case F_GET_SENSOR_VALUE_FILTERED:
			values[1] = getSensorValueFiltered(parameters[1], sensorValuesToFilterDefined);
			break;

		case F_GET_TWO_DMS_SENSOR_VALUES:
			parametersReceived=3;
			getTwoDMSSensorsValues();
			break;

		case F_GET_MULTIPLE_SENSOR_VALUE:
			getMultipleSensorsValues();
			break;

		case F_DO_SENSOR_SCAN: 
			values[1]= sensorScan(parameters[1]);
			break;

		case F_SET_VALUE_DMS1 : //set default value DMS1
			DMS1=parameters[1];
			break;

		case F_SET_VALUE_DMS2 : //set default value DMS1
			DMS2=parameters[1];
			break;

		case F_BEEP:
			if (debugMode)
				printf("executeCM510Function beep\n");
			beep();
			break;

		case F_SET_SENSOR_VALUES_TO_FILTER:
			sensorValuesToFilterDefined=parameters[1];
			break;
	}

	return function;
}

}
...
int getSensorValueRaw(unsigned char portId)
{
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1);

		setPort(portId);
		//PORTA &= ~0x80;
		//PORTA &= ~0x20;

		//_delay_us(12);				// Short Delay for rising sensor signal
		_delay_us(24);
		ADCSRA |= (1 << ADIF);		// AD-Conversion Interrupt Flag Clear
		ADCSRA |= (1 << ADSC);		// AD-Conversion Start

		while( !(ADCSRA & (1 << ADIF)) );	// Wait until AD-Conversion complete

		PORTA = 0xFC;				// IR-LED Off

		//printf( "%d\r\n", ADC); // Print Value on USART

		//_delay_ms(50);
		_delay_ms(ReadSensorDelayMS);

		return ADC;
}

 


void beep()
{
   buzzOn(100);
   buzzOff();
}

But we can do a little more with the CM-510 processor, we can do some filtering to the sensor values.

The readings from the DMS are usually somewhat erratic, so we can simply:

– discard the minimum and maximum values:

– if we take 5 more than measures, then return the average if the are more than 3, if 3 or less it

Previously we should set how many readings should be done, if not, the default number of readings are 5:

int getSensorValueFiltered(unsigned char portId, int times)
{
...
	switch(function)
	{		
		case F_GET_SENSOR_VALUE_RAW:
			values[1] = getSensorValueRaw(parameters[1]);
			break;

		case F_GET_SENSOR_VALUE_FILTERED:
			values[1] = getSensorValueFiltered(parameters[1], sensorValuesToFilterDefined);
			break;

		case F_GET_TWO_DMS_SENSOR_VALUES:
			parametersReceived=3;
			getTwoDMSSensorsValues();
			break;

		case F_GET_MULTIPLE_SENSOR_VALUE:
			getMultipleSensorsValues();
			break;

		case F_DO_SENSOR_SCAN: 
			values[1]= sensorScan(parameters[1]);
			break;

		case F_SET_VALUE_DMS1 : //set default value DMS1
			DMS1=parameters[1];
			break;

		case F_SET_VALUE_DMS2 : //set default value DMS1
			DMS2=parameters[1];
			break;

		case F_BEEP:
			if (debugMode)
				printf("executeCM510Function beep\n");
			beep();
			break;

		case F_SET_SENSOR_VALUES_TO_FILTER:
			sensorValuesToFilterDefined=parameters[1];
			break;
	}
...

We also can take values from multiple sensors with one query, but It will be explained in the next post…

(II) C++ crash examples tutorial using Robotis CM-900 board and IDE (II)

This entry is part 5 of 5 in the series Programming CM-900

In this post I will try to show one important C++ feature, virtual classes as interfaces, defining a rol that several classes can implement. Also

Here you can download the file with the source code.

_2_CM900_CPP_Interfaces


// C++ crash tutorial with Robotis CM-900.

// First example: http://softwaresouls.com/softwaresouls/

/*
Classes inheritance and interface creation in C++
*/

// Abstract class as Interface for communication device classes http://www.cplusplus.com/doc/tutorial/polymorphism/
class CommunicationDevice
{
public:
virtual void setup(int baudrate=0)=0; // baudrate=0, default parameter in case is not passed any parameter.
//...)=0; is a pure virtual method that convert the class in abstract http://www.cplusplus.com/doc/tutorial/polymorphism/
//      because is not straight usable , a derived classimpllementing the pure virtual methods must be created
virtual void send(char *message)=0;   // default parameter in case is not passed any parameter.

virtual void send(int i)=0; //Method overloading http://www.cplusplus.com/doc/tutorial/functions2/ Same method name with different parameter types

};

class Zigbee : public CommunicationDevice //inherits the interface a should define the methos to be able to create objects.
{
public:
void setup(int baudrate=0);
void send (char *message);
void send(int i);
};

class USB : public CommunicationDevice //inherits the interface a should define the methos to be able to create objects.
{
public:
void setup(int baudrate=0);
void send (char *message);
void send(int i);
};

class Debug {
CommunicationDevice &commDevice;
public:
Debug(CommunicationDevice &aCommDevice) : commDevice(aCommDevice) {}; // member object commDevice is instantiated by reference to avoid object copy
void show(char *message)
{
commDevice.send(message); // the "commDevice"  method called depends on the object passed to the constructor
}

void show(int i)
{
commDevice.send(i);
}
};

void Zigbee::setup(int baudrate)
{
if (baudrate==0)
baudrate=57600; //only changes local copy, not the variable passed as value parameter http://www.cplusplus.com/doc/tutorial/functions2/
Serial2.begin(baudrate);
}

void Zigbee::send(char *message)
{
Serial2.println(message);
}

void Zigbee::send(int i)
{
Serial2.println(i);
}

void USB::setup(int baudrate)
{
SerialUSB.begin();
}

void USB::send(char *message)
{
SerialUSB.println(message);
}

void USB::send(int i)
{
SerialUSB.println(i);
}

Zigbee zigbee;
USB usb;

const byte NumberOfCommsDevices=2;
CommunicationDevice *commsDevices[]={&usb, &zigbee};
//={usb, zigbee};

void setup()
{
//  Individually:

//  zigbee.setup();
//  usb.setup();

//  collectively. using the common Interface "CommunicationDevice"
for (int i=0;i<NumberOfCommsDevices;i++) commsDevices[i]->setup();
delay(2000); // waiting for 2 seconds, let the user activate the monitor/console window (Control+Shift+M).
}

int counter=0;
void loop()
{
++counter;
Debug debug1(usb); // Debug constructor accepts any class inhereting the Interface "CommunicationDevice", Debug(CommunicationDevice &aCommDevice)
debug1.show("Hola"); //debug object will call the method "send" implemented in the object passed to the constructor. In this case "usb.send"

//Showing the counter for each iteration until the 2000th iteration
if (counter <=2000)
debug1.show(counter);
else
{
// Showing the counter every 100 iterations and waiting for 2 seconds
if (counter%100==0) // Operator modulo http://www.cplusplus.com/doc/tutorial/operators/ (returns the remainder)
{
debug1.show(counter);
delay(2000);
}
}
}

Arduino C++ examples tutorial using Duemilanove (I)

This entry is part 5 of 5 in the series Cheapest robot (Arduino)

This is the first example in a serie of cheap (absolutely free and cheap) articles to get some basic and practical C++ knowledge. It will references the great explanations provided at www.cplusplus.com C++ tutorial. Using Arduino Duemilanove (well, really it’s a Funduino).

Here you can download The file with the code, and you can find links to a lot of free tutorials, courses and books to learn C++ here.

// C++ crash tutorial with Arduino Duemilanove.

// First example: http://softwaresouls.com/softwaresouls/2013/06/23/c-crash-tutorial-using-robotis-cm-900-board-and-ide-i/

/*
Hello World shows messages on construction and destruction
Also it lets you to salute.
Showing always its assigned identifiction number MyId
*/
class HelloWorld
{
private:
int myId; //Object identification num ber

public:

// class constructor http://www.cplusplus.com/doc/tutorial/classes/
HelloWorld(char *message, byte id)
{
myId=id;
Serial.print(message);
printId();
}

// class destructor http://www.cplusplus.com/doc/tutorial/classes/
~HelloWorld()
{
Serial.print ("Destructing object: ");
printId();
}

void printId()
{
Serial.print(" ID:");
Serial.println(myId);
Serial.println(" ");
}

void Salute(char *name)
{
Serial.print("Hi!, ");
Serial.println(name);
Serial.print("Regards from object: ");
printId();
}
};

/*
void setup() function it's only executed one time at the start of the execution.
It is called from a hidden main() function in the Ronbotis CM-900 IDE core.

\ROBOTIS-v0.9.9\hardware\robotis\cores\robotis\main.cpp
Note: "while (1)" is a forevr loop ( http://www.cplusplus.com/doc/tutorial/control ):

(Basic structure http://www.cplusplus.com/doc/tutorial/program_structure/)

int main(void) {
setup();

while (1) {
loop();
}
return 0;
}
*/
void setup()
{
Serial.begin(57600); //initialize serial USB connection
delay(3000); //We will wait 3 seconds, let the user open (Control+Shift+M) the Monitor serial console
}

//We will not see neither the construction nor the destruction of this global object because serial port it's not still initiated
HelloWorld hw0("construction object", 0); //Object construction http://www.cplusplus.com/doc/tutorial/classes/

// A counter to see progress and launch events
int iterationCounter=0; //An integer variable to count iterations http://www.cplusplus.com/doc/tutorial/variables

// void loop() will be executing the sentences it contains while CM-900 is on.
void loop()
{
// Lets's show only the first 5 iterations http://www.cplusplus.com/doc/tutorial/control/
if (iterationCounter<5)
{
Serial.print("starting iteration #");
Serial.println(++iterationCounter); // firts, iterationCounter is incremented and then printed

// We will see the consttructiona and destruction messages from this local (inside the loop function) object. Object construction http://www.cplusplus.com/doc/tutorial/classes/
HelloWorld hw1("constructing object", 1);
hw1.Salute("Joe");

if (iterationCounter==3)
{
// We will see the consttruction and destruction messages from this local (inside the "if" block inside the "loop" function) object. Objet construction http://www.cplusplus.com/doc/tutorial/classes/
HelloWorld hw2("constructing object", 2);
hw2.Salute("Jones");
} // Objet hw2 destruction http://www.cplusplus.com/doc/tutorial/classes/

//Let's show that object hw0 is alive
hw0.Salute("Pepe");

Serial.print("ending iteration #");
Serial.println(iterationCounter++); // first cpunter is printed, then incremented.
} // Objet hw1 destruction http://www.cplusplus.com/doc/tutorial/classes/
} // Program end. Objet hw0 destruction http://www.cplusplus.com/doc/tutorial/classes/
%d bloggers like this: