Archivo de la categoría: Programación

Arduino: bibliotecas de funciones personales

A menudo tenemos fragmentos de código con funciones que podemos reutilizar en muchos programas. Algo muy habitual en programación. Creamos una función que resuelve una necesidad concreta y queremos tenerla disponible para reutilizarla en cualquier otro programa en el que debamos resolver la misma necesidad.

Lo habitual —pero no lo más práctico— es copiar el código de esa función especial dentro de cada nuevo programa. Pero conviene tenerla en un formato reutilizable con facilidad, sobre todo si la función es muy extensa.

Para lograrlo, guardamos esa función (y todas las variables y constantes que incluya) en un archivo .ino separado, pero no debemos cargarlo individualmente en una placa Arduino, sino que luego lo incluiremos en cada programa que necesitemos, de al modo que siempre lo tendremos disponible.

( Nota: no le llamamos “sketch” sino “programa” para Arduino. )

¿Cómo incluimos un trozo de programa en otro?

Vamos a crear un código reutilizable, y lo guardaremos en una ubicación conocida del disco, un “reservorio” de funciones útiles que llevan un nombre que nos recuerde qué es y lo que hace.

Quedará con la extensión .INO, pero no es un programa para cargar al Arduino y ejecutarlo. Queda con esa extensión porque todos los programas editados en la IDE de Arduino se graban siempre con la extensión .ino.

El código es uno que hayamos creado como función o grupo de funciones dentro de un programa mayor.

Tomaremos como ejemplo una cantidad de funciones creadas para los distintos movimientos de los motores en un programa para un robot navegador.

El circuito que este programa mueve, para mejor comprensión de los ejemplos, es este:

Veamos el programa original con las funciones incluidas dentro de él:

/*
Control de motores CC usando el modulo L298N.
El programa activa los motores en un sentido por 
4 segundos, los detiene 500 ms, activa los 
motores en sentido inverso por 4 segundos y 
por ultimo se detiene por 5 segundos. 
Luego repite la accion indefinidamente. */

int IN1 = 9;
int IN2 = 8;
int IN3 = 5;
int IN4 = 4;

void setup()
{
pinMode (IN2, OUTPUT); // Input2 conectada al pin 2
pinMode (IN1, OUTPUT); // Input1 conectada al pin 3
pinMode (IN4, OUTPUT); // Input4 conectada al pin 4
pinMode (IN3, OUTPUT); // Input3 conectada al pin 5
}

void loop()
{
// Motor gira adelante
adelanteDerecho();
adelanteIzquierdo();
retardo(4000);

// Motor no gira
pararDerecho();
pararIzquierdo();
retardo(500);

// Motor gira atras
atrasDerecho();
atrasIzquierdo();
retardo(4000);

// Motor no gira
pararDerecho();
pararIzquierdo();
retardo(5000);
}

/* FUNCIONES DE MANEJO DE MOTOR */

void adelanteDerecho()
{
digitalWrite (IN4, LOW);
digitalWrite (IN3, HIGH);
}
void adelanteIzquierdo()
{
digitalWrite (IN2, LOW);
digitalWrite (IN1, HIGH);
}

void atrasDerecho()
{
digitalWrite (IN4, HIGH);
digitalWrite (IN3, LOW);
}
void atrasIzquierdo()
{
digitalWrite (IN2, HIGH);
digitalWrite (IN1, LOW);
}

void pararDerecho()
{
digitalWrite (IN4, LOW);
digitalWrite (IN3, LOW);
}
void pararIzquierdo()
{
digitalWrite (IN2, LOW);
digitalWrite (IN1, LOW);
}
void retardo(int valor)
{
  delay(valor);
}

Control de motores CC usando el modulo L298N.

El programa activa los motores en un sentido por

4 segundos, los detiene 500 ms, activa los

motores en sentido inverso por 4 segundos y

por ultimo se detiene por 5 segundos.

Luego repite la accion indefinidamente. */

int IN1 = 9;

int IN2 = 8;

int IN3 = 5;

int IN4 = 4;

void setup()

{

pinMode (IN2, OUTPUT); // Input2 conectada al pin 2

pinMode (IN1, OUTPUT); // Input1 conectada al pin 3

pinMode (IN4, OUTPUT); // Input4 conectada al pin 4

pinMode (IN3, OUTPUT); // Input3 conectada al pin 5

}

void loop()

{

// Motor gira adelante

adelanteDerecho();

adelanteIzquierdo();

retardo(4000);

// Motor no gira

pararDerecho();

pararIzquierdo();

retardo(500);

// Motor gira atras

atrasDerecho();

atrasIzquierdo();

retardo(4000);

// Motor no gira

pararDerecho();

pararIzquierdo();

retardo(5000);

}

/* FUNCIONES DE MANEJO DE MOTOR */

void adelanteDerecho()

{

digitalWrite (IN4, LOW);

digitalWrite (IN3, HIGH);

}

void adelanteIzquierdo()

{

digitalWrite (IN2, LOW);

digitalWrite (IN1, HIGH);

}

void atrasDerecho()

{

digitalWrite (IN4, HIGH);

digitalWrite (IN3, LOW);

}

void atrasIzquierdo()

{

digitalWrite (IN2, HIGH);

digitalWrite (IN1, LOW);

}

void pararDerecho()

{

digitalWrite (IN4, LOW);

digitalWrite (IN3, LOW);

}

void pararIzquierdo()

{

digitalWrite (IN2, LOW);

digitalWrite (IN1, LOW);

}

void retardo(int valor)

{

delay(valor);

}

Ahora vamos a escribir un programa diferente, con otra serie de movimientos. Suponemos que estamos editando en el IDE de Arduino, como sigue:

int IN1 = 9;
int IN2 = 8;
int IN3 = 5;
int IN4 = 4;

void setup()
{
pinMode (IN2, OUTPUT); // Input2 conectada al pin 2
pinMode (IN1, OUTPUT); // Input1 conectada al pin 3
pinMode (IN4, OUTPUT); // Input4 conectada al pin 4
pinMode (IN3, OUTPUT); // Input3 conectada al pin 5
}

void loop()
{
adelanteDerecho(); // Motores giran adelante
adelanteIzquierdo();
retardo(1000);

atrasDerecho(); // Motores giran atras
atrasIzquierdo();
retardo(1000);
}

int IN1 = 9;

int IN2 = 8;

int IN3 = 5;

int IN4 = 4;

void setup()

{

pinMode (IN2, OUTPUT); // Input2 conectada al pin 2

pinMode (IN1, OUTPUT); // Input1 conectada al pin 3

pinMode (IN4, OUTPUT); // Input4 conectada al pin 4

pinMode (IN3, OUTPUT); // Input3 conectada al pin 5

}

void loop()

{

adelanteDerecho(); // Motores giran adelante

adelanteIzquierdo();

retardo(1000);

atrasDerecho(); // Motores giran atras

atrasIzquierdo();

retardo(1000);

}

Pero así no funcionaría, ya que tiene llamados a funciones (como adelanteDerecho, atrasIzquierdo, etc.) que están en otro lugar.

De modo que abrimos el programa que las tiene, copiamos las funciones que necesitamos…

… y las pegamos en una ventana vacía del IDE. Luego las guardamos con Guardar como… en la carpeta que deseemos. A esta carpeta podemos llamarla, por ejemplo: /FuncionesUtiles/

El archivo de funciones que creamos y guardamos es este: FuncionesMotor.ino, y es así:

/* FUNCIONES DE MANEJO DE MOTOR */

void adelanteDerecho()
{
digitalWrite (IN4, LOW);
digitalWrite (IN3, HIGH);
}
void adelanteIzquierdo()
{
digitalWrite (IN2, LOW);
digitalWrite (IN1, HIGH);
}

void atrasDerecho()
{
digitalWrite (IN4, HIGH);
digitalWrite (IN3, LOW);
}
void atrasIzquierdo()
{
digitalWrite (IN2, HIGH);
digitalWrite (IN1, LOW);
}

void pararDerecho()
{
digitalWrite (IN4, LOW);
digitalWrite (IN3, LOW);
}
void pararIzquierdo()
{
digitalWrite (IN2, LOW);
digitalWrite (IN1, LOW);
}
void retardo(int valor)
{
  delay(valor);
}

/* FUNCIONES DE MANEJO DE MOTOR */

void adelanteDerecho()

{

digitalWrite (IN4, LOW);

digitalWrite (IN3, HIGH);

}

void adelanteIzquierdo()

{

digitalWrite (IN2, LOW);

digitalWrite (IN1, HIGH);

}

void atrasDerecho()

{

digitalWrite (IN4, HIGH);

digitalWrite (IN3, LOW);

}

void atrasIzquierdo()

{

digitalWrite (IN2, HIGH);

digitalWrite (IN1, LOW);

}

void pararDerecho()

{

digitalWrite (IN4, LOW);

digitalWrite (IN3, LOW);

}

void pararIzquierdo()

{

digitalWrite (IN2, LOW);

digitalWrite (IN1, LOW);

}

void retardo(int valor)

{

delay(valor);

}

Ahora sólo debemos ver cómo hacemos para incluir el archivo de funciones auxiliares en nuestro nuevo programa.

Para eso desplegamos el menú Programa en la barra de menúes de la parte superior del IDE. Seleccionamos la opción Añadir fichero… y se nos abre un cuadro de diálogo para que busquemos el .ino que guardamos allí, con las funciones de motor que queremos incluir en este programa nuevo.

Lo abrimos, como si fuera un .ino estándar, pero, debido a la opción que hemos elegido, en lugar de abrirse en una nueva ventana del IDE se abre en una nueva pestaña auxiliar de la misma ventana. Nuestra ventana de trabajo queda como vemos aquí:

Ya podemos regresar a la pestaña principal, compilar y subir el programa al Arduino.

Cuando guardemos este programa principal, y volvamos a abrirlo otro día, el IDE de Arduino se abrirá con las dos pestañas. Si se observa dentro de la carpeta que, como es habitual, lleva el nombre del programa (en este ejemplo Otro_control_de_motores) veremos que dentro de ella están los dos archivos .ino: Otro_control_de_motores.ino y FuncionesMotor.ino

Esto no significa que el IDE haya movido FuncionesMotor.ino desde la carpeta /FuncionesUtiles/ que creamos, sino que sólo lo ha copiado. Así que, por supuesto, este archivo .ino de funciones auxiliares para adjuntar podemos incluirlo en todos los programas donde sea necesario. No será propiedad exclusiva de ninguno de ellos.

Uso de la placa L298N para motores de CC

3 respuestas

Este artículo es el paso 1 para ir adelantando explicaciones sobre el funcionamiento de un robot navegador con dos sensores de obstáculos al frente y uno en la parte trasera, que publicaré en breve. Nos muestra cómo se debe utilizar la placa de manejo (doble puente H) L298N para controlar un motor de CC.

Este módulo tan común en el Mercado, basado en el chip L298, permite controlar dos motores de corriente continua, o un motor paso a paso bipolar, en ambos casos de hasta 2 A por salida.

Diagrama de circuito del circuito integrado L298

El módulo es autosuficiente para funcionar en el control de los motores, sin que sea necesario disponer de elementos adicionales. Ya tiene los diodos de protección de contracorriente y un regulador LM78M05 interno que suministra 5V a la parte lógica del integrado L298.

La salida en la bornera A esta compuesta por las líneas OUT1 y OUT2, y la salida B por OUT3 y OUT4.

En la parte inferior se encuentran los pines de control del módulo, marcados como IN1, IN2, IN3 e IN4. A los lados de estas señales encontramos un pin de 5V preparado para colocar puentes de selección (jumpers) que habilitar cada una de las salidas del módulo, A y B). Los pines de habilitación son nombrados, respectivamente, ENA y ENB (por la palabra en inglés Enable = habilitación).

Conexión de alimentación

Este módulo se puede alimentar de dos maneras: utilizando o no el regulador LM7805 integrado en la placa.

El módulo permite ingresar una alimentación para los motores y lógica de entre 6V a 12V CC (7,5V a 12V si se está utilizando el regulador interno, 78M05).

Cuando el puente de selección de 5V se encuentra activo, dado que de esta manera el regulador se encuentra activo, el pin marcado como +5V tendrá un voltaje de salida de 5V CC. Este voltaje alimenta dentro de la placa la lógica del chip, y también se puede usar para dar alimentación a la parte de control del módulo, ya sea un microcontrolador de otro tipo o una placa Arduino, pero recomendamos que el consumo externo que se tome de la placa L298N no supere los 500 mA.

Cuando el jumper de selección de 5V es retirado, el módulo admite una alimentación más amplia para los motores: de entre 12V a 35V CC. Como en este caso el regulador interno 78M05 no se utiliza, tendremos que conectar el pin de +5V a una tensión de 5V externa, regulada, para alimentar la parte lógica del L298N. Usualmente esta tensión puede ser la misma de la parte de control, ya sea un microcontrolador de otra línea o una placa Arduino.

No se debe conectar una tensión de entrada al pin de +5V cuando se encuentre colocado el puente de selección de 5V. Esto provocaría un conflicto entre ambas fuentes de alimentación y podría dañar permanentemente el módulo.

Control de un motor de CC

Como demostración, vamos a controlar un motor de CC usando la salida B del módulo. El pin de habilitación ENB se mantiene en ALTO por medio de la conexión al pin 3 del Arduino, puesto en ALTO por el programa. Opcionalmente se puede conectar ENB a +5V con el jumper (marcado amarillo en los diagramas) —como se observa en la imagen de abajo—, aunque luego deberemos modificar la conexión para el segundo ejercicio.

El ejemplo fue desarrollado en Arduino UNO, pero el código es compatible con cualquier Arduino.

Esquema de conexión del ejemplo 1

Tabla de señales de control

Código en el Arduino – Ejemplo 1

El programa activará el motor en un sentido por cuatro segundos, luego detiene el motor por medio segundo, después activa el motor en sentido inverso por cuatro segundos, y por último detiene el motor durante cinco segundos. Este ciclo se repite indefinidamente.

/*
Ejemplo de control de motor CC usando modulo L298
El programa activa el motor en un sentido por 4 segundos,
para el motor por 500 ms, activa el motor en sentido inverso por 4 segundos
y se detiene por 5 segundos. Se repite indefinidamente.
*/
int ENB = 3;  // ENB conectada al pin 3 / SIN EL JUMPER EN ENB
int IN3 = 5;  // Input4 conectada al pin 4
int IN4 = 4;  // Input3 conectada al pin 5

void setup()
{
pinMode(ENB, OUTPUT);  // ENB
pinMode(IN4, OUTPUT);  // Input4
pinMode(IN3, OUTPUT);  // Input3
digitalWrite(ENB,HIGH);  // ALTO habilita la salida B / SIN EL JUMPER EN ENB
}

void loop()
{
// Motor gira en un sentido
digitalWrite(IN4, HIGH);
digitalWrite(IN3, LOW);
delay(4000);
// Motor no gira
digitalWrite(IN4, LOW);
delay(500);
// Motor gira en sentido inverso
digitalWrite(IN3, HIGH);
delay(4000);
// Motor no gira
digitalWrite(IN3, LOW);
delay(5000);
}

Ejemplo de control de motor CC usando modulo L298

El programa activa el motor en un sentido por 4 segundos,

para el motor por 500 ms, activa el motor en sentido inverso por 4 segundos

y se detiene por 5 segundos. Se repite indefinidamente.

int ENB = 3; // ENB conectada al pin 3 / SIN EL JUMPER EN ENB

int IN3 = 5; // Input4 conectada al pin 4

int IN4 = 4; // Input3 conectada al pin 5

void setup()

{

pinMode(ENB, OUTPUT); // ENB

pinMode(IN4, OUTPUT); // Input4

pinMode(IN3, OUTPUT); // Input3

digitalWrite(ENB,HIGH); // ALTO habilita la salida B / SIN EL JUMPER EN ENB

}

void loop()

{

// Motor gira en un sentido

digitalWrite(IN4, HIGH);

digitalWrite(IN3, LOW);

delay(4000);

// Motor no gira

digitalWrite(IN4, LOW);

delay(500);

// Motor gira en sentido inverso

digitalWrite(IN3, HIGH);

delay(4000);

// Motor no gira

digitalWrite(IN3, LOW);

delay(5000);

}

Control de un motor CC con variación de su velocidad

Si queremos controlar la velocidad del motor, debemos hacer uso de una salida PWM, en este ejemplo la salida digital 3 del Arduino Uno. Esta señal PWM será aplicada a los pines de activación de cada salida, ENA y ENB respectivamente, de manera que en este caso los jumper de habilitación a +5V no deben ser colocados.

Esquema de conexión del ejemplo 2

Código en el Arduino – Ejemplo 2

Este programa controla la velocidad de un motor CC aplicando una señal PWM al pin ENB del módulo L298N. Se observará un ciclo de tres velocidades diferentes. Usted puede probar diversos valores de velocidad, pero nunca baje el valor 55 porque un motor que no esté libre (con caja de engranajes, por ejemplo) pude quedar sin girar pero alimentado, lo que producirá una corriente elevada.

/*
Cambio de velocidad de motor CC usando modulo L298
*/
int IN3 = 5;  // Input3 conectada al pin 5
int IN4 = 4;  // Input4 conectada al pin 4
int ENB = 3;  // ENB conectada al pin 3 (PWM de Arduino)

void setup()
{
pinMode(ENB, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
analogWrite(ENB,0);
}

void loop()
{
// Preparamos la salida para que el motor gire en un sentido
digitalWrite (IN3, HIGH);
digitalWrite (IN4, LOW);
// Aplicamos PWM al pin ENB, haciendo girar el motor, cada 2 seg aumenta la velocidad
analogWrite(ENB,55); // Velocidad minima
delay(2000);
analogWrite(ENB,105); // Velocidad media
delay(2000);
analogWrite(ENB,255); // Velocidad maxima
delay(2000);
analogWrite(ENB,0); // Apagamos el motor y esperamos 5 seg
delay(5000);
}

Cambio de velocidad de motor CC usando modulo L298

int IN3 = 5; // Input3 conectada al pin 5

int IN4 = 4; // Input4 conectada al pin 4

int ENB = 3; // ENB conectada al pin 3 (PWM de Arduino)

void setup()

{

pinMode(ENB, OUTPUT);

pinMode(IN3, OUTPUT);

pinMode(IN4, OUTPUT);

analogWrite(ENB,0);

}

void loop()

{

// Preparamos la salida para que el motor gire en un sentido

digitalWrite (IN3, HIGH);

digitalWrite (IN4, LOW);

// Aplicamos PWM al pin ENB, haciendo girar el motor, cada 2 seg aumenta la velocidad

analogWrite(ENB,55); // Velocidad minima

delay(2000);

analogWrite(ENB,105); // Velocidad media

delay(2000);

analogWrite(ENB,255); // Velocidad maxima

delay(2000);

analogWrite(ENB,0); // Apagamos el motor y esperamos 5 seg

delay(5000);

}

Diagrama de circuito del módulo

Diagrama de ejemplo para un robot

Arduino: Comunicación inalámbrica con NRF24L01

1 respuesta

La función de este artículo es ofrecer una explicación sobre cómo establecer una comunicación inalámbrica entre dos placas Arduino usando el módulo transceptor NRF24L01.

La primera comunicación inalámbrica que explicaré será básica: enviar un simple mensaje de texto, tipo «Hola Mundo», de un Arduino a otro.

A continuación podremos extender este ejemplo de comunicación al envío de comandos de texto —usando el mismo circuito y estructura de programa— para controlar un sistema cualquiera ubicado en el extremo receptor.

Más adelante ofreceré un artículo con un ejemplo de comunicación bidireccional entre placas Arduino. Un Arduino tiene conectado un potenciómetro con el que se controla un servo en el segundo Arduino. Y en el otro sentido, unos interruptores en el segundo Arduino servirán para controlar LEDs en el primero.

Módulo transceptor NRF24L01

En la imagen se observa el módulo transceptor NRF24L01. Utiliza la banda de 2,4 GHz y puede operar con velocidades de transmisión de 250 kbps hasta 2 Mbps. Si se usa en espacios abiertos y, con menor velocidad de transmisión, su alcance puede llegar hasta los 100 metros. Para mayores distancias, hasta 1000 metros, existen módulos provistos con una antena externa en lugar de una antena trazada sobre la misma placa, como se observa en la imagen.

El módulo puede usar 125 canales diferentes, lo que da la posibilidad de tener una red de 125 módems que funcionen con independencia uno de otro en un solo lugar. Cada canal puede tener hasta 6 direcciones, es decir, cada unidad puede comunicarse con hasta otras 6 unidades al mismo tiempo.

El consumo de este módulo es de alrededor de 12 mA durante la transmisión, un valor menor al de un LED encendido. El voltaje de operación del módulo es de 1,9 a 3,6V, pero lo bueno es que los demás pines toleran la lógica de 5V, por lo que podemos conectarlo sin problemas a un Arduino sin necesidad de un convertidor de niveles lógicos.

Tres de estos pines son para la comunicación SPI: MOSI, MISO y SCK, que deben conectarse a los pines de la interfaz SPI del Arduino. Se debe tener en cuenta que diferentes placas Arduino pueden tener los pines del interfaz SPI en diferentes posiciones. Los pines CSN y CE se pueden conectar a cualquier pin digital de la placa Arduino, y su función es configurar el módulo en modo de espera o activo, así como para alternar entre modo de transmisión o de comando. El último pin, IRQ, es un pin de interrupción que no es necesario utilizar.

Una vez conectados los módulos NRF24L01 a las placas Arduino, llegará el momento de escribir los programas para el transmisor, y para el receptor.

Conexionado para utilizar Arduinos Uno R3 en ambos lados de la comunicación:

Código para los Arduino

Primero debemos descargar e instalar la librería RF24.

Aquí están los dos códigos para la comunicación inalámbrica y abajo, en los archivos, hay amplias explicaciones. He puesto la mayor parte de las explicaciones dentro del programa, como comentarios.

Código del Transmisor

/* Comunicacion inalambrica con NRF24L01 Arduino 
Ejemplo 1 – Programa para el Transmisor
Libreria: 
TMRh20/RF24 https://github.com/tmrh20/RF24/ */

/* Debemos incluir la libreria SPI basica y la 
libreria RF24  que ya hemos instalado */
#include <SPI.h>
#include <RF24.h>

/* Crear un objeto RF24 al que llamaremos “radio”. 
Los dos argumentos que se utilizan en la funcion 
son los numeros de pin que vamos a usar para CS y CE. */
  RF24 radio(7, 8); // CE, CSN

/* Creamos una matriz de bytes que represente la 
direccion con la que se reconoceran entre si los 
dos modulos. Podemos cambiar el valor de esta 
direccion a cualquier conjunto de 5 letras y/o 
numeros. Esta direccion permite elegir con que 
receptor vamos a comunicarnos. En nuestro caso, 
usaremos la misma direccion tanto en el receptor 
como en el transmisor. */
  const byte identificacion[6] = "00001";

void setup() {
/* En la seccion de configuracion debemos inicializar 
el objeto “radio” */
  radio.begin();

/* Mediante la funcion radio.openWritingPipe(), 
establecer la direccion del receptor al que 
enviaremos los datos. En este ejemplo, la cadena 
de 5 caracteres que hemos configurado. */
  radio.openWritingPipe(identificacion);

/* Configuramos el nivel del amplificador de potencia,
usando la funcion radio.setPALevel(). Mientras 
estemos a este nivel de prueba, es decir prototipos 
sobre la mesa de trabajo, lo establecemos al minimo, 
ya que los modulos estaran cerca el uno del otro. 
Si se utiliza un nivel mas alto, se recomienda 
utilizar capacitores de filtro entre las entradas 
GND y 3,3 V de los mdulos para que su voltaje se 
mantenga más estable durante el funcionamiento. */
  radio.setPALevel(RF24_PA_MIN);

/* La función radio.stopListening() cumple la de establecer al módulo como transmisor. */
  radio.stopListening();
}

void loop() {
/* Creamos una matriz de caracteres a la que 
asignamos el mensaje "Hola mundo" o cualquiera 
que usted desee enviar. */
  const char texto[] = "Hola Mundo"; 

/* Usando la funcion radio.write() se envía el 
mensaje al receptor. El primer argumento es la 
variable que deseamos enviar. */
  radio.write(&texto, sizeof(texto));
/* El simbolo “&” delante del nombre de la variable 
establece un indicador que apunta a la variable 
que contiene los datos que queremos enviar y, con 
el segundo argumento, establecemos la cantidad 
de bytes que se van a usar de esa variable. En 
este caso, la funcion sizeof() nos devuelve la 
cantidad total de los bytes de la cadena "texto". */

  delay(1000); // Un segundo (1000 milisegundos) de espera entre envío y envío
}

/* Comunicacion inalambrica con NRF24L01 Arduino

Ejemplo 1 – Programa para el Transmisor

Libreria:

TMRh20/RF24 https://github.com/tmrh20/RF24/ */

/* Debemos incluir la libreria SPI basica y la

libreria RF24 que ya hemos instalado */

#include <SPI.h>

#include <RF24.h>

/* Crear un objeto RF24 al que llamaremos “radio”.

Los dos argumentos que se utilizan en la funcion

son los numeros de pin que vamos a usar para CS y CE. */

RF24 radio(7, 8); // CE, CSN

/* Creamos una matriz de bytes que represente la

direccion con la que se reconoceran entre si los

dos modulos. Podemos cambiar el valor de esta

direccion a cualquier conjunto de 5 letras y/o

numeros. Esta direccion permite elegir con que

receptor vamos a comunicarnos. En nuestro caso,

usaremos la misma direccion tanto en el receptor

como en el transmisor. */

const byte identificacion[6] = "00001";

void setup() {

/* En la seccion de configuracion debemos inicializar

el objeto “radio” */

radio.begin();

/* Mediante la funcion radio.openWritingPipe(),

establecer la direccion del receptor al que

enviaremos los datos. En este ejemplo, la cadena

de 5 caracteres que hemos configurado. */

radio.openWritingPipe(identificacion);

/* Configuramos el nivel del amplificador de potencia,

usando la funcion radio.setPALevel(). Mientras

estemos a este nivel de prueba, es decir prototipos

sobre la mesa de trabajo, lo establecemos al minimo,

ya que los modulos estaran cerca el uno del otro.

Si se utiliza un nivel mas alto, se recomienda

utilizar capacitores de filtro entre las entradas

GND y 3,3 V de los mdulos para que su voltaje se

mantenga más estable durante el funcionamiento. */

radio.setPALevel(RF24_PA_MIN);

/* La función radio.stopListening() cumple la de establecer al módulo como transmisor. */

radio.stopListening();

}

void loop() {

/* Creamos una matriz de caracteres a la que

asignamos el mensaje "Hola mundo" o cualquiera

que usted desee enviar. */

const char texto[] = "Hola Mundo";

/* Usando la funcion radio.write() se envía el

mensaje al receptor. El primer argumento es la

variable que deseamos enviar. */

radio.write(&texto, sizeof(texto));

/* El simbolo “&” delante del nombre de la variable

establece un indicador que apunta a la variable

que contiene los datos que queremos enviar y, con

el segundo argumento, establecemos la cantidad

de bytes que se van a usar de esa variable. En

este caso, la funcion sizeof() nos devuelve la

cantidad total de los bytes de la cadena "texto". */

delay(1000); // Un segundo (1000 milisegundos) de espera entre envío y envío

}

Código del receptor

/* Comunicacion inalambrica con NRF24L01 Arduino 
Ejemplo 1 – Programa para el Receptor
Libreria: 
TMRh20/RF24 https://github.com/tmrh20/RF24/ */

/* Debemos incluir la libreria SPI basica y 
la libreria RF24 que ya hemos instalado */
#include <SPI.h>
#include <RF24.h>

/* Crear un objeto RF24 al que llamaremos 
“radio”. Los dos argumentos que se utilizan 
en la funcion son los numeros de pin que 
vamos a usar para CS y CE. */
RF24 radio(7, 8); // CE, CSN

/* Creamos una matriz de bytes que represente la 
direccion con la que se reconoceran entre si los 
dos modulos. Podemos cambiar el valor de esta 
direccion a cualquier conjunto de 5 letras y/o 
numeros. Esta direccion permite elegir con que 
receptor vamos a comunicarnos. En nuestro caso, 
usaremos la misma direccion tanto en el receptor 
como en el transmisor. */
const byte identificacion[6] = "00001";

void setup() {
  Serial.begin(9600); // Iniciamos la comunicacion serie hacia el Monitor Serie en la PC

/* En la sección de configuracion debemos 
inicializar el objeto “radio” */
  radio.begin();

/* En el receptor establecemos la misma direccion 
que en el transmisor usando la funcion 
radio.setReadingPipe() y asi queda habilitada 
la comunicacion entre los dos modulos. */
  radio.openReadingPipe(0, identificacion);

/* Configuramos el nivel del amplificador de potencia,
usando la funcion radio.setPALevel(). Mientras 
estemos a este nivel de prueba, es decir prototipos 
sobre la mesa de trabajo, lo establecemos al minimo, 
ya que los modulos estaran cerca el uno del otro. 
Si se utiliza un nivel mas alto, se recomienda 
utilizar capacitores de filtro entre las entradas 
GND y 3,3 V de los mdulos para que su voltaje se 
mantenga mas estable durante el funcionamiento. */
  radio.setPALevel(RF24_PA_MIN);

/* La funcion radio.startListening() establece al 
modulo como receptor. */
  radio.startListening();
}

void loop() {
  if (radio.available()) {
  char texto[32] = ""; 
/* Creamos una matriz de caracteres donde recibir el 
mensaje */

  radio.read(&texto, sizeof(texto)); // Esperamos que llegue algo por RF desde el módulo
/* El símbolo “&” delante del nombre de la variable 
establece un indicador que señala a la variable que 
contiene los datos que queremos enviar y, con el 
segundo argumento, establecemos la cantidad de bytes 
que se van a usar de esa variable. En este caso, la 
funcion sizeof() nos devolvera la cantidad total de 
los bytes de la cadena "texto". */

  Serial.println(texto);
/* Enviamos lo que hemos recibido al Monitor 
Serie en la PC */
 }
}

/* Comunicacion inalambrica con NRF24L01 Arduino

Ejemplo 1 – Programa para el Receptor

Libreria:

TMRh20/RF24 https://github.com/tmrh20/RF24/ */

/* Debemos incluir la libreria SPI basica y

la libreria RF24 que ya hemos instalado */

#include <SPI.h>

#include <RF24.h>

/* Crear un objeto RF24 al que llamaremos

“radio”. Los dos argumentos que se utilizan

en la funcion son los numeros de pin que

vamos a usar para CS y CE. */

RF24 radio(7, 8); // CE, CSN

/* Creamos una matriz de bytes que represente la

direccion con la que se reconoceran entre si los

dos modulos. Podemos cambiar el valor de esta

direccion a cualquier conjunto de 5 letras y/o

numeros. Esta direccion permite elegir con que

receptor vamos a comunicarnos. En nuestro caso,

usaremos la misma direccion tanto en el receptor

como en el transmisor. */

const byte identificacion[6] = "00001";

void setup() {

Serial.begin(9600); // Iniciamos la comunicacion serie hacia el Monitor Serie en la PC

/* En la sección de configuracion debemos

inicializar el objeto “radio” */

radio.begin();

/* En el receptor establecemos la misma direccion

que en el transmisor usando la funcion

radio.setReadingPipe() y asi queda habilitada

la comunicacion entre los dos modulos. */

radio.openReadingPipe(0, identificacion);

/* Configuramos el nivel del amplificador de potencia,

usando la funcion radio.setPALevel(). Mientras

estemos a este nivel de prueba, es decir prototipos

sobre la mesa de trabajo, lo establecemos al minimo,

ya que los modulos estaran cerca el uno del otro.

Si se utiliza un nivel mas alto, se recomienda

utilizar capacitores de filtro entre las entradas

GND y 3,3 V de los mdulos para que su voltaje se

mantenga mas estable durante el funcionamiento. */

radio.setPALevel(RF24_PA_MIN);

/* La funcion radio.startListening() establece al

modulo como receptor. */

radio.startListening();

}

void loop() {

if (radio.available()) {

char texto[32] = "";

/* Creamos una matriz de caracteres donde recibir el

mensaje */

radio.read(&texto, sizeof(texto)); // Esperamos que llegue algo por RF desde el módulo

/* El símbolo “&” delante del nombre de la variable

establece un indicador que señala a la variable que

contiene los datos que queremos enviar y, con el

segundo argumento, establecemos la cantidad de bytes

que se van a usar de esa variable. En este caso, la

funcion sizeof() nos devolvera la cantidad total de

los bytes de la cadena "texto". */

Serial.println(texto);

/* Enviamos lo que hemos recibido al Monitor

Serie en la PC */

}

Una vez cargados ambos programas, podemos abrir el monitor serie en el Arduino receptor y observaremos la aparición del mensaje «Hola Mundo» cada 1 segundo.

CONTROL INALÁMBRICO A DISTANCIA

Esta prueba consiste en tener un Arduino (con el programa TRANSMISOR listado más abajo) conectado a la PC a través de USB / Conexión Serie, con el Monitor Serie del IDE de Arduino abierto (Herramientas > Monitor Serie) y asignado en el COM que corresponde, y transmitiendo en forma inalámbrica los caracteres que son tipeados dentro de este Monitor.

Nota: Un defecto que tiene el Monitor Serie del IDE del Arduino es que para que se transmita un caracter, o una serie de caracteres, hay que tipearlo y pulsar ENTER (ENTRAR). Eso es incómodo para controlar un equipo remoto pulsando teclas. Por eso recomiendo utilizar un programa simple y gratuito de terminal. Quizás usted ya tenga uno. En mi caso utilizo el programa Parallax Serial Terminal (PST.EXE), que se puede bajar de aquí (Página de manual de uso).

El otro Arduino lleva grabado el programa RECEPTOR, y en ese Arduino se ha agregado un pequeño servo al diagrama estándar, como muestra la figura más abajo.

El funcionamiento será básico: pulsando los números de 1 a 0 ubicados en la hilera superior del teclado, o si lo desea y lo tiene, en el teclado numérico a la derecha. Para cada uno de estos números el servo se ubicará en 10 posiciones diferentes, separadas 20º. Desde 0 a 180º, que es el rango que tiene todo servo, y más aún estos pequeños. Los servos mayores se pueden mover 270º. La selección de acciones que corresponden a cada comando se realiza por medio de comparaciones IF en el primer programa ejemplo de RECEPTOR, y por medio de una estructura SWICH-CASE en el segundo programa ejemplo. El primero es así porque puede resultar más comprensible para los recién iniciados, y el segundo ejemplo es más simple, elegante y profesional. Puse enlaces en los nombres de las estructuras de programa que apuntan a la sección de REFERENCIA del sitio oficial de Arduino.

La elección de cuál programa RECEPTOR desea usar queda a su gusto. En realidad, es conveniente probar ambos. En lo funcional se comportarán igual.

DIAGRAMA

TRANSMISOR

/* Comunicacion inalambrica con NRF24L01 Arduino 
Ejemplo 1 – Manejo de servo / Programa del Transmisor
Libreria: 
TMRh20/RF24 https://github.com/tmrh20/RF24/ */

/* Debemos incluir la libreria SPI basica y la 
libreria RF24  que ya hemos instalado */
#include <SPI.h>
#include <RF24.h>

/* Crear un objeto RF24 al que llamaremos “radio”. 
Los dos argumentos que se utilizan en la funcion 
son los numeros de pin que vamos a usar para CS y CE. */
  RF24 radio(7, 8); // CE, CSN

/* Creamos una matriz de bytes que represente la 
direccion con la que se reconoceran entre si los 
dos modulos. Podemos cambiar el valor de esta 
direccion a cualquier conjunto de 5 letras y/o 
numeros. Esta direccion permite elegir con que 
receptor vamos a comunicarnos. En nuestro caso, 
usaremos la misma direccion tanto en el receptor 
como en el transmisor. */
  const byte identificacion[6] = "00001";

void setup() {
  Serial.begin(9600); // Iniciamos la comunicacion serie hacia el Monitor Serie en la PC

/* En la seccion de configuracion debemos inicializar 
el objeto “radio” */
  radio.begin();

/* Mediante la funcion radio.openWritingPipe(), 
establecer la direccion del receptor al que 
enviaremos los datos. En este ejemplo, la cadena 
de 5 caracteres que hemos configurado. */
  radio.openWritingPipe(identificacion);

/* Configuramos el nivel del amplificador de potencia,
usando la funcion radio.setPALevel(). Mientras 
estemos a este nivel de prueba, es decir prototipos 
sobre la mesa de trabajo, lo establecemos al minimo, 
ya que los modulos estaran cerca el uno del otro. 
Si se utiliza un nivel mas alto, se recomienda 
utilizar capacitores de filtro entre las entradas 
GND y 3,3 V de los mdulos para que su voltaje se 
mantenga más estable durante el funcionamiento. */
  radio.setPALevel(RF24_PA_MIN);

/* La función radio.stopListening() cumple la de establecer al módulo como transmisor. */
  radio.stopListening();
}

void loop() {
/* Creamos un constante de un caracter que se 
recibe desde el teclado de la PC. */
  char caracter; 

/* Esperamos a que llegue un caracter por la
linea serie que usaremos para controlar */
  if (Serial.available() > 0) {

/* leer el caracter que llega desde PC: */
    caracter = Serial.read();
    
/* Usando la funcion radio.write() se envía el 
mensaje al receptor. El primer argumento es la 
variable que deseamos enviar y el segundo la 
longitud de la variable caracter. */
    if (sizeof(caracter) == 1) { 
        radio.write(&caracter, 1);
    }
  }
/* El simbolo “&” delante del nombre de la variable 
establece un indicador que apunta a la variable 
que contiene los datos que queremos enviar y, con 
el segundo argumento, establecemos la cantidad 
de bytes que se van a usar de esa variable. En este 
caso, se usa 1 ya que char es un caracter unico. */
}

/* Comunicacion inalambrica con NRF24L01 Arduino

Ejemplo 1 – Manejo de servo / Programa del Transmisor

Libreria:

TMRh20/RF24 https://github.com/tmrh20/RF24/ */

/* Debemos incluir la libreria SPI basica y la

libreria RF24 que ya hemos instalado */

#include <SPI.h>

#include <RF24.h>

/* Crear un objeto RF24 al que llamaremos “radio”.

Los dos argumentos que se utilizan en la funcion

son los numeros de pin que vamos a usar para CS y CE. */

RF24 radio(7, 8); // CE, CSN

/* Creamos una matriz de bytes que represente la

direccion con la que se reconoceran entre si los

dos modulos. Podemos cambiar el valor de esta

direccion a cualquier conjunto de 5 letras y/o

numeros. Esta direccion permite elegir con que

receptor vamos a comunicarnos. En nuestro caso,

usaremos la misma direccion tanto en el receptor

como en el transmisor. */

const byte identificacion[6] = "00001";

void setup() {

Serial.begin(9600); // Iniciamos la comunicacion serie hacia el Monitor Serie en la PC

/* En la seccion de configuracion debemos inicializar

el objeto “radio” */

radio.begin();

/* Mediante la funcion radio.openWritingPipe(),

establecer la direccion del receptor al que

enviaremos los datos. En este ejemplo, la cadena

de 5 caracteres que hemos configurado. */

radio.openWritingPipe(identificacion);

/* Configuramos el nivel del amplificador de potencia,

usando la funcion radio.setPALevel(). Mientras

estemos a este nivel de prueba, es decir prototipos

sobre la mesa de trabajo, lo establecemos al minimo,

ya que los modulos estaran cerca el uno del otro.

Si se utiliza un nivel mas alto, se recomienda

utilizar capacitores de filtro entre las entradas

GND y 3,3 V de los mdulos para que su voltaje se

mantenga más estable durante el funcionamiento. */

radio.setPALevel(RF24_PA_MIN);

/* La función radio.stopListening() cumple la de establecer al módulo como transmisor. */

radio.stopListening();

}

void loop() {

/* Creamos un constante de un caracter que se

recibe desde el teclado de la PC. */

char caracter;

/* Esperamos a que llegue un caracter por la

linea serie que usaremos para controlar */

if (Serial.available() > 0) {

/* leer el caracter que llega desde PC: */

caracter = Serial.read();

/* Usando la funcion radio.write() se envía el

mensaje al receptor. El primer argumento es la

variable que deseamos enviar y el segundo la

longitud de la variable caracter. */

if (sizeof(caracter) == 1) {

radio.write(&caracter, 1);

}

/* El simbolo “&” delante del nombre de la variable

establece un indicador que apunta a la variable

que contiene los datos que queremos enviar y, con

el segundo argumento, establecemos la cantidad

de bytes que se van a usar de esa variable. En este

caso, se usa 1 ya que char es un caracter unico. */

}

RECEPTOR – Basado en elección de comandos por IF

/* Comunicacion inalambrica con NRF24L01 Arduino 
Ejemplo 1 – Control un servo a distancia - Programa para el Receptor
Libreria: 
TMRh20/RF24 https://github.com/tmrh20/RF24/ */

/* Debemos incluir la libreria SPI basica y 
la libreria RF24 que ya hemos instalado */
#include <SPI.h>
#include <RF24.h>
#include <Servo.h>

/* Crear un objeto RF24 al que llamaremos 
“radio”. Los dos argumentos que se utilizan 
en la funcion son los numeros de pin que 
vamos a usar para CS y CE. */
RF24 radio(7, 8); // CE, CSN

/* Creamos una matriz de bytes que represente la 
direccion con la que se reconoceran entre si los 
dos modulos. Podemos cambiar el valor de esta 
direccion a cualquier conjunto de 5 letras y/o 
numeros. Esta direccion permite elegir con que 
receptor vamos a comunicarnos. En nuestro caso, 
usaremos la misma direccion tanto en el receptor 
como en el transmisor. */
const byte identificacion[6] = "00001";
Servo miServo;

void setup() {
  miServo.attach(5);
  
  Serial.begin(9600); // Iniciamos la comunicacion serie hacia el Monitor Serie en la PC

/* En la sección de configuracion debemos 
inicializar el objeto “radio” */
  radio.begin();

/* En el receptor establecemos la misma direccion 
que en el transmisor usando la funcion 
radio.setReadingPipe() y asi queda habilitada 
la comunicacion entre los dos modulos. */
  radio.openReadingPipe(0, identificacion);

/* Configuramos el nivel del amplificador de potencia,
usando la funcion radio.setPALevel(). Mientras 
estemos a este nivel de prueba, es decir prototipos 
sobre la mesa de trabajo, lo establecemos al minimo, 
ya que los modulos estaran cerca el uno del otro. 
Si se utiliza un nivel mas alto, se recomienda 
utilizar capacitores de filtro entre las entradas 
GND y 3,3 V de los modulos para que su voltaje se 
mantenga mas estable durante el funcionamiento. */
  radio.setPALevel(RF24_PA_MIN);

/* La funcion radio.startListening() establece al 
modulo como receptor. */
  radio.startListening();
}
void loop() {
  if (radio.available()) {
  char texto; 
/* Creamos una matriz de caracteres donde recibir el 
mensaje */
    radio.read(&texto, 1); // Esperamos que llegue algo por RF desde el módulo
/* El símbolo “&” delante del nombre de la variable 
establece un indicador que señala a la variable que 
contiene los datos que queremos enviar y, con el 
segundo argumento, establecemos la cantidad de bytes 
que se van a usar de esa variable. En este caso, la 
funcion sizeof() nos devolvera 1 que es un char. */
  if (sizeof(texto)>0) {
    if (texto == '0') {
      miServo.write(0);
   }
    if (texto == '1') {
      miServo.write(20);
   }
    if (texto == '2') {
      miServo.write(40);
    }
    if (texto == '3') {
      miServo.write(60);
    }
    if (texto == '4') {
      miServo.write(80);
    }
    if (texto == '5') {
      miServo.write(100);
    }
    if (texto == '6') {
      miServo.write(120);
    }
    if (texto == '7') {
      miServo.write(140);
    }
    if (texto == '8') {
      miServo.write(160);
    }
    if (texto == '9') {
      miServo.write(180);
    }
  }
/* Enviamos una posicion al servo en base a 
lo que hemos recibido desde el Monitor Serie 
del transmisor, tecleado en la PC */
 }
}

100

101

102

103

104

105

106

107

/* Comunicacion inalambrica con NRF24L01 Arduino

Ejemplo 1 – Control un servo a distancia - Programa para el Receptor

Libreria:

TMRh20/RF24 https://github.com/tmrh20/RF24/ */

/* Debemos incluir la libreria SPI basica y

la libreria RF24 que ya hemos instalado */

#include <SPI.h>

#include <RF24.h>

#include <Servo.h>

/* Crear un objeto RF24 al que llamaremos

“radio”. Los dos argumentos que se utilizan

en la funcion son los numeros de pin que

vamos a usar para CS y CE. */

RF24 radio(7, 8); // CE, CSN

/* Creamos una matriz de bytes que represente la

direccion con la que se reconoceran entre si los

dos modulos. Podemos cambiar el valor de esta

direccion a cualquier conjunto de 5 letras y/o

numeros. Esta direccion permite elegir con que

receptor vamos a comunicarnos. En nuestro caso,

usaremos la misma direccion tanto en el receptor

como en el transmisor. */

const byte identificacion[6] = "00001";

Servo miServo;

void setup() {

miServo.attach(5);

Serial.begin(9600); // Iniciamos la comunicacion serie hacia el Monitor Serie en la PC

/* En la sección de configuracion debemos

inicializar el objeto “radio” */

radio.begin();

/* En el receptor establecemos la misma direccion

que en el transmisor usando la funcion

radio.setReadingPipe() y asi queda habilitada

la comunicacion entre los dos modulos. */

radio.openReadingPipe(0, identificacion);

/* Configuramos el nivel del amplificador de potencia,

usando la funcion radio.setPALevel(). Mientras

estemos a este nivel de prueba, es decir prototipos

sobre la mesa de trabajo, lo establecemos al minimo,

ya que los modulos estaran cerca el uno del otro.

Si se utiliza un nivel mas alto, se recomienda

utilizar capacitores de filtro entre las entradas

GND y 3,3 V de los modulos para que su voltaje se

mantenga mas estable durante el funcionamiento. */

radio.setPALevel(RF24_PA_MIN);

/* La funcion radio.startListening() establece al

modulo como receptor. */

radio.startListening();

}

void loop() {

if (radio.available()) {

char texto;

/* Creamos una matriz de caracteres donde recibir el

mensaje */

radio.read(&texto, 1); // Esperamos que llegue algo por RF desde el módulo

/* El símbolo “&” delante del nombre de la variable

establece un indicador que señala a la variable que

contiene los datos que queremos enviar y, con el

segundo argumento, establecemos la cantidad de bytes

que se van a usar de esa variable. En este caso, la

funcion sizeof() nos devolvera 1 que es un char. */

if (sizeof(texto)>0) {

if (texto == '0') {

miServo.write(0);

}

if (texto == '1') {

miServo.write(20);

}

if (texto == '2') {

miServo.write(40);

}

if (texto == '3') {

miServo.write(60);

}

if (texto == '4') {

miServo.write(80);

}

if (texto == '5') {

miServo.write(100);

}

if (texto == '6') {

miServo.write(120);

}

if (texto == '7') {

miServo.write(140);

}

if (texto == '8') {

miServo.write(160);

}

if (texto == '9') {

miServo.write(180);

}

/* Enviamos una posicion al servo en base a

lo que hemos recibido desde el Monitor Serie

del transmisor, tecleado en la PC */

}

RECEPTOR – Basado en elección de comandos por SWITCH-CASE

/* Comunicacion inalambrica con NRF24L01 Arduino 
Ejemplo 2 – Manejo servo / Programa del Receptor
Libreria: 
TMRh20/RF24 https://github.com/tmrh20/RF24/ */

/* Debemos incluir la libreria SPI basica, 
la libreria RF24 que ya hemos instalado 
y la libreria Servo para manejar un servo*/
#include <SPI.h>
#include <RF24.h>
#include <Servo.h>

/* Crear un objeto RF24 al que llamaremos 
“radio”. Los dos argumentos que se utilizan 
en la funcion son los numeros de pin que 
vamos a usar para CS y CE. */
RF24 radio(7, 8); // CE, CSN

/* Creamos una matriz de bytes que represente la 
direccion con la que se reconoceran entre si los 
dos modulos. Podemos cambiar el valor de esta 
direccion a cualquier conjunto de 5 letras y/o 
numeros. Esta direccion permite elegir con que 
receptor vamos a comunicarnos. En nuestro caso, 
usaremos la misma direccion tanto en el receptor 
como en el transmisor. */
const byte identificacion[6] = "00001";

Servo miServo;
/* Definimos e nombre miServo para este servo */

void setup() {
  miServo.attach(5); // Define que el pin 5 controla el servo
  
  Serial.begin(9600); // Iniciamos la comunicacion serie hacia el Monitor Serie en la PC

/* En la sección de configuracion debemos 
inicializar el objeto “radio” */
  radio.begin();

/* En el receptor establecemos la misma direccion 
que en el transmisor usando la funcion 
radio.setReadingPipe() y asi queda habilitada 
la comunicacion entre los dos modulos. */
  radio.openReadingPipe(0, identificacion);

/* Configuramos el nivel del amplificador de potencia,
usando la funcion radio.setPALevel(). Mientras 
estemos a este nivel de prueba, es decir prototipos 
sobre la mesa de trabajo, lo establecemos al minimo, 
ya que los modulos estaran cerca el uno del otro. 
Si se utiliza un nivel mas alto, se recomienda 
utilizar capacitores de filtro entre las entradas 
GND y 3,3 V de los modulos para que su voltaje se 
mantenga mas estable durante el funcionamiento. */
  radio.setPALevel(RF24_PA_MIN);

/* La funcion radio.startListening() establece al 
modulo como receptor. */
  radio.startListening();
}
void loop() {
  if (radio.available()) {
  char texto; 
/* Creamos una matriz de caracteres donde recibir el 
mensaje */
    radio.read(&texto, 1); // Esperamos que llegue algo por RF desde el módulo
/* El símbolo “&” delante del nombre de la variable 
establece un indicador que señala a la variable que 
contiene los datos que queremos enviar y, con el 
segundo argumento, establecemos la cantidad de bytes 
que se van a usar de esa variable. En este caso se 
usa 1 porque un char mide 1. */

/* Podemos enviar comandos 0 a 9 desde la PC.
Cada valor pondra el servo en una posicion,
una cada 20 grados, de 0 a 180. Usamos la 
estructura switch / case para la eleccion. */
  if (sizeof(texto)>0) {
    switch(texto) {
     case '1': miServo.write(0);
     break;
     case '2': miServo.write(20);
     break;
     case '3': miServo.write(40);
     break;
     case '4': miServo.write(60);
     break;
     case '5': miServo.write(80);
     break;
     case '6': miServo.write(100);
     break;
     case '7': miServo.write(120);
     break;
     case '8': miServo.write(140);
     break;
     case '9': miServo.write(160);
     break;
     case '0': miServo.write(180);
     break;
    }
  }
/* Enviamos una posicion al servo en base a 
lo que hemos recibido desde el Monitor Serie 
del transmisor, tecleado en la PC */
 }
}

100

101

102

103

104

105

106

107

/* Comunicacion inalambrica con NRF24L01 Arduino

Ejemplo 2 – Manejo servo / Programa del Receptor

Libreria:

TMRh20/RF24 https://github.com/tmrh20/RF24/ */

/* Debemos incluir la libreria SPI basica,

la libreria RF24 que ya hemos instalado

y la libreria Servo para manejar un servo*/

#include <SPI.h>

#include <RF24.h>

#include <Servo.h>

/* Crear un objeto RF24 al que llamaremos

“radio”. Los dos argumentos que se utilizan

en la funcion son los numeros de pin que

vamos a usar para CS y CE. */

RF24 radio(7, 8); // CE, CSN

/* Creamos una matriz de bytes que represente la

direccion con la que se reconoceran entre si los

dos modulos. Podemos cambiar el valor de esta

direccion a cualquier conjunto de 5 letras y/o

numeros. Esta direccion permite elegir con que

receptor vamos a comunicarnos. En nuestro caso,

usaremos la misma direccion tanto en el receptor

como en el transmisor. */

const byte identificacion[6] = "00001";

Servo miServo;

/* Definimos e nombre miServo para este servo */

void setup() {

miServo.attach(5); // Define que el pin 5 controla el servo

Serial.begin(9600); // Iniciamos la comunicacion serie hacia el Monitor Serie en la PC

/* En la sección de configuracion debemos

inicializar el objeto “radio” */

radio.begin();

/* En el receptor establecemos la misma direccion

que en el transmisor usando la funcion

radio.setReadingPipe() y asi queda habilitada

la comunicacion entre los dos modulos. */

radio.openReadingPipe(0, identificacion);

/* Configuramos el nivel del amplificador de potencia,

usando la funcion radio.setPALevel(). Mientras

estemos a este nivel de prueba, es decir prototipos

sobre la mesa de trabajo, lo establecemos al minimo,

ya que los modulos estaran cerca el uno del otro.

Si se utiliza un nivel mas alto, se recomienda

utilizar capacitores de filtro entre las entradas

GND y 3,3 V de los modulos para que su voltaje se

mantenga mas estable durante el funcionamiento. */

radio.setPALevel(RF24_PA_MIN);

/* La funcion radio.startListening() establece al

modulo como receptor. */

radio.startListening();

}

void loop() {

if (radio.available()) {

char texto;

/* Creamos una matriz de caracteres donde recibir el

mensaje */

radio.read(&texto, 1); // Esperamos que llegue algo por RF desde el módulo

/* El símbolo “&” delante del nombre de la variable

establece un indicador que señala a la variable que

contiene los datos que queremos enviar y, con el

segundo argumento, establecemos la cantidad de bytes

que se van a usar de esa variable. En este caso se

usa 1 porque un char mide 1. */

/* Podemos enviar comandos 0 a 9 desde la PC.

Cada valor pondra el servo en una posicion,

una cada 20 grados, de 0 a 180. Usamos la

estructura switch / case para la eleccion. */

if (sizeof(texto)>0) {

switch(texto) {

case '1': miServo.write(0);

break;

case '2': miServo.write(20);

break;

case '3': miServo.write(40);

break;

case '4': miServo.write(60);

break;

case '5': miServo.write(80);

break;

case '6': miServo.write(100);

break;

case '7': miServo.write(120);

break;

case '8': miServo.write(140);

break;

case '9': miServo.write(160);

break;

case '0': miServo.write(180);

break;

}

/* Enviamos una posicion al servo en base a

lo que hemos recibido desde el Monitor Serie

del transmisor, tecleado en la PC */

}

AQUÍ LOS ARDUINOS ARMADOS

Arduino: Entradas y salidas – Manipulación de puertos

1 respuesta

NOTA: Para ver el uso de los pines del ATmega328P en Arduino recomiendo leer el artículo Arduino UNO R3 – Conectándolo al mundo exterior.

Programación avanzada de puertos

En principio, es importante recordar que los puertos de un microcontrolador de 8 bits tienen esa misma cantidad de entradas/salidas, o sea ocho líneas. Esto nos haría pensar que el ATmega328P, que posee tres puertos (B, C y D), dispone de 3 x 8 = 24 líneas de entrada/salida disponibles. Sin embargo, utilizado en un Arduino no es así, como veremos.

La mayoría de los bits de los puertos de los microcontroladores son de uso múltiple, es decir que se comportan de una forma u otra de acuerdo con su configuración. Varias líneas de puertos cumplen funciones vitales en la operación de un Arduino, funciones que no son líneas de entrada/salida de uso general.

El PORTB (puerto B) tiene ocupadas dos líneas de entrada/salida que se utilizan para conectar el cristal oscilador. Estos pines, el PORTB bit-6 y PORTB bit-7, pueden quedar libres si se configura al chip para utilizar el oscilador interno, pero esta opción no podemos utilizarla en el Arduino debido a que ya tiene su sistema basado en la velocidad de cristal de 16 MHz, además de que el cristal está soldado a esos pines en el circuito de la placa.

El PORTC tiene dos bits que no están disponibles, uno de ellos, el PORTC bit-6 se utiliza como entrada de reinicio (RESET), y el otro bit (7) no está cableado hacia el exterior del ATmega328P con cápsula PDIP que viene enchufado en el zócalo del Arduino Uno R3, porque no posee suficientes líneas disponibles en su encapsulado de 28 patas. Y cuando se trata de un chip con encapsulado de montaje superficial TQFP de 32 pines (como en el Arduino Nano y en algunos clones de Arduino Uno), las dos líneas faltantes están dedicadas al convertidor analógico digital (ADC6 y ADC7) y no son pines de entrada/salida digital.

Dos bits del PORTD, el PORTD bit-0 y el PORTD bit-1, se utilizan durante la programación del Arduino, ya que están conectados a la interfaz USB, además de ser los pines TX y RX utilizados para la comunicación serie. Estos pines se pueden utilizar para comunicación serie asincrónica hacia el exterior, y también como entradas o salidas cuando no se está grabando un programa. Pero no deben tener conexiones instaladas mientras se programa el Arduino.

En consecuencia, no se llega a disponer de la cantidad de 24 entradas/salidas que ofrecerían tres puertos de 8 bits.

El ATmega328P, como cualquier otro microcontrolador, tiene registros para cada puerto con los cuales se define si cada bit del puerto será usado como entrada o como salida, y en varios casos otra función. El ATmega328P tiene tres puertos: PORTB, PORTC y PORTD, por lo cual hay tres bancos de registros de configuración, uno para cada puerto.

Bancos y puertos de ATmega 328p
Banco	2⁷	2⁶	2⁵	2⁴	2³	2²	2¹	2⁰
PORTB			Digital 13	Digital 12	Digital 11	Digital 10	Digital 9	Digital 8
PORTC			A5	A4	A3	A2	A1	A0
PORTD	Digital 7	Digital 6	Digital 5	Digital 4	Digital 3	Digital 2	Digital 1	Digital 0
Valor	128	64	32	16	8	4	2	1

Registros

El ATmega328P tiene tres registros de 8 bits con los que administra estos tres puertos:

DDRx (donde x es B, C o D en este caso) determina si un bit es entrada (fijándolo en 0) o salida (fijándolo en 1)
PORTx controla si el pin está en nivel ALTO (HIGH) o BAJO (LOW). También define la existencia o no de un resistor de polarización a Vcc (pull-up, en inglés) si es una entrada.
PINx permite leer el estado de los pines de un puerto (solo es para lectura)

Antes de entrar de lleno a explicar el uso de los registros, veamos primero para qué podría servir este esfuerzo.

Ventajas de usar registros:

Cada instrucción de máquina necesita un ciclo de reloj a 16 MHz. Las funciones digitalRead() y digitalWrite() se componen cada una de ellas de varias instrucciones de máquina, lo que puede influir negativamente en aplicaciones muy dependientes del tiempo. El uso de los registros PORTx puede hacer el mismo trabajo en muchos menos ciclos de reloj.
Si es necesario cambiar de estado varios pines simultáneamente en lugar de ir haciéndolo de a uno con un ciclo for, que tomaría mucho tiempo, es posibles escribir directamente al registro y establecer los valores de varios pines de una sola vez.
Si el código está llegando al límite de memoria de programa disponible (memoria Flash), es posible usar este método para hacer que el código use menos bytes de programa.

Desventajas de usar registros:

El código no es fácil de entender para novatos.
Es mucho mas fácil cometer errores de difícil depuración. Por ejemplo con DDRD = B11111111 se pone a todos los pines, D0 a D7 como salida, inclyendo el pin D0 (RX), lo que causará que el puerto serie deje de funcionar.

En las librerías es muy recomendable usar la manipulación directa de registros, de modo de hacerlas mucho más eficientes.

Registro DDRx – Definición de pines como entrada o salida

Al utilizar los registros DDR tenemos la ventaja de que con solo una instrucción podemos declarar el pin como entrada o salida, en cambio, utilizando pinMode() necesitaríamos 8 instrucciones.

Veamos un ejemplo con el registro DDRB del PORTB:

El ejemplo de la imagen define los 4 bits bajos o menos significativos (0 a 3) como entradas, y los 4 bits altos o más significativos (4 a 7) como salidas. Veamos cómo se verían este y otros ejemplos en el programa del IDE de Arduino.

DDRB = B11110000;  // PORTB7-PORTB4 como salidas, PORTB0-PORTB3 como entradas.
DDRD = B11111111;  // PORTD0-PORTD7 como salidas.
DDRB = B00000000;  // PORTB0-PORTB7 como entradas.
DDRB = B00000111;  // PORTB0-PORTB2 salidas, PORTB3-PORTB7 como entradas.
PORTD = B11111111; // PORTD0-PORTD7 en ALTO (HIGH).
PORTD = B00000000; // PORTD0-PORTD7 en BAJO (LOW).
PORTB = B00000101; // PORTB0 y PORTB2 en ALTO (HIGH), PORTB1, PORTB3-PORTB7 en BAJO (LOW).
byte variable = PIND; // Guarda en una variable 'byte' el estado de PORTD0-PORTD7.

DDRB = B11110000; // PORTB7-PORTB4 como salidas, PORTB0-PORTB3 como entradas.

DDRD = B11111111; // PORTD0-PORTD7 como salidas.

DDRB = B00000000; // PORTB0-PORTB7 como entradas.

DDRB = B00000111; // PORTB0-PORTB2 salidas, PORTB3-PORTB7 como entradas.

PORTD = B11111111; // PORTD0-PORTD7 en ALTO (HIGH).

PORTD = B00000000; // PORTD0-PORTD7 en BAJO (LOW).

PORTB = B00000101; // PORTB0 y PORTB2 en ALTO (HIGH), PORTB1, PORTB3-PORTB7 en BAJO (LOW).

byte variable = PIND; // Guarda en una variable 'byte' el estado de PORTD0-PORTD7.

Mediante estos registros también podemos controlar las resistencias internas de pull-up que se usan, básicamente, para no dejar los pines de entrada al aire, ya que esto genera ruido eléctrico. Se puede resolver el problema de dos maneras: poner una resistencia externa de 10K a Vcc (+5V) o usar los pull-up internos del microcomputador, que polarizan de la misma forma las entradas y hacen más simple el circuito.

Para habilitar las resistencias pull-up, primero tenemos que configurar como entrada el puerto (con el bit 0), mediante registro DDRx, y luego escribir un 1 en el registro PORTx.

DDRD = B00000000;  // Configura los pines del puerto PORTD (D0-D7) como entradas.
PORTD = B00001111; // Habilitar las pull-ups de los pines D0-D3.

1 2	DDRD = B00000000; // Configura los pines del puerto PORTD (D0-D7) como entradas. PORTD = B00001111; // Habilitar las pull-ups de los pines D0-D3.

Es el equivalente de usar varias veces las funciones digitalRead() y digitalWrite() de Arduino. Sin embargo, con acceso directo al puerto se puede ahorrar espacio en la memoria flash, porque cada operación con funciones de leer estados de un puerto ocupa varios bytes de instrucciones, y también se puede ganar mucha velocidad, porque las funciones Arduino puede tomar más de 40 ciclos de reloj para leer o escribir un solo bit en un puerto.

Nada mejor que un ejemplo concreto para entender las instrucciones de programa. Veamos un ejemplo con Leds.

Diagrama:

En este ejemplo, durante dos segundos todos los leds encienden, durante otros dos segundos se encienden los impares, luego los pares, y durante dos más se apagan todos.

Abrimos Arduino IDE y escribimos el siguiente código:

void setup(){
  DDRD= B11111100; // Utilizamos seis bits del puerto D. 

// En este ejemplo no utilizamos los pines 0 y 1 del Arduino
// para no interferir con la comunicación serie.

/* Esta instrucción equivale a hacer esto:
  pinMode(2,OUTPUT);
  pinMode(3,OUTPUT);
  pinMode(4,OUTPUT);
  pinMode(5,OUTPUT);
  pinMode(6,OUTPUT);
  pinMode(7,OUTPUT); 
*/
}
void loop(){
  PORTD= B11111100; // aquí encenderemos todos los leds
  delay(2000);
  PORTD= B10101000; // aquí encenderemos solo una mitad.
  delay(2000);
  PORTD= B01010100; // aquí encenderemos la otra mitad.
  delay(2000);
  PORTD= B00000000; // aquí los apagaremos todos.
  delay(2000);
}

void setup(){

DDRD= B11111100; // Utilizamos seis bits del puerto D.

// En este ejemplo no utilizamos los pines 0 y 1 del Arduino

// para no interferir con la comunicación serie.

/* Esta instrucción equivale a hacer esto:

pinMode(2,OUTPUT);

pinMode(3,OUTPUT);

pinMode(4,OUTPUT);

pinMode(5,OUTPUT);

pinMode(6,OUTPUT);

pinMode(7,OUTPUT);

}

void loop(){

PORTD= B11111100; // aquí encenderemos todos los leds

delay(2000);

PORTD= B10101000; // aquí encenderemos solo una mitad.

delay(2000);

PORTD= B01010100; // aquí encenderemos la otra mitad.

delay(2000);

PORTD= B00000000; // aquí los apagaremos todos.

delay(2000);

}

Un segundo ejemplo que puede resultar más divertido. Enciende un led en secuencia hacia a un lado y hacia el otro. No hice más sofisticado el programa para claridad y comprensión. Se puede hacer dentro de una estructura for, por ejemplo, tomando el dato a poner el puerto de una matriz. O usando otros recursos más complicados, como desplazar el dato sobre un registro antes de ponerlo al puerto. Pero prefiero que sea didáctico y comprensible para todos.

La secuencia suelen llamarla «El auto fantástico». Hasta se vende un dispositivo con ese efecto de luces para adornar los autos.

El programa es:

void setup(){
  DDRD= B11111100; // Utilizamos seis bits del puerto D. 

// En este ejemplo no utilizamos los pines 0 y 1 del Arduino
// para no interferir con la comunicación serie.

/* Esta instrucción equivale a hacer esto:
  pinMode(2,OUTPUT);
  pinMode(3,OUTPUT);
  pinMode(4,OUTPUT);
  pinMode(5,OUTPUT);
  pinMode(6,OUTPUT);
  pinMode(7,OUTPUT); 
*/
}
void loop(){
  PORTD= B00000100; // aquí encenderemos un primer led.
  delay(200);
  PORTD= B00001000; // aquí el siguiente.
  delay(200);
  PORTD= B00010000; // y sigue la secuencia.
  delay(200);
  PORTD= B00100000; // sigue.
  delay(200);
  PORTD= B01000000; // sigue.
  delay(200);
  PORTD= B10000000; // sigue.
  delay(200);
  PORTD= B01000000; // y ahora regresa.
  delay(200);
  PORTD= B00100000; // sigue.
  delay(200);
  PORTD= B00010000; // sigue.
  delay(200);
  PORTD= B00001000; // sigue.
  delay(200);
}

void setup(){

DDRD= B11111100; // Utilizamos seis bits del puerto D.

// En este ejemplo no utilizamos los pines 0 y 1 del Arduino

// para no interferir con la comunicación serie.

/* Esta instrucción equivale a hacer esto:

pinMode(2,OUTPUT);

pinMode(3,OUTPUT);

pinMode(4,OUTPUT);

pinMode(5,OUTPUT);

pinMode(6,OUTPUT);

pinMode(7,OUTPUT);

}

void loop(){

PORTD= B00000100; // aquí encenderemos un primer led.

delay(200);

PORTD= B00001000; // aquí el siguiente.

delay(200);

PORTD= B00010000; // y sigue la secuencia.

delay(200);

PORTD= B00100000; // sigue.

delay(200);

PORTD= B01000000; // sigue.

delay(200);

PORTD= B10000000; // sigue.

delay(200);

PORTD= B01000000; // y ahora regresa.

delay(200);

PORTD= B00100000; // sigue.

delay(200);

PORTD= B00010000; // sigue.

delay(200);

PORTD= B00001000; // sigue.

delay(200);

}

@nbsp;

Un chip de la liga mayor:

Sólo por completar la información, y dar una idea de la importancia de este tipo de ahorro de código en otros microcontroladores, voy a mostrar algunos datos de los puertos del ATMega2560, el núcleo del Arduino Mega 2560 R3 (esquemático). Un tremendo chip con nada menos que 100 pines y ONCE puertos, que van desde el PORTA al PORTL. ¡Imagínense el banco de registros que hay para manejar!

Microcontrolador ATmega2560-16AU

Placa Arduino Mega 2560 R3

Encapsulado del ATmega2560-16AU utilizado en el Mega 2560

Arduino: reconocer colores con el módulo TCS230 – TCS3200

1 respuesta

En principio hay que dejar en claro que nos vamos a encontrar en los sitios de venta y en la información técnica en-línea con diversos formatos de soporte físico de este sensor. Voy a mostrar al menos 4 en la imagen que sigue.

Confusiones de Mercado:

Antes de seguir se presenta la necesidad de aclarar que hay una controversia difícil de resolver: los vendedores, sea en sitios como Mercadolibre o internacionales como eBay, nombran a estos sensores como «TCS230 TCS3200 Recognition Color Sensor Detector Module» («Módulo Sensor Detector de Reconocimiento de Color TCS230 TCS3200»). Es decir, en el nombre descriptivo aparecen dos códigos, y estos códigos son los nombres de dos chips diferentes: TCS230 y TCS3200. Modelos diferentes. Si alguien desea dilucidar qué chip detector posee su propio módulo recomiendo leer y seguir este debate en el foro oficial de Arduino. O más fácil, una observación detallada de la ventana del chip permite ver de cuántos fotodiodos se compone. Si es una matriz de 8×8 (es visible con facilidad), su sensor corresponde a la descripción y ejemplos que tratamos aquí. Si la matriz es de 4×4 o 8×4, usted se encuentra en presencia de otro sensor. Digamos que, de ser así, y la cantidad y nombre de los pines de entrada/salida de su módulo coinciden con las descripciones que ofrezco aquí, usted puede probar con su sensor los diagramas de conexión y programas propuestos en este artículo. Para mayor tranquilidad, según sus hojas de datos, tanto el TCS230 como el TCS3200 poseen una matriz de 8×8 fotodiodos y la descripción de funcionamiento de la primera hoja coincide en todos sus parámetros, excepto en el tamaño de los fotodiodos, que es de 110 μm x 110 μm separados 134-μm centro a centro en el TCS3200, y de 120 µm x 120 µm separados 144-µm en el TCS230. También se nota una diferencia física en el diagrama de ambos chips, visible en la forma de sus conexiones metálicas internas. La opinión en el debate del foro de Arduino es que el TCS230 en una versión anterior de fabricación del TCS3200, lo cual es muy posible porque la empresa fabricante originalmente era TAOS, y luego se convirtió en AMS.

Diagrama en la hojas de datos del chip TCS230 y TCS3200:

Módulo Sensor/Detector de reconocimiento de color

Descripción básica:

Este módulo utiliza un sensor integrado provisto de 64 fotodiodos. De estos 64 fotodiodos, 16 tienen filtro para el color rojo, 16 para el color verde, 16 para el color azul y 16 para luz directa (sin ningún filtro).

Al estar distribuidos uniformemente sobre el chip, estos fotodiodos captan la luz, filtran los colores, y generan una salida de señal de onda cuadrada cuyo ancho de pulso indica la información sobre la intensidad del rojo (R = red: rojo), verde (G = green: verde) y azul (B = blue: azul).

Si observa de cerca un chip TCS3200, se pueden ver los diferentes filtros:

En el módulo que se ve en la foto de cabecera, el sensor se ha montado junto con cuatro LEDs blancos que aportan la iluminación. El módulo posee ocho pines de conexión.

El rango de distancia para la medición es de 10 mm. El módulo mide 31,6 mm x 24,4 mm. Sus pines están separados entre sí con la separación estándar de la placas de circuito impreso preperforadas y de las protoboard, o placas de prototipo.

El módulo acepta una alimentación de 3 a 5 voltios aplicada en dos pines, y para la conexión con un Arduino u otro microcontrolador se utilizan 6 pines:

Control: S0, S1, S2, S3
OUT (SALIDA): que se encarga de enviar la información
OE (Output Enable: habilitación de la salida)

Las entradas se pueden controlar desde una salida digital del Arduino u otra plaqueta de control, o en el caso de OE, conectarla a tierra (lado ─, o negativo, de la alimentación) para habilitar el módulo de manera constante.

Funcionamiento:

Los TCS3200 son sensores que convierten en frecuencia la intensidad de luz medida por una matriz de fotodiodos. La frecuencia entregada por el sensor TCS3200 es mayor cuanta mayor luminosidad se detecte. La configuración en matriz de los fotodiodos permite lograr un promedio del valor que se mide para compensar diferencias de color en la superficie que se muestrea. También dispone de filtros de color distribuidos de manera uniforme por la superficie, ubicados sobre los fotodiodos, que, al ir alternando su estado, sirven para distinguir cada componente de la luz.

La matriz de los sensores TCS3200 está formada por 16 fotodiodos con un filtro rojo, 16 con un filtro verde, 16 con un filtro azul y otros 16 sin filtrar. Los 64 fotodiodos no funcionan de manera simultánea sino que se activan por grupos de color antes de realizar la medición de la intensidad de luz que incide en ellos. Para elegir qué filtros deben activarse en cada momento, los TCS3200 disponen de dos pines, S2 y S3, con las que configurarlos.

Una vez obtenida la lectura de la iluminación, la corriente se convierte a frecuencia en forma de onda cuadrada con un ciclo de trabajo del 50% (mitad pulso alto, mitad pulso bajo). Enviar al microcontrolador una frecuencia en lugar de una corriente (intensidad) permite que sea más estable y soporte mejor las interferencias producidas por las pistas del circuito o los cables que unan el TCS3200 con el micro.

La máxima frecuencia que los TCS3200 puede generar (sin producir saturación) dependiendo de la intensidad de la luz medida y del color (longitud de onda de la luz) es de 600 KHz. Para poder utilizar un microcontrolador (u otros componentes) a poca velocidad, es posible escalar la frecuencia en tres niveles, la normal (máxima) al 100%, una media al 20% y otra baja al 2%. Los pines S0 y S1 de los TCS3200 son para establecer estos valores de frecuencia.

Conexiones del sensor

GND Tierra de la fuente de alimentación
OE (entrada) Habilitar la salida de frecuencia (activo bajo)
OUT (salida) Frecuencia de salida
S0, S1 (entradas） Entradas de selección de la escala de frecuencia de salida
S2, S3 (entradas） Entradas de selección del tipo de fotodiodo
VDD Voltaje de alimentación

Selección de filtro:

Para seleccionar el color que se lee de los fotodiodos, se utilizan los pines de control S2 y S3. Dado que los fotodiodos están conectados en paralelo, estableciendo S2 y S3 en diferentes combinaciones de BAJO y ALTO permite seleccionar diferentes grupos de fotodiodos. La tabla de abajo indica las opciones:

Escala de frecuencia:

Para el Arduino es común usar una escala de frecuencia del 20%. Por lo tanto, se establece el pin S0 en ALTO y el pin S1 en BAJO.

Sensor de color con Arduino y TCS3200:

En este ejemplo, se va a detectar colores con el Arduino y el sensor de color TCS3200. Esta configuración sensor no es muy precisa, pero funciona bien para detectar colores en proyectos simples.

Esquemático:

Conectar el sensor TCS3200 al Arduino es bastante sencillo. Simplemente se debe seguir el siguiente diagrama esquemático. Utilizo en este ejemplo el modelo que aparece en la foto en el encabezado de esta nota.

Las primeras pruebas serán:

1. Lectura y visualización de la frecuencia de salida en el monitor serie. En esta parte, anotaremos los valores de frecuencia al colocar diferentes colores frente al sensor.

2. Distinguir entre diferentes colores. En esta sección, insertaremos los valores de frecuencia seleccionados en el código previo, para que el sensor pueda distinguir entre diferentes colores. Detectaremos colores rojos, verdes y azules.

Leyendo la frecuencia de salida

//
// Cableado de TCS3200 a Arduino
//
#define S0 8
#define S1 9
#define S2 12
#define S3 11
#define salidaSensor 10

// Para guardar las frecuencias de los fotodiodos
int frecuenciaRojo = 0;
int frecuenciaVerde = 0;
int frecuenciaAzul = 0;

void setup() {
  // Definiendo las Salidas
  pinMode(S0, OUTPUT);
  pinMode(S1, OUTPUT);
  pinMode(S2, OUTPUT);
  pinMode(S3, OUTPUT);
  
  // Definiendo salidaSensor como entrada
  pinMode(salidaSensor, INPUT);
  
  // Definiendo la escala de frecuencia a 20%
  digitalWrite(S0,HIGH);
  digitalWrite(S1,LOW);
  
   // Iniciar la comunicacion serie 
  Serial.begin(9600);
}
void loop() {
  // Definiendo la lectura de los fotodiodos con filtro rojo
  digitalWrite(S2,LOW);
  digitalWrite(S3,LOW);
  
  // Leyendo la frecuencia de salida del sensor
  frecuenciaRojo = pulseIn(salidaSensor, LOW);
  
  // Mostrando por serie el valor para el rojo (R = Red)
  Serial.print("R = ");
  Serial.print(frecuenciaRojo);
  delay(100);
  
  // Definiendo la lectura de los fotodiodos con filtro verde
  digitalWrite(S2,HIGH);
  digitalWrite(S3,HIGH);
  
  // Leyendo la frecuencia de salida del sensor
  frecuenciaVerde = pulseIn(salidaSensor, LOW);
  
  // Mostrando por serie el valor para el verde (G = Green)
  Serial.print(" G = ");
  Serial.print(frecuenciaVerde);
  delay(100);
 
  // Definiendo la lectura de los fotodiodos con filtro azul
  digitalWrite(S2,LOW);
  digitalWrite(S3,HIGH);
  
  // Leyendo la frecuencia de salida del sensor
  frecuenciaAzul = pulseIn(salidaSensor, LOW);
  
  // Mostrando por serie el valor para el azul (B = Blue)
  Serial.print(" B = ");
  Serial.println(frecuenciaAzul);
  delay(100);
}

// Cableado de TCS3200 a Arduino

#define S0 8

#define S1 9

#define S2 12

#define S3 11

#define salidaSensor 10

// Para guardar las frecuencias de los fotodiodos

int frecuenciaRojo = 0;

int frecuenciaVerde = 0;

int frecuenciaAzul = 0;

void setup() {

// Definiendo las Salidas

pinMode(S0, OUTPUT);

pinMode(S1, OUTPUT);

pinMode(S2, OUTPUT);

pinMode(S3, OUTPUT);

// Definiendo salidaSensor como entrada

pinMode(salidaSensor, INPUT);

// Definiendo la escala de frecuencia a 20%

digitalWrite(S0,HIGH);

digitalWrite(S1,LOW);

// Iniciar la comunicacion serie

Serial.begin(9600);

}

void loop() {

// Definiendo la lectura de los fotodiodos con filtro rojo

digitalWrite(S2,LOW);

digitalWrite(S3,LOW);

// Leyendo la frecuencia de salida del sensor

frecuenciaRojo = pulseIn(salidaSensor, LOW);

// Mostrando por serie el valor para el rojo (R = Red)

Serial.print("R = ");

Serial.print(frecuenciaRojo);

delay(100);

// Definiendo la lectura de los fotodiodos con filtro verde

digitalWrite(S2,HIGH);

digitalWrite(S3,HIGH);

// Leyendo la frecuencia de salida del sensor

frecuenciaVerde = pulseIn(salidaSensor, LOW);

// Mostrando por serie el valor para el verde (G = Green)

Serial.print(" G = ");

Serial.print(frecuenciaVerde);

delay(100);

// Definiendo la lectura de los fotodiodos con filtro azul

digitalWrite(S2,LOW);

digitalWrite(S3,HIGH);

// Leyendo la frecuencia de salida del sensor

frecuenciaAzul = pulseIn(salidaSensor, LOW);

// Mostrando por serie el valor para el azul (B = Blue)

Serial.print(" B = ");

Serial.println(frecuenciaAzul);

delay(100);

}

Abrir el monitor serie configurado a una velocidad de 9600 baudios.

Colocar un objeto AZUL frente al sensor a diferentes distancias. Registrar dos mediciones: cuando el objeto se coloca a distancia del sensor, y cuando el objeto está cerca de él (ideal 1 cm).

Comprobar los valores que muestra el monitor serie. La frecuencia para el AZUL (B) debe ser la más baja en comparación con las lecturas de frecuencia del ROJO (R) y VERDE (G).

Con el objeto AZUL delante del sensor, los valores de frecuencia para el AZUL (B) oscilan entre dos valores que pueden estar separados por una relación cercana a 4 a 1 para las mediciones de cerca y de lejos.

Los valores que mostremos en este ejemplo no deben ser tomados como referencia. Para su código, usted debe medir los colores de su objeto específico con su propio sensor de color. Guarde los límites de frecuencia superior e inferior para el color AZUL, porque son necesarios más adelante.

Repetir el proceso con objetos de color VERDE y color ROJO y anotar los límites de frecuencia superior e inferior para cada uno de ellos.

Distinguir entre diferentes colores

El programa a continuación asigna los valores de frecuencia a valores RGB (que están cada uno entre 0 y 255).

En el paso anterior, cuando tomamos el máximo AZUL, digamos como ejemplo que obtuvimos una frecuencia de 60 y cuando colocamos el objeto AZUL a una distancia mayor obtuvimos 230.

Entonces, 60 en frecuencia corresponde a 255 (en RGB) y 230 en frecuencia a 0 (en RGB). La conversión se realiza con la función map() del lenguaje Arduino. En la función map() usted debe reemplazar los parámetros xx con los valores que usted ha registrado.

//
// Cableado de TCS3200 a Arduino
//
#define S0 8
#define S1 9
#define S2 12
#define S3 11
#define salidaSensor 10

// Para guardar las frecuencias de los fotodiodos
int frecuenciaRojo = 0;
int frecuenciaVerde = 0;
int frecuenciaAzul = 0;
int colorRojo;
int colorVerde;
int colorAzul;

void setup() {
  // Definiendo las Salidas
  pinMode(S0, OUTPUT);
  pinMode(S1, OUTPUT);
  pinMode(S2, OUTPUT);
  pinMode(S3, OUTPUT);
  
  // Definiendo salidaSensor como entrada
  pinMode(salidaSensor, INPUT);
  
  // Definiendo la escala de frecuencia a 20%
  digitalWrite(S0,HIGH);
  digitalWrite(S1,LOW);
  
   // Iniciar la comunicacion serie 
  Serial.begin(9600);
}

void loop() {
  // Definiendo la lectura de los fotodiodos con filtro rojo
  digitalWrite(S2,LOW);
  digitalWrite(S3,LOW);
  
  // Leyendo la frecuencia de salida del sensor
  frecuenciaRojo = pulseIn(salidaSensor, LOW);

  // Mapeando el valor de la frecuencia del ROJO (RED = R) de 0 a 255
  // Usted debe colocar los valores que registro. Este es un ejemplo: 
  // colorRojo = map(frecuenciaRojo, 70, 120, 255,0);
  colorRojo = map(frecuenciaRojo, xx, xx, 255,0);
  
  // Mostrando por serie el valor para el rojo (R = Red)
  Serial.print("R = ");
  Serial.print(colorRojo);
  delay(100);
  
  // Definiendo la lectura de los fotodiodos con filtro verde
  digitalWrite(S2,HIGH);
  digitalWrite(S3,HIGH);
  
  // Leyendo la frecuencia de salida del sensor
  frecuenciaVerde = pulseIn(salidaSensor, LOW);

  // Mapeando el valor de la frecuencia del VERDE (GREEN = G) de 0 a 255
  // Usted debe colocar los valores que registro. Este es un ejemplo: 
  // colorVerde = map(frecuenciaVerde, 100, 199, 255,0);
  colorVerde = map(frecuenciaVerde, xx, xx, 255,0);

  // Mostrando por serie el valor para el verde (G = Green)
  Serial.print("G = ");
  Serial.print(colorVerde);
  delay(100);
 
  // Definiendo la lectura de los fotodiodos con filtro azul
  digitalWrite(S2,LOW);
  digitalWrite(S3,HIGH);
  
  // Leyendo la frecuencia de salida del sensor
  frecuenciaAzul = pulseIn(salidaSensor, LOW);

  // Mapeando el valor de la frecuencia del AZUL (AZUL = B) de 0 a 255
  // Usted debe colocar los valores que registro. Este es un ejemplo: 
  // colorAzul = map(frecuenciaAzul, 38, 84, 255, 0);
  colorAzul = map(frecuenciaAzul, xx, xx, 255, 0);
  
  // Mostrando por serie el valor para el azul (B = Blue)
  Serial.print("B = ");
  Serial.print(colorAzul);
  delay(100);

  // Comprobar cual es el color detectado y mostrarlo
  // con un mensaje en el monitor serie
  if(colorRojo > colorVerde && colorRojo > colorAzul){
      Serial.println(" - Detectado ROJO");
  }
  if(colorVerde > colorRojo && colorVerde > colorAzul){
    Serial.println(" - Detectado VERDE");
  }
  if(colorAzul > colorRojo && colorAzul > colorVerde){
    Serial.println(" - Detectado AZUL");
  }
}

// Cableado de TCS3200 a Arduino

#define S0 8

#define S1 9

#define S2 12

#define S3 11

#define salidaSensor 10

// Para guardar las frecuencias de los fotodiodos

int frecuenciaRojo = 0;

int frecuenciaVerde = 0;

int frecuenciaAzul = 0;

int colorRojo;

int colorVerde;

int colorAzul;

void setup() {

// Definiendo las Salidas

pinMode(S0, OUTPUT);

pinMode(S1, OUTPUT);

pinMode(S2, OUTPUT);

pinMode(S3, OUTPUT);

// Definiendo salidaSensor como entrada

pinMode(salidaSensor, INPUT);

// Definiendo la escala de frecuencia a 20%

digitalWrite(S0,HIGH);

digitalWrite(S1,LOW);

// Iniciar la comunicacion serie

Serial.begin(9600);

}

void loop() {

// Definiendo la lectura de los fotodiodos con filtro rojo

digitalWrite(S2,LOW);

digitalWrite(S3,LOW);

// Leyendo la frecuencia de salida del sensor

frecuenciaRojo = pulseIn(salidaSensor, LOW);

// Mapeando el valor de la frecuencia del ROJO (RED = R) de 0 a 255

// Usted debe colocar los valores que registro. Este es un ejemplo:

// colorRojo = map(frecuenciaRojo, 70, 120, 255,0);

colorRojo = map(frecuenciaRojo, xx, xx, 255,0);

// Mostrando por serie el valor para el rojo (R = Red)

Serial.print("R = ");

Serial.print(colorRojo);

delay(100);

// Definiendo la lectura de los fotodiodos con filtro verde

digitalWrite(S2,HIGH);

digitalWrite(S3,HIGH);

// Leyendo la frecuencia de salida del sensor

frecuenciaVerde = pulseIn(salidaSensor, LOW);

// Mapeando el valor de la frecuencia del VERDE (GREEN = G) de 0 a 255

// Usted debe colocar los valores que registro. Este es un ejemplo:

// colorVerde = map(frecuenciaVerde, 100, 199, 255,0);

colorVerde = map(frecuenciaVerde, xx, xx, 255,0);

// Mostrando por serie el valor para el verde (G = Green)

Serial.print("G = ");

Serial.print(colorVerde);

delay(100);

// Definiendo la lectura de los fotodiodos con filtro azul

digitalWrite(S2,LOW);

digitalWrite(S3,HIGH);

// Leyendo la frecuencia de salida del sensor

frecuenciaAzul = pulseIn(salidaSensor, LOW);

// Mapeando el valor de la frecuencia del AZUL (AZUL = B) de 0 a 255

// Usted debe colocar los valores que registro. Este es un ejemplo:

// colorAzul = map(frecuenciaAzul, 38, 84, 255, 0);

colorAzul = map(frecuenciaAzul, xx, xx, 255, 0);

// Mostrando por serie el valor para el azul (B = Blue)

Serial.print("B = ");

Serial.print(colorAzul);

delay(100);

// Comprobar cual es el color detectado y mostrarlo

// con un mensaje en el monitor serie

if(colorRojo > colorVerde && colorRojo > colorAzul){

Serial.println(" - Detectado ROJO");

}

if(colorVerde > colorRojo && colorVerde > colorAzul){

Serial.println(" - Detectado VERDE");

}

if(colorAzul > colorRojo && colorAzul > colorVerde){

Serial.println(" - Detectado AZUL");

}

La explicación de las comparaciones es:

Cuando R es el valor máximo (en parámetros RGB), sabemos que tenemos un objeto rojo.
Cuando G es el valor máximo, sabemos que tenemos un objeto verde.
Cuando B es el valor máximo, sabemos que tenemos un objeto azul.

Al colocar algo delante del sensor, deberá mostrar en su monitor serie el color detectado: rojo, verde o azul.

Agregando al programa más comparaciones se puede ampliar la detección. Como se dijo a inicio de este artículo. se trata de un ejemplo simple de uso de este detector de colores, al que, con tiempo y dedicación, se puede ampliar a los niveles de complejidad que se desee.

Robots Didácticos

Robótica, Automatización, control industrial, microcontroladores, electrónica digital

Archivo de la categoría: Programación

Arduino: bibliotecas de funciones personales

Uso de la placa L298N para motores de CC

Arduino: Comunicación inalámbrica con NRF24L01

Arduino: Entradas y salidas – Manipulación de puertos

Arduino: reconocer colores con el módulo TCS230 – TCS3200