Arduino und HC-12 Drahtloses Kommunikationsmodul mit großer Reichweite

In diesem Arduino-Tutorial lernen wir, wie man das drahtlose serielle Kommunikationsmodul HC-12 verwendet, das eine drahtlose Kommunikation mit großer Reichweite zwischen mehreren Arduino-Boards mit Entfernungen von bis zu 1,8 km herstellen kann. Sie können sich das folgende Video ansehen oder das schriftliche Tutorial unten lesen, um weitere Einzelheiten zu erfahren.

Übersicht

Für dieses Tutorial habe ich zwei grundlegende Beispiele erstellt, die erklären, wie das HC-12-Modul angeschlossen und eine grundlegende Kommunikation zwischen zwei Arduinos hergestellt wird, und ein zusätzliches Beispiel, bei dem ich mit einem Beschleunigungssensor am ersten Arduino die Position des Steppers am zweiten drahtlos steuere Arduino.

HC-12 Drahtloses Kommunikationsmodul

Lassen Sie uns zunächst einen genaueren Blick auf das HC-12 Wireless Serial Port Kommunikationsmodul werfen. Hier sind einige Spezifikationen:

Sein drahtloses Arbeitsfrequenzband reicht von 433,4 MHz bis 473,0 MHz
Es hat insgesamt 100 Kanäle mit einer Schrittweite von 400 KHz zwischen jedem Kanal
Die Sendeleistung reicht von -1 dBm (0,79 mW) bis 20 dBm (100 mW)
Die Empfangsempfindlichkeit reicht von -117 dBm (0,019 pW) bis -100 dBm (10 pW).

Diese Werte hängen tatsächlich von der ausgewählten seriellen und Over-the-Air-Baudrate ab, wie in der Tabelle zu sehen ist.

Das HC-12-Modul verfügt über einen Mikrocontroller, der eigentlich nicht vom Benutzer programmiert werden muss. Zur Konfiguration des Moduls verwenden wir einfach AT-Befehle, die von einem Arduino, einem PC oder einem anderen Mikrocontroller über die serielle Schnittstelle gesendet werden können. Um in den AT-Befehlsmodus zu gelangen, müssen wir nur den „Set“-Pin des Moduls auf einen niedrigen Logikpegel setzen.

Arduino und HC-12

Verbinden wir nun das HC-12-Modul mit dem Arduino und machen das erste Beispiel. Hier sind die Schaltpläne. Die Betriebsspannung des Moduls liegt zwischen 3,2 V und 5,5 V und für stabileres Arbeiten wird empfohlen, einen Entkopplungskondensator und eine externe Stromversorgung zu verwenden. Ich habe jedoch für alle drei Beispiele in diesem Tutorial den USB-Anschluss des PCs als Stromversorgung verwendet und hatte damit keine Probleme.

Ich habe das erste Modul mit einem Arduino UNO und das zweite Modul mit einem Arduino MEGA verbunden, aber Sie können natürlich jedes beliebige Board verwenden.

Die für dieses Arduino-Tutorial benötigten Komponenten erhalten Sie über die folgenden Links:

HC-12 Drahtloses Kommunikationsmodul ………..
Arduino-Board ………………………………………………
Steckbrett und Schaltdrähte …………………………

Beispiel 01 – Arduino-Code

Hier ist der Arduino-Code für das erste Beispiel, eine grundlegende Kommunikation zwischen den beiden Modulen mit dem Serial Monitor.

/*    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
  }
}

Codesprache:Arduino (arduino)

Für beide Arduinos wird der gleiche Code verwendet. Wir können die beiden Arduinos auf zwei separaten Computern verbinden, aber wir können auch einen einzigen Computer verwenden.

In diesem Fall müssen wir, sobald wir den ersten Arduino mit dem Computer verbinden, das Modell und den COM-Port auswählen und den Code auf den Arduino hochladen. Dann schließen wir den zweiten Arduino an und müssen die Arduino IDE erneut starten, um den anderen COM-Port auswählen zu können, an dem unser zweiter Arduino angeschlossen ist, und dann den gleichen Code hochladen.

Sobald wir also die beiden Arduino IDEs laufen haben, können wir die seriellen Monitore starten und testen, ob die Kommunikation richtig funktioniert. Alles, was wir in den seriellen Monitor eingeben, wird von einem zum anderen Arduino gesendet.

So funktioniert der Code: Sobald wir also etwas in den seriellen Monitor eingeben und auf die Schaltfläche Senden klicken, wird beim ersten Arduino die While-Schleife mit der Funktion Serial.available () wahr, und mit der Funktion HC12.write () senden wir die Daten von der serieller Monitor an das HC-12-Modul. Dieses Modul überträgt die Daten drahtlos an das zweite HC-12-Modul, sodass beim zweiten Arduino die While-Schleife mit der Funktion HC12.available() wahr wird und mit der Funktion Serial.write() die Daten an das gesendet werden serieller Monitor.

Wir können denselben Code zum Senden von AT-Befehlen und zum Konfigurieren der Modulparameter verwenden. Alles, was wir tun müssen, ist, den „Set“-Pin des Moduls mit Masse oder einem beliebigen digitalen Pin des Arduino zu verbinden und den Pin auf niedrigen Logikpegel zu setzen.

Um zu testen, ob wir den Modus erfolgreich aufgerufen haben, können wir im seriellen Monitor „AT“ eingeben und sollten eine Antwortmeldung „OK“ erhalten. Es gibt insgesamt 12 AT-Befehle, die zum Ändern verschiedener Parameter wie Baudrate, Kanal, Sendeleistung usw. verwendet werden. Wenn wir beispielsweise „AT+B38400“ eingeben, wird die Baudrate des Moduls eingestellt 38400.

AT-Befehle:

1. AT – Testbefehl.

Beispiel:Senden Sie „AT“ an das Modul und das Modul gibt „OK“ zurück.

2. AT+Bxxxx – Baudrate der seriellen Schnittstelle ändern.

Verfügbare Baudraten:1200 bps, 2400 bps, 4800 bps, 9600 bps, 19200 bps, 38400 bps, 57600 bps und 115200 bps. Standard:9600 bps.

Beispiel:Senden Sie „AT+B38400“ an das Modul und das Modul gibt „OK+B19200“ zurück.

3. AT+Cxxxx – Ändert den drahtlosen Kommunikationskanal von 001 auf 100.

Standard:Kanal 001, mit einer Arbeitsfrequenz von 433,4 MHz. Jeder nächste Kanal ist 400 kHz höher.

Beispiel:Wenn wir das Modul auf Kanal 006 einstellen möchten, müssen wir den Befehl „AT+C006“ an das Modul senden, und das Modul gibt „OK+C006“ zurück. Die neue Arbeitsfrequenz beträgt 435,4 MHz.

Beispiel 02

Lassen Sie uns nun das zweite Beispiel verschieben. Hier verwenden wir zwei Drucktasten zum Auswählen verschiedener Kommunikationskanäle und sehen eine andere Methode zum Speichern der eingehenden Daten.

Hinweis:Die „Set“-Pins beider HC-12-Module werden mit den Pins Nummer 6 der beiden Arduinos verbunden und die beiden Taster, beim ersten Arduino, mit den Pins 4 und 3.

Erster Arduino-Code:

/*    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
  }
} Codesprache:Arduino (arduino)

Zweiter Arduino-Code:

/*    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
  }
} Codesprache:Arduino (arduino)

Beschreibung der Codes:

Also müssen wir zuerst die Pins definieren und den „Set“-Pin auf einen hohen Logikpegel setzen, damit das Modul im normalen, transparenten Modus arbeitet. Mit der ersten While-Schleife speichern wir die eingehenden Daten in einer String-Variablen, damit wir besser damit umgehen können.

// ==== 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
  } Codesprache:Arduino (arduino)

Die eingehenden Daten kommen immer Byte für Byte, wenn wir also zum Beispiel den String „Test123“ vom zweiten Arduino senden, führt diese While-Schleife 7 Iterationen aus. Bei jeder Iteration lesen wir mit der HC12.read()-Funktion jedes eingehende Byte oder Zeichen und fügen es der String-Variablen mit dem Namen „readBuffer“ hinzu.

Als nächstes wollen wir sehen, wie wir den Kommunikationskanal mit der ersten Schaltfläche ändern können. Wenn wir also den ersten Taster drücken, senden wir mit der Funktion HC12.print() die Zeichenfolge „AT+C001“ an das HC-12-Modul oder an das zweite Arduino.

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;
  } Codesprache:Arduino (arduino)

Wenn dieser String beim zweiten Arduino empfangen wird, versetzen wir das HC-12-Modul in den AT-Befehlsmodus und schreiben dann denselben String „AT+C001“, der das Modul auf den Kommunikationskanal Nummer eins setzt. P>

// 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 = "";
  } Codesprache:Arduino (arduino)

Mit der nächsten While-Schleife geben wir die Antwortmeldung des HC-12-Moduls aus, ob der Kanal erfolgreich gewechselt wurde.

while (HC12.available()) {           // If HC-12 has data (the AT Command response)
      Serial.write(HC12.read());         // Send the data to Serial monitor
    } Codesprache:Arduino (arduino)

Zurück beim ersten Arduino führen wir das gleiche Verfahren durch, um den AT-Befehl an das erste HC-12-Modul zu senden. Auf die gleiche Weise stellen wir durch Drücken der zweiten Taste den zweiten Kommunikationskanal ein. Auf diese Weise können wir also jederzeit auswählen, mit welchem HC-12-Modul wir kommunizieren.

Am Ende überprüft die benutzerdefinierte Funktion checkATCommand(), ob die empfangene Nachricht ein AT-Befehl ist, indem sie prüft, ob die Zeichenfolge mit „AT“ beginnt. Wenn dies der Fall ist, wechselt das Modul in den AT-Befehlsmodus und führt den Befehl aus.

// ==== 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
  }
} Codesprache:Arduino (arduino)

HC-12 Drahtlose Kommunikation:Schrittmotorsteuerung mit einem Beschleunigungsmesser

Schauen wir uns nun das dritte Beispiel an. Hier steuern wir die Position des Schrittmotors am zweiten Arduino mit dem Beschleunigungssensormodul am ersten Arduino.

Die Schaltung enthält auch einen Mikroschalter zum Finden der Anfangsposition des Schrittmotors bei 0 Grad.

Die für dieses Beispiel benötigten Komponenten erhalten Sie über die folgenden Links:

Kabelloses HC-12-Kommunikationsmodul …………
A4988 Schrittmotortreiber …………………………..
Schrittmotor NEMA 17 …………………………………
Arduino-Board ………………………………………………..
Steckbrett und Schaltdrähte …………………………..
GY-80-Platine mit ADXL345-Beschleunigungsmesser ………

Beachten Sie hier, dass ich bereits detaillierte Tutorials zum Anschließen und Verwenden sowohl des Beschleunigungsmessers als auch des Schrittmotors habe, daher werde ich für dieses Beispiel nur den HC-12-Teil des Codes erklären.

Erster Arduino – Sendercode:

/*   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;
    }
  }
}
 Codesprache:Arduino (arduino)

Zweiter Arduino – Empfängercode:

/*   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
  }
} Codesprache:Arduino (arduino)

Beschreibung der Codes:

Also definieren wir zuerst die Pins und initialisieren die Module im Setup-Bereich. Dann lesen wir die Werte der X- und Y-Achse des Beschleunigungsmessers und ordnen sie einem Wert von 0 bis 180 Grad zu. Die vom Beschleunigungsmesser kommenden Werte können manchmal instabil sein oder zittern, daher habe ich zum Glätten des Ergebnisses den Durchschnittswert von hundert Messwerten verwendet.

// 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;
    }
  } Codesprache:Arduino (arduino)

Zur weiteren Glättung sende ich den neuen Wert des Winkels nur dann, wenn er sich um 2 vom vorherigen unterscheidet.

Beachten Sie hier, dass ich beim Senden des Winkels an das HC-12-Modul auch das Zeichen „s“ vorne und das Zeichen „e“ danach sende, was mir beim Empfang der Daten beim zweiten Arduino hilft. P>

Beim zweiten Arduino warten wir bis der Startmarker „s“ kommt, dann lesen wir den Wert des Winkels ab bis der Endmarker „e“ kommt. Auf diese Weise sind wir sicher, dass wir nur den Wert des Winkels erhalten.

// 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
    }
  } Codesprache:Arduino (arduino)

Dann wandeln wir den Wert in Integer um und ordnen den Wert von 0 bis 1600 Schritten zu, was der ausgewählten Sechzehntel-Schrittauflösung am A4988-Stepper-Treiber entspricht. Dann drehen wir den Schrittmotor auf den aktuellen Winkel.

Das wäre also alles für dieses Arduino-Tutorial. Fühlen Sie sich frei, Fragen im Kommentarbereich unten zu stellen.

L298N-Motortreiber – Arduino-Schnittstelle, Funktionsweise, Codes, Schaltpläne Wie RFID funktioniert und wie man ein Arduino-basiertes RFID-Türschloss herstellt