Arduino delayMicroseconds(): kısa beklemeler, ölçüldü
Başlangıç
Ya da tüm dersleri gör.
- 526parça tezgahta
- 46kart şu an çalışıyor
- 1.00xgerçek zamanlı, her kartta
delayMicroseconds(us) o kadar saniyenin milyonda biri kadar bekler, sonra devam eder. delay()'nin fazla kaba kaldığı kısa ve kesin beklemeler için kullan: bir ultrasonik sensörün 10 µs'lik tetik darbesi, bir servonun 1 ile 2 ms arası darbesi, bir step sürücüsünün adım darbeleri. Yaklaşık 16 milisaniyeden uzun her şey için onun yerine delay() kullan: Uno'da delayMicroseconds() o kadar yükseğe sayamaz.
Yukarıdaki devre servo fader'dır. Çalıştır'a bas ve slaydırı sürükle. Servo onu izler ve seri monitör her açıyı yazdırır, örneğin "fader 1000 -> 175 degrees". Altındaki servo kodu her darbeyi delayMicroseconds() ile yapar: 0 derece için 544 µs, 180 için 2400 µs, saniyede elli kez.
Aşağıda gerçekte ne kadar beklediği, sınırı ve sınırın ötesinde ne olduğu, elle yapılmış bir servo darbesi ve insanların onunla yaptığı hatalar var; her biri bir Uno'da çalıştırıldı ve micros() ile zamanlandı.
delay() mi delayMicroseconds() mı?
delay() milisaniye cinsinden, delayMicroseconds() ise bin kat küçük olan mikrosaniye cinsinden sayar. delay(1) ve delayMicroseconds(1000) ikisi de bir milisaniyedir: micros() ile zamanlandığında delay(1) 1020 µs, delayMicroseconds(1000) ise 1016 µs sürdü, micros()'un bir adımı içinde aynı milisaniye. İkisi de beklerken kodu durdurur, yani hiçbiri aynı anda iki şey yapmanın bir yolu değildir. O iş millis()'e kalır.
micros() kendi 16 MHz Uno'da 4 µs'lik adımlarla sayar, bu yüzden aşağıdaki her süre 4'ün katıdır. Aynı zamanda onunla ölçebileceğin en ince adım da budur: daha kısa bir şeyi zamanlamak için onu bin kez çalıştır ve böl, aşağıdaki kısa beklemelerde yapıldığı gibi.
Gerçekte ne kadar bekliyor
Bu kod micros() ile yedi bekleme süresini ölçer. "10 us took 16", "100 us took 104", "1000 us took 1016" ve "10000 us took 10140" yazdırdı. Fazladan birkaç mikrosaniye, çağrının kendisi ve micros()'tur. Uzun beklemeler yüzde 1 ila 2 uzun çıkar, çünkü millis()'i ilerleten zamanlayıcı kesmesi her 1024 µs'de bir çalışır ve bekleme ona durmaz.
Şimdi sınır. "16383 us took 16608", ve 16384, 16612 sürdü. 20000 ise 3668 sürdü. Bu yazım hatası değil: Uno'daki delayMicroseconds() 16 bitlik bir çeyrek mikrosaniye sayısıyla sayar, bu yüzden 16383'ü geçen her şey başa sarar. 20000 sınırı 3616 aşar, yani yaklaşık 3.6 ms bekledi.
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() {
}Bu kodu düzenleyicide açSadece kod: düzenleyici, kartı ve koddan okuyabildiği parçaları yerleştirir.
Çok kısa beklemeler
Yaklaşık 3 µs'nin altında çağrının kendisi beklemeden uzun sürer. Bu kod her değeri bin kez çalıştırır. 0 toplam 1376 µs sürdü, 1, 1380 ve 2, 1388 sürdü, sonra 3, 3408, 4, 4432 ve 5, 5444 sürdü. Yani 1 ve 2, 0'dan uzun beklemez (üçü arasındaki birkaç mikrosaniye, zamanlayıcı kesmesinin nereye denk geldiğidir) ve 3'ten yukarıda her çağrı değere yaklaşık 0.4 µs ekler.
Mokxi'nin Uno çekirdeği 0, 1 ve 2 için hemen döner, çünkü çağrının tek başına zaten yaklaşık o kadar sürer; Arduino çekirdeği 0 ve 1 için aynısını yapar. Birkaç mikrosaniyeden kısa bir darbeye ihtiyacın varsa, digitalWrite() ve delayMicroseconds() çağırmak yerine port yazmacına doğrudan yaz.
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() {
}Bu kodu düzenleyicide açSadece kod: düzenleyici, kartı ve koddan okuyabildiği parçaları yerleştirir.
Elle bir servo darbesi
Bir servo, saniyede yaklaşık 50 kez gönderilen bir darbenin genişliğini okur: 0 derece için yaklaşık 544 µs, 180 için 2400 µs. Bu kod, kütüphane olmadan darbeyi kendisi üretir. 1500 ile servo 94.0 dereceye gitti. 1000 ile 45.5'e, 2400 ile 180'e gitti.
1472 µs tam ortadır ve bu, servoyu 90'a değil 91.3 dereceye koydu. Fazladan derece digitalWrite()'ten gelir: her çağrı birkaç mikrosaniye sürer, bu yüzden darbe yazdığın sayıdan yaklaşık 12 µs geniş çıkar. Servo kütüphanesi bunu hesaba katar, ki kullanmanın bir nedeni de budur.
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
}Bu kodu düzenleyicide açSadece kod: düzenleyici, kartı ve koddan okuyabildiği parçaları yerleştirir.
Bir kare dalga ve neden yavaş çıktığı
İki 50 µs'lik bekleme 10 kHz'lik bir kare dalga oluşturmalı. Pin 9'daki bir frekans sayacı 8732 Hz okudu. Aynı kod 500 µs'lik beklemelerle 1000 yerine 980 Hz okudu. Fark, her yarım dalgada digitalWrite() ve loop()'un aynı birkaç mikrosaniyesidir; bekleme ne kadar kısaysa o kadar önemlidir.
Sabit bir frekans için işi donanıma bırak: tone() ses için ve analogWrite() PWM için bir zamanlayıcıda çalışır ve kodunla sürüklenmez.
const int OUT = 9;
void setup() {
pinMode(OUT, OUTPUT);
}
void loop() {
digitalWrite(OUT, HIGH);
delayMicroseconds(50);
digitalWrite(OUT, LOW);
delayMicroseconds(50);
}Bu kodu düzenleyicide açSadece kod: düzenleyici, kartı ve koddan okuyabildiği parçaları yerleştirir.
Sık yapılan hatalar
16383'ten fazla değer geçirmek. delayMicroseconds(20000) burada 3668 µs bekledi. Servo darbeleri arasındaki 20 ms'lik boşluk için delay(20) kullan; delayMicroseconds(20000) ile yukarıdaki servo kodu saniyede 46 yerine 194 darbe gönderdi.
Onu uzun şeyleri zamanlamak için kullanmak. Bin kez delayMicroseconds(10) çağıran bir döngü 10000 değil 10388 µs sürdü. Hatalar birikir; beklemeleri üst üste eklemek yerine zamanı micros() ile kontrol et.
1 µs'nin gerçekten 1 µs olmasını beklemek. Çağrının kendisi bundan uzundur.
Onunla aynı anda iki şey yapmak. delay() gibi engeller. Onun yerine millis() veya micros() kullan ve zamanı kontrol et.
Bu devreyi düzenleyicide aç. Arduino Uno: mikrosaniye cinsinden zamanlanmış darbelerle sürülen bir servo, bu sayfanın üstünde çalıştığı gibi kablolandı. Bir parçayı ya da değeri değiştir ve yeniden çalıştır.
Devreyi açSorular
delayMicroseconds için en yüksek değer nedir?
16 MHz'lik bir Uno'da 16383. Daha büyük değerler başa sarar: delayMicroseconds(20000) burada yaklaşık 3,6 ms bekledi. Yaklaşık 16 ms'den uzun bekleme için delay() kullan.
delay ile delayMicroseconds arasındaki fark nedir?
delay() milisaniye, delayMicroseconds() ise bin kat daha kısa olan mikrosaniye cinsinden bekler. delay(1) ve delayMicroseconds(1000) ikisi de yaklaşık bir milisaniye bekler. İkisi de beklerken kodu durdurur.
delayMicroseconds ne kadar doğru?
Kısa bekleme için birkaç mikrosaniye içinde: 100 burada 104 µs sürdü. Daha uzun bekleme, millis() zamanlayıcı kesmesi çalışmaya devam ettiği için yüzde 1 ila 2 uzun sürer ve 1 ile 2 µs'lik bekleme 0'dan uzun sürmez.
delayMicroseconds diğer kodu engeller mi?
Evet. delay() gibi, dönene kadar loop() içinde başka hiçbir şey çalışmaz. Kesmeler yine de çalışır; uzun beklemelerin biraz uzun çıkmasının sebebi budur.
Devam et
Bu sayfadaki bilgiler nereden geliyor
Bunu gerçekten kur
Düzenleyiciyi aç, bir değeri değiştir ve sayının onunla birlikte değiştiğini izle. Kurulacak bir şey yok, hesaba da gerek yok.