Compluino 03 – Referencia de programación

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 Movimiento Display OLED Altavoz piezoeléctrico Lectura de sensores Control del pulsador Control de los ledes Control de la brújula (Compass) Esperas Servo Constantes

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 -----------

pantalla_presenta

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 pantalla_escribe

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 pantalla_escribe_2x

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 pantalla_lee_sensores

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 pantalla_pot

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 pantalla_ldr

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.

pantalla_no_pul pantalla_pul
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 pantalla_suelo_derecho

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 pantalla_sensores_suelo

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.

pantalla_sensor_derecho_blanco pantalla_sensor_derecho_negro
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 pantalla_sensores_suelo_digital

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 pantalla_distancia

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

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. Por defecto led se configura como [NO].

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

Volver página principal Compluino 03

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
Share Button
Follow us on Facebook Follow us on Twitter
  • tienda Complubot

  • SUSCRIBETE

    Suscríbete a nuestro boletín informativo para estar puntualmente informado de nuestros cursos, talleres, eventos y novedades.

  • Próximos eventos

    1. Campamentos de robótica semana del 25 de junio al 29 de junio

      junio 25 @ 10:00 - junio 29 @ 14:00

    2. Campamentos de robótica semana del 2 de julio al 6 de julio

      julio 2 @ 10:00 - julio 6 @ 14:00

    3. Crumble – Aula robótica (14ª Edición)

      julio 2 @ 16:00 - julio 6 @ 20:00

    4. Campamentos de robótica del 9 de julio al 13 de julio

      julio 9 @ 10:00 - julio 13 @ 14:00

    5. LEGO Education Academy – LEGO WeDo para formadores

      julio 9 @ 16:00 - 20:00

    6. Curso de especialización en robótica con Arduino

      julio 9 @ 16:00 - julio 13 @ 20:00

    7. LEGO Education Academy – LEGO WeDo 2.0 para formadores

      julio 10 @ 16:00 - 20:00

    8. Empezando con LEGO Mindstorms EV3 para formadores

      julio 11 @ 16:00 - 20:00

    9. Proyectos y desafíos con LEGO Mindstorms EV3 para formadores

      julio 12 @ 16:00 - 20:00

    10. Proyectos avanzados con LEGO Mindstorms EV3 para formadores

      julio 13 @ 16:00 - 20:00

    Ver todos los Eventos

A ver si adivinas que utilizamos en este sitio? Aquí tienes el ladrillo en cuestión por si quieres leerlo