logo elektroda
logo elektroda
X
logo elektroda
Adblock/uBlockOrigin/AdGuard mogą powodować znikanie niektórych postów z powodu nowej reguły.

Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych

andreyatakum 13 Lut 2024 08:31 2481 13
  • Parę lat temu, kiedy planowałem wziąć udział w Kazachstan Solar Challenge, zastanawiałem się nad tym, jak własnoręcznie zrobić sterownik do trójfazowego elektrycznego silnika rowerowego. Po krótkim poszukiwaniu znalazłem interesujący artykuł, który wyjaśnia ten temat dość dokładnie. Postanowiłem przetłumaczyć najciekawsze jego części.

    Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych


    Celem stworzenia takiego kontrolera według autora było badanie działania silnika trójfazowego pod kontrolą sterownika.
    Większość kontrolerów do rowerów elektrycznych dostępnych na rynku to produkty chińskie. Choć są stosunkowo tanie, to jest to swoista czarna skrzynka, w której nie wiadomo, co się dzieje. Od razu pojawia się wiele pytań — czy oszczędnie zużywa i rozprowadza prąd, jaką ma rezerwę mocy, dlaczego tak bardzo się przegrzewa i przedwcześnie uruchamia zabezpieczenie prądowe itp.

    Jednocześnie na rynku można znaleźć wysokiej jakości europejskie sterowniki do rowerów elektrycznych. Wyposażone są w zaawansowane funkcje, działają przy różnych napięciach i prądach oraz można je programować. Instaluje się je w rowerach elektrycznych o dużej wytrzymałości. Jednak ich cena jest wysoka.

    Zostaje jedyna opcja — opracować projekt kontrolera, wykonać prototyp, a następnie stworzyć produkt lepszy od chińskiego.

    Rowery elektryczne wykorzystują trójfazowe bezszczotkowe silniki elektryczne z czujnikami Halla. Warto zauważyć, że zastosowanie takich napędów jest dość szerokie.

    Aby opracować sterownik, konieczne jest zrozumienie zasady działania samego silnika elektrycznego.

    Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych


    Składa się on z uzwojeń fazowych, magnesów i czujników Halla, które monitorują położenie wału.
    Strukturalnie silniki elektryczne dzielą się na dwa typy: inrunnery i outrunnery.
    W inrunnerze wirnik jest w środku, płytki magnetyczne są przymocowane na wale, a uzwojenia znajdują się na bębnie (stojanie). W tym przypadku napędzany jest wał. W kwestii outrunnera jest odwrotnie: na wale są uzwojenia, a w bębnie — płytki magnetyczne. W ten sposób napędzany jest bęben.

    Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych


    Ponieważ koło roweru jest przymocowane do ramy za pomocą wału, zastosowano tutaj typ outrunner.

    Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych



    To zdjęcie tradycyjnie przedstawia trzy fazy z połączonymi ze sobą uzwojeniami. W rzeczywistości uzwojeń jest znacznie więcej, są one równomiernie rozmieszczone, z przemiennymi fazami na obwodzie silnika. Im więcej zwojów, tym płynniej, wyraźniej i bardziej elastycznie pracuje silnik.
    Są w nim zamontowane trzy czujniki Halla. Reagują one na pole magnetyczne, określając w ten sposób położenie wirnika względem stojana silnika. Instalowane w odstępach co 60 lub 120 stopni elektrycznych. Stopnie te odnoszą się do rotacji fazy elektrycznej silnika. Należy wziąć pod uwagę, że im więcej uzwojeń na fazę, tym więcej obrotów elektrycznych następuje podczas jednego fizycznego obrotu koła silnika.

    Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych



    Uzwojenia trzech faz w większości przypadków są połączone ze sobą według dwóch obwodów: gwiazdy i trójkąta. W pierwszym przypadku prąd przepływa z jednej fazy do drugiej, w odmiennym – w różnym stopniu przez wszystkie trzy fazy. Czasami te dwa schematy połączeń są łączone w jednym silniku, na przykład w pojazdach elektrycznych. Podczas uruchamiania i przyspieszania fazy są połączone gwiazdą: daje to większy moment obrotowy przy stosunkowo niskich prędkościach. Następnie po osiągnięciu wystarczającej szybkości ma miejsce przełączenie w trójkąt. W efekcie liczba obrotów wzrasta, gdy wysoki moment obrotowy nie jest już potrzebny. W istocie okazuje się, że jest to warunkowo automatyczna skrzynia biegów silnika elektrycznego.
    Aby napędzać silnik trójfazowy, należy wziąć pod uwagę jego cykl pracy na obrót elektryczny. Mamy więc trzy fazy — A, B, C. Każda z nich otrzymuje w pewnym momencie dodatnią i ujemną polaryzację. Alternatywnie, stopniowo, prąd przepływa od: „plusa” jednej fazy do: „minusa” drugiej. Daje to sześć kroków = trzy fazy × dwie polaryzacje.
    A+, A–, B+, B–, C+, C–.

    Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych



    Przyjrzyjmy się tym sześciu etapom cyklu. Załóżmy, że w punkcie pierwszym ustawione jest położenie wirnika, z czujników Halla otrzymamy więc kod w postaci 101, gdzie 1 to faza A, 0 to faza B, 1 to faza C. Po ustaleniu wału na podstawie kodu musimy przyłożyć prąd do odpowiednich faz o podanych polaryzacjach. W rezultacie wał się obraca, czujniki odczytują kod nowego położenia wału itp.
    Tabela pokazuje kody czujników i zmiany kombinacji faz dla większości silników elektrycznych. Aby odwrócić ruch koła, wystarczy odwrócić znaki polaryzacji faz. Cykl silnika przedstawiony jest w animacji GIF.

    Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych



    Tranzystory i mostek H

    Aby jednak naprzemiennie dostarczać prąd do każdej z faz i zmieniać ich polaryzację, niezbędne są tranzystory. Potrzebujemy również przesyłu dużych: prądów i prędkości przełączania oraz wyraźnego otwierania/zamykania bram. W takim przypadku wygodniej jest sterować bramkami napięciem, a nie prądem. Dlatego optymalne są tranzystory polowe (MOSFET).
    Aby przełączyć fazy i zmienić ich polaryzację, użyto klasycznego obwodu H-Bridge z tranzystorów polowych.

    Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych



    Składa się on z trzech par tranzystorów. Każda z nich jest podłączona do odpowiedniej fazy cewki silnika i dostarcza prąd o wartości (+ lub –). Tranzystory odpowiedzialne za włączenie fazy o wartości dodatniej nazywane są przełącznikami górnymi. Z negatywnymi — niższymi. Dla każdego kroku otwierana jest para kluczy: górny dla jednej fazy i dolny dla sąsiedniej. W rezultacie prąd przepływa z jednej fazy do drugiej i napędza silnik elektryczny.

    Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych



    Ze schematu jasno wynika, że ​​nie możemy jednocześnie włączyć górnego i dolnego przełącznika w tej samej fazie: nastąpi zwarcie. Dlatego bardzo ważne jest szybkie przełączenie górnego i dolnego klucza, aby podczas procesów przejściowych nie mogło ono zaistnieć. Im lepiej i szybciej zapewnimy przełączanie, tym mniej będziemy mieli strat i nagrzewania/przegrzania tranzystorów z mostkiem H.

    Na początek pozostaje kontrolować bramy mostka H. Do sterowania potrzeba:
    * Odczytać dane z czujnika Halla;
    * Określić, w jakiej pozycji i która para kluczy powinna być włączona;
    * Przesłać sygnały do ​​odpowiednich bramek tranzystorów.

    Prototyp na Arduino

    Wydaje się, że najłatwiejszy sposób to zbudować kontroler na podstawie Arduino UNO.

    Przede wszystkim należy zasilić czujniki Halla napięciem 5 V z Arduino (to powinno wystarczyć). Przewody sygnałowe z nich są podłączone do pinów cyfrowych Arduino. Napisano też prosty program do odczytu i przetwarzania sygnałów z czujników.

    //Piny mostków 
    const int TRAplus = 8;
    const int TRAminus = 9;
    const int TRBplus = 10;
    const int TRBminus = 11;
    const int TRCplus = 12;
    const int TRCminus = 13;
    
    //czujniki Halla
    const int HallA = 3;
    const int HallB = 1;
    const int HallC = 0;
    
    boolean vala;
    boolean valb;
    boolean valc;
    
    boolean pvala;
    boolean pvalb;
    boolean pvalc;
    
    int pHall;
    
    int turns;
    
    void setup() {
      //Podłączenie pinów na wyjście 
      pinMode(TRAplus, OUTPUT);
      pinMode(TRAminus, OUTPUT);
      pinMode(TRBplus, OUTPUT);
      pinMode(TRBminus, OUTPUT);
      pinMode(TRCplus, OUTPUT);
      pinMode(TRCminus, OUTPUT);
      //Odesłać dane do portu szeregowego   
      Serial.begin(9600); 
    }
    
    void loop() {
      //Odczytujemy dane z czujników Halla i zapisujemy te wartości do val
      vala = digitalRead(HallA);
      valb = digitalRead(HallB);
      valc = digitalRead(HallC);
    
    //Licznik obrotów koła. Potrzebuje dopasowania
    
      if(vala && !pvala) {
        if(pHall == HallC) // lub HallB dla obrotów wstecz
          turns++;
        pHall = HallA;
      }
      if(valb && !pvalb) {
        if(pHall == HallA) // lub HallC dla obrotów wstecz
          turns++;
        pHall = HallB;
      }
      if(valc && !pvalc) {
        if(pHall == HallB) // lub HallA dla obrotów wstecz
          turns++;
        pHall = HallC;
      }
    
      digitalWrite(TRAplus,  (vala && !valb) ? HIGH : LOW); //jeśli vala==HIGH oraz valb==LOW, zapisujemy HIGH, 
    w przeciwnym przypadku LOW
      digitalWrite(TRAminus, (valb && !vala) ? HIGH : LOW);
      digitalWrite(TRBplus,  (valb && !valc) ? HIGH : LOW);
      digitalWrite(TRBminus, (valc && !valb) ? HIGH : LOW);
      digitalWrite(TRCplus,  (valc && !vala) ? HIGH : LOW);
      digitalWrite(TRCminus, (vala && !valc) ? HIGH : LOW);
    
      pvala = vala;
      pvalb = valb;
      pvalc = valc;
    
      Serial.print(vala);
      Serial.print(valb);
      Serial.println(valc);
    
      //Serial.println(turns/3);
    
    }


    Następnie należy zmontować mostek H z tranzystorów polowych NPN. Do mostka podpinamy niezależny zasilacz 12 V. Jednak podczas debugowania, aby upewnić się, że działa, bezpośrednio podłączamy sześć pinów 5 V z Arduino do bramek mostka H. Większość tranzystorów MOSFET ma bramkę operującą przy napięciu 20 woltów. Więc takie rozwiązanie nie jest dobre, ponieważ mostek H nie będzie działał prawidłowo i się przegrzeje. Jednak w przypadku testów krótkoterminowych wystarczy. Przy silnym przegrzaniu i strasznych dźwiękach, wibracjach i wstrząsach koło zaczęło się powoli kręcić. Początek jest zrobiony.

    Sterowniki mostków

    Teraz trzeba opracować sposób, ażeby zapewnić napięcie 20 V do sterowania bramkami. Istnieją do tego sterowniki tranzystorów mostkowych, które gwarantują stabilne impulsy 20 V i dużą prędkość reakcji. Na początku autor konstrukcji miał popularne sterowniki do silników małej mocy L293D.

    Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych



    Są wystarczające do sterowania bramkami, a ponadto bardzo proste w obsłudze. Jeden taki sterownik może zasilać dwie pary kluczy. Więc trzeba stosować dwie sztuki L293D. Po zamontowaniu ich na kontrolerze, koło zaczęło się obracać znacznie płynniej. Było też mniej obcych dźwięków, a nagrzewanie się tranzystorów zmalało. Jednak wraz ze wzrostem prędkości zniknęła synchronizacja ze sterownikiem, pojawił się obcy dźwięk, koło drgnęło, zawibrowało i całkowicie się zatrzymało.

    Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych
    HIP4086


    Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych
    IR2101


    Jeśli chodzi o HIP4086, jest to pełnoprawny sterownik bramki mostkowej przeznaczony do trójfazowego silnika elektrycznego. Wydaje się to trochę zagmatwane, a próby użycia go w kontrolerze zakończyły się niepowodzeniem: u autora to nigdy nie zadziałało.
    Lepsze wyniki pokazał IR2101 — sterownik półmostkowy, który zapewnia działanie dolnego i górnego przełącznika dla jednej fazy. Potrzebne są trzy takowe. Swoją drogą sterownik jest bardzo prosty w obsłudze, podłączenie go jest łatwe. Rezultatem jest następujący diagram:

    Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych


    Zostaje zamontować kontroler z tym sterownikiem i uruchomić silnik. Jego praca nie zmieniła się radykalnie, objawy pozostają takie same, jak w przypadku L293D.

    Przerwanie sprzętowe

    Jak się okazało, Arduino nie ma czasu na przetwarzanie odczytów czujników Halla! Dlatego konieczne było zastosowanie pinów Arduino z przerwaniem sprzętowym. Ponieważ Arduino UNO ma tylko dwa takie piny, a na czujniki potrzebne są trzy, trzeba wziąć Arduino Leonardo lub Megę Neo, gdzie są cztery.

    Po przepisaniu programu na przerwania i podłączeniu Megi, zamiast UNO, autor powtórzył testy.

    //Piny mostków
    const int TAH = 8; //T — tranzystor, А — faza (niebieska), Н — górny półmostek
    const int TAL = 9; //T — tranzystor, А — faza (niebieska), L — dolny półmostek
    const int TBH = 10; //T — tranzystor, B — faza (zielona), H — górny półmostek
    const int TBL = 11; //T — tranzystor, B — faza (zielona), L — dolny półmostek
    const int TCH = 12; //T — tranzystor, C — faza (żółta), H — górny półmostek
    const int TCL = 13; //T — tranzystor, C — faza (żółta), L — dolny półmostek //------------------------------------------------------------------------------------------------
    //czujniki Halla
    int HallA = 3; //pin 1 (z przerwaniem)
    int HallB = 1; //pin 2 (z przerwaniem)
    int HallC = 0; //pin 3 (z przerwaniem)
    //------------------------------------------------------------------------------------------------
    volatile boolean vala;
    volatile boolean valb;
    volatile boolean valc;
    //------------------------------------------------------------------------------------------------
    void setup() {  
        //Instalowanie kluczowych pinów dla wyjścia
        pinMode(TAH, OUTPUT);
        pinMode(TAL, OUTPUT);
        pinMode(TBH, OUTPUT);
        pinMode(TBL, OUTPUT);
        pinMode(TCH, OUTPUT);
        pinMode(TCL, OUTPUT);
        //Odczyt danych z czujników Halla
        vala = digitalRead(HallA);
        valb = digitalRead(HallB);
        valc = digitalRead(HallC);
    
        //Przerwanie sprzętowe na pinach czujnika Halla
        attachInterrupt (digitalPinToInterrupt(HallA), changeA, CHANGE);
        attachInterrupt (digitalPinToInterrupt(HallB), changeB, CHANGE);
        attachInterrupt (digitalPinToInterrupt(HallC), changeC, CHANGE);
        //LOW powoduje przerwanie, gdy port jest w stanie LOW
         //CHANGE przerwanie jest wywoływane, gdy wartość na porcie zmienia się z LOW na HIGH i odwrotnie
         //Przerwanie RISING jest wywoływane tylko wtedy, gdy wartość na porcie zmieni się z LOW na HIGH
         //Przerwanie FALLING jest wywoływane tylko wtedy, gdy wartość na porcie zmieni się z HIGH na LOW
    }
    void Fases() {
        digitalWrite(TAH,  (vala && !valb) ? HIGH : LOW);
        digitalWrite(TAL, (valb && !vala) ? HIGH : LOW);
        digitalWrite(TBH,  (valb && !valc) ? HIGH : LOW);
        digitalWrite(TBL, (valc && !valb) ? HIGH : LOW);
        digitalWrite(TCH,  (valc && !vala) ? HIGH : LOW);
        digitalWrite(TCL, (vala && !valc) ? HIGH : LOW);
    
    void changeA() {
        vala = digitalRead(HallA); 
        Fases();
    }
    void changeB() {
        valb = digitalRead(HallB);  
        Fases();
    }
    void changeC() {
        valc = digitalRead(HallC); 
        Fases();
    }
    
    void loop() {
    }
    


    Koło w końcu zaczęło działać płynnie, bez wibracji i hałasu, idealnie nabierając prędkości, bez rozsynchronizowania. Prototyp okazał się wykonalny. Jednak nie jest to jeszcze pełnoprawny kontroler, ponieważ nie miał zabezpieczeń i wysokiej jakości sygnału PWM.


    Prototyp oparty na chipie MC33035

    Alternatywną opcją kontrolera na Arduino może być układ scalony MC33035. Zaprojektowany specjalnie do wydajnych silników trójfazowych.
    Ten scalak:
    Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych


    Odpowiedzialny za całą logiczną część sterownika:
    * Odczytuje dane z czujników Halla;
    * Definiuje pozycje wałów;
    * Dostarcza sygnały dla bramek mostka H do ich sterowników;
    * Ma możliwość podłączenia wskaźnika błędu, przegrzania;
    * Przetwarza i przesyła sygnał PWM (PWM);
    * Wykonuje bieg wsteczny (odwrotny ruch koła).


    Krótko mówiąc, układ scalony zawiera wszystko, co niezbędne do sterowania silnikiem elektrycznym. Aby zbudować na jego podstawie pełnoprawny kontroler, jest potrzebny układ MC33035, sterowniki półmostkowe i mostka H wykonanego z tranzystorów polowych. Po zmontowaniu kontrolera na tym chipie działa on świetnie, stabilnie, koło kręci się, jak należy przy różnych prędkościach. Jednak funkcjonalność scalaka jest ograniczona, jeśli trzeba dodać wielorakie funkcje. Do wyświetlania prędkości, licznika kilometrów, zużycia baterii znowu konieczne jest dodatkowe podłączenie Arduino lub czegoś podobnego.

    Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych
    Obwód z MC33035.


    Konkluzja

    Główną zaletą kontrolera opartego na MC33035 jest łatwość obsługi. Wystarczy kupić układ scalony, złożyć mostek H, przylutować wszystko do płytki z odrobiną okablowania i sterownik gotowy. Jeśli potrzebujesz tylko uruchomić silnik sygnałem PWM i sterować nim, jest to najlepsza opcja.
    Kontroler oparty na Arduino to bardziej skomplikowane rozwiązanie. Należy napisać logikę i zapewnić dodatkową ochronę kontrolera. Jednak w przypadku eksperymentów, prototypów, dodatkowej funkcjonalności i stosowania różnych trybów pracy silnika jest to odpowiednia decyzja.

    Źródło: https://habr.com/ru/companies/vk/articles/373397/
    Autor: Makarenko, https://habr.com/ru/users/makarenko/

    Fajne? Ranking DIY
    O autorze
    andreyatakum
    Poziom 13  
    Offline 
    Elektronik, podróżnik, dziennikarz niezależny
    Specjalizuje się w: komunikacja bezprzewodowa
    andreyatakum napisał 471 postów o ocenie 590. Mieszka w mieście Antalya. Jest z nami od 2021 roku.
  • #2 20959786
    Block3r
    Poziom 14  
    Szkoda, że autor nie pokusił się o sterowanie wektorowe, które wcale nie jest ciężkim konceptem, a w takich zastosowaniach byłoby idealne. Do Arduino są nawet gotowe biblioteki, na najnowszym R4 działałoby świetnie, bo ma już FPU.
  • #3 20959849
    andreyatakum
    Poziom 13  
    Block3r napisał:
    Szkoda, że autor nie pokusił się o sterowanie wektorowe,

    Sprawdzę kolejne artykuły tego autora. Może być jest coś nowego. To był tylko początek....
  • #4 20960827
    krru
    Poziom 33  
    Kod: C / C++
    Zaloguj się, aby zobaczyć kod


    Już w tym fragmencie (dopisałem brakującą klamerkę) widać pewną nieścisłość. Wcześniej było wspomniane by nie włączać jednocześnie górnego i dolnego tranzystora jednej fazy. Ten kod tego nie gwarantuje - oczywiście chwilowo. Przecież te digitalWrite wykonują się kolejno i tym samym pomiędzy kolejnymi zapisami mogą wystąpić zwarcia. Trzeba by wcześniej wyłączyć oba tranzystory danej fazy i potem ustawić nowy stan. Jeśli wszystkie tranzystory są sterowane pinami jednego portu można też zrezygnować z funkcji Arduino i sterować bezpośrednio całym portem ustawiając wszystkie sygnały jednym zapisem.
  • #5 20963091
    __Maciek__
    Poziom 20  
    Sterowanie silnikiem BLDC jest proste i jednoczenie nie jest ...
    Jest - bo niewiele trzeba i będzie działał,
    Nie jest - bo kultura pracy wymaga bardziej złożonych algorytmów ( np. sterowanie wektorowe )

    Ja poprzestałem na takim prostym sterowaniu ... po części z braku czasu / wiedzy, po części z braku dawcy do testowania ... Silnik roweru SPARTA mam w stanie niebyt dobrym, aktualnie nadaje się tylko obudowa i wirnik ( magnesy obeszły całkowicie z powłoki ochronnej i nawet pomimo reanimacji i czyszczenia szybko dochodzi do sytuacji że silnik się blokuje mechanicznie. )

    Jeśli ktoś ma ochotę mam jeszcze kilka gołych płytek sterownika - które za przysłowiowe pifko / przesyłkę mogę podarować.

    - PCB sterownika pod STM32f103 lub coś kompatybilnego
    - druga niezbędna część to część oryginalna silnika SPARTA TOPRUN z tranzystorami mocy i sterownikiem HIP4086
    Całość pasuje w oryginalny silnik.
    Sterownik ma miejsce na akcelerometr 6050, pomiar nacisku ( tensometr na ośce silnika ), modu BTLE ( antena miała wychodzić jedynie z 2 żyłami zasilania na zewnątrz silnika), buzer.

    Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych Samodzielny kontroler silnika BLDC na podstawie Arduino Uno dla pojazdów elektrycznych
  • #6 20963397
    andreyatakum
    Poziom 13  
    andreyatakum napisał:
    Sprawdzę kolejne artykuły tego autora. Może być jest coś nowego. To był tylko początek....

    Niestety to był pierwszy i jedyny artykuł tego autora- Ale szkoda. Jestm ciekaw do go wynalazków.
    __Maciek__ napisał:
    - PCB sterownika pod STM32f103

    W dzisiejszych czasach to chyba najlepsze rozwiązanie. Czyli lepsza alternatywa do Atmega328
  • #7 20966382
    szym86
    Poziom 13  
    Sprytnie napisany kod. Pokazałem go chatowi-gpt żeby mi go rozgryzł. Wygląda na to że sygnał na wyjściu jest prostokątny. Gdyby był modulowany mógłbyś zdaniem chata : zwiększyć efektywność energetyczną, poprawić kontrolę prędkości i momentu, zredukować hałas i drgania.
  • #10 20987904
    andreyatakum
    Poziom 13  
    tos18 napisał:
    tylko czy warto

    Moim zadaniem warto do nauczania.
    sortes napisał:
    Taka ciekawostka:

    Naprawde ciekawe ale nie wszystko zrozumiałem. Jak zrozumie do końca to postaram się przetłumaczyć.
  • #11 20988016
    tos18
    Poziom 42  
    andreyatakum napisał:
    Moim zadaniem warto do nauczania.

    Zbudowałem kilka.
    Na MC33035 i na L6235.
    L6235 jest do małych silniczków
    MC33035 chodzi fajnie ale ma bardzo wrażliwy wzmacniacz kontroli prądów i trzeba starannie projektować płytkę.Dodatkowo warto go dozbroić MC33039 - da możliwość stabilizacji obrotów.
    Nagle okazuje się że chiński moduł - działający można kupić za ułamek ceny samego MC33035.
  • #12 20988343
    andreyatakum
    Poziom 13  
    tos18 napisał:
    działający można kupić za ułamek ceny samego MC33035.

    Osz! Nie sprawdzjąc cenę zaczałem projektować plytkę. Chyba naprawde nie warto. Mi zależało na tym żeby umieścić tranzystory na ramie pojazdu bez obudowy. Dlatego nie chcialem gotowy kontroler.
  • #13 20988386
    __Maciek__
    Poziom 20  
    W nawiązaniu do @sortes .. na stronie https://blog.avislab.com/ Andrey bardzo ciekawie opisał, opowiada i tłumaczy zawiłości sterowania silnikami BLDC ( od podstaw do wersji zaawansowanych FOC ).

Podsumowanie tematu

Dyskusja dotyczy budowy samodzielnego kontrolera silnika BLDC na bazie Arduino Uno, z uwagi na ograniczenia dostępnych na rynku chińskich kontrolerów. Uczestnicy poruszają kwestie związane z algorytmami sterowania, w tym sterowaniem wektorowym, oraz problemami z przegrzewaniem i efektywnością energetyczną. Wskazują na potrzebę dokładnego projektowania układów, aby uniknąć zwarć w kodzie. Wspomniane są różne komponenty, takie jak MC33035 i L6235, oraz ich zastosowanie w projektach. Uczestnicy dzielą się również linkami do artykułów i zasobów dotyczących zaawansowanego sterowania silnikami BLDC.
Podsumowanie wygenerowane przez model językowy.
REKLAMA