Module de communication sans fil longue portée Arduino et HC-12
Dans ce tutoriel Arduino, nous apprendrons à utiliser le module de communication série sans fil HC-12 qui est capable d'établir une communication sans fil longue portée entre plusieurs cartes Arduino, avec des distances allant jusqu'à 1,8 km. Vous pouvez regarder la vidéo suivante ou lire le didacticiel écrit ci-dessous pour plus de détails.
Pour ce tutoriel, j'ai fait deux exemples de base expliquant comment connecter le module HC-12 et établir une communication de base entre deux Arduinos et un exemple supplémentaire où l'utilisation d'un capteur accéléromètre au premier Arduino je contrôle sans fil la position du stepper au second Arduino.
Examinons d'abord de plus près le module de communication de port série sans fil HC-12. Voici quelques spécifications :
Ces valeurs dépendent en fait du débit en bauds série et OTA sélectionné, comme indiqué dans le tableau.
Le module HC-12 dispose d'un microcontrôleur qui n'a pas besoin d'être programmé par l'utilisateur. Pour configurer le module, nous utilisons simplement les commandes AT, qui peuvent être envoyées depuis un Arduino, un PC ou tout autre microcontrôleur utilisant le port série. Pour entrer dans le mode de commande AT, il suffit de régler la broche "Set" du module sur un niveau logique bas.
Connectons maintenant le module HC-12 à l'Arduino et faisons le premier exemple. Voici les schémas du circuit. La tension de fonctionnement du module est de 3,2 V à 5,5 V et pour un travail plus stable, il est recommandé d'utiliser un condensateur de découplage et une alimentation externe. Cependant, j'ai utilisé l'USB du PC comme alimentation pour les trois exemples de ce didacticiel et je n'ai rencontré aucun problème.
J'ai connecté le premier module à un Arduino UNO et le deuxième module à un Arduino MEGA, mais bien sûr, vous pouvez utiliser n'importe quelle carte que vous voulez.
Vous pouvez obtenir les composants nécessaires pour ce didacticiel Arduino à partir des liens ci-dessous :
Voici le code Arduino pour le premier exemple, une communication de base entre les deux modules utilisant le Serial Monitor.
Le même code est utilisé pour les deux Arduinos. Nous pouvons connecter les deux Arduinos sur deux ordinateurs distincts mais nous pouvons également utiliser un seul ordinateur.
Dans ce cas, une fois que nous avons connecté le premier Arduino à l'ordinateur, nous devons sélectionner le modèle et le port COM et télécharger le code sur l'Arduino. Ensuite, nous connectons le deuxième Arduino et nous devons redémarrer l'IDE Arduino afin de pouvoir sélectionner l'autre port COM auquel notre deuxième Arduino est connecté, puis télécharger le même code.
Ainsi, une fois que nous avons les deux IDE Arduino en cours d'exécution, nous pouvons démarrer les moniteurs série et tester si la communication fonctionne correctement. Tout ce que nous tapons dans le moniteur série sera envoyé de l'un à l'autre Arduino.
Comment fonctionne le code : Donc, une fois que nous avons tapé quelque chose dans le moniteur série et cliqué sur le bouton Envoyer, au premier Arduino, la boucle while avec la fonction Serial.available () deviendra vraie et en utilisant la fonction HC12.write () nous enverrons les données du moniteur série au module HC-12. Ce module transférera les données sans fil au deuxième module HC-12, donc au deuxième Arduino, la boucle while avec la fonction HC12.available() deviendra vraie et en utilisant la fonction Serial.write() les données seront envoyées au moniteur série.
Nous pouvons utiliser le même code pour envoyer des commandes AT et configurer les paramètres du module. Tout ce que nous avons à faire est de connecter la broche "Set" du module à la masse ou à n'importe quelle broche numérique de l'Arduino et de régler la broche sur le niveau logique bas.
Pour tester si nous avons réussi à entrer dans le mode, dans le moniteur série, nous pouvons taper "AT" et nous devrions obtenir un message de réponse "OK". Il y a au total 12 commandes AT, et elles sont utilisées pour modifier divers paramètres tels que le débit en bauds, le canal, la puissance d'émission, etc. Par exemple, si nous tapons "AT + B38400", le débit en bauds du module sera défini sur 38400.
1. AT - Commande de test.
Exemple :Envoyez "AT" au module, et le module renvoie "OK".
2. AT+Bxxxx – Modifier le débit en bauds du port série.
Débits en bauds disponibles :1200 bps, 2400 bps, 4800 bps, 9600 bps, 19200 bps, 38400 bps, 57600 bps et 115200 bps. Par défaut :9 600 bits/s.
Exemple :envoyez "AT+B38400" au module, et le module renvoie "OK+B19200".
3. AT+Cxxxx – Changer le canal de communication sans fil, de 001 à 100.
Par défaut :Canal 001, avec une fréquence de travail de 433,4 MHz. Chaque canal suivant est supérieur de 400 KHz.
Exemple : si nous voulons régler le module sur le canal 006, nous devons envoyer la commande "AT+C006" au module, et le module renverra "OK+C006". La nouvelle fréquence de travail sera de 435,4 MHz.
Passons maintenant au deuxième exemple. Ici, nous allons utiliser deux boutons-poussoirs pour sélectionner différents canaux de communication et voir une méthode différente de stockage des données entrantes.
Remarque :Les broches "Set" des deux modules HC-12 sont connectées aux broches numéro 6 des deux Arduinos et les deux boutons, au premier Arduino, aux broches 4 et 3.
Premier code Arduino :
Deuxième code Arduino :
Description des codes :
Donc, nous devons d'abord définir les broches et régler la broche "Set" sur le niveau logique élevé pour que le module fonctionne en mode normal et transparent. Avec la première boucle while, nous stockons les données entrantes dans une variable String, afin que nous puissions mieux les gérer.
Les données entrantes arrivent toujours un octet à la fois, donc par exemple si nous envoyons la chaîne "Test123" du second Arduino, cette boucle while fera 7 itérations. À chaque itération, en utilisant la fonction HC12.read(), nous lirons chaque octet ou caractère entrant et l'ajouterons à la variable String nommée "readBuffer".
Voyons ensuite comment changer de canal de communication à l'aide du premier bouton poussoir. Donc, si nous appuyons sur le premier bouton-poussoir, en utilisant la fonction HC12.print(), nous enverrons la chaîne "AT+C001" au module HC-12 ou au deuxième Arduino.
Lorsque cette chaîne sera reçue sur le deuxième Arduino, nous mettrons le module HC-12 en mode de commande AT, puis y écrirons la même chaîne "AT + C001" qui définira le module sur le canal de communication numéro un.
Nous utilisons la boucle while suivante pour imprimer le message de réponse du module HC-12 indiquant si le canal a été modifié avec succès.
De retour au premier Arduino, nous effectuons la même procédure d'envoi de la commande AT au premier module HC-12. De la même manière, en appuyant sur le deuxième bouton, nous définissons le canal de communication numéro deux. Ainsi, en utilisant cette méthode, nous pouvons sélectionner, à tout moment, avec quel module HC-12 nous communiquerons.
À la fin, la fonction personnalisée checkATCommand() vérifie si le message reçu est une commande AT, en vérifiant si la chaîne commence par "AT". Si tel est le cas, le module passe en mode de commande AT et exécute la commande.
Voyons maintenant le troisième exemple. Ici, nous contrôlons la position du moteur pas à pas du deuxième Arduino, en utilisant le module accéléromètre du premier Arduino.
Le circuit contient également un micro-interrupteur pour trouver la position initiale du moteur pas à pas à 0 degré.
Vous pouvez obtenir les composants nécessaires pour cet exemple à partir des liens ci-dessous :
Notez ici que j'ai déjà des tutoriels détaillés sur la façon de connecter et d'utiliser à la fois l'accéléromètre et le moteur pas à pas, donc pour cet exemple, je n'expliquerai que la partie HC-12 du code.
Premier Arduino – Code émetteur :
Second Arduino – Code récepteur :
Description des codes :
Nous définissons donc d'abord les broches et initialisons les modules dans la section de configuration. Ensuite, nous lisons les valeurs des axes X et Y de l'accéléromètre et les mappons à des valeurs de 0 à 180 degrés. Les valeurs provenant de l'accéléromètre peuvent parfois être instables ou secouer, donc pour lisser le résultat, j'ai utilisé la valeur moyenne de cent lectures.
Pour encore plus de lissage, j'enverrai la nouvelle valeur de l'angle uniquement si elle diffère de la précédente de 2.
Notez ici que lors de l'envoi de l'angle au module HC-12, j'envoie également le caractère "s" devant et le caractère "e" après, ce qui m'aidera lors de la réception des données sur le deuxième Arduino.
Au deuxième Arduino, nous attendons que le marqueur de début "s" vienne, puis nous lisons la valeur de l'angle jusqu'à ce que le marqueur de fin "e" arrive. De cette façon, nous sommes sûrs que nous ne recevrons que la valeur de l'angle.
Ensuite, nous convertissons la valeur en nombre entier et mappons la valeur de 0 à 1600 pas, ce qui correspond à la résolution de seizième pas sélectionnée sur le pilote pas à pas A4988. Ensuite, nous faisons tourner le moteur pas à pas à l'angle actuel.
Ce serait donc tout pour ce tutoriel Arduino. N'hésitez pas à poser des questions dans la section des commentaires ci-dessous.Aperçu
Module de communication sans fil HC-12
Arduino et HC-12
Exemple 01 – Code Arduino
/* 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)
Commandes AT :
Exemple 02
/* 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)/* 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)// ==== 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)
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)// 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)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)// ==== 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)Communication sans fil HC-12 :contrôle de moteur pas à pas à l'aide d'un accéléromètre
/* 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)/* 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)// 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)// 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)
Processus de fabrication
- Portée de communication sans fil
- Pourquoi le sans fil longue portée alimenté par batterie est perturbateur
- Animation LCD et jeux
- Générateur d'ondes JX
- module GPS u-blox LEA-6H 02 avec Arduino et Python
- Scanner de température infrarouge sans fil
- Communication Python3 et Arduino
- Radio FM utilisant Arduino et RDA8057M
- Un système de détection de chute basé sur Arduino, Windows et Azure