Función random


Llega un momento en la que se quiere emular el azar en un programa, como por ejemplo, encender varios leds de forma aleatoria. Para ello existe la función Random en Arduino.

Utilizando esta función obtendremos números aleatorios para nuestro sketch. Pero estos números aleatorios en realidad no lo son. Como ocurre en la mayoría de estos lenguajes, incluyendo Arduino, son números seudoaleatorios, es decir, si se inicia la función random con los mismos parámetros se obtiene la misma secuencia de números.

La sintaxis de esta función es la siguiente:
  •     Random(max): Se obtiene un numero “aleatorio” desde 0 hasta max.
  •     Random(min, max): Se obtiene un numero “aleatorio” desde min hasta max

 Veamos cómo se comporta esta función escribiendo el resultado en el monitor serie con los parámetros random(1,100):

/*

Obtiene un numero aleatorio y lo muestra en monitor serie
*/

//Variable donde almacenaremos el numero aleatorio
long randomNumber;

//Función de inicialización
void setup() {
 
  //Inicializamos la comunicación serial
  Serial.begin(9600);
 
  //Escribimos por el puerto serie mensaje de inicio
  Serial.println("Inicio de sketch - secuencia de numeros aleatorios");
     
}

//Bucle principal
void loop() {

  //Genera un numero aleatorio entre 1 y 100
  randomNumber = random(1,100);
 
  //Escribimos el numero aleatorio por el puerto serie
  Serial.print("El numero aleatorio es = ");
  Serial.println(randomNumber);

  //Esperamos 1 segundo para repetir
  delay(1000);
}
Valores que se mostrarán en el monitor serie:


 Si reseteamos el programa vuelve a salir la misma secuencia. 

Pero hay una solución llamada semilla y que existe en todos los lenguajes que implementan la función random. La semilla es un valor por defecto que coge la función random para inicializarse, si cambiamos esta semilla la secuencia de datos cambiara.

La función randomSeed en Arduino

La sintaxis de esta función es la siguiente:

    randomSeed(semilla): Incializa la función random con el valor semilla pasado por parámetro. Esta función se incluirá dentro de la función setup de nuestro skecth.

La solución en Arduino

Para conseguir que cada vez que iniciemos el skecth tengamos secuencias diferentes tenemos que pasarle cada vez una semilla diferente. Esto lo conseguimos si como semilla le pasamos el valor de una entrada analógica que no utilicemos en nuestro sketch mediante la función analogRead(). Estos pin analógicos cuando no son utilizados no tienen ninguna tensión de referencia y devolverá un valor de ruido que será diferente cada vez que preguntemos por su valor.

Así es que el código nos quedara así:

/*
Obtiene un numero aleatorio con semilla variable y lo muestra en monitor serie
*/

//Variable donde almacenaremos el numero aleatorio
long randomNumber;

//Función de inicialización
void setup() {
 
  //Inicializamos la comunicación serial
  Serial.begin(9600);
 
  //Escribimos por el puerto serie mensaje de inicio
  Serial.println("Inicio de sketch - secuencia de numeros aleatorios");
     
  //Establecemos la semilla en un pin analogico
  randomSeed(analogRead(A0)); 
     
}

//Bucle principal
void loop() {
 
  //Genera un numero aleatorio entre 1 y 100
  randomNumber = random(1,100);
 
  //Escribimos el numero aleatorio por el puerto serie
  Serial.print("El numero aleatorio es = ");
  Serial.println(randomNumber);

  //Esperamos 1 segundo para repetir
  delay(1000);
}

 Valores que se mostrarán en el monitor serie:



Ya tenemos la forma correcta de emular el azar con Random en Arduino ahora solo nos queda ver que podemos hacer. Os pongo un ejemplo sencillo con LEDs: En este ejemplo tenemos 4 LEDs y encendemos uno de ellos aleatoriamente según nos devuelva la función random.

Monta el esquema que te muestro a continuación.



Este es el código que debes utilizar para seleccionar los LEDs al azar con random en Arduino.

/*

Obtiene un numero aleatorio con semilla variable y enciende el LED correspondiente utilizando random en Arduino
*/

//Declaramos los pins de los LEDs
#define LED_1  3
#define LED_2  4
#define LED_3  5
#define LED_4  6

//Variable donde almacenaremos el numero aleatorio
long randomNumber;

//Función de inicialización
void setup() {
 
  //Inicializamos la comunicación serial
  Serial.begin(9600);
 
  //Escribimos por el puerto serie mensaje de inicio
  Serial.println("Inicio de sketch - secuencia de numeros aleatorios");

  //Establecemos los pin en modo salida
  pinMode(LED_1, OUTPUT);
  pinMode(LED_2, OUTPUT);
  pinMode(LED_3, OUTPUT);
  pinMode(LED_4, OUTPUT);
     
  //Establecemos la semilla en un pin analogico
  randomSeed(analogRead(A0)); 
     
}

//Bucle principal
void loop() {

  //Apagamos todos los LEDs
  digitalWrite(LED_1, LOW);
  digitalWrite(LED_2, LOW);
  digitalWrite(LED_3, LOW);
  digitalWrite(LED_4, LOW);
 
  //Genera un numero aleatorio entre 2 y 6
  randomNumber = random(3,7);
 
  //Escribimos el numero aleatorio por el puerto serie
  Serial.print("El numero aleatorio es = ");
  Serial.println(randomNumber);

  //Encendemos el pin aleatorio
  digitalWrite(randomNumber, HIGH);

  //Esperamos 300 milisegundos para repetir
  delay(300);
}




 Fuente: https://programarfacil.com/


Conexión a Arduino por Bluetooth

El protocolo de comunicaciones Bluetooth, nacido hace ya casi 20 años, está destinado a la transmisión de voz y datos en pequeñas redes inalámbricas. Ampliamente utilizado para evitar los cables en la conexión de dispositivos periféricos como teclados a computadoras de escritorio y notebooks o para conectar una gran variedad de dispositivos a teléfonos móviles o tabletas, también puede ser aprovechado para el control inalámbrico de nuestros proyectos con Arduino gracias a módulos como el popular HC05, algunas de cuyas aplicaciones veremos en este artículo.

En este artículo voy a utilizar una placa que contiene toda la circuitería para alimentar el módulo HC05 con 5V y permite su conexión en forma directa a placas que funcionen con esta tensión, como Arduino UNO.



Conexionado

La conexión de este módulo a una placa Arduino es sumamente simple. Toda la complejidad del protocolo Bluetooth está resuelta por el HC05 que nos presenta un puerto serie con los típicos pines TX y RX para el envío y recepción de datos. La alimentación de 5 Voltios debe proveerse a través de los pines VCC y GND. KEY es una entrada que nos permite cambiar el modo de funcionamiento  y LED es una salida para conectar un led que indique la condición de trabajo del módulo, aunque éste ya cuenta con un led azul soldado sobre la placa en el lado inferior que cumple con esa función. 
 
El circuito mínimo para utilizar Bluetooth en nuestros proyectos es el siguiente:

Conexionado HC05-Arduino

Como se puede ver, el pin KEY se deja desconectado. En esta condición, todo lo que escribamos en el pin TXD es enviado por el HC05 a través de la conexión bluetooth a otro dispositivo (por ejemplo un teléfono) y los datos recibidos saldrán por el pin RXD, siempre a una velocidad de 9600 baudios, que es la preestablecida de fábrica. Si quisieramos realizar algún cambio en la configuración del HC05, como la velocidad de transmisión o modificar alguno de los muchos parámetros con que cuenta, debemos hacerlo entrar en el llamado «modo AT», donde los datos que se envían al módulo no son transmitidos sino que son interpretados como comandos o instrucciones. En este artículo no voy a explicar esta funcionalidad, que quedará para un artículo futuro (de todos modos, no es imprescindible para dar los primeros pasos). Arduino provee la alimentación al módulo a través de sus pines 5V y GND y las señales de datos se asignan a los pines 10 y 11, que funcionarán como un puerto serie por software para no interferir con el puerto serie de Arduino en los pines 0 y 1. 

Para comprobar que la placa de Arduino es capaz de comunicarse con un dispositivo Bluetooth necesitamos dos cosas al menos: un dispositivo que envíe datos y un programa en Arduino que los reciba. Para esto último, escribimos un programa simple que lee continuamente los datos recibidos por la interfaz serie por software en los pines 5 y 6 y los retransmite por el puerto serie del Arduino al programa Monitor en el IDE. De esa manera, cualquier dato recibido a través del módulo Bluetooth se copiará en la ventana del monitor. El programa es el siguiente:
El programa es el siguiente:

#include

SoftwareSerial ModuloHC05 (5, 6);  //pin RX, pin TX

void setup()
 {
  Serial.begin(9600);        //Inicializa puerto serie por hardware
  ModuloHC05.begin(9600);    //Inicializa puerto serie por software
 }

void loop() 
{

 if (ModuloHC05.available())                    //Llega algo por bluetooth?
      Serial.write(ModuloHC05.read());    //Sacarlo a la terminal

}

Para enviar datos a la placa Arduino usaremos un teléfono Android con una aplicación específica. Afortunadamente, si buscamos en la Play Store (Arduino Bluetooth, por ejemplo) hallaremos gran cantidad de apps que son capaces de transmitir datos, de muy variadas formas: terminales de texto, simuladores de controles de juego, controles remotos para autos, etc. Por su versatilidad, yo elegí la app llamada «Arduino Bluetooth Controller», que tiene varias funciones y es muy configurable. Puede encontrarse en Play Store.

Si alimentamos nuestro circuito, veremos que el led azul parpadea rápidamente, lo que indica que el HC05 no está conectado ni vinculado a otro dispositivo. ¿Qué significa esto? Dos dispositivos están conectados cuando están a una distancia mínima y operativos para que el bluetooth funcione y sea capaz de transmitir datos. Si el teléfono está apagado, por ejemplo, no puede existir conexión. Por otro lado, los dispositivos están vinculados (paired) cuando ya se han conectado y han intercambiado información de protocolo como la clave de conexión.


Una vez vinculados el teléfono y el HC05, ya podemos enviar datos. Podemos comprobar esta condición porque el led azul del HC05 parpadea lentamente, prendiendo dos veces (la tercera condición es cuando ya hay vinculación pero se pierde la conexión, lo que se evidencia porque el led parpadea lento, pero prende una sola vez). La app tiene cuatro modos de trabajo posibles: Controller, que simula un joystick, switch que funciona como un botón ON/OFF, Dimmer para realizar un control continuo, como el del brillo de una lámpara y Terminal para enviar y recibir texto. Para la primer prueba tocamos «Terminal Mode»


Una vez en el modo terminal, escribimos un texto y le damos al botón aceptar del teclado


 Si todo está bien conectado, la placa Arduino recibirá este texto por el módulo HC05 y lo mostrará en la terminal del IDE:


En todos los casos que queramos controlar algún dispositivo con Arduino (leds, relés, motores, etc) debemos seguir un procedimiento similar: contar con una app que envíe datos por bluetooth y un programa en el Arduino que los reciba y actúe de acuerdo a los datos recibidos. Si el proyecto consiste en activar y/o detener un motor, la app deberá contar con uno o dos botones que al ser pulsados envíen un código por ejemplo «1» y «2», según el caso y el programa del Arduino deberá esperar estos textos y  procesar la información según el código y activar el pin correspondiente.

En el menu de inicio de la app, podemos seleccionar la opción controller mode, nos presentará la siguiente pantalla con los botones de comando similares a los de una consola.

Si accedemos a la configuración nos aparecerán los botones y el código que tienen asociado, código necesario para procesar en nuestros programas de Arduino. Una vez que sabemos el código de cada botón ya podemos pasar a utilizar el app.



En el siguiente ejemplo hemos realizado un circuito para probar el funcionamiento del módulo bluetooth y la app. Se trata de un montaje con cuatro diodos led, su funcionamiento será el siguiente: Vamos a poder encender los diodos de uno en uno desde el teléfono móvil y después apagar los cuatro a la vez.


#include
SoftwareSerial ModuloHC05 (5, 6);  //pin TX, pin RX
 
SoftwareSerial ModuloHC05 (5, 6);  //pin TX, pin RX

#define pinLedRojo 13
#define pinLedVerde 12
#define pinLedAmarillo 11
#define pinLedBlanco 10
void setup()
{
  pinMode(pinLedRojo, OUTPUT);
  pinMode(pinLedVerde, OUTPUT);
  pinMode(pinLedAmarillo, OUTPUT);
  pinMode(pinLedBlanco, OUTPUT);
  Serial.begin(9600);     
  ModuloHC05.begin(9600);

}
void loop()
{
  char dato;
 if (ModuloHC05.available())   //Llega algo por bluetooth?
 {        
  dato=ModuloHC05.read();            //Leer el dato recibido
  Serial.write(dato);                       //Mostrar el dato por el monitor serie
    if (dato=='4')
      {
      digitalWrite(pinLedBlanco,HIGH);    //Si el dato recibido es "4", Encender el diodo led blanco     
      }
    if (dato=='7')
      {
      digitalWrite(pinLedRojo,HIGH);           //Si el dato recibido es "1", Encender el diodo led rojo
     
      }
      if (dato=='2')
      {
        //Apagar diodos
        digitalWrite(pinLedRojo,LOW);      
        digitalWrite(pinLedVerde,LOW);            
        digitalWrite(pinLedAmarillo,LOW);           
        digitalWrite(pinLedBlanco,LOW);    
      }
     
 if (dato=='3')
      digitalWrite(pinLedVerde,HIGH);         //Si el dato recibido es "1", Encender el diodo led verde
      if (dato=='6')
      digitalWrite(pinLedAmarillo,HIGH);          //Si el dato recibido es "2", Apagar el diodo led amarillo
  }
}



Ejemplo anterior modificado para controlar la posición de un servomotor, posicionar el ser en 0º, 90º y 180º, además se completa el circuito con tres diodos led que indican la posición del servo.

#include
SoftwareSerial ModuloHC05 (5, 6);  //pin TX, pin RX
#include // Importamos la librera servo

#define pinServo 3  //Pin donde se conecta el servo
#define pinLedRojo 13
#define pinLedVerde 12
#define pinLedAmarillo 11
#define pinLedBlanco 10
Servo myservo;  // creamos el objeto servo de tipo servo

void setup()
{
  myservo.attach(pinServo);
  pinMode(pinLedRojo, OUTPUT);
  pinMode(pinLedVerde, OUTPUT);
  pinMode(pinLedAmarillo, OUTPUT);
  pinMode(pinLedBlanco, OUTPUT);
  Serial.begin(9600);     
  ModuloHC05.begin(9600);

}
void loop()
{
  char dato;
 if (ModuloHC05.available()) //Llega algo por bluetooth?
 {        
  dato=ModuloHC05.read();   //Leer el dato recibido
  Serial.write(dato);       //Mostrar el dato por el monitor serie
   
    if (dato=='7') // Posicionar el servo en 0º
      {
        digitalWrite(pinLedRojo,HIGH);   //Si el dato recibido es "1", Encender el diodo led rojo
        myservo.write(0);              
        delay(15); 
        //damos tiempo al servo para moverse a la nueva posicion      //Si el dato recibido es "4", Encender el diodo led blanco     
      
      }
    
      if (dato=='3') // Posicionar el servo en 90º
      {
        myservo.write(90);              
        delay(15); 
        //damos tiempo al servo para moverse a la nueva posicion      //Si el dato recibido es "4", Encender el diodo led blanco     
        digitalWrite(pinLedVerde,HIGH);   //Si el dato recibido es "1", Encender el diodo led verde
      }
    
      if (dato=='6') // Posicionar el servo en 180 º
      {
       myservo.write(180);              
       delay(15); 
       //damos tiempo al servo para moverse a la nueva posicion
       digitalWrite(pinLedAmarillo,HIGH);   //Si el dato recibido es "2", Apagar el diodo led amarillo
      }
      if (dato=='2')
       {
        //Apagar diodos
        digitalWrite(pinLedRojo,LOW);      //Si el dato recibido es "2", Apagar el diodo led  rojo
        digitalWrite(pinLedVerde,LOW);     //Si el dato recibido es "2", Apagar el diodo led verde
        digitalWrite(pinLedAmarillo,LOW);  //Si el dato recibido es "2", Apagar el diodo led amarillo
        digitalWrite(pinLedBlanco,LOW);    //Si el dato recibido es "2", Apagar el diodo led blanco
        myservo.write(0);  // Posicionar el servo en 0º            
        delay(15); 
        //damos tiempo al servo para moverse a la nueva posicion 
       }
  
  }
}



¿Qué es un higrómetro FC-28?

Un higrómetro de suelo FC-28 es un sensor que mide la humedad del suelo. Son ampliamente empleados en sistemas automáticos de riego para detectar cuando es necesario activar el sistema de bombeo.

El FC-28 es un sensor sencillo que mide la humedad del suelo por la variación de su conductividad. No tiene la precisión suficiente para realizar una medición absoluta de la humedad del suelo, pero tampoco es necesario para controlar un sistema de riego.

El FC-28 se distribuye con una placa de medición estándar que permite obtener la medición como valor analógico o como una salida digital, activada cuando la humedad supera un cierto umbral.

Los valores obtenidos van desde 0 sumergido en agua, a 1023 en el aire (o en un suelo muy seco). Un suelo ligeramente húmero daría valores típicos de 600-700. Un suelo seco tendrá valores de 800-1023.

La salida digital dispara cuando el valor de humedad supera un cierto umbral, que ajustamos mediante el potenciómetro. Por tanto, obtendremos una señal LOW cuando el suelo no está húmedo, y HIGH cuando la humedad supera el valor de consigna.

El valor concreto dependerá del tipo de suelo y la presencia de elementos químicos, como fertilizantes. Además, no todas las plantas requieren la misma humedad, por lo que lo mejor es que hagáis una pequeña calibración en el terreno real.

Precio

El sensor de humedad FC-28 es realmente barato. Podemos encontrarlo por 0,85€ en vendedores internacionales de Ebay y Aliexpress.


Esquema de montaje

El esquema eléctrico es sencillo. Alimentamos el módulo conectando GND y 5V a los pines correspondientes de Arduino.

Ahora si queremos usar la lectura analógica, conectamos la salida A0 a una de las entradas analógicas de Arduino.


Mientras que la conexión vista desde Arduino quedaría así,
 



Si quisiéramos emplear el valor digital, que se ajusta con el potenciómetro de la placa, en su lugar conectaríamos la salida D0 del sensor a una entrada digital de Arduino.

Ejemplos de código

El código necesario es realmente sencillo. Si estamos empleando la señal analógica A0, leemos el valor mediante la entrada analógica, y usamos el puerto serie para mostrar el valor por pantalla. En un caso real, este valor se emplearía para ejecutar acciones, en lugar de mostrar el valor.

#define sensorPin  A0

void setup() {
Serial.begin(9600);
}

void loop()
{
int humedad = analogRead(sensorPin);
Serial.print(humedad);

if(humedad <= 500)
{
Serial.println("Encendido");
//hacer las acciones necesarias
}
delay(1000);
}


Si estamos empleando la señal digital, empleamos una entrada digital para leer el estado. En el ejemplo mostramos un mensaje por la pantalla, pero igualmente en un caso real ejecutaríamos las acciones oportunas.


#define sensorPin  A0

void setup()
{
Serial.begin(9600);
pinMode(sensorPin, INPUT);
}

void loop()
{
int humedad = digitalRead(sensorPin);

//mandar mensaje a puerto serie en función del valor leído
if (humedad == HIGH)
{
Serial.println("Encendido");
//aquí se ejecutarían las acciones
}
delay(1000);
}

Robot seguidor de líneas


Propuesta

El objetivo de nuestro proyecto será crear un robot móvil que siga el recorrido marcado por una línea negra. El robot detectará con sensores de infrarrojos la presencia de la línea negra para poder rectificar su trayectoria y seguir el recorrido marcado por la misma.

Descripción

Los robots seguidores de línea son robots muy sencillos, que cumplen una única misión: seguir una línea marcada en el suelo normalmente de color negro sobre un tablero blanco (normalmente una línea negra sobre un fondo blanco). 

Componentes 

Estos robots pueden variar desde los más básicos (van tras una línea única) hasta los robots que recorren laberintos. Todos ellos, sin embargo, poseen (por lo general) ciertas partes básicas comunes entre todos: 

Sensores: Un rastreador detecta la línea a seguir por medio de sensores. Hay muchos tipos de sensores que se pueden usar para este fin; sin embargo, por razones de costos y facilidad de uso, los más comunes son los sensores infrarrojos (IR), que normalmente constan de un LED infrarrojo y un fototransistor, la línea a seguir, puede ser de color negro con fondo blanco o línea blanca con fondo negro.


Motores: El robot se mueve utilizando motores. Dependiendo del tamaño, el peso, la precisión del motor, entre otros factores, éstos pueden ser de varias clases: motores de corriente continua, motores paso a paso o servomotores.


Ruedas: Las ruedas del robot son movidas por los motores. Normalmente se usan ruedas de materiales anti-deslizantes para evitar fallas de tracción. Su tamaño es otro factor a tener en cuenta a la hora de armar el robot. 


Fuente de energía: El robot obtiene la energía que necesita para su funcionamiento de baterías.



Tarjeta de control: La toma de decisiones y el control de los motores están generalmente a cargo de Arduino UNO ( rev3).

Circuito eléctrico




Código del programa Arduino A continuación se muestra el código Arduino que implementa la funcionalidad..  Acceder al sketch

Maqueta de un invernadero

Propuesta de trabajo

 El problema técnico que hay que abordar consiste en analizar, diseñar y construir un invernadero que incorpore los siguientes sistemas: 
  1. Apertura (manual o mecánica) de algunos elementos estructurales (techo, paredes, ventanas…) que permita la ventilación del mismo. 
  2. Sobre las vigas del techo debe existir una iluminación artificial. 
  3. Sistema automático de riego de las plantas (depósito, tuberías y sensores). 
  4. Sistema de ventilación.
  5. Sistema de control basado en Arduino

DISEÑO DE LA SOLUCIÓN

Antes de empezar a construir es necesario responder las siguientes preguntas: ¿Cuál será la forma del invernadero? ¿Cuáles son sus elementos? ¿Qué dimensiones tienen? ¿Cómo se unen los diferentes elementos para conseguir la forma final? Esto será tarea del alumno/a.

Se deben de tener en cuenta las Siguientes consideraciones:

  • Toda la estructura del invernadero se apoya sobre una plataforma de aglomerado. 
  • Las vigas y pilares de la estructura son listones de madera.
  • La cubierta estará compuesta en parte o totalmente de un toldo abatible con lo cual debe estar inclinada (la cubierta) 
  • En todo momento hay que tener en cuenta la ubicación de otros elementos que se irán incluyendo (poleas, correas de transmisión, varillas, interruptores final de carrera, LDR, NTC, etc….)
  • En el exterior y sobre una estructura de listones o sobre base de aglomerado se situará un recipiente con la bomba de agua.
  • En el interior se instalará un sistema de riego mediante tubos de plástico y se ha controlar el riego según la humedad.
Materiales

Materiales para la estructura

  • Aglomerado.
  • Contrachapado.
  • DM
  • Listones de madera.
  • Alambre de 2 mm de sección (cubierta túnel).
  • Lona de plástico.
  • Puntillas, tornillos, grapas, …


Materiales para el riego

  • Tubos y depósito de plástico..
  • Bomba de riego.
  • Sensor de humedad.

 Sistema de control

  • Arduino UNO.
  • Cables.
  • Sensor de humedad.
  • Ldr.
  • Diodos led.
  • Display LCD.
  • Placa protoboard.


Otros materiales

  • Poleas
  • Correas
  • Pila
  • Lámparas.
  • Cables, interruptor, ...

Receptor de infrarrojos


Estamos tan acostumbrados a los mandos a distancia infrarrojos que no dedicamos un momento a pensar en ellos y simplemente nos parece normal, algo que a nuestros abuelos les hubiera parecido magia.
Nos parece normal que los equipos electrónicos, televisores, cadenas de música, aires acondicionados, respondan a nuestras instrucciones sin levantarnos del sofá, pero esto no ha sido siempre así, es más, es relativamente reciente, que estos mandos se popularizaron.
Pero el concepto de la emisión y recepción de señales infrarrojas no es, ni mucho menos trivial, y exige tener nociones de ondas electromagnéticas (energía, frecuencia, longitud, etc...) que sobrepasan nuestro nivel. No obstante para aquellos que queráis profundizar más en el tema os recomiendo la excelente descripción del artículo de Prometec sobre sensores infrarrojos.

Un típico receptor de infrarrojos, es el AX-1838HS, que se consigue por poco más de unos euros. En su hoja de normas encontráis este diagrama, y son relativamente fáciles de encontrar, en dos formas. Independientes y montados en un soporte para utilizar sin complicaciones con nuestros Duinos. 





El esquema de conexión nuevamente es trivial, pues el AX-1838HS solo tiene 3 pines: Vcc, GND y señal.

El objetivo de este ejercicio es aprender a recibir señales infrarrojas mediante un sensor/receptor IR emitidas por un mando a distancia de infrarrojo.

Circuito eléctrico



Con lo que bastará con conectar la patilla GND al pin GND de Arduino, la patilla VCC al pin 5V de Arduino y la patilla DAT (señal) a cualquier salida digital de Arduino, en nuestro caso, lo haremos al pin digital 9.

Ejemplos de código
Existen múltiples librerías para emplear mandos a distancia con Arduino. Nosotros usaremos la librería Arduino-IRremote desarrollada por Rafi Khan (z3t0) disponible en este enlace.

El siguiente código realiza la lectura del valor recibido por el mando, y lo muestra por pantalla. El código se muestra en formato hexadecimal.
 
// Incluir la librería para trabajar con el sensor IR

#include "IRremote.h"

// Definición de variables y constantes relacionadas con el sensor infrarrojos

const int RECV_PIN=9; // Pin digital 9 para conectar el sensor

IRrecv irrecv(RECV_PIN);  // Se crea un nuevo objeto para trabajar con el sensor

decode_results results;


void setup()
{
Serial.begin(9600);  // Se inicia el puerto de comunicaciones en serie

irrecv.enableIRIn(); // Se inicia el receptor IR

}
void loop()
{
if(irrecv.decode)(&results)
{
Serial.println(results.value, HEX);
irrecv.resume();
}
}

Armazón o esqueleto del robot

El armazón es como el esqueleto de un ser humano. Es la parte que soporta los componentes del que esta compuesto el robot. Una característica es su robustez, el tipo de material, facilidad para el cambio y del tipo de trabajo a desempeñar.

En nuestro caso, vamos a montar el siguiente armazón:

Base, para la base vamos a utilizar una madera de DM de 3 mm de grosor, debido a que no se pandea y es muy rígida.

Realizar el siguiente dibujo:

Cortar la pieza utilizando una sierra de marquetería, para así obtener la base del robot.

Lijar los bordes y después pintar la pieza obtenida.


Pegar con cola termofusible los motores reductores a la base de la estructura, por su parte inferior.

Motor reductor con neumático

Fijar mediante tornillos la rueda loca a la base.

Rueda loca
En la siguiente imagen se muestra el esqueleto del robot.

Esqueleto del robot

Por último colocar la placa de Arduino UNO, la placa protoboard y la batería sobre la base del robot.

Esqueleto del robot

Este esqueleto nos va a permitir  implementar diferentes robots cuyo funcionamiento siempre va a depender del sensor o sensores instalados.