Arduino Rover controlado por Bluetooth en

Android con Virtuino!

https://bentek.fr/rover-arduino-bluetooth-android-virtuino/

Hola creadores Hoy, vamos a poner en práctica lo que vimos en la serie "Learn Arduino" y
presentaremos la biblioteca Virtuino para controlar un rover Arduino con su teléfono
inteligente gracias a Bluetooth.

¡Fue durante la competencia para convertirme en embajador de Conrad con Make It With
Conrad, que tuve la oportunidad de desarrollar este proyecto! Encontrará el tutorial
completo para la realización de este proyecto en la publicación que realicé aquí . ¡No
dudes en ayudarme votando por este proyecto! ¡Encuentra cada etapa de la construcción
del móvil Arduino controlado por bluetooth hasta la realización del chasis en 3D!
Encuentre también los archivos .STL para el chasis impreso en 3D para un rover Joy-It
para Arduino / Raspberry Pi .
Todavía aprovecharé la oportunidad para aclarar las dificultades encontradas durante la
realización de este tutorial.
 El tutorial completo: Rover Arduino
o 1. Montaje del chasis
o 2. Configuración de los blindajes del motor.
o 3. Conexión de la electrónica de control.
o 4. Conexión de la electrónica de potencia.
o 5. Terminando el cableado
o 6. Programación - Rover Arduino lado
o 7. Programación: lado del teléfono inteligente con Virtuino
o 8. Paso opcional: impresión 3D de la carcasa superior del chasis
 Dificultades encontradas y preguntas
o Limitaciones actuales en los motores Arduino y Shields:
o Un punto crucial sobre la autonomía del Arduino Rover:
o Raspberry Pi / Arduino y Bluetooth / Wifi diferencias:
 Conclusión
El tutorial completo: Rover Arduino
1. Montaje del chasis
- Suelde los cables del kit Joy-It en los terminales de soldadura de los motores. Respete
siempre la misma dirección con el código de color (siempre rojo y negro en el mismo lado
del motor)
. Monte los motores en la primera placa del kit Joy-It de acuerdo con las instrucciones del
kit.
- Monte la segunda placa del kit Joy-It.
- Localice las fijaciones disponibles para poder colocar su Arduino UNO en esta segunda
placa.

2. Configuración de los blindajes del motor.

Los Velleman Motor Shields están formados por puentes para definir qué pines del Arduino
cambiarán la dirección de rotación del motor, así como el punto de ajuste de velocidad
PWM. Para hacerlo, seleccione diferentes pines en cada escudo. Por mi parte utilicé los
siguientes pines:
- En el primer escudo:
- Dirección trasera izquierda: 12
- Dirección trasera derecha: 4
- PWM trasero izquierdo: 10
- PWM trasero derecho: 5
- En el segundo escudo:
- Dirección delantera izquierda: 8
- Dirección delantera derecha 2
- PWM delantera izquierda: 9
- PWM delantera derecha: 3
También asegúrese de colocar el puente de la fuente de voltaje (POWER o PWR) en EXT y
no en INT.
Una vez que se han colocado los puentes, puedes apilar los Motor Shields en el tablero
Arduino UNO.
3. Conexión de la electrónica de control.
Para la electrónica de control, utilicé dos placas de prueba para soldar los conectores
hembra de 5 pines de 2,54 mm. Los corté a la forma de la estructura Joy-It (ver video). Sin
embargo, no es necesario ir a este nivel de detalle, dos mapas rectangulares simples harán
el truco.

Sabías ?
Las entradas analógicas A0 a A5 se pueden usar como entradas digitales. En el último
caso, A0 a A5 se convierte en ENTRADAS de 14 a 19.

Para el cableado de los diferentes sensores al Arduino, seguí el siguiente diagrama (haga
clic para ampliar):
4. Conexión de la electrónica de potencia.
Luego, conecte los cables de los diferentes motores a los Shields. No importa la polaridad,
solo tendrá que verificar que sea igual para los 4 motores. Para la distribución, consulte la
distribución realizada en el paso 3.
Conecte una batería de 9V a los conectores PWR de los 2 blindajes del motor.
5. Terminando el cableado
Luego, asegure todo su cableado con bridas para que sus cables no corran por todas
partes.

6. Programación - Rover Arduino lado

Luego viene la etapa de programación. Para hacer esto, descargue la biblioteca Virtuino
aquí: http://users.art.sch.gr/iliaslamprou/virtuino/virtuino.zip
Para obtener más información sobre cómo agregar esta biblioteca y la aplicación Virtuino,
consulte el tutorial de inicio de Virtuino disponible
aquí: http://users.sch.gr//iliaslamprou/virtuino/virtuino_bluetooth_tutorial_1.html
Una vez que la biblioteca esté instalada, podremos comenzar a codificar. Os dejo el
código completo y comenté aquí:
#include <VirtuinoBluetooth.h>
#include <VirtuinoEsp8266_WebServer.h>
#include <VirtuinoEthernet_WebServer.h>

#include <SoftwareSerial.h>

SoftwareSerial bluetoothSerial = SoftwareSerial(0,1);

VirtuinoBluetooth virtuino(bluetoothSerial);

// VirtuinoBluetooth virtuino(Serial1);

int buzzerPin = 13;

int dirArG = 12;

int dirArD = 4;
int dirAvG = 8;
int dirAvD = 2;

int PWMArG = 10;

int PWMArD = 5;
int PWMAvG = 9;
int PWMAvD = 3;

int trigAv = 7;
int trigAr = 6;

int echoAvG = 14;

int echoAvD = 15;
int echoArD = 16;
int echoArC = 17;
int echoArG = 18;

int vitesseGauche = 0;
int vitesseDroite = 0;
int capteur = 0;

void setup() {
// put your setup code here, to run once:

//virtuino.DEBUG=true; // set this value TRUE to enable the serial monitor status
//Serial.begin(9600); // Set serial monitor baud rate
bluetoothSerial.begin(9600);

virtuino.vPinMode(buzzerPin,OUTPUT);

//Gauche
pinMode(PWMArG, OUTPUT);
pinMode(PWMAvG, OUTPUT);
pinMode(dirArG, OUTPUT);
pinMode(dirAvG, OUTPUT);

//Droite
pinMode(PWMArD, OUTPUT);
pinMode(PWMAvD, OUTPUT);
pinMode(dirArD, OUTPUT);
pinMode(dirAvD, OUTPUT);

//Trigger des émetteurs Ultrasons

pinMode(trigAv, OUTPUT);
pinMode(trigAr, OUTPUT);

//Récepteurs Ultrasons
pinMode(echoAvG, INPUT);
pinMode(echoAvD, INPUT);
pinMode(echoArD, INPUT);
pinMode(echoArC, INPUT);
pinMode(echoArG, INPUT);

void loop() {
// put your main code here, to run repeatedly:

virtuino.run();

// Arrêt des moteurs sur VD0

if(virtuino.vDigitalMemoryRead(0) == 1){
RAZMot();
}

vitesseGauche = (int)virtuino.vMemoryRead(0);
vitesseDroite = (int)virtuino.vMemoryRead(1);

// Contrôle Gauche entre -250 et 250

if(vitesseGauche >= 0){

digitalWrite(dirArG, 1);
digitalWrite(dirAvG, 1);
 analogWrite(PWMArG, vitesseGauche);
analogWrite(PWMAvG, vitesseGauche);
}
if(vitesseGauche < 0){
digitalWrite(dirArG, 0);
digitalWrite(dirAvG, 0);
analogWrite(PWMArG, -vitesseGauche);
analogWrite(PWMAvG, -vitesseGauche);
}

// Contrôle Droite entre -250 et 250

if(vitesseDroite >= 0){

digitalWrite(dirArD, 1);
digitalWrite(dirAvD, 1);
analogWrite(PWMArD, vitesseDroite);
analogWrite(PWMAvD, vitesseDroite);
}
if(vitesseDroite < 0){
digitalWrite(dirArD, 0);
digitalWrite(dirAvD, 0);
analogWrite(PWMArD, -vitesseDroite);
analogWrite(PWMAvD, -vitesseDroite);
}

//Une mesure est réalisée toutes les 100 boucles (100 cycles), à chaque fois sur un capteur différent pour éviter la
latence de la commande.

capteur++;

switch (capteur) {
case 100:{
Distance(trigAr,echoArD,4);
break;
}
case 200:{
Distance(trigAv,echoAvG,2);
break;
}
case 300:{
Distance(trigAr,echoArC,5);
break;
}
case 400:{
Distance(trigAv,echoAvD,3);
break;
}
case 500:{
Distance(trigAr,echoArG,6);
break;
}
}

if(capteur == 500){
capteur = 0;
}
}

// Permet de faire un bip tout les 2,5 cycle (sur VD1) et de constater la longueur des cycles, et donc la latence.
if(virtuino.vDigitalMemoryRead(1) == 1){
if(capteur == 400){
digitalWrite(buzzerPin,1);
}
if(capteur == 200){
digitalWrite(buzzerPin,0);
}
}

void RAZMot(){ // Fonction permettant de réinitialiser les moteurs à 0 pour s'arrêter proprement
virtuino.vMemoryWrite(0,0);
virtuino.vMemoryWrite(1,0);
}

// Fonction qui calcule la distance selon le pin de trigger et d'echo. Le MemoryWrite designe la valeur mémoire où
écrire dans Virtuino.
void Distance(int trigPin, int echoPin, int MemoryWrite) {

long duration, distance;

// Envoie de l'onde
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
// Réception de l'écho
duration = pulseIn(echoPin, HIGH);

// Calcul de la distance
distance = (duration/2) / 29.1;

if (distance >= 20 || distance <= 0){

virtuino.vMemoryWrite(MemoryWrite,20);
}
else {
virtuino.vMemoryWrite(MemoryWrite,distance);
}

delay(10);
}
 

Las personas que leyeron este artículo también leyeron:   [2/50] Desafío de 50

objetos: la bandeja de recarga
7. Programación: lado del teléfono inteligente con
Virtuino
Primero, descargue Virtuino de Google Play Store: https://tinyurl.com/virtuino
Como antes, consulte este tutorial para la configuración y conexión de
Bluetooth: http://users.sch.gr// iliaslamprou / virtuino / virtuino_bluetooth_tutorial_1.html

Luego, una vez que se inicia el software, puede personalizar la interfaz. Debe saber que
Virtuino puede trabajar directamente con los valores de INPUT / OUTPUT de Arduino, pero
también tiene un sistema llamado "memoria virtual" que permite hacer enlaces con
variables en el programa Arduino.
Las memorias programadas (en el programa del paso anterior) son:
- DV0: apagado completo de los motores móviles Arduino.
- DV1: se utiliza para emitir un pitido cada 2.5 ciclos. Esto hace posible estimar los
tiempos de latencia.
- V0: Velocidad del motor a la izquierda que puede variar de -255 (reversa) a 255 (adelante).
- V1: Velocidad del motor a la derecha que puede variar de -255 (reversa) a 255 (adelante).
- V2: Distancia medida por el sensor ultrasónico delantero izquierdo en cm.
- V3: Distancia medida por el sensor ultrasónico delantero derecho en cm.
- V4: Distancia medida por el sensor ultrasónico trasero derecho en cm.
- V5: Distancia medida por el sensor ultrasónico del centro trasero en cm.
- V6: Distancia medida por el sensor ultrasónico trasero izquierdo en cm.
También puede obtener mi archivo de configuración disponible aquí .
Para recuperarlo, descomprima el archivo .vrt en su teléfono inteligente y ábralo con
Virtuino.

8. Paso opcional: impresión 3D de la carcasa superior del

chasis
Para proteger mejor el montaje del móvil Arduino, puede descargar el modelo que imprimí
en el video aquí:
https://www.thingiverse.com/thing:2922890

Para la impresión de esta parte, los soportes son necesarios. El relleno es del 20%.
Y como beneficio adicional, agregué soporte para un CAM deportivo.
Dificultades encontradas y preguntas
Limitaciones actuales en los motores Arduino y Shields:
La primera dificultad en este proyecto se refiere a las limitaciones actuales en los pines
del Arduino. De hecho, el Arduino puede suministrar un máximo de 50 mA por pin y el
regulador de 5 V en la tarjeta no admite más de 450 mA en el consumo total. Sabiendo que
la placa Arduino puede consumir hasta 80 mA, esto nos deja alrededor de 370 mA para la
potencia de los diversos sensores y Shield Arduino para agregar. Los transmisores /
receptores ultrasónicos consumen entre 10 y 40 mA cada uno. Calculo que consumen 10
mA en reposo y 40 mA durante la medición. En el programa, solo tomaré una medida a la
vez, lo que nos da 4 * 10 + 1 * 40 = 80 mA para los sensores ultrasónicos que redondeo a
100 mA (no creo que la corriente sea siempre 10 mA en reposo, esto es solo un valor de
bajo consumo).

Las personas que leyeron este artículo también leyeron:   [7] Aprenda Arduino
- Operadores

Luego viene el timbre, que consume alrededor de 10 mA cuando está activo. Caemos a

260 mA. Luego, el módulo Bluetooth que consume unos 30 mA en funcionamiento, cae a
230 mA.
Por lo tanto, debemos garantizar que, en términos de consumo, no caigamos a 0 mA, de lo
contrario, el Arduino se reiniciará tan pronto como se alcance el pico de consumo. ¡Y
especialmente no queremos que el rover Arduino se detenga en medio de una carrera!
Luego está la gran pregunta sobre los Motor Shields. No veo ninguna información sobre el
consumo de estos Shields. Debemos cambiar 4 direcciones para los 4 motores y enviar 4
señales PWM. Estas señales consumen poco en teoría, alrededor de 10 mA cada una. 230
- 8 × 10 = 150 mA restantes. Posteriormente, los dos Shields deben suministrar sus
componentes, es decir, dos puentes H dobles, dos veces dos Leds y una multitud de
componentes pasivos o inductivos. Al conectar todo y después de varias pruebas, en
términos de consumo de tarjeta y el suministro de todos los sensores y escudos,
funciona. Sin embargo, cuando ejecuto más de un motor al mismo tiempo, todo el sistema
se apaga y se reinicia.
Para los 2 Shields, tengo la opción de suministrar los motores a través de la placa Arduino,
que tiene el efecto de tomar directamente el voltaje de entrada del Arduino. Sin embargo,
cuando más de un motor estaba funcionando, todo el sistema se apagaba. De ahí la
solución de pasar por una fuente de alimentación separada para los motores, lo que
explica la elección de 2 baterías de 9 V.
Un punto crucial sobre la autonomía del Arduino Rover:
Todavía no he tenido suficiente perspectiva sobre la autonomía de la parte "Arduino y
sensores", porque después de varias pruebas en este móvil Arduino, todavía no he logrado
vaciar la batería de 9V para la parte de control. Por contra lado de la batería del motor,
después de aproximadamente 1 hora de prueba comencé a sentir la batería un poco
débil. En este proyecto no tuve la oportunidad de agregar baterías de modelado externas
(demasiado caras en comparación con el costo general del proyecto). ¡De este lado, mi
PiRobot tenía mucha más energía de sobra! (Al mismo tiempo, con una batería modelo de
22000 mAh y un banco de energía de 5000 mAh para la parte de control, ¡es un poco
normal que me mantenga despierto durante el día!).
Raspberry Pi / Arduino y Bluetooth / Wifi diferencias:
Esto es solo una sensación en comparación con el pilotaje del rodu Arduino y el PiRobot: la
comunicación Wifi con el PiRobot se optimizó mucho mejor que la comunicación Bluetooth
con el Arduino en el RoverDuino. Sin embargo, las frecuencias de Bluetooth y Wifi están
muy cerca una de la otra. Así que creo que la velocidad de ejecución del programa juega
un papel crucial en la conducción del Robot. En PiRobot, con el servidor de control
codificado en C ++, el programa tenía una velocidad de ejecución mucho mayor. Creo que
la latencia quizás se deba a la biblioteca Virtuino que espera sistemáticamente una
respuesta a cada una de las solicitudes realizadas, que no fue mi caso con PiRobot, porque
me comuniqué a través del protocolo UDP.

Conclusión
Estaba feliz de participar en este concurso con Conrad. Me doy cuenta de que mi primer
Rover, que requirió mucho más tiempo y desarrollo, finalmente tiene más éxito. La ventaja
aquí es que ya tenía buenas ideas con respecto a la creación de rover. Así que pude
desarrollar este proyecto rápidamente, sin tener demasiadas limitaciones.