Étape 10 : logiciel
Le programme a été écrit en 1.01 IDE Arduino.
#include « EEPROM.h »
#define D1 2 / / sens de rotation moteur 1
#define M1 3 / / PWM à gauche moteur
#define D2 4 / / sens de rotation moteur 2
#define 5 M2 / / PWM droite moteur
#define cor 13 / / supplémentaire canal 1
#define autoOFF 2500 / / millisecondes après lequel le robot s’arrête lorsque la connexion
#define cmdL « L » / / UART-commande pour moteur gauche
#define cmdR « R » / / UART-commande pour moteur droite
#define antenne « H » / / UART-commande pour un canal supplémentaire (par exemple Horn)
#define FDMC « F » / / UART-commande pour le fonctionnement de l’EEPROM
#define cmdr « r » / / UART-commande pour l’opération d’EEPROM (Lire)
#define cmdw « w » / / UART-commande pour le fonctionnement de l’EEPROM (écriture)
char incomingByte ; données entrantes
char L_Data [4] ; données du tableau pour moteur gauche
octet L_index = 0 ; index du tableau L
char R_Data [4] ; données du tableau pour moteur droite
octet R_index = 0 ; index du tableau R
char H_Data [1] ; données du tableau pour canal supplémentaire
octet H_index = 0 ; index du tableau H
char F_Data [8] ; données du tableau pour EEPROM
octet F_index = 0 ; index du tableau F
commande de char ; commande
unsigned long currentTime, lastTimeCommand, autoOFF ;
void setup() {}
Serial.Begin(9600) ; initialisation UART
pinMode (corne, sortie) ; canal supplémentaire
pinMode (D1, sortie) ; sortie pour la rotation du moteur
pinMode (D2, sortie) ; sortie pour la rotation du moteur
/ * EEPROM.write(0,255) ;
EEPROM.write(1,255) ;
EEPROM.write(2,255) ;
EEPROM.write(3,255); * /
timer_init() ; minuterie de logiciel d’initialisation
}
void timer_init() {}
uint8_t sw_autoOFF = EEPROM.read(0) ; lire EEPROM « est activé ou ne pas arrêter la voiture lorsque la perte de connexion »
Si (sw_autoOFF == « 1 ») {/ / si activé
char var_Data [3] ;
var_Data [0] = EEPROM.read(1) ;
var_Data [1] = EEPROM.read(2) ;
var_Data [2] = EEPROM.read(3) ;
autoOFF = atoi (var_Data) * 100 ; autoOFF variable ms
}
ElseIf (sw_autoOFF == « 0 ») {}
autoOFF = 999999 ;
}
d’autre if(sw_autoOFF == 255) {}
autoOFF = 2500 ; Si l’EEPROM est vide, la valeur dafault est 2,5 sec
}
currentTime = millis() ; lire que le temps écoulé depuis le démarrage de l’application
}
void loop() {}
Si (Serial.available() > 0) {/ / si a reçu les données de l’UART
incomingByte = Serial.read() ; Raed octets
if(incomingByte == cmdL) {/ / si a reçu les données pour le moteur gauche L
commande = cmdL ; commande en cours
memset(L_Data,0,sizeof(L_Data)) ; effacer le tableau
L_index = 0 ; réinitialiser l’index de tableau
}
d’autre if(incomingByte == cmdR) {/ / si a reçu les données pour le moteur gauche R
commande = capitaine de frégate ;
memset(R_Data,0,sizeof(R_Data)) ;
R_index = 0 ;
}
d’autre if(incomingByte == cmdH) {/ / si a reçu les données pour le canal supplémentaire
commande = antenne ;
memset(H_Data,0,sizeof(H_Data)) ;
H_index = 0 ;
}
d’autre if(incomingByte == cmdF) {/ / si a reçu les données pour op EEPROM
commande = FDMC ;
memset(F_Data,0,sizeof(F_Data)) ;
F_index = 0 ;
}
ElseIf (incomingByte == « \r ») command = « e » ; fin de ligne
ElseIf (incomingByte == « \t ») commande = ' t ' ; fin de ligne pour op EEPROM
Si (commande == cmdL & & incomingByte! = cmdL) {}
L_Data [L_index] = incomingByte ; stocker chaque octet dans le tableau
L_index ++ ; index de tableau incrément
}
ElseIf (commande == cmdR & & incomingByte! = cmdR) {}
R_Data [R_index] = incomingByte ;
R_index ++ ;
}
ElseIf (commande == antenne & & incomingByte! = antenne) {}
H_Data [H_index] = incomingByte ;
H_index ++ ;
}
ElseIf (commande == FDMC & & incomingByte! = FDMC) {}
F_Data [F_index] = incomingByte ;
F_index ++ ;
}
ElseIf (commande == « e ») {/ / si nous prenons la fin de ligne
Control4WD(atoi(L_Data),atoi(R_Data),atoi(H_Data)) ;
Delay(10) ;
}
ElseIf (commande ' t ==') {/ / si nous prenons l’extrémité EEPROM
Flash_Op(F_Data[0],F_Data[1],F_Data[2],F_Data[3],F_Data[4]) ;
}
lastTimeCommand = millis() ; lire que le temps écoulé depuis le démarrage de l’application
}
if(Millis() > = (lastTimeCommand + autoOFF)) {/ / comparer la minuterie actuelle avec la variable lastTimeCommand + autoOFF
Control4WD(0,0,0) ; arrêter la voiture
}
}
void Control4WD (int mLeft, int mRight, cor uint8_t) {}
bool directionL, directionR ; sens de rotation moteur L298N
valueL octet, expert ; PWM M1, M2 (0-255)
Si (mLeft > 0) {}
valueL = mLeft ;
directionL = 0 ;
}
ElseIf (mLeft < 0) {}
valueL = 255 - abs(mLeft) ;
directionL = 1 ;
}
else {}
directionL = 0 ;
valueL = 0 ;
}
Si (mRight > 0) {}
Expert = mRight ;
directionR = 0 ;
}
ElseIf (mRight < 0) {}
Expert = 255 - abs(mRight) ;
directionR = 1 ;
}
else {}
directionR = 0 ;
Expert = 0 ;
}
analogWrite (M1, valueL) ; régler la vitesse du moteur gauche
analogWrite (M2, expert) ; régler la vitesse pour moteur droite
digitalWrite (D1, directionL) ; définir la direction de rotation du moteur gauche
digitalWrite (D2, directionR) ; définir la direction de rotation du moteur droit
digitalWrite (klaxon, klaxon) ; canal supplémentaire
}
void Flash_Op (char FCMD, uint8_t z1, z2 uint8_t, uint8_t z3, z4 uint8_t) {}
if(FCMD == CMdR) {/ / si la lecture de données EEPROM commande
Serial.Print("FData:") ; Envoyer des données de l’EEPROM
Serial.Write(EEPROM.Read(0)) ; lire la valeur de la mémoire avec 0 adresse et imprimez-le à UART
Serial.Write(EEPROM.Read(1)) ;
Serial.Write(EEPROM.Read(2)) ;
Serial.Write(EEPROM.Read(3)) ;
Serial.Print("\r\n") ; marquer la fin de la transmission de données EEPROM
}
d’autre if(FCMD == cmdw) {/ / si écrire de données EEPROM commande
EEPROM.write(0,z1) ; enregistrement de Z1 à un mémoire dont l’adresse 0
EEPROM.write(1,z2) ;
EEPROM.write(2,z3) ;
EEPROM.write(3,z4) ;
timer_init() ; réinitialiser la minuterie
Serial.Print("FWOK\r\n") ; Envoyer un message que les données sont écrites avec succès à EEPROM
}
Le code utilise une bibliothèque de travailler avec mémoire EEPROM AVR. La carte Arduino par USART du module Bluetooth reçoit de données prêt pour le moteur gauche et droit. Tous les calculs de base sont effectuées dans l’application Android.
La structure du projet dans Eclipse, vous pouvez voir sur la capture d’écran ci-dessus.
Vous pouvez télécharger le code source pour l’Arduino et le projet pour Eclipse
Télécharger Application APK pour Android-périphérique
La dernière version du logiciel se trouvent sur cette page vidéo de démonstration du mode volant virtuel (version 1.2 et supérieure) :
PS Désolé pour mon mauvais anglais
