Aprender

Arduino delayMicroseconds(): esperas cortas, medidas

Principiante

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Arduino Uno: un servo controlado por pulsos cronometrados en microsegundosen vivo0.000 s 0.00x
Haz clic para abrirlo en el editor
El deslizador ajusta el ángulo; cada pulso al servo se cronometra con delayMicroseconds().

delayMicroseconds(us) espera esa cantidad de millonésimas de segundo y luego continúa. Úsalo para las esperas cortas y exactas que delay() no puede medir con precisión: el pulso de disparo de 10 µs de un sensor ultrasónico, el pulso de 1 a 2 ms de un servo, los pulsos de paso de un driver de motor a pasos. Para cualquier cosa mayor a unos 16 milisegundos, usa delay(): en un Uno, delayMicroseconds() no puede contar tan alto.

El circuito de arriba es el fader del servo. Presiona Ejecutar y arrastra el deslizador. El servo lo sigue, y el monitor serie imprime cada ángulo, como "fader 1000 -> 175 grados". El código del servo de abajo genera cada pulso con delayMicroseconds(): 544 µs para 0 grados, 2400 µs para 180, cincuenta veces por segundo.

Abajo verás cuánto espera en realidad, el límite y qué pasa al pasarlo, un pulso de servo hecho a mano y los errores que la gente comete con esta función, cada uno ejecutado en un Uno con micros() cronometrándolo.

¿delay() o delayMicroseconds()?

delay() cuenta en milisegundos y delayMicroseconds() en microsegundos, mil veces más pequeño. delay(1) y delayMicroseconds(1000) son ambos un milisegundo: cronometrados con micros(), delay(1) tomó 1020 µs y delayMicroseconds(1000) tomó 1016 µs, el mismo milisegundo con diferencia de un paso de micros(). Ambos detienen el sketch mientras esperan, así que ninguno sirve para hacer dos cosas a la vez. Eso es trabajo para millis().

micros() mismo cuenta en pasos de 4 µs en un Uno de 16 MHz, así que cada tiempo de abajo es múltiplo de 4. Ese es también el paso más fino que puedes medir con él: para cronometrar algo más corto, ejecútalo mil veces y divide, como hacen las esperas cortas de abajo.

Cuánto espera en realidad

Este sketch cronometra siete esperas con micros(). Imprimió "10 us took 16", "100 us took 104", "1000 us took 1016" y "10000 us took 10140". Los microsegundos extra son la llamada misma y micros(). Las esperas más largas salen 1 a 2 por ciento largas porque la interrupción del temporizador que mantiene millis() corriendo se ejecuta cada 1024 µs y la espera no se detiene por ella.

Luego el límite. "16383 us took 16608", y 16384 tomó 16612. 20000 tomó 3668. No es un error de dedo: delayMicroseconds() en un Uno cuenta en un número de 16 bits de cuartos de microsegundo, así que cualquier valor mayor a 16383 se desborda. 20000 es 3616 más allá del límite, así que esperó unos 3.6 ms.

Cronometra siete esperas
void setup() {
  Serial.begin(9600);
  unsigned int waits[] = {10, 100, 1000, 10000, 16383, 16384, 20000};
  for (int i = 0; i < 7; i++) {
    unsigned long start = micros();
    delayMicroseconds(waits[i]);
    unsigned long took = micros() - start;
    Serial.print(waits[i]);
    Serial.print(" us took ");
    Serial.println(took);
  }
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Esperas muy cortas

Por debajo de unos 3 µs la llamada misma toma más que la espera. Este sketch ejecuta cada valor mil veces. 0 tomó 1376 µs en total, 1 tomó 1380 y 2 tomó 1388, luego 3 tomó 3408, 4 tomó 4432 y 5 tomó 5444. Así que 1 y 2 no esperan más que 0 (los pocos microsegundos entre los tres son donde cayó la interrupción del temporizador), y desde 3 en adelante cada llamada es el valor más unos 0.4 µs.

El núcleo de Uno de Mokxi regresa de inmediato para 0, 1 y 2, porque la llamada sola ya toma aproximadamente ese tiempo; el núcleo de Arduino hace lo mismo para 0 y 1. Si necesitas un pulso más corto que unos microsegundos, escribe el registro del puerto directamente en lugar de llamar digitalWrite() y delayMicroseconds().

Mil esperas cortas
void setup() {
  Serial.begin(9600);
  for (int us = 0; us <= 5; us++) {
    unsigned long start = micros();
    for (int i = 0; i < 1000; i++) {
      delayMicroseconds(us);
    }
    Serial.print(us);
    Serial.print(": ");
    Serial.println(micros() - start);
  }
}

void loop() {
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Un pulso de servo a mano

Un servo lee el ancho de un pulso, enviado unas 50 veces por segundo: unos 544 µs para 0 grados y 2400 µs para 180. Este sketch genera el pulso él mismo, sin biblioteca. Con 1500 el servo fue a 94.0 grados. Con 1000 fue a 45.5 y con 2400 a 180.

1472 µs es el punto medio exacto, y eso puso el servo en 91.3 grados, no en 90. El grado extra viene de digitalWrite(): cada llamada toma unos microsegundos, así que el pulso sale unos 12 µs más ancho que el número que escribiste. La biblioteca Servo lo toma en cuenta, y esa es una razón para usarla.

Un pulso de servo sin biblioteca
const int SERVO = 9;

void setup() {
  pinMode(SERVO, OUTPUT);
}

void loop() {
  digitalWrite(SERVO, HIGH);
  delayMicroseconds(1500);  // the pulse: 1.5 ms is about the middle
  digitalWrite(SERVO, LOW);
  delay(20);                // the gap: about 50 pulses a second
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Una onda cuadrada, y por qué sale lenta

Dos esperas de 50 µs deberían producir una onda cuadrada de 10 kHz. Un contador de frecuencia en el pin 9 leyó 8732 Hz. El mismo sketch con esperas de 500 µs leyó 980 Hz en lugar de 1000. La diferencia son los mismos pocos microsegundos de digitalWrite() y loop() en cada media onda, lo cual importa más cuanto más corta es la espera.

Para una frecuencia estable, deja que el hardware lo haga: tone() para sonido y analogWrite() para PWM corren en un temporizador y no se desvían con tu código.

Una onda cuadrada en el pin 9
const int OUT = 9;

void setup() {
  pinMode(OUT, OUTPUT);
}

void loop() {
  digitalWrite(OUT, HIGH);
  delayMicroseconds(50);
  digitalWrite(OUT, LOW);
  delayMicroseconds(50);
}

Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.

Errores comunes

Pasar más de 16383. delayMicroseconds(20000) esperó 3668 µs aquí. Para el hueco de 20 ms entre pulsos de servo, usa delay(20); con delayMicroseconds(20000) el sketch de servo de arriba envió 194 pulsos por segundo en lugar de 46.

Usarlo para cronometrar cosas largas. Un ciclo de mil llamadas a delayMicroseconds(10) tomó 10388 µs, no 10000. Los errores se acumulan; usa micros() para revisar el tiempo en lugar de sumar esperas.

Esperar que 1 µs sea 1 µs. La llamada misma toma más que eso.

Usarlo para hacer dos cosas a la vez. Como delay(), bloquea. Usa millis() o micros() y revisa el tiempo en su lugar.

Abre este circuito en el editor. Arduino Uno: un servo controlado por pulsos cronometrados en microsegundos, cableado como se ejecuta al principio de esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Abrir el circuito

Preguntas

¿Cuál es el valor máximo para delayMicroseconds?

16383 en un Uno de 16 MHz. Los valores más grandes se desbordan: delayMicroseconds(20000) esperó unos 3.6 ms aquí. Usa delay() para cualquier espera mayor de unos 16 ms.

¿Cuál es la diferencia entre delay y delayMicroseconds?

delay() espera en milisegundos y delayMicroseconds() en microsegundos, mil veces menos. delay(1) y delayMicroseconds(1000) esperan ambos alrededor de un milisegundo. Ambas bloquean el sketch mientras esperan.

¿Qué tan preciso es delayMicroseconds?

Dentro de unos pocos microsegundos para esperas cortas: 100 tomó 104 µs aquí. Las esperas largas duran de 1 a 2 por ciento más porque la interrupción del temporizador de millis() sigue corriendo, y las esperas de 1 y 2 µs no toman más de 0.

¿delayMicroseconds bloquea otro código?

Sí. Nada más en loop() corre hasta que regresa, igual que delay(). Las interrupciones siguen funcionando, y por eso las esperas largas salen un poco largas.

Fuentes

De dónde vienen los datos de esta página

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.