Crear juguetes reciclando

 Propuesta de trabajo

Siguiendo el método de proyectos tecnológicos, diseña y construye la maqueta de un robot pequeño utilizando materiales reciclados. Debes tener en cuenta las siguientes condiciones:

Obligatorias

  1. Tendrán que ser realizados con trozos de madera y materiales reciclados, como pueden ser: botones, tapones de envases, tornillos, tuercas y restos de diferentes materiales  como pueden ser alambre, cuerdas, etc...

  2. El diseño es libre y cada alumn@ debe de fabricar su propio robot..

  3. Las dimensiones son reducidas, la maqueta del robot no debe superar los 15 cm de altura..

  4. Es obligatorio tener una caja personalizada para guardar el proyecto una vez terminado y los materiales durante la fase de fabricación..

  5. Se puede trabajar en casa y en el aula de tecnología.

  6. Es obligatorio terminar las tareas propuestas hasta la fecha.

Documentación que hay que presentar

  1. Memoria técnica. La redacción se deberá realizar con un procesador de textos (google docs, word, writer..) o editor de presentaciones (Prower point, presentaciones de google, genially, canva...). En el siguiente enlace puedes encontrar información sobre la elaboración de la memoria técnica Cómo redactar la memoria técnica


     

Puedes ampliar información

¿Cómo alimento mi Arduino?


Así que vamos a hacer un repaso de algunas de las opciones de alimentación más comunes de las placas Arduino. Para alimentar tu proyecto puedes repasar esta lista en orden y elegir la primera fuente que cumpla con las características que necesitas o deseas, porque voy a repasarlas de las más sencillas a las más especiales.

El puerto USB

Allá donde haya un puerto USB puedes alimentar tu Arduino. Sin más complicaciones. El puerto USB es la fuente de alimentación más fácil y segura de utilizar con Arduino. Si estás aprendiendo, utiliza una de las siguientes opciones USB siempre que puedas.

El puerto USB del ordenador

Cuando conectamos nuestro Arduino al ordenador por el puerto USB ya lo estamos alimentando:
  • Voltaje de 5V de forma continua. Estupendo para trabajar con él y alimentar todo tipo de accesorios.
  • Puede entregar hasta 500 mA.
  • Necesitamos el ordenador. ¡Qué fuente de alimentación más cara!
  • Por lo general el ordenador tiene que estar encendido para que los puertos USB tengan alimentación (aunque depende de las capacidades de tu ordenador).
  • Si le pedimos más de 500mA podemos dañarlos y dejarlos inservibles. Están protegidos de exceso de corriente, ¿pero quién quiere poner la protección a prueba? 

Cargador de móvil


Igual que podemos alimentar Arduino con el puerto USB del ordenador, podemos hacerlo con cualquier fuente de alimentación USB, como un cargador de móvil. Muchas placas Arduino no tienen conector MicroUSB como los móviles, pero puedes coger uno de esos cargadores que tienen un puerto USB y el cable se puede desconectar. ¡A esos cargadores puedes ponerle cualquier cable USB!
  • Voltaje de 5V de forma continua. Estupendo para trabajar con él y alimentar todo tipo de accesorios.
  • Pueden entregar al menos 1A de corriente (excepto los más antiguos). Los más modernos superan los 2A. La corriente máxima la encontramos en la etiqueta del cargador.
  • No pasa por el regulador de 5V de Arduino, que está limitado a 800mA. Pasa por un transistor P-MOSFET que soporta corrientes de 2,4A de forma continua.
  • Muy económico.
  • Fácilmente disponible.

Powerbank

¡Fuera cables! Los powerbanks tienen puertos USB, ¿verdad? Pues entonces podemos alimentar nuestro Arduino.

Voltaje de 5V de forma continua. Estupendo para trabajar con él y alimentar todo tipo de accesorios.
  • La corriente máxima depende del estado de carga de la batería interna. Cuando está llena fácilmente supera 1 y 2A.
  • No pasa por el regulador de 5V de Arduino, que está limitado a 800mA. Pasa por un transistor P-MOSFET que soporta corrientes de 2,4A de forma continua.
  • Muy económico.
  • Fácilmente disponible.
  • ¡Vivan los proyectos móviles!
  • Recargable por el conector de carga del powerbank, sin circuitería adicional.
El pin VIN

En los pines de Arduino puedes encontrar uno etiquetado como VIN. ¡Úsalo con cuidado! El pin VIN tiene dos funcionalidades:

Si estamos alimentando Arduino por cualquiera de sus conectores, en el pin VIN tendremos el voltaje bruto de alimentación. Es decir, si estamos alimentando Arduino por USB, en VIN tendremos 5V que podemos utilizar para alimentar otros accesorios. Si estamos alimentando Arduino a través del conector jack, en VIN tendremos el mismo voltaje que tenga la fuente de alimentación que estamos utilizando.

Si NO estamos alimentando Arduino por ninguno de sus conectores, podemos utilizar el pin VIN y un GND para alimentar la placa. Las características de la fuente son las mismas que las del conector jack, pues hace uso del mismo regulador de 5V para regular su voltaje.
  • Sin necesidad de conector. Solo necesitas 2 cables: el negativo a GND y el postivo a VIN. 
  • Perfecto para portapilas y otras fuentes de alimentación sin conector. 
  • Puedes utilizar reguladores de tensión externos.

Aplicación de la función map()

Controlar la posición del eje de un servomotor con un potenciómetro

En ocasiones, los valores que obtenemos de una lectura de un pin analógico, como un sensor, pueden estar fuera de una escala determinada, y tenemos que convertirlos a otro rango para poder usarlos.

El valor de salida que podemos darle al servomotor es de 0 a 180, que se traduce en la posición del eje, pero los datos que leemos del sensor pueden llegar a 1024. Por esto debemos mapear el resultado, es decir , dejarlo en unos valores de entre 0 y  180.

La función “map” del programa asigna un valor máximo y un valor mínimo a un rango dado.

El valor máximo suele estar en 1024, pero el mínimo en nuestro caso será 0. Por eso en el código se especifican las siguientes valores:

valorPotenciometro = analogRead(potenciometro);
posicion = map(valor, 0, 1023, 0, 180);

valor = map(valor que recibo, de Mínimo, de Máximo, a Mínimo, a Máximo)

Descripción

Re-asigna un número de una gama de valores a otra.

Parámetros


valor que recibo: el número a mapear   valorPotenciometro=(analogRead(potenciometro)
deMínimo: el límite inferior del rango actual del valor  (0)
deMáximo: el límite superior del rango actual del valor (1023)
aMínimo: el límite inferior del rango resultado del valor (0)
aMáximo: el límite superior del rango resultado del valor (180)

Valor retornado por la función

El valor mapeado. (posicion)

La función map () usa números enteros por lo que no va a generar decimales, cuando las operaciones matemáticas podrían indicar que debería hacerlo. Los decimales remanentes se truncan, y no son redondeados o promediados.

Nota: No restringe los valores dentro del rango, ya que los valores fuera de la gama a veces se entiende que son útiles. La función constrain () se puede usar antes o después de esta función, si se desean límites de los intervalos.

El código correspondiente al void loop(), se corresponderá con las siguientes acciones:
  1. Guardo en valor lo que marca el potenciómetro.
  2. Mapeo el valor que su rango original es de 0-1023 a 0-180 que es lo que me interesa para controlar la posición del eje del sermovotor (0-180º).
  3. Posicionar el servomotor.

// sketch para controlar la posición del eje de un servomotor

#include

// Incluimos la librería para poder controlar el servo

int valorPotenciometro=0;
int posicion=0;
// Declaramos la variable para controlar el servo
Servo servoMotor;

void setup() {
  // Iniciamos el monitor serie para mostrar el resultado
  Serial.begin(9600);

  // Iniciamos el servo para que empiece a trabajar con el pin 9
  servoMotor.attach(9);
}

void loop() {
 valorPotenciometro=analogRead(0); //Leemos el valor del potenciometro
    posicion = map(valorPotenciometro, 0, 1023, 0, 180);
    servoMotor.write(posicion);
   
}
 






Ejemplo 2 Control del brillo de un diodo led

#define pinLed 5
int valorPotenciometro=0;
int brillo=0;

void setup() {
 pinMode(pinLed, OUTPUT);

}

void loop() {
valorPotenciometro=analogRead(0); //Leemos el valor del potenciometro
    brillo = map(valorPotenciometro, 0, 1023, 0, 255);
 
  analogWrite(pinLed,brillo);
}
 






¿Qué son los potenciómetros?

Un potenciómetro es un resistor eléctrico con un valor de resistencia variable y generalmente ajustable manualmente. Los potenciómetros utilizan tres terminales. En muchos dispositivos eléctricos los potenciómetros son los que establecen el nivel de salida. Por ejemplo, en un altavoz el potenciómetro ajusta el volumen; en un televisor o un monitor de ordenador se puede utilizar para controlar el brillo.


El valor de un potenciómetro viene expresado en ohmios (símbolo Ω) como las resistencias, y el valor del potenciómetro siempre es la resistencia máxima que puede llegar a tener. La mínimo lógicamente es cero. Por ejemplo un potenciómetro de 10KΩ puede tener una resistencia variable con valores entre 0Ω y 10.000Ω.

Los potenciómetros que encontramos en el mercado vienen con un valor de resistencia determinado. Estos valores han sido estandarizados y solamente encontraremos valores de resistencia específicos, por ejemplo 1K, 5K, 10k, 50k, 100k, etc. Este valor de resistencia lo podemos medir entre las terminales 1 y 3 del potenciómetro.

Su símbolo es básicamente, el símbolo de una resistencia con una flecha que nos indica que podemos variar su valor.



La capacidad de variar la resistencia entre 2 terminales y mantenerla entre sus extremos permite que los potenciómetros se utilicen como variadores de tensión. En ciertas aplicaciones se necesita establecer un nivel de tensión de referencia. Para esto se emplea un potenciómetro conectando la patas 1 y 3 a una fuente de voltaje y a tierra, respectivamente. Veamos el diagrama:

En Arduino vamos a utilizar los potenciómetros para variar por ejemplo la intensidad de luz de un diodo led, variar la velocidad de giro de un motor, variar la posición del eje de un servomotor, etc..

El potenciómetro tiene tres patillas, la 1 la vamos a conectar a 5 v, la 3 a GND y la central a una entrada analógica (en esta patilla obtendremos un valor variable comprendido entre 0 y 5 v).


Los valores medidos por el pin analógico pueden ser utilizados como valores de una variable de nuestro programa para hacer algo o tomar decisiones, como, por ejemplo, variar la intensidad de luz. Para ello, usaremos la función analogRead.

Esta función devolverá un valor comprendido entre 0 y 1023, que generalmente se guardará en una variable.

analogRead(pin)

En el siguiente ejemplo utiliza un potenciómetro para encender cinco diodos LEDs, en función de la posición en la que se encuentre el cursor.



 Acceder al sketch: Encendido de 5 diodos leds





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