Aprender

Arduino delayMicroseconds(): esperas curtas, medidas

Iniciante

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: um servo movido por pulsos cronometrados em microssegundosao vivo0.000 s 0.00x
Clique para abrir no editor
O slider define o ângulo; cada pulso para o servo é cronometrado com delayMicroseconds().

delayMicroseconds(us) espera essa quantidade de milionésimos de segundo e segue em frente. Use para as esperas curtas e exatas que delay() é grosso demais: o pulso de trigger de 10 µs de um sensor ultrassônico, o pulso de 1 a 2 ms de um servo, os pulsos de passo de um driver de motor de passo. Para qualquer coisa acima de cerca de 16 milissegundos, use delay(): em um Uno, delayMicroseconds() não consegue contar tão alto.

O circuito acima é o fader do servo. Aperte Rodar e arraste o slider. O servo acompanha, e o monitor serial imprime cada ângulo, como "fader 1000 -> 175 graus". O código do servo abaixo faz cada pulso com delayMicroseconds(): 544 µs para 0 graus, 2400 µs para 180, cinquenta vezes por segundo.

Abaixo está quanto ele realmente espera, o limite e o que acontece além dele, um pulso de servo feito à mão, e os erros que as pessoas cometem, cada um rodado em um Uno com micros() cronometrando.

delay() ou delayMicroseconds()

delay() conta em milissegundos e delayMicroseconds() em microssegundos, mil vezes menor. delay(1) e delayMicroseconds(1000) são ambos um milissegundo: cronometrados com micros(), delay(1) levou 1020 µs e delayMicroseconds(1000) levou 1016 µs, o mesmo milissegundo com diferença de um passo de micros(). Ambos param o sketch enquanto esperam, então nenhum deles serve para fazer duas coisas ao mesmo tempo. Isso é trabalho para millis().

O próprio micros() conta em passos de 4 µs em um Uno de 16 MHz, então todo tempo abaixo é múltiplo de 4. Esse também é o passo mais fino que você pode medir com ele: para cronometrar algo mais curto, rode mil vezes e divida, como fazem as esperas curtas abaixo.

Quanto ele realmente espera

Este sketch cronometra sete esperas com micros(). Ele imprimiu "10 us took 16", "100 us took 104", "1000 us took 1016" e "10000 us took 10140". Os microssegundos extras são a própria chamada e o micros(). As esperas mais longas saem 1 a 2 por cento maiores porque a interrupção do timer que mantém o millis() rodando acontece a cada 1024 µs e a espera não para por causa dela.

Agora o limite. "16383 us took 16608", e 16384 levou 16612. 20000 levou 3668. Não é erro de digitação: delayMicroseconds() em um Uno conta em um número de 16 bits de quartos de microssegundo, então tudo acima de 16383 dá a volta. 20000 é 3616 além do limite, então esperou cerca de 3,6 ms.

Cronometre sete 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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Esperas muito curtas

Abaixo de cerca de 3 µs a própria chamada leva mais tempo que a espera. Este sketch roda cada valor mil vezes. 0 levou 1376 µs no total, 1 levou 1380 e 2 levou 1388, depois 3 levou 3408, 4 levou 4432 e 5 levou 5444. Ou seja, 1 e 2 não esperam mais que 0 (os poucos microssegundos entre os três é onde a interrupção do timer caiu), e a partir de 3 cada chamada é o valor mais cerca de 0,4 µs.

O core do Uno do Mokxi retorna imediatamente para 0, 1 e 2, porque a chamada sozinha já leva cerca disso; o core do Arduino faz o mesmo para 0 e 1. Se você precisa de um pulso mais curto que alguns microssegundos, escreva no registrador da porta diretamente em vez de chamar digitalWrite() e delayMicroseconds().

Mil esperas curtas
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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Um pulso de servo à mão

Um servo lê a largura de um pulso, enviado cerca de 50 vezes por segundo: cerca de 544 µs para 0 graus e 2400 µs para 180. Este sketch faz o pulso sozinho, sem biblioteca. Com 1500 o servo foi a 94,0 graus. Com 1000 foi a 45,5 e com 2400 a 180.

1472 µs é o meio exato, e isso deixou o servo em 91,3 graus, não 90. O grau extra vem de digitalWrite(): cada chamada leva alguns microssegundos, então o pulso sai cerca de 12 µs mais largo que o número que você escreveu. A biblioteca Servo compensa isso, e esse é um motivo para usá-la.

Um pulso de servo sem 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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Uma onda quadrada, e por que ela sai lenta

Duas esperas de 50 µs deveriam fazer uma onda quadrada de 10 kHz. Um contador de frequência no pino 9 leu 8732 Hz. O mesmo sketch com esperas de 500 µs leu 980 Hz em vez de 1000. A diferença são os mesmos poucos microssegundos de digitalWrite() e loop() em cada meia onda, o que pesa mais quanto mais curta a espera.

Para uma frequência estável, deixe o hardware fazer: tone() para som e analogWrite() para PWM rodam em um timer e não variam com o seu código.

Uma onda quadrada no pino 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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Erros comuns

Passar mais que 16383. delayMicroseconds(20000) esperou 3668 µs aqui. Para o intervalo de 20 ms entre pulsos de servo, use delay(20); com delayMicroseconds(20000) o sketch de servo acima enviou 194 pulsos por segundo em vez de 46.

Usá-lo para cronometrar coisas longas. Um laço de mil chamadas a delayMicroseconds(10) levou 10388 µs, não 10000. Os erros se acumulam; use micros() para conferir o tempo em vez de somar esperas.

Esperar que 1 µs seja 1 µs. A própria chamada é mais longa que isso.

Usá-lo para fazer duas coisas ao mesmo tempo. Como delay(), ele bloqueia. Use millis() ou micros() e confira o tempo em vez disso.

Abra este circuito no editor. Arduino Uno: um servo movido por pulsos cronometrados em microssegundos, ligado como roda no topo desta página. Troque um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

Qual é o valor máximo para delayMicroseconds?

16383 em um Uno de 16 MHz. Valores maiores fazem wrap: delayMicroseconds(20000) esperou cerca de 3,6 ms aqui. Use delay() para qualquer espera maior que uns 16 ms.

Qual é a diferença entre delay e delayMicroseconds?

delay() espera em milissegundos e delayMicroseconds() em microssegundos, mil vezes mais curto. delay(1) e delayMicroseconds(1000) esperam ambos cerca de um milissegundo. Os dois bloqueiam o sketch enquanto esperam.

Qual é a precisão do delayMicroseconds?

Dentro de alguns microssegundos para esperas curtas: 100 levou 104 µs aqui. Esperas mais longas ficam 1 a 2 por cento maiores porque a interrupção do timer do millis() continua rodando, e esperas de 1 e 2 µs não levam mais que 0.

O delayMicroseconds bloqueia outro código?

Sim. Nada mais em loop() roda até ele retornar, igual a delay(). As interrupções continuam rodando, e é por isso que esperas longas saem um pouco maiores.

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.