Menu sterowania prędkością krokową dla Arduino: 6 kroków

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

Ta biblioteka SpeedStepper jest przepisaną biblioteką AccelStepper, aby umożliwić sterowanie prędkością silnika krokowego. Biblioteka SpeedStepper pozwala zmienić ustawioną prędkość silnika, a następnie przyspiesza/zwalnia do nowej ustawionej prędkości przy użyciu tego samego algorytmu, co biblioteka AccelStepper. Biblioteka SpeedStepper pozwala również ustawić limit plus i minus oraz pozycję „domową”. Jest polecenie goHome, aby powrócić do pozycji wyjściowej.

Ograniczenia: Biblioteka SpeedStepper steruje tylko kierunkiem i wyjściami krokowymi, dlatego musi być podłączona do sterownika silnika, takiego jak Easy Driver, aby faktycznie sterować silnikiem krokowym. Biblioteka AccelStepper zapewnia więcej opcji sterowania, które w razie potrzeby można skopiować do tej biblioteki.

Dostarczono trzy przykładowe szkice, z których każdy można uruchomić bez silnika lub sterownika silnika. Szkic speedStepperPlot wydaje przykładowe polecenia prędkości i polecenie goHome oraz generuje wykres prędkości i pozycji wynikowej. Szkic speedStepperSetup zapewnia konfigurację za pomocą menu, aby ustawić położenie początkowe i limity silnika, a następnie uruchomić silnik i dostosować prędkość w górę iw dół oraz goHome, aby zakończyć. Szkic speedStepperProfile przedstawia przykład konfigurowania i wykonywania profilu prędkości.

Chociaż biblioteka AccelStepper zapewnia dobrą kontrolę pozycji, w przypadku Prototype Ice-Melting Probe do zbierania próbek biologicznych w Europie potrzebna była kontrola prędkości. Oto film przedstawiający wcześniejszą wersję prototypu, w której zamiast silnika zastosowano masę. W wersji 1.1 dodano profile prędkości po tym, jak użytkownik zażądał środków do kontrolowania profilu prędkości pompy.

Ta biblioteka działa na Arduino Uno i Mega2560, ale do prototypu użyto większej pamięci/szybszego procesora SparkFun Redboard Turbo.

Ta instrukcja jest również dostępna online w bibliotece Stepper Speed Control Library dla Arduino

Kieszonkowe dzieci

Do uruchomienia przykładowych szkiców potrzebne są tylko Arduino UNO lub Mega2560 i biblioteki oprogramowania

Do testów laboratoryjnych biblioteki użyto SparkFun Redboard Turbo z Easy Driver, 200 kroków/obr, silnikiem krokowym 12V 350mA i zasilaniem 12 DC 2A lub większym, np.. https://www.sparkfun.com/products/14934. Kabel USB A do MicroKabel szeregowy USB do TTLArduino IDE V1.8.9 i komputer, na którym można go uruchomić. Biblioteka SpeedStepperBiblioteka pfodParser dla klas nonBlockingInput i pfodBufferedStreambiblioteka millisDelay dla nieblokujących opóźnień

Krok 1: Funkcje biblioteki

Biblioteka SpeedStepper uruchamia silnik krokowy ograniczony przez granice ustawione przez bibliotekę. Zobacz plik SpeedStepper.h, aby zapoznać się z różnymi dostępnymi metodami bibliotecznymi. Oto zarys logiki, która za nimi stoi.

Pozycja stepera jest śledzona poprzez zliczanie liczby kroków (impulsów). Biblioteka ogranicza pozycję między pozycjami setPlusLimit(int32_t) i setMinusLimit(int32_t). Limit plus jest zawsze >= 0, a limit minus jest zawsze <= 0. Po uruchomieniu pozycja silnika wynosi 0 (dom), a limity są ustawione na bardzo duże liczby +/- (około +/-1e9 kroków). setAcceleration(float) określa, jak szybko silnik będzie zmieniać prędkość w górę lub w dół. Gdy silnik zbliża się do limitu dodatniego lub ujemnego, będzie zwalniał z tą szybkością, aż zatrzyma się na limicie. Przy uruchomieniu przyspieszenie jest ustawione na 1,0 krok/sek./sek. Ustawienie przyspieszenia to zawsze liczba +ve. Znak ustawienia setSpeed(float) określa kierunek ruchu silnika.

setSpeed(float) ustawia prędkość przyspieszania/zwalniania silnika od jego aktualnej prędkości. Prędkość, którą można ustawić poprzez setSpeed(float) jest ograniczona, w wartości bezwzględnej, przez ustawienia, setMaxSpeed(float), domyślnie 1000 kroków/s i setMinSpeed(float), domyślnie 0,003 kroki/s. Te wartości domyślne są również bezwzględnymi, zakodowanymi na stałe ograniczeniami prędkości, które biblioteka zaakceptuje dla setMaxSpeed() i setMinSpeed(). Jeśli chcesz ustawić maksymalną prędkość > 1000 kroków/s, musisz edytować pierwszą linię w pliku SpeedStepper.cpp, aby zmienić maxMaxSpeed(1000) na maksymalną prędkość, którą chcesz. W praktyce maksymalna prędkość jest również ograniczona czasem między wywołaniami metody run() biblioteki. Dla 1000 kroków/s metoda run() musi być wywoływana co najmniej co 1ms. Zobacz sekcję Opóźnienia poniżej.

Próba ustawienia prędkości mniejszej niż prędkość minimalna spowoduje zatrzymanie silnika. Każdy z tych ustawiaczy ma odpowiedni getter, zobacz plik SpeedStepper.h. W przypadku prędkości, getSetSpeed() zwraca prędkość ustawioną za pomocą setSpeed(), podczas gdy getSpeed() zwraca aktualną prędkość silnika, która zmienia się w miarę przyspieszania/hamowania do ustawionej przez Ciebie prędkości. Jeśli silnik nie jedzie w kierunku, w którym myślisz o +ve, możesz wywołać invertDirectionLogic(), aby zamienić kierunek, w którym porusza się silnik na +ve prędkości.

getCurrentPosition() zwraca bieżącą pozycję silnika w porównaniu do „domu” (0). Można nadpisać aktualną pozycję silnika setCurrentPosition(int32_t). Nowa pozycja jest ograniczona do ustalonych limitów plus/minus.

Początkowo silnik jest zatrzymywany w pozycji 0. Wywołanie setSpeed (50.0) spowoduje, że zacznie przyspieszać w kierunku +ve do maksymalnej prędkości 50 kroków/min. Wywołanie hardStop() natychmiast zatrzyma silnik w miejscu, w którym się znajduje. Z drugiej strony wywołanie metody stop() ustawi prędkość na zero i spowolni silnik do zatrzymania. Wywołanie stopAndSetHome() spowoduje natychmiastowe zatrzymanie silnika i ustawienie jego pozycji na 0. Wartości limitów plus/minus nie są zmieniane, ale teraz odnoszą się do nowej pozycji 0 (home). Wywołanie goHome() spowoduje powrót stepera do tej pozycji 0 (home) i zatrzymanie. Wywołanie setSpeed() anuluje powrót do domu.

Biblioteka SpeedStepper zapewnia również kontrolę profilu prędkości za pomocą metod setProfile(SpeedProfileStruct* profileArray, size_t arrayLen), startProfile(), stopProfile(), aby przerwać działający profil, oraz isProfileRunning(). Zobacz przykładowy szkic speedStepperProfile.

Krok 2: Uruchamianie przykładu SpeedStepperPlot bez silnika

Zainstaluj Arduino IDE V1.8.9 Pobierz i zainstaluj bibliotekę SpeedStepper Zapisz SpeedStepper.zip, a następnie użyj pozycji menu Arduino IDE Szkic → Dołącz bibliotekę → Dodaj bibliotekę. ZIP, aby zaimportować bibliotekę Pobierz i zainstaluj również bibliotekę millisDelay

Otwórz przykładowy szkic Przykłady → SpeedStepper → speedStepperPlot (w razie potrzeby uruchom ponownie środowisko IDE). Ten szkic jest skonfigurowany do pracy z Serialem, m.in. UNO i Mega itp. Informacje o bieganiu na SparkFun Redboard Turbo patrz poniżej.

Do uruchomienia tego przykładu nie jest potrzebna płyta sterownicza ani silnik krokowy. Te przykłady wykorzystują D6 i D7 jako wyjścia. Możesz zmienić piny wyjściowe na dowolne wyjście cyfrowe, zmieniając ustawienia STEP_PIN i DIR_PIN w górnej części szkicu.

Prześlij szkic na tablicę, a następnie otwórz Narzędzia → Ploter szeregowy przy 115200 bodach, aby wyświetlić wykres prędkości (CZERWONY) i pozycji (NIEBIESKI) Limit plus jest ustawiony na 360, co powoduje, że prędkość spada do zera od około 100 punktów na osi X. Limit ujemny to -510. Pozycja zatrzymuje się na ~-390, ponieważ żądano prędkości 0,0. W punkcie 380 na osi x wydawana jest komenda goHome, która przywraca stepper do pozycji zerowej.

Ten szkic speedStepperPlot wykorzystuje milisopóźnienia do przełączania w czasie między różnymi prędkościami i przyspieszeniami. W wielu przypadkach użycie SpeedStepperProfile, jak w następnym przykładzie, jest prostsze.

Krok 3: Uruchamianie przykładu SpeedStepperProfile bez silnika

Otwórz przykładowy szkic Przykłady → SpeedStepper → speedStepperPlot, ten szkic tworzy powyższy wykres za pomocą plotera szeregowego Arduino i jest przykładem uruchamiania zalecanego profilu prędkości, na przykład podczas uruchamiania pompy.

Profile prędkości krokowej składają się z tablicy SpeedProfileStruct, która jest zdefiniowana w pliku SpeedStepper.h.

struct SpeedProfileStruct {

prędkość pływania; // prędkość docelowa na końcu tego kroku unsigned long deltaTms; // czas przyspieszenia od prędkości bieżącej (na początku tego kroku) do prędkości docelowej };

Zdefiniuj tablicę SpeedProfileStruct zawierającą docelową prędkość dla każdego kroku i czas deltaTms w mS, aby osiągnąć tę docelową prędkość z poprzedniej docelowej prędkości. Jeśli deltaTms wynosi zero lub jest bardzo mała, prędkość po prostu natychmiast przeskoczy do nowej prędkości docelowej. W przeciwnym razie wymagane przyspieszenie zostanie obliczone. Wywołana zostanie funkcja setAcceleration(), a następnie funkcja setSpeed() dla nowej prędkości docelowej. We wszystkich przypadkach profil będzie ograniczony istniejącymi limitami pozycji plus i minus oraz ustawieniami maksymalnej/minimalnej prędkości. Jeśli chcesz utrzymać prędkość, po prostu powtórz poprzednią prędkość z czasem, w którym chcesz ją utrzymać. Ponieważ nowa prędkość docelowa jest taka sama jak prędkość bieżąca, obliczone przyspieszenie będzie wynosić zero i nie nastąpi żadna zmiana prędkości.

Ta tablica SpeedProfileStruct utworzyła powyższy wykres

const SpeedProfileStruct profile = { { 0, 0}, // zatrzymaj natychmiast, jeśli jeszcze nie zatrzymano { 0, 1000}, // przytrzymaj zero przez 1s { -50, 0}, // przeskocz do -50 { -200, 2000}, // spadek do -200 { -200, 6000}, // zatrzymanie -200 przez 6 sekund { -50, 2000}, // spadek do -50 { 0, 0}, // // zatrzymanie natychmiast { 0, 1500}, //przytrzymaj zero przez 1,5 sekundy { 50, 0}, // skocz do 50 { 200, 2000}, // zwiększ do 200 { 200, 6000}, // przytrzymaj 200 przez 6 s { 50, 2000}, // rampa do 50 { 0, 0}, // // zatrzymaj natychmiast { 0, 1000} // zatrzymaj zero // dla wykreślenia wyjścia }; const size_t PROFILE_LEN = sizeof(profil) / sizeof(SpeedProfileStruct); // oblicz rozmiar tablicy profili

Profil ustawiamy poprzez wywołanie setProfile(SpeedProfileStruct* profileArray, size_t arrayLen) np. stepper.setProfile(profil, PROFIL_LEN);

Po ustawieniu profilu wywołaj startProfile(), aby uruchomić go od bieżącej prędkości silnika (zwykle zaczynasz od zatrzymania). Na końcu profilu silnik będzie kontynuował pracę z ostatnią docelową prędkością. Można wywołać metodę isProfileRunning(), aby sprawdzić, czy profil nadal działa. Jeśli chcesz wcześniej zatrzymać profil, możesz wywołać stopProfile(), co spowoduje porzucenie profilu i zatrzymanie silnika.

Krok 4: Uruchamianie przykładu SpeedStepperSetup bez silnika

Przykładowy szkic jest zaprojektowany jako podstawa dla Twojej własnej aplikacji silnika krokowego. Zapewnia interfejs oparty na menu, który umożliwia przejście do silnika do jego pozycji wyjściowej, jeśli jeszcze tam nie jest, a następnie opcjonalnie zresetowanie limitów plus i minus, a następnie uruchomienie silnika w tym zakresie. Menu „uruchom” umożliwia zwiększanie i zmniejszanie prędkości, zamrożenie przy bieżącej prędkości, zatrzymanie, a także powrót do domu.

Ten szkic ilustruje szereg funkcji oprogramowania, które sprawiają, że funkcja loop() jest responsywna, dzięki czemu można dodawać własne wejścia czujników do sterowania stepperem. Unikanie opóźnień, które zakłócałyby kontrolę prędkości, wymaga trudu. (Zobacz Opóźnienia są złe)

Zainstaluj biblioteki używane do uruchamiania powyższego SpeedStepperPlot, a następnie zainstaluj bibliotekę pfodParser. Biblioteka pfodParser dostarcza klasy NonBlockingInput i pfodBufferedStream, które służą do obsługi wejścia użytkownika i wyjścia menu z blokowaniem uruchamiania loop().

Otwórz Przykłady → SpeedStepper → przykład speedSpeedSetup. Ten szkic jest skonfigurowany do pracy z Serialem, m.in. UNO i Mega itp. Informacje o bieganiu na SparkFun Redboard Turbo patrz poniżej.

Do uruchomienia tego przykładu nie jest potrzebna płyta sterownicza ani silnik krokowy. Te przykłady wykorzystują D6 i D7 jako wyjścia. Możesz zmienić piny wyjściowe na dowolne wyjście cyfrowe, zmieniając ustawienia STEP_PIN i DIR_PIN w górnej części szkicu. Prześlij szkic do tablicy, a następnie otwórz Tools → Serial Monitor at 115200, aby wyświetlić menu SETUP.

SETUP poz:0 sp:0.00 +Lim:500000 -Lim:-500 LATENCY: stepper:492uS loop:0uS p -- set Home l -- set limity h -- goHome r -- run >

Po uruchomieniu szkicu bieżąca pozycja steppera jest traktowana jako pozycja „domowa” (0). Jeśli chcesz ponownie ustawić stepper w jego prawdziwej pozycji „domowej”, wprowadź polecenie p, aby wyświetlić menu SET HOME

SET HOME poz:0 sp:0.00 +Lim:1073741808 -Lim:-1073741808 LATENCY: stepper:752uS loop:3852uS x -- setHome tutaj i wyjście + -- Forward - -- Reverse s -- zamiana Forward/Reverse -- hardStop >

Jak widać, ograniczenia zakodowane w szkicu zostały usunięte, dzięki czemu można zmienić położenie steppera w dowolnym miejscu. Musisz uważać, aby nie przekroczyć fizycznych ograniczeń, bo możesz coś złamać.

Użyj + cmd, aby rozpocząć przesuwanie steppera do przodu, jeśli zauważysz, że porusza się w złym kierunku, wprowadź bez polecenia lub po prostu pustą linię, aby go zatrzymać, a następnie użyj polecenia, aby zamienić kierunek do przodu. Należy zaktualizować szkic, aby uwzględnić w konfiguracji wywołanie invertDirectionLogic(), aby rozwiązać ten problem przy następnym uruchomieniu.

Użyj poleceń +/-, aby ustawić stepper w prawidłowej pozycji zerowej. Silnik uruchamia się powoli, a następnie nabiera prędkości w miarę postępu, wystarczy użyć pustej linii, aby go zatrzymać. Maksymalna prędkość dla tego i menu limitów jest ustawiana przez MAX_SETUP_SPEED na górze setupMenus.cpp.

Gdy silnik zostanie ustawiony w pozycji wyjściowej, użyj x cmd, aby zresetować bieżącą pozycję na 0 i powrócić do menu SETUP.

Jeśli potrzebujesz ustawić limity, zwykle tylko przy początkowej konfiguracji, użyj l cmd, aby wejść do menu SET LIMITS

SET LIMITS poz:0 sp:0.00 +Lim:1073741808 -Lim:-1073741808 LATENCY: stepper:944uS loop:5796uS l -- setLimit tutaj + -- Forward - -- Reverse h -- goHome x -- exit -- hardStop >

Użyj polecenia +, aby przejść dalej do limitu plus, a następnie użyj polecenia l, aby ustawić go jako limit plus. Polecenie h może być następnie użyte do powrotu do 0, a – cmd użyć do przemieszczenia, jeśli cofa się do pozycji silnika na granicy minus. Ponownie użyj polecenia l, aby ustawić limit minusowy. Zwróć uwagę na pozycje limitów plus i minus i zaktualizuj instrukcje setPlusLimit i setMinusLimit metody setup() o te wartości.

Gdy limity są ustawione, użyj x cmd, aby powrócić do menu SETUP, a następnie użyj r cmd, aby otworzyć menu RUN

RUN MENU poz:0 sp:3.31 +Lim:500000 -Lim:-500 LATENCY: stepper:944uS pętla:5796uS + -- Przyspieszenie - -- Przyspieszenie h -- goHome. -- hardStop -- freeze Speed >+ poz:4 sp:9.49 +Lim:500000 -Lim:-500 LATENCY: stepper:792uS loop:5664uS poz:42 sp:29.15 +Lim:500000 -Lim:-500 LATENCY: stepper:792uS loop:5664uS poz:120 sp:49.09 +Lim:500000 -Lim:-500 LATENCY: stepper:792uS loop:5664uS poz:238 sp:69.06 +Lim:500000 -Lim:-500 LATENCY: stepper:792uS loop: 5664us

Polecenie + zaczyna przyspieszać w kierunku do przodu i drukuje pozycję i prędkość co 2 sekundy. Gdy silnik osiągnie żądaną prędkość, możesz zatrzymać przyspieszanie dowolnym innym klawiszem (lub pustym wejściem). Możesz zmniejszyć prędkość, używając – cmd w dół, aby zatrzymać. Jeśli zatrzymany – cmd przyspieszy w odwrotnym kierunku.

To menu URUCHOM zapewnia ręczną kontrolę nad projektem. Do automatycznego sterowania będziesz musiał dodać kilka innych czujników.

Krok 5: Opóźnienie

Sterowanie silnikiem krokowym zależy od oprogramowania sterującego każdym krokiem. Aby utrzymać ustawioną prędkość, szkic musi wywoływać metodę stepper.run() wystarczająco często, aby uruchomić następny krok we właściwym czasie dla bieżącej prędkości. Aby sterować za pomocą czujników, musisz mieć możliwość szybkiego przetwarzania nowych pomiarów. Wydruk pozycji/prędkości obejmuje dwa pomiary LATENCJI, aby umożliwić sprawdzenie, czy szkic jest wystarczająco szybki.

Opóźnienie krokowe (pfodBufferedStream)

Opóźnienie krokowe mierzy maksymalne opóźnienie między kolejnymi wywołaniami metody stepper.run(). Aby uruchomić silnik krokowy z prędkością 1000 kroków na sekundę, opóźnienie krokowe musi być mniejsze niż 1000uS (1mS). Pierwsza wersja tego szkicu miała wiele milisekund opóźnienia. Aby przezwyciężyć to dodatkowe wywołania metody runStepper() (która wywołuje stepper.run()), które zostały dodane w kodzie. Nie rozwiązało to całkowicie problemu, ponieważ instrukcje drukowania menu i wyjścia blokowały szkic, gdy mały bufor Serial Tx był pełny. Aby uniknąć tego blokowania, użyto pfodBufferedStream z biblioteki pfodParser, aby dodać 360-bajtowy wyjściowy bufor wydruku, do którego można szybko zapisywać instrukcje print. Następnie pfodBufferedStream zwalnia bajty z szybkością określoną w tym przypadku 115200. pfodBufferedStream ma opcję blokowania, gdy bufor jest pełny, lub po prostu odrzuca znaki przepełnienia. Tutaj jest ustawione, aby zrzucać dodatkowe znaki, gdy bufor jest pełny, aby szkic nie był blokowany w oczekiwaniu na wysłanie znaków przez Serial.

Opóźnienie pętli (NonBlockingInput)

Opóźnienie pętli mierzy maksymalne opóźnienie między kolejnymi wywołaniami metody loop(). Ustawia to, jak szybko można przetwarzać nowe pomiary czujnika i regulować ustawioną prędkość silnika. To, jak szybko musi być, zależy od tego, co próbujesz kontrolować.

Opóźnienia wynikające z instrukcji print zostały usunięte przy użyciu powyższego pfodBufferedStream, ale aby przetworzyć dane wejściowe użytkownika, należy wziąć tylko pierwszy znak danych wejściowych i zignorować resztę wiersza. Klasa NonBlockingInput w bibliotece pfodParer służy do zwracania niezerowego znaku, gdy jest dane wejściowe, za pomocą readInput() oraz do czyszczenia i odrzucania następujących znaków za pomocą funkcji clearInput(), dopóki żadne znaki nie zostaną odebrane przez 10 ms bez blokowania pętli ()

Oczywiście opóźnienie pętli zostanie zwiększone przez dodatkowy kod, który dodasz, aby odczytać czujniki i obliczyć nową ustawioną prędkość. Wiele bibliotek czujników stosuje tylko opóźnienie (..) między rozpoczęciem pomiaru a pobraniem wyniku. Będziesz musiał przepisać te biblioteki, aby zamiast tego używać millisDelay, aby pobrać pomiar po odpowiednim nieblokującym opóźnieniu.

Krok 6: Uruchamianie SpeedStepperSetup z silnikiem krokowym i SparkFun Redboard Turbo

Aby naprawdę uruchomić szkic SpeedStepperSetup, potrzebujesz silnika krokowego, sterownika i zasilacza, aw tym przykładzie SparkFun Redboard Turbo.

Powyższy schemat połączeń (wersja pdf) przedstawia połączenia. W szkicu SpeedStepperSetup zmień SERIAL define na #define SERIAL Serial1

Silnik krokowy, zasilacz, sterownik i ochrona

Istnieje wiele typów i rozmiarów silników krokowych. Tutaj do testowania używany jest dwucewkowy silnik krokowy 12V 350mA. Do zasilania tego steppera potrzebny jest zasilacz 12V lub większy i większy niż 350mA.

Ta biblioteka zapewnia tylko kierunek i wyjście krokowe, więc potrzebujesz sterownika do połączenia z silnikiem krokowym. Easy Driver i Big Easy Driver kontrolują prąd doprowadzany do cewek silnika, dzięki czemu można bezpiecznie korzystać z zasilacza o wyższym napięciu, na przykład przy użyciu zasilacza 6 V dla silnika 3,3 V. Easy Driver może zasilać od 150mA/cewkę do 700mA/cewkę. W przypadku wyższych prądów, Big Easy Driver może dostarczyć do 2A na cewkę. Przeczytaj często zadawane pytania na dole strony Easy Drive.

Te przykłady wykorzystują D6 i D7 jako wyjścia Krok i Kierunek. Możesz zmienić piny wyjściowe na dowolne wyjście cyfrowe, zmieniając ustawienia STEP_PIN i DIR_PIN w górnej części szkicu.

Programowanie Turbo Sparkfun Redboard

Programowanie Redboard Turbo jest problematyczne. Jeśli program się nie powiedzie, najpierw naciśnij raz przycisk resetowania i ponownie wybierz port COM w menu Arduino Tools i spróbuj ponownie. Jeśli to nie zadziała, naciśnij dwukrotnie przycisk resetowania i spróbuj ponownie.

Podłączanie Easy Driver

Silniki krokowe z dwoma cewkami mają 4 przewody. Za pomocą multimetru znajdź pary, które łączą się z każdą cewką, a następnie podłącz jedną cewkę do zacisków Easy Driver A, a drugą cewkę do zacisku B. Nie ma znaczenia, w którą stronę je okablowasz, ponieważ możesz użyć polecenia s cmd w menu ustawień, aby zamienić kierunek ruchu.

Zasilanie silnika jest podłączone do M+ i GNDSet poziom logiczny płyty z łączem 3/5V. Zewrzyj ze sobą połączenie dla wyjść mikroprocesorowych 3.3V, np. SparkFun Redboard Turbo (jeśli zostawisz otwarte to nadaje się do sygnałów cyfrowych 5V, np. UNO, Mega)Podłącz piny GND, STEP, DIR do GND mikroprocesora i step i piny wyjściowe dir. Żadne inne połączenia nie są konieczne do napędzania silnika.

Kabel szeregowy USB do TTL

Podczas przenoszenia szkicu SpeedStepperSetup z Uno/Mega do Redboard Turbo możesz naiwnie zamienić #define SERIAL Serial na #define SERIAL SerialUSB, aby pasował do połączenia szeregowego USB Redboard Turbo, jednak okaże się, że wynikowe opóźnienie steppera wynosi około 10ms. To 10 razy wolniej niż w przypadku UNO. Wynika to ze sposobu, w jaki procesor Redboard obsługuje połączenie USB. Aby temu zaradzić, podłącz kabel szeregowy USB do TTL do D0/D1 i ustaw #define SERIAL Serial1, aby użyć sprzętowego połączenia szeregowego do sterowania silnikiem krokowym. Użycie Serial1 daje LATENCY: stepper:345uS loop:2016uS, który jest 3 razy szybszy niż UNO dla steppera i pętli latencji

Program terminala

Monitor szeregowy Arduino jest nieco trudniejszy w użyciu do sterowania silnikiem krokowym, ponieważ musisz wprowadzić znak w linii cmd, a następnie nacisnąć Enter, aby go wysłać. Szybszym, bardziej responsywnym sposobem jest otwarcie okna terminala, TeraTerm na PC (lub CoolTerm Mac), podłączonego do portu COM kabla USB do TTL. Następnie w tym oknie naciśnięcie klawisza cmd wysyła go natychmiast. Naciśnięcie Enter wystarczy wysłać pustą linię.

Ustawianie zakresu prędkości silnika

Jak okablowanie powyżej, Easy Drive jest skonfigurowany dla 1/8 kroku, więc 1000 kroków/s spowoduje obrót silnika o 1000/8/200 kroków/obrót = 0,625 obr/s lub maksymalnie 37,5 obr/min. Zmieniając wejścia na MS1/MS2 można przełączać między krokami 1/8, ¼, ½ i pełnymi. Aby wykonać pełne kroki, podłącz MS1 i MS2 do GND. Pozwoli to na osiągnięcie prędkości do 300 obr./min. Wybranie odpowiednich ustawień MS1/MS2 umożliwia dostosowanie do zainstalowanego przełożenia przekładni między silnikiem a napędzaną częścią.

Ochrona sprzętu

Podczas gdy biblioteka SpeedStepper umożliwia ustawienie limitów pozycji dla ruchu silnika, sczepianie pozycji odbywa się poprzez zliczanie kroków wyjściowych przez oprogramowanie. Jeśli silnik zgaśnie, tj. moment obrotowy jest niewystarczający do napędzania silnika w następnym kroku, pozycja oprogramowania nie będzie zsynchronizowana z pozycją silnika. Następnie, gdy użyjesz polecenia „goHome”, silnik przekroczy pozycję wyjściową. Aby zapobiec uszkodzeniu sprzętu, należy zamontować wyłączniki krańcowe na twardych granicach, aby odłączyć zasilanie silnika

Ustawianie limitu prądu silnika

Najpierw ustaw go na najniższe ustawienie potencjometru. tj. napięcie na TP1 jest minimalne. Potencjometr jest delikatny, więc nie wciskaj potencjometru poza mechaniczne ograniczniki. Ustaw silnik na wolną stałą prędkość, a następnie powoli obracaj potencjometr, aż silnik nie przeskoczy ani nie szarpnie się między krokami.

Wniosek

Ten projekt pokazuje, jak wykorzystać bibliotekę SpeedStepper w praktycznym zastosowaniu. Podczas gdy biblioteka AccelStepper zapewnia dobrą kontrolę pozycji, Prototype Ice-Melting Probe for Collecting Biological Samples on Europa potrzebna była kontrola prędkości, więc biblioteka AccelStepper została przepisana, aby zapewnić kontrolę prędkości z ograniczeniami końcowymi i funkcją goHome.