Téma megtekintése - hardver szorzó lépéseket (megvalósíthatósági)
Társaik, de egy ilyen kérdés. Kínzó nekem képtelenség kis microstepping nagy sebességgel a program szintjén - a mac 75kGts viselkedése nagyon instabillá 100 kHz lehet letette szorosan, LinuxCNC általában 50kHz nem ad, és a lappangási-teszt azt mutatja, a rendszer késedelmes
7000ns, ami nekem legfeljebb 44 kHz impulzus generáció. Röviden, mint microstep 1/64 vagy akár 1/128 sebességgel 5000 mm / min, de nincs hardveres impulzusadóval ezt nem lehet elérni. Hardver opciók még mindig vigyáz, és a ravasz lélek varangy, de az ára rájuk fáj a gonoszt.
Általában itt van egy ilyen ötlet, kérjen segítséget - hogy lehetséges-e, hogy végre egy hardveres szorzó lépéseket a külső vezérlő, ideális esetben az Arduino?
A magam részéről van néhány ötlet, mivel - Maceo ki a kívánt microstep vezetett csak szükséges pontosság. Például, szükségünk van egy 0,01 mm lépést, hogy 5 mm / fordulat = 500 lépést tesz meg fordulatonként. De ugyanakkor a motor driver, mi üzembe csípése microstep, például 1/50. Így, ha a sebesség 4500mm / perc (a jó intézkedés) = 75mm / sec = 15 ford / sec mi potreuetsya csak 7500 impulzus / sec, azaz Softovaya vezetők előállításához szükséges impulzusok egy tengelyen 7,5kGts sebességet.
Ezután LPT port elfog egy lépés szorzó (Arduino), azaz tompa tűk olvasható állapotban változó, amíg az utolsó impulzus. Végére a pulzus, van egy rés, hogy a következő lépésben (ha van ideje), hogy reprodukálja a szükséges impulzusok száma, azaz 1. példa reprodukálható impulzusok 20, ami számunkra 1/50 microstep kimenet.
Gondolod, hogy ez a valóság?
Re: hardver szorzó lépéseket (megvalósíthatósági?)
Re: hardver szorzó lépéseket (megvalósíthatósági?)
Gondolod, hogy ez a valóság?
Valóban, de vannak kész vezető szorzóval.
Re: hardver szorzó lépéseket (megvalósíthatósági?)
Hmm, ez elég szomorú.
Itt van egy kód termel csak 100 kHz:
digitalWrite (outPin, LOW);
digitalWrite (outPin, HIGH);
Valamivel jobb, mágia segítségével kicsit, kimenetek 1000 kHz:
7.5kGts szimulálni impulzusokat LPT port:
const int outPin = A2;
void setup () pinMode (A2, kimenetet);
>
void loop () while (1) digitalWrite (outPin, HIGH);
delayMicroseconds (5);
digitalWrite (outPin, LOW);
delayMicroseconds (115);
>
>
A szorzó 4 tengely mentén 1/20, 1/50 a kimeneten (kiinduláskor 1 / 2,5):
byte outVal = B00000000;
// számláló microsteps a lépés kimenet
// szükséges számlálást fragmentáció lépésben bemeneti
//
bájt plnCntX = 0;
bájt plnCntY = 0;
bájt plnCntZ = 0;
bájt plnCntA = 0;
// ütemező állapotát jelzi az léptető kimenetek
// meghatározásához szükséges viselkedését az ütemezőt, amikor a bemeneti megváltozik
//
logikai plnRunX = 0;
logikai plnRunY = 0;
logikai plnRunZ = 0;
logikai plnRunA = 0;
// Előző és a jelenlegi állapot
// jöhet a ciklus tervezése
//
byte inpValPrv = B00000000;
byte inpValCur = B00000000;
void setup () pinMode (30, kimenetet);
pinMode (29, bemenet);
Serial.begin (9600);
>
void loop () // A fő hurok naklanye hatalmas költségek:
// létre, hogy megakadályozzák a menekülési pont feltétel nélküli ugrást
// igen, úgy néz ki, furcsa, de az ötlet egy normál fordító-
// űrlapot JMP, így leszünk újra egy ciklus minimális veszteség
//
STP:
//// tervet a jelenlegi intézkedés léptető kimenetek:
//// beolvassa az értékek bemenet, ha a bemeneti szint megváltozott
//// meghatározni, hogy az a pillanat, esemény, vagy folytatása
//// lépésben lezárás
////
inpValCur = PINA;
//// ha megváltoztatja a bemeneti állapot
////// és impulzusszámláló blank
//////// beállított impulzus számláló
//////// telepíteni a jele
////////. Jött a bemenő
////////. Kezdjük képező microstep
//////, ha az impulzus számlálás nem üres
//////// és van egy jele státusz
////////// eltávolítás jel
//////////. bemenő befejeződött
//////////. Mi továbbra is generál microstep
//////// ha nincsenek jelei
////////// minden elveszett
//////////. Nem volt idő alkotnak minden microstepping
//////////. két lépésben
if ((inpValCur B10000000)! = (InpValPrv ! B10000000)) ha (plnCntX) plnCntX = 20;
plnRunX = 1;
> Else if (plnRunX) plnRunX = 0;
> Else goto dbg;
>
>
>
if ((inpValCur B01000000)! = (InpValPrv ! B01000000)) ha (plnCntY) plnCntY = 20;
plnRunY = 1;
> Else if (plnRunY) plnRunY = 0;
> Else goto dbg;
>
>
>
if ((inpValCur B00100000)! = (InpValPrv ! B00100000)) ha (plnCntZ) plnCntZ = 20;
plnRunZ = 1;
> Else if (plnRunZ) plnRunZ = 0;
> Else goto dbg;
>
>
>
if ((inpValCur B00010000)! = (InpValPrv ! B00010000)) ha (plnCntA) plnCntA = 20;
plnRunA = 1;
> Else if (plnRunA) plnRunA = 0;
> Else goto dbg;
>
>
>
//// Forma szinten a következő impulzus léptető kimenetek:
////, ha az impulzus számlálás nem üres invert szintjén
//// megfelelő kimeneti és csökkenti a impulzusszámláló
////
ha (plnCntX) PORTC = PORTC ^ B10000000;
plnCntX--;
>
ha (plnCntY) PORTC = PORTC ^ B01000000;
plnCntY--;
>
ha (plnCntZ) PORTC = PORTC ^ B00100000;
plnCntZ--;
>
ha (plnCntA) PORTC = PORTC ^ B00010000;
plnCntA--;
>
Alakítás //// jelkimeneteket nem igénylő feldolgozás:
//// egyszerűen másolja az aktuális értéket a bemeneti
////
outVal = inpValCur B00001111;
//// írja le a kapott értékeket a kimeneti port
//// a következő pillanatban, a kimenet etetni bizonyos jeleket
////
PORTC = outVal;
//// A egyenletes kijuttatásra microsteps lépésben választott empirikusan
//// jó meg kell kiszámítani
delayMicroseconds (2);
//// ilyen tervezés impulzusszélesség alacsony jel
=
//// magas szélessége, azaz a a vezető meg tudja határozni a lendület, amíg
//// aprító lépésben, amíg az érték az elfogadható határokon belül. KMK
////
goto stp;
//// Szorongás, szorongás, farkas ellopta leverets!
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;
>
Ha valaki mondja meg, hol lehet faragni nemnozhno ciklust, azt szívesen.