Mimo potężnego skoku technologicznego na rynku prostych maszyn CNC absolutnie nie widać tego w cenach usług dla ludu. O ile oczywiście nie warto budować cegielni żeby mieć parę cegieł to w przypadku prostych domowych urządzeń CNC warto sprawę przemyśleć bo może się okazać, że za cenę jednej usługi u obcych możemy złożyć swoją własną maszynkę.

Ten manual pokaże jak od początku zrobić sobie coś takiego

Oczywiście dostępnych rozwiązań na rynku jest całe mnóstwo ale chciałbym się skupić na jednym. Jako, że jest najprostsze i absolutnie najtańsze. Nie pozwoli nam na zbudowanie super maszyny, za pomocą której będziemy mogli robić projekty dla NASA ale "dla naszych potrzeb" absolutnie wystarczy.
Z czasem gdy nabierzecie wprawy a przede wszystkim wiedzy - można zawsze zbudować maszynę o większych możliwościach.

Ok, wstęp przydługi żeby powiedzieć jedno: GRBL. https://github.com/grbl/grbl/wiki

Czym jest GRBL?
To bezpłatny, otwarty projekt stworzony by kontrolować ruch we wszelkiego typu maszynach CNC. Mówimy tu o ploterach, frezerkach czy drukarkach 3D. A przy odrobinie wyobraźni/zmian można sterować też innymi typami maszyn.
Jest oparty na platformie Arduino i do działania absolutnie nie potrzebuje komputera! Chociaż można z niego korzystać.
Grbl obsługuje głównie 3 osie, ale również 2 - póki co nie istnieje wersja z 4 osią - czyli obrotem materiału czy głowicy tnącej.
Ma również możliwość klonowania osi - jeśli z jakiś powodów chcemy mieć 2 silniki w jednej osi.
Grbl steruje silnikami krokowymi typu bipolarnego (4 przewody) ale jeśli akurat w szufladzie mamy silniki z 6 przewodami - nic straconego, tutaj znajdziecie opis jak to poprawić: http://rcclub.eu/viewtopic.php?f=108&t=8117

Każda oś ma swoją nazwę i takiej nomeklatury się trzymamy. Bez względu na fizyczność samej maszyny układ literek pozostaje bez zmian.

Żeby zbudować całe sterowanie będziemy potrzebować:
- płytkę Arduino z procesorem 328p, wybierając ArduinoUno zyskacie łatwość w podłączaniu jej do komputera oraz do płytki ze sterownikami silników
- dla płytek Arduino bez USB będzie potrzebny interfejs USBttl np Cp2102
- płytkę pod sterowniki silników (EasyDriver, grblshield, stepper shield) - opcji jest wiele ważne żeby sterowanie odbywało się przez STEP/DIR. Każdy driver służy do obsługi różnej mocy silników - zamawiając upewnijcie się, że będą pasować. Do tego 2 sztuki lub więcej sterowników silnika.
- zasilacz lub dwa w zależności od tego jakie mamy silniki, czyli czy wystarczy nam jedno zasilanie na całość
- maszynę CNC wystarczy nawet taka z wózków napędów CDROM

- lutownicę, cynę
- przewody połączeniowe

I Lutujemy, wgrywamy bootloadera Arduino

W zależności od wybranej opcji na stole możemy mieć na przykład coś takiego:

Cnc shield zazwyczaj udaje się kupić gotowy ale są też wersje do samodzielnego montażu, wtedy warto skorzystać z manuala kolejności lutowania:
http://blog.protoneer.co.nz/arduino-cnc-shield-v3-00-assembly-guide
Zwróćcie uwagę, na to, że można kupić płytki w różnych wersjach lub od innych producentów czy do innych zastosowań. Poniżej zestaw oparty o Nano, 2 osie i dodatkowo sterowanie laserem czyli widzimy grawerkę cnc.

A tu 3 sterowniki silników czyli np drukarka 3d, albo frezarka 3 osiowa również z Nano

Natomiast StepSticki czyli właściwe sterowniki silników przychodzą w stanie "do polutowania". Piny możemy wlutować od góry albo do dołu w zależności od tego gdzie dalej będą instalowane. Pamiętajcie, że płytka cnc shield jest tylko pomocą do złożenia całości więc możemy ją zupełnie pominąć i podłączyć wszystko "na pająka"

Tak wygląda nieco uproszczony schemat podłączenia jednej płytki sterownika silnika do Arduino (brakuje kondensatora w linii zasilania silnika, oraz podłączenia pinu ENABLE

Złożone płytki odkładamy na bok - gdyż chwilowo nie będziemy ich podłączać! Z resztą jeszcze będą zworki do poustawiania.

Żeby na każdym etapie eliminować możliwe błędy sprawdźmy czy jest wgrany bootloader do naszej płytki Arduino. Żeby to zrobić uruchamiamy środowisko Arduino IDE podłączamy płytkę, wybieramy typ płytki i numer portu oraz wgrywamy przykładowo program z Plik->Przykłady->01 Basics->Blink

Jeśli mamy wgrany bootloader, program się załaduje i po chwili wbudowana na płytce dioda zacznie mrugać. Oznacza to, że możemy iść dalej.
GRBL zapisuje wszystkie swoje ustawienia w pamięci EEPROM Arduino - warto więc ją wyczyścić żeby mieć pewność, że nie ma tam żadnych śmieci.

Plik->Przykłady->EEPROM->eeprom_clear a zanim wgramy ten program do płytki znajdujemy tam taką linijkę:


i zmieniamy na 1024, czyli:



Jeśli wgrywanie programów się nie powiodło należy wgrać bootloader, temat opisany jest tu na forum: http://rcclub.eu/viewtopic.php?f=108&t=6601

c.d.n.
W następnej części pojawi się opis wgrywania GRBL do arduino.

II wgrywamy oprogramowanie GRBL do Arduino

Jeśli już wiemy, że nasza płytka Arduino działa poprawnie czas na wgranie właściwego oprogramowania Grbl. To taki kroczek "quick win" jak mawiają trenerzy personalni Roboty niewiele a zmiana spora.

Na początek ściągamy plik wsadu ze strony: https://github.com/grbl/grbl/downloads
A dokładniej: https://github.com/downloads/grbl/grbl/grbl_v0_9a_edge_328p_16mhz_9600_build20121210.hex
Zapisujemy go na dysku.
Teraz potrzebujemy program, który posłuży do wgrania powyższego pliku do płytki. Idziemy więc do strony XLoader'a:
http://xloader.russemotto.com/ i ściągamy: http://xloader.russemotto.com/XLoader.zip
Po zapisaniu na dysku i rozpakowaniu dostaniemy takie pliki:



Teraz podłączamy naszą płytkę Arduino do komputera oraz uruchamiamy XLoader.exe

Wybieramy port do którego mamy podłączoną naszą płytkę,
Wskazujemy na położenie wcześniej pobranego pliku grbl_v0_9a_edge_328p_16mhz_9600_build20121210.hex
Sprawdzamy ustawioną prędkość portu ma być:
57600 dla Duemilanove/Nano (ATmega 328) albo
115200 dla Uno (ATmega 328)

Klikamy UPLOAD

Proces zajmie około 10 sekund, gdy się zakończy po lewej stronie na dole zobaczycie ile danych się władowało do uC.

Ładowanie zakończone Możemy zamknąć program XLoader i ściągnąć Grbl Controller 3.6.1
http://zapmaker.grblcontroller.s3-website-us-west-2.amazonaws.com/
Po zainstalowaniu uruchamiamy, wybieramy port do którego jest podłączone Arduino oraz klikamy Open

Po połączeniu zobaczycie taki obrazek jak poniżej, oznacza to, że program połączył się z Arduino oraz pobrał konfigurację! Brawo!

Przyciskami (strzałki) po prawej możemy spróbować "poprzesuwać" poszczególne osie. Oczywiście na razie nic się nie wydarzy oprócz zmian na ekranie gdyż nie mamy podłączonych silników ani sterowników.

Możemy też spróbować otworzyć jakiś plik z gotowym g-kodem tu w przykładzie motorówka Monika - jeśli jeszcze ją pamiętacie

Możemy też zmienić program i uruchomić np. Lite Fire Laser, o którym było już trochę tu na Forum.


c.d.n. w następnej części zajmiemy się zworkami oraz wytłumaczeniem co gdzie jest na płytce cnc shield

III Mapa płytki CNC Shield oraz użycie zworek

No więc, ten tego, mamy awers i rewers albo górę i dół jak kto woli. Na obydwu stronach płytki mamy nadrukowanych sporo informacji:


Mamy też sporo pinów z każdej strony.

Zajmijmy się najpierw dołem płytki.
Jeśli mamy zamiar używać Arduino UNO to właśnie te wszystkie wystające piny po wciśnięciu będą pasowały jak ulał do płytki UNO - ale czy aby na pewno?
Bo właśnie tu pojawia się pierwsza niespodzianka. Dla wersji Grbl v0.9 ze sterowaniem wrzeciona za pomocą PWM zostały zamienione piny Z-limit i "spindle enable" ponieważ tylko pin D11 ma PWM. Musicie więc wiedzieć, którą wersję GRBL wgrywacie i którą funkcjonalność potrzebujecie.

Po prawej tradycyjny układ po lewej układ ze sterowaniem PWM wrzeciona.

Jeśli natomiast nie używacie krańcówki dla osi Z (limit Z) i nie sterujecie wrzecionem z programu, nie musicie się tym kawałkiem przejmować. Gdyż nie ma to znaczenia gdzie (na który pin) program wyśle nieużywane sterowanie.

Jeśli nie wykorzystujemy płytki UNO tylko na przykład NANO PRO będziemy musieli użyć "paru" przewodów połączeniowych. Łączących te 2 płytki razem. Jakieś 25 (na oko).


Góra płytki jest podzielona na parę odzielnych bloków. Mamy więc 2 bloki zdublowane z dołu płytki czyli są tu wszystkie piny, którymi podłączamy się do płytki Arduino. Nimi płyną rozkazy do sterowników.

Czyli albo wpinamy płytkę CNC Shield do Arduino UNO i zapominamy o tych 2 blokach, albo zapominamy o pinach na dole i podłączamy po kolei do każdego pinu w tych 2 blokach przewód łączący z odpowiednim pinem w Nano PRO.

Mamy blok sterowania maszyną czyli włączania wrzeciona/laseru, wyłączniki krańcowe a także główny wyłącznik emergency (e-stop to to samo co przycisk reset). Czarna część listwy kołkowej to minus.


Typowa krańcówka czyli przycisk chwilowy ma 3 wyprowadzenia:

NC - normalnie połączony
NO - normalnie otwarty
COM - wspólny/komunikacyjny
Naciskając krańcówkę powodujemy, że styk NC straci połączenie a styk NO uzyska połączenie z przewodem wspólnym. Większość profesjonalnych maszyn pracuje na połączeniach typu NC czyli dopiero rozwarcie zestyków powoduje działanie - takie podłączenia to bezpieczeństwo bo jeśli stracimy połączenie z krańcówką to system zanotuje to tak samo jakby była wciśnięta. Grbl jest prostym systemem więc jest na odwrót Jeśli chcemy żeby krańcówka zadziałała to musi ona zwierać czyli używamy końcówek COM i NO albo możemy to zasymulować spinaczem biurowym
Jak widzicie mamy 6 miejsc na krańcówki czyli na każdą oś po 2. Na jej początek i koniec. Tak jest najbezpieczniej wtedy jeśli coś pójdzie nie tak maszyna sama siebie nie zniszczy...
W niektórych miejscach internetu znajdziecie informację o konieczności podłączania rezystorów do krańcówek. Jednak aktualna wersja ich nie potrzebuje.

Oprócz powyższych możemy sobie podłączyć też 3 dodatkowe pstrykacze - piny Abort, Hold i Resume. Przydadzą się do szczątkowego sterowania maszyną - zwłaszcza na początku całej przygody. Podobnie jak krańcówki nie potrzebują rezystorów i wystarczy tu dać mikrostyki chwilowe.

Jest też blok zasilania silników. Jeśli zasilanie silników i zasilanie płytki pochodzi z różnych źródeł należy pamiętać żeby połączyć ich masy.


oraz 4 moduły przeznaczone dla poszczególnych driverów silników.
Każdy z nich ma 4 piny po prawej przeznaczone do podłączenia silnika krokowego (cewki: 1A,1B,2A,2B) oraz 3 zworki M0,M1 i M2 dla ustawienia w jakim trybie ma pracować silnik. Krokowo, półkrokowo, itd.


Zworki wstawiamy przed podłączeniem drivera A4988. Jeśli nie wiecie, który tryb wybrać wybierzcie pełnokrokowy czyli wszystkie zworki założone. W specyficznych rozwiązaniach można użyć innego sterowania zmieniając ich konfigurację.
Dla 3 działających osi będziecie potrzebować 9 zworek. Płytka A4988 - driver silnika ma mieć potencjometr skierowany w dół - nad zworkami M0,M1,M2. Jeśli wepniecie na odwrót - spalicie.

Pomiędzy elementami znajduje się też ukryty bezpiecznik zabezpieczający obwód zasilania silników.


Gdybyśmy podłączali wszystko bezpośrednio do płytki Arduino (nie mając CNC shield) to wtedy musimy rozprowadzić pin
D8 Stepper Enable/Disable na tyle osi ile używamy. Pin enable jest tylko jeden a każda płytka drivera go potrzebuje żeby ruszyć.
Dodatkowo nie używając płytki cnc shield musimy zdublować podłączenie krańcówek jak na obrazku poniżej.



PAMIĘTAJCIE ŻEBY NIGDY NIE PODŁĄCZAĆ DRIVERÓW BEZ PODPIĘTYCH SILNIKÓW! Czyli możemy się pobawić samym Arduino ale na ten czas odpinamy płytki driverów!


c.d.n. W następnym odcinku klonowanie osi i ustawienia Grbl.

IV Clone Wars czyli Klonowanie osi silnika

W niektórych konstrukcjach maszyn zachodzi potrzeba dodania kolejnego silnika do jednej z osi. Mając płytkę CNC Shield możemy sklonować taki jeden kanał.
Orygianlnie płytka jest przeznaczona do sterowania 3 osiami (X,Y i Z). Oś oznaczona jako A - jest przeznaczona na bycie klonem.

Tu macie przykład takiej dwusilnikowej maszynki:https://sites.google.com/site/3dprinterlist/lasercutters/laser-v



Blok na płytce odpowiadający klonowaniu znajduje się tutaj:



Żeby sklonować oś/silnik musimy:
- ustawić zworki sterowania krokiem (M0,M1,M2) tak samo jak klonowany silnik
- dostarczyć informacji o krokach i kierunku, czyli przekazać piny: STEP i DIR
Robi się to bardzo łatwo, lewa część niebieska odpowiada za kroki (STEP) a prawa żółta za kierunek (DIR). Sklonowanie polega na dodanie 2 zworek w linii (na rysunku oznaczone kolorem pomarańczowym i niebieskim) z opisem odpowiadającym osi z której bierzemy sygnał:

I to tyle - mówiłem, że proste? Pozostaje podłączyć 4 przewody do silnika pamiętając, o tym, że klonowany silnik powinien obracać się w przeciwną stronę - mówię o większości konstrukcji.

c.d.n. Następna część to ustawiania GRBL czyli dolarki $

V Ustawienia Grbl
Czas napić się kawy bo będzie potrzebne trochę myślenia. Żeby dobrze skonfigurować maszynę musimy wiedzieć co możemy ustawić i jak poszczególne ustawienia mogą na nią wpłynąć. Inaczej będziemy ustawiali ploter wykorzystujący do przesuwu osi pręt gwintowany (szpilkę) załóżmy M8 a inaczej maszynę wyposażoną w paski zębate.
Tylko od Was zależy czy maszyna będzie szybka, cicha i dokładna czy wprost przeciwnie.

Po podłączeniu się do sterownika on zgłasza swoją gotowość przedstawiając się numerem wersji oprogramowania Grbl. Numer wersji jest dość istotny ponieważ od niego zależy jak całość będzie działać.

I teraz ciekawostka wersja 0.9a ma wszelkie ustawienia jeszcze z wersji 0.8.

Natomiast "prawdziwą" wersję 0.9g można znaleźć na:
https://github.com/grbl/grbl


Ustawienia dla wersji 0.8
Zaraz po podłączeniu dostaniemy numer wersji oprogramowania wgranego do Arduino, tutaj 0.9a:

a także po wpisaniu znaku dolara $ listę możliwych opcji do wpisania:


Wszystkie komendy wpisujemy w tym miejscu, potwierdzając enterem:


Pamiętajcie, że na tym etapie dalej nie musimy mieć podłączonych driverów ani silników - wystarczy goła płytka Arduino lub taka z podpiętym CNC SHield.
Wpisujemy $$, dostaniemy w odpowiedzi listę wszystkich ustawień:

Pierwsze znaki opisują numer ustawienia, potem po znaku "=" mamy aktualnie przypisaną wartość dla tego ustawienia a w nawiasie opis słowny - żeby nie trzeba było pamiętać wszystkiego.
Wprowadzenie zmiany polega na wpisaniu numeru ustawienia i nowej wartości. Gdybyśmy więc chcieli zmienić ustawienie dotyczące ilości kroków na przesunięcie osi X o 1 mm, znajdujemy właściwy wpis:

wpisujemy:


Pamiętajcie żeby zawsze wpisywać nowe wartości w formacie jaki dla danego pola obowiązuje, czyli w tym przypadku dodanie kropki i 3 zer. Po wysłaniu sterownik odpowie nam
'ok'

Jeśli ktoś nie lubi pisać może użyć interfejsu graficznego i tu wpisać potrzebne wartości:

Po wpisaniu naciskamy Apply

W zależności od wersji oprogramowania (w tym przypadku 0.9a) ustawienia mogą być inne. Przypomnę że wersja 0.9a bazuje na ustawieniach 0.8.Pełna lista dla tej wersji to:


OPIS kolejnych ustawień

$0, $1 i $2 – [X,Y,Z] steps/mm
Ilość kroków silnika na mm. GRBL musi wiedzieć ile kroków musi wysłać do sterownika żeby w rzeczywistości przemieścić daną oś o 1mm. Liczymy więc:
- musimy znać ilość kroków na 1 pełny obrót przy sterowaniu pełnokrokowym nazwijmy to jak reszta świata: "steps_per_revolution"
- musimy wiedzieć jak sterujemy naszym silnikiem (przypomnę zworki M0,M1,M2) pełnokrokowo, półkrokowo, itd podstawiamy: 1, 2, 4, 8, lub 16 dla "microsteps"
- ilość mm przejechanych przez oś w czasie 1 obrotu silnika - "mm_per_rev"
Podstawiamy do wzoru:
steps_per_mm = (steps_per_revolution*microsteps)/mm_per_rev
To co nam wyjdzie wstawiamy do ustawień:
$0 dla osi X,
$1 dla osi Y,
$2 dla osi Z.

Powyższe łatwiej się liczy dla śrub metrycznych (szpilek) - dla przykładu gwint M8 i M9 ma skok 1,25
weźmy do tego silnik ustawiony na półkrok (2) który normalnie robi 200 kroków na 1 obrót:

(2 microsteps/step) x (200 steps/motor_rev) x (1 motor_rev/screw_turn) / (1.25 mm/screw_turn) = 320 microsteps/mm

wpisujemy 320 i gotowe

Teraz możemy tjuningować (śruby nie zmieniamy bo już kupiliśmy), a reszta:
200-step-per-rev motor, full stepping: 160 microsteps/mm
200-step-per-rev motor, half stepping: 320 microsteps/mm
200-step-per-rev motor, 8x microstepping: 1280 microsteps/mm
200-step-per-rev motor, 16x microstepping: 2560 microsteps/mm
400-step-per-rev motor, full stepping: 320 microsteps/mm
400-step-per-rev motor, half stepping: 640 microsteps/mm
400-step-per-rev motor, 8x microstepping: 2560 microsteps/mm
400-step-per-rev motor, 16x microstepping: 5120 microsteps/mm

Spore różnice, prawda?
Dla paskowców (napęd osi to pasek zębaty i rolka zębata) i do tego jest kalkulator: http://homepage.ntlworld.com/r.j.noble/ ... /grblcalc/

$3 - (microseconds step pulse)
Każdy silnik krokowy może przyjąć jakąś minimalną długość impulsu dla kroku w mikrosekundach. Szczęśliwcy będą mieli to podane w nocie katalogowej silnika, inni muszą znaleźć eksperymentalnie. Zaczynamy od 10. Za długie mogą spowodować nachodzenie ich na siebie. Zazwyczaj sprawdza się liczba z przedziału 5-50.


$4 (mm/min default feed rate), $5 (mm/min default seek rate)
Dwie zmienne, które mówią o prędkości przesuwu w mm na minutę. Normalnie wysyłamy tą informację w kodzie do cięcia (g-code) Jednak nie wszystkie programy CAM ją ustawiają. Stąd GRBL ma ustawiony te dwie prędkości jako domyślne.
seek to komenda - G0
feed to komendy - G1,G2,G3

Seek ($5) powinien być ustawiony na maksymalną możliwą prędkość maszyny gdyż jest używany na podróż narzędzie gdy nie pracuje => skok do następnego punktu

Feed ($4) jest prawie zawsze wysyłany przez programy typu CAM, więc rzadko używamy ten z konfiguracji często ustawiany też na maksymalną prędkość lub nieco mniejszą niż dla seek.

$4 = 500.000
$5 = 500.000

Niektórzy ustawiają je na tą samą wartość.

UWAGA! W kolejnych wersjach konfiguracji domyślny "feed rate" zostanie usunięty na rzecz sterowania nim z gcode.


$6 (step port invert mask. int = 00000000)Odwrócenie sygnału kroku (step) dla wszystkich osi. Jeden z zaawansowanych paramaterów używany gdy nasze sterowniki (drivery) silników tego potrzebują lub dla małego oszustwa wprowadzającego sztuczną zwłokę pomiędzy wysłaniem 2 komunikatów STEP i DIR.
Normalnie sygnały są wysyłane jako wysoki lub niski dla kierunku (DIR) a następnie wysoki opadający na niski w ciągu kilku mikrosekund dla sygnału kroku.
Wartości wprowadzamy jako liczbą dzisiętną na podstawie tabelki, z której program tłumaczy sobie to na zapis dwójkowy.

X_STEP_BIT 2
Y_STEP_BIT 3
Z_STEP_BIT 4
X_DIRECTION_BIT 5
Y_DIRECTION_BIT 6
Z_DIRECTION_BIT 7

Jeśli więc chcemy odwrócić kierunek (DIRECTION) dla X i Y musimy wykonać przesunięcie bitowe:
(1<<X_DIRECTION_BIT)|(1<<Y_DIRECTION_BIT)

czego wynikiem jest 96
i taką liczbę wpisujemy:
$6=96
co da nam 1 na bitach 5 i 6:
$6=96 (step port invert mask. int:1100000)


$7 (step idle delay, msec)
Po każdym wykonanym kroku silnik ma okres zatrzymania - w tym czasie możemy utrzymywać jego stan jako włączony (enable) lub wyłączony (disable). Ta zmienna ustawia blokadę na silnik, może przyjmować 3 stany:
$7=255 silniki zawsze włączone (enable)
$7=0 silniki zawsze wyłączone (disable)
$7=1 do $7=244 czas w mikrosekundach dla silnika po każdym kroku na dokończenie zatrzymania.
Wszystko zależy więc od silników które macie, są takie które w czasie ciągłego włączenia/wyłączenia pogubia kroki, są takie które muszą to mieć ustawione na np 25-50 a są takie które muszą być cały czas włączone lub będą pracowały bez względu na to co tu wpiszecie. Czyli wpisujemy, testujemy, wpisujemy, testujemy, wpis.....


$8 (acceleration in mm/sec^2)
Przyspieszenie. http://pl.wikipedia.org/wiki/Przyspieszenie
"Normalnie" w fizyce w układzie Si opisujemy je jako metr na seukndę do kwadratu. Tutaj jest to milimetr na sekundę do kwadratu.

Składnik określa maksymalne możliwe przyspieszenie dla wszystkich osi maszyny. Jest więc dość ważny gdyż on niego między innymi będzie zależało ile rozkazów popłynie do silników w określonym czasie.

Dla przykładu jeśli mamy silnik 200 kroków na obrót, ustawiony na mikrokroki 1/16, podłączony do szpilki M8 (skok 1,25) da nam to 2560 kroków na przesunięcie o 1mm.
Jest fajny kalkulator na samym końcu strony który pokaże czy i jak długo utrzymacie swoją spodziewaną prędkość
http://www.prusaprinters.org/calculator/
wpiszcie np 300 w Acceleration
200 w Distance or axis length
150 w Desired speed
Oznacza to, że maszyna z przyspieszeniem 300 mm/sec^2 osiągnie spodziewaną prędkość po przejechaniu 37,5mm, jednak nie osiągnie maksymalnego pułapu prędkości gdyż przy ok 250 mm/sec^2 (i dystansie przebytym 100mm) zacznie hamować osiągając koniec naszej spodziewanej prędkości przy 162,5mm
Czyli krótkie maszyny będą przyspieszać żeby po chwili hamować. Większe maszyny będą mogły pracować szybciej i mniej obciążać silniki.

$9 = 0.050 (junction deviation, mm)
Wartość wykorzystywana przez algorytm zarządzający prędkością w czasie pokonywania zakrętów. Dla wymagających można sobie poczytać o całej podstawie matematycznej: https://onehossshay.wordpress.com/2011/09/24/improving_grbl_cornering_algorithm/
Reszta może zacząć od 0.05. Jeśli w zakrętach maszyna ma problemy zmniejszamy tę liczbę, jeśli pracuje za wolno ale widać, że mogłaby szybciej zwiększamy.

Większa liczba oznacza większą prędkość.


$10 = 0.100 (arc, mm/segment)
W większości przypadków nie musimy tu nic ruszać. Wartość wykorzystywana przy wycinaniu kół i łuków ponieważ grbl tnie je na malutkie proste kawałeczki.

Jeśli więc Twoje kółko lub łuk jest zbyt "surowe" i wygląda jak pocięte siekierką a nie zaawansowaną maszyną można się pokusić o zmianę.
Mniejsza liczba = większa precyzja ale też mniejsza prędkość.


$11 = 25 (n-arc correction, int)
Kolejny zaawansowany punkt. W 999999 przypadkach na milion nie warto jej ruszać. Postało żeby było możliwe stosowanie kodów dla łuków G02/03. GRBL oblicza w przybliżeniu położenie następnego segmentu za pomocą kolejnych N-łuków i ich mniejszych kątów. Im więcej wpiszemy tym więcej liczenia ma program. Domyślne wartości są dobre. Aksjomat taki.


$12 = 3 (n-decimals, int)
Mówi z jaką precyzją GRBL pokazuje liczby zmienno przecinkowe, tu ustawione na 3 miejsca. Raczej nie ruszamy.


$13 = 0 (report inches, bool)
W jakich jednostkach pracuje grbl 0 to milimetry, 1 to cale. Domyślnie pracuje w milimetrach.


$14 = 1 (auto start, bool)
Autostart. Profesjonalne maszyny mają swój przycisk, który uruchamia ich pracę. Grbl też może mieć ale niedomyślnie. Domyślnie sam się uruchamia jeśli tylk o mamy dla niego dane - więc nie potrzebuje też fizycznych przycisków. Jeśli więc zdecydujecie się na takie profesjonalne sterowanie jak w dużych maszynach doróbcie przycisk "cycle" oraz "feed-hold" i zmieńcie wartość tego pola na 0.


$15 = 0 (invert step enable, bool)
Zachowanie pinu enable. Domyślnie low = enable a high = disable jeśli ze względu na sterowniki silników potrzebujecie na odwrót wpisujecie tu 1.


$16 = 0 (hard limits, bool)
Bezpieczeństwo. Ten przełącznik włącza używanie krańcówek. Domyślnie jak widzicie ma je wyłączone jeśli więc chcecie je stosować trzeba tu wtawić 1. Zwarcie dowolnej krańcówki spowoduje natychmiastowe wyłaczenie wszystkich osi, wrzeciona oraz chłodzenia wrzeciona (jeśli ktoś go używa). Po takim zatrzymaniu maszyna jest w ciemnym lesie i raczej nie będzie możliwe ponowne wystartowanie gdyż część kroków z pewnością bezpowrotnie utraciliśmy.


$17 = 0 (homing cycle, bool)
Są dwa typy krańcówek. Jedne dla opcji homing drugie dla "hard limits" W sumie może być ich 6. Na osi X 2 szt, na Y 2szt i na Z 2szt. Krańcówki dla homing montujemy w najdalszym możliwym położeniu dla wartości +X, +Y i +Z.
Z kolei krańcówki "hard limits" montujemy w najdalszym skrajnym położeniu dla wartości -X, -Y i -Z.
Wartość 1 oznacza włączoną funkcję homing. Od teraz wystarczy wysłać maszynę do domu - homing i ona już sobie go znajdziec, co ważne zawsze w tym samym miejscu.


$18 = (homing dir invert mask, int:00000000)
Domyślnym ustawieniem jest położenie domu w części dodatniej koordynatów maszyny czyli +X, +Y i +Z co z kolei oznacza, że najpierw oś Z zostanie skierowana do swojego dodatniego końca a następnie X i Y. Jeśli chcemy żeby krańcówki zamieniły się miejscami (hard limits na homing) odwracamy je podobnie jak ustawienie $6


$19 = 25.000 (homing feed, mm/min)
Prędkość dla posuwu homing w celu znalezienia krańcówki "limit" i ustawieniu maszyny na 0. Najpierw wykorzystuje się następne ustwienie homing seek a po znalezieniu krańcówki w celu dokłądnego ustawienia homing feed.
Zazwyczaj feed($4) jest ustawiany mniejszy od seek($5). Program najpierw steruje w kierunku początku układu właśnie z prędkością seek($5) a następnie po znalezieniu krańcówki zwalnia do prędkości feed($4) dojeżdżając do zera (0,0)

$20 = 250.000 (homing seek, mm/min)
Może być ustawiony szybszy niż nasza najwyższa prędkość dla G1


$21 = 100 (homing debounce, msec)
Czas zwłoki dla ustania drgania styków wszystkich krańcówek, zazwyczaj ustawiany na 5-25. Dla żądnych teorii co to jest, polecam świetny artykuł: http://mikrokontrolery.blogspot.com/2011/04/przycisk-drgania-stykow-debouncing.html

$22 = 1.000 (homing pull-off, mm)
Ile mm poza zadziałanie krańcówki dla homingu wyjedzie maszyna żeby znaleźć punkt 0, od zadziałania krańcówki do tego miejsca użyje prędkości z punku $19

Wszystkie ustawienia $$ są trzymane w EEPROM więc nie utracicie ich po odłączeniu zasilania.

c.d.n.

VI Ustawienia Grbl dla wersji 0.9i

Na wstępie małe przypomnienie, że nie każda wersja 0.9 jest "prawdziwą" wersją 0.9 Wersja kodu "a" to w 100% wersja 0.8 która m.in. ma zupełnie inne ustawienia oraz pracuje z prędkością UART 9600.

Jeśli już zdobędziecie "prawdziwą" wersję 0.9 - aktualnie jest to wersja "i": https://github.com/grbl/grbl
To po uruchomieniu zobaczycie:


Nowości:
- teraz pracujemy z prędkością UART: 115200
- parametr $14 cycle auto-start został usunięty
- dodano obsługę następujących komend Gcode: G38.3, G38.4, G38.5
- usunięto: G40 cutter radius compensation
- dodano obsługę mechaniki CoreXY (źródło:http://corexy.com/)

- dodano obsługę czujnika drzwi bezpieczeństwa
- dodano możliwość pełnej kontroli nad pinami wymiany informacji, od teraz możemy włączać lub wyłączać rezystory podciągające, co w praktyce umożliwia stosowanie krancówek NO oraz NC
- Z limit teraz jest na pinie D12 !!
- Spindle enable jest teraz na pinie D11 !!
- plus parę pomniejszych zmian, zainteresowanych odsyłam na: https://github.com/grbl/grbl

Co ciekawe możemy sobie teraz pobrać też wersję kodu z wprowadzonymi już ustawieniami dla maszynek ShapeOKO http://docs.shapeoko.com/

Aktualna lista obsługiwanych Gcode:
- Non-Modal Commands: G4, G10L2, G10L20, G28, G30, G28.1, G30.1, G53, G92, G92.1
- Motion Modes: G0, G1, G2, G3, G38.2, G38.3, G38.4, G38.5, G80
- Feed Rate Modes: G93, G94
- Unit Modes: G20, G21
- Distance Modes: G90, G91
- Arc IJK Distance Modes: G91.1
- Plane Select Modes: G17, G18, G19
- Tool Length Offset Modes: G43.1, G49
- Cutter Compensation Modes: G40
- Coordinate System Modes: G54, G55, G56, G57, G58, G59
- Program Flow: M0, M1, M2, M30*
- Coolant Control: M7*, M8, M9
- Spindle Control: M3, M4, M5
- Valid Non-Command Words: F, I, J, K, L, N, P, R, S, T, X, Y, Z

Nie zmienił się sposób wpisywania danych dla konfiguracji, jedynie wydłużyła się lista możliwych ustawień. Pełna lista dla tej wersji to (v0.9i):


OPIS kolejnych ustawień(trochę tego jest...):
$0=10 (step pulse, usec)
Poprzednio był to parametr $3 więc i poprzedni opis pozostaje aktualny. Podobnie jak poprzednio domyślne ustawienie to 10 mikrosekund, które sprawdza się dla wielu silników.

$1=25 (step idle delay, msec)
Poprzednio był to parametr $7, opis bez zmian.

$2=0 (step port invert mask:00000000)
Poprzednio był to parametr $6, opis bez zmian.

$3=6 (dir port invert mask:00000110)
Nowa rzecz, odwrócenie kierunku poruszania się dla każdej osi przez użycie maski. Teraz w czasie budowy maszyny już nie musimy się bardzo zastanawiać, w którym kierunku każda z osi ma mieć wartości z plusem, itd. Gdyż dzięki temu parametrowi możemy ją sobie "odwrócić"


Przykład: jeśli chcemy odwrócić kierunek osi Y, musimy wysłać do maszyny $3=2
a jeśli chcemy odwrócić wszystkie osie musimy wysłać do maszyny $3=7


$4=0 (step enable invert, bool)
Poprzednio był to parametr $15, opis bez zmian.

$5=0 (limit pins invert, bool)
Wyłączenie wewnętrznych rezystorów podciągających dla linii krańcówek. Żeby to zrobić wpisujemy: $5=1 Od teraz jeśli nie podłączymy zewnętrznych rezystorów możemy usmażyć uC.

$6=0 (probe pin invert, bool)
Podobnie jak poprzednie ustawienie to także wyłącza wewnętrzne rezystory podciągające ale dla sondy na A5. Włączamy też podobnie: $6=1 i również możemy spowodować usmażenie uC.

$10=3 (status report mask:00000011)
Ustawienie zmieniające co GRBL wysyła do użytkownika po wydaniu komendy: "?" sprawdzającej w czasie rzeczywistym status maszyny. W sumie oprogramowanie może raportować:
- status maszyny - nie może być wyłączony, możliwe statusy to: Idle, Queue, Run, Hold, Home, Alarm, Check
- pozycja maszyny
- pozycja pracy - czyli pozycja maszyny + wszystkie zastosowane offsety
- bufor pracy
- bufor interfejsu RX
Do wprowadzenia ustawień używamy maski

Przykład: jeśli chcemy raportować absolutnie wszystko wpisujemy: $10=15
lub tylko dwa bufory $10=12

$11=0.020 (junction deviation, mm)
Poprzednio był to parametr $9, opis bez zmian.

$12=0.002 (arc tolerance, mm)
Tolerancja dla łuków i kół, poprzednio mieliśmy do tego parametry $10 i $11 teraz został zastąpiony tym jednym. Jeśli Wasze łuki wyglądają po wycięciu dobrze to nie ruszamy tego 0.002 jeśli uważacie że nie to zmieńcie. Mniejsza wartość to dokładniejszy łuk ale i wolniejsza praca. Wyższe wartości na odwrót czyli jedziemy szybciej i mniej dokładnie.

$13=0 (report inches, bool)
Poprzednio był to parametr $13, opis bez zmian.

$20=0 (soft limits, bool)
Są dwa typy limitów, ten (miękki) gdy jest włączony będzie sprawdzał czy maszyna nie chce pojechać poza swoje wymiary. Wymaga włączenia opcji homing i ustawienia wymiarów maszyny w parametrach $130, $131, $132. Włączamy to wpisując 1. I warto mieć włączone.

$21=0 (hard limits, bool)
Drugi typ limitów - ten używa krańcówek. Krańcówki możemy zamontować na obu końcach każdej osi. Pamiętajcie, że uruchomienie krańcówki powoduje zatrzymanie działania maszyny i nie jest możliwe wznowienie pracy od tego momentu. Krańcówki zostały już opisane wcześniej w tym temacie.

$22=0 (homing cycle, bool)
Jeśli używamy fizycznych krańcówek możemy ich użyć do znajdowania pozycji początkowej dla maszyny włączając tą funkcję. Grbl zakłada że pozycja domowa jest w +X, +Y, +Z. Po jej uruchomieniu pierwsze przemieszcza oś Z w kierunku plusa, a następnie naraz X i Y. Ważne ustawienie to $27 Homing pull-off

$23=1 (homing dir invert mask:00000001)
Jeśli pozycję domową w naszej maszynie mamy po przeciwnej stronie czyli -X, -Y, -Z możemy za pomocą maski ją odwrócić, używamy starej znanej tabelki:


$24=50.000 (homing feed, mm/min)
Poprzednio był to parametr $19, opis bez zmian.

$25=635.000 (homing seek, mm/min)
Poprzednio był to parametr $20, opis bez zmian.

$26=250 (homing debounce, msec)
Poprzednio był to parametr $21, opis bez zmian.

$27=1.000 (homing pull-off, mm)
Poprzednio był to parametr $22, opis bez zmian.

$100=314.961 (x, step/mm)
Poprzednio był to parametr $0, opis bez zmian.

$101=314.961 (y, step/mm)
Poprzednio był to parametr $1, opis bez zmian.

$102=314.961 (z, step/mm)
Poprzednio był to parametr $2, opis bez zmian.

$110=635.000 (x max rate, mm/min)
Poprzednio był to parametr $4 i $5 teraz działa trochę inaczej. Gdyż to jedno ustawienie wpływa na szybkość dla feed i seek oraz teraz można te prędkości ustawić dla każdej osi osobno a poprzednio była tylko 1 prędkość globalna. Najlepszy sposób uzyskania naszej liczby to eksperyment, wpisujemy:

I patrzymy jak maszyna jedzie w osi X. Jeśli za wolno zwiększamy $110 aż uzyskamy największą możliwą prędkość wtedy zmniejszamy tę wartość o 10-20% i tak zostawiamy.

$111=635.000 (y max rate, mm/min)
Jak wyżej ale dla osi Y.

$112=635.000 (z max rate, mm/min)
Jak wyżej ale dla osi Z.

$120=50.000 (x accel, mm/sec^2)
Przyspieszenie dla każdej osi. Poprzednio był globalny parametr dla wszystkich osi $8. Teraz każdą oś możemy ustawić osobno. I znów najlepiej znaleźć swoją liczbę doświadczalnie.

$121=50.000 (y accel, mm/sec^2)
Jak wyżej ale dla osi Y.

$122=50.000 (z accel, mm/sec^2)
Jak wyżej ale dla osi Z.

$130=225.000 (x max travel, mm)
Maksymalny możliwy ruch w milimetrach dla osi X. Potrzebne przy włączonych limitach i homingu (heh ale słowo wyszło)

$131=125.000 (y max travel, mm)
Maksymalny możliwy ruch w milimetrach dla osi Y. Potrzebne przy włączonych limitach i homingu.

$132=170.000 (z max travel, mm)
Maksymalny możliwy ruch w milimetrach dla osi Z. Potrzebne przy włączonych limitach i homingu

Dzisiaj artykulik, typu "szybka wygrana" (quick win). Jeśli macie już Cnc shield oraz przynajmmiej jeden StepStick, można łatwo sprawdzić czy układ zadziała - bez instalacji i konfiguracji Grbl.



Można użyć silniczków z cdrom/dvdrom lub już docelowych z maszyny. Silnik podłączamy pod oś X. Nie zakładamy zworek sterujących mikrokrokami.

Wgrywamy do Arduino ten prosty kod:



Jeśli chcecie sprawdzić pozostałe osie z płytki cnc shield to ten kawałek w kodzie należy zmienić na inny:







Jeśli nie macie CNC shield a tylko step stick też można to podłączyć, wystarczy trzymać się poniższego schematu.


Na płytce kolejne piny to:


Te same piny na taśmie od takiego silniczka (bipolarny):


Oraz sam silniczek typu pierwszego:


I inny silniczek typu drugiego (taśma/złącze ma tą samą kolejność):


Podpięte wszystko razem. Czyli 4 przewody do silnika, zasilanie po USB, zasilanie silnika z pakietu 3s (a co!).


I widok z góry:


No, a że bez filmu się nie liczy:

Modyfikując kod można uzyskać większy zakres ruchu czy szybszy ruch. Silnik pracujący na 12V szybko się grzeje więc nie przesadzajcie

Jak się takie 2 tacki skrzyżuje, to można wypalić na przykład osiołka.

W rzeczywistości wygląda lepiej niż tu na zdjęciu

Jeszcze trzeba nad ustawieniami popracować

Po założeniu radiatora na laser, oraz delikatnej kalibracji mam taki efekt, krawędzie ładne, dokładność też fajna. Lubię to.

Fajnie. Jaka szerokość ścieżki wyszła i jaka odległość soczewki od materiału

Wysłane z mojego GT-S7560 przy użyciu Tapatalka

Aktualnie soczewka jest 40mm nad materiałem, a grubość rzazu to 0,7mm ale myślę, że będzie jeszcze węższy. Prace trwają.

Często pod koniec budowy spieszymy się uruchamiając maszynę zbyt wcześnie... Może poniższa lista pomoże niecierpliwcom:

Pierwsze uruchomienie.
- upewnij się, że wszystkie przewody są podłączone poprawnie i każdy element ma zasilanie. Pamiętaj o wspólnej masie dla wszystkich elementów
- jeśli zamontowałeś już silniki upewnij się, że każda z osi pracuje gładko, można to zrobić kręcąc ręcznie daną osią żeby sprawdzić czy nic się nie blokuje (np za sprzęgło)
- sprawdź czy silniki są dobrze przykręcone, czy sprzęgła się nie obluzowały a wszystkie połączenia śrubowe są dociągnięte i zabezpieczone klejem do gwintów. Jeśli masz gdzieś śrubki "robaczki" też je sprawdź
- kolejny krok to upewnienie, że każda oś ma właściwy kierunek. Żeby całość dobrze działała zaleca się skonfigurowanie maszyny w układzie kartezjańskim (XYZ) z zastosowaniem zasady prawej ręki.
Kolejne palce pokazują kierunki osi.

Warto też popatrzeć na ten diagram:

- wyślij podstawowe komendy ruchu wpisując je ręcznie w linię poleceń
(spowoduje ruch w osi X +1mm)
(spowoduje ruch w osi X -1mm)
- sprawdź w ten sposób wszystkie osie, jeśli któraś porusza się w "złą" stronę popraw parametr $3 (dir port invert mask)
- jeśli silniki "wyją" w czasie pierwszych ruchów spróbuj zmniejszyć odpowiednie parametry ($) odpowiadające za przyspieszenie i maksymalne prędkości (X/Y/Z max rate, X/Y/Z accel) Odgłos taki występuje np gdy silniki gubią kroki lub dostają zbyt duży prąd (A) - też go sprawdź!
- jeśli silniki są ciche to dobry czas żeby poustawiać możliwe najwyższe parametry dla przyspieszenia i maksymalnej prędkości ($ jak wyżej). To też dobry moment na sprawdzenie czy sterowanie (pełny krok, 1/2 itd) są odpowiednie dla Ciebie.
- sprawdź czy wpisany parametr ilość kroków na mm jest poprawny. Żeby to zrobić wyślij możliwie najdłuższy ruch możliwy w danej osi np
(spowoduje ruch w osi X +350mm) zaznaczając wcześniej miejsce startu i mierząc przebytą drogę. Jeśli zmierzona odległość jest mniejsza lub większa niż 350mm musisz zmodyfikować parametr ilość kroków /mm.
- ustaw parametr "X/Y/Z max travel" czyli najdłuższy możliwy ruch w każdej osi. Nawet nie mając krańcówek program będzie pamiętał żeby nie przekraczać tego punktu.
- jeśli jesteś zadowolony - możesz wykonać Pierwszy test z plikiem GCODE

źrodła:
- głowa
- https://github.com/gnea/grbl/wiki
- http://linuxcnc.org/docs/html/user/user-concepts.html

Witam, po przeczytaniu tego tematu zaciekawiłem się działaniem GRBLa.
Jakie są różnice między różnymi wersjami GRBL? Pytam o różnice na wyprowadzeniach procesora i dodatkowe funkcje.
Czy można dodać jakiś ekran np.LCD?

Pozdrawiam.

Za 12 godzin za niedostosowanie się do regulaminu pożegnamy się. No chyba że jednak uda się przeczytać ze zrozumieniem zaakceptowany wspomniany regulamin.

Skąd ściągnąć Grbl Controller 3.6.1 lub nowszy.

Na Twoim miejscu wybrał bym UGS.
https://winder.github.io/ugs_website/download/

Wysłane z mojego Redmi 5 Plus przy użyciu Tapatalka

Na zdjęciu zamieszczonym w w tym wątku jest pewna nieścisłość jeżeli chodzi o wyprowadzenia na płytce



Hubert podaje kolejność od góry
2B
2A
1A
1B
tymczasem na płytce jest
B2
B1
A1
A2

która jest prawidłowa?

Darek obie są prawidłowe

Wysłane z mojego Redmi 5 Plus przy użyciu Tapatalka

Trzymaj się tego i będzie dobrze.