Archivo del Autor: ecarletti

Arduino: Motor paso a paso 28BYJ-48 y módulo ULN2003

Un motor paso a paso es un dispositivo electromecánico que convierte pulsos eléctricos en movimientos mecánicos exactos. El eje de un motor paso a paso gira en pasos de ángulos fijos cuando se le aplican impulsos eléctricos en la secuencia correcta. La dirección de rotación del eje del motor se relaciona directamente con la secuencia de los pulsos. La velocidad de la rotación del eje está relacionada con la frecuencia de los pulsos de entrada y la duración de la rotación está relacionada con la cantidad de pulsos que se aplican a la entrada.

Una de las ventajas más importantes de un motor paso a paso es su capacidad de ser controlado con precisión en un sistema de lazo abierto, es decir, sin necesidad de ninguna realimentación que indique su posición. Este tipo de control elimina la necesidad de costosos dispositivos de detección y ajuste, como los codificadores ópticos.

Para ampliar su conocimiento en más detalle sobre motores paso a paso ver aquí.

28BYJ-48 y su módulo controlador asociado ULN2003

El motor 28BYJ-48 tiene un ángulo de paso de 5,625 grados (64 pasos por vuelta usando half-step). El reductor interno tiene una relación de 1/64. Combinados, la precisión total es 64 x 64 = 4096 pasos por vuelta, equivalente a un paso de 0,088°, que resulta en una precisión muy elevada. Debido a alguna razón mecánica que el fabricante no explica, no son exactamente 4096: es necesario aclarar que la cantidad verdadera de pasos para dar una vuelta completa de 360° —como verán en el programa— es de 4076.

Los parámetros de este motor paso a paso son:

Modelo: 28BYJ-48 – 5V
Tensión nominal: 5V (o 12 V, valor indicado en la parte trasera).
Cantidad de fases: 4.
Reductor de velocidad: 1/64
Ángulo de paso: 5,625° / 64
Frecuencia: 100Hz
Resistencia en CC: 50Ω ±7 % (25° C)
Frecuencia con tracción: > 600Hz
Frecuencia sin tracción: > 1000Hz
Torque con tracción: >34,3mN.m (120Hz)
Torque en autoposicionamiento: >34,3mN.m
Torque con fricción: 600-1200 gf.cm
Arrastre en torque: 300 gf.cm
Resistencia de aislación > 10MΩ (500V)
Aislación eléctrica: 600VAC/1mA/1s
Grado de aislación: A
Aumento de temperatura: < 40K (120Hz)
Ruido: < 35dB (120Hz, sin carga, 10cm)

El integrado ULN2003

Consiste en un conjunto de 7 pares de transistores en configuración Darlington, con diodo de protección de contracorriente. Cada salida es capaz de manejar 500 mA y hasta 50V en sus salidas.

Diagrama en bloques:

Diagrama interno de cada circuito:

Los circuitos de transistores Darlington tienen un resistor en la entrada, de modo que se los puede conectar directamente a la salida de un microcontrolador. También tienen protección con un diodo para evitar daños en las entradas, si accidentalmente se les aplica un voltaje negativo.

¿Cómo se acciona?

El motor tiene cuatro bobinados que son excitados en una precisa secuencia para hacer girar el eje.

En el modo elegido, de medio paso, o “half step”, primero se excita una bobina, luego dos a la vez, luego la siguiente… Y así hasta completar la secuencia. Para cambiar el sentido de giro, simplemente se invierte el orden de la secuencia.

Diagrama de las dos secuencias usadas habitualmente

Por eso, en la secuencia de medio paso (half step, en inglés), la variación de señales necesaria para el funcionamiento en uno u otro sentido tiene 8 combinaciones, tal como lo muestra el cuadro.

Vista del conector al motor y las salidas A, B, C, D y E (entrada de alimentación):

Diagrama de la placa de control:

A (Azul), B (Rosa), C (Amarillo), D (Naranja), E (Rojo)

La conexión entre el módulo y el motor no requiere mucha atención ya que tiene un conector con ranuras para guiar la unión entre los dos dispositivos.

El módulo posee cuatro leds que indican qué bobina está activada (dibujo de arriba) en cada momento.

La salida de 5V de la placa Arduino es suficiente para un motor, pero si su proyecto tiene más elementos conectados, debe usar una fuente de alimentación externa de 5V, debido a que se puede exceder la corriente que es capaz de suministrar el microcontrolador.

Los pines IN1, IN2, IN3 e IN4 se conectan a cuatro salidas digitales del Arduino (pines digitales del 8 al 11 empezando, por el IN1 con el 8).

Programa

El programa tal como se ve está preparado para el modo de medio paso, o half-step, ya que es el que recomienda el fabricante. Sin embargo, cambiando los signos // de comentario en el programa de un bloque de código a otro, es posible probar los tres modos en el motor.

//definicion de pines
const int pinMotor1 = 8;    // 28BYJ48 - In1
const int pinMotor2 = 9;    // 28BYJ48 - In2
const int pinMotor3 = 10;   // 28BYJ48 - In3
const int pinMotor4 = 11;   // 28BYJ48 - In4

//definicion variables
int velocidadMotor = 1000;  // variable para determinar la velocidad 
// 800 maxima - minima 1000 o mas
int contadorPasos = 0;      // contador para los pasos
int pasosPorVuelta = 4076;  // pasos para una vuelta completa

// Tablas con la secuencia de encendido 
// quitar signo de comentar a la necesaria)

//secuencia 1-fase usar velocidadMotor = 2000
//const int cantidadPasos = 4;
//const int tablaPasos[4] = { B1000, B0100, B0010, B0001 };

//secuencia 2-fases usar velocidadMotor = 2000
//const int cantidadPasos = 4;
//const int tablaPasos[4] = { B1001, B1100, B0110, B0011 };

//secuencia media fase usar velocidadMotor = 1000
const int cantidadPasos = 8;
const int tablaPasos[8] = { B1000, B1100, B0100, B0110, B0010, B0011, B0001, B1001 };


void setup()
{
//declarar pines como salida
pinMode(pinMotor1, OUTPUT);
pinMode(pinMotor2, OUTPUT);
pinMode(pinMotor3, OUTPUT);
pinMode(pinMotor4, OUTPUT);
}

void loop()
{
for (int i = 0; i < pasosPorVuelta * 2; i++)
{
sentidoHorario();
delayMicroseconds(velocidadMotor);
}
delay(200);

for (int i = 0; i < pasosPorVuelta * 2; i++)
{
sentidoAntihorario();
delayMicroseconds(velocidadMotor);
}

delay(200);
}

void sentidoHorario() // en dirección de las agujas del reloj
{
contadorPasos++;
if (contadorPasos >= cantidadPasos) contadorPasos = 0;
escribirSalidas(contadorPasos);
}

void sentidoAntihorario()// en dirección contraria a las agujas del reloj
{
contadorPasos--;
if (contadorPasos < 0) contadorPasos = cantidadPasos - 1;
escribirSalidas(contadorPasos);
}

void escribirSalidas(int paso)
{
digitalWrite(pinMotor1, bitRead(tablaPasos[paso], 0));
digitalWrite(pinMotor2, bitRead(tablaPasos[paso], 1));
digitalWrite(pinMotor3, bitRead(tablaPasos[paso], 2));
digitalWrite(pinMotor4, bitRead(tablaPasos[paso], 3));
}

//definicion de pines

const int pinMotor1 = 8; // 28BYJ48 - In1

const int pinMotor2 = 9; // 28BYJ48 - In2

const int pinMotor3 = 10; // 28BYJ48 - In3

const int pinMotor4 = 11; // 28BYJ48 - In4

//definicion variables

int velocidadMotor = 1000; // variable para determinar la velocidad

// 800 maxima - minima 1000 o mas

int contadorPasos = 0; // contador para los pasos

int pasosPorVuelta = 4076; // pasos para una vuelta completa

// Tablas con la secuencia de encendido

// quitar signo de comentar a la necesaria)

//secuencia 1-fase usar velocidadMotor = 2000

//const int cantidadPasos = 4;

//const int tablaPasos[4] = { B1000, B0100, B0010, B0001 };

//secuencia 2-fases usar velocidadMotor = 2000

//const int cantidadPasos = 4;

//const int tablaPasos[4] = { B1001, B1100, B0110, B0011 };

//secuencia media fase usar velocidadMotor = 1000

const int cantidadPasos = 8;

const int tablaPasos[8] = { B1000, B1100, B0100, B0110, B0010, B0011, B0001, B1001 };

void setup()

{

//declarar pines como salida

pinMode(pinMotor1, OUTPUT);

pinMode(pinMotor2, OUTPUT);

pinMode(pinMotor3, OUTPUT);

pinMode(pinMotor4, OUTPUT);

}

void loop()

{

for (int i = 0; i < pasosPorVuelta * 2; i++)

{

sentidoHorario();

delayMicroseconds(velocidadMotor);

}

delay(200);

for (int i = 0; i < pasosPorVuelta * 2; i++)

{

sentidoAntihorario();

delayMicroseconds(velocidadMotor);

}

delay(200);

}

void sentidoHorario() // en dirección de las agujas del reloj

{

contadorPasos++;

if (contadorPasos >= cantidadPasos) contadorPasos = 0;

escribirSalidas(contadorPasos);

}

void sentidoAntihorario()// en dirección contraria a las agujas del reloj

{

contadorPasos--;

if (contadorPasos < 0) contadorPasos = cantidadPasos - 1;

escribirSalidas(contadorPasos);

}

void escribirSalidas(int paso)

{

digitalWrite(pinMotor1, bitRead(tablaPasos[paso], 0));

digitalWrite(pinMotor2, bitRead(tablaPasos[paso], 1));

digitalWrite(pinMotor3, bitRead(tablaPasos[paso], 2));

digitalWrite(pinMotor4, bitRead(tablaPasos[paso], 3));

}

Este programa hace girar al motor dos vueltas completas en un sentido, y luego dos vueltas en el otro sentido. Es posible cambiar algunos parámetros para ver su funcionamiento en tres modos diferentes.

Presento aquí un interesante diseño realizado con cuatro de estos motores como tracción y cuatro servos para darles dirección. Su creador lo ha llamado Stepperbot. He aquí una foto del proyecto (al que, sin duda, habría que quitarle una buena cantidad de peso acortando los cables al mínimo). Con menor peso podía moverse más rápido, utilizando ruedas de mayor diámetro.

Lo interesante es la gran flexibilidad de movimientos que ha logrado. Agrego un video para mostrar su desplazamiento.

Arduino: bibliotecas de funciones personales

Deja un comentario

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.

RCWL-0516: Módulo sensor de movimiento de microondas con radar Doppler

Deja un comentario

Este módulo ha sido diseñado como una alternativa a los conocidos sensores de movimiento PIR (Sensor Infrarrojo Pasivo), ampliamente utilizados en alarmas antirrobo, y en luces de seguridad. Contiene en su interior todos los componentes electrónicos esenciales, incluyendo un regulador de tensión interno en el chip, que entrega 3,3V.

Al igual que el sensor PIR, este sensor también detecta solamente algo que esté en movimiento dentro de su rango de detección, pero en lugar de percibir la radiación del cuerpo negro (infrarrojo) de una persona que se mueve, este sensor utiliza una técnica de “radar Doppler de microondas” para detectar cualquier tipo de objetos en movimiento.

Tamaño:

Tiene un rango de sensibilidad de alrededor de 7 metros. Cuando se dispara, su pin de salida de nivel TTL (OUT) cambia de BAJO (0 V) a ALTO (3,3 V) por un tiempo de 2 a 3 segundos antes de volver a su estado inactivo (BAJO).

Características:

1. Voltaje de Operación: 4-28V
2. Corriente de Operación: 2,8mA (típica); 3mA (máx)
3. Distancia de Detección: 5-7m
4. Potencia de Transmisión: 20mW (típica); 30mW (máx)
5. Voltaje de Salida: 3,2-3,4V
6. Capacidad de Corriente del Voltaje de Salida: 100mA
7. Modo de Disparo: repetición de disparo
8. Nivel de Salida Bajo: 0V
9. Nivel de Salida Alto: 3,3V
10. Temperatura de Operación: -20º a 80º celsius
11. Temperatura de almacenamiento: -40º a 100º celsius

Como se ve en sus características, el sensor puede manejar un amplio rango de alimentación: desde 4 hasta 28 V. El pin de salida se puede utilizar para una multitud de tareas, como el manejo de un indicador auditivo o visual, o incluso para conectarlo a la entrada de un microcontrolador para su procesamiento.

Donde se instale, se debe evitar que haya partes metálicas delante del módulo. Del mismo modo, siempre hay que mantener un mínimo de espacio libre de 1 cm en la parte frontal y posterior del módulo.

Pines de salida:

CDS – Entrada de desactivación del sensor (bajo = desactivado)
VIN – entrada de alimentación de 4 a 28V CC
OUT – ALTO (3,3V) movimiento detectado / BAJO (0V) inactivo
GND – Tierra / 0V
3V3 – Salida de CC regulada (100mA máx)

El LDR es opcional. Si se instala, inhibe el funcionamiento del módulo cuando recibe la luz del día. Es evidente que se convierte en una función útil cuando se utiliza el sensor para encender luces de seguridad, ya que al hacerse de día dejará de encenderla por no ser necesaria esa iluminación con luz diurna.

La distancia de detección, y la duración de la salida del módulo cuando hay una detección, se pueden ajustar añadiendo componentes pasivos en unos puntos de soldadura de la parte posterior de la placa de circuito.

Los elementos opcionales para realizar distintos ajustes van soldados sobre los puntos marcados C-TM, R-GN y R-CDS (abajo, imagen del lado de la soldadura de la placa).

Hay puntos de soldadura donde agregar una resistencia dependiente de la luz LDR (marcado CDS). El pin de entrada CDS sirve para desactivar (anular la opción de detección de luz ambiental) en el sensor, si fuese necesario.

C-TM: Ajusta el tiempo de activación de repetición (predeterminado: 2 segundos). Agregar un condensador dará una repetición más extensa del tiempo de disparo.

R-GN: ajuste de la distancia de detección (por defecto 7 metros). Añadiendo una resistencia a la detección la distancia se hará más corta. Si está conectado con una resistencia de 1 MΩ, el rango de detección es de aproximadamente 5 m.

R-CDS: al agregar una resistencia (en paralelo con la resistencia interna de 1 MΩ), el usuario puede cambiar el umbral de detección de luz según su necesidad individual. Esto es aplicable solo cuando hay un sensor de luz soldado en los puntos de soldadura (CDS) en la parte frontal de la placa de circuito.

Una resistencia de 47–100K funciona bien con un LDR estándar de 5 mm.

Funcionamiento

La electrónica del módulo posee dos secciones igualmente importantes: un transmisor / receptor / mezclador de frecuencia de microondas basado en un transistor NPN de alta frecuencia MMBR941M, y una sección de frecuencia mucho más baja basada en un circuito integrado RCWL-9196.

Técnicamente, la sección de microondas se parece a un «oscilador Colpitt» con el inductor requerido (y los capacitores) hechos con trazas de la placa de circuito. El inductor (~ 10 nH) es el trazado de la curva S en la superficie superior, y los condensadores son la estructura en anillo en la superficie inferior, y también el bloque rectangular a la izquierda de la S curva.

Circuito de la placa

Ubicación de los componentes

Circuito del chip

Dos modos de salida

Un circuito de prueba

Antes de profundizar en algo, le recomiendo que se familiarice con el hardware y el procedimiento inicial de instalación/ejecución y tratar de hacer algunos pequeños experimentos.

Aunque puede usar RCWL-0516 solo con una fuente de alimentación y un LED en su salida, se puede agregar un circuito controlador de relé para controlar cargas externas que requieran mayor corriente al accionarse cuando se detecta un movimiento.

Esquemático de la primera prueba:

Tenga en cuenta que la resistencia de 1 k (R1) no es necesaria ya que el módulo tiene una resistencia de 1 kΩ entre el pin OUT y el pin de salida real del chip de 16 patas (RCWL-9196).

El relé (RL1) en el circuito es accionado por un transistor estándar BC547 o 2N3904 (T1), y hay un indicador de «relé encendido» (LED1) que se enciende cuando el relé está en estado activo. Si lo desea, también puede utilizar otros relés de voltaje diferente. Sin embargo, en ese caso, la entrada de la fuente de alimentación (que es de 5 V) tendría que ser cambiada (con algunas otras modificaciones menores, por supuesto). El conector de 2 pines (JP1) está reservado para pruebas futuras, y sólo es utilizable cuando hay un sensor de luz conectado al módulo.

Para fines experimentales, este circuito se puede construir en una placa de pruebas. Se puede usar un conector de 5 patas (sólo se requieren tres para la primera prueba) para conectar el módulo de radar.

A continuación se muestra el montaje de esta configuración de prueba (ver también el video de prueba):

Video

Efecto Doppler

En principio, el efecto Doppler es un cambio en la frecuencia recogida por un receptor de la señal reflejada en un objeto en movimiento. En los radares de efecto Doppler, para detectar un objeto en movimiento se puede usar una señal no modulada (CW). El receptor del sensor procesa la señal transmitida con la señal reflejada en un objetivo.

Debido al efecto Doppler, la velocidad de desplazamiento de un objeto en relación con la antena provoca un cambio en la frecuencia. Se puede estimar, simplemente, que la frecuencia Doppler (que es la frecuencia obtenida en el receptor) es la cantidad de medias-ondas de la frecuencia de señal enviada por el objetivo por segundo. Una velocidad más alta producirá una frecuencia Doppler más alta. Un sistema de este tipo, con una disposición para detectar la fase de la señal, también puede indicar el sentido del movimiento del objetivo: los objetos que se alejan generan una frecuencia más baja que la de la señal de sondeo, mientras que los objetos que se aproximan generan una frecuencia más alta.

Oscilador Colpitts

El oscilador Colpitts es un tipo popular de oscilador LC inventado por Edwin Colpitts en 1918. La figura que se ve a continuación muestra un oscilador Colpitts típico basado en un BJT con un circuito tanque, en el cual un inductor L está conectado en paralelo a la combinación en serie de condensadores C1 y C2. La frecuencia del oscilador Colpitts depende de los componentes de su circuito tanque, y se puede calcular mediante una fórmula simple (ver figura). Por ejemplo: si L = 27 uH, C1 = 1 nF y C2 = 15 nF, entonces F = 1 MHz. Tenga en cuenta que el oscilador Colpitts se puede sintonizar variando la inductancia o la capacitancia.

Diagrama de un oscilador Colpitts

En mi opinión, el sensor de microondas RCWL-0516 es una poderosa alternativa al sensor PIR común, pero este modelo tiene una documentación muy limitada (escasa), lo que lo convierte en un problema para los principiantes. Además de leer el material «chino» encontrado, también se han hecho algunas investigaciones para agregar alguna información para que alguien pueda usarla rápidamente. Mientras que, por el momento, no se ve otro uso para este módulo de sensor aparte de su aplicación de detección de movimiento, se puede adaptar fácilmente para agregar o modificar funciones. Una de ella sería una discriminación más detallada de las trayectorias de objetos que se alejan o se acercan. Debido a sus características de emisión de RF, no se deben colocar sensores a menos de 1 metro uno de otro, pero con dos sensores colocados a la distancia correcta sería posible, también, conocer si el objeto en movimiento lo hace de derecha a izquierda o a la inversa, de izquierda a derecha. Combinando ambas detecciones, es decir, aproximación y alejamiento, y desplazamiento en sentido horizontal respecto a los sensores, sería posible saber detalles de cómo se está desplazando el objeto detectado en el área monitoreada.

[Varias partes de este artículo están basadas en la recopilación de Joe Desbonnet y otros colaboradores mencionados en ésta en GitHub bajo licencia Creative Commons y autorización expresa del autor]

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

Robots Didácticos

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

Archivo del Autor: ecarletti

Arduino: Motor paso a paso 28BYJ-48 y módulo ULN2003

Arduino: bibliotecas de funciones personales

RCWL-0516: Módulo sensor de movimiento de microondas con radar Doppler

Uso de la placa L298N para motores de CC

Arduino: Comunicación inalámbrica con NRF24L01