¿Qué es un módulo de comunicación inalámbrica de largo alcance y cómo puede utilizarlo en sus proyectos con Arduino? En este artículo, exploraremos las capacidades del módulo HC-12 y cómo puede integrarse con la plataforma Arduino para establecer comunicación a larga distancia. ¡Descubra todo lo que necesita saber sobre esta potente herramienta de comunicación inalámbrica!
En este tutorial de Arduino, aprenderá a utilizar el módulo de comunicación serie inalámbrico HC-12, que permite la comunicación inalámbrica de larga distancia entre múltiples placas Arduino a distancias de hasta 1,8 km. Para obtener más detalles, puede ver el siguiente vídeo o leer el tutorial escrito a continuación.
descripción general
Para este tutorial, creé dos ejemplos básicos que explican cómo conectar el módulo HC-12 y establecer una comunicación básica entre dos Arduinos, y un ejemplo adicional donde uso un acelerómetro en el primer Arduino para determinar la posición del paso a paso en el segundo. Controla Arduino de forma inalámbrica.
Módulo de comunicación inalámbrica HC-12
Primero, echemos un vistazo más de cerca al módulo de comunicación serie inalámbrico HC-12. Aquí hay algunas especificaciones:
- Su banda de frecuencia de trabajo inalámbrica va desde 433,4 MHz hasta 473,0 MHz
- Tiene un total de 100 canales con una gradación de 400 kHz entre cada canal
- La potencia de transmisión oscila entre -1 dBm (0,79 mW) y 20 dBm (100 mW).
- La sensibilidad de recepción está entre -117 dBm (0,019 pW) y -100 dBm (10 pW).
Estos valores en realidad dependen de la velocidad en baudios serial y inalámbrica seleccionada, como se muestra en la tabla.
El>
Arduino y HC-12
Ahora conectemos el módulo HC-12 al Arduino y hagamos el primer ejemplo. Aquí está el diagrama del circuito. El voltaje de funcionamiento del módulo es de 3,2 V a 5,5 V y se recomienda utilizar un condensador de desacoplamiento y una fuente de alimentación externa para un funcionamiento más estable. Sin embargo, para los tres ejemplos de este tutorial, utilicé el puerto USB de la PC como fuente de energía y no tuve problemas con él.
Conecté>
Puede obtener los componentes necesarios para este tutorial de Arduino en los siguientes enlaces:
- Módulo de comunicación inalámbrica HC-12……….. Amazon / Banggood / AliExpress
- Placa Arduino…………………………………………………… Amazon / Banggood / AliExpress
- Cables de puente y placa de pruebas………………………… Amazon / Banggood / AliExpress
Divulgación: estos son enlaces de afiliados. Como asociado de Amazon, gano con compras que califican.
Ejemplo 01 – Código Arduino
Aquí está el código Arduino para el primer ejemplo, comunicación básica entre los dos módulos mediante el monitor serie.
/* Arduino Long Range Wireless Communication using HC-12
Example 01
by Dejan Nedelkovski, www.HowToMechatronics.com
*/
#include <SoftwareSerial.h>
SoftwareSerial HC12(10, 11); // HC-12 TX Pin, HC-12 RX Pin
void setup() {
Serial.begin(9600); // Serial port to computer
HC12.begin(9600); // Serial port to HC12
}
void loop() {
while (HC12.available()) { // If HC-12 has data
Serial.write(HC12.read()); // Send the data to Serial monitor
}
while (Serial.available()) { // If Serial monitor has data
HC12.write(Serial.read()); // Send that data to HC-12
}
}Code language: Arduino (arduino)
Se utiliza el mismo código para ambos Arduinos. Podemos conectar los dos Arduino en dos ordenadores separados, pero también podemos usar un solo ordenador.
En>
Entonces, una vez que tengamos los dos IDE de Arduino en ejecución, podemos iniciar los monitores en serie y probar si la comunicación funciona correctamente. Todo lo que ingresamos en el monitor serie se envía de un Arduino a otro.
Así> Entonces tan pronto como escribimos algo en el monitor serial y hacemos clic en el botón enviar, en el primer Arduino el bucle while con la función “Serial.available()” se vuelve verdadero y con la función “HC12.write()” enviamos los datos del monitor serial al módulo HC-12. Este módulo transmite los datos de forma inalámbrica al segundo módulo HC-12, por lo que en el segundo Arduino el bucle while con la función HC12.available() se vuelve verdadero y los datos se envían al módulo con la función Serial.write() Serial Monitor .
Podemos usar el mismo código para enviar comandos AT y configurar los parámetros del módulo. Todo lo que tenemos que hacer es conectar el pin «Set» del módulo a tierra o cualquier pin digital del Arduino y configurar el pin a un nivel lógico bajo.
Para>
Comandos AT:
1. AT – comando de prueba.
Ejemplo: envíe «AT» al módulo y el módulo devuelve «OK».
2. AT+Bxxxx: cambia la velocidad en baudios del puerto serie.
Velocidades de baudios disponibles: 1200 bps, 2400 bps, 4800 bps, 9600 bps, 19200 bps, 38400 bps, 57600 bps y 115200 bps. Valor predeterminado: 9600 bps.
Ejemplo: envíe «AT+B38400» al módulo y el módulo devuelve «OK+B19200».
3. AT+Cxxxx: cambia el canal de comunicación inalámbrica, de 001 a 100.
Estándar: Canal 001, con una frecuencia de operación de 433,4 MHz. Cada canal siguiente es 400 kHz más alto.
Ejemplo: Si queremos configurar el módulo en el canal 006, debemos enviar el comando «AT+C006» al módulo y el módulo devolverá «OK+C006». La nueva frecuencia de trabajo es 435,4 MHz.
Ejemplo 02
Ahora pasemos al segundo ejemplo. Aquí utilizamos dos botones para seleccionar diferentes canales de comunicación y ver otro método para almacenar los datos entrantes.
Nota:>
Primer código Arduino:
/* Arduino Long Range Wireless Communication using HC-12
Example 02 - Changing channels using push buttons - Buttons side
by Dejan Nedelkovski, www.HowToMechatronics.com
*/
#include <SoftwareSerial.h>
#define setPin 6
#define button1 4
#define button2 3
SoftwareSerial HC12(10, 11); // HC-12 TX Pin, HC-12 RX Pin
byte incomingByte;
String readBuffer = "";
int button1State = 0;
int button1Pressed = 0;
int button2State = 0;
int button2Pressed = 0;
void setup() {
Serial.begin(9600); // Open serial port to computer
HC12.begin(9600); // Open serial port to HC12
pinMode(setPin, OUTPUT);
pinMode(button1, INPUT);
pinMode(button2, INPUT);
digitalWrite(setPin, HIGH); // HC-12 normal, transparent mode
}
void loop() {
// ==== Storing the incoming data into a String variable
while (HC12.available()) { // If HC-12 has data
incomingByte = HC12.read(); // Store each icoming byte from HC-12
readBuffer += char(incomingByte); // Add each byte to ReadBuffer string variable
}
delay(100);
// ==== Sending data from one HC-12 to another via the Serial Monitor
while (Serial.available()) {
HC12.write(Serial.read());
}
// ==== If button 1 is pressed, set the channel 01
button1State = digitalRead(button1);
if (button1State == HIGH & button1Pressed == LOW) {
button1Pressed = HIGH;
delay(20);
}
if (button1Pressed == HIGH) {
HC12.print("AT+C001"); // Send the AT Command to the other module
delay(100);
//Set AT Command Mode
digitalWrite(setPin, LOW); // Set HC-12 into AT Command mode
delay(100); // Wait for the HC-12 to enter AT Command mode
HC12.print("AT+C001"); // Send AT Command to HC-12
delay(200);
while (HC12.available()) { // If HC-12 has data (the AT Command response)
Serial.write(HC12.read()); // Send the data to Serial monitor
}
Serial.println("Channel successfully changed");
digitalWrite(setPin, HIGH); // Exit AT Command mode
button1Pressed = LOW;
}
// ==== If button 2 is pressed, set the channel 02
button2State = digitalRead(button2);
if (button2State == HIGH & button2Pressed == LOW) {
button2Pressed = HIGH;
delay(100);
}
if (button2Pressed == HIGH) {
HC12.print("AT+C002"); // Send the AT Command to the other module
delay(100);
//Set AT Command Mode
digitalWrite(setPin, LOW); // Set HC-12 into AT Command mode
delay(100); // Wait for the HC-12 to enter AT Command mode
HC12.print("AT+C002"); // Send AT Command to HC-12
delay(200);
while (HC12.available()) { // If HC-12 has data (the AT Command response)
Serial.write(HC12.read()); // Send the data to Serial monitor
}
Serial.println("Channel successfully changed");
digitalWrite(setPin, HIGH);
button2Pressed = LOW;
}
checkATCommand();
readBuffer = ""; // Clear readBuffer
}
// ==== Custom function - Check whether we have received an AT Command via the Serial Monitor
void checkATCommand () {
if (readBuffer.startsWith("AT")) { // Check whether the String starts with "AT"
digitalWrite(setPin, LOW); // Set HC-12 into AT Command mode
delay(200); // Wait for the HC-12 to enter AT Command mode
HC12.print(readBuffer); // Send AT Command to HC-12
delay(200);
while (HC12.available()) { // If HC-12 has data (the AT Command response)
Serial.write(HC12.read()); // Send the data to Serial monitor
}
digitalWrite(setPin, HIGH); // Exit AT Command mode
}
}Code language: Arduino (arduino)Segundo código Arduino:
/* Arduino Long Range Wireless Communication using HC-12
Example 02 - Changing channels using push buttons
by Dejan Nedelkovski, www.HowToMechatronics.com
*/
#include <SoftwareSerial.h>
#define setPin 6
SoftwareSerial HC12(10, 11); // HC-12 TX Pin, HC-12 RX Pin
byte incomingByte;
String readBuffer = "";
void setup() {
Serial.begin(9600); // Open serial port to computer
HC12.begin(9600); // Open serial port to HC12
pinMode(setPin, OUTPUT);
digitalWrite(setPin, HIGH); // HC-12 normal mode
}
void loop() {
// ==== Storing the incoming data into a String variable
while (HC12.available()) { // If HC-12 has data
incomingByte = HC12.read(); // Store each icoming byte from HC-12
readBuffer += char(incomingByte); // Add each byte to ReadBuffer string variable
}
delay(100);
// ==== Sending data from one HC-12 to another via the Serial Monitor
while (Serial.available()) {
HC12.write(Serial.read());
}
// === If button 1 is pressed, set channel 01
if (readBuffer == "AT+C001") {
digitalWrite(setPin, LOW); // Set HC-12 into AT Command mode
delay(100); // Wait for the HC-12 to enter AT Command mode
HC12.print(readBuffer); // Send AT Command to HC-12 ("AT+C001")
delay(200);
while (HC12.available()) { // If HC-12 has data (the AT Command response)
Serial.write(HC12.read()); // Send the data to Serial monitor
}
Serial.println("Channel successfully changed");
digitalWrite(setPin, HIGH); // Exit AT Command mode
readBuffer = "";
}
// === If button 2 is pressed, set channel 02
if (readBuffer == "AT+C002") {
digitalWrite(setPin, LOW); // Set HC-12 into AT Command mode
delay(100); // Wait for the HC-12 to enter AT Command mode
HC12.print(readBuffer); // Send AT Command to HC-12
delay(200);
while (HC12.available()) { // If HC-12 has data (the AT Command response)
Serial.write(HC12.read()); // Send the data to Serial monitor
}
Serial.println("Channel successfully changed");
digitalWrite(setPin, HIGH); // Exit AT Command mode
readBuffer = "";
}
checkATCommand();
readBuffer = ""; // Clear readBuffer
}
// ==== Custom function - Check whether we have received an AT Command via the Serial Monitor
void checkATCommand () {
if (readBuffer.startsWith("AT")) { // Check whether the String starts with "AT"
digitalWrite(setPin, LOW); // Set HC-12 into AT Command mode
delay(100); // Wait for the HC-12 to enter AT Command mode
HC12.print(readBuffer); // Send AT Command to HC-12
delay(200);
while (HC12.available()) { // If HC-12 has data (the AT Command response)
Serial.write(HC12.read()); // Send the data to Serial monitor
}
digitalWrite(setPin, HIGH); // Exit AT Command mode
}
}Code language: Arduino (arduino)Descripción de códigos:
Entonces, primero debemos definir los pines y configurar el pin «Establecer» en un nivel lógico alto para que el módulo funcione en modo normal y transparente. Con el primer bucle while, almacenamos los datos entrantes en una variable de cadena para poder procesarlos mejor.
// ==== Storing the incoming data into a String variable
while (HC12.available()) { // If HC-12 has data
incomingByte = HC12.read(); // Store each icoming byte from HC-12
readBuffer += char(incomingByte); // Add each byte to ReadBuffer string variable
}Code language: Arduino (arduino)Los datos entrantes siempre llegan byte a byte. Entonces, por ejemplo, si enviamos la cadena «Test123» desde el segundo Arduino, este bucle while realizará siete iteraciones. En cada iteración, usamos la función HC12.read() para leer cada byte o carácter entrante y agregarlo a la variable de cadena llamada readBuffer.
A>
if (button1Pressed == HIGH) {
HC12.print("AT+C001"); // Send the AT Command to the other module
delay(100);
//Set AT Command Mode
digitalWrite(setPin, LOW); // Set HC-12 into AT Command mode
delay(100); // Wait for the HC-12 to enter AT Command mode
HC12.print("AT+C001"); // Send AT Command to HC-12
delay(200);
while (HC12.available()) { // If HC-12 has data (the AT Command response)
Serial.write(HC12.read()); // Send the data to Serial monitor
}
Serial.println("Channel successfully changed");
digitalWrite(setPin, HIGH); // Exit AT Command mode
button1Pressed = LOW;
}Code language: Arduino (arduino)Cuando se recibe esta cadena en el segundo Arduino, ponemos el módulo HC-12 en modo de comando AT y luego escribimos la misma cadena «AT+C001» en él, configurando el módulo en el canal de comunicación número uno.
// At the second Arduino
// === If button 1 is pressed, set channel 01
if (readBuffer == "AT+C001") {
digitalWrite(setPin, LOW); // Set HC-12 into AT Command mode
delay(100); // Wait for the HC-12 to enter AT Command mode
HC12.print(readBuffer); // Send AT Command to HC-12 ("AT+C001")
delay(200);
while (HC12.available()) { // If HC-12 has data (the AT Command response)
Serial.write(HC12.read()); // Send the data to Serial monitor
}
Serial.println("Channel successfully changed");
digitalWrite(setPin, HIGH); // Exit AT Command mode
readBuffer = "";
}Code language: Arduino (arduino)Usamos el siguiente bucle while para generar el mensaje de respuesta del módulo HC-12 si el canal se ha cambiado correctamente.
while (HC12.available()) { // If HC-12 has data (the AT Command response)
Serial.write(HC12.read()); // Send the data to Serial monitor
}Code language: Arduino (arduino)De vuelta en el primer Arduino, realizamos el mismo proceso y enviamos el comando AT al primer módulo HC-12. De la misma forma, pulsando el segundo botón configuramos el canal de comunicación número dos. Así que con este método podremos elegir con qué módulo HC-12 queremos comunicarnos en cada momento.
Al final, la función personalizada checkATCommand() comprueba si el mensaje recibido es un comando AT comprobando si la cadena comienza con «AT». En caso afirmativo, el módulo ingresa al modo de comando AT y ejecuta el comando.
// ==== Custom function - Check whether we have received an AT Command via the Serial Monitor
void checkATCommand () {
if (readBuffer.startsWith("AT")) { // Check whether the String starts with "AT"
digitalWrite(setPin, LOW); // Set HC-12 into AT Command mode
delay(200); // Wait for the HC-12 to enter AT Command mode
HC12.print(readBuffer); // Send AT Command to HC-12
delay(200);
while (HC12.available()) { // If HC-12 has data (the AT Command response)
Serial.write(HC12.read()); // Send the data to Serial monitor
}
digitalWrite(setPin, HIGH); // Exit AT Command mode
}
}Code language: Arduino (arduino)Comunicación inalámbrica HC-12: control de motor paso a paso mediante acelerómetro
Ahora veamos el tercer ejemplo. Aquí controlamos la posición del motor paso a paso en el segundo Arduino usando el módulo de acelerómetro en el primer Arduino.
El>
Puede>
- Módulo de comunicación inalámbrica HC-12 ………… Amazon / Banggood / AliExpress
- Controlador de motor paso a paso A4988………………………….. Amazon / Banggood / AliExpress
- Motor paso a paso NEMA 17 ………………………………… Amazon / Banggood / AliExpress
- Placa Arduino…………………………………………………….. Amazon / Banggood / AliExpress
- Cables de puente y placa de pruebas………………………….. Amazon / Banggood / AliExpress
- Placa GY-80 con acelerómetro ADXL345……… Amazon/AliExpress
Divulgación: estos son enlaces de afiliados. Como asociado de Amazon, gano con compras que califican.
Tenga en cuenta aquí que ya tengo tutoriales detallados sobre cómo conectar y utilizar tanto el acelerómetro como el motor paso a paso. Por lo tanto, en este ejemplo solo explicaré la parte HC-12 del código.
Primer Arduino – código del transmisor:
/* Arduino Long Range Wireless Communication using HC-12
Example 03 - Stepper Motor Control using Accelerometer - Transmitter, Accelerometer
by Dejan Nedelkovski, www.HowToMechatronics.com
*/
#include <SoftwareSerial.h>
#include <Wire.h>
SoftwareSerial HC12(10, 11); // HC-12 TX Pin, HC-12 RX Pin
float angle;
int lastAngle = 0;
int count = 0;
int angleSum = 0;
//--- Accelerometer Register Addresses
#define Power_Register 0x2D
#define X_Axis_Register_DATAX0 0x32 // Hexadecima address for the DATAX0 internal register.
#define X_Axis_Register_DATAX1 0x33 // Hexadecima address for the DATAX1 internal register.
#define Y_Axis_Register_DATAY0 0x34
#define Y_Axis_Register_DATAY1 0x35
#define Z_Axis_Register_DATAZ0 0x36
#define Z_Axis_Register_DATAZ1 0x37
int ADXAddress = 0x53; //Device address in which is also included the 8th bit for selecting the mode, read in this case.
int X0, X1, X_out;
int Y0, Y1, Y_out;
int Z1, Z0, Z_out;
float Xa, Ya, Za;
void setup() {
HC12.begin(9600); // Open serial port to HC12
Wire.begin(); // Initiate the Wire library
Serial.begin(9600);
delay(100);
Wire.beginTransmission(ADXAddress);
Wire.write(Power_Register); // Power_CTL Register
// Enable measurement
Wire.write(8); // Bit D3 High for measuring enable (0000 1000)
Wire.endTransmission();
}
void loop() {
// X-axis
Wire.beginTransmission(ADXAddress); // Begin transmission to the Sensor
//Ask the particular registers for data
Wire.write(X_Axis_Register_DATAX0);
Wire.write(X_Axis_Register_DATAX1);
Wire.endTransmission(); // Ends the transmission and transmits the data from the two registers
Wire.requestFrom(ADXAddress, 2); // Request the transmitted two bytes from the two registers
if (Wire.available() <= 2) { //
X0 = Wire.read(); // Reads the data from the register
X1 = Wire.read();
/* Converting the raw data of the X-Axis into X-Axis Acceleration
- The output data is Two's complement
- X0 as the least significant byte
- X1 as the most significant byte */
X1 = X1 << 8;
X_out = X0 + X1;
Xa = X_out / 256.0; // Xa = output value from -1 to +1, Gravity acceleration acting on the X-Axis
}
//Serial.print("Xa= ");
//Serial.println(X_out);
// Y-Axis
Wire.beginTransmission(ADXAddress);
Wire.write(Y_Axis_Register_DATAY0);
Wire.write(Y_Axis_Register_DATAY1);
Wire.endTransmission();
Wire.requestFrom(ADXAddress, 2);
if (Wire.available() <= 2) {
Y0 = Wire.read();
Y1 = Wire.read();
Y1 = Y1 << 8;
Y_out = Y0 + Y1;
Ya = Y_out / 256.0;
}
// Combine X and Y values for getting the angle value from 0 to 180 degrees
if (Y_out > 0) {
angle = map(Y_out, 0, 256, 90, 0);
}
else if (Y_out < 0) {
angle = map(Y_out, 256, 0, 90, 0);
angle = 90 - angle;
}
if (X_out < 0 & Y_out < 0) {
angle = 180;
}
if (X_out < 0 & Y_out >0) {
angle = 0;
}
// float to int
int angleInt = int(angle);
// Makes 100 accelerometer readings and sends the average for smoother result
angleSum = angleSum + angleInt;
count++;
if (count >= 100) {
angleInt = angleSum / 100;
angleSum = 0;
count = 0;
// Some more smoothing of acceleromter reading - sends the new angle only if it differes from the previous one by +-2
if (angleInt > lastAngle + 2 || angleInt < lastAngle - 2) {
Serial.println(angleInt);
String angleString = String(angleInt);
//sends the angle value with start marker "s" and end marker "e"
HC12.print("s" + angleString + "e");
delay(10);
lastAngle = angleInt;
angleSum = 0;
count = 0;
}
}
}
Code language: Arduino (arduino)Segundo Arduino – código del receptor:
/* Arduino Long Range Wireless Communication using HC-12
Example 03 - Stepper Motor Control using Accelerometer - Receiver, Stepper Motor
by Dejan Nedelkovski, www.HowToMechatronics.com
*/
#include <SoftwareSerial.h>
SoftwareSerial HC12(10, 11); // HC-12 TX Pin, HC-12 RX Pin
char incomingByte;
String readBuffer = "";
// defines pins numbers
const int dirPin = 4;
const int stepPin = 3;
const int button = 2;
int currentAngle = 0;
int lastAngle = 0;
int rotate = 0;
void setup() {
Serial.begin(9600); // Open serial port to computer
HC12.begin(9600); // Open serial port to HC12
// Sets the two pins as Outputs
pinMode(dirPin, OUTPUT);
pinMode(stepPin, OUTPUT);
// Microswitch input, with internal pull-up resistor activated
pinMode(button, INPUT_PULLUP);
delay(10);
digitalWrite(dirPin, HIGH);
boolean startingPosition = true;
while (startingPosition) {
digitalWrite(stepPin, HIGH);
delayMicroseconds(200);
digitalWrite(stepPin, LOW);
delayMicroseconds(200);
if (digitalRead(button) == LOW) {
startingPosition = false;
}
}
delay(100);
}
void loop() {
readBuffer = "";
boolean start = false;
// Reads the incoming angle
while (HC12.available()) { // If HC-12 has data
incomingByte = HC12.read(); // Store each icoming byte from HC-12
delay(5);
// Reads the data between the start "s" and end marker "e"
if (start == true) {
if (incomingByte != 'e') {
readBuffer += char(incomingByte); // Add each byte to ReadBuffer string variable
}
else {
start = false;
}
}
// Checks whether the received message statrs with the start marker "s"
else if ( incomingByte == 's') {
start = true; // If true start reading the message
}
}
// Converts the string into integer
currentAngle = readBuffer.toInt();
// Makes sure it uses angles between 0 and 180
if (currentAngle > 0 && currentAngle < 180) {
// Convert angle value to steps (depending on the selected step resolution)
// A cycle = 200 steps, 180deg = 100 steps ; Resolution: Sixteenth step x16
currentAngle = map(currentAngle, 0, 180, 0, 1600);
//Serial.println(currentAngle); // Prints the angle on the serial monitor
digitalWrite(dirPin, LOW); // Enables the motor to move in a particular direction
// Rotates the motor the amount of steps that differs from the previous positon
if (currentAngle != lastAngle) {
if (currentAngle > lastAngle) {
rotate = currentAngle - lastAngle;
for (int x = 0; x < rotate; x++) {
digitalWrite(stepPin, HIGH);
delayMicroseconds(400);
digitalWrite(stepPin, LOW);
delayMicroseconds(400);
}
}
// rotate the other way
if (currentAngle < lastAngle) {
rotate = lastAngle - currentAngle;
digitalWrite(dirPin, HIGH); //Changes the rotations direction
for (int x = 0; x < rotate; x++) {
digitalWrite(stepPin, HIGH);
delayMicroseconds(400);
digitalWrite(stepPin, LOW);
delayMicroseconds(400);
}
}
}
lastAngle = currentAngle; // Remembers the current/ last positon
}
}Code language: Arduino (arduino)Descripción de códigos:
Primero definimos los pines e inicializamos los módulos en el área de configuración. Luego leemos los valores de los ejes X e Y del acelerómetro y les asignamos un valor de 0 a 180 grados. Los valores provenientes del acelerómetro a veces pueden ser inestables o fluctuar, así que utilicé el valor promedio de cien lecturas para suavizar el resultado.
// Makes 100 accelerometer readings and sends the average for smoother result
angleSum = angleSum + angleInt;
count++;
if (count >= 100) {
angleInt = angleSum / 100;
angleSum = 0;
count = 0;
// Some more smoothing of acceleromter reading - sends the new angle only if it differes from the previous one by +-2
if (angleInt > lastAngle + 2 || angleInt < lastAngle - 2) {
Serial.println(angleInt);
String angleString = String(angleInt);
//sends the angle value with start marker "s" and end marker "e"
HC12.print("s" + angleString + "e");
delay(10);
lastAngle = angleInt;
angleSum = 0;
count = 0;
}
}Code language: Arduino (arduino)Para suavizar aún más, sólo envío el nuevo valor del ángulo si difiere del anterior en 2.
Tenga en cuenta aquí que cuando envío el ángulo al módulo HC-12, también envío el carácter «s» delante y el carácter «e» después, lo que me ayuda a recibir los datos en el segundo Arduino.
En el segundo Arduino esperamos hasta que llegue el marcador de inicio “s”, luego leemos el valor del ángulo hasta que llegue el marcador de final “e”. Esto asegura que solo obtengamos el valor del ángulo.
// Reads the incoming angle
while (HC12.available()) { // If HC-12 has data
incomingByte = HC12.read(); // Store each icoming byte from HC-12
delay(5);
// Reads the data between the start "s" and end marker "e"
if (start == true) {
if (incomingByte != 'e') {
readBuffer += char(incomingByte); // Add each byte to ReadBuffer string variable
}
else {
start = false;
}
}
// Checks whether the received message statrs with the start marker "s"
else if ( incomingByte == 's') {
start = true; // If true start reading the message
}
}Code language: Arduino (arduino)Luego convertimos el valor a un número entero y asignamos el valor de 0 a 1600 pasos, que corresponde a la resolución del decimosexto paso seleccionada en el controlador paso a paso A4988. Luego giramos el motor paso a paso al ángulo actual.
Eso es todo por este tutorial de Arduino. No dude en hacer sus preguntas en la sección de comentarios a continuación.
Módulo de comunicación inalámbrica de largo alcance Arduino y HC-12
En este tutorial de Arduino, aprenderemos a utilizar el módulo de comunicación serial inalámbrica HC-12, el cual es capaz de realizar una comunicación inalámbrica de largo alcance entre múltiples placas Arduino, con distancias de hasta 1.8 km. Puedes ver el siguiente video o leer el tutorial escrito a continuación para más detalles.
Visión general
Para este tutorial, realicé dos ejemplos básicos explicando cómo conectar el módulo HC-12 y establecer una comunicación básica entre dos Arduinos, y un ejemplo adicional donde, utilizando un sensor acelerómetro en el primer Arduino, controlo de forma inalámbrica la posición del motor paso a paso en el segundo Arduino.
Módulo de comunicación inalámbrica HC-12
Primero veamos más de cerca el módulo de comunicación serial inalámbrica HC-12. Aquí están algunas especificaciones:
- Su banda de trabajo inalámbrica va desde 433.4 MHz a 473.0 MHz.
- Posee un total de 100 canales con un paso de 400 kHz entre cada canal.
- La potencia de transmisión va desde -1dBm (0.79mW) hasta 20dBm (100mW).
- La sensibilidad de recepción va desde -117dBm (0.019pW) hasta -100dBm (10pW).
Estos valores dependen del Baud Rate seleccionado, como se muestra en la tabla. El módulo HC-12 tiene un microcontrolador que en realidad no necesita ser programado por el usuario. Para configurar el módulo, simplemente utilizamos comandos AT, que pueden ser enviados desde un Arduino, una PC o cualquier otro microcontrolador utilizando el puerto serie. Para ingresar al modo de comando AT, simplemente tenemos que establecer el pin «Set» del módulo en un nivel lógico bajo.
Arduino y HC-12
Ahora conectemos el módulo HC-12 al Arduino y hagamos el primer ejemplo. Aquí está el esquema del circuito. El voltaje de operación del módulo va desde 3.2 V hasta 5.5 V. Recomiendo usar un condensador de desacoplamiento y una fuente de alimentación externa para un trabajo más estable, aunque en los ejemplos de este tutorial utilicé la alimentación USB de la PC para los tres casos sin problemas.
Conecté el primer módulo a un Arduino UNO y el segundo módulo a un Arduino MEGA, pero por supuesto, puedes utilizar cualquier placa que desees.
Preguntas frecuentes
- ¿Cómo se establece la comunicación inalámbrica entre dos placas Arduino utilizando el módulo HC-12?
- ¿Es necesario programar el microcontrolador del módulo HC-12?
- ¿Cómo se configura el módulo HC-12 utilizando comandos AT?
- ¿Cómo se puede cambiar el canal de comunicación del módulo HC-12?
- ¿Qué tipo de sensores se pueden utilizar en conjunto con el módulo HC-12 para realizar proyectos más avanzados?
Para más detalles sobre la programación y conexión de los módulos HC-12 con Arduino, te invito a revisar detenidamente los códigos y esquemas proporcionados en los ejemplos de este tutorial.
¡Vaya, qué descubrimiento! No sabía que se podía lograr esa comunicación inalámbrica tan potente con Arduino y HC-12. Definitivamente, este artículo me ha abierto los ojos a nuevas posibilidades. ¡Gracias por compartir!
¡Qué genialidad! Nunca pensé que se podría lograr una comunicación inalámbrica de largo alcance con Arduino y HC-12. Definitivamente, este artículo ha ampliado mis horizontes tecnológicos. ¡Gracias por compartir esta información tan interesante!
¡Qué interesante! Nunca me imagine que se pudiera lograr comunicación inalámbrica de largo alcance con Arduino y HC-12. Definitivamente voy a probarlo. ¡Gracias por compartir este artículo tan informativo!
¡Interesante artículo! Me encanta aprender sobre nuevas tecnologías de comunicación inalámbrica en Arduino. ¡Gracias por compartir!
¡Increíble! Nunca imaginé que se pudiera lograr comunicación inalámbrica de largo alcance con Arduino y HC-12. ¡Definitivamente, este artículo me ha sorprendido! ¡Gracias por la información!