home Productietechnologie Fabricage-apparatuur
Industriële fabricage
Industrieel internet der dingen | Industriële materialen | Onderhoud en reparatie van apparatuur | Industriële programmering |
home  MfgRobots >> Industriële fabricage >  >> Manufacturing Technology >> Productieproces

Arduino en HC-12 draadloze communicatiemodule voor lange afstand

In deze Arduino-zelfstudie leren we hoe we de HC-12 draadloze seriële communicatiemodule kunnen gebruiken die in staat is om een ​​lange afstand draadloze communicatie te maken tussen meerdere Arduino-kaarten, met afstanden tot 1,8 km. Je kunt de volgende video bekijken of de schriftelijke tutorial hieronder lezen voor meer details.

Overzicht

Voor deze tutorial heb ik twee basisvoorbeelden gemaakt waarin wordt uitgelegd hoe de HC-12-module moet worden aangesloten en een basiscommunicatie tussen twee Arduino's kan worden gemaakt en een aanvullend voorbeeld waarbij ik met behulp van een versnellingsmetersensor op de eerste Arduino draadloos de positie van de stepper op de tweede regel. Arduino.

HC-12 draadloze communicatiemodule

Laten we eerst de HC-12 draadloze seriële poortcommunicatiemodule eens nader bekijken. Hier zijn enkele specificaties:

  • De draadloze werkende frequentieband is van 433,4 MHz tot 473,0 MHz
  • Het heeft in totaal 100 kanalen met een tussenstap van 400 KHz tussen elk kanaal
  • Het zendvermogen is van -1dBm (0,79mW) tot 20dBm (100mW)
  • De ontvangstgevoeligheid is van -117dBm (0,019pW) tot -100dBm (10pW).

Deze waarden zijn in feite afhankelijk van de geselecteerde seriële en over-the-air baudrate, zoals te zien is in de tabel.

De HC-12 module heeft een microcontroller die eigenlijk niet door de gebruiker geprogrammeerd hoeft te worden. Voor het configureren van de module gebruiken we gewoon AT-commando's, die kunnen worden verzonden vanaf een Arduino, een pc of een andere microcontroller via de seriële poort. Om de AT-commandomodus te openen, hoeven we alleen de "Set" -pin van de module op een laag logisch niveau in te stellen.

Arduino en HC-12

Laten we nu de HC-12-module op de Arduino aansluiten en het eerste voorbeeld maken. Hier zijn de circuitschema's. De bedrijfsspanning van de module is van 3,2 V tot 5,5 V en voor stabieler werk wordt het aanbevolen om een ​​ontkoppelcondensator en een externe voeding te gebruiken. Ik gebruikte echter de pc-USB als voeding voor alle drie de voorbeelden in deze tutorial en had er geen enkel probleem mee.

Ik heb de eerste module aangesloten op een Arduino UNO en de tweede module op een Arduino MEGA, maar je kunt natuurlijk elk bord gebruiken dat je wilt.

U kunt de benodigde componenten voor deze Arduino-zelfstudie verkrijgen via de onderstaande links:

  • HC-12 draadloze communicatiemodule ……….. 
  • Arduino-bord ………………………………………………
  • Broodplank en springdraden ……………………… 

Voorbeeld 01 – Arduino-code

Hier is de Arduino-code voor het eerste voorbeeld, een basiscommunicatie tussen de twee modules met behulp van de seriële 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
  }
}Code language: Arduino (arduino)

Dezelfde code wordt gebruikt voor beide Arduino's. We kunnen de twee Arduino's op twee aparte computers aansluiten, maar we kunnen ook een enkele computer gebruiken.

In dat geval moeten we, zodra we de eerste Arduino op de computer hebben aangesloten, het model en de COM-poort selecteren en de code naar de Arduino uploaden. Dan sluiten we de tweede Arduino aan en moeten we de Arduino IDE opnieuw starten om de andere COM-poort te kunnen selecteren waarop onze tweede Arduino is aangesloten, en dan dezelfde code uploaden.

Dus zodra we de twee Arduino IDE's hebben draaien, kunnen we de seriële monitoren starten en testen of de communicatie goed werkt. Alles wat we in de seriële monitor typen, wordt van de ene naar de andere Arduino gestuurd.

Hoe de code werkt: Dus zodra we iets in de seriële monitor typen en op de knop Verzenden klikken, bij de eerste Arduino, wordt de while-lus met de functie Serial.available() waar en met behulp van de functie HC12.write() sturen we de gegevens van de seriële monitor naar de HC-12-module. Deze module zal de gegevens draadloos naar de tweede HC-12-module overbrengen, dus bij de tweede Arduino wordt de while-lus met de HC12.available()-functie waar en met behulp van de Serial.write()-functie worden de gegevens naar de seriële monitor.

We kunnen dezelfde code gebruiken voor het verzenden van AT-opdrachten en het configureren van de moduleparameters. Het enige dat we hoeven te doen, is de "Set" -pin van de module verbinden met Ground of een digitale pin van de Arduino en de pin op een laag logisch niveau instellen.

Om te testen of we de modus met succes hebben ingevoerd, kunnen we in de seriële monitor "AT" typen en zouden we een antwoordbericht "OK" moeten krijgen. Er zijn in totaal 12 AT-commando's en deze worden gebruikt voor het wijzigen van verschillende parameters zoals de baudrate, het kanaal, het zendvermogen enz. Als we bijvoorbeeld "AT+B38400" typen, wordt de baudrate van de module ingesteld op 38400.

AT-opdrachten:

1. AT – Testopdracht.

Voorbeeld:stuur "AT" naar module en de module retourneert "OK".

2. AT+Bxxxx – Wijzig de baudrate van de seriële poort.

Beschikbare baudrates:1200 bps, 2400 bps, 4800 bps, 9600 bps, 19200 bps, 38400 bps, 57600 bps en 115200 bps. Standaard:9600 bps.

Voorbeeld:Stuur “AT+B38400” naar module, en de module retourneert “OK+B19200”.

3. AT+Cxxxx – Wijzig het draadloze communicatiekanaal, van 001 naar 100.

Standaard:kanaal 001, met een werkfrequentie van 433,4 MHz. Elk volgend kanaal is 400KHz hoger.

Voorbeeld:Als we de module op kanaal 006 willen zetten, moeten we de opdracht "AT+C006" naar de module sturen en de module zal "OK+C006" retourneren. De nieuwe werkfrequentie wordt 435,4 MHz.

Voorbeeld 02

Laten we nu het tweede voorbeeld verplaatsen. Hier zullen we twee drukknoppen gebruiken om verschillende communicatiekanalen te selecteren en een andere methode zien om de binnenkomende gegevens op te slaan.

Opmerking:de "Set"-pinnen van beide HC-12-modules zijn verbonden met de pinnen nummer 6 van de twee Arduino's en de twee knoppen, bij de eerste Arduino, met de pinnen 4 en 3.

Eerste 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
  }
}Code language: Arduino (arduino)

Tweede 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
  }
}Code language: Arduino (arduino)

Beschrijving van de codes:

Dus eerst moeten we de pinnen definiëren en de "Set" -pin instellen op een hoog logisch niveau om de module in de normale, transparante modus te laten werken. Met de eerste while-lus slaan we de binnenkomende gegevens op in een String-variabele, zodat we er beter mee om kunnen gaan.

// ==== 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)

De binnenkomende gegevens komen altijd één byte tegelijk, dus als we bijvoorbeeld de string "Test123" van de tweede Arduino sturen, zal deze while-lus 7 iteraties doen. Elke iteratie, met behulp van de HC12.read()-functie, zullen we elke inkomende byte of elk teken lezen en toevoegen aan de String-variabele met de naam "readBuffer".

Laten we vervolgens kijken hoe we het communicatiekanaal kunnen wijzigen met de eerste drukknop. Dus als we op de eerste drukknop drukken en de functie HC12.print() gebruiken, sturen we de string "AT+C001"  naar de HC-12-module of naar de tweede 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;
  }Code language: Arduino (arduino)

Wanneer deze string wordt ontvangen bij de tweede Arduino, zullen we de HC-12-module in de AT-opdrachtmodus zetten en vervolgens dezelfde string "AT+C001" erop schrijven die de module op communicatiekanaal nummer één zal zetten.

// 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)

We gebruiken de volgende while-lus om het antwoordbericht van de HC-12-module af te drukken of het kanaal met succes is gewijzigd.

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)

Terug bij de eerste Arduino doen we dezelfde procedure om het AT-commando naar de eerste HC-12-module te sturen. Op dezelfde manier stellen we met het indrukken van de tweede knop het communicatiekanaal nummer twee in. Met deze methode kunnen we dus op elk moment selecteren met welke HC-12-module we zullen communiceren.

Aan het einde controleert de aangepaste functie checkATCommand() of het ontvangen bericht een AT-opdracht is, door te controleren of de tekenreeks begint met "AT". Als dit het geval is, gaat de module naar de AT-opdrachtmodus en voert de opdracht uit.

// ==== 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)

HC-12 draadloze communicatie:stappenmotorbesturing met behulp van een versnellingsmeter

Laten we nu eens kijken naar het derde voorbeeld. Hier regelen we de positie van de stappenmotor bij de tweede Arduino, met behulp van de accelerometermodule bij de eerste Arduino.

Het circuit bevat ook een microschakelaar om de beginpositie van de stappenmotor op 0 graden te vinden.

U kunt de benodigde componenten voor dit voorbeeld vinden via de onderstaande links:

  • HC-12 draadloze communicatiemodule ………… 
  • A4988 Stappenmotor Driver ……………………….. 
  • Stappenmotor NEMA 17 ……………………………… 
  • Arduino-bord ……………………………………………..
  • Broodplank en springdraden ……………………….. 
  • GY-80 bord met ADXL345 versnellingsmeter ……… 

Merk op dat ik al gedetailleerde tutorials heb over het aansluiten en gebruiken van zowel de accelerometer als de stappenmotor, dus voor dit voorbeeld zal ik alleen het HC-12-gedeelte van de code uitleggen.

Eerste Arduino – Zendercode:

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

Tweede Arduino – Ontvangercode:

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

Beschrijving van de codes:

Dus eerst definiëren we de pinnen en initialiseren we de modules in de setup-sectie. Vervolgens lezen we de waarden van de X- en Y-as van de versnellingsmeter en brengen ze in kaart met waarden van 0 tot 180 graden. De waarden die van de accelerometer komen, kunnen soms onstabiel zijn of trillen, dus om het resultaat glad te strijken heb ik de gemiddelde waarde van honderd metingen gebruikt.

// 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)

Voor nog meer afvlakking stuur ik de nieuwe waarde van de hoek alleen als deze 2 verschilt van de vorige.

Merk hier op dat wanneer ik de hoek naar de HC-12-module stuur, ik ook het teken "s" ervoor en het teken "e" erna stuur, wat me zal helpen bij het ontvangen van de gegevens op de tweede Arduino.

Bij de tweede Arduino wachten we tot de startmarkering "s" komt, dan lezen we de waarde van de hoek totdat de eindmarkering "e" arriveert. Op deze manier zijn we er zeker van dat we alleen de waarde van de hoek zullen ontvangen.

// 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)

Vervolgens converteren we de waarde naar integer, en brengen de waarde in kaart van 0 tot 1600 stappen, wat overeenkomt met de geselecteerde zestiende stapresolutie bij de A4988 stepper driver. Vervolgens draaien we de stappenmotor naar de huidige hoek.

Dus dat zou alles zijn voor deze Arduino-tutorial. Stel gerust een vraag in de opmerkingen hieronder.


Productieproces

  • Productieproces
  • 3d printen
  • Automatisering Besturingssysteem
  • Industriële technologie
    1. Bereik draadloos communicatie
    2. Waarom batterijgevoede langeafstandsdraadloos storend is
    3. LCD-animatie en gaming
    4. JX Wave Generator
    5. u-blox LEA-6H 02 GPS-module met Arduino en Python
    6. Draadloze IR-temperatuurscanner
    7. Python3- en Arduino-communicatie
    8. FM-radio met Arduino en RDA8057M
    9. Een valdetectiesysteem op basis van Arduino, Windows en Azure
    10. ArduRadio AlarmClock
    11. Ultrasone afstandsmeter