Metody synchronizacji Arduino z Millis(): 4 kroki

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:30

W tym artykule przedstawiamy millis(); funkcji i użyj jej do tworzenia różnych przykładów taktowania.

Millis? Nie ma nic wspólnego z synchronizatorami ust… miejmy nadzieję, że rozpoznałeś mili jako numeryczny prefiks dla jednej tysięcznej; czyli pomnożenie jednostki miary przez 0,001 (lub dziesięć do potęgi minus 3).

Co ciekawe, nasze systemy Arduino będą liczyć milisekundy (tysiące sekund) od początku uruchomionego szkicu, aż liczba osiągnie maksymalną liczbę, jaką można zapisać w zmiennej typu unsigned long (32-bitowa [czterobajtowa] liczba całkowita – to waha się od zera do (2 ^ 32)-1, (2 ^ 32)-1, czyli 4294967295 milisekund zamienia się na 49,71027-nieparzyste dni.

Licznik resetuje się po zresetowaniu Arduino, osiągnięciu maksymalnej wartości lub przesłaniu nowego szkicu. Aby uzyskać wartość licznika w określonym momencie, po prostu wywołaj funkcję – na przykład:

start=milli();

Gdzie start jest zmienną typu long bez znaku. Oto bardzo prosty przykład pokazujący działanie millis():

/* demonstracja millis() */

długi start bez znaku, skończony, upłynął;

pusta konfiguracja()

{ Szeregowy.początek(9600); }

pusta pętla()

{ Serial.println("Rozpocznij…"); start=milli(); opóźnienie (1000); skończone=mili(); Serial.println("Zakończono"); upłynęło=zakończono-start; Serial.print(upłynął); Serial.println("milisekundy upłynęły"); Serial.println(); opóźnienie (500); }

Szkic przechowuje aktualną liczbę milisów na początku, a następnie czeka jedną sekundę, a następnie ponownie przechowuje wartość milisów jako ukończone. Na koniec oblicza czas opóźnienia. Na poniższym zrzucie ekranu monitora szeregowego widać, że czas trwania nie zawsze wynosił dokładnie 1000 milisekund, jak pokazano na obrazku.

Krok 1:

Mówiąc prościej, funkcja milis wykorzystuje wewnętrzny licznik w mikrokontrolerze ATmega w sercu Arduino. Ten licznik zwiększa każdy cykl zegara – co dzieje się (w standardowym Arduino i kompatybilnych) z częstotliwością zegara 16 Mhz. Ta prędkość jest kontrolowana przez kryształ na płytce Arduino (srebrna rzecz z wytłoczonym T16.000).

Krok 2:

Dokładność kryształu może się różnić w zależności od temperatury zewnętrznej i tolerancji samego kryształu. To z kolei wpłynie na dokładność wyniku w milisekundach. Anegdotyczne doświadczenia wykazały, że dryf w dokładności pomiaru czasu może wynosić około trzech lub czterech sekund na okres dwudziestu czterech godzin.

Jeśli używasz deski lub własnej wersji, która wykorzystuje rezonator ceramiczny zamiast kryształu, pamiętaj, że nie są one tak dokładne i wprowadzą możliwość wyższych poziomów dryftu. Jeśli potrzebujesz znacznie wyższego poziomu dokładności taktowania, rozważ konkretne układy scalone timera, takie jak Maxim DS3231.

Teraz możemy wykorzystać milis do różnych funkcji czasowych. Jak pokazano na poprzednim przykładzie szkicu, możemy obliczyć upływający czas. Aby rozwinąć ten pomysł, zróbmy prosty stoper. Może to być tak proste lub tak złożone, jak to konieczne, ale w tym przypadku skręcimy w stronę prostych.

Z perspektywy sprzętowej będziemy mieli dwa przyciski – Start i Stop – z rezystorami ściągającymi 10 kΩ podłączonymi odpowiednio do cyfrowych pinów 2 i 3. Gdy użytkownik naciśnie start, szkic zanotuje wartość w milisach – następnie po naciśnięciu stop, szkic ponownie zanotuje wartość w milisach, obliczy i wyświetli upływający czas. Użytkownik może następnie nacisnąć start, aby powtórzyć proces lub zatrzymać, aby uzyskać zaktualizowane dane. Oto szkic:

/* Superpodstawowy stoper używający millis(); */

długi start bez znaku, skończony, upłynął;

pusta konfiguracja()

{ Szeregowy.początek(9600); pinMode(2, WEJŚCIE); // przycisk start pinMode(3, INPUT); // przycisk stop Serial.println("Naciśnij 1, aby uruchomić/zresetować, 2, aby upłynąć"); }

void displayResult()

{ float h, m, s, ms; niepodpisany już dawno; upłynęło=zakończono-start; h=int(upływało/3600000); ponad=upłynął%3600000; m=int(powyżej/60000); ponad=ponad%60000; s=int(powyżej/1000); ms=ponad%1000; Serial.print("Czas, który upłynął: "); Serial.println(upłynął); Serial.print("Czas, który upłynął: "); Serial.print(h, 0); Serial.print("h"); Serial.print(m, 0); Serial.print("m"); Serial.print(s, 0); Serial.print("s"); Serial.print(ms, 0); Serial.println("ms"); Serial.println(); }

pusta pętla()

{ if (digitalRead(2)==HIGH) { start=milis(); opóźnienie(200); // for debounce Serial.println("Rozpoczęto…"); } if (digitalRead(3)==HIGH) { finish=millis(); opóźnienie(200); // dla debounce displayResult(); } }

Wywołania funkcji delay() służą do odbicia przełączników - są one opcjonalne, a ich użycie będzie zależeć od sprzętu. Obraz jest przykładem wyjścia monitora szeregowego szkicu – stoper został uruchomiony, a następnie przycisk dwa wciśnięty sześć razy w różnych okresach czasu.

Krok 3: Prędkościomierz…

Gdybyś miał czujnik na początku i końcu ustalonego dystansu, prędkość można by obliczyć: prędkość = dystans ÷ czas.

Można również wykonać prędkościomierz do ruchu kołowego, na przykład roweru. W tej chwili nie mamy roweru, z którym można by się zadzierać, jednak możemy opisać proces, jak to zrobić – jest to dość proste. (Zastrzeżenie – zrób to na własne ryzyko itp.)

Przede wszystkim przejrzyjmy niezbędną matematykę. Musisz znać obwód koła. Sprzęt – potrzebujesz czujnika. Na przykład – kontaktron i magnes. Rozważ kontaktron jako przycisk normalnie otwarty i podłącz go jak zwykle za pomocą rezystora ściągającego 10 kΩ.

Inni mogą używać czujnika z efektem Halla – każdy z osobna). Pamiętaj z matematyki, aby obliczyć obwód – użyj wzoru: obwód = 2πr gdzie r jest promieniem okręgu.

Teraz, gdy masz obwód koła, tę wartość można uznać za naszą „stałą odległość”, a zatem prędkość można obliczyć, mierząc czas, jaki upłynął między pełnymi obrotem.

Twój czujnik – po zamontowaniu – powinien działać w taki sam sposób, jak normalnie otwarty przycisk, który jest wciskany przy każdym obrocie. Nasz szkic zmierzy czas, jaki upłynął między każdym impulsem z czujnika.

Aby to zrobić, nasz przykład będzie miał wyjście czujnika podłączone do cyfrowego pinu 2 – ponieważ spowoduje to przerwanie w celu obliczenia prędkości. W przeciwnym razie szkic będzie wyświetlał prędkość na normalnym module LCD z interfejsem I2C. Sugerowany jest interfejs I2C, ponieważ wymaga on tylko 4 przewodów z płytki Arduino do LCD – im mniej przewodów, tym lepiej.

Oto szkic do wglądu:

/*Podstawowy prędkościomierz wykorzystujący millis(); */

#include "Wire.h" // dla wyświetlacza LCD magistrali I2C

#include "LiquidCrystal_I2C.h" // dla modułu LCD magistrali I2C - https://bit.ly/m7K5wt LiquidCrystal_I2C lcd(0x27, 16, 2); // ustaw adres LCD na 0x27 dla 16-znakowego i 2-wierszowego wyświetlacza

start pływakowy, zakończony;

upłynął czas, czas; pływak circMetric=1,2; // obwód koła względem pozycji czujnika (w metrach) float circImperial; // używając 1 kilometra = 0,621371192 miles float speedk, speedm; // przechowuje obliczone wartości prędkości w jednostkach metrycznych i imperialnych

pusta konfiguracja()

{ attachInterrupt(0, speedCalc, ROSING); // przerwanie wywoływane, gdy czujniki wysyłają cyfrę 2 w stan wysoki (przy każdym obrocie koła) start=millis(); // konfiguracja LCD lcd.init(); // zainicjuj lcd lcd.backlight(); // włącz podświetlenie LCD lcd.clear(); lcd.println(" Załóż kask! "); opóźnienie(3000); lcd.clear(); Serial.początek(115200); circImperial=circMetric*.62137; // przekonwertuj metrykę na cale do obliczeń MPH }

nieważne obliczanie prędkości()

{ upłynęło=millis()-start; start=milli(); speedk=(3600*circMetric)/upłynął; // km/h speedm=(3600*circImperial)/upływało; // Mile na godzinę }

pusta pętla()

{ lcd.setCursor(0, 0); lcd.print(int(speedk)); lcd.print("km/h"); lcd.print(int(speedm)); lcd.print("MPH"); lcd.setCursor(0, 1); lcd.print(int(upłynął)); lcd.print("ms/rev"); opóźnienie (1000); // dostosuj osobiste preferencje, aby zminimalizować migotanie }

Niewiele się dzieje – za każdym razem, gdy koło wykona jeden obrót, sygnał z czujnika zmieni się z niskiego na wysoki – wywołując przerwanie, które wywołuje funkcję speedCalc().

Pobiera to odczyt millis(), a następnie oblicza różnicę między bieżącym odczytem a poprzednim odczytem – ta wartość staje się czasem do pokonania dystansu (który jest obwodem koła względem czujnika – zapisanym w

pływak circMetric=1,2;

i jest mierzony w metrach). Ostatecznie oblicza prędkość w km/h i MPH. Między przerwami szkic wyświetla zaktualizowane dane prędkości na wyświetlaczu LCD, a także surową wartość czasu dla każdego obrotu dla ciekawości. W prawdziwym życiu nie sądzę, żeby ktokolwiek montował LCD na rowerze, być może wyświetlacz LED byłby bardziej odpowiedni.

W międzyczasie możesz zobaczyć, jak ten przykład działa w poniższym krótkim klipie wideo. Zamiast koła rowerowego i kombinacji przełącznika kontaktronowego/magnesu, podłączyłem wyjście fali prostokątnej z generatora funkcyjnego do pinu przerywającego, aby symulować impulsy z czujnika, dzięki czemu możesz zorientować się, jak to działa.

Krok 4:

To prawie podsumowuje użycie millis() na razie. Jest też micros(); funkcja zliczająca mikrosekundy.

A więc masz to – kolejna praktyczna funkcja, która może pozwolić na rozwiązywanie większej liczby problemów za pośrednictwem świata Arduino. Jak zawsze, teraz od ciebie i twojej wyobraźni zależy znalezienie czegoś do kontrolowania lub dostanie się do innych wybryków.

Ten post został dostarczony przez pmdway.com - wszystko dla producentów i entuzjastów elektroniki, z bezpłatną dostawą na całym świecie.