Przeszukaj forum

Cześć, Mam taki mały problem z odpaleniem sterowania wektorowego (FOC) z modulacją przestrzenną wektora (SVM). Problem polega na tym, że silnik zamiast kręcić się stoi w miejscu, jak próbuję go ręcznie ruszyć to pomiędzy cewkami jest wyczuwalny luz natomiast w miejscu cewek próbuje trzymać pozycję. Raczej nie liczę na sprawdzenie kodu, ale podpowiedź co może powodować takie zachowanie. FOC: void focAlgorithm(motorParamsTypedef *mot) { __disable_irq(); static float32_t pSinVal, pCosVal; arm_sin_cos_f32(mot->enc.elecAngleDegrees_f32, &pSinVal, &pCosVal); arm_clarke_f32(mot->current.n_f32[PHASE_A], mot->current.n_f32[PHASE_B], &mot->current.alpha_f32, &mot->current.beta_f32); arm_park_f32(mot->current.alpha_f32, mot->current.beta_f32, &mot->current.IdMagnFlux_f32, &mot->current.IqRotaryTorque_f32, pSinVal, pCosVal); mot->current.targetIqRotaryTorque_f32 = mot->pidAngVel.PIDout; //PI working in SysTick handler below PIDIdMagnFluxFunc(&mot->pidId, &mot->current, mot->current.targetIdMagnFlux_f32); PIDIqRotaryTorqueFunc(&mot->pidIq, &mot->current, mot->current.targetIqRotaryTorque_f32); arm_inv_park_f32(mot->pidId.PIDout, mot->pidIq.PIDout, &mot->current.alphaPostInvPark_f32, &mot->current.betaPostInvPark_f32, pSinVal, pCosVal); arm_inv_clarke_f32(mot->current.alphaPostInvPark_f32, mot->current.betaPostInvPark_f32, &mot->current.aPostInvClarke_f32, &mot->current.bPostInvClarke_f32); svmAlgorithm(mot); __enable_irq(); } SVM: void svmAlgorithm(motorParamsTypedef *mot) { float32_t Uout = 0, angle = 0; angle = mot->enc.elecAngleRadians_f32 + M_PI; //angle = atan2f(mot->current.betaPostInvPark, mot->current.alphaPostInvPark); //sq -> a^2 arm_sqrt_f32(sq(mot->current.alphaPostInvPark_f32) + sq(mot->current.alphaPostInvPark_f32), &Uout); float32_t t1 = M_SQRT3_2*arm_sin_f32(M_PI_3 - angle)*Uout; float32_t t2 = M_SQRT3_2*arm_sin_f32(angle)*Uout; float32_t t0 = 1.0F - (t1 + t2); if(angle >= 0 && angle < DEG2RAD_60) //sector 1 { mot->svm.a_f32 = t1 + t2 + (t0/2); mot->svm.b_f32 = t2 + (t0/2); mot->svm.c_f32 = (t0/2); } else if(angle >= DEG2RAD_60 && angle < DEG2RAD_120) //sector 2 { mot->svm.a_f32 = t1 + (t0/2); mot->svm.b_f32 = t1 + t2 + (t0/2); mot->svm.c_f32 = (t0/2); } else if(angle >= DEG2RAD_120 && angle < DEG2RAD_180) //sector 3 { mot->svm.a_f32 = (t0/2); mot->svm.b_f32 = t1 + t2 + (t0/2); mot->svm.c_f32 = t2 + (t0/2); } else if(angle >= DEG2RAD_180 && angle < DEG2RAD_240) //sector 4 { mot->svm.a_f32 = (t0/2); mot->svm.b_f32 = t1 + (t0/2); mot->svm.c_f32 = t1 + t2 + (t0/2); } else if(angle >= DEG2RAD_240 && angle < DEG2RAD_300) //sector 5 { mot->svm.a_f32 = t2 + (t0/2); mot->svm.b_f32 = (t0/2); mot->svm.c_f32 = t1 + t2 + (t0/2); } else if(angle >= DEG2RAD_300 && angle <= DEG2RAD_360) //sector 6 { mot->svm.a_f32 = t1 + t2 + (t0/2); mot->svm.b_f32 = (t0/2); mot->svm.c_f32 = t1 + (t0/2); } else { mot->svm.a_f32 = 0; mot->svm.b_f32 = 0; mot->svm.c_f32 = 0; angle = 0; } mot->timMot->CCR1 = mot->svm.a_f32; mot->timMot->CCR2 = mot->svm.b_f32; mot->timMot->CCR3 = mot->svm.c_f32; } FOCInit: void focInit(motorParamsTypedef *mot) { float32_t Ts = 1.0F/TIM_PWM_FREQUENCY; float32_t Td = Ts; float32_t Ti = Ts; myAdc.adcFilterSteps_u16 = 10; myAdc.adcCalibSteps_u16 = 1000; myAdc.adcCalibFlag_enum = CALIB_START; mot->motorMaxVoltage_f32 = 1; mot->current.targetIdMagnFlux_f32 = 0; mot->svm.ts_f32 = Ts; mot->targetAngularVelocity_f32 = 10000; //PID1 mot->pidAngVel.kp = 0.01; mot->pidAngVel.ki = 0.1; mot->pidAngVel.kd = 0; mot->pidAngVel.Ts = 0.001; mot->pidAngVel.Td = mot->pidAngVel.Ts; mot->pidAngVel.Ti = mot->pidAngVel.Ts; mot->pidAngVel.PIDoutMax = MOTOR_MAX_ANG_VEL_RAD; mot->pidAngVel.PIDoutMin = -MOTOR_MAX_ANG_VEL_RAD; mot->pidAngVel.errorTolerance = 0.01; //PID2 mot->pidId.kp = computeKp(13); mot->pidId.ki = computeKi(13, 1); mot->pidId.kd = 0; mot->pidId.Ts = Ts; mot->pidId.Td = Td; mot->pidId.Ti = Ti; mot->pidId.PIDoutMax = MOTOR_MAX_CURRENT; mot->pidId.PIDoutMin = -MOTOR_MAX_CURRENT; mot->pidId.errorTolerance = 0.01; //PID3 mot->pidIq.kp = computeKp(13); mot->pidIq.ki = computeKi(13, 1); mot->pidIq.kd = 0; mot->pidIq.Ts = Ts; mot->pidIq.Td = Td; mot->pidIq.Ti = Ti; mot->pidIq.PIDoutMax = MOTOR_MAX_CURRENT; mot->pidIq.PIDoutMin = -MOTOR_MAX_CURRENT; mot->pidIq.errorTolerance = 0.01; } Inne: void PIDIdMagnFluxFunc(PidTypedef *pid, MotorCurrentTypedef *motI, float32_t targetIdMagnFlux) { pid->valPres = motI->IdMagnFlux_f32; pid->valTarget = targetIdMagnFlux; PIDController(pid); } void PIDIqRotaryTorqueFunc(PidTypedef *pid, MotorCurrentTypedef *motI, float32_t targetIqRotaryTorque) { pid->valPres = motI->IqRotaryTorque_f32; pid->valTarget = targetIqRotaryTorque; PIDController(pid); } void PIDMotorAngularVelocity(PidTypedef *pid, encoderTypedef *enc, float32_t targetAngularVelocity) { pid->valPres = enc->angleRadiansSpeed_f32; pid->valTarget = targetAngularVelocity; PIDController(pid); } float32_t computeAB(float32_t VBusDC) { //https://www.st.com/resource/en/user_manual/cd00298474-stm32f-pmsm-singledual-foc-sdk-v43-stmicroelectronics.pdf //page 38 return (VBusDC*SHUNT_RES_VAL*SHUNT_AMPLIFICATION)*UC_REF_VOLTAGE; } float32_t computeKp(float32_t VBusDC) { return MOTOR_LS_H*(MOTOR_MAX_ANG_VEL_RAD/computeAB(VBusDC))*PID_KP_DIV; } float32_t computeKi(float32_t VBusDC, float32_t T) { return ((MOTOR_RS_OHM*MOTOR_MAX_ANG_VEL_RAD*PID_KI_DIV)/computeAB(VBusDC))*T; } void SysTick_Handler(void) { encoderAngularSpeedRead(&motorLeftStruct.enc); encoderAngularSpeedRead(&motorRightStruct.enc); motorLeftStruct.targetAngularVelocity_f32=50; PIDMotorAngularVelocity(&motorLeftStruct.pidAngVel, &motorLeftStruct.enc, motorLeftStruct.targetAngularVelocity_f32); PIDMotorAngularVelocity(&motorRightStruct.pidAngVel, &motorRightStruct.enc, motorRightStruct.targetAngularVelocity_f32); }

Witam. Mam problem z sterownikiem ESC do silnika BLDC. Dodatkowo silnik bardzo mi się nagrzewa po kilku sekundach pracy bez obciążenia nie da się go dotknąć. Jestem początkujący i chciałem uruchomić silnik aby w ogóle zaczął się kręcić. Wszystko się grzeje a ze sterownika poszedł nawet dym. Używam następujących podzespołów: https://abc-rc.pl/product-pol-12358-ESC-ABC-Power-Air-40A-2-3S-BEC-1A-Prosty-regulator-silnikow.html https://allegro.pl/oferta/bateria-li-po-11-1v-3s-1000mah-25c-35c-zippy-rc-7787929208?snapshot=MjAxOS0xMS0wNVQxNTo1NTozNi4wODFaO2J1eWVyO2EzNDFmMTJkMzhjYTAzMjVkNTk3ODg5NDA0NmRkNzZkOWM3ZDJhNmRiODIzZmFiNjc2MzBmOGJhOWU4MjkwYmE%3D https://pl.aliexpress.com/item/32822131805.html?src=google&src=google&albch=shopping&acnt=494-037-6276&isdl=y&slnk=&plac=&mtctp=&albbt=Google_7_shopping&aff_platform=google&aff_short_key=UneMJZVf&&albagn=888888&albcp=6459808507&albag=76872920869&trgt=743612850874&crea=pl32822131805&netw=u&device=c&gclid=Cj0KCQiA2vjuBRCqARIsAJL5a-JQrX5JscoqziVYoLqq4Xq4TNgpofR3NcNXMkl321WQCJxTgm_MvF0aAn6SEALw_wcB&gclsrc=aw.ds Użyłem podłączenia jak na filmie tylko że zwarłem A0 z 3.3V gdyż nie mam potencjometru. Czy wina jest w źle dobranym sprzęcie? Pozdrawiam

Cześć, od kiedy opisałem swojego robota Pika na forum, minęło już troszkę. W tym czasie zdążyło powstać kilka kolejnych konstrukcji, zarówno bez turbiny jak i z turbiną. W tym poście chciałbym przybliżyć Wam moją najnowszą konstrukcję - robota klasy Linefollower Turbo o nazwie Spark. Głównym założeniem, jakie przyświecało mi podczas projektowania była chęć nauczenia się wektorowego sterowania silnikami BLDC oraz wykorzystanie właśnie takich silników jako napęd bezpośredni w robocie. Podczas opisu założeń konstrukcyjnych posłużę się modelem 3D robota. Jak można zauważyć na powyższym zdjęciu, ogólna konstrukcja nie różni się od znanego wszystkim standardu. Na przedzie delikatna i lekka listewka z 14 czujnikami linii KTIR0711S. Centralnie umieszczona turbina QX-Motor 14000 kv o średnicy 30 mm. Dwa silniki hexTronik 1300KV umieszczone w tylnej części w taki sposób, aby możliwe było uniesienie przodu celem wjazdu na pochylnię/rampę w kategorii Linefollower Enchanced. Sercem robota jest mikrokontroler STM32H743VIT6. Jest on oparty na rdzeniu Cortex M7 oraz taktowany z prędkością 400 MHz. Wybór tak potężnej jednostki sterującej podyktowany był chęcią wydajnego obliczania komutacji sterowania wektorowego dla każdego z silników jezdnych oraz realizacji algorytmu jazdy przy pomocy tylko jednej jednostki. Dodatkowo tak szybki mikrokontroler pozwolił na zatuszowanie moich niedoskonałości w optymalizacji kodu 🙂 Głównym elementem konstrukcyjnym jest 4-warstwowy obwód drukowany. W trakcie projektowania falowników do sterowania silnikami powstały dwa prototypy, w których miałem problem z przegrzewającymi się tranzystorami dlatego w docelowym PCB zastosowałem aż 4 warstwy. Dodatkową zaletą takiego obwodu jest jego większa odporność na zakłócenia elektromagnetyczne. Podświetlony obszar to miedź na wszystkich czterech warstwach połączonych setkami przelotek chłodząca tranzystory. Do sterowania każdym z silników wykorzystałem 6 tranzystorów w układzie pełnego mostka 3-fazowego. Posłużyły mi do tego półmostkowe układy BSG0813NDI za których udostępnienie serdecznie dziękuję firmie Infineon (oraz za tranzystory i drivery, które spaliłem w prototypach - ok 60 sztuk, nie od razu Rzym zbudowano 😅) Ostatecznie jako drivery wykorzystane zostały układy MIC4607-2 ze względu na możliwość sterowania całym mostkiem przy pomocy tylko jednego układu. Do odczytywania pozycji wirnika służy enkoder magnetyczny AMS5045B. Całość zasila akumulator Li-Po Tattu 450mAh 7.4V 75C. Za komunikację bezprzewodową odpowiada stary dobry moduł HC05. W celu zapewnienia pod robotem podciśnienia wywoływanego turbiną, zwiększającego nacisk kół na podłoże obrys uszczelniony został wydrukowaną w 3D ścianą. Do usztywnienia konstrukcji tak, aby opierała się ona o podłoże tylko kołami i ślizgaczami z przodu, posłużyły wałki węglowe o średnicy 4 mm. Do połączenia ze sobą poszczególnych elementów konstrukcyjnych wykorzystane zostały aluminiowe mocowania wykonane w technologii WEDM. Poniżej kilka fotek. Prototyp 1: Ratowanie prototypu 1 (rezystory bramkowe? A na co to potrzebne 🙂) : Prototyp 2: Elementy konstrukcyjne: Pierwsze ruchy silnika: Poszukiwanie granic: Opona wykonana z poliuretanu 20': Aluminiowa felga wciśnięta na wirnik (Pololki dla skali): Zamontowana felga wraz z oponami (Mini-Z 20'): Turbina po dezintegracji (podczas jazdy eksplodowała): Przejazd w konkurencji Linefollower Drag podczas Bałtyckich Bitw Robotów 2018: Próby podczas RobotChallenge 2018 w Pekinie: Wnioski: Konstrukcja waży 250 g. To zdecydowanie za dużo, gdyż opony nie są w stanie zapewnić wystarczającej przyczepności na zakrętach i robot wpada w poślizg na zakrętach przez co osiągnięcie prędkości średniej na krętej trasie powyżej 3 m/s jest bardzo trudne. Zastosowanie silników BLDC jako direct-drive umożliwia rozpędzenie robota do ogromnych prędkości liniowych (15 m/s+) lecz aby posiadały one zadowalający moment przy niskich obrotach konieczny do gwałtownych zwrotów muszą być duże i ciężkie. Lepiej zastosować małe silniki z przekładnią. Nowa konstrukcja już się tworzy! Dziękuję za przejrzenie albumu, który utworzyłem i zapraszam do zadawania pytań w komentarzach 🙂