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);
}