Hispalis RobIOTics

Arduino Trainer v1.0

Manual de Uso

Diciembre, 2017

Hispalis RobIOTics Arduino Trainer v1.0 Página 1 de 30

Indice

Introducción
Elementos de Arduino Trainer v1.0
Arduino Trainer: Leds integrados ( D3, D5, D6 )
Arduino Trainer: Sensor Ultrasónico ( D2, D4 )
Arduino Trainer: Salidas para módulo L9110 ( D7, D8, D9, D10 )
Arduino Trainer: Conexión de módulo driver de motores L9110
Arduino Trainer: Pulsadores ( D12, D13 )
Arduino Trainer: Sensor de línea ( A0 A1 A2 A3 )
Arduino Trainer: Salida Buzzer ( D11 )
Arduino Trainer: Conector Bluetooth ( RX, TX )
Arduino Trainer: Conector I2C
Arduino Trainer: Conector de Alimentación
Alimentando Arduino UNO
Analizando el pin VIN de Arduino Trainer v1.0
Alimentando Arduino Trainer v1.0 con Arduino UNO

Hispalis RobIOTics Arduino Trainer v1.0 Página 2 de 30

Introducción

Arduino Trainer v1.0 es un shield diseñado para introducirse de forma sencilla en el mundo
Arduino y la programación.
Un shield ( del inglés escudo, o más propiamente placa ) es una placa de circuito impreso
( PCB , de Printed Circuit Board ) que se encaja sobre Arduino UNO, y que añade nuevas
funcionalidades a la placa Arduino original. Para ello incluye componentes electrónicos que se
conectan directamente a las patillas de Arduino. Esto elimina el cableado necesario para conectar
los componentes, lo cual es fuente de problemas para modelos con cierta complejidad.
A modo de ejemplo, consideremos un circuito con un sensor ultrasónico, dos LEDs y dos
interruptores. Para conectar todos estos componentes necesitaremos de 8 a 12 cables en una placa
protoboard. Este tipo de placas es ideal para prototipos, pero a medida que añadimos componentes,
el cableado se vuelve engorroso, propenso a fallos, y difícil de diagnosticar en caso de error. Si
integramos todos estos componentes en una placa shield, el cableado se reduce o elimina casi en su
totalidad.
Arduino Trainer integra los siguientes elementos hardware:
• Tres LEDS conectados a salidas PWM

• Dos pulsadores

• Sensor Ultrasónico HCSR04

• Dos conectores para conexión a servomotores

• Dos conectores para salidas digitales

• Conector para 2 LDRs, lo que posibilita un robot "seguidor de luz"

• Sensor de línea analógico de cuatro canales

• Conector para buzzer

• Conector I2C

• Conector para módulo bluetooth como puente para la programación mediante AppInventor

• Conectores para alimentación de 5 V

• Pulsador de RESET

El diseño del shield permite realizar innumerables prácticas, y su límite viene dado por la
imaginación del usuario. Como recurso didáctico en el aula, Arduino Trainer facilita el aprendizaje
en grupo, ya que ArduinoTrainer elimina el cableado de componentes, y simplifica las conexiones,
por lo que evita los problemas derivados de la complejidad de las conexiones. De este modo,
podemos centrarnos en conceptos de programación, evitando los fallos derivados de un mal
conexionado del hardware.

Hispalis RobIOTics Arduino Trainer v1.0 Página 3 de 30

 Arduino Trainer se inserta encima de la placa Arduino UNO, y se alimenta a través de la
conexión USB de UNO, siendo su consumo mínimo. Además, Arduino Trainer admite diversas
configuraciones de alimentación externa.

Gracias a la conexión Bluetooth, Arduino Trainer nos permite introducirnos en el IOT

( Internet Of Things o Internet de las cosas ). Con Arduino Trainer v1.0, podemos encender/apagar
LEDs, utilizar sliders, o comunicarnos con un PC y monitorizar con Processing las entradas/salidas
de UNO.

Arduino Trainer puede convertirse en un completo robot, gracias al chasis TrainerBot,

disponible en Thingiverse [Link]

Hispalis RobIOTics TrainerBot

Hispalis RobIOTics Arduino Trainer v1.0 Página 4 de 30

Elementos de Arduino Trainer v1.0
La imagen inferior muestra el hardware integrado en Arduino Trainer v1.0

En la web [Link] se encuentra un conjunto de programas que

permiten experimentar con todo el hardware integrado. Dichos programas se encuentran en
constante revisión, y está en contínuo crecimiento. La última versión del conjunto de programas se
encuentra alojada en github:

Una vez descargado el fichero [Link], basta con descomprimirlo en la

carpeta Arduino donde guardamos nuestros proyectos. Al reiniciar el IDE de Arduino, podremos
encontrar el conjunto de programas en

Archivo → Proyectos → ArduinoTrainerv1.0

Es preciso indicar que dichos programas no son exclusivos de Arduino Trainer, y pueden ser
ejecutados en Arduino UNO, sin necesidad de conectar Arduino Trainer. Obviamente, los elementos
hardware ( LEDs, interruptores, etc …) deberán conectarse externamente ( por ejemplo en una placa
breadboard ), de modo que cualquier persona que quiera utilizarlos debe tan solo conocer la
asignación de pines de Trainer, y cablear los elementos adecuados en los pines asignados.

Hispalis RobIOTics Arduino Trainer v1.0 Página 5 de 30

Arduino Trainer: LEDs integrados ( D3, D5, D6)
Arduino Trainer incluye tres LEDs, los cuales se conectan a los siguiente pines de Arduino
UNO:

• LED rojo: pin 3

• LED amarillo: pin 5
• LED verde: pin 6

LEDs integrados en Arduino Trainer v1.0

El siguiente programa ilumina secuencialmente los LEDs

#define LED_ROJO 3
#define LED_AMARILLO 5
#define LED_VERDE 6
void setup()
{
pinMode( LED_ROJO , OUTPUT );
pinMode( LED_AMARILLO , OUTPUT );
pinMode( LED_VERDE , OUTPUT );
}
void loop()
{
digitalWrite( LED_ROJO , HIGH );
delay( 1000 );
digitalWrite( LED_ROJO , LOW );
delay( 1000 );
digitalWrite( LED_AMARILLO , HIGH );
delay( 1000 );
digitalWrite( LED_AMARILLO , LOW );
delay( 1000 );
digitalWrite( LED_VERDE , HIGH );

Hispalis RobIOTics Arduino Trainer v1.0 Página 6 de 30

 delay( 1000 );
digitalWrite( LED_VERDE , LOW );
delay( 1000 );
}

Los LEDs emplean salidas que admiten modulación PWM. Esto significa que podemos
controlar el brillo de cada uno mediante la funcion analogWrite( valor ) , con valor en el rango { 0 –
255 }.

El siguiente programa es una modificación del ejemplo “Fade”, disponible en el menú

Archivo → Ejemplos → Basics → Fade

/*
Fade
This example shows how to fade an LED on pin 3 using the analogWrite() function.
The analogWrite() function uses PWM, so if you want to change the pin you're using, be sure to use another PWM
capable pin. On most Arduino, the PWM pins are identified with a "~" sign, like ~3, ~5, ~6, ~9, ~10 and ~11.
This example code is in the public domain.
*/

int led = 3; // the PWM pin the LED is attached to

int brightness = 0; // how bright the LED is
int fadeAmount = 5; // how many points to fade the LED by

// the setup routine runs once when you press reset:

void setup()
{
// declare pin 3 to be an output:
pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:

void loop()
{
// set the brightness of pin 9:
analogWrite(led, brightness);

// change the brightness for next time through the loop:

brightness = brightness + fadeAmount;

// reverse the direction of the fading at the ends of the fade:

if (brightness <= 0 || brightness >= 255) {
fadeAmount = -fadeAmount;
}

// wait for 30 milliseconds to see the dimming effect

delay(30);
}

Hispalis RobIOTics Arduino Trainer v1.0 Página 7 de 30

Arduino Trainer: Sensor Ultrasónico ( D2, D4 )
Arduino Trainer integra el popular sensor ultrasónico HCSR04, el cual es un sensor de
distancias que emplea un haz ultrasónico de ida y vuelta, similar a la visión de los murciélagos.

Sensor Ultrasónico de distancia HCSR04

El asignamiento de pines del sensor el el siguiente:

• HCSR04_TRIGGER: pin 2
• HCSR04_ECHO: pin 4

El siguiente ejemplo muestra cómo programar el sensor y visualizar los datos a través del
Monitor Serie del IDE de Arduino:
#define HCSR04_ECHO 4
#define HCSR04_TRIGGER 2

void setup()
{
pinMode(HCSR04_TRIGGER , OUTPUT);
pinMode(HCSR04_ECHO , INPUT);
[Link]( 115200);
}

void loop()
{
int gap;
for(;;)
{
gap = Distance_StandardTest();
[Link]( "Distancia ... "+ String(gap) + " cm.");
delay( 500);
}
}

/*
Funcion: Distance_StandardTest()
Devuelve en cm la distancia del sensor HCSR04 al objeto más cercano
Funcionamiento:
1) Lanzamos un pulso de señal cuadrado. Para ello el pin TRIGGER
a) Lo ponemos a LOW, y esperamos un tiempo a que se estabilice ( por si estaba en nivel HIGH )

Hispalis RobIOTics Arduino Trainer v1.0 Página 8 de 30

 b) Lo ponemos a HIGH, y esperamos un tiempo
c) Lo ponemos a LOW again
2) El sensor devuelve un pulso de entrada en el pin ECHO, que es el tiempo de ida y vuelta del sonido
3) Con una formula lo convertimos a cm.
*/
int Distance_StandardTest(void)
{
long duracion, distancia;

// Pulso en TRIGGER
digitalWrite(HCSR04_TRIGGER , LOW);
delayMicroseconds(5);
digitalWrite(HCSR04_TRIGGER, HIGH);
delayMicroseconds(5);
digitalWrite(HCSR04_TRIGGER, LOW);

// Pulso de ECHO
duracion = pulseIn(HCSR04_ECHO , HIGH) ;

// Conversion a int. Podemos convertir a float ...

distancia = (int) (duracion / 2 / 29.1 ) ;

//[Link]( "Distancia ... "+ String(distancia) + " cm.") ;

return distancia;
}
Es posible utilizar una biblioteca de funciones para el sensor HCSR04. En este sentido, la
biblioteca NewPing es fiable y popular. Es por ello que se incluye un ejemplo de cómo integrar
dicha biblioteca con Arduino Trainer. De modo general, Los pasos necesarios para utilizar una
biblioteca son:

• Descargar el fichero [Link] de [Link]

ping/wiki/Home
• Extraerlo en la carpeta Arduino/libraries

El programa ( NewPingExample ),una vez instalado [Link], se encuentra en

Archivo → Proyectos → ArduinoTrainerv1.0 → Sensors → HCSR04 → NewPingExample

// ---------------------------------------------------------------------------
// Example NewPing library sketch that does a ping about 20 times per second.
// ---------------------------------------------------------------------------
#include <NewPing.h>
#define TRIGGER_PIN 2 // 3 Hercules , 2 Trainer
#define ECHO_PIN 4 // 2 Hercules , 4 Trainer
#define MAX_DISTANCE 200 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is
rated at 400-500cm.

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance.

void setup()
{
[Link](115200); // Open serial monitor at 115200 baud to see ping results.
}
void loop()
{
delay(50); // Wait 50ms between pings (about 20 pings/sec). 29ms should be the shortest delay between
pings.
unsigned int uS = [Link](); // Send ping, get ping time in microseconds (uS).
[Link]("Ping: ");
[Link](uS / US_ROUNDTRIP_CM); // Convert ping time to distance in cm and print result (0 = outside set
distance range)
[Link]("cm");
}

Hispalis RobIOTics Arduino Trainer v1.0 Página 9 de 30

Arduino Trainer: Salidas para módulo L9110 ( D7, D8, D9, D10 )
Arduino Trainer dispone de 4 salidas agrupadas en un conector múltiple macho,
correspondientes a las salidas D7, D8, D9 y D10 de Arduino UNO. Dichas salidas tienen las
siguientes características:

• Salidas D7 D8 Salida Digital

• Salidas D9 D10 Salida PWM

El conector posee ademas tomas para alimentación ( VIN ) y masa ( GND ), de modo que
podemos acceder a pines de alimentación. Esto es especialmente útil si queremos conectar servos en
los pines D9 y D10 ( salida PWM ), ya que el conector se ajusta al proporcionado por dichos servos.

En este punto, es necesario indicar que el pin central VIN de cada conector no se
encuentra conectado a ningún pin de alimentación, por lo que si conectamos un servo ( por
ejemplo en D9 ), este no funcionará. Para ello, es preciso conectar cualquier pin VIN al conector 5V
Supply. D este modo, el servo quedará conectado a la alimentación.

Conector múltiple macho D7 a D10

En el epígrafe “Analizando el pin VIN de Arduino Trainer v1.0” se analiza con detalle las
posibilidades de conectar estos pines adecuadamente.

Hablar de Arduino y robótica nos conduce inexorablemente a hablar de robots con motores y
ruedas. En este sentido, este conector se ha diseñado para conectar un par de motores a Arduino
Trainer, para crear un coche-robot. Aunque hay muchos tipos de robots con ruedas, los más
adecuados para personas que se inician en el mundo de la robótica son:

• Robots con servos de rotación contínua

• Robots con un driver o puente en H ( L9110 , L293D … )

A continuación veremos cómo conectar un driver para dos motores a Trainer.

Hispalis RobIOTics Arduino Trainer v1.0 Página 10 de 30

Arduino Trainer: Conexión de módulo driver de motores L9110
El driver de motores L9110 permite conectar dos motores con un consumo máximo de 800
mA., siendo ideal para construir pequeños robots con motores y ruedas. Dicho driver dispone de
cuatro entradas, denominadas { A-IA , A-IB , B-IA , B-IB }. Veamos cómo conectarlas.

Driver L9110. Los conectores verdes son salidas de motores

a) Entradas del driver L9110

Las entradas {A_IA , A-IB } permiten controlar un motor ( digamos el izquierdo ), mientras
que { B-IA , B-IB } permiten controlar el segundo. De las dos entradas { A-IA , A-IB }

• A-IA ( B-IA ) se conecta a una salida analógica ( D9, D10 )

• A-IB ( B-IB ) se conecta a una salida digital ( D7, D8 )

de este modo, la salida analógica permite conducir al motor con un rango de velocidades en el rango
{ 0 – 255 }, de un modo similar a la salida PWM del programa Fade visto anteriormente. En otras
palabras, podemos hacer que el motor vaya a mayor o menor velocidad.

b) Conexión del driver L9110 a Arduino Trainer v1.0

Para conectar el driver L9110 a Arduino Trainer v1.0 podemos utilizar el siguiente esquema
de conexionado, con los colores que se muestran en las imágenes posteriores:

Salida D7 → Entrada B-IB ( Gris ) Digital, sentido de giro Motor Izquierdo

Salida D9 → Entrada B-IA ( Morado) Analógica, velocidad Motor Izquierdo
Salida D8 → Entrada A-IB ( Negro) Digital, sentido de giro Motor Derecho
Salida D10→ Entrada A-IA ( Blanco ) Analógica, velocidad Motor Derecho

Es conveniente definir las siguientes constantes de preprocesador al principio de un

programa

#define MOTOR_IZDO_DIR 7 // Low Adelante , HIGH Atras

#define MOTOR_IZDO_SPEED 9 // Velocidad { 0 – 255 }
#define MOTOR_DCHO_DIR 8
#define MOTOR_DCHO_SPEED 10

Hispalis RobIOTics Arduino Trainer v1.0 Página 11 de 30

Driver L9110 conectado a Arduino Trainer v1.0, así como a la alimentación (cables rojo marrón )

Driver L9110: Cables de conexión a Arduino Trainer v1.0

Arduino Trainer v1.0: Cables de conexión al driver L9110

Hispalis RobIOTics Arduino Trainer v1.0 Página 12 de 30

 A continuación se muestra una tabla con las características eléctricas y de entrada del driver
L9110, extraída de la hoja de características ( datasheet ):

La tabla superior derecha muestra el comportamiento de la salida del driver conectado al

motor ( OA, OB ) frente a las entradas ( IA, IB ). En ella se aprecia lo siguiente:

• Si ambas están entradas están a nivel alto ( H ) o bajo ( L ), el motor permanecerá parado
• Si una entrada está a nivel alto, y otra a bajo, el motor funciona en un sentido u otro, ya que
el voltaje en { OA, OB } cambia de polaridad.

Esta tabla no muestras las propiedades PWM del driver, y asume como entrada niveles
lógicos ( alto o bajo ) en vez de analógicos, pero el funcionamiento en ambos casos es similar.

El siguiente programa permite verificar el funcionamiento de los dos motores del driver L9110.
Sencillamente, hace que vayan ambos en una dirección, y luego en otra.

#define PARA delay(1000);

#define MOTOR_IZDO_DIR 7 // Low Adelante , HIGH Atras

#define MOTOR_IZDO_SPD 9 // Velocidad { 0 – 255 }
#define MOTOR_DCHO_DIR 8
#define MOTOR_DCHO_SPD 10

void setup()
{
pinMode( MOTOR_IZDO_DIR , OUTPUT );
pinMode( MOTOR_IZDO_SPD , OUTPUT );
pinMode( MOTOR_DCHO_DIR , OUTPUT );
pinMode( MOTOR_DCHO_SPD , OUTPUT );
}

void loop()
{
int vel = 200; // velocidad = { 0 , 255 }
Forward_Motor_Left( vel );
Forward_Motor_Right( vel );
PARA;
Stop_Motor_Left();
Stop_Motor_Right();
PARA;
Reverse_Motor_Left( vel );

Hispalis RobIOTics Arduino Trainer v1.0 Página 13 de 30

 Reverse_Motor_Right( vel );
PARA;
Stop_Motor_Left();
Stop_Motor_Right();
PARA;
}

void Stop_Motor_Left( void )

{
digitalWrite( MOTOR_IZDO_DIR , LOW );
digitalWrite( MOTOR_IZDO_SPD , LOW );
}

void Stop_Motor_Right( void )

{
digitalWrite( MOTOR_DCHO_DIR , LOW );
digitalWrite( MOTOR_DCHO_SPD , LOW );
}

void Forward_Motor_Left( int velocidad )

{
digitalWrite( MOTOR_IZDO_DIR, HIGH );
analogWrite( MOTOR_IZDO_SPD, 255-velocidad );
}

void Forward_Motor_Right( int velocidad )

{
digitalWrite( MOTOR_DCHO_DIR, HIGH );
analogWrite( MOTOR_DCHO_SPD, 255-velocidad );
}

void Reverse_Motor_Left( int velocidad )

{
digitalWrite( MOTOR_IZDO_DIR, LOW );
analogWrite( MOTOR_IZDO_SPD, velocidad );
}

void Reverse_Motor_Right( int velocidad )

{
digitalWrite( MOTOR_DCHO_DIR, LOW );
analogWrite( MOTOR_DCHO_SPD, velocidad );
}

Hispalis RobIOTics Arduino Trainer v1.0 Página 14 de 30

Arduino Trainer: Pulsadores ( D12, D13 )
Arduino Trainer integra en la placa dos pulsadores, correspondientes a las entradas D12 y
D13. Dichos pulsadores pueden servir de entradas a Trainer para incluirlos en nuestros programas
Por un error en la serigrafía, las entradas están invertidas. Esto significa que la entrada rotulada D12
corresponde a la entrada D13 de Arduino UNO, mientras que la rotulada D13 corresponde al pin
D12 de UNO. Esto no es un problema si asignamos las siguientes constantes de preprocesador
#define SWITCH_D12 13

#define SWITCH_D13 12

con lo que en adelante podremos referenciarlas de modo correcto en los programas

Los pines D12 y D13 de Arduino UNO se configuran como entradas PULL-UP
( INPUT_PULLUP ), y se conectan a los switches. La otra patilla de los conectores se conecta a
masa, En este caso, cuando leemos los pines D12 o D13, obtendremos un valor

• LOW → Pulsador abierto

• HIGH → Pulsador presionado

El modo correcto por tanto de inicializarlos en setup() es el siguiente

#define SWITCH_D12 13
#define SWITCH_D13 12

void setup()
{
pinMode( SWITCH_D12 , INPUT_PULLUP ); // Enable internal pull-up resistor
pinMode( SWITCH_D13 , INPUT_PULLUP ); // Enable internal pull-up resistor
}

La siguiente funcion devuelve el valor del pulsador D12 ( 1 Si está pulsado, 0 en caso
contrario )

int Switchd12_esta_pulsado(void)
{
return !digitalRead( SWITCH_D12 );
}

Hispalis RobIOTics Arduino Trainer v1.0 Página 15 de 30

 El siguiente sketch integra todo lo anterior. Al pulsar D12 ( D13 ) se enciende (apaga ) el
LED
#define SWITCH_D12 13
#define SWITCH_D13 12
#define LED_ROJO 3

void setup()
{
pinMode( LED_ROJO , OUTPUT );
pinMode( SWITCH_D12 , INPUT_PULLUP );
pinMode( SWITCH_D13 , INPUT_PULLUP );
}

void loop(void)
{
if( Switchd12_esta_pulsado() )
digitalWrite( LED_ROJO , HIGH );
else if( Switchd13_esta_pulsado() )
digitalWrite( LED_ROJO , LOW );
}

/*
Funcion: Switch_esta_pulsado(void)
Devuelve 1 si el pulsador esta siendo presionado, 0 si no
*/
int Switchd12_esta_pulsado(void)
{
return !digitalRead( SWITCH_D12 );
}

/*
Funcion: Switch_esta_pulsado(void)
Devuelve 1 si el pulsador esta siendo presionado, 0 si no
*/
int Switchd13_esta_pulsado(void)
{
return !digitalRead( SWITCH_D13 );
}

Hispalis RobIOTics Arduino Trainer v1.0 Página 16 de 30

Arduino Trainer: Sensor de línea ( A0, A1, A2, A3 )
Arduino Trainer integra en la placa un conjunto de cuatro sensores infrarrojos. Cada uno de
estos sensores está formado por un LED emisor ( transparente ) y un fototransistor ( oscuro ). En
adelante, denominaremos sensor de línea al conjunto de cuatro emisores/receptores

El sensor de línea se puede separar con facilidad de la placa de Arduino Trainer, ya que la
placa posee un corte que facilita dicha operación. De esta forma podemos disponer del sensor de
línea en la posición más adecuada dentro de nuestro robot.

El sensor de línea se conecta a Arduino Trainer mediante un conector de seis cables:

• Cuatro cables conectan las salidas de los sensores individuales, denominados S1 a S4

• Dos cables conectan la alimentación y masa, y se conectan al conector 5V Supply / GND
Supply

En las siguientes imágenes se muestra el sensor de línea, y la forma de cablearlo a Arduino

Trainer v1.0

Sensor de línea ( vista inferior ). Diodos emisores aislados Sensor de línea ( vista superior )

Conexión del Sensor de línea a Arduino Trainer Detalle de conexionado

En presencia de luz, la salida de cada sensor infrarrojo es alta, mientras que en ausencia de
luz, la salida del sensor es baja. Para mejorar la respuesta del sensor, se debe aislar el LED emisor
( aislados con capuchones negros, imagen superior izquierda ), o bien con una tira de cartón negro
de 5 mm de ancho, que se inserta entre la fila de sensores emisores y receptores. De este modo, el
sensor receptor no capta emisión lateral del emisor.

Hispalis RobIOTics Arduino Trainer v1.0 Página 17 de 30

 El sensor de línea se conecta a las entradas analógicas A0 – A3 de Arduino UNO, y su
funcionamiento en un sketch se puede verificar fácilmente. Nótese que en la serigrafía de los
conectores ( tanto del sensor de línea como de Arduino Trainer ) hay grabado un “1”, que se
corresponde con el sensor S1, para reducir errores de conexionado.

Recordemos que las entradas analógicas de Arduino UNO se digitalizan mediante un

conversor A/D de 10 bits de resolución. Esto significa que un valor nulo de la entrada analógica
corresponderá a un valor cero de la entrada digital, mientras que el máximo valor de la entrada
analógica corresponde a una lectura de 1023 ( 2 10 - 1 ).

El sensor de línea es ideal para investigar sobre arrays ( vectores ) en C. En la carpeta de

proyectos

Archivo → Proyectos → ArduinoTrainerv1.0 → Sensors → LineSensor

hay disponible un conjunto de programas que ejemplifican el manejo de arrays, paso y devolución
desde una función, etc.

El siguiente programa muestra cómo verificar el funcionamiento del sensor de línea

// Constantes de preprocesador
#define PARA delay(500)

void setup()
{
// No es necesario iniciar las entradas analógicas
[Link]( 115200 );
}

void loop()
{
int s1 , s2 , s3 , s4;
int ind;

for(;;)
{
s1 = analogRead( A0 );
s2 = analogRead( A1 );
s3 = analogRead( A2 );
s4 = analogRead( A3 );
PARA;

for( ind =0; ind <4 ; ind++)

[Link]("LineSensor -->\tS1:"+String(s1)+" \tS2:"+String(s2)+" \tS3:"+String(s3)+" \tS4:"+String(s4) );
PARA;
}
}

Hispalis RobIOTics Arduino Trainer v1.0 Página 18 de 30

Arduino Trainer: LDRs ( A4, A5 )
Arduino Trainer posee disponibles las entradas analógicas A4 A5 en un conector con la
serigrafía LDR, situado junto al conector bluetooth. Dichas entradas se conectan a su ver a sendas
resistencias pull up ( conectadas a su vez a 5V Supply ) de 10K, como se indica en la figura
siguiente

Arduino Trainer: Entradas analógicas A4, A5 LDRs

Si conectamos a dicho conector una LDR ( por ejemplo en A4 ), tendremos un divisor de

tensión similar al siguiente

5V
Según la fórmula del divisor de tensión
10 K

Vout = ( LDR ) 5V
R1

( R1 + LDR )
Vout ( A4 , A5 )

a) Si LDR << 10K resulta Vout = 0V

LDR

GND b) Si LDR >> 10K resulta Vout = 5V

Los valores típicos de una LDR se encuentran en el rango de resistencia

• LDR iluminada: 0 a 1K
• LDR en oscuridad: 50K a Megaohmios

Con estos datos, si conectamos una LDR a la entrada A4 ( a la patilla del conector, la otra
patilla a masa GND ) y la iluminamos, debemos obtener un valor bajo en la entrada A4 de Arduino
UNO, por lo que la lectura de A4 con analogRead( A4 ) debe devolver un valor cercano a 0. En el
otro caso, si mantenemos sin iluminar la LDR, el valor esperado debe ser cercano a 5V ( y
analogRead( A4 ) debe devolver un valor cercano a 1024 )

Estas dos fotoresistencias se pueden emplear en el caso de un robot que siga un haz de
luz, por ejemplo una linterna. A modo de ejemplo, consultar el siguiente enlace

Robot Seguidor de luz

Hispalis RobIOTics Arduino Trainer v1.0 Página 19 de 30

Arduino Trainer: BUZZER ( D11 )
Arduino Trainer v1.0 dispone de una salida, denominada BUZZER, conectada al pin 11
( PWM ) de Arduino UNO. Este conector se ha diseñado para conectarle bien un zumbador, o un
pequeño altavoz para generar sonidos y melodías.

Un zumbador ( dispositivo que emite pitidos, como el de las alarmas de los despertadores )
es un dispositivo piezoeléctrico ( varía su volumen al ser atravesado por una corriente eléctrica ),
mientras que un altavoz se basa en una bobina electromagnético. Ambos generan el sonido haciendo
vibrar una membrana.

Si conectamos un pequeño buzzer/altavoz, podremos generar sonidos, y crear melodías o

música con Arduino Trainer. El altavoz reproducirá notas a partir de la frecuencia de la señal que
reciba. Es preciso indicar que la calidad del sonido no es elevada (lo es, pero nosotros estamos
acostumbrados a ondas sinusoidales, no cuadradas ), pero es una práctica interesante para realizar
con alumnos que se inician en el mundo de la programación.

Existe una función que genera una nota ( la cual es una señal cuadrada ), denominada note().
Su sintaxis es

tone( pin , frecuencia , duracion );

por ejemplo,

tone ( 11 , 440 , 1000 );

generaría la nota “La” durante 1 sg ( 1000 msg ).

Hay muchos ejemplos de programas que crean melodías de canciones en la Web. El

siguiente programa, extraído de la siguiente web

[Link]

hace sonar dos melodías que todos reconocerán

Buzzer Piezoeléctrico

Hispalis RobIOTics Arduino Trainer v1.0 Página 20 de 30

/**************************/
/* popurri para Arduino */
/**************************/

/**************** Antonio Guillermo Pérez Coronilla ***************/

/* declaración de variables */
int spk=11; // altavoz a GND y pin 11
int c[5]={131,262,523,1046,2093}; // frecuencias 4 octavas de Do
int cs[5]={139,277,554,1108,2217}; // Do#
int d[5]={147,294,587,1175,2349}; // Re
int ds[5]={156,311,622,1244,2489}; // Re#
int e[5]={165,330,659,1319,2637}; // Mi
int f[5]={175,349,698,1397,2794}; // Fa
int fs[5]={185,370,740,1480,2960}; // Fa#
int g[5]={196,392,784,1568,3136}; // Sol
int gs[5]={208,415,831,1661,3322}; // Sol#
int a[5]={220,440,880,1760,3520}; // La
int as[5]={233,466,932,1866,3729}; // La#
int b[5]={247,494,988,1976,3951}; // Si

void nota(int a, int b); // declaración de la función auxiliar. Recibe dos números enteros.

void setup()
{
/*******************/
/* STAR WARS */
/*******************/
/**** tema principal ****/
nota(d[1],150);noTone(spk);delay(50);
nota(d[1],150);noTone(spk);delay(50);
nota(d[1],150);noTone(spk);delay(50);
nota(g[1],900);noTone(spk);delay(150);
nota(d[2],900);noTone(spk);delay(50);
nota(c[2],150);noTone(spk);delay(50);
nota(b[1],150);noTone(spk);delay(50);
nota(a[1],150);noTone(spk);delay(50);
nota(g[2],900);noTone(spk);delay(150);
nota(d[2],900);noTone(spk);delay(100);
nota(c[2],150);noTone(spk);delay(50);
nota(b[1],150);noTone(spk);delay(50);
nota(a[1],150);noTone(spk);delay(50);
nota(g[2],900);noTone(spk);delay(150);
nota(d[2],900);noTone(spk);delay(100);
nota(c[2],150);noTone(spk);delay(50);
nota(b[1],150);noTone(spk);delay(50);
nota(c[2],150);noTone(spk);delay(50);
nota(a[1],1200);noTone(spk);delay(2000);

/**** marcha del imperio ****/

nota(g[2],500);noTone(spk);delay(100);
nota(g[2],500);noTone(spk);delay(100);
nota(g[2],500);noTone(spk);delay(100);
nota(ds[2],500);noTone(spk);delay(1);
nota(as[2],125);noTone(spk);delay(25);
nota(g[2],500);noTone(spk);delay(100);
nota(ds[2],500);noTone(spk);delay(1);
nota(as[2],125);noTone(spk);delay(25);
nota(g[2],500);
noTone(spk);delay(2000);

void nota(int frec, int t)

{
tone(spk,frec); // suena la nota frec recibida
delay(t); // para después de un tiempo t
}

void loop()
{
}

Hispalis RobIOTics Arduino Trainer v1.0 Página 21 de 30

Arduino Trainer: Conector Bluetooth ( RX, TX )
Arduino UNO dispone de un puerto serie, el cual se emplea para la comunicación USB con
un ordenador. Esta conexión se emplea cada vez que queremos subir un programa a Arduino UNO,
o bien cuando utilizamos el Monitor Serie.

El puerto serie necesita una conexión mediante cable, aunque podemos eliminarlo por medio
de diversos dispositivos:

• Módulo Bluetooth HC-06

• Módulo WIFI
• Módulo RF 2,4 Ghz
• Conectar otro microprocesador con conectividad WIFI, como ESP8266 a Arduino UNO
(Shield Hércules de Hispalis RobIOTics, pronto a la venta ).

En el diseño de Arduino Trainer se consideró la primera posibilidad, por lo que se ha

dispuesto un conector ( zócalo ) en el que insertar un módulo Bluetooth. Con este módulo, podemos
conectar ArduinoTrainer v1.0 con otro ordenador, o incluso con un teléfono móvil, con tal de
establecer conexión entre ambos dispositivos.

El módulo Bluetooth posee dos terminales para la comunicación, denominados RX

( recepción ) y TX ( transmisión ). Dichos terminales deben conectarse a los terminales del puerto
serie de Arduino, a saber

• Pin 0 ( RX ) de Arduino ←→ Pin TX de HC-06

• Pin 1 ( TX ) de Arduino ←→ Pin RX de HC-06

Es posible utilizar otros pines de Arduino diferentes a RX y TX, usando una biblioteca
denominada Software Serial, la cual reasigna los pines TX y RX. Sin embargo, Arduino Trainer
emplea los pines originales RX/TX.

Esto origina un pequeño inconveniente: durante la carga de un programa, es preciso

retirar el módulo HC-06 del zócalo, puesto que durante la carga de un programa, los pines RX/TX
de Arduino UNO están inhabilitados, entran en conflicto con el módulo HC-06 y el programa no se
sube a Arduino UNO. Salvando este inconveniente, el módulo funciona sin ningún otro problema.

El módulo Bluetooth es el puente para introducirnos en el IOT ( Internet of Things ),

mediante la conexión vía AppInventor con un teléfono móvil.

Para programar una aplicación, deberemos crear un programa para Arduino UNO, y otro
( usando AppInventor ) en nuestro teléfono móvil. Un programa típico mostrará en el teléfono una
serie de botones, sliders, etc., los cuales al ser manipulados enviarán una serie de caracteres de
control a Arduino. Por su parte, el programa en Arduino leerá periódicamente el puerto serie, y
recibirá los caracteres enviados por el teléfono. Posteriormente, según el carácter recibido se
ejecutarán las instrucciones de programa pertinentes ( encender un LED, apagar un motor, etc ).
Obvia decir que en el interfaz de AppInventor debemos incluir el componente cliente bluetooth, y
tal vez un temporizador. El uso del temporizador es necesario para recibir datos de Arduino UNO, y
la aplicación, cada cierto tiempo ( digamos un segundo ), puede chequear si se ha recibido algún
dato de Arduino.

Hispalis RobIOTics Arduino Trainer v1.0 Página 22 de 30

 A modo de ejemplo, si queremos encender/apagar un LED, deberíamos diseñar un programa
para el teléfono con AppInventor. En el diseño del interfaz del programa incluiríamos dos botones:
ON y OFF. El programa de AppInventor podría enviar un carácter ( por ejemplo ‘A’ ) al pulsar el
botón de encendido, y otro ( ‘B’ ) al pulsar el botón de apagado. Adicionalmente, el teléfono podría
recibir cada cierto tiempo un ‘1’ o un ‘0’, según el LED esté encendido o apagado.

Por otra parte, el programa en Arduino debería muestrear continuamente el puerto serie. Esto
se consigue con el siguiente programa:
#define LED 3

void setup()
{
pinMode(LED, OUTPUT);
digitalWrite(LED, LOW);

[Link](9600);
}

void loop()
{
static int bytein;

if([Link]() > 0)
{
bytein = [Link]();

switch (bytein)
{
case '0':
digitalWrite(LED, LOW);break;
case '1':
digitalWrite(LED, HIGH);break;
}
}
}
Por otra parte, en AppInventor debemos crear una aplicación. A continuación se muestra un
ejemplo de cómo encender / apagar un LED. Este programa debe ser cargado en el teléfono.

Diseño del layout:

Hispalis RobIOTics Arduino Trainer v1.0 Página 23 de 30

Diseño de Bloques:

Imágenes de LEDs:

Led ON Led OFF

NOTA: Este ejemplo asume que el lector posee cierta experiencia con AppInventor, así como un
conocimiento básico de Arduino. Por otra parte, se ha evitado todo tipo de control de errores, y el
diseño del layout se ha simplificado con fines didácticos.

Hispalis RobIOTics Arduino Trainer v1.0 Página 24 de 30

Arduino Trainer: Conector I2C ( A4, A5 )

Se ha dispuesto de un conector I2C en la placa Arduino Trainer. De este modo, podemos

conectar diverso hardware periférico a nuestro Arduino Trainer.

El bus I2C, desarrollado por Philips, es un bus serie de datos. Junto con el puerto serie, y el
bus SPI, constituyen los tres principales sistemas de comunicación de Arduino UNO. También se
conoce con las siglas TWI ( Two Wires Interface ), y constituye un medio de comunicar Arduino
UNO con hardware periférico mediante dos cables, los cuales son:

• SDA: Cable para la transmisión de datos

• SCL: Cable para conectar la señal de reloj

El bus es síncrono, y por tanto la señal de reloj se comparte entre todos los dispositivos
conectados. Por otra parte, la arquitectura es maestro-esclavo. Arduino UNO actúa como maestro,
y es el que inicia la comunicación. Posteriormente, los esclavos pueden mandar o recibir datos con
el dispositivo maestro.

El bus I2C presenta una particularidad, consistente en que las líneas de datos deben
disponer de resistencias de pull-up ( conectadas a 5V ) de un valor entre 1K a 10K ( el valor típico
es de 4K7 ).

En la placa Arduino, los terminales I2C se comparten con las entradas analógicas A4 ( SDA )
y A5 (SCL ). Como vimos anteriormente, estas entradas analógicas se conectan al conector LDR,
visto anteriormente, y disponen de resistencias de pull-up, de valor 10K.

En la actualidad, existe mucho hardware conectable mediante el bus I 2C a Arduino, entre los
que podemos destacar el módulo de pantalla LCD.

Las especificaciones del protocolo se encuentran en [Link]

Hispalis RobIOTics Arduino Trainer v1.0 Página 25 de 30

Arduino Trainer: Conector de Alimentación

Arduino Trainer proporciona un conector múltiple macho de alimentación de 5V,

denominado 5V Supply/GND Supply. Cuando Arduino Trainer se conecta a un ordenador mediante
el cable USB de Arduino UNO, dicho conector permite alimentar cualquier dispositivo externo que
interactúe con Arduino Trainer, con las limitaciones de Arduino UNO ( intensidad máxima inferior
a 1 amperio ), pero además presenta otras características.
En primer lugar, si no alimentamos a Arduino UNO mediante el conector USB del
ordenador, dicho conector permite alimentar a Arduino Trainer externamente con un Battery
Pack ( también conocido como Power Bank ) de 5V. Dichos dispositivos son ampliamente
utilizados para recargar teléfonos móviles, y proporcionan un voltaje estable de 5V. Esta situación
se presenta cuando Arduino Trainer se convierte en TrainerBot, un robot programable con conexión
bluetooth.
Para alimentar Arduino Trainer con dicho pack, basta con conectar los cables de
alimentación del Power Bank al conector 5V Supply / GND Supply.

Conector USB tipo A

Conectores USB: patillaje

Otra utilidad del conector de alimentación es la de alimentar a los pines VIN del conector
múltiple macho D7 a D10. Como hemos dicho anteriormente, dichos pines no tienen conexión
eléctrica a Arduino UNO, ya que de fábrica el pin VIN de Arduino Trainer no se encuentra soldado.
Si quisiéramos por ejemplo conectar un Servo, deberemos conectar cualquier pin VIN del conector
múltiple D7 a D10 con algún pin 5V Supply del conector de alimentación. Con esto, el micromotor
del Servo quedará alimentado a 5V Supply.
Los siguientes epígrafes tratan con detalle esta cuestión.

Hispalis RobIOTics Arduino Trainer v1.0 Página 26 de 30

Alimentando Arduino UNO

Es importante conocer el esquema de Arduino para entender los diferentes modos de

alimentación. En la figura se muestra el esquema de Arduino UNO R3

Esquema eléctrico de Arduino UNO R3

En la zona marcada con la elipse amarilla se encuentra el conector externo de alimentación,

el cual se conecta a un diodo, para prevenir que se conecte la alimentación con la polaridad
invertida,lo cual provocaría la destrucción de circuitos de Arduino UNO. Dicho diodo provoca una
caída ( típica )de tensión de 0,7V. A la salida de dicho diodo se encuentra el pin VIN, cuya tensión
debería ser 0,7V inferior a la del voltaje externo, el cual se recomienda que no exceda los 9V.

El pin VIN a su vez se conecta a un regulador de tensión de 5V ( MC 33269ST-5.0 , el cual

en la práctica es un AMS 1117-5V, situado junto a dicho conector ) que permite salidas de hasta 800
mA. Dicha salida regulada de 5V es la que alimenta el microprocesador ATMEGA 328 de Arduino.

Es importante comprender que esta salida regulada de 5V puede ser a su vez entrada de
alimentación. En otras palabras, por este pin podemos conectar una fuente externa de 5V, pero en
este caso, el regulador integrado en Arduino UNO quedará sin funcionamiento, ya que para que
actúe debe recibir alimentación bien por VIN, bien por la alimentación externa.

Así pues, tenemos los siguientes posibles esquemas de alimentación de Arduino:

Hispalis RobIOTics Arduino Trainer v1.0 Página 27 de 30

Alimentación de 9V: Conector externo para no sobrecalentar el regulador, ya que la caída de 0,7 V
del diodo resultará en una entrada de tensión del regulador de unos 8 voltios.

Alimentación de 6 voltios ( por ejemplo, un pack de 4 pilas de 1,5 V ): Conexión al pin VIN.

Alimentación de 5V: ( Battery Pack USB ) Conectarlo al pin 5V de Arduino.

En definitiva, Arduino UNO se puede alimentar de diversas fuentes, a saber:

• Alimentación externa mediante batería de 9V.

• Alimentación directa por pin 5V Esta es la ideal si alimentamos Arduino UNO con un
Battery Pack USB de 5V.
• Alimentación por el conector USB, la cual emplea los pines de alimentación 5V de la
especificación USB.
• Alimentación por pin VIN. En este caso, debemos tener cuidado con la polaridad.

Hispalis RobIOTics Arduino Trainer v1.0 Página 28 de 30

Analizando el pin VIN de Arduino Trainer

Arduino Trainer v1.0 aplica las características anteriores de Arduino UNO, con la salvedad
de que el pin VIN se encuentra sin conectar, dejando dicha posibilidad al usuario. Dicho pin VIN
se conecta a su vez al conector múltiple macho VIN de las salidas D7 a D10, diseñado para
conectar Servos ( D9 D10 ) o bien entradas/salidas digitales ( D7 D8 ) como sensores externos, o
bien salidas por transistor para gobernar relés.

Arduino Trainer v1.0

Queremos remarcar que dicha patilla VIN alimenta al conector múltiple macho VIN de los
pines D7 D8 D9 D10. En la configuración de fábrica dicho conector no tiene alimentación. Si
por ejemplo conectamos un Servo a la salida D9 ( PWM ), dicho Servo no funcionará, ya que el
conector pertinente no tiene alimentación en el pin VIN.

Esta característica permite alimentar Servos con una alimentación superior a 5V, en el
caso de un robot con Servos de rotación contínua, los cuales se alimentan a 6 voltios.

Si no queremos hacer uso de esta característica, debemos conectar cualquiera de los pines
VIN del conector múltiple macho D7 a D10 a 5V Supply. Esta configuración se puede conseguir
de un modo similar si soldamos por la cara superior el pin VIN, en la fila de pines que se conectan
a Arduino UNO, y lo conectamos al conector 5V Supply. Así conseguiremos alimentar con 5V los
pines VIN del conector múltiple macho D7 a D10, sin alimentar por este pin a UNO. Esta es la
configuración recomendada.

Hispalis RobIOTics Arduino Trainer v1.0 Página 29 de 30

Alimentando Arduino Trainer con Arduino UNO
Arduino Trainer v1.0 integra un conector múltiple de 5V, el cual se conecta al pin 5V de
UNO. Esta flexible configuración permite alimentar ArduinoTrainer v1.0 de formas diferentes. En
todos los casos, Arduino Trainer alimentará adecuadamente a Arduino UNO:

a) Alimentación de UNO con 9V

• En este caso, Arduino Trainer v1.0 se alimenta a través de la salida de 5V de UNO.

• El conector múltiple macho VIN de los pines D7 a D10 no tienen alimentación, para lo
cual debemos conectar cualquier pin VIN del conector D7 a D10 a 5V Supply.

b) Alimentación de Trainer mediante Battery Pack USB

• En esta configuración, debemos conectar la salida del Battery Pack USB al conector 5V
Supply - GND Supply. Arduino Trainer v1.0 alimentará a su vez a Arduino UNO mediante
la entrada 5V de Arduino UNO.
• El conector múltiple macho VIN de los pines D7 a D10 no tienen alimentación, para lo cual
debemos conectar cualquier pin VIN del conector D7 a D10 a 5V Supply.

c) Alimentación por el conector USB

• En este caso, Arduino Trainer v1.0 se alimenta a través de la alimentación 5V del

conector USB.
• El conector múltiple macho VIN de los pines D7 a D10 no tienen alimentación, para lo
cual debemos conectar cualquier pin VIN del conector D7 a D10 a 5V Supply.

d) Alimentación por pin VIN ( avanzada )

Esta es la configuración mas compleja, ya que el pin VIN de Trainer v1.0 puede conectarse o
no al pin VIN de UNO. Es por esto que esta configuración se recomienda solo a usuarios
expertos, que hayan entendido claramente el esquema de alimentación de Arduino UNO.

Este esquema es solo recomendado si queremos conectar Servos de rotación continua y

alimentarlos a 6V, ya que al alimentar Arduino Trainer v1.0 por VIN el conector múltiple macho
VIN D7 A D10 SE ALIMENTARÁ A VIN externa. Para el resto de configuraciones, basta conectar
cualquier pin VIN del conector D7 a D10 a 5V Supply, como ya hemos repetido anteriormente.

Para conseguir que Arduino Trainer v1.0 alimente a Arduino UNO, debemos soldar el pin
VIN de Arduino Trainer v1.0 por debajo de la placa, para que entre en el conector VIN de UNO.
Por la cara de arriba, soldaremos los cables de alimentación externa VIN. Así, si alimentamos ( por
ejemplo 6 V mediante con 4 pilas de 1,5 V ) a Trainer, este a su vez alimentará al regulador de 5V
de Arduino. Asimismo, el conector múltiple VIN del conector D7 a D10 se alimentará con la misma
alimentación VIN externa ( los mismos 6 V de la alimentación externa ).

Hispalis RobIOTics
Contacto: hispalisrobiotics@[Link]

Hispalis RobIOTics Arduino Trainer v1.0 Página 30 de 30