TX Technical Specifications: |
- Working voltage: 3V~12V
- Working current: max=40mA (12V), min=9mA(3V)
- Resonance mode: sound wave resonance (SAW)
- Modulation mode: ASK /OOK
- Working frequency: 315MHz-433.92MHz, customized frequency is available.
- Transmission power: 25mW (315MHz at 12V)
- Frequency error: +150kHz (max)
- Velocity: =10Kbps
- Self-owned codes: negative
- - Distancia: 20-200 metros (diferente tensión, diferentes resultados)
- Voltaje: 3.5-12 V
- Transferencia: 4kb/s
- Potencia de transmisión: 10 mW
- Antena externa: 25 cm ordinaria MULTI-CORE-
|
RX Technical Specifications: |
- Working voltage: 5.0VDC +0.5V
- Working current:=5.5mA (5.0VDC)
- Working principle: single chip superregeneration receiving
- Working method: OOK/ASK
- Working frequency: 315MHz-433.92MHz, customized frequency is available.
- Bandwidth: 2MHz (315MHz, having result from testing at lowing the sensitivity 3dBm)
- Sensitivity: excel -100dBm (50O)
- Transmitting velocity: <9.6Kbps (at 315MHz and -95dBm)
- - Voltaje: DC5V
- Intensidad: 4mA
- Sensibilidad del receptor:-105 dB
- Antena externa: 32 cm alambre de un solo núcleo, enrollado en una espiral
|
|
Dependiendo de la alimentación obtendremos unos valores distintos.
Se le puede acoplar una antena para trabajar con mayores distancias. |
Antena |
_______________________
- Modulación por ASK y OOK
Funciona con modulación digital OOK (Modulación por Desplazamiento de Amplitud), es decir, cuando transmite un "1" envía una portadora de 433 MHz y cuando transmite un "0", no envía portadora.
- Modulación ASK
- Modulacion OOK.
_____________________________________
- Librería.
Bajamos esta librería: VirtualWire.zip (IDE 1.0.6 archivos .ino)
La descomprimimos y copiamos la carpeta VirtualWire en la subcarpeta libraries del IDE de Arduino.
- Si tienes una versión más moderna del IDE de Arduino, puedes utilizar la librería RadioHead.zip.
- Con esta librería debes utilizar el terminal 12 para el emisor y el 11 para el receptor.
https://lastminuteengineers.com/433mhz-rf-wireless-arduino-tutorial/
_____________________________________
- IDE Arduino.
Copia y pega los archivos de códigos que verás más abajo, con extensión .ine, los compilas y los cargas.
En caso que no funcionen porque la librería es incompatible con el IDE que tienes, bajas a tu ordenador el IDE 0022 para Window de https://www.arduino.cc/en/Main/OldSoftwareReleases. Instala la librería VirtualWire.zip en su carpeta libraries. Copias los archivos de códigos que verás más abajo, con extensión .pde.
../Arduino/libraries/VirtualWire
____________________________________
- Conexionado.
Conexión del Transmisor.
Vcc ------- 5 V
GND ---- GND
ATAD --- PIN 12
|
Conexión del Receptor
Vcc ------------------- 5 V
GND ----------------- GND
Datos izquierda --- PIN 11
|
____________________________________
- Códigos.
Código del Transmisor |
#include <VirtualWire.h>
const int pin_de_transmision = 12;
void setup()
{
// Inicializa IO y ISR
vw_set_tx_pin(pin_de_transmision);
vw_setup(2000); // Bits por segundo
}
byte count = 1;
void loop()
{
char msg[7] = {'J','U','A','N','#',' '};
msg[6] = count;// Hace que al final salga el número de envío
vw_send((uint8_t *)msg, 7); // Send: Aquí envía 7 elementos.
vw_wait_tx(); // Espera que termine el mensaje
delay(1000); // Envía cada 1000 ms. Si ponemos 100 enviará rápido
count = count + 1;
} |
Código del Receptor |
#include <VirtualWire.h>
const int pin_de_recepcion = 11;
void setup()
{
delay(1000);
Serial.begin(9600); // Poner el Monitor Serial en 9600
Serial.println("Recepcion");
// Inicializa IO y ISR
vw_set_rx_pin(pin_de_recepcion);
vw_setup(2000); // Bits por segundo
vw_rx_start(); // Comienzo de recepción
}
void loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen)) // Non-blocking
{
int i;
// Mensaje en el Monitor Serial
Serial.print("Recibi: ");
for (i = 0; i < buflen; i++)
{
Serial.print(buf[i], HEX);
// Serial.print((char)buf[i]); // Muestra los caracteres.
Serial.print(' ');
}
Serial.println();
}
} |
____________________________________
- Obtención de información.
En el receptor, consultamos el Serial Port COM23 (en mi caso) y veremos la información recibida.
Obtendremos el código HEXADECIMAL de los caracteres enviados.
Los primeros son los caracteres JUAN (4A 55 41 4E), el siguiente el carácter # (23), el siguente el espacio (20) y el último el número de recepción.
Para visualizar debemos poner el Monitor Serial en 9600 baud.
____________________________________
- Comentarios.
- Tanto en el Transmisor como en el Receptor he puesto un LED que parpadeará cuando emita o reciba, estos LED no son necesarios, puedes copiar y pegar los códigos del transmisor y receptor tal como lo he publicado sin necesidad de esos LED.
- Puedes probar el transmisor y el receptor en el mismo ordenador, necesitará un cable USB para uno y otro. Además cuando trabajes con uno u otro deberás cambiar el puerto de conexión.
En mi caso utilizo el COM4 para el transmisor y el COM23 para el receptor, debo cambiar de uno a otro cuando trabajo con el código del transmisor o receptor.
- Para ver la información que estoy recibiendo, entro en el receptor, establezco el Serial Port COM23, y luego entro en el Serial Monitor.
- En cualquier momento podemos enviar un nuevo caracter y el receptor lo recibirá, ponemos establecer que según el caracter recibido el receptor realice una acción; encender cierto LED, mostrar cierta información, ejecutar cierto código,...
- Una vez cargado los códigos en el Arduino emisor y en el receptor, podemos quitarle el cable USB e independizarlo del ordenador. Lo alimentaremos con pila de 9 V.
- Como habrás visto en el código, la información se envía troceando la cadena en caracteres individuales, es decir si se quiere transmitir "Juan", se debe transmitir 'J', 'u', 'a', y 'n' individualmente, caracter a caracter.
- Al trabajar con char array, el primer elemento es el cero: msg[0]= 'J' msg[1]='u' msg[2]='a' msg[3]='n'
- En el ejemplo anterior, el char tendría 4 elementos, se declararía msg[4]
_______________________________________
- Modificación del Código del Receptor.
Aquí pongo una modificación del Código del Receptor. En este caso salen las letras y cuando llega la letra J, emite un mensaje.
Saldrá algo así...
Recibi: Jjota U A N # 23
Código del Receptor 2 |
#include <VirtualWire.h>
const int pin_de_recepcion = 11;
String letra;
void setup()
{
delay(1000);
Serial.begin(9600); // Poner el Monitor Serial en 9600
Serial.println("Recepcion");
// Inicializa IO y ISR
vw_set_rx_pin(pin_de_recepcion);
vw_setup(2000); // Bits por segundo
vw_rx_start(); // Comienzo de recepción
}
void loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen)) // Non-blocking
{
int i;
// Mensaje en el Monitor Serial
Serial.print("Recibi: ");
for (i = 0; i < buflen; i++)
{
// Serial.print(buf[i],HEX); // Sale Hexadecimal
Serial.print(' ');
Serial.print((char) buf[i]); // Salen los caracteres
letra = buf[i];
if (letra == "J") { Serial.print("jota");}
}
Serial.println();
}
} |
____________________________________
- Para qué sirve esto
- Puedes poner en el transmisor 8 botones, por ejemplo, cada uno enviará un carácter. El receptor recibirá ese carácter y según cual sea ejecutará una acción, por ejemplo mover el motor de un vehículo.
____________________________________
1.- Propuesta 1.
- Supongamos que tienes 2 motores de continua. Realiza un proyecto con dos Arduinos y los módulos transmisor y receptor de RF. El Arduino emisor tendrá 2 pulsadores, según el pulsador activado entrará en funcionamiento un motor del Arduino receptor.
- Si no dispones de motores, utiliza 2 LED.
- Solución:
- En el Emisor tenemos dos pulsadores. Según los pulsemos se enviará al Receptor: 01, 10, 11 o 00.
- El Receptor tomará la información recibida. Según se reciba se encenderá un LED, otro LED, los dos o ninguno.
- TRANSMISOR
|
- RECEPTOR
 |
- TRANSMISOR
Código del Transmisor |
// Juan Antonio Villalpando
// juana1991@yahoo.com
// kio4.com
#include <VirtualWire.h>
#define pulsadorA 2
#define pulsadorB 3
int valorA, valorB;
char A, B;
const int pin_de_transmision = 12;
void setup()
{
// Inicializa IO y ISR
vw_set_tx_pin(pin_de_transmision);
vw_setup(2000); // Bits por segundo
pinMode(pulsadorA, INPUT);
pinMode(pulsadorB, INPUT);
Serial.begin(9600);
}
void loop()
{
valorA = digitalRead(pulsadorA);
valorB = digitalRead(pulsadorB);
if (valorA == HIGH) {
A='0';
} else {
A='1';
}
if (valorB == HIGH) {
B='0';
} else {
B='1';
}
char msg[2] = {A, B};
Serial.println(msg);
vw_send((uint8_t *)msg, 2); // Send: Envía 2 elementos.
vw_wait_tx(); // Espera que termine el mensaje
delay(200);
}
|
|
Código del Receptor |
// Juan Antonio Villalpando
// juana1991@yahoo.com
// kio4.com
#include <VirtualWire.h>
#define LED5 5 // Conectar en terminales con ~
#define LED6 6 // Conectar en terminales con ~
const int pin_de_recepcion = 11;
void setup()
{
pinMode(LED5, OUTPUT);
pinMode(LED6, OUTPUT);
Serial.begin(9600); // Poner el Monitor Serial en 9600
Serial.println("Recepcion");
// Inicializa IO y ISR
vw_set_rx_pin(pin_de_recepcion);
vw_setup(2000); // Bits por segundo
vw_rx_start(); // Comienzo de recepción
}
void loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen))
{
int i;
// Mensaje en el Monitor Serial
Serial.print("Recibi: ");
for (i = 0; i < buflen; i++)
{
Serial.print((char) buf[i]); // Salen los caracteres
Serial.print(' ');
}
Serial.println();
//////////////// Los LED
// LED5
if(buf[0] == '1'){
analogWrite(LED5,HIGH);
} else {
analogWrite(LED5,LOW);
}
// LED6
if(buf[1] == '1'){
analogWrite(LED6,HIGH);
} else {
analogWrite(LED6,LOW);
}
}
}
|
|
________________
- Comentarios.
- Se puede visualizar tanto la emisión como la recepción en el Serial Monitor.
- Es conveniente que la salida a los LED sean de terminales con PWM.
- Respetar los número de terminales puestos en el ejemplo.
____________________________________
2.- Propuesta 2.
- Poner un potenciómetro en el Emisor y enviar el valor del potenciómetro al Receptor. Según el valor recibido un LED3 encenderá más o menos.
Solución:
- Ampliamos el proyecto anterior. Ponemos un potenciómetro con su cursor en el ANALOG IN A2
- Obtenemos su valor y hacemos que siempre tenga 4 caracteres.
str = "0000" + String(valorpotenciometro); // Pasa el entero a String
str = str.substring(str.length()-4); // Siempre 4 caracteres
- Su valor lo troceamos en caracteres por ejemplo: 0546
- Enviamos los pulsadores A y B y el valor del potenciómetro, por ejemplo: 110546
- El receptor recibe el char array 110546, las dos primeras cifra apagarán o encenderán los LED5 y LED6.
- Las 4 últimas se mapearán a 255 y atacarán a la salida PWM 3, que a su vez hará que un LED3 encienda más o menos, según el número recibido.
- Consulta qué es mapear y qué es PWM.
- TRANSMISOR
|
- RECEPTOR
 |
Código del Transmisor |
// Juan Antonio Villalpando
// juana1991@yahoo.com
// kio4.com
#include <VirtualWire.h>
#define pulsadorA 2
#define pulsadorB 3
#define potenciometro A2
int valorA, valorB;
char A, B;
int valorpotenciometro;
const int pin_de_transmision = 12;
void setup()
{
// Inicializa IO y ISR
vw_set_tx_pin(pin_de_transmision);
vw_setup(2000); // Bits por segundo
pinMode(pulsadorA, INPUT);
pinMode(pulsadorB, INPUT);
Serial.begin(9600);
}
void loop()
{
valorA = digitalRead(pulsadorA);
valorB = digitalRead(pulsadorB);
valorpotenciometro = analogRead(potenciometro);
// A y B son los valores de los botones.
if (valorA == HIGH) {
A='0';
} else {
A='1';
}
if (valorB == HIGH) {
B='0';
} else {
B='1';
}
// str es el valor del potenciómetro con 4 caracteres.
String str="";
str = "0000" + String(valorpotenciometro); // Pasa el entero a String
str = str.substring(str.length()-4); // Siempre 4 caracteres
char msg[6] = {A, B, str[0], str[1],str[2], str[3]};
vw_send((uint8_t *)msg, 6); // Send: Aquí envía 6 elementos.
// Si está A y B en alto y el potenciómetro en 546, enviará:
// 1 1 0 5 4 6
vw_wait_tx(); // Espera que termine el mensaje
delay(200);
}
|
Código del Receptor |
// Juan Antonio Villalpando
// juana1991@yahoo.com
// kio4.com
#include <VirtualWire.h>
// Es importante utilizar estos números de terminales.
#define LED5 5 // Conectar en terminales con ~
#define LED6 6 // Conectar en terminales con ~
#define LED3 3 // LED controlado por potenciómetro
int valorpotenciometro;
const int pin_de_recepcion = 11;
int DutyCycle;
void setup()
{
pinMode(LED5, OUTPUT);
pinMode(LED6, OUTPUT);
pinMode(LED3, OUTPUT);
Serial.begin(9600); // Poner el Monitor Serial en 9600
Serial.println("Recepcion");
// Inicializa
vw_set_rx_pin(pin_de_recepcion);
vw_setup(2000); // Bits por segundo
vw_rx_start(); // Comienzo de recepción
}
void loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen))
{
int i;
// Mensaje en el Monitor Serial
for (i = 0; i < buflen; i++)
{
Serial.print((char) buf[i]); // Salen los 6 caracteres
Serial.print(' ');
}
Serial.println();
//////////////// Los LED
// LED5
if(buf[0] == '1'){
analogWrite(LED5,HIGH);
} else {
analogWrite(LED5,LOW);
}
// LED6
if(buf[1] == '1'){
analogWrite(LED6,HIGH);
} else {
analogWrite(LED6,LOW);
}
// Obtiene el valor del potenciómetro
int a, b, c, d;
a = 1000 * (buf[2] - 48);
b = 100 * (buf[3] - 48);
c = 10 * (buf[4] - 48);
d = 1 * (buf[5] - 48);
valorpotenciometro = a + b + c + d;
Serial.print("Valor potenciometro = "); Serial.print(valorpotenciometro);
Serial.println();
// Lo mapea a 255 para trabajar con PWM
DutyCycle = map(valorpotenciometro, 0, 1023, 0, 255); // Cambiamos los 1024 valores a 256.
delay(100);
Serial.print("Duty Cycle = "); Serial.print(DutyCycle);
Serial.println();
analogWrite(LED3, DutyCycle); // Enviamos a LED3 un Duty Cycle del 0 al 255.
}
}
|
_________________________________
- Otro ejemplo con el detector de humedad DHT11, obtenido de...
http://www.geeetech.com/wiki/index.php/Wireless_temperature_and_humidity_sensor_with_RF_modules
Relating code(transmitter)):
#include "DHT.h"
#define DHTPIN 2
#define DHTTYPE DHT11 // DHT 11
DHT dht(DHTPIN, DHTTYPE);
#include
#undef int
#undef abs
#undef double
#undef float
#undef round
char charnum[10];
void setup() {
Serial.begin(9600);
Serial.println("setup");
dht.begin();
// Initialise the IO and ISR
vw_set_ptt_inverted(true); // Required for DR3100
vw_setup(2000); // Bits per sec
}
void loop() {
int humidity = dht.readHumidity();
int temp = dht.readTemperature();
// check if returns are valid, if they are NaN (not a number) then something went wrong!
if (isnan(humidity) || isnan(temp)) {
Serial.println("Failed to read from DHT");
}
else {
char buff[30];
sprintf(buff,"%c",255);
const char *msg0 = buff;
vw_send((uint8_t *)msg0, strlen(msg0)); // Send control character
vw_wait_tx(); // Wait until the whole message is gone
sprintf(buff,"%d",temp);
const char *msg1 = buff;
vw_send((uint8_t *)msg1, strlen(msg1)); // Send control character
vw_wait_tx(); // Wait until the whole message is gone
sprintf(buff,"%cC ",223);
const char *msg2 = buff;
vw_send((uint8_t *)msg2, strlen(msg2));
vw_wait_tx(); // Wait until the whole message is gone
sprintf(buff,"%c",254);
const char *msg3 = buff;
vw_send((uint8_t *)msg3, strlen(msg3));
vw_wait_tx();
sprintf(buff,"%d",humidity);
const char *msg4 = buff;
vw_send((uint8_t *)msg4, strlen(msg4)); // Send control character
vw_wait_tx(); // Wait until the whole message is gone
const char *msg5 = "% ";
vw_send((uint8_t *)msg5, strlen(msg5));
vw_wait_tx(); // Wait until the whole message is gone
delay(1000);
}
}
Receiver:
#include
LCD4Bit_mod lcd = LCD4Bit_mod(2);
#include
#undef int
#undef abs
#undef double
#undef float
#undef round
void setup()
{
lcd.init();
Serial.begin(9600); // Debugging only
Serial.println("setup");
// Initialise the IO and ISR
vw_set_ptt_inverted(true); // Required for DR3100
vw_setup(2000); // Bits per sec
vw_set_rx_pin(23);
vw_rx_start(); // Start the receiver PLL running
}
void loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen)) // Non-blocking
{ int i;
digitalWrite(13, true); // Flash a light to show received good message
Serial.print("Got: ");
// Message with a good checksum received, dump it.
for (i = 0; i < buflen; i++) {
if (buf[i]==255){ lcd.cursorTo(1,0);
}
lcd.print(buf[i]);
}
}
}
