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
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...
El diseño es libre y cada alumn@ debe de fabricar su propio robot..
Las dimensiones son reducidas, la maqueta del robot no debe superar los 15 cm de altura..
Es obligatorio tener una caja
personalizada para guardar el proyecto una vez terminado y los
materiales durante la fase de fabricación..
Se puede trabajar en casa y en el aula de tecnología.
Es obligatorio terminar las tareas propuestas hasta la fecha.
Documentación que hay que presentar
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
Instagram se puede obtener información sobre proyectos realizados en cursos anteriores: #proyectosolidosirregulares
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.
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:
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:
Guardo en valor lo que marca el potenciómetro.
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º).
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);
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.
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);
}
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:
{
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.
}
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.
} 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 }
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);
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.
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);
}
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
