Precizna kontrola Servo Motora Pomocu SimpleFOC biblioteke

[elektropionir]

SimpleFOC je trenutno najbolji framework za kontrolu elektricnih motora pomocu FOC metode.
Ovo je open source projekat koji me je zainteresirao jako davno. Mislim da je projekat zapoceo inzinjer koji se zove Antun Skuric sa nasih prostora, ali ovo je sada jako veliki framework kome doprinosi mnogo developera.
Razviti citav kontrolni algoritam je jako komplikovan zadatak. Srecom SimpleFOC je jako modularan i fleksibilan framework.
Podrzava mnogo tipova motora, tipova kontrole obrtnog momenta, brzine ili pozicije u open loop ili closed loop modu, kao i mnogo razlicitih senzora za detekciju pozicije.

Ovdje cu opisati svoj test setup. Namjerno sam koristio jako jednostavne i jeftine alate da bi ovaj primjer bio laksi za reproducirati.

Motor koji koristim je mali servo motor, nema17 RS broj 536-6024. Napon 24V, peak struje 6A sa 4 para polova i 3 hall senzora. Bez obzira na tip motora, ovi primjeri i metodi rade za bilo koju masinu.



Naravno protrebna nam je i kontrolna ploca sa 3fanzim mostom kao servo pojacalom. Eksperimentisanje sam zapoceo sa steval-spin3202.


Medjutim, ova ploca nema shunt u svakoj grani 3faznog mosta, tako da sam odlucio da nabavim mnogo popularniju b-g431b-esc1. Ovo je plocica koja je namjenjena za kontrolu motora u RC avionima i dronovima. Ima jako brz G4 microcontroller, ali je nocna mora za bilo kakvo testiranje. Definitivno cu se vratiti Prvoj opciji kada budem morao ustvari primjeniti ovaj motor i dodati svoju elektroniku i mehaniku na uredjaj koji pravim.



Posto je ESC1 popularna razvojna plocica, svi pinovi mikrokontrolera kao i ostali hardware su vec definisani u SimpleFOC.
U ini file platformio mozemo da stavimo osnovne podatke o projektu, ovo je moj platformio.ini fajl:

Code:

[env:disco_b_g431b_esc1]
platform = ststm32
board = disco_b_g431b_esc1
framework = arduino
monitor_speed = 115200
upload_protocol = stlink
lib_archive = no
build_flags =
    -D PIO_FRAMEWORK_ARDUINO_NANOLIB_FLOAT_PRINTF
    -D HAL_OPAMP_MODULE_ENABLED
    -D HAL_TIM_MODULE_ENABLED
lib_deps =
    https://github.com/simplefoc/Arduino-FOC
    SPI
    Wire

Da bi skratio ovu temu, ovdje cu postaviti citav main.cpp code:
Cilj ovog koda je testirati regulator brzine. Brzina se mjeri pomocu hall senzora. Trenutno samo regulator brzine je aktivan, regulator momenta i sve ostalo je ugaseno-
Prvi dio koda definise senzor i motor objekat i neke osnovne parametre o motoru.
Commander command je objekat je objekat koji uzima ulaz sa serijskog porta i mjenja reaguje na odredjene ulaze koje cemo kasnije definisati.
void onTarget ili onP I D kao sto vidite su method funkcije koje ce pozvati komander objekat. Ove funkcije samo mjenjaju koeficjent u PID kontroleru brzine kao sto je ocito.
U init dijelu ovi objekti se iniciraju sa parametrima i opisom koji smo zadali.
Init metod po paljenju uredjaja pokrene motor u obje strane za jedno 30 stepeni, provjeri prirodni smijer obrtanja kao i broj pari polova. Postoji nacin da se ovo preskoci i da se zadaju tacni parametri jer inicijalizacija traje 10tak sekundi.

Code:

#include <Arduino.h>
#include <SimpleFOC.h>

HallSensor sensor = HallSensor(A_HALL1, A_HALL2, A_HALL3, 4);

// Interrupt routine intialisation
// channel A and B callbacks
void doA(){sensor.handleA();}
void doB(){sensor.handleB();}
void doC(){sensor.handleC();}
// put function declarations here:


// BLDC motor & driver instance
// BLDCMotor motor = BLDCMotor(pole pair number);
BLDCMotor motor = BLDCMotor(4);
// BLDCDriver3PWM driver = BLDCDriver3PWM(pwmA, pwmB, pwmC, Enable(optional));
BLDCDriver6PWM driver = BLDCDriver6PWM(A_PHASE_UH, A_PHASE_UL, A_PHASE_VH, A_PHASE_VL, A_PHASE_WH, A_PHASE_WL);

Commander command = Commander(Serial);
float target_velocity=0;

void onTarget(char* cmd){
  command.scalar(&target_velocity, cmd);
  }

void onP(char* cmd){
  command.scalar(&motor.PID_velocity.P, cmd);
  }
void onI(char* cmd){
  command.scalar(&motor.PID_velocity.I, cmd);
  }
void onD(char* cmd){
  command.scalar(&motor.PID_velocity.D, cmd);
  }
void onT(char* cmd){
  command.scalar(&motor.LPF_velocity.Tf, cmd);
  }
float target = 0.0;

void SerialLoop(){
  static String received_chars;

  while(Serial.available()){
    char inChar = (char) Serial.read();
    received_chars += inChar;
    if (inChar=='\n')
    {
      target = received_chars.toFloat();
      Serial.print("Target = ");
      Serial.println(target);
      received_chars="";
    }
   
  }
}

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  delay(1000);

  sensor.init();
  // hardware interrupt enable
  sensor.enableInterrupts(doA, doB, doC);

  // driver config
  // power supply voltage [V]
  driver.voltage_power_supply = 24;
  // limit the maximal dc voltage the driver can set
  // as a protection measure for the low-resistance motors
  // this value is fixed on startup
  driver.voltage_limit = 8;
  driver.init();
  // link the motor and the driver
  motor.linkDriver(&driver);

  // limiting motor movements
  motor.voltage_limit = 9;    // [V]
  motor.velocity_limit = 500;  // [rad/sec]
  motor.voltage_sensor_align=2;
  // limit the voltage to be set to the motor
  // start very low for high resistance motors
  // current = voltage / resistance, so try to be well under 1Amp
  motor.phase_resistance = 1.6; // [Ohm]
  motor.current_limit = 6;   // [Amps] - if phase resistance defined

  motor.useMonitoring(Serial);
  motor.monitor_downsample = 5;
  motor.monitor_variables = _MON_TARGET | _MON_VEL| _MON_VOLT_Q;

  motor.linkSensor(&sensor);

  motor.PID_velocity.P=0.03;
  motor.PID_velocity.I=0.2;
  motor.PID_velocity.D=0.002;
  motor.LPF_velocity.Tf=0.09;

  // open loop control config
  //motor.torque_controller = TorqueControlType::voltage;
  motor.controller = MotionControlType::velocity;

  // init motor hardware
  motor.init();
  motor.initFOC();
  Serial.println("Setup Done!");

  command.add('v', onTarget, "target velocity");
  command.add('p', onP, "Proportional Regulator");
  command.add('i', onI, "Integral Regulator");
  command.add('d', onD, "Differential Regulator");
  command.add('t', onT, "loop speed Regulator");
}

void loop() {

  motor.loopFOC();

  motor.move(target_velocity);
  //motor.monitor();
  command.run();
 
}

// put function definitions here:

Glavna petlja je jako kratka i samo mjenja zadatu brzinu, i poziva glavni FOC kontrolni algoritam.
motor.monitor je funkcija koja u terminalu moze da ispise trenutnu poziciju, ali ova funkcija je uzasno spora. Citav 1 dan sam pokusao da skontam zasto algoritam ne funkcionise. Imao sam cak 0.5A na 24V praznu potrosnju, i kontrolni parametri su bili potpuno besmisleni. Motor je bio nemoguc za kontrolisati. Ukidanjem ove funkcije algoritam radi kako treba

Sada dolazimo do glavnog problem. Podesavanje PID parametara, sto nebi trebao biti problem za nekoga ko je zavrsio Automatiku, ali mi je i dalje trebalo 2 dana da pripremim sve
Iz nekog razloga, sva dokumentacija, primjeri i demonstracije ove biblioteke, cak i od strane developera su poprilicno besmislene. Svaki control loop primjer je ustvari PI kontroler.
Svima samo preporucuju da ne koriste D, jer to cini motor nestabilnim. Meni to nema nikakvog smisla, vidio sam source code ovih regulatora, sve je savrseno programirano.
Ali zaista, poceo sam sa malim parametrima i cim dodam D koji nije 0, motor bi poceo da skace, tako da sam odlucio da vidim sta je problem.
Osim toga, svakaki konverter koji sam ikada napravio obavezno koristi D regulator.

----------------------- OFFTOPIC----------------------
Upravo nedavno sam morao da napravim konverter za napajanje gate drajvera, sto zvuci kao maciji kasalj za mnoge od Vas. Medjutim drajver je za 4.5kV IGBT modul, konverter je 2MW, i sav elektricni naboj koji se potrosi za paljenje modula, mora biti zamjenjen u periodu od 5 mikrosekundi. Paljenje velikog modula uzrokuje da gate napon blago opadne,za oko 1V cak i uz ogroman bulk cap. Manji gate napon povecava disipaciju modula, sto na 2kA nije zezancija. Uglavnom srednja snaga tog jako malog konvertera je samo oko 5w ali peak snaga je 120W, i pored toga udaljen je 2 PCB plocice i 20CM kabla od bulk-a i gate drajvera. HAH! Napravi taj brz i stabilan regulator bez mnogo Dif. komponenti.
----------------------------------------------------------

Prvi zadatak je definitivno napraviti neovisno mjerenje brzine obrtaja.
3D printao sam jako jednostavan enkoder, sa samo 6 pozicija. On se vrti kroz jedan opticki endstop. Ovo sam imao viska kada sam upgrade-ova svoj 3d printer.
Ovi endstopi nisu dobri za brz odziv enkodera. Potrebno je smanjiti intenzitet svjetla diode za brzi odziv. Takodjer fototranzistor sluzi samo da ugasi 2N7002 mosfet, uz malu modifikaciju sheme, uklanjanje mosfeta, pomocu PNP-a pojacati signal da se odziv jos ubrza.



Pravi izazov je snimiti ove signale. Naravno to mozemo pomocu osciloskopa ali to je mukotrpan proces, preracunavanje tih analognih signala u brzinu, to mi se definitivno nije radilo.
Tako da mi je palo na pamet da iskoristim jedan od ovih logickih analizatora koje imam. Ovo je najjeftinija kopija starog Saleae Logic8 analizatora ali za ovu svrhu vise nego dovoljan!
Kada radim testove uvjek koristim jedan od DreamSourceLab jako brzih logickih analizatora tako da sam zaboravio da imam ovo, ali vjerujem da skoro svako ima bar jedan negdje.
Dovoljno je samo spojiti masu i jedan od ulaza, na izlaz iz ovog optickog prekidaca.

Mozemo koristiti LogicView Sigrok open source software za snimanje ovih signala, medjutim, sigrok takodjer ima comand line client koji sam uvjek zelio da naucim koristiti tako da je ovo bila dobra prilika da to provjerimo

Ovdje cu postaviti citavu python skriptu, ja sam je koristio u jupyter notebook:

Ovo su osnovne funkcije:

Code:

import subprocess

SIGROK_CLI_PATH = 'C:/Program Files/sigrok/sigrok-cli/sigrok-cli.exe'

def find_transitions(data):
    states = [data[0]]
    durations = [0]
    for bit_possition, bit_value in enumerate(data):
        if bit_value != states[-1]:
            states.append(bit_value)
            durations.append(bit_possition-durations[-1])
    return states, durations

def calculate_speed(sample_rate, encoder_resolution, durations):
    speeds = [sample_rate*3.14/((durations[i+2]-durations[i])*encoder_resolution) for i in range(len(durations)-2) ]
    timescale = [0]
   
    for index in range(1,len(durations)-2,2):
        temp1=durations[index+2]-durations[index]
        temp2=durations[index+1]-durations[index-1]
        timescale.append(timescale[-1]+temp2)
        timescale.append(timescale[-1]+temp1)
     
    time = [timescale[i]/sample_rate for i in range(1,len(timescale))]
    return speeds, time


def plot_speed(in_samplerate):
    samplerate = {   
    20000   :'20 kHz',
    25000   :'25 kHz',
    50000   :'50 kHz',
    100000  :'100 kHz',
    200000  :'200 kHz',
    250000  :'250 kHz',
    500000  :'500 kHz',
    1000000 :'1 MHz',
    2000000 :'2 MHz',
    3000000 :'3 MHz',
    4000000 :'4 MHz',
    6000000 :'6 MHz',
    8000000 :'8 MHz',
    12000000:'12 MHz',
    16000000:'16 MHz',
    24000000:'24 MHz',
    48000000:'48 MHz'
    }

    SAMPLES = f'{8*10000}'
    TRIGGER = 'D0=1'
    SAMPLE_RATE = f'{samplerate[in_samplerate]}'

    capture = subprocess.run(
        [SIGROK_CLI_PATH, '--driver', DEVICE,
         '--samples', SAMPLES,
         '--triggers', TRIGGER,
         '--output-format' , 'bits:width=8',
         '--channels', 'D0',
         #'--output-file', 'test.csv',
         '--config', f'samplerate={SAMPLE_RATE}'],
        shell=True,
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT)

    datastream=capture.stdout.decode('ascii')
    datastream = datastream.replace('FRAME-END','').replace('FRAME-BEGIN','').replace('T:^ 0','').replace('D0:','')

    test = datastream.split('\n')
    to_delete = []
    for index,value in enumerate(test):
        if(len(value)!=8):
            to_delete.append(index)

    to_delete.reverse()

    for index in to_delete:
        test.pop(index)

    waveform = ""
    for bits in test:
        waveform+=bits

    s,d = find_transitions(waveform)
    #print(waveform)
    speed, time = calculate_speed(in_samplerate,6,d)

    return speed, time

I ovo napokon iscrtava grafove koje zelimo vidjeti

Code:

from time import sleep
import plotly.graph_objs as go
speed, time = plot_speed(20000)
fig = go.FigureWidget()
fig.add_scatter(y=speed)
fig.update_layout(xaxis_title="samples x 50us", yaxis_title="rad/s")
fig['data'][0]['name']='speed'
fig['data'][0]['showlegend']=True
fig.update_traces(marker=dict(size=24, color="blue"), selector = dict(name="first_trace"))
fig

Sada dolazi zabavan dio.
U VS code terminalu mozemo da saljemo komande. Kao sto smo programirali "v20" komanda bi promjenila brzinu obrtaja na 20rad/sec. Komanda i5.4 bi promjenila koeficjent kI na 5.4 u PID regulatoru. Sada imamo sve da lako testiramo regulator brzine.
Korak 1.
I = 0 D = 0. Mjenjamo P od 0 to broja koji nam daje relativno glatku opraciju na srednjem broju obrtaja, 50rad/sekundi i ne previse skakanja na 0-5rad/s. 0 je obicno jako nestabilna.
Ukoliko regulator ne reaguje na zadatu vrijednost, P je premali broj. Za moj motor P je bio ok od 0.03 do 0.1 medjutim na vecem broju obrtaja veci P je bio nestabilan. Izabrao sam manju vrijednost.
Nakon nekoliko pokusaja dolazimo do prvog koraka:

Kao sto se vidi iz prvog grafa sam P regulator ima staticku gresu od oko 20rad/s. To je prihvatljivo za ovaj korak.
Sljedeci korak je podesavanje I regulatora. Cilj je imati manji I regulator da dovoljno brzo popravi staticku gresku. Nakon podesavanja I regulatora motor ce raditi ok, ali step odziv je uzasan. Motor radi ok u stacionarnom stanju ali... Dinamika je katastrofa. Na zalost sva dokumentacija i savjeti koje daju pocetnicima na razlicitim platformama kaze da je ovo dovoljno dobro. Za moj cilj na zalost nije. Nakon malo igranja sa parametrima, dajem kratak sazetak rezultata ispod:


Ovo je sada vec mnogo respektabilnije.
Naredni korak bi bio ukljucivanje regulatora momenta. Ali to cu ostaviti za buduci trenutak.

[mikikg]

Zanimljivo i korisno da se proba i izuči ceo taj HW/SW mehanizam za kontrolu motora.

Posle toga se obično ide na sledeći "level", svi ti HW/SW mehanizmi tako lepo kompaktno spakovani na jednoj PCB koja se zakači na poledjinu motora, tu je SVE, i drajver, kontroler i komunikacija čak ima i mali displejčić

Radi kao klasičan step motor ali zaključan u PID sa izlazima za greške, ima magnetne enkodere za FB i pokreće se klasično sa PULSE/DIR jednom kada se interno podesi.

Ima gomila varijanti po tom principu, na Ali-u tona i cene sa sve motorom jeftinije nego ja da nabavim samo jedan drajver IC ...

Ima ovaj veliki motor-drajver, ima displej kao od našeg "Relejnog Atenuatora", isto i Enkoder od Relejnog Atenuatora može da se iskoristi jer još nemamo ove fine magnetne enkodere i gle fore rade isto sa STM32 kao naš Relejni Atenuator!

[savan]

Miki mozes li okaciti link do Aliexpress ovog sa poslednje slike?

[mikikg]

Na primer ovaj Nema17, 10E drajver i 10E motor i kod tog prodavca 5E poštarina jer je malo teže zbog motora ali su taj rang cena za te spravice.

Ima dosta oglasa i dosta se to prodaje jer uglavnom koriste za razne CNC sprave, čak i kao "upgrade" za istu mehaniku i motore ali da se zameni sa tim drajverima jer stvarno rade drastično bolje, tiše, ne zuje, manje se greju i rade sa vrećim frekvencijama, manje EMI buke.

https://vi.aliexpress.com/item/1005005509159404.html

[elektropionir]

Zdravo Miki

Imam jako puno iskustva sa takvim drajverima. Ustvari ti uredjaji su bili i inspiracija za ovaj projekat.
Imam 6-7 komada drajvera i motora koje si postavio. Nekoliko proizvodjaca ima svoje verzije takvog drajvera.
Na zalost skoro ni jedan od njih nije otvorio svoj kod iako koriste open source biblioteke poput SimpleFOC. To je nesto sto mi se ne svidja.

Ovo su ustvari closed loop stepper drajveri sa magnetnim enkoderom.
Ovi motorici su mali za CNC ali ja ih koristim vec 2 godine na svom 3d printeru, i rijesili su jedan od najvecih problema kod 3d printanja. A to je layer shift.

Firmware ovih motora ima nekoliko poznatih bug-ova koje na zalost ne zele da poprave, ali hardware je solidan.
Nadam se da cu moci napisati svoj firmware za neke od ovih motora koje imam ukoliko uspijem podesiti Keil da kompajlira kod za ovu kinesku verziju STM32. Imam negdje u projek folderu datasheet ovih mikrokontrolera koji su na tim plocicama. Na papiru su jako sposobni i vrlo slicni ST-u. 
Magnetni enkoderu su isto kineski dizajn i izgleda da imaju ok performanse, pogotovo za tako jeftinu cijenu.

Moj fokus je sada trenutno samo na pravim BLDC servo motorima, jer se nadam da cu imati veci moment na visokom broju obrtaja.

Upravo sam promjenio setup sa gornjeg posta, nakon sto sam odlucio da sam zadovoljan kontrolerom brzine, umjesto jednostavnog optickog enkodera, postavio sam magnetni enkoder.
U centru ove plocice nalazi se AS5600L i2c magnetni enkoder, i trenutno popravljam kod. Dijametralni magnet se nalazi na vrhu ove crvene kape sa kazaljkom.



U prvom postu smo vidjeli kako podesiti regulator brzine obrtaja. Ukoliko taj regulator brzine obavijemo jednom kontrolnom petljom sa jednostavnim P regulatorom, dobijemo regulator ugla/pozicije. Regulator ugla racuna razliku izmedju zadatog i trenutnog ugla, mnozi to sa kP i podesava to kao zadatu brzinu okretanja. Ova kontrolna shema radi jako dobro. Medjutim problem je sto se trenutni ugao, kao i brzina rotacije mjeri pomocu hall senzora koji su u motoru, i taj ugao nije bas precizan, tako da i rezultat te kontrole ugla nije precizan.
Zato sam napravio ovaj test sa magnetnim enkoderom.

[savan]

Hvala, ja sam nesto poceo da tragam i da se interesujem za cnc koji bi bio pogodan za obradu aluminijuma ali nemam iskustva sto se cnc tice pa nemam ni ideju koja tehnologija bi mi odgovarala, kakvo je iskustvo sa "Ethernet SmoothStepper"? Koji motori po vasem misljenju bi bili idealni za linearno vodjenje za obradu aluminijuma? Dali postoji neki opticki 32bit sklop koji opticki meri razdaljinu referentne tacke na cnc podlozi u odnosu na tacku na z osi, ustvari tri takllva senzora bi bila potrebna za sve tri ose, dali postoji nesto takvo 32bit rezolucije 1MHz++? Meni i2c senzori/encoderi ne deluju obecavajuce za nesto da se uradi u real tajmu. Ovde bi trebalo takvo nesto imati sto bi dinamicki zadavalo parametre motoru u vezi apsolutne distance u real tajmu, i2c je previse spor za takvo nesto, samo razmisljam na glas. : )

[ddanijel]

Čemu bi to služilo ?

[HomeMadeAudioProject]

Hvala, ja sam nesto poceo da tragam i da se interesujem za cnc koji bi bio pogodan za obradu aluminijuma ali nemam iskustva sto se cnc tice pa nemam ni ideju koja tehnologija bi mi odgovarala, kakvo je iskustvo sa "Ethernet SmoothStepper"? Koji motori po vasem misljenju bi bili idealni za linearno vodjenje za obradu aluminijuma? Dali postoji neki opticki 32bit sklop koji opticki meri razdaljinu referentne tacke na cnc podlozi u odnosu na tacku na z osi, ustvari tri takllva senzora bi bila potrebna za sve tri ose, dali postoji nesto takvo 32bit rezolucije 1MHz++? Meni i2c senzori/encoderi ne deluju obecavajuce za nesto da se uradi u real tajmu. Ovde bi trebalo takvo nesto imati sto bi dinamicki zadavalo parametre motoru u vezi apsolutne distance u real tajmu, i2c je previse spor za takvo nesto, samo razmisljam na glas. : )

mislim da ova pitanja zaslužuju svoju temu,da ne skrenemo sa ovog što je čovek krenuo da predstavlja...

[elektropionir]

Hvala sto se interesujete za temu. Postavljati cu update-e kako projekat napreduje.

Savane, dosta CNC masina uopste nema closed loop sistem za pozicioniranje, pogotovo masine koje se mogu kupiti za 2-5000e. Mislim da dizajneri smatraju da konstruisanjem preciznih linearnih aktuatora, koristenjem linearnih vodilica i kuglicnih navojnih osovina ne moraju imati zatvoren sistem. I cesto to je istina, dovoljno veliki steper motori koji kod CNC masina rade na malom broju obrtaja ne pate od preskocenih koraka.

Cilj ovog projekta je da postane vrlo precizno i brzo doziranje filamenta u glavu 3d printera sa kontrolom pritiska. To koliko znam trenutno ne postoji i zahtjeva closed loop sistem sa nekoliko senzora.
Trenutno stanje u svijetu 3d printanja je da ljudi smatraju da su direktni ekstruderi dovoljno dobri i sve mane takvih ekstrudera se ne adresiraju. Nakon sto sam koristio nekoliko najpopularnijih direktnih ekstrudera mislim da ima mnogo mjesta da se stvari unaprijede.

[savan]

Ok, zato pitam dali postoji opticki 32bit senzor daljine koji moze precizno da izmeri polozaj ose u 0.001mm greske, na primer ako bi na sve tri ose postojao po jedan takav senzor koji moze da vrti na 1MHz++ i da se u svakom trenutku zna svaka osa pojedinacno u kom polozaju se nalazi. To je onako neko moje vidjenje posto vidim da dosta problema postoji sto se "preskakanja" tice na step motorima, nemam iskustva cisto onako pitam a sto da ne i kao neka ideja. Ajde necu da pitam vise da ne zatrpavam ovu intersantnu temu.

[Ubledeli]

@elektropionir

mislim da ti ideje idu u pravom smeru vezano za BLDC closed loop sa vektorskim upravljanjem,
steta je sto nema open source kontrolera sa programom za direktnu kontrolu sa racunara u real-time

o extruderima za 3d printere ne znam skoro nista tako da ne mogu da kazem nista osim da ako imas kakvu god ideju da to poboljsas
sigurno da ima mesta za closed loop sistem jer je trenutno obican step motor sa open loop

bravo za temu

[mikikg]

@elektropionir

Vidim da si dosta radio sa tim stvarima.

Nama fali ovo za Relejni Atenuator, jeste prosta stvar ali nema da se kupi tek-tako, tj ima Bourns ali košta 40+E ali da ima osovinu bukvalno istu kod klasičnih potenciometara. To bi bila fina ideja da se odradi u DIY varijanti. 

 

Vezano za same kontrolere i implementaciju celog takvog sistema po FOC principu, jeste nezgodna situacija i "veliki" igrači uglavnom ne daju source-code za takve stvari, generalno ni za kakav low-level firmware šta god da je u pitanju.

Medjutim, moraju da prodaju čipove i kontrolere, kako sad ipak da se prevazidje taj "jaz" otvorenog/zatvorenog code-a, neko treba da napiše neki software da mašina nešto radi ...

Tu je Texas Instruments rešio tako što sve što je vezano za Cortex-A/R/M je otvorenog coda, sa tim se generalno pišu Linux, RTOS i bare-metal aplikacije, čak ima prevodioca i za njihove sve ostale periferije poput PRU (ICSG) gde korisnik može da piše šta god želi ako ume naravno.

Napravili su caku, imaju male i gotove firmware za neke specificne potrebe za PRU jedinice, na primer industriski mrežni protokoli, ProfiBUS, EtherCat i slični i za korisnika su oni potpuno besplatni ali zu zatvorenog code-a, mogu da se slobodno koriste ali preko definisanih API metoda i poziva iz aplikacija višeg nivoa. 
Postoje gotovi .elf fajlovi za razne stvari koji se ubace u te PRU jedinice i nadalje se komunicira preko API.

I sad je tu glavna caka što imaju i posebne firmware za FOC kontrolu motora, vrlo ozbiljno napravljeno sve do besplatnog GUI sa grafikonima i Auto-tuning specifično za te motor-kontrol potrebe.

Kada se to sve vozi sa njihovim best-in-class kontrolerima koji imaju najfinije/najbrže PWM module na tržištu dobije se veoma ozbiljna sprava klase profi industriskih servo dravejera poput Siemens, Schneider, Panasonic i ostala ekipa.

Takodje imaju veoma dobru Sitara multi-core platformu sa više Cortex A + M + PRU + NEKA jezgra u jednom čipu, i tu se obično gura FOC za motor + obavezno neki "brzi" industriski iprotokol poput EtherCat i slični.
Imaju gotove primere za kontrolu motora preko mreže sa sve WEB GUI koji dolazi sa Cortex-A jezgra.

[mikikg]

Bavili su se podosta sa tim, ima dosta materijala, na primer ovako nešto:

AM437x Single-Chip Motor-Control Design Guide
https://www.ti.com/lit/ug/tidu800b/tidu800b.pdf

Design Features
• Demonstrates Concurrent Industrial Communications, Current/Position Data Acquisition, and Field Oriented Control (FOC)
• Runs on Processor SDK (Software Development Kit) for AM437x
• Offers a Three-phase FOC of a Single Permanent- Magnet Synchronous Motor (PMSM)
• Offers FOC Drive Current Feedback Using the Onchip ADCs or Sigma Delta Decimation Filtering Under PRU Automation
• Can Provide FOC Position Feedback Using an EnDAT 2.2 Interface to a Position Encoder Under PRU Automation
• Receives Commands and Provides Status Through a Standard CiA402 Drive Profile Over EtherCAT® Industrial Interface to an External EtherCAT Compatible Master
• Uses an External Third-party EtherCAT-Compatible Master Hosted on a PC that Provides a Command Interface to Control the Application
• Offers a Demonstration and Benchmark Example of the AM437x in Communications and Motor- Control Applications
• Offers a Representation of Supported Communications Protocols With Current- and Position-Feedback Interfaces
Featured Applications
• Industrial Applications
• Industrial Communications Protocols 

[andrics]

Nama fali ovo za Relejni Atenuator, jeste prosta stvar ali nema da se kupi tek-tako, tj ima Bourns ali košta 40+E ali da ima osovinu bukvalno istu kod klasičnih potenciometara. To bi bila fina ideja da se odradi u DIY varijanti.

A opticki encoder ,u toj formi ,vam ne odgovara?
Grayhill optical encoder

[savan]

Ne znam koliko je zanimljiv ovakav jedan hal senzor https://www.lcsc.com/datasheet/lcsc_data...913974.pdf , preko i2c veze moze da se cita ugao registar u 14bit rezoluciji, nije komplikovano napraviti encoder u diy varijanti!

[elektropionir]

savane, taj senzor, ili barem slican senzor istog proizvodjaca je na svim onim stepper drajverima koje ti je miki postavio.
Taj senzor je vrlo slican onom kojeg sada trenutno koristim.
Kineski proizvodjaci naravno preferiraju svoje komponente, mosfeti su ja mislim alpha omega, sto je isto ok kineska firma za diskretne komponente, a microcontroller je kineska verzija STM32.

[savan]

Moram pogledati ono sto je Miki gore okacio koje sve senzore ima na sebi onakav jedan step motor kontroler i videti sta sve od senzora ima u sebi ako uspem naci neki link, verovatno su ga vec kopirali i postavili shemu negde na netu, treba to procesljati dobro. Inace ovaj MT6701 moze da ide u rotaciju do 55kRPM, verovatno su ga postavili u analog mod pa na strani mcu broje pulseve po revoluciji 360 i znaju tacno na kojim obrtajima je motor drona, propagation delay ovog senzora je 5us sto je = 200kHz = 12kRPM sto bi mu bio neki limit, poklapa se sa ovim gore sto kazes da su neki uspeli da ga iskoriste za kontrolu motora drona. Odlican je ovaj simpleFOC, postoji i mesta za nadogradnju za neke druge tipove senzora, struja, napon... bas je super i nije nesto preterano obiman i lako se razume : ) Auh ovaj AM437x je zver!

[mikikg]

Auh ovaj AM437x je zver!

Hehe, da vidiš tek AM6442 sa kojim radim nešto, ovo su "core-ovi" u sistemu : )

Code:

ls -la /sys/class/remoteproc/
total 0
drwxr-xr-x  2 root root 0 Apr  8 20:01 .
drwxr-xr-x 73 root root 0 Apr  8 13:47 ..
lrwxrwxrwx  1 root root 0 Apr  8 20:01 remoteproc0 -> ../../devices/platform/bus@f4000/bus@f4000:bus@4000000/5000000.m4fss/remoteproc/remoteproc0
lrwxrwxrwx  1 root root 0 Apr  8 20:01 remoteproc1 -> ../../devices/platform/bus@f4000/bus@f4000:r5fss@78000000/78000000.r5f/remoteproc/remoteproc1
lrwxrwxrwx  1 root root 0 Apr  8 20:01 remoteproc10 -> ../../devices/platform/bus@f4000/30000000.icssg/30004000.rtu/remoteproc/remoteproc10
lrwxrwxrwx  1 root root 0 Apr  8 20:01 remoteproc11 -> ../../devices/platform/bus@f4000/30080000.icssg/30086000.rtu/remoteproc/remoteproc11
lrwxrwxrwx  1 root root 0 Apr  8 20:01 remoteproc12 -> ../../devices/platform/bus@f4000/30080000.icssg/3008c000.txpru/remoteproc/remoteproc12
lrwxrwxrwx  1 root root 0 Apr  8 20:01 remoteproc13 -> ../../devices/platform/bus@f4000/30080000.icssg/300b4000.pru/remoteproc/remoteproc13
lrwxrwxrwx  1 root root 0 Apr  8 20:01 remoteproc14 -> ../../devices/platform/bus@f4000/30080000.icssg/30084000.rtu/remoteproc/remoteproc14
lrwxrwxrwx  1 root root 0 Apr  8 20:01 remoteproc15 -> ../../devices/platform/bus@f4000/bus@f4000:r5fss@78400000/78400000.r5f/remoteproc/remoteproc15
lrwxrwxrwx  1 root root 0 Apr  8 20:01 remoteproc2 -> ../../devices/platform/bus@f4000/bus@f4000:r5fss@78000000/78200000.r5f/remoteproc/remoteproc2
lrwxrwxrwx  1 root root 0 Apr  8 20:01 remoteproc3 -> ../../devices/platform/bus@f4000/30000000.icssg/3000a000.txpru/remoteproc/remoteproc3
lrwxrwxrwx  1 root root 0 Apr  8 20:01 remoteproc4 -> ../../devices/platform/bus@f4000/30000000.icssg/3000c000.txpru/remoteproc/remoteproc4
lrwxrwxrwx  1 root root 0 Apr  8 20:01 remoteproc5 -> ../../devices/platform/bus@f4000/30000000.icssg/30038000.pru/remoteproc/remoteproc5
lrwxrwxrwx  1 root root 0 Apr  8 20:01 remoteproc6 -> ../../devices/platform/bus@f4000/30080000.icssg/3008a000.txpru/remoteproc/remoteproc6
lrwxrwxrwx  1 root root 0 Apr  8 20:01 remoteproc7 -> ../../devices/platform/bus@f4000/30000000.icssg/30006000.rtu/remoteproc/remoteproc7
lrwxrwxrwx  1 root root 0 Apr  8 20:01 remoteproc8 -> ../../devices/platform/bus@f4000/30080000.icssg/300b8000.pru/remoteproc/remoteproc8
lrwxrwxrwx  1 root root 0 Apr  8 20:01 remoteproc9 -> ../../devices/platform/bus@f4000/30000000.icssg/30034000.pru/remoteproc/remoteproc9

[savan]

Samo tu treba bas debelo iskustvo za tako nesto : )

[mikikg]

Nama fali ovo za Relejni Atenuator, jeste prosta stvar ali nema da se kupi tek-tako, tj ima Bourns ali košta 40+E ali da ima osovinu bukvalno istu kod klasičnih potenciometara. To bi bila fina ideja da se odradi u DIY varijanti.

A opticki encoder ,u toj formi ,vam ne odgovara?
Grayhill optical encoder

Nije loš, završio bi posao specifično za atenuator, ali kada je već bal neka bude maskenbal : ) ... 
Na primer za VFO kontrolu od nekog oscilatora valjalo da bude za većom rezolucijom po krugu, da bude fin tj brz da može da se manupuliše brzo sitnim koracima.
Zato pikiram te magnetne senzore sa 14bit rezolucije po krugu, 10bit je realno dosta.

I vidim da ima i varijanta sa "push-button" sa megnetom, da IC prepozna taj pokret magneta kao "click" što je isto sjajna varijanta, dakle sve su predvideli da naprave zamenu za klasičan mehanički/optički enkoder sa click, samo gde je mehanika gde se to umetne? : )