Puedes programar el Compluino 03 directamente desde el IDE de Arduino, pero la forma más sencila de hacerlo es usando la librería que hemos escrito para este robot.

En este caso hemos optado por realizar un conjunto de funciones que nos permitan programar el robot, de forma textual, de una forma muy similar al lenguaje natural. A continuación se listan todas las funciones de esta librería. Hemos acompañado un pequeño ejemplo a la descripción de cada función. También puedes examinar los distintos ejemplos que también están incluidos en la propia librería del Compluino 03.

Inicialización

Robot.inicia()

Movimiento

Robot.para()
Robot.avanza()
Robot.retrocede()
Robot.mueve()
Robot.gira_derecha()
Robot.gira_izquierda()
Robot.gira()
Robot.mueve_motor()

Display OLED

Robot.borra_oled()
Robot.escribe_oled()
Robot.escribe_2x_oled()
Robot.escribe_oled_sensor()
Robot.escribe_oled_pot()
Robot.escribe_oled_ldr()
Robot.escribe_oled_pulsador()
Robot.escribe_oled_suelo_d()
Robot.escribe_oled_suelo_i()
Robot.escribe_oled_suelo_dd()
Robot.escribe_oled_suelo_id()
Robot.escribe_oled_distancia()
Robot.escribe_oled_brujula()
Robot.escribe_oled_int()

Altavoz piezoeléctrico

Robot.beep()
Robot.doble_beep()
Robot.enciende_altavoz()
Robot.apaga_altavoz()

Lectura de sensores

Robot.lee_sensor()
Robot.lee_pot()
Robot.lee_ldr()
Robot.lee_pulsador()
Robot.lee_suelo_d()
Robot.lee_suelo_i()
Robot.lee_suelo_dd()
Robot.lee_suelo_id()
Robot.lee_distancia()

Control del pulsador

Robot.espera_pulsador()
Robot.espera_pulsador_mensaje()
Robot.espera_pulsador_soltar()
Robot.estado_pulsador()

Control de los ledes

Robot.enciende()
Robot.apaga()
Robot.brillo_rgb()

Control de la brújula (Compass)

Robot.lee_brujula()

Esperas

Robot.espera_segundos()
Robot.espera_milisegundos()

Servo

Robot.pos_servo()
Robot.lee_pos_servo()

Constantes

Asignación de pines
Referencias a sensores
Notas musicales

Robot.inicia()

Descripción

Inicialización del robot

Sintaxis

Robot.inicia()

Parámetros

No necesita parámetros

Retorna

No retorna nada

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// Estructura de programa mínima para trabajar con Compluino 03
// desde el IDE de Arduino.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
//Aquí iría tu programa
}

----------- Movimiento -----------

Robot.para()

Descripción

Detiene el movimiento del robot

Sintaxis

Robot.para()

Parámetros

No necesita parámetros.

Retorna

No retorna nada.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// Este ejemplo hace que el robot se pare,
// justo después de avanzar durante un segundo.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
Robot.avanza(75);
Robot.espera_segundos(1);
Robot.para();
}

void loop()
{
// No hacemos nada en el bucle principal
}

Volver a Movimiento

Robot.avanza()

Descripción

Mueve el robot en el sentido de avance, a la velocidad indicada

Sintaxis

Robot.avanza(velocidad)

Parámetros

velocidad: velocidad de avance robot en %. El rango de velocidad es de 0% al 100%.

Retorna

No retorna nada

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// Este ejemplo hace que el robot avance al 75% de su velocidad máxima
// de forma indefinida.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
//El robot avanza de forma indefinida al 75% de su velocidad máxima
Robot.avanza(75);
}

void loop()
{
// No hacemos nada en el bucle principal
}

Volver a Movimiento

Robot.retrocede()

Descripción

Mueve el robot en el sentido de retroceso, a la velocidad indicada

Sintaxis

Robot.retrocede(velocidad)

Parámetros

velocidad: velocidad de retroceso robot en %. El rango de velocidad es de 0% al 100%.

Retorna

No retorna nada

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Este ejemplo hace que el robot se mueva de forma alterna,
// hacia adelante y hacia atrás,
// en intervalos de un segundo y al 75% de la velocidad máxima.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
//El robot avanza al 75% de su velocidad máxima, durante un segundo
Robot.avanza(75);
Robot.espera_segundos(1);

//El robot retrocede al 75% de su velocidad máxima, durante un segundo
Robot.retrocede(75);
Robot.espera_segundos(1);
}

Volver a Movimiento

Robot.mueve()

Descripción

Mueve el robot en el sentido de avance o de retroceso.

Sintaxis

Robot.mueve(velocidad)

Parámetros

velocidad: velocidad de movimiento del robot en %. El rango de velocidad es de -100% al 100%. De -100% a 0% se mueve en el sentido de retroceso y de 0% a 100% se mueve en el sentido de avance.

Retorna

No retorna nada

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Este ejemplo hace que el robot se mueva de forma alterna,
// hacia adelante y hacia atrás,
// en intervalos de un segundo y al 75% de la velocidad máxima.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
//El robot avanza al 75% de su velocidad máxima, durante un segundo
Robot.mueve(75);
Robot.espera_segundos(1);

//El robot retrocede al 75% de su velocidad máxima, durante un segundo
Robot.mueve(-75);
Robot.espera_segundos(1);
}

Volver a Movimiento

Robot.gira_derecha()

Descripción

Hace girar el robot hacia la derecha (sentido horario), haciendo avanzar la rueda izquierda y retroceder la rueda derecha.

Sintaxis

Robot.gira_derecha(velocidad)

Parámetros

velocidad: velocidad de giro a la derecha del robot en %. El rango de velocidad es de 0% al 100%.

Retorna

No retorna nada

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// Este ejemplo hace que el robot avance y gire a la derecha de forma repetida,
// si ajustas bien TIEMPO_GIRO (está en ms) podrás conseguir que el robot
// describa un cuadrado

#include <Compluino_03.h>

#define TIEMPO_GIRO 300

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// El robot avanza al 75% de su velocidad máxima durante 1,5 segundos
Robot.avanza(75);
Robot.espera_milisegundos(1500);

// El robot gira a la derecha durante TIEMPO_GIRO milisegundos
Robot.gira_derecha(75);
Robot.espera_milisegundos(TIEMPO_GIRO);
}

Volver a Movimiento

Robot.gira_izquierda()

Descripción

Hace girar el robot hacia la izquierda (sentido anti-horario), haciendo avanzar la rueda derecha y retroceder la rueda izquierda.

Sintaxis

Robot.gira_izquierda(velocidad)

Parámetros

velocidad: velocidad de giro a la izquierda del robot en %. El rango de velocidad es de 0% al 100%.

Retorna

No retorna nada

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// Este ejemplo hace que el robot avance y gire a la izquierda de forma repetida,
// si ajustas bien TIEMPO_GIRO (está en ms) podrás conseguir que el robot
// describa un cuadrado

#include <Compluino_03.h>

#define TIEMPO_GIRO 300

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// El robot avanza de forma indefinida al 75% de su velocidad máxima durante 1,5 segundos
Robot.avanza(75);
Robot.espera_milisegundos(1500);

// El robot gira a la izquierda durante TIEMPO_GIRO milisegundos
Robot.gira_izquierda(75);
Robot.espera_milisegundos(TIEMPO_GIRO);
}

Volver a Movimiento

Robot.gira()

Descripción

Hace girar el robot hacia la derecha o la izquierda, usando ambas ruedas: avanzando la rueda izquierda y retrocediendo la rueda derecha para girar a la derecha (sentido horario) y avanzando la rueda derecha y retrocediendo la rueda izquierda para girar a la izquierda (sentido anti-horario).

Sintaxis

Robot.gira(velocidad)

Parámetros

velocidad: velocidad de giro del robot en %. El rango de velocidad es de -100% al 100%. De -100% a 0% gira hacia la derecha (sentido horario) y de 0% a 100% gira hacia la izquierda (sentido anti-horario).

Retorna

No retorna nada

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// Este ejemplo hace que el robot gire a la derecha y a la izquierda de forma alterna.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// El robot gira a la derecha durante dos segundos
Robot.gira(-75);
Robot.espera_segundos(2);

// El robot gira a la izquierda durante dos segundos
Robot.gira(75);
Robot.espera_segundos(2);
}

Volver a Movimiento

Robot.mueve_motor()

Descripción

Esta función permite controlar la velocidad y sentido de giro de cada motor del robot de forma independiente.

Sintaxis

Robot.mueve_motor(motor, velocidad)

Parámetros

motor: indica el motor a mover. PIN_MOTOR_D, para el motor de la derecha del robot y PIN_MOTOR_I para el motor de la izquierda del robot.

velocidad: velocidad de movimiento del motor en %. El rango de velocidad es de -100% al 100%. De -100% a 0% se mueve en el sentido de retroceso y de 0% a 100% se mueve en el sentido de avance.

Retorna

No retorna nada

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// Este ejemplo hace que el robot avance moviendo de forma alterna e independiente cada uno de los motores.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// El robot avanza el motor derecho, al 75% de su velocidad máxima, durante medio segundo
Robot.mueve_motor(PIN_MOTOR_D, 75);
Robot.espera_milisegundos(500);

// El robot avanza el motor izquierdo, al 75% de su velocidad máxima, durante medio segundo
Robot.mueve_motor(PIN_MOTOR_I, 75);
Robot.espera_milisegundos(500);
}

Volver a Movimiento

----------- Display OLED -----------

Compluino 03 incluye un display OLED gráfico monocromo de 0,96" de tamaño (diagonal). La resolución es de 128 x 64 pixels, siendo la coordenada (0,0) la esquina superior izquierda, y la coordenada (127,63) la esquina inferior derecha.

Este display usa el driver SSD1306, que controlamos mediante la librería U8g2. Esta librería es muy amplia (soporta un montón de dispositivos) y además tiene dos modos de trabajo:

U8g2 - Funciones para escritura de gráficos y texto.
U8x8 - Funciones para escritura de texto.

En las funciones de la librería del Compluino 03 hemos implementado U8x8, ya que son funciones que usan menos memoria y, por tanto, reducen el tiempo de descarga del programa al robot.

Robot.borra_oled()

Descripción

Borra el display OLED del robot

Sintaxis

Robot.borra_oled()

Parámetros

No necesita parámetros

Retorna

No retorna nada

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// Este ejemplo muestra y borra un mensaje en el centro de la pantalla del
// robot después de la secuencia de inicialización.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();

// El robot nos saluda durante dos segundos
// después borra el display OLED
Robot.escribe_2x_oled(6, 4, "Hola");
Robot.espera_segundos(2);
Robot.borra_oled();
}

void loop()
{
// No hacemos nada en el bucle principal
}

Robot.escribe_oled()

Descripción

Escribe en el display OLED del robot. En este modo el display del robot actúa como una cuadrícula de 16 columnas y 8 filas. Siendo la posición (0,0) la esquina superior izquierda y la (15,7) la esquina inferior derecha.

Sintaxis

Robot.escribe_oled(xpos, ypos, "texto")

Parámetros

xpos: [0..15] posición en la coordenada x del display.

ypos: [0..7] posición en la coordenada y del display.

texto: texto a mostrar en el display a partir de las coordenadas (xpos,ypos).

Retorna

No retorna nada

Ejemplo

En el siguiente ejemplo mostramos los números del 1 al 4 en cada una de las esquinas del display OLED usando el tamaño normal de texto. Con este tamaño de texto podemos visualizar una gran cantidad de información en el display del robot.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Este ejemplo muestra los números del 1 al 4
// en cada una de las cuatro esquinas del display del robot.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();

// Escribe los números del 1 al 4
// en cada una de las cuatro esquinas del display del robot.
Robot.escribe_oled(0, 0, "1");
Robot.escribe_oled(15, 0, "2");
Robot.escribe_oled(0, 7, "3");
Robot.escribe_oled(15, 7, "4");
}

void loop()
{
// No hacemos nada en el bucle principal
}

Robot.escribe_2x_oled()

Descripción

Escribe en el display OLED del robot, con caracteres de tamaño grande. En este modo el display del robot actúa como una cuadrícula de 15 columnas y 7 filas. Siendo la posición (0,0) la esquina superior izquierda y la (14,6) la esquina inferior derecha.

Sintaxis

Robot.escribe_2x_oled(xpos, ypos, "texto")

Parámetros

xpos: [0..14] posición en la coordenada x del display.

ypos: [0..6] posición en la coordenada y del display.

texto: texto a mostrar en el display a partir de las coordenadas (xpos,ypos).

Retorna

No retorna nada.

Ejemplo

En el siguiente ejemplo mostramos los números del 1 al 4 en cada una de las esquinas del display OLED usando el tamaño grande de texto. Es de notar que en este modo de texto el posicionamiento x e y sigue teniendo el mismo espaciado que en el modo normal. Esto es por que se trata de un display gráfico y el posicionamiento del texto no está sujeto al tamaño del caracter, por lo que se recomienda dejar una posición libre entre cada caracter.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// Este ejemplo muestra los números del 1 al 4
// en cada una de las cuatro esquinas del display del robot
// usando texto de tamaño grande.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();

// Escribe los números del 1 al 4
// en cada una de las cuatro esquinas del display del robot
// usando texto grande
Robot.escribe_2x_oled(0, 0, "1");
Robot.escribe_2x_oled(14, 0, "2");
Robot.escribe_2x_oled(0, 6, "3");
Robot.escribe_2x_oled(14, 6, "4");
}

void loop()
{
// No hacemos nada en el bucle principal
}

Robot.escribe_oled_sensor()

Descripción

Función genérica que nos permite mostrar en la pantalla OLED la información de cualquiera de los sensores del robot. La función es la misma con independencia del tipo de lectura (analógica, digital, anchura de pulso o comunicación I2C) que proporcione cada sensor.

Sintaxis

Robot.escribe_oled_sensor(xpos, ypos, font, ref_sensor)

Parámetros

xpos: posición en la coordenada x del display.

ypos: posición en la coordenada y del display.

font tamaño de letra:

T_NORMAL - Tamaño de letra normal
T_GRANDE - Tamaño de letra grande

ref_sensor referencia del sensor a medir:

REF_POT - Referencia al potenciómetro
REF_LDR - Referencia al sensor de luz LDR
REF_PULSADOR - Referencia al pulsador de usuario
REF_SUELO_D - Referencia al sensor reflexivo de suelo derecho en analógico
REF_SUELO_I - Referencia al sensor reflexivo de suelo izquierdo en analógico
REF_SUELO_DD - Referencia al sensor reflexivo de suelo derecho en digital
REF_SUELO_ID - Referencia al sensor reflexivo de suelo izquierdo en digital
REF_DISTANCIA - Referencia al sensor de distancias HC-SR04
REF_BRUJULA - Referencia al sensor de orientación HMC5883L (brújula electrónica)

Retorna

El valor medido en el sensor referenciado.

Ejemplo

El siguiente programa de ejemplo muestra en la pantalla OLED la información de varios de los sensores del robot. En la primera línea, en el centro, tenemos la medida del sensor de distancias (HC-SR04). En la segunda y tercera línea se visualiza la lectura de los sensores reflexivos de suelo, en la segunda de forma analógica y en la tercera de forma digital (el robot está sobre una superficie blanca). En la cuarta línea tenemos a la izquierda la lectura del sensor de luz (LDR) y a la derecha la lectura del potenciómetro. En la última línea, en el centro, se muestra el estado del pulsador de usuario.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// Visualiza en la pantalla OLED la información de varios de
// los sensores del robot.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// Visualiza en la pantalla OLED la información de todos
// los sensores del robot.
Robot.escribe_oled_sensor(6,0, T_NORMAL, REF_DISTANCIA);
Robot.escribe_oled_sensor(0,1, T_NORMAL, REF_SUELO_I);
Robot.escribe_oled_sensor(13,1, T_NORMAL, REF_SUELO_D);
Robot.escribe_oled_sensor(0,3, T_NORMAL, REF_SUELO_ID);
Robot.escribe_oled_sensor(10,3, T_NORMAL, REF_SUELO_DD);
Robot.escribe_oled_sensor(0,5, T_NORMAL, REF_LDR);
Robot.escribe_oled_sensor(13,5, T_NORMAL, REF_POT);
Robot.escribe_oled_sensor(5,7, T_NORMAL, REF_PULSADOR);
}

Robot.escribe_oled_pot()

Descripción

Escribe en el display OLED del robot la lectura del potenciómetro normalizada a los valores min y max.

Sintaxis

Robot.escribe_oled_pot(xpos, ypos, tamaño, min, max)

Parámetros

xpos: posición en la coordenada x del display.

ypos: posición en la coordenada y del display.

tamaño: [T_NORMAL, T_GRANDE] tamaño del texto a usar. Por defecto la fuente es T_NORMAL.

min: valor leido en la posición mínima del potenciómetro. El valor mínimo por defecto es 0.

max: valor leido en la posición máxima del potenciómetro. El valor máximo por defecto es 1023.

Retorna

Lectura del potenciómetro normalizada a los valores min y max.

Ejemplo

Con las funciones originales del IDE de Arduino, los rangos de lectura y actuación no están normalizados, en Compluino 03 hemos preferido normalizar todo de 0 a 100, como en la lectura del potenciómetro de este ejemplo. Aun así el usuario puede modificar este rango de normalización cambiando los valores min y max de la función.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// Escribe el valor del potenciómetro, normalizado de 0 a 100,
// en el centro del display OLED,
// usando texto de tamaño grande.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
Robot.escribe_2x_oled(5, 0, "POT");
}

void loop()
{
// Muestra el valor del potenciómetro en el display OLED
Robot.escribe_oled_pot(5, 4, T_GRANDE, 0, 100);
}

Robot.escribe_oled_ldr()

Descripción

Escribe en el display OLED del robot la lectura del sensor de luz LDR normalizada a los valores min y max.

Sintaxis

Robot.escribe_oled_ldr(xpos, ypos, tamaño, min, max)

Parámetros

xpos: posición en la coordenada x del display.

ypos: posición en la coordenada y del display.

tamaño: [T_NORMAL, T_GRANDE] tamaño del texto a usar. Por defecto la fuente es T_NORMAL.

min: valor mínimo para el sensor de luz LDR. El valor mínimo por defecto es 0.

max: valor máximo para el sensor de luz LDR. El valor máximo por defecto es 1023.

Retorna

Lectura del sensor de luz LDR normalizada a los valores min y max.

Ejemplo

Con las funciones originales del IDE de Arduino, los rangos de lectura y actuación no están normalizados, en Compluino 03 hemos preferido normalizar todo de 0 a 100, como en la lectura del sensor de luz de este ejemplo. Aun así el usuario puede modificar este rango de normalización cambiando los valores min y max de la función.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// Escribe el valor del sensor de luz LDR, normalizado de 0 a 100,
// en el centro del display OLED,
// usando texto de tamaño grande.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// Muestra el valor del potenciómetro en el display OLED
Robot.escribe_oled_ldr(4, 3, T_GRANDE, 0, 100);
}

Robot.escribe_oled_pulsador()

Descripción

Escribe en el display OLED del robot el estado del pulsador de usuario. Escribe "PUL" si se encuantra pulsado y "NO PUL" en caso contrario.

Sintaxis

Robot.escribe_oled_pulsador(xpos, ypos, tamaño)

Parámetros

xpos: posición en la coordenada x del display.

ypos: posición en la coordenada y del display.

tamaño: [T_NORMAL, T_GRANDE] tamaño del texto a usar. Por defecto la fuente es T_NORMAL.

Retorna

El valor numérico 0 si el pulsador no está pulsado y el valor numérico 1 en caso contrario.

Ejemplo

En el siguiente ejemplo vamos a monitorizar el estado del pulsador de usuario. Fíjate que en el programa podemos combinar texto escrito con los dos tamaños (normal y grande), en función de lo que nos interese que se vea más grande.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// Escribe el estado del pulsador en el dsiplay OLED del robot

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
Robot.escribe_oled(4, 0, "Estado del");
Robot.escribe_oled(5, 2, "pulsador");
Robot.escribe_oled(4, 4, "de usuario");
}

void loop()
{
// Muestra el valor del pulsador en el display OLED
Robot.escribe_oled_pulsador(3, 6, T_GRANDE);
}

Robot.escribe_oled_suelo_d()

Descripción

Escribe en el display OLED la lectura analógica del sensor reflexivo de suelo derecho, normalizada a los valores min y max. La indicación del sensor es más alta cuanto más oscura es la superficie sobre la que se encuentre el robot. Así pues, este sensor está diseñado como un detector de líneas negras.

Sintaxis

Robot.escribe_oled_suelo_d(xpos, ypos, tamaño, min, max)

Parámetros

xpos: posición en la coordenada x del display.

ypos: posición en la coordenada y del display.

tamaño: [T_NORMAL, T_GRANDE] tamaño del texto a usar. Por defecto la fuente es T_NORMAL.

min: valor mínimo para el sensor reflexivo de suelo. El valor mínimo por defecto es 0.

max: valor máximo para el sensor reflexivo de suelo. El valor máximo por defecto es 1023.

Retorna

Lectura analógica del sensor de suelo derecho normalizada a los valores min y max

Ejemplo

Con las funciones originales del IDE de Arduino, los rangos de lectura y actuación no están normalizados, en Compluino 03 hemos preferido normalizar todo de 0 a 100, como en la lectura del sensor reflexivo de este ejemplo. Aun así el usuario puede modificar este rango de normalización cambiando los valores min y max de la función.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// Escribe la medida analógica del sensor
// reflexivo de suelo derecho, normalizada de 0 a 100,
// en el display OLED

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
Robot.escribe_oled(5, 0, "Sensor");
Robot.escribe_oled(4, 2, "reflexivo");
Robot.escribe_oled(5, 4, "derecho");
}

void loop()
{
// Muestra el valor del sensor reflexivo derecho en el display OLED
Robot.escribe_oled_suelo_d(5, 6, T_GRANDE, 0, 100);
}

Robot.escribe_oled_suelo_i()

Descripción

Escribe en el display OLED la lectura analógica del sensor reflexivo de suelo izquierdo, normalizada a los valores min y max. La indicación del sensor es más alta cuanto más oscura es la superficie sobre la que se encuentre el robot. Así pues, este sensor está diseñado como un detector de líneas negras.

Sintaxis

Robot.escribe_oled_suelo_i(xpos, ypos, tamaño, min, max)

Parámetros

xpos: posición en la coordenada x del display.

ypos: posición en la coordenada y del display.

tamaño: [T_NORMAL, T_GRANDE] tamaño del texto a usar. Por defecto la fuente es T_NORMAL.

min: valor mínimo para el sensor reflexivo de suelo. El valor mínimo por defecto es 0.

max: valor máximo para el sensor reflexivo de suelo. El valor máximo por defecto es 1023.

Retorna

Lectura analógica del sensor de suelo izquierdo normalizada a los valores min y max

Ejemplo

Este programa de ejemplo hace que se muestren los valores analógicos de los sensores de suelo izquierdo y derecho, normalizados de 0 a 100. En la imagen de la derecha ambos sensores se encuentran sobre una superficie blanca.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Escribe la medida analógica de los sensores
// reflexivos de suelo izquierdo y derecho,
// normalizada de 0 a 100, en el display OLED del robot

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
Robot.escribe_oled(1, 0, "Sensores suelo");
Robot.escribe_2x_oled(1, 3, "IZQ");
Robot.escribe_2x_oled(1, 6, "DER");
}

void loop()
{
// Muestra los valores de los sensores de suelo
// en el display OLED del robot
Robot.escribe_oled_suelo_i(9, 3, T_GRANDE, 0, 100);
Robot.escribe_oled_suelo_d(9, 6, T_GRANDE, 0, 100);
}

Robot.escribe_oled_suelo_dd()

Descripción

Escribe en el display OLED el estado digital del sensor reflexivo de suelo derecho, mostrando "BLANCO" o "NEGRO" según sea el color de la superficie sobre la que se encuentra el robot.

Sintaxis

Robot.escribe_oled_suelo_dd(xpos, ypos, tamaño)

Parámetros

xpos: posición en la coordenada x del display.

ypos: posición en la coordenada y del display.

tamaño: [T_NORMAL, T_GRANDE] tamaño del texto a usar. Por defecto la fuente es T_NORMAL.

Retorna

El valor numérico 0, cuando detecta BLANCO y el valor 1, cuando detecta NEGRO.

Ejemplo

El siguiente programa de ejemplo muestra en el display OLED el estado digital del sensor reflexivo derecho.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// Escribe el estado digital del sensor reflexivo
// de suelo derecho, en el display OLED

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
Robot.escribe_oled(5, 0, "Sensor");
Robot.escribe_oled(4, 2, "reflexivo");
Robot.escribe_oled(5, 4, "derecho");
}

void loop()
{
// Muestra el estado digital del sensor reflexivo derecho en el display OLED
Robot.escribe_oled_suelo_dd(3, 6, T_GRANDE);
}

Robot.escribe_oled_suelo_id()

Descripción

Escribe en el display OLED el estado digital del sensor reflexivo de suelo izquierdo, mostrando "BLANCO" o "NEGRO" según sea el color de la superficie sobre la que se encuentra el robot.

Sintaxis

Robot.escribe_oled_suelo_id(xpos, ypos, tamaño)

Parámetros

xpos: posición en la coordenada x del display.

ypos: posición en la coordenada y del display.

tamaño: [T_NORMAL, T_GRANDE] tamaño del texto a usar. Por defecto la fuente es T_NORMAL.

Retorna

El valor numérico 0, cuando detecta BLANCO y el valor 1, cuando detecta NEGRO.

Ejemplo

El siguiente programa de ejemplo muestra en el display OLED del robot el estado digital de los sensores reflexivos izquierdo y derecho. En la imagen de la derecha, la fotografía del display muestra el caso en el que el robot está con el sensor derecho sobre una marca (línea) negra y el izquierdo sobre una zona blanca.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// Escribe el estado digital de los sensores reflexivos
// de suelo izquierdo y derecho, en el display OLED

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
Robot.escribe_oled(1, 0, "Sensores suelo");
Robot.escribe_2x_oled(0, 3, "I");
Robot.escribe_2x_oled(0, 6, "D");
}

void loop()
{
// Muestra los valores de los sensores de suelo
// en el display OLED del robot
Robot.escribe_oled_suelo_id(4, 3, T_GRANDE);
Robot.escribe_oled_suelo_dd(4, 6, T_GRANDE);
}

Robot.escribe_oled_distancia()

Descripción

Muestra en la pantalla OLED del robot la distancia, en centímetros, a la que se encuentra un objeto en su parte delantera. Para ello utiliza el sensor de distancia por ultrasonidos HC-SR04.

Sintaxis

Robot.escribe_oled_distancia(xpos, ypos, tamaño, led)

Parámetros

xpos: posición en la coordenada x del display.

ypos: posición en la coordenada y del display.

tamaño: [T_NORMAL, T_GRANDE] tamaño del texto a usar. Por defecto la fuente es T_NORMAL.

led: Activa [SI] o desactiva [NO] la indicación visual del proceso de medida en el led azul del robot. En caso de activación [SI] esta funcionalidad es incompatible con cualquier otro uso que se quiera dar al led azul del robot en ese mismo programa.

Retorna

La distancia en centímetros a la que se encuentra el objeto, con un máximo de 255 cm.

Ejemplo

El siguiente ejemplo muestra en la pantalla OLED la distancia, en centímetros, a la que se encuentra un objeto que está en la parte delantera del robot.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// Muestra la distancia en cm medida por el sensor
// ultrasónico HC-SR04, en el display OLED del robot

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
Robot.escribe_oled(4, 0, "Distancia");
Robot.escribe_2x_oled(10, 4, "cm");
}

void loop()
{
// Muestra la distancia en cm
Robot.escribe_oled_distancia(3, 4, T_GRANDE, SI);
}

Robot.escribe_oled_brujula()

Descripción

Muestra en la pantalla OLED del robot la orientación del robot el grados sesagesimales [+/- 180º] La orientación de 0º se toma en el proceso de inicialización y es, por tanto, la posición inicial del robot. Para clacular la orientación el robot usa una brújula electrónica HMC5883L. Este dispositivo, al igual que todos los similares, es muy sensible a los campos magnéticos, radiaciones electromagnéticas y estructuras metálicas próximas al robot.

Sintaxis

Robot.escribe_oled_brujula(xpos, ypos, tamaño)

Parámetros

xpos: posición en la coordenada x del display.

ypos: posición en la coordenada y del display.

tamaño: [T_NORMAL, T_GRANDE] tamaño del texto a usar. Por defecto la fuente es T_NORMAL.

Retorna

Valor numérico que indica la orientación del robot en el rango de [+/- 180º]

Ejemplo

Robot.escribe_oled_int()

Descripción

Muestra en el display OLED del robot el contenido de una variable del programa de ltipo entero (int).

Sintaxis

Robot.escribe_oled_int(xpos, ypos, valor, tamaño)

Parámetros

xpos: posición en la coordenada x del display.

ypos: posición en la coordenada y del display.

valor: valor de la variable a mostrar en el display OLED.

tamaño: [T_NORMAL, T_GRANDE] tamaño del texto a usar. Por defecto la fuente es T_NORMAL.

Retorna

No retorna nada.

Ejemplo

El siguiente ejemplo muestra en la pantalla OLED la variable contador que varía de 0 a 100.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Muestra la variable contador

#include <Compluino_03.h>

Compluino_03 Robot;

int contador;

void setup()
{
Robot.inicia();
Robot.escribe_oled(4, 0, "Contador");
}

void loop()
{
// Muestra la variable contador
for (contador=0; contador<=100; contador++)
{
Robot.escribe_oled_int(5, 4, contador);
Robot.espera_milisegundos(300);
}
}

----------- Altavoz piezoeléctrico -----------

Robot.beep()

Descripción

Emite un beep, una señal aguda de corta duración, concretamente un tono de 1000Hz durante 200 milisegundos.

Sintaxis

Robot.beep()

Parámetros

No necesita parámetros.

Retorna

No retorna nada.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// Este ejemplo emite un Beep, tono de 1000Hz durante 200ms,
// durante intervalos de un segundo.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
Robot.espera_milisegundos(800);
Robot.beep();
}

Robot.doble_beep()

Descripción

Reproduce dos sonidos tipo Beep espaciados 50ms.

Sintaxis

Robot.doble_beep()

Parámetros

No necesita parámetros.

Retorna

No retorna nada.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// Este ejemplo emite un doble Beep cada un segundo.
// Se corresponde con dos tonos de 1000Hz espaciados 50ms

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
Robot.espera_milisegundos(500);
Robot.doble_beep();
}

Robot.enciende_altavoz()

Descripción

Activa el altavoz reproduciendo un tono de la frecuencia indicada.

Sintaxis

Robot.enciende_altavoz(frecuencia)

Parámetros

frecuencia: valor de la frecuencia del tono a reproducir.

Retorna

No retorna nada.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// Este ejemplo reproduce un sonido de 500Hz

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// Enciende el altavoz a la frecuencia indicada
Robot.enciende_altavoz(500);
// Nótese que la duración es ilimitada
// ya que nunca se apaga.
}

Robot.apaga_altavoz()

Descripción

Detiene la fúncion de encendido del altavoz.

Sintaxis

Robot.apaga_altavoz()

Parámetros

No necesita parámetros.

Retorna

No retorna nada.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// Este ejemplo reproduce un sonido de 500Hz a intervalos
// de un segundo encendido y un segundo apagado.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// Enciende el altavoz durante un segundo
Robot.enciende_altavoz(500);
Robot.espera_segundos(1);
// Apaga el altavoz durante un segundo
Robot.apaga_altavoz();
Robot.espera_segundos(1);
}

----------- Lectura de sensores -----------

Robot.lee_sensor()

Descripción

Sintaxis

Robot.lee_sensor()

Parámetros

Retorna

Ejemplo

Robot.lee_pot()

Descripción

Obtiene la lectura del potenciómetro normalizada a los valores min y max.

Sintaxis

Robot.lee_pot(min, max)

Parámetros

min: valor leido en la posición mínima del potenciómetro. El valor mínimo por defecto es 0.

max: valor leido en la posición máxima del potenciómetro. El valor máximo por defecto es 1023.

Retorna

Lectura del potenciómetro normalizada a los valores min y max.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// Este ejemplo reproduce un sonido de 500Hz
// si la lectura del potenciómetro es inferior al 50%.

#include <Compluino_03.h>

Compluino_03 Robot;

int dato;

void setup()
{
Robot.inicia();
}

void loop()
{
// Obtengo el valor del potenciómetro
dato=Robot.lee_pot(0,100);

// Utilizo el valor obtenido para mi programa
if (dato<50)
{
Robot.enciende_altavoz(500);
}
else
{
Robot.apaga_altavoz();
}
}

Robot.lee_ldr()

Descripción

Obtiene la lectura del sensor de luz LDR normalizada a los valores min y max.

Sintaxis

Robot.lee_ldr(min, max)

Parámetros

min: valor mínimo para el sensor de luz LDR. El valor mínimo por defecto es 0.

max: valor máximo para el sensor de luz LDR. El valor máximo por defecto es 1023.

Retorna

Lectura del sensor de luz LDR normalizada a los valores min y max.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// Este ejemplo enciende el led RGB
// si la lectura del sensor de luz LDR es inferior al 30%.

#include <Compluino_03.h>

Compluino_03 Robot;

int dato;

void setup()
{
Robot.inicia();
}

void loop()
{
// Obtengo el valor de la LDR
dato=Robot.lee_ldr(0,100);

// Utilizo el valor obtenido para mi programa
if (dato<30)
{
Robot.enciende(RGB_BLANCO);
}
else
{
Robot.apaga(RGB);
}
}

Robot.lee_pulsador()

Descripción

Obtiene el estado del pulsador de usuario.

Sintaxis

Robot.lee_pulsador()

Parámetros

No necesita parámetros.

Retorna

El valor numérico 0 si el pulsador no está pulsado y el valor numérico 1 en caso contrario.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// Este ejemplo reproduce un sonido de 500Hz
// mientras esté activo el pulsador.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// Utilizo el valor obtenido para mi programa
if (Robot.lee_pulsador())
{
Robot.enciende_altavoz(500);
}
else
{
Robot.apaga_altavoz();
}
}

Robot.lee_suelo_d()

Descripción

Obtiene la lectura analógica del sensor reflexivo de suelo derecho, normalizada a los valores min y max. La indicación del sensor es más alta cuanto más oscura es la superficie sobre la que se encuentre el robot. Así pues, este sensor está diseñado como un detector de líneas negras.

Sintaxis

Robot.lee_suelo_d(min, max)

Parámetros

min: valor mínimo para el sensor reflexivo de suelo. El valor mínimo por defecto es 0.

max: valor máximo para el sensor reflexivo de suelo. El valor máximo por defecto es 1023.

Retorna

Lectura analógica del sensor de suelo derecho normalizada a los valores min y max.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Este ejemplo varía el brillo del led RGB
// en función del valor analógico del sensor de suelo derecho.

#include <Compluino_03.h>

Compluino_03 Robot;

int dato;

void setup()
{
Robot.inicia();
}

void loop()
{
// Obtengo el valor del sensor
dato=Robot.lee_suelo_d(0,100);

// Utilizo el valor obtenido para mi programa
Robot.brillo_rgb(dato,dato,dato);

}

Robot.lee_suelo_i()

Descripción

Obtiene la lectura analógica del sensor reflexivo de suelo izquierdo, normalizada a los valores min y max. La indicación del sensor es más alta cuanto más oscura es la superficie sobre la que se encuentre el robot. Así pues, este sensor está diseñado como un detector de líneas negras.

Sintaxis

Robot.lee_suelo_i(min, max)

Parámetros

min: valor mínimo para el sensor reflexivo de suelo. El valor mínimo por defecto es 0.

max: valor máximo para el sensor reflexivo de suelo. El valor máximo por defecto es 1023.

Retorna

Lectura analógica del sensor de suelo izquierdo normalizada a los valores min y max.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Este ejemplo varía el brillo del led RGB
// en función del valor analógico del sensor de suelo izquierdo.

#include <Compluino_03.h>

Compluino_03 Robot;

int dato;

void setup()
{
Robot.inicia();
}

void loop()
{
// Obtengo el valor del sensor
dato=Robot.lee_suelo_i(0,100);

// Utilizo el valor obtenido para mi programa
Robot.brillo_rgb(dato,dato,dato);

}

Robot.lee_suelo_dd()

Descripción

>Obtiene la lectura digital del sensor reflexivo de suelo derecho, 0 si es blanco o 1 si es negro.

Sintaxis

Robot.lee_suelo_dd()

Parámetros

No necesita parámetros.

Retorna

El valor numérico 0, cuando detecta BLANCO y el valor 1, cuando detecta NEGRO.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// En este ejemplo el robot gira a la izquierda
// si detecta una línea negra con el sensor sensor reflexivo de suelo derecho.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// Utilizo el valor obtenido para mi programa
if (Robot.lee_suelo_dd())
{
Robot.gira_izquierda(75);
}
else
{
Robot.para();
}
}

Robot.lee_suelo_id()

Descripción

>Obtiene la lectura digital del sensor reflexivo de suelo izquierdo, 0 si es blanco o 1 si es negro.

Sintaxis

Robot.lee_suelo_id()

Parámetros

No necesita parámetros.

Retorna

El valor numérico 0, cuando detecta BLANCO y el valor 1, cuando detecta NEGRO.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// En este ejemplo el robot gira a la derecha
// si detecta una línea negra con el sensor sensor reflexivo de suelo izquierdo.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// Utilizo el valor obtenido para mi programa
if (Robot.lee_suelo_id())
{
Robot.gira_derecha(75);
}
else
{
Robot.para();
}
}

Robot.lee_distancia()

Descripción

Obtiene la distancia, en centímetros, a la que se encuentra un objeto en su parte delantera. Para ello utiliza el sensor de distancia por ultrasonidos HC-SR04.

Sintaxis

Robot.lee_distancia(led)

Parámetros

Retorna

La distancia en centímetros a la que se encuentra el objeto, con un máximo de 255 cm.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// Este ejemplo emite un Beep continuamente
// si el objeto está a menos de 10cm.

#include <Compluino_03.h>

Compluino_03 Robot;

int dato;

void setup()
{
Robot.inicia();
}

void loop()
{
// Obtengo la distancia al objeto
dato=Robot.lee_distancia(SI);

// Utilizo el valor obtenido para mi programa
if (dato<10)
{
Robot.beep();
}

}

----------- Control de la brújula -----------

Robot.lee_brujula()

Descripción

Sintaxis

Robot.lee_brujula()

Parámetros

Retorna

Ejemplo

----------- Control del pulsador -----------

Robot.espera_pulsador()

Descripción

El programa se mantiene a la espera de que se pulse el pulsador para continuar con la siguiente instrucción. En caso de estar activo al llegar a esta sección, habrá que soltar y pulsar de nuevo.

Sintaxis

Robot.espera_pulsador()

Parámetros

No necesita parámetros.

Retorna

No retorna nada.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// Este ejemplo emite un doble Beep al activar el pulsador.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// Espera hasta que se pulse el pulsador
Robot.espera_pulsador();

// Reproduce doble Beep
Robot.doble_beep();

}

Robot.espera_pulsador_mensaje()

Descripción

El programa se mantiene a la espera de que se pulse el pulsador para continuar con la siguiente instrucción. En caso de estar activo al llegar a esta sección, habrá que soltar y pulsar de nuevo. Mientras tanto muestra por pantalla el mensaje "Pulsar ->", indicando donde se encuentra el pulsador de usuario.

Sintaxis

Robot.espera_pulsador_mensaje()

Parámetros

No necesita parámetros.

Retorna

No retorna nada.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// Este ejemplo emite un doble Beep al activar el pulsador.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// Espera hasta que se pulse el pulsador
Robot.espera_pulsador_mensaje();

// Reproduce doble Beep
Robot.doble_beep();

}

Robot.espera_pulsador_soltar()

Descripción

Sintaxis

Robot.espera_pulsador_soltar()

Parámetros

>No necesita parámetros.

Retorna

No retorna nada.

Ejemplo

Robot.estado_pulsador()

Descripción

Obtiene el estado del pulsador de usuario.

Sintaxis

Robot.estado_pulsador()

Parámetros

No necesita parámetros.

Retorna

El valor numérico 0 si el pulsador no está pulsado y el valor numérico 1 en caso contrario.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// Este ejemplo reproduce un sonido de 500Hz
// mientras esté activo el pulsador.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// Utilizo el valor obtenido para mi programa
if (Robot.estado_pulsador())
{
Robot.enciende_altavoz(500);
}
else
{
Robot.apaga_altavoz();
}
}

----------- Control de los ledes -----------

Robot.enciende()

Descripción

Enciende el led de usuario LED o el led RGB en el color indicado.

Sintaxis

Robot.enciende(color)

Parámetros

COLOR: Indica el led azul de usuario conectado el pin 13 [LED] o el color del led RGB:

[RGB] - Para el color blanco
[RGB_NEGRO] - Para el color negro, es decir, apagado
[RGB_ROJO] - Para el color rojo
[RGB_VERDE] - Para el color verde
[RGB_AZUL] - Para el color azul
[RGB_MAGENTA] - Para el color magenta
[RGB_CIAN] - RPara el color cian
[RGB_AMARILLO] - Para el color amarillo
[RGB_BLANCO] - Para el color blanco

Retorna

No retorna nada.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// Este ejemplo alterna el encendido y apagado
// del led RGB en varios colores.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// Enciendo el led RGB en varios colores
Robot.enciende(RGB_VERDE);
Robot.espera_milisegundos(500);
Robot.enciende(RGB_NEGRO);
Robot.espera_milisegundos(500);

Robot.enciende(RGB_AZUL);
Robot.espera_milisegundos(500);
Robot.enciende(RGB_NEGRO);
Robot.espera_milisegundos(500);

Robot.enciende(RGB_ROJO);
Robot.espera_milisegundos(500);
Robot.enciende(RGB_NEGRO);
Robot.espera_milisegundos(500);
}

Robot.apaga()

Descripción

Apaga el led indicado, pudiendo ser el led RGB o el led de usuario LED.

Sintaxis

Robot.apaga(led)

Parámetros

led: Corresponde al led que queremos apagar, [RGB] para el led RGB o [LED] para el led de usuario conectado al pin 13.

Retorna

No retorna nada.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// Este ejemplo enciende y apaga alternativamente
// el LED y el led RGB en color azul.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// Enciendo LED y apago el led RGB
Robot.enciende(LED);
Robot.apaga(RGB);
Robot.espera_segundos(1);

// Enciendo RGB en color azul y apago LED
Robot.enciende(RGB_AZUL);
Robot.apaga(LED);
Robot.espera_segundos(1);

}

Robot.brillo_rgb()

Descripción

Controla el color del led RGB mediante cada una de sus componentes rojo, verde o azul.

Sintaxis

Robot.brillo_rgb(rojo,verde,azul)

Parámetros

rojo: Corresponde al valor de color rojo del led RGB en %. El rango varía de 0% al 100%.

verde: Corresponde al valor de color verde del led RGB en %. El rango varía de 0% al 100%.

azul: Corresponde al valor de color azul del led RGB en %. El rango varía de 0% al 100%.

Retorna

No retorna nada.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// Este ejemplo alterna el encendido
// del led RGB en sus colores primarios.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();
}

void loop()
{
// Color rojo al 100%, verde y azul al 0%
Robot.brillo_rgb(100,0,0);
Robot.espera_segundos(1);

// Color verde al 100%, rojo y azul al 0%
Robot.brillo_rgb(0,100,0);
Robot.espera_segundos(1);

// Color azul al 100%, verde y rojo al 0%
Robot.brillo_rgb(0,0,100);
Robot.espera_segundos(1);
}

----------- Control de la brújula (Compass) -----------

----------- Esperas -----------

Robot.espera_segundos()

Descripción

Mantiene en espera el programa cierto tiempo. Durante estos segundos se mantendrá en ejecución los comandos anteriores antes de proseguir con los siguientes.

Sintaxis

Robot.espera_segundos(segundos)

Parámetros

segundos: Indica el número de segundos que está en espera el programa.

Retorna

No retorna nada.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// Este ejemplo muestra y borra un mensaje en el centro de la pantalla del
// robot después de la secuencia de inicialización durante 2 segundos.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();

// El robot nos saluda durante dos segundos
// después borra el display OLED
Robot.escribe_2x_oled(3, 3, "Hola");
Robot.espera_segundos(2);
Robot.borra_oled();
}

void loop()
{
// No hacemos nada en el bucle principal
}

Robot.espera_milisegundos()

Descripción

Mantiene en espera el programa cierto tiempo. Durante estos milisegundos se mantendrá en ejecución los comandos anteriores antes de proseguir con los siguientes.

Sintaxis

Robot.espera_milisegundos(milisegundos)

Parámetros

milisegundos: Indica el número de milisegundos que está en espera el programa.

Retorna

No retorna nada.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// Este ejemplo muestra y borra un mensaje en el centro de la pantalla del
// robot después de la secuencia de inicialización durante 500 milisegundos.

#include <Compluino_03.h>

Compluino_03 Robot;

void setup()
{
Robot.inicia();

// El robot nos saluda durante 500ms
// después borra el display OLED
Robot.escribe_2x_oled(3, 3, "Hola");
Robot.espera_milisegundos(500);
Robot.borra_oled();
}

void loop()
{
// No hacemos nada en el bucle principal
}

----------- Servo -----------

Robot.pos_servo()

Descripción

Mueve el servo a la posición indicada en grados. Se recomienda estimar un tiempo de espera necesario para que se establezca el posicionamiento correctamente, pudiendo ser 200ms por ejemplo.

Sintaxis

Robot.pos_servo(grados)

Parámetros

grados:Indica la posición en grados a la cual se va a colocar el servo. Este valor debe estar normalizado de 0 a 180 grados.

Retorna

No retorna nada.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

// Este ejemplo varía la posición del servo
// desde los 45º a 135º y viceversa en saltos de 5º.
// Los tiempos de espera en un sentido y en otro son distintos.

#include <Compluino_03.h>

Compluino_03 Robot;

int i;

void setup()
{
Robot.inicia();
}

void loop()
{
// Gira el servo en sentido anti-horario cada 500ms
for(i=45;i<135;i+=5)
{
Robot.pos_servo(i);
Robot.espera_milisegundos(500);
}

// Gira el servo en sentido horario cada 200ms
for(i=135;i>45;i-=5)
{
Robot.pos_servo(i);
Robot.espera_milisegundos(200);
}

}

Robot.lee_pos_servo()

Descripción

Obtiene la posición en grados a la que se encuentra posicionado el servo. Dicho valor estará normalizado de 0 a 180 grados.

Sintaxis

Robot.lee_pos_servo()

Parámetros

No necesita parámetros.

Retorna

El valor en grados al que que encuentra colocado el servo. Este valor está comprendido entre 0 y 180.

Ejemplo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// Este ejemplo varía la posición del servo
// desde los 45º a 135º y viceversa en saltos de 5º.
// Los tiempos de espera en un sentido y en otro son distintos.
// Muestra por pantalla la posición en la que se encuentra el servo.

#include <Compluino_03.h>

Compluino_03 Robot;

int i;
int posicion;

void setup()
{
Robot.inicia();
}

void loop()
{
// Gira el servo en sentido anti-horario cada 500ms
for(i=45;i<135;i+=5)
{
Robot.pos_servo(i);
posicion = Robot.lee_pos_servo();
Robot.escribe_oled_int(0,0,posicion);
Robot.espera_milisegundos(500);
}

// Gira el servo en sentido horario cada 200ms
for(i=135;i>45;i-=5)
{
Robot.pos_servo(i);
posicion = Robot.lee_pos_servo();
Robot.escribe_oled_int(0,0,posicion);
Robot.espera_milisegundos(200);
}

}

----------- Constantes -----------

Asignación de pines

Asignación de pines de Compluino 03, configurados según el formato del IDE de Arduino para la placa Arduino UNO. Los pines 0 y 1 están reservados a las comunicaciones (Serie-USB y Bluetooth). Los pines del 2 al 13 corresponden a las entradas/salidas digitales. Los pines 16 y 17 hacen referencia a los pines A2 y A3 configurados como digitales. Los pines A0..A3 son entradas analógicas. Los pines A4 y A5 no están disponibles ya que están utilizados como bus I2C para controlar el display OLED y la brújula electrónica. Puedes encontrar más información en el esquema de Compluino 03.

2 - PIN_SERVO - Control de servos de RC
3 - PIN_PULSADOR - Pulsador de usuario
4 - PIN_EN - Habilitación de los motores
5 - PIN_MOTOR_D - PWM motor derecho
6 - PIN_MOTOR_I - PWM motor izquierdo
7 - PIN_US - Sensor de distancias ultrasonidos HC-SR04. Configuración un pin
8 - PIN_ALTAVOZ - Altavoz piezoeléctrico (pasivo)
9 - PIN_RGB_ROJO - Color rojo del led RGB
10 - PIN_RGB_AZUL - Color azul del led RGB
11 - PIN_RGB_VERDE - Color verde del led RGB
12 - PIN_MISO - Pin MISO (1) del conector ICSP (CMUCAM)
13 - PIN_LED - Led azul
16 - PIN_SENSOR_DD - Sensor reflexivo derecho, en digital
17 - PIN_SENSOR_ID - Sensor reflexivo izquierdo, en digital
A0 - PIN_POT - Potenciómetro
A1 - PIN_LDR - Sensor de luz LDR
A2 - PIN_SUELO_D - Sensor reflexivo de suelo derecho, en analógico
A3 - PIN_SUELO_I - Sensor reflexivo de suelo izquierdo, en analógico

Referencias a sensores

Algunas funciones de la librería del Compluino 03 usan referencias genéricas (distintas del pin físico) para poder tratar a los distintos sensores por una misma función, con independencia del pin al que están conectados o al tipo de señal que usan.

REF_POT - Referencia al potenciómetro
REF_LDR - Referencia al sensor de luz LDR
REF_PULSADOR - Referencia al pulsador de usuario
REF_SUELO_D - Referencia al sensor reflexivo de suelo derecho en analógico
REF_SUELO_I - Referencia al sensor reflexivo de suelo izquierdo en analógico
REF_SUELO_DD - Referencia al sensor reflexivo de suelo derecho en digital
REF_SUELO_ID - Referencia al sensor reflexivo de suelo izquierdo en digital
REF_DISTANCIA - Referencia al sensor de distancias HC-SR04
REF_BRUJULA - Referencia al sensor de orientación HMC5883L (brújula electrónica)

Notas musicales

Para simplificar el uso del altavoz, hemos creado referencias a la escala musical de la cuarta octava. Paras ello puedes usar las siguientes referencias a dichas notas musicales:

DO4 - Nota musical DO de la cuarta octava
RE4 - Nota musical RE de la cuarta octava
MI4 - Nota musical MI de la cuarta octava
FA4 - Nota musical FA de la cuarta octava
SOL4 - Nota musical SOL de la cuarta octava
LA4 - Nota musical LA de la cuarta octava
SI4 - Nota musical SI de la cuarta octava

Compluino 03 – Referencia de programación

Robot.inicia()

----------- Movimiento -----------

Robot.para()

Robot.avanza()

Robot.retrocede()

Robot.mueve()

Robot.gira_derecha()

Robot.gira_izquierda()

Robot.gira()

Robot.mueve_motor()

----------- Display OLED -----------

Robot.borra_oled()

Robot.escribe_oled()

Robot.escribe_2x_oled()

Robot.escribe_oled_sensor()

Robot.escribe_oled_pot()

Robot.escribe_oled_ldr()

Robot.escribe_oled_pulsador()

Robot.escribe_oled_suelo_d()

Robot.escribe_oled_suelo_i()

Robot.escribe_oled_suelo_dd()

Robot.escribe_oled_suelo_id()

Robot.escribe_oled_distancia()

Robot.escribe_oled_brujula()

Robot.escribe_oled_int()

----------- Altavoz piezoeléctrico -----------

Robot.beep()

Robot.doble_beep()

Robot.enciende_altavoz()

Robot.apaga_altavoz()

----------- Lectura de sensores -----------

Robot.lee_sensor()

Robot.lee_pot()

Robot.lee_ldr()

Robot.lee_pulsador()

Robot.lee_suelo_d()

Robot.lee_suelo_i()

Robot.lee_suelo_dd()

Robot.lee_suelo_id()

Robot.lee_distancia()

----------- Control de la brújula -----------

Robot.lee_brujula()

----------- Control del pulsador -----------

Robot.espera_pulsador()

Robot.espera_pulsador_mensaje()

Robot.espera_pulsador_soltar()

Robot.estado_pulsador()

----------- Control de los ledes -----------

Robot.enciende()

Robot.apaga()

Robot.brillo_rgb()

----------- Control de la brújula (Compass) -----------

----------- Esperas -----------

Robot.espera_segundos()

Robot.espera_milisegundos()

----------- Servo -----------

Robot.pos_servo()

Robot.lee_pos_servo()

----------- Constantes -----------

Asignación de pines

Referencias a sensores

Notas musicales

SUSCRIBETE

Próximos eventos