Arduino+UNO

toc

ARDUINO en la RED
Sitios interesantes para empezar con arduino: = =
 * Prometec tutoriales en español, para empezar es una auténtica joya.
 * El sitio web oficial de arduino (inglés) te servirá para conocer el entorno de programación IDE de arduino.
 * Esquema muy detallado del patillaje de ARDUINO UNO

La placa de arduino UNO te la muestro en la imagen (click sobre la imagen para AMPLIAR):



Ejemplo de FICHA WEB de una Práctica
Cada **práctica de Arduino** hay que documentarla en vuestra página de wikispaces, os dejo un enlace donde podéis ver el ejemplo de la primera práctia: LED que Parpadea

Práctica 1: LED que parpadea

 * Funcionamiento**: un diodo LED, montado en el PIN 13 parpadeará en un ciclo de 1 s encendido y 1 s apagado.
 * Monta un LED sobre el pin 13 y protégelo con una R de 220 Ω
 * Abre Arduino **Archivo/Ejemplos/01 Basics/Blink.**


 * Descarga el programa sobre la placa Arduino y comprueba el funcionamiento del LED.

Si quieres comprender lo que estás haciendo te recomiento el tutorial de Prometec: Blinkin LED


 * ====**Desafío 1: LED** 3s-1s====
 * Funcionamiento**: modificar en el LED anterior el tiempo de parpadeo a 3 seg encendido y 1 segundo apagado en un ciclo continuo. ||

Tienes que montar sobre la placa de protoboard 2 LEDs con dos resistencias (220 Ω ). Tal y como aparece en la captura. Programa: eso es cosa tuya... ||
 * ====**Desafío 2 Dos LEDs**====
 * Funcionamiento**: ambos LEDs se encienden y apagan en ciclos de 0.5 segundos pero cuando uno luce el otro está apagado y viceversa.
 * [[image:doble_LED.jpg width="286" height="404" caption="Doble LED" link="@file:doble_LED.jpg"]] ||

Práctica 2: Manejar 8 LEDs
Si sabemos manejar dos LEDs, ¿por qué no 8?
 * Funcionamiento**: montamos 8 LEDs en los pines 6-13. Los LEDs se encenderán y apagarán uno a uno secuencialmente desde el 6 hasta el 13. Cuando acaben la secuencia, empezará de nuevo en el 6.

Esta práctica está muy bien explicada en: @http://www.prometec.net/circuito-multiples-leds/

En este ejemplo aprenderás a:
 * crear **variables** para guardar datos.
 * bucle **for** para repetir una secuencia de acciones un número determinado de veces.

Empezamos con el setup. Tenemos que configurar los pines desde el 6 hasta el 13 como pines de SALIDA para los 8 LEDs: code void setup {     pinMode( 6, OUTPUT) ; pinMode( 7, OUTPUT) ; pinMode( 8, OUTPUT) ; pinMode( 9, OUTPUT) ; pinMode(10, OUTPUT) ; pinMode(12, OUTPUT) ; pinMode(13, OUTPUT) ; } code Este código es correcto pero... es demasiado largo. Si nos fijamos se repite siempre lo mismo variando sólo el número del pin. code void setup {       int x = 0 ; // creamos la variable x para almacenar numeros enteros for ( x = 6 ; x < 14 ; x++) { pinMode(x, OUTPUT) ;}
 * Se usan los bucles FOR para acciones que se repiten un numero de veces conocido**. El código, mucho más corto que el anterior, sería así:

} code

Ahora nos queda escribir el código del loop. Recordamos que los LEDs se encenderán y apagarán uno a uno secuencialmente desde el 6 hasta el 13. Cuando acaben la secuencia, empezará de nuevo en el 6. code void loop {             int y = 0 ; // creamos la variable "y" para almacenar numeros enteros for ( y = 6 ; y < 14 ; y++) {                      digitalWrite( y, HIGH) ; delay (250) ; digitalWrite( y, LOW); delay (250) ; }         } code




 * ====**Desafío 3: 8 LEDs inv**====


 * Modificar el código del ejercicio de 8 LEDs para que los leds se enciendan en orden inverso.


 * PISTA: igual que **i++** incrementa de un en uno la variable i, existe **i--** que resta de uno en uno. ||


 * ====**Desafío 4: 8 LEDs vaivén**====
 * Modificar el código del ejercicio de 8 LEDs para que los leds se enciendan y apaguen haciendo una onda hacia la derecha y luego hacia la izquierda en un ciclo continuo.
 * PISTA: Tendrías que usar dos veces el bucle FOR, la primera para contar hacie adelante delde el 6-> 13 y la segunda para contar hacia atrás. ||

Práctica 3: Sensor de luz controla LED
Vamos a hacer que un sensor de luz (**LDR**) controle la frecuencia de parpadeo de un LED. Monta el circuito de la ilustración.



El código sería el siguiente: code void setup { // ponemos el pin 8 como SALIDA para usarlo con un LED pinMode(8, OUTPUT); // inicialización puerto serie a 9600 bps Serial.begin(9600); }

void loop { // creamos una variable para almacenar el valor del sensor int x ; // analogRead lee en el pin A0 el voltaje y lo convierte en un valor entre 0-1023 x = analogRead(A0); // enciende el LED digitalWrite(8, HIGH); delay(x); //retardo de x milisegundos // apaga el LED digitalWrite(8, LOW); delay(x); //retardo de x milisegundos // mostrar el valor de X en el Monitor Serie Serial.println(x); } code
 * Responde a las siguientes preguntas en tu espacio web.**
 * 1.- Completa la siguiente frase: //Cuanta más acerco la mano al sensor de luz, más ___ (rápido / lento)____ parpadeará el LED.//
 * 2.- ¿Qué hace la función **analogRead**? Pista: busca analogRead en @http://www.prometec.net/funciones1/
 * 3.- Rellena la siguiente tabla:
 * < **Haz lo siguiente:** ||< **Valor de luz en el monitor serie** ||
 * < Tapa completamente la luz que llega al sensor LDR ||<  ||
 * < Permite que llegue normalmente la luz al sensor LDR ||<  ||
 * 4.- Además del Pin A0 ¿qué otros pines puede leer analogRead en la placa de arduino uno?

**Practica 4: Theremin**
La LDR puede controlar también un altavoz. Para construirlo partimos del montaje anterior, pero necesitamos cambiar la salida quitando el LED+R y poniendo en su lugar un altavoz o timbre. Tenemos que subir a la placa Arduino un nuevo CÓDIGO según se explica en el tutorial "**El circuito para un Theremin óptico**" --> @http://www.prometec.net/ldrs/




 * CÓDIGO 1**

code int pinAltavoz = 13; //defino pin digital del altavoz void setup {  Serial.begin(9600); pinMode (pinAltavoz, OUTPUT); } void loop {  int sensor = analogRead(A0); //sensor luz 0-1023 //nota = nota musical a reproducir en el altavoz int nota = map (sensor, 0,1023, 50, 1000); tone ( pinAltavoz, nota); Serial.println(sensor); } code ¡No está mal para empezar el código 1! Al acercar la mano al sensor LDR oimos claramente un sonido con frecuencias variando de forma continua. Pero no distinguimos las notas musicales, DO, RE, etc... ¿Podemos mejorar el código? ¡Vamos con el código 2!
 * NO TE OLVIDES DE SUSTITUIR EN LA FUNCIÓN map** los valores 0 y **1023** por los valores **mínimo** y **máximo** que obtuviste en la **tabla del ejercicio 3** de la práctica anterior.

Es mejor que el anterior ya que ahora en el altavoz suenan notas musicales independientes.
 * CÓDIGO 2:**

¡De nuevo **NO TE OLVIDES** de modificar los valores **0 y 1023** como lo hiciste antes! code //creamos una lista con las notas musicales int tono[ ] = {261, 277, 294, 311, 330, 349, 370, 392, 415, 440, 466, 494}; // do, do#, re,  re#, mi,  fa, fa#,  sol, sol#, sol#,la#, si     void setup { pinMode (13, OUTPUT) ; //conectamos el altavoz al pin 13 Serial.begin(9600); //iniciamos el puerto serie }

void loop {           int sensorLuz = analogRead(A0) ;//sensor luz 0-1023 int nota = map (sensorLuz, 0,1023, 0, 11) ; // El array solo tiene 12 notas //el altavoz lo conectamos en el pin 13 tone(13, tono[nota]); delay(300);

//muestra en pantalla el valor de la luz detectada Serial.println(sensorLuz); } code

Busca información en internet... y **responde a las siguientes preguntas en tu espacio WEB**:
 * 1. ¿Qué es un **Theremin**?
 * 2.- ¿Para qué sirve la función **map de arduino**?

**Desafío 5: La cucaracha**
Vamos a tocar la canción de la Cucaracha, usando la función **tone:** Pasos a seguir: **tone(13, 349);** **delay(1500);** 5.- Es mejor crear una variable para cada nota musical, por ejemplo para la nota Do: int Do = 262; y luego usarla con la función tone, así: **tone(7, Do);** **delay(500);**
 * Sólo tienes que conectar un **altavoz** entre el pin **digital 13** y tierra (**GND**)
 * Usa la función **tone (pin, frecuencia)** para generar cada nota de la canción. Explicación:
 * 1) pin = número del pin digital donde se conecta el altavoz
 * 2) frecuencia= valor numérico de la nota musical en Hercios
 * 3) Ejemplo: generar en el pin digital 13 la nota Fa durante 1.5 segundos:
 * Las NOTAS de La Cucaracha:.

do do do fa la do do do fa la fa fa mi mi re re do do do do mi sol do do do mi sol do* re* do* sib la sol fa

do do fa fa la la do* la do* re* do* sib la do* si* sol do do mi mi sol sol si* sol do* re* do* sib la sol fa

do do do fa la do do do fa la fa fa mi mi re re do do do do mi sol do do do mi sol do* re* do* sib la sol fa   do* = do sostenido sib = Si bemol || ** Las notas y sus frecuencias en Hz para la escala nº 3 son:. **

Do : 262 Do#: 277 Re : 294 Re# : 311 Mi : 330 Fa : 349 Fa# : 370 Sol : 392 Sol# : 415 La : 440 La# : 466 Sib : 466 Si : 494 Do4 : 523

significado de #, b : b = bemol ||
 * 1) = sostenido

Práctica 5: Sensor de Ultrasonidos controla LED

 * Sensor HC-SR04 ¿Qué hace?** El sensor emite un pulso muy breve de ultrasonido y, si regresa el pulso rebotado contra algún obstáculo, mide cuanto tiempo ha tardado el pulso en regresar, sumados la ida y vuelta. Conocida la velocidad del sonido 343 m/s es fácil calcular la distancia a la que se encuentra el objeto.




 * Objetivo de la práctica** : Vamos a hacer que un sensor de ultrasonidos (**HC-SR04)** modifique la frecuencia de parpadeo de un LED cuando detecte un obstáculo delante de él.


 * Montaje**

En esta práctica empleamos dos nuevas instrucciones: **if ... else if...**, muy importantes para controlar más adelante el coche robot. Su uso se explica en este tutorial de prometec: http://www.prometec.net/condicionales-botones/, y también el la web oficial de arduino: @https://www.arduino.cc/en/Reference/Else échales un vistazo para comprender el código de esta práctica. code /* LED controlado por sensor ultrasonico HC-SR04 Este sensor mide la distancia a un obstaculo en cm //***************************** //Conexiones del sensor // Vcc = 5V // trigger = 12 // echo = 11 // GND = 0V // led =8 //*****************************



int trigPin = 12; // pin trigger dispara el pulso ultrasonico int echoPin = 11; //pin echo mide el tiempo de rebote del pulso int led = 8; //pin LED

void setup {   Serial.begin (9600); // Inicia la comunicacion con el monitor serie pinMode(trigPin, OUTPUT); pinMode(echoPin, INPUT); pinMode(led, OUTPUT); }

void loop {  long duracion, distancia ; digitalWrite(trigPin, LOW); // apaga el disarador del pulso ultrasonico delayMicroseconds(2); digitalWrite(trigPin, HIGH);    // Inicia el pulso ultrasonico delayMicroseconds(10);        //el pulso dura 10 microsegundos digitalWrite(trigPin, LOW);   // apaga el pulso y espera el echo

duracion = pulseIn(echoPin, HIGH) ; distancia = duracion / 58.28 ; // Si hay rebote del pulso calcula la distancia en cm.    delay(300); //Herramientas -> Serial Monitor para ver distancia Serial.println(String(distancia) + " cm.");

//Según la distancia medida en cm hasta el obstaculo... //Determinamos diferentes frecuencias de parpadeo del LED

if (distancia<5){ digitalWrite ( led, HIGH) ; delay(20); digitalWrite( led, LOW) ; delay(20); } else if (distancia<10){ digitalWrite ( led, HIGH) ; delay(50); digitalWrite( led, LOW) ; delay(50); } else if (distancia<20){ digitalWrite ( led, HIGH) ; delay(100); digitalWrite( led, LOW) ; delay(100); } else if (distancia<30){ digitalWrite ( led, HIGH) ; delay(400); digitalWrite( led, LOW) ; delay(400); } else if (distancia<40){ digitalWrite ( led, HIGH) ; delay(600); digitalWrite( led, LOW) ; delay(600); } else { digitalWrite ( led, HIGH) ; } } //fin del loop

code

Práctica 6: Control de Un Motor con MotorShield v.1
El escudo motor (motor shield en inglés) es una placa fabricada por Ada Fruit que se monta sobre la placa Arduino y permite manejar fácilmente hasta 4 motores DC (eléctricos de corriente continua).




 * Funcionamiento**: vamos a hacer una práctica de manejo básico de un motor: girar hacia adelante durante 2 s, parar 1 s, girar hacia atrás 5 s y parar 1 s, todo en un ciclo continuo.

AYUDA
 * El fabricante del motor shiled v.1 te ofrece ejemplo del control de motores DC.
 * La documentación completa en PDF: motor_shield_v.1.pdf
 * Lee con atención y monta la siguiente práctica: @http://www.prometec.net/motorshieldv1/

**Desafío 6 : Manejo de 2 motores**
En el código del programa que crees, llama a los objetos que controlan los motores, **motor_der** y **motor_izqu**.
 * Intenta gobernar dos motores, el de las ruedas traseras DERECHA e IZQUIERDA del robot de al lado.

Funcionamiento:
 * Mover el coche 2 segundos hacia ADELANTE.
 * PARAR 1 segundo.
 * Mover marcha ATRÁS otros 2 segundos.
 * Girar hacia la DERECHA durante 1 seg.
 * Girar hacia la IZQUIERDA durante 1 seg.
 * PARAR 1 seg. || [[image:robot_arduino.jpg]] ||

**Práctica 7: Diseñar funciones para mover el coche**
Sigue las instrucciones del profesor para manejar el coche usando funciones. Objetivo: mover el coche **como en el ejercicio anterior**, pero usando una función para cada movimiento: ADELANTE, PARA, GIRA_DERECHA, GIRA_IZQUIERDA

Desafío 7: Añadir dos LEDS que se indiquen coche parado y en movimiento.
Sobre el código de la práctica 7, añade dos LEDs uno rojo y otro verde, cada uno con una R= 220 ohmios. LED Rojo: conectado entre tierra y el pin analógico A5, debe encenderse sólo cuando el coche se para. LED Verde: conectado al pin analógico A4, debe encenderse sólo cuando el coche se mueve hacia adelante.
 * Funcionamiento**:

**Desafío 8 final: Sensor de ultrasonidos Maneja coche**
Este desafío supone el final de nuestro recorrido con Arduino: **Hay que conectar a la placa MotorShield dos motores y un sensor de ultrasonidos HC-SR04.** **¡ ¡ ¡ ¡ ¡ ¡ ¡ ¡ SUERTE ! ! ! ! ! !** code // --- // ROBOT-COCHE // DOS MOTORES DC MUEVEN AMBAS RUEDAS TRASERAS // UN SENSOR ULTRASÓNICO MIDE LA DISTANCIA A OBSTÁCULOS. // SI EL COCHE ESTÁ CERCA DE UN OBSTÁCULO DEBE EVITARLO // A VECES EL SENSOR SE QUEDA COLGADO MIDIENDO DISTANCIAS 0, 0, 0, 0 CM, REITERADAMENTE // LO ARREGLAMOS CON INSTRUCCIONES PARA EL DESBLOQUEO METIDAS EN UN BUCLE WHILE // SOLUCION AL 0,0,0,0,0,0,... //When I detect the sensor is stuck, I simply switch echo pin to OUTPUT, //put it into LOW state, and after a while re-set it to INPUT, then cycle again.
 * Conecta el sensor HC-SR04 a los pines según lees en las primeras líneas del código de abajo.
 * Conecta los dos motores de las ruedas DERECHA e IZQUIERDA a la placa escudo motor.
 * Crea el código para que cuando el coche detecte un obstáculo a cierta distancia lo evite.
 * **El coche será tuyo si es capaz de estar 15 segundos moviéndose por el taller sin chocarse.**

//conexiones del sensor HC-SR04 //trigger A1 //echo   A0 //Gnd     tierra (GND) //Vcc    5V // -

//Definicion de constantes y variables usadas const int trigPin = A1; // pin disparo del sensor ultrasonico const int echoPin = A0; // pin echo que recoge el rebote del pulso ultrasonico int intentos = 0;//num de veces que el sensor ultrasónico se cuelga con 0

//AQUÍ INCLUYE LIBRERIA AFMotor.h

//AQUÍ CREA DOS CONTROLADORES PARA LOS DOS MOTORES DERECHO E IZQUIERDO

void setup { Serial.begin(9600); // Open serial monitor at 115200 baud pinMode(trigPin, OUTPUT); pinMode(echoPin, INPUT); //pinMode (led, OUTPUT);

//AQUI PONER LAS VELOCIDADES DE LOS DOS MOTORES

}

void loop { delay(50); //dos variables vamos a definir para el trabajo del sensor ulrasónico //duration = tiempo de duración del pulso ida y vuelta //y range = distancia en cm al obstáculo long duration, range; digitalWrite(trigPin, LOW);  // Resetea el disparador ulstrasónico delayMicroseconds(2);  //damos un tiempo de espera antes de lanzar un pulso digitalWrite(trigPin, HIGH); // Manda EL PULSO delayMicroseconds(10);   //el pulso dura 10 microsegundos digitalWrite(trigPin, LOW); // Deshabilita la transimison de otros pulsos //y espera a que el pin echo recoja el pulso rebotado duration = pulseIn(echoPin, HIGH) ; //mide el tiempo de ida y vuelta del pulso en µs range = duration / 58.28 ; // Calcula la distancia al obstáculo en cm. delay(300); //imprimimos la distancia al obstáculo en el monitor serie Serial.println(String(range) + " cm."); // Tools-->Serial Monitor to see the range

//SI el sensor se cuelga enviando continuos 0 cm, lo solucionamos en el bucle while while (range == 0 && ++intentos < 3); { delay(50);//100 pinMode(echoPin, OUTPUT); digitalWrite(echoPin, LOW); delay(50);//100 pinMode(echoPin, INPUT); motorD.run(RELEASE); motorI.run(RELEASE); }

if (range < 40 && range!=0) { // si el obstáculo está a menos de 40 cm   //&& range!=0 incluirlo dentro del if sólo si el sensor se cuelga con 0,0,0,... //AQUÍ LO QUE HACE EL COCHE SI HAY UN OBSTÁCULO A MENOS DE range (cm)

}//fin del if else { // si no hay ningún obstáculo //AQUÍ LO QUE HACE EL COCHE SI NO HAY OBSTÁCULO DELANTE

}//fin del else }//fin del loop

code


 * Desafío 9 final: Manejo de un servo-motor**


 * ¿Qué es un servo motor?** Es un motor de corriente continua que gira una ángulo fijo entre 0-180º, manteniendo su posición a lo largo del tiempo.

Te muestro como conectar el servo motor a la placa motor-shield v1.
 * ¿Cómo funciona?** Tiene 3 cables:
 * ROJO para +5V (+)
 * NEGRO o MARRÓN para TIERRA (-)
 * AMARILLO para la señal de control (S)
 * ¿Cómo se conecta ?**

code // POSICIONAR EL MOTOR SERVO EN LAS 3 DIRECCIONES // DE FRENTE, A LA DERECHA Y A LA IZQUIERDA SUCESIVAMENTE
 * Código para posicionar el motor a 0 º, 90º y 180º**

Servo mi_siervo; // crea un objeto llamado mi_siervo para controlar el motor
 * 1) include 

void setup { mi_siervo.attach(9);  // el motor servo solo puede conectarse al pin 9 o al 10 }

void loop {   mi_siervo.write(90);              // el servo se coloca mirando hacia EL FRENTE delay(5000);                      // espera 5 s en esa posicion

mi_siervo.write(0);             // el servo se coloca mirando hacia la DERECHA delay(2000);                      // espera 2 s en esa posicion

mi_siervo.write(180);             // el servo se coloca mirando hacia la IZQUIERDA delay(1000);                      // espera 1 s en esa posicion } code Si cargas el código anterior en tu placa Arduino, el servo-motor permanece 5 s mirando de frente, desconecta la pila dentro de ese intervalo de tiempo e inserta el sensor de ultrasonidos en el eje del servo-motor, ayúdate de las aspas de plástico que vienen en la bolsa junto al servo-motor.
 * ¿Cómo fijar el sensor de ultrasonidos al eje del servo motor?**



**3A-B ESPAÑOL Grupos para el coche**
 * ~ Coche ||~ ___Alumnos___ ||~ Notas ||
 * 1 ||  ||   ||
 * 2 ||  ||   ||
 * 3 ||  ||   ||
 * 4 ||  ||   ||
 * 5 ||  ||   ||
 * 6 ||  ||   ||
 * 7 ||  ||   ||

**3C Grupos para el coche** **3D Grupos para el coche**
 * ~ Coche ||~ _Alumnos _ ||~ Notas ||
 * 1 ||  ||   ||
 * 2 ||  ||   ||
 * 3 ||  ||   ||
 * 4 ||  ||   ||
 * 5 ||  ||   ||
 * 6 ||  ||   ||
 * 7 ||  ||   ||
 * 8 ||  ||   ||
 * ~ Coche ||~ ___Alumnos___ ||~ Notas ||
 * 1 ||  ||   ||
 * 2 ||  ||   ||
 * 3 ||  ||   ||
 * 4 ||  ||   ||
 * 5 ||  ||   ||
 * 6 ||  ||   ||
 * 7 ||  ||   ||
 * 8 ||  ||   ||

 //---// ROBOT-COCHE //DOS MOTORES DC MUEVEN AMBAS RUEDAS TRASERAS// UN SENSOR ULTRASÓNICO MIDE LA DISTANCIA A OBSTÁCULOS. //SI EL COCHE ESTÁ CERCA DE UN OBSTÁCULO DEBE EVITARLO// A VECES EL SENSOR SE QUEDA COLGADO MIDIENDO DISTANCIAS 0, 0, 0, 0 CM, REITERADAMENTE //LO ARREGLAMOS CON INSTRUCCIONES PARA EL DESBLOQUEO METIDAS EN UN BUCLE WHILE// SOLUCION AL 0,0,0,0,0,0,... //When I detect the sensor is stuck, I simply switch echo pin to OUTPUT,// put it into LOW state, and after a while re-set it to INPUT, then cycle again.

//conexiones del sensor HC-SR04// trigger A1 //echo A0// Gnd tierra (GND) //Vcc 5V// -

//Definicion de constantes y variables usadas// //const int trigPin = A1;// pin disparo del sensor ultrasonico const int echoPin = A0; //pin echo que recoge el rebote del pulso ultrasonico// //int intentos = 0;//num de veces que el sensor ultrasónico se cuelga con 0

AF_DCMotor motorD(3); //create motor derecha// //AF_DCMotor motorI(1);// create motor izquierda
 * 1) include 

void setup { Serial.begin(9600); //Open serial monitor at 115200 baud// //pinMode(trigPin, OUTPUT);// //pinMode(echoPin, INPUT);// pinMode (led, OUTPUT); motorD.setSpeed(90); //90, set the speed from 0 to 255 90// //motorI.setSpeed(120);// 120,set the speed form 0 to 255 120

}

void loop { delay(50); //dos variables vamos a definir para el trabajo del sensor ulrasónico// duration = tiempo de duración del pulso ida y vuelta //y range = distancia en cm al obstáculo// //long duration, range;// //digitalWrite(trigPin, LOW);// Resetea el disparador ulstrasónico delayMicroseconds(2); //damos un tiempo de espera antes de lanzar un pulso// //digitalWrite(trigPin, HIGH);// Manda EL PULSO delayMicroseconds(10); //el pulso dura 10 microsegundos// //digitalWrite(trigPin, LOW);// Deshabilita la transimison de otros pulsos //y espera a que el pin echo recoja el pulso rebotado// //duration = pulseIn(echoPin, HIGH) ;// mide el tiempo de ida y vuelta del pulso en µs range = duration / 58.28 ; //Calcula la distancia al obstáculo en cm.// //delay(300);// imprimimos la distancia al obstáculo en el monitor serie Serial.println(String(range) + " cm."); //Tools-->Serial Monitor to see the range//

///*// SI el sensor se cuelga enviando continuos 0 cm, lo solucionamos en el bucle while while (range == 0 && ++intentos < 3); { delay(50);//100// //pinMode(echoPin, OUTPUT);// //digitalWrite(echoPin, LOW);// //delay(50);//100 pinMode(echoPin, INPUT); motorD.run(RELEASE); motorI.run(RELEASE); } if (range < 40 && range!=0) { //si el obstáculo está a menos de 25 cm// && range!=0 incluirlo dentro del if sólo si el sensor se cuelga con 0,0,0,... motorD.run(RELEASE); motorI.run(RELEASE); delay(1000); motorD.setSpeed(120); motorI.setSpeed(120); motorD.run(BACKWARD); motorI.run(BACKWARD); delay (500); //giro del coche entre 45-90º aproximadamente// //motorD.setSpeed(90);// //motorI.setSpeed(90);// //motorD.run(BACKWARD);// //motorI.run(RELEASE);// //delay (500);// //motorD.run(RELEASE);// //motorI.run(RELEASE);// //delay(500);// //}//fin del if else { //si no hay ningún obstáculo// //motorD.setSpeed(90);// 90, set the speed from 0 to 255 90 motorI.setSpeed(120); //este motorI nec mayor veloc para que el coche vaya recto.// //motorD.run(FORWARD);// //motorI.run(FORWARD);// //}//fin del else }//fin del loop