Reinicio de Millis Arduino. Arduino retrasa milis y micros para organizar el retraso en el boceto. Ejemplo de retraso con LED parpadeante
Lo primero que encuentra un principiante en el aprendizaje de Arduino es la desagradable propiedad de la función delay(): bloquear la ejecución del programa. Muchos ejemplos en Internet utilizan esta función, pero la aplicación práctica de alguna manera sugiere que es mejor prescindir de ella.
Como corresponde a un principiante, reinventé la rueda e hice mi propia implementación del retardo sin bloqueo. La tarea era así:
- Proporcione pseudomultitarea para que los diferentes eventos ocurran en su propio momento, en sus propios intervalos y no se bloqueen entre sí.
- Fue conveniente usar esto.
- Podría diseñarse como una biblioteca e incluirse fácilmente en otros proyectos sin necesidad de copiar y pegar.
El resultado es este.
#incluir
El método Now() devuelve verdadero si el intervalo ha pasado. En este caso, la cuenta atrás comienza de nuevo en el mismo intervalo. Es decir, Now() se “recarga” automáticamente cada vez.
El clásico parpadeo del LED puede complicarse inmediatamente con dos parpadeos. Por ejemplo, las bombillas conectadas a los pines 12 y 11 deberían parpadear a intervalos de 1 s y 777 ms, respectivamente.
#incluir
Puedes hacer algo más en el bucle; los LED parpadeantes no bloquearán la ejecución de este código.
Está claro que esto no es un reemplazo completo de delay(), que detiene el flujo durante un tiempo determinado; el programa siempre debe escribirse como un FSM (mecanismo de máquina de estados finitos). Es decir, almacenar el estado y, dependiendo de él, desplazarse al lugar deseado del código.
Versión antigua:
Acción1(); retraso(1000); acción2(); retraso(500); acción3(); ...
Nueva opción:
Estado del byte = 0; SmartDelayd(); ... cambiar (estado) (caso 0: acción1(); d.Set(1000000UL); estado=1; descanso; caso 1: if (d.Now()) (acción2(); d.Set(500000UL) ; estado=2; ) romper; caso 2: if (d.Now()) ( acción3(); estado=0; ) romper;
El método Set(interval) establece un nuevo intervalo y devuelve el anterior. Simplemente puedes mirar el intervalo usando el método Get();
Stop() detiene el procesamiento y Now() siempre devuelve falso.
Start() se reanuda y Now() comienza a funcionar normalmente.
Si necesita ralentizar el cálculo del tiempo, pero no detenerlo por completo, existe el método Wait(). Por ejemplo, si el LED 12 parpadea, pero no parpadea cuando se presiona el botón, simplemente agregue el siguiente código a loop() en el ejemplo con dos diodos anteriores:
Si (digitalRead(9)) led12.Wait(); ...
Entonces, con un nivel de señal alto en la pata 9, el diodo en la pata 12 no parpadeará y continuará cuando aparezca 0 allí.
Cuando se dibuja una pantalla usando un “temporizador” de este tipo, por ejemplo, y los botones se procesan en paralelo, puede ser necesario volver a dibujar la pantalla o parte inmediatamente después de presionar el botón, en lugar de esperar al final del intervalo. Para esto se utiliza el método Reset(), después del cual la siguiente llamada a Now() devolverá verdadero. Por ejemplo:
Pantalla SmartDelay (1000000UL); void loop() ( if (btClick()) display.Reset(); // presionó el botón, necesita dibujar la pantalla. if (display.Now()) screenRedraw(); // dibuja la pantalla. )
El único fallo que veo es que no se tiene en cuenta el desbordamiento del contador de microsegundos, pero por lo demás eso sí, hay que limpiar el código. No me gusta cómo se hace Reset(), todavía lo estoy pensando.
Si desea "pausar" el microcontrolador, solo necesita ingresar la instrucción de retardo en el lugar correcto del programa. Pero esto se convierte en un verdadero obstáculo cuando intentas hacer otras cosas, como realizar un seguimiento de los clics en los botones. En este caso, es necesario implementar una especie de multitarea.
Sí, agregará algunas líneas de código a tus programas, pero esto a su vez te convertirá en un programador con más experiencia y aumentará el potencial de tu Arduino. Para hacer esto, solo necesitas aprender a usar la función milis.
Debe entenderse que la función de retardo pausa la ejecución de su programa Arduino, por lo que no puede hacer nada más durante ese período de tiempo. En lugar de pausar todo nuestro programa durante un cierto período de tiempo, aprenderemos a contar cuánto tiempo ha pasado antes de que se complete una acción. Por supuesto, esto se hace usando la función millis() y algunas variables amigas para almacenar nuestros datos. Para que todo sea fácil de entender, comenzaremos con el primer boceto del tutorial llamado “Blink”, pero en este caso haremos parpadear el LED sin demora.
El comienzo de este programa es el mismo que el de cualquier otro programa Arduino estándar. Primero viene la declaración de todas las variables necesarias y líneas de entrada/salida (por ejemplo, línea 13 para el LED). Aquí también necesitamos una variable entera para almacenar el estado actual del LED. Se establecerá en BAJO porque el estado inicial del LED está apagado. Luego declaramos la variable “previousMillis” de tipo “unsigned long”. A diferencia de "int", las variables largas sin signo son de 32 bits, esto es necesario para variables cuyo valor puede llegar a ser muy grande, como el tiempo potencial que podemos esperar hasta que se tomen medidas. La variable anteriorMillis se utilizará para almacenar la hora en que el LED parpadeó por última vez. También hay un tipo “const long”, también es de 32 bits, pero no cambia el valor, es decir, es para constantes (en este caso para la constante de intervalo). Lo configuraremos en 1000 y lo usaremos como tiempo de pausa, medido en milisegundos.
constante int ledPin = 13; // define la salida del LED // Las variables cambiarán: int ledState = LOW; // ledState se utiliza para determinar el estado del LED unsigned long anteriorMillis = 0; // guardará la hora en que se actualizó el LED por última vez // las constantes no cambiarán: const long intervalo = 1000 // intervalo de parpadeo en milisegundos void setup() ( // configurando la línea 13 de salida pinMode(ledPin, OUTPUT) );
Luego entramos en un bucle infinito. Recuerda que en lugar de retraso, queremos contar cuánto tiempo ha pasado desde nuestro último parpadeo, en nuestro caso 1000ms. Si ha pasado el tiempo especificado, es hora de cambiar el estado de nuestro LED.
Primero, estableceremos el "currentMillis" largo sin firmar en "millis()", que especifica la hora actual en milisegundos. Esto nos ayudará a determinar si la diferencia entre la hora actual y la anterior ha superado los 1000 ms. Para hacer esto decimos: "Si el tiempo actual menos la vez anterior que nuestro LED parpadeó es mayor o igual a nuestro valor asignado de 1000 ms, almacene el último tiempo de parpadeo como el anterior". Esto nos ayudará a recordar cuánto tiempo ha pasado desde el último parpadeo en la siguiente ronda del bucle. Luego, si el estado del LED es BAJO, póngalo ALTO; de lo contrario, hágalo BAJO. Luego use el comando digitalWrite para escribir el estado actual en el LED.
void loop() ( unsigned long currentMillis = millis(); if (currentMillis - anteriorMillis >= intervalo) ( // guarda la hora del último cambio en el estado del LED anteriorMillis = actualMillis; // si el LED está apagado, luego enciéndalo y viceversa if (ledState == LOW) ( ledState = HIGH; ) else ( ledState = LOW; ) // salida a LED digitalWrite(ledPin, ledState) )
La función millis() le permite contar el tiempo que ha pasado desde que se inició el programa actual. La función devuelve un valor en formato "largo sin firmar" y le permite contar valores de hasta 50 días desde el momento en que se lanzó el programa. Pasado este tiempo, la cuenta atrás comenzará nuevamente. A continuación se muestra un ejemplo del uso de la función millis():
Sin firmar desde hace mucho tiempo; void setup())( Serial.begin(9600); ) void loop())( Serial.print("A tiempo: "); time = millis(); // recuerda el valor de tiempo Serial.println(time); // envío de información por puerto serie delay(1000);
En el ejemplo anterior, cada segundo, se enviará al monitor del puerto información sobre el tiempo transcurrido desde que se inició el programa. Dado que el tiempo se mide en milisegundos, cada valor posterior diferirá en 1000. La precisión de la lectura depende de la estabilidad del resonador de cuarzo Arduino.
función micros()
La función micros() es análoga a la función millis(), la diferencia radica en la precisión de la medición. Usando la función micros() obtendremos el tiempo transcurrido desde que se inició el programa actual en microsegundos. El contador de microsegundos contado se restablecerá después de 70 minutos. A continuación se muestra un ejemplo del uso de la función micros():
Sin firmar desde hace mucho tiempo; void setup())( Serial.begin(9600); ) void loop())( Serial.print("Tiempo desde el inicio: "); tiempo = micros(); Serial.print(time); Serial.println(" µs "); retraso(1000);
Al igual que en el ejemplo con la función millis(), aquí la información sobre el tiempo medido se enviará al monitor del puerto cada segundo, la única diferencia es que en este caso el tiempo se mide en microsegundos.
función de retraso ()
La función delay() le permite pausar la ejecución del programa actual durante el tiempo especificado en el parámetro. La sintaxis del comando es la siguiente:
//comandos retrasar(500); //retraso 0,5 segundos //comandos retraso(1000); //retraso por 1s
El tiempo se indica en milisegundos (1 segundo = 1000 ms). Este parámetro puede ser del tipo "largo sin firmar", que oscila entre 0 y 4294967295. A continuación se muestra un ejemplo del uso del comando delay():
#define ledPin 13 void setup() ( pinMode(ledPin,13); ) void loop() ( digitalWrite(ledPin,HIGH); //activa el retraso del LED(500); //espera 500 ms (0,5 seg) digitalWrite( ledPin ,BAJO); //apaga el retraso del LED(1000); //espera 1000 ms (1 seg))
En el ejemplo anterior, el LED se enciende durante 0,5 segundos, luego se apaga durante 1 segundo y así sucesivamente hasta que se apaga el Arduino.
Función delayMicrosegundos()
La función delayMicrosegundos() es una variación de la función delay(). La diferencia radica en la cantidad y la precisión del tiempo. La función delay() le permite contar el tiempo con una precisión de 1 milisegundo, mientras que delayMicrosegundos() le permite medir el tiempo con una precisión de 1 microsegundo.
El valor que se puede especificar en el parámetro varía de 0 a 16383. Para intervalos de tiempo más largos, use la función delay() o use delayMicrosegundos() varias veces.
#define outPin 8 void setup() ( pinMode(outPin, OUTPUT); // pin 8 como salida ) void loop() ( digitalWrite(outPin, HIGH); // pin 8 retardo de estado altoMicrosegundos(50); // pausa 50 microsegundos digitalWrite(outPin, LOW); // retardo de estado bajo del pin 8Microsegundos(50); // pausa 50 microsegundos
Este ejemplo genera una onda cuadrada con un período de 100 microsegundos y una tasa de llenado del 50%.
Los retrasos en Arduino juegan un papel muy importante. Sin ellos, incluso el ejemplo más simple de Blink, que hace parpadear un LED después de un período de tiempo determinado, no puede funcionar. Pero la mayoría de los programadores novatos saben poco sobre los retrasos de tiempo y solo usan el retraso de Arduino sin conocer los efectos secundarios de este comando. En este artículo, hablaré en detalle sobre las funciones de temporización y cómo usarlas en el IDE de Arduino.
Hay varios comandos diferentes en Arduino que se encargan de trabajar con el tiempo y las pausas:
- demora()
- retrasoMicrosegundos()
- milisegundos()
- micros()
Se diferencian en precisión y tienen sus propias características que deben tenerse en cuenta al escribir código.
Usando la función de retardo de arduino
Sintaxis
El retardo de Arduino es el comando más simple y lo utilizan con mayor frecuencia los principiantes. Básicamente, es un retraso que pausa el programa durante el número de milisegundos indicado entre paréntesis. (Hay 1000 milisegundos en un segundo). El valor máximo puede ser 4294967295 ms, que equivale aproximadamente a 50 días. Veamos un ejemplo sencillo que muestra claramente cómo funciona este comando.
Void setup() ( pinMode(13, OUTPUT); ) void loop() ( digitalWrite(13, HIGH); // envía una señal alta al pin 13 delay(10000); // pausa 10000ms o 10 segundos digitalWrite13, LOW) ; // envía una señal baja al pin 13 delay(10000); // pausa 10000 ms o 10 segundos)
en método configuración Especificamos que el pin 13 se utilizará como salida. En la parte principal del programa, primero se envía una señal alta al pin, luego hacemos un retraso de 10 segundos. Durante este tiempo, el programa parece estar suspendido. Luego se da una señal baja y nuevamente hay un retraso y todo comienza de nuevo. Como resultado, obtenemos que el pin recibe alternativamente 5 V o 0.
Debe comprender claramente que durante una pausa con retraso, el trabajo del programa se suspende y la aplicación no recibirá ningún dato de los sensores. Ésta es la mayor desventaja de utilizar la función de retardo de Arduino. Puede sortear esta limitación mediante interrupciones, pero hablaremos de esto en un artículo aparte.
Ejemplo de retraso con LED parpadeante
Un circuito de ejemplo para ilustrar cómo funciona la función de retardo.
Puedes construir un circuito con un LED y una resistencia. Luego tendremos un ejemplo estándar: un LED parpadeante. Para hacer esto, debe conectar un LED con un contacto positivo al pin, que designamos como salida. Conectamos la pata libre del LED a tierra mediante una resistencia de 220 Ohmios aproximadamente (un poco más es posible). Puedes determinar la polaridad mirando su interior. La taza grande del interior está conectada al menos y la pierna pequeña al plus. Si su LED es nuevo, puede determinar la polaridad por la longitud de los cables: el tramo largo es positivo y el tramo corto es negativo.
función de retardo de microsegundos
Esta función es un completo análogo del retraso, excepto que sus unidades de medida no son milisegundos, sino microsegundos (en 1 segundo hay 1.000.000 de microsegundos). El valor máximo será 16383, que equivale a 16 milisegundos. La resolución es 4, es decir, el número siempre será múltiplo de cuatro. Un fragmento de ejemplo se vería así:
Escritura digital (2, ALTA); // envía una señal alta al pin 2 delayMicrosegundos(16383); // pausa 16383 µs digitalWrite(2, LOW); // envía una señal baja al pin 2 delayMicrosegundos(16383); // pausa 16383 µs
El problema con delayMicrosegundos es exactamente el mismo que con el retraso: estas funciones "cuelga" completamente el programa y literalmente se congela por un tiempo. En este momento, es imposible trabajar con puertos, leer información de sensores y realizar operaciones matemáticas. Esta opción es adecuada para luces intermitentes, pero los usuarios experimentados no la utilizan para proyectos grandes, ya que allí no se necesitan tales fallas. Por tanto, es mucho mejor utilizar las funciones que se describen a continuación.
Función Millis en lugar de retraso.
La función millis() le permitirá realizar un retardo sin demora en el Arduino, evitando así las deficiencias de los métodos anteriores. El valor máximo del parámetro milis es el mismo que el de la función de retardo (4294967295ms o 50 días).
Usando millis, no detenemos la ejecución de todo el boceto, sino que simplemente indicamos cuánto tiempo el Arduino debe simplemente "omitir" el bloque exacto de código que queremos pausar. A diferencia del delay millis, no detiene nada por sí solo. Este comando simplemente nos devuelve desde el temporizador incorporado en el microcontrolador el número de milisegundos que han transcurrido desde el inicio. Con cada llamada al bucle, nosotros mismos medimos el tiempo que ha pasado desde la última llamada de nuestro código y si la diferencia de tiempo es menor que la pausa deseada, entonces ignoramos el código. Tan pronto como la diferencia sea mayor que la pausa requerida, ejecutamos el código, obtenemos la hora actual usando los mismos milisegundos y la recordamos; esta vez será el nuevo punto de partida. En el siguiente ciclo la cuenta atrás ya será desde el nuevo punto y volveremos a ignorar el código hasta que la nueva diferencia entre milisegundos y nuestro valor previamente guardado alcance nuevamente la pausa deseada.
Retrasar sin demora el uso de millis requiere más código, pero con su ayuda puedes hacer parpadear un LED y pausar un boceto sin detener el sistema.
A continuación se muestra un ejemplo que ilustra claramente el trabajo del equipo:
Tiempo prolongado sin firmar; // Variable para almacenar el punto de referencia void setup() ( Serial.begin(9600); ) void loop() ( /* En este punto comienza la ejecución del análogo delay(). Calcula la diferencia entre el momento actual y el punto de referencia previamente guardado Si la diferencia es mayor que el valor deseado, ejecute el código. Si no, no haga nada */ if (millis() - timing > 10000)( // En lugar de 10000, sustituya el valor de pausa que necesita. = milis(); Serial.println ("10 segundos") ;
Primero introducimos la variable de tiempo, que almacenará la cantidad de milisegundos. Por defecto, el valor de la variable es 0. En la parte principal del programa, verificamos la condición: si el número de milisegundos desde el inicio del microcontrolador menos el número escrito en la variable de sincronización es mayor que 10000, entonces el Se realiza la acción de enviar un mensaje al monitor de puerto y el valor de tiempo actual se escribe en la variable. Como resultado de la operación del programa, el mensaje 10 segundos se mostrará en el monitor del puerto cada 10 segundos. Este método le permite hacer parpadear el LED sin demora.
Los micros funcionan en lugar de retardo.
Esta función también puede realizar un retraso sin utilizar el comando de retraso. Funciona exactamente igual que milisegundos, pero cuenta microsegundos en lugar de milisegundos con una resolución de 4 μs. Su valor máximo es 4294967295 microsegundos o 70 minutos. Si se desborda, el valor simplemente se restablece a 0, no lo olvides.
Resumen
La plataforma Arduino nos proporciona varias formas de implementar un retraso en nuestro proyecto. Usando el retraso, puede pausar rápidamente la ejecución de un boceto, pero al mismo tiempo bloqueará el funcionamiento del microcontrolador. Usar el comando millis te permite hacerlo sin demora en Arduino, pero esto requerirá un poco más de programación. Elija el mejor método dependiendo de la complejidad de su proyecto. Como regla general, en bocetos simples y con un retraso de menos de 10 segundos, se utiliza el retraso. Si la lógica operativa es más compleja y se requiere un gran retraso, entonces es mejor utilizar milisegundos en lugar de retraso.
Hola Andrei. Es muy interesante su enfoque para transferir el conocimiento y la experiencia que ha acumulado. Ayuda mucho en tus emprendimientos. Bueno, yo, empezando a dominar arduino, tengo ganas de progresar. Además, con ayuda externa puedo hacerlo más rápido. Entonces: al principio mi tarea era hacer un robot que se desplazara a lo largo de una línea. Lo hice, todo estuvo bien. Pero además, al brindarle opciones adicionales, no entendí por qué dejó de responder correctamente a la línea. Encontré este artículo y entendí el motivo.
Ahora tengo una pregunta para usted: en el boceto terminado y mencionado a continuación, teniendo en cuenta los problemas con el retraso, ¿tengo que cambiar a milisegundos en todos los lugares donde esté presente esta función? Si es así, ¿tengo entendido que habrá que rehacer casi todo el boceto? ¿Y no está del todo claro cómo utilizar milis para medir distancias? Gracias.
//Robot con función de seguimiento de línea blanca
// **********************Instalación de los cables del motor *********************** *
int MotorLeftSpeed = 5; // VELOCIDAD del motor izquierdo (A) - ENA
int MotorLeftForward = 4; // Motor izquierdo (A) ADELANTE - IN1
int MotorLeftBack = 3; // Motor izquierdo (A) ATRÁS - IN2
int MotorDerechaAdelante = 8; // Motor derecho (B) ADELANTE - IN3
int MotorDerechaVolver = 7; // Motor derecho (B) ATRÁS - IN4
int MotorRightSpeed = 9; // VELOCIDAD del motor derecho (B) - ENB
// **********************Instalación de salidas de sensores ultrasónicos********************* * *
inttrigPinL = 14; // configurando el número de pin del sensor ultrasónico de activación izquierda
int ecoPinL = 15; // configuración del número de salida del sensor ultrasónico de eco izquierdo
inttrigPinC = 10; // configuración del número de salida del sensor ultrasónico de activación central
int ecoPinC = 11; // configuración del número de salida del sensor ultrasónico de eco central
inttrigPinR = 12; // configurando el número de pin del sensor ultrasónico de activación derecha
int ecoPinR = 13; // configuración del número de salida del sensor ultrasónico de eco derecho
// ********************** Instalación de pines del sensor de línea *******************
const int LineSensorLeft = 19; // entrada del sensor de línea izquierda
const int LineSensorRight = 18; // entrada del sensor de línea derecha
ent SL; // estado del sensor izquierdo
int SR; // estado del sensor derecho
// **********************Configuración de la salida de alarma de luz y sonido**************
int Luz = 2; // configurando el número de salida de alarma de luz
intZum = 6; // configurando el número de salida del zumbador
int ledState = BAJO; // establece el estado del LED con esta variable
largo anteriorMillis = 0; // almacena la hora del último cambio de LED
intervalo largo = 300; // intervalo entre encendido/apagado del LED (0,3 segundos)
// **********************Medición de distancia variable mediante sensores***************
unsigned int impulseTimeL=0;
unsigned int impulseTimeC=0;
unsigned int impulseTimeR=0;
dist larga L=0; // distancia medida por el sensor ultrasónico izquierdo
dist largaC=0; // distancia medida por el sensor ultrasónico central
distR larga=0; // distancia medida por el sensor de ultrasonido derecho
// ********************************** CONFIGURACIÓN ************ * *******************
Serie.begin(9600); //iniciar el puerto serie (velocidad 9600)
//*************** Configurar los contactos del motor****************
pinMode(MotorRightBack, SALIDA); // Motor derecho (B) VOLVER
pinMode(MotorDerechoAdelante, SALIDA); // Motor derecho (B) ADELANTE
pinMode(MotorLeftBack, SALIDA); // Motor izquierdo (A) VOLVER
pinMode(MotorLeftForward, SALIDA); // Motor izquierdo (A) ADELANTE
retraso(duración);
//*************** Configurar los contactos del sensor de tira*************
pinMode(LineSensorLeft, ENTRADA); // definiendo el pin del sensor de línea izquierda
pinMode(LineSensorRight, ENTRADA); // determinando el pin del sensor de línea derecha
// ****************Configuración de los modos de salida de los sensores ultrasónicos**********************
pinMode(trigPinL, SALIDA); // configuración del modo de funcionamiento de la salida de activación izquierda del sensor ultrasónico
pinMode(echoPinL, ENTRADA); // configuración del modo de funcionamiento de la salida del sensor ultrasónico de eco izquierdo
pinMode(trigPinC, SALIDA); // configuración del modo de funcionamiento de la salida del sensor ultrasónico de activación central
pinMode(echoPinC, ENTRADA); // configuración del modo de funcionamiento de la salida del sensor ultrasónico de eco central
pinMode(trigPinR, SALIDA); // configuración del modo de funcionamiento de la salida del sensor ultrasónico de activación derecha
pinMode(echoPinR, ENTRADA); // configuración del modo de funcionamiento de la salida del sensor ultrasónico de eco derecho
// ****************Configurar contactos para alarmas luminosas y sonoras*************************** * *****
pinMode(Zumm,SALIDA); // configuración del modo de funcionamiento de la salida del zumbador
pinMode(Luz,SALIDA); // configuración del modo de funcionamiento de la salida de señalización luminosa
// ******************* Comandos básicos de movimiento ******************
anular hacia adelante (int a, int sa) // ADELANTE
analogWrite(MotorRightSpeed, sa);
analogWrite(MotorLeftSpeed, sa);
void right (int b, int sb) // GIRAR A LA DERECHA (un lado)
escritura digital (MotorRightBack, BAJO);
escritura digital (MotorLeftBack, BAJO);
escritura digital (MotorLeftForward, ALTA);
analogWrite(MotorLeftSpeed, sb);
void left (int k, int sk) // GIRAR A LA IZQUIERDA (un lado)
escritura digital (MotorRightBack, BAJO);
escritura digital (MotorDerechaAdelante, ALTA);
analogWrite(MotorRightSpeed, sk);
escritura digital (MotorLeftBack, BAJO);
parada vacía (int f) // DETENER
escritura digital (MotorRightBack, BAJO);
escritura digital (MotorDerechoAdelante, BAJO);
escritura digital (MotorLeftBack, BAJO);
digitalWrite(MotorLeftForward, BAJO);
// *********************************Medida de distancia************* ****** *
void izmdistL () // medición de distancia con el sensor ultrasónico izquierdo
escritura digital (trigPinL, ALTA);
escritura digital (trigPinL, BAJO); // Impulso de 10 mS a la salida de activación del sensor ultrasónico para medir la distancia
impulseTimeL = pulseIn(echoPinL, ALTO); // lectura de la distancia desde el sensor ultrasónico
distL=tiempodeimpulsoL/58; // Convertir a centímetros
void izmdistC () // medición de distancia mediante el sensor ultrasónico central
escritura digital (trigPinC, ALTA);
escritura digital (trigPinC, BAJO); // Impulso de 10 mS a la salida de activación del sensor ultrasónico para medir la distancia
impulseTimeC = pulseIn(echoPinC, ALTO); // lectura de la distancia desde el sensor ultrasónico
distC=tiempodeimpulsoC/58; // Convertir a centímetros
void izmdistR () // medición de distancia mediante el sensor ultrasónico central
escritura digital (trigPinR, ALTA);
escritura digital (trigPinR, BAJO); // Impulso de 10 mS a la salida de activación del sensor ultrasónico para medir la distancia
impulseTimeR = pulseIn(echoPinR, ALTO); // lectura de la distancia desde el sensor ultrasónico
distR=tiempodeimpulsoR/58; // Convertir a centímetros
// *********************************** BUCLE ************ **********************
// ********************** Modo de seguimiento de LINEA *********************** ********* ***
// **********************alarma luminosa y sonora***************
tono(Zumm,900); // enciende el sonido a 900 Hz
tono(Zumm,900); // enciende el sonido a 800 Hz
actualMillis largo sin firmar = millis();
if (currentMillis - anteriorMillis > intervalo) //comprobar si ha pasado el intervalo requerido, si ha pasado entonces
Millisanterior = Millisactual; // guarda la hora del último cambio
if (ledState == LOW) // si el LED no está encendido, enciéndelo y viceversa
estadoled = ALTO;
escritura digital (luz, estado led); // establece los estados de salida para encender o apagar el LED
// *********************** Distancia de medición************************ **
Serial.println(distL);
Serial.println(distC);
Serial.println(distR);
if (distL>50 && distC>50 && distR>50) // si la distancia medida es mayor a 50 centímetros, vamos
SL = digitalRead(LineSensorLeft); // lee la señal del sensor del carril izquierdo
SR = digitalRead(LineSensorRight); // lee la señal del sensor del carril derecho
// ******************************** Siguiendo la línea negra *********** ******* ****
// ROBOT en el carril - sigue recto
if (SL == BAJO & SR == BAJO) // BLANCO - BLANCO - yendo RECTO
adelante (10, 100); // DIRECTO (tiempo, velocidad)
// El ROBOT comienza a salir del carril - rodamos
de lo contrario, si (SL == BAJO y SR == ALTO) // NEGRO - BLANCO - gire a la IZQUIERDA
izquierda (10, 100); // girar a la IZQUIERDA (tiempo, velocidad)
de lo contrario, si (SL == ALTO y SR == BAJO) // BLANCO - NEGRO - gire a la DERECHA
derecha (10, 100); // girar a la DERECHA (tiempo, velocidad)
// FINALIZAR - EL ROBOT ve la raya con ambos sensores
de lo contrario si (SL == ALTO & SR == ALTO) // NEGRO - NEGRO - DETENER
detener (50); // DETENER
de lo contrario // si la distancia medida es menor o igual al mínimo - nos detenemos
Qué hacer si el video no se expande a pantalla completa ¿Por qué no se abre el modo de pantalla completa?
¿Qué significa la palabra "prohibición"?
Arduino retrasa milis y micros para organizar el retraso en el boceto.
Tipos de bolsillo de computadoras y teléfonos inteligentes.
Revisión del teléfono inteligente Huawei U8860 Honor: descripción, especificaciones y reseñas
Revisión de las gafas de realidad virtual Xiaomi Mi VR Glasses Black Opinión del administrador sobre las gafas Xiaomi Mi VR Play
Crear una copia de seguridad de Android Dónde hacer una copia de seguridad de Android