Colegii, dar această întrebare. Torturarea mi incapacitatea microstepping mici la o viteză ridicată la nivel de program - pe Mac 75kGts se comportă foarte instabilă la 100 kHz poate fi închis ermetic, în general, mai mult LinuxCNC 50KHz nu dă, și latență-test indică întârzierea în sistem
7000ns, care îmi dă un maxim de 44kHz pentru generarea de impulsuri. Pe scurt, vreau un microstep de 1/64 sau chiar 1/128 la o viteză de 5000mm / min, dar fără un generator de impulsuri hardware, acest lucru nu poate fi atins. Opțiuni hardware, eu încă mă uit pentru și în tăcere broască broasca, dar eticheta de preț pe ele este dureros de supărat.
În general, aici există o astfel de idee, cere ajutor - dacă este posibil să se pună în aplicare un hardware pași de multiplicare pe controlerul extern, în mod ideal pe Arduino?
Pentru mine, îmi imaginez aproximativ acest lucru - în coadă am pus micro-pasul dorit ghidat doar de precizia necesară. De exemplu, avem nevoie de 0,01 mm pe pas, care este la 5mm / rev = 500 pași pe revoluție. Dar, în același timp, conducătorul motorului expune microstepul patentat, de exemplu 1/50. Astfel, la o viteză de 4500mm / min (pentru numărarea netedă) = 75mm / sec = 15 r / s, vom avea nevoie doar de 7500 imp / sec, adică de la driverul de software va necesita generarea de impulsuri la o viteză de 7.5kHz per axă.
Apoi, facem pasul de la port la multiplicator (arduin), adică citiți stupid starea pinilor din variabila atâta timp cât pulsul durează. După terminarea impulsului, putem reproduce numărul necesar de impulsuri în intervalul până la pasul următor (dacă avem timp). de exemplu, reproducem 20 de impulsuri pe pas, ceea ce ne dă un microstep de 1/50 la ieșire.
Crezi că e adevărat?
Re: Multiplicatorul pasului hardware (posibilitatea de implementare?)
Re: Multiplicatorul pasului hardware (posibilitatea de implementare?)
Crezi că e adevărat?
Într-adevăr, dar există drivere gata cu un multiplicator.
Re: Multiplicatorul pasului hardware (posibilitatea de implementare?)
Hmm, totul e destul de trist.
Iată codul care produce numai 100kHz:
digitalWrite (outPin, LOW);
digitalWrite (outPin, HIGH);
Un pic mai bine, cu ajutorul magiei bit, produce 1000kHz:
7.5kHz, pentru a simula impulsuri din portul lpt:
const int outPin = A2;
void setup () pinMode (A2, OUTPUT);
>
void loop () în timp ce (1) digitalWrite (outPin, HIGH);
întârziereMicrosecunde (5);
digitalWrite (outPin, LOW);
întârziereMicrosecunde (115);
>
>
Multiplicator pentru 4 axe 1/20, la ieșirea 1/50 (la valoarea inițială 1 / 2,5):
byte outVal = B00000000;
// Contoare microstep pentru ieșiri pas cu pas
// necesar pentru a număra fragmentarea de intrare efectuată
//
byte plnCntX = 0;
byte plnCntY = 0;
byte plnCntZ = 0;
byte plnCntA = 0;
// Un semn al stadiului planificatorului pentru ieșirile pasului
// necesar pentru a determina comportamentul planificatorului la schimbarea intrării
//
boolean plnRunX = 0;
boolean plnRunY = 0;
boolean plnRunZ = 0;
boolean plnRunA = 0;
// Starea anterioară și cea actuală a intrării
// util pentru programarea tactului
//
byte inpValPrv = B00000000;
byte inpValCur = B00000000;
void setup () pinMode (30, OUTPUT);
pinMode (29, INPUT);
Serial.begin (9600);
>
void loop () // Ciclul principal are costuri uriașe de cheltuieli:
// pentru a preveni ieșirea, setați punctul de salt necondiționat
// Da, pare destul de ciudat, dar teoretic un compilator normal
// va forma aici jmp, deci vom reveni la ciclu cu pierderi minime
//
stp:
//// Planificăm pasul curent al ieșirilor pasului:
// // citiți valorile de intrare dacă nivelul de intrare sa modificat
determină dacă acesta este momentul apariției, continuării sau
//// sfarsitul pasului
////
inpValCur = PINA;
//// Dacă starea de intrare sa schimbat
////// iar contorul de impulsuri este gol
//////// setați contorul de impulsuri
//////// stabilește caracteristica
////////. la intrare era un pas
////////. începe să formeze microstepuri
////// în cazul în care contorul de impulsuri nu este gol
//////// și există o indicație a stării
////////// elimina semnul
//////////. pasul de intrare sa încheiat
//////////. continuă să formeze microstepuri
//////// dacă nu există nici o indicație
////////// totul a fost pierdut
//////////. nu a reușit să formeze toate micro-pașii
//////////. între două etape
dacă ((inpValCur B10000000)! = (InpValPrv B10000000)) dacă (! PlnCntX) plnCntX = 20;
plnRunX = 1;
> altfel dacă (plnRunX) plnRunX = 0;
> altceva a obținut dbg;
>
>
>
dacă ((inpValCur B01000000)! = (InpValPrv B01000000)) dacă (! PlnCntY) plnCntY = 20;
plnRunY = 1;
> altfel dacă (plnRunY) plnRunY = 0;
> altceva a obținut dbg;
>
>
>
dacă ((inpValCur B00100000)! = (InpValPrv B00100000)) dacă (! PlnCntZ) plnCntZ = 20;
plnRunZ = 1;
> altfel dacă (plnRunZ) plnRunZ = 0;
> altceva a obținut dbg;
>
>
>
dacă ((inpValCur B00010000)! = (InpValPrv B00010000)) dacă (! PlnCntA) plnCntA = 20;
plnRunA = 1;
> altfel dacă (plnRunA) plnRunA = 0;
> altceva a obținut dbg;
>
>
>
//// Formează nivelul următorului impuls pentru ieșirile pasului:
//// dacă contorul de impulsuri nu este gol, inversați nivelul
// / ieșire corespunzătoare și reduceți contorul de impulsuri
////
dacă (plnCntX) PORTC = PORTC ^ B10000000;
plnCntX--;
>
dacă (plnCntY) PORTC = PORTC ^ B01000000;
plnCntY--;
>
dacă (plnCntZ) PORTC = PORTC ^ B00100000;
plnCntZ--;
>
dacă (plnCntA) PORTC = PORTC ^ B00010000;
plnCntA--;
>
//// Formează semnalul pentru ieșirile care nu necesită prelucrare:
//// copiați doar valorile curente de la intrare
////
outVal = inpValCur B00001111;
//// Înregistrați valorile de ieșire ale ieșirilor în port
//// în momentul următor vor fi trimise semnale la ieșire
////
PORTC = outVal;
//// Pentru a împrăștia uniform etapele micro într-un pas, este selectat empiric
// // pentru bine este necesar să se calculeze
întârziereMicrosecunde (2);
//// Cu o astfel de planificare puls, lățimea semnalului scăzut va fi
=
// / lățimea înălțimii, adică Soferul va putea determina pulsul,
//// atâta timp cât valoarea împărțirii pasului se situează în limite acceptabile. KMK
////
goto stp;
//// Anxietate, anxietate, un lup furat un împrumut!
DBG:
Serial.print ("ERR");
Serial.print ("\ t");
Serial.print (outVal, BIN);
Serial.print ("\ t");
Serial.print (inpValPrv, BIN);
Serial.print ("\ t");
Serial.print (inpValCur, BIN);
Serial.print ("\ t");
Serial.print (plnCntX);
Serial.print ("\ t");
Serial.print (plnRunX);
Serial.print ("\ n");
plnCntX = 0;
plnRunX = 0;
>
Dacă cineva îți spune unde poți tăia câteva baruri aici, mă bucur.