Arduino contrôlée Bluetooth-bot (4 / 4 étapes)

Étape 4: Code

Bluetooth-bot v1
Arduino robotique officieux chapitre 14
Adaptateur série Bluetooth Mate permet de recevoir des commandes de PC
Arduino décode les commandes dans les mouvements du moteur
Crée le haut-débit liaison série sans fil pour la commande de robot à l’aide du clavier
Utilise les touches « i » = vers l’avant, « j » = gauche, « k » = marche arrière et « l » = droite
régulateur de vitesse est également implémentée à l’aide ","= vitesse vers le bas,"" = vitesse vers le haut, et « / » = vitesse max.

Variables de contrôle moteur L298
int M1_A = 12 ;    Si vous utilisez Ardumoto, changer à la broche 13
int M1_PWM = 11 ;
int M1_B = 10 ; Si vous utilisez Ardumoto, supprimer cette variable

int M2_A = 4 ;   Si vous utilisez Ardumoto, changement d’axe de 12
int M2_PWM = 3 ;
int M2_B = 2 ;    Si vous utilisez Ardumoto, supprimer cette variable

Broche de LED attaché à Arduino D13
int LED = 13 ;

variable pour stocker des données en série
int incomingByte = 0 ;

variable pour stocker la valeur de la vitesse
int speed_val = 255 ;

//////////////////////////////

void setup() {}

TCCR2B = TCCR2B & 0b11111000 | 0 x 01 ; changer de fréquence PWM pour broches 3 et 11 et 32kHz afin qu’il n’y aura pas pleurnicher moteur

Démarrez l’analyseur de série à 115 200 bits/s
Serial.Begin(115200) ;

déclarer les sorties
pinMode (LED, sortie) ;

pinMode (M1_A, sortie) ;
pinMode (M1_PWM, sortie) ;
pinMode (M1_B, sortie) ;

pinMode (M2_A, sortie) ;
pinMode (M2_PWM, sortie) ;
pinMode (M2_B, sortie) ;

désactiver les moteurs par défaut
M1_stop() ;
M2_stop() ;

Delay(500) ;

}

////////////////////////////////////

void loop() {}

cocher pour les données série
Si (Serial.available() > 0) {}
lire les octets entrants :
incomingByte = Serial.read() ;
le cas échéant, clignoter la LED et imprimer des données série reçues.
digitalWrite (LED, haute) ;
dire ce que tu as :
Serial.Print ("J’ai reçu:") ;
Serial.println(incomingByte) ;
retard de 10 millisecondes pour laisser le temps de mise à jour de série
Delay(10) ;

vérifier les octets entrants pour la direction
Si l’octet est égal à « 46 » ou «, » - augmenter la vitesse
Si (incomingByte == 46) {}
speed_val = speed_val + 5 ;
test_speed() ;
Serial.println(speed_val) ;
}
Si l’octet est égal à « 44 » ou "."-baisser la vitesse
ElseIf (incomingByte == 44) {}
speed_val = speed_val - 5 ;
test_speed() ;
Serial.println(speed_val) ;
}
Si l’octet est égal à « 47 » ou « / » - Vitesse max
ElseIf (incomingByte == 47) {}
speed_val = 255 ;
test_speed() ;
}

Si l’octet est égal à « 105 » ou « i », aller de l’avant
ElseIf (incomingByte == 105) {}
M1_forward(speed_val) ;
M2_forward(speed_val) ;
Delay(25) ;
}
Si l’octet est égal à « 106 » ou « j », tourner à gauche
ElseIf (incomingByte == 106) {}
M1_reverse(speed_val) ;
M2_forward(speed_val) ;
Delay(25) ;
}
Si l’octet est égal à « 108 » ou « l », aller à droite
ElseIf (incomingByte == 108) {}
M1_forward(speed_val) ;
M2_reverse(speed_val) ;
Delay(25) ;
}
Si l’octet est égal à « 107 » ou « k », allez inverse
ElseIf (incomingByte == 107) {}
M1_reverse(speed_val) ;
M2_reverse(speed_val) ;
Delay(25) ;
}
Sinon, arrêter les deux moteurs
else {}
M1_stop() ;
M2_stop() ;
}

}

else {}
M1_stop() ;
M2_stop() ;
digitalWrite (LED, faible) ;
}
}

void test_speed() {}
limiter la valeur de la vitesse à entre 0 et 255
Si {(speed_val > 250)
speed_val = 255 ;
Serial.println ("MAX") ;
}
Si (speed_val < 0) {}
speed_val = 0 ;
Serial.println ("MIN") ;
}

}

fonctions motrices / / /

void M1_reverse(int x) {}
digitalWrite (M1_B, basse) ;
digitalWrite (M1_A, élevé) ;
analogWrite (M1_PWM, x) ;
}

void M1_forward(int x) {}
digitalWrite (M1_A, basse) ;
digitalWrite (M1_B, élevé) ;
analogWrite (M1_PWM, x) ;
}

void M1_stop() {}
digitalWrite (M1_B, basse) ;
digitalWrite (M1_A, basse) ;
digitalWrite (M1_PWM, basse) ;
}

void M2_forward(int y) {}
digitalWrite (M2_B, basse) ;
digitalWrite (M2_A, élevé) ;
analogWrite (M2_PWM, y) ;
}

void M2_reverse(int y) {}
digitalWrite (M2_A, basse) ;
digitalWrite (M2_B, élevé) ;
analogWrite (M2_PWM, y) ;
}

void M2_stop() {}
digitalWrite (M2_B, basse) ;
digitalWrite (M2_A, basse) ;
digitalWrite (M2_PWM, basse) ;
}