Mașină -unealtă cu comandă numerică [631829]

1
Universitatea “Politehnica” din București
Facultatea de Electronică, Telecomunicații și Tehnologia Informației

Mașină -unealtă cu comandă numerică

Proiect de diplomă
prezentat ca cerință parțială pentru obținerea titlului de
Inginer în domeniul Electronică aplicată și Ingineria Informației
programul de studii de licență Ingineria Informației

Conducător științific Absolvent
Ș.L.Dr.Ing. Valentin STOICA Cristi -Bogdan V OICU

2018

2

3

4

5

DECLARATIA DE ONESTITA TE TREBUIE PRINTATA, SEMNATA ȘI APOI SCANATA.

6

7
Cuprins

Capitolul 1 – Platforma Arduino ………………………….. ………………………….. ………………………….. ………………. 16
1.1 Descriere microcontrolerului Arduino Uno ………………………….. ………………………….. ……………………… 17
1.1.1 Descriere microcontroler ATmega328P -PU ………………………….. ………………………….. ………………. 18
1.2 Descriere mediu de dezvoltare Arduino ………………………….. ………………………….. ………………………….. 19
1.3 Componente electronice ………………………….. ………………………….. ………………………….. ………………….. 20
1.3.1 Driver motoare ULN2003 ………………………….. ………………………….. ………………………….. ………….. 20
1.3.2 Motoare 28BYJ -48 ………………………….. ………………………….. ………………………….. ……………………. 21
1.3.2 Servo motorul FS90B ………………………….. ………………………….. ………………………….. ……………….. 21
Capitolul 2 – Mașina -unealtă ………………………….. ………………………….. ………………………….. ………………….. 22
3.1 Arhitectura sistemului ………………………….. ………………………….. ………………………….. ……………………… 22
3.2 Implementare Hardware ………………………….. ………………………….. ……….. Error! Bookmark not defined.
3.3 Implementare software ………………………….. ………………………….. …………. Error! Bookmark not defined.
3.3.1 Implementare software Arduino ………………………….. ……………………. Error! Bookmark not defined.
3.3.2 Implementare software Gcode ………………………….. ………………………. Error! Bookmark not defined.
Capitolul 3 – Testarea mașinii ………………………….. ………………………….. ………. Error! Bookmark not defined.
BIBLIOGRAFIE ………………………….. ………………………….. ………………………….. ………………………….. ……….. 27
Anexa 1 ………………………….. ………………………….. ………………………….. ………………………….. ……………………… 28
Anexa 2 ………………………….. ………………………….. ………………………….. ………………………….. ……………………… 31

8

9
LISTĂ FIGURI

Fig. 1.1 Platforma Arduino Uno
Fig. 1.1 .1 Pinii microcontrolerului ATmega328
Fig. 1.2 Mediul de dezvoltare Arduino
Fig. 1. 3.1 Driver ULN2003
Fig. 1. 3.2 Schema electrică a motorului 28BYJ -48 cu driverul ULN2003
Fig. 2.1 Arhitectura sistemului
Fig. 2.2.1 Placajul de bază
Fig. 2.2.2 Bare de inox și stâlpi de susținere
Fig. 2.2.3 Susținerea stâlpilor pe Ox
Fig. 2.2.4 Susținerea stâlpilor pe Oy
Fig. 2.2.5 Prinderea motoarelor și a servo motorului

10

11
LISTĂ TABELE

Tabel 1.1 Specificații Arduino Uno
Tabel 1. 3.2 Specificații motor 28BYJ -48
Tabel 1. 3.3 Specificații servo motor FS90B
Tabel 2.2 Dimensiune componente

12

13
LISTĂ ACRONIME

PWM – Pulse Width Modulation
UART – Universal Asynchronous Recieve/Transmit

14

15
Introducere
Tema presupune proiectarea unei mașini -unealtă cu comandă numerică , cu ajutorul
cunoștințelor hardware și software. La nivel hardware se folosește o platformă de dezvoltare Arduino
Uno, două motoare pas cu pas 28BYJ -48, două drivere pentru motoare ULN2003 și un servo motor
FS90B . În platforma de dezvoltare, modul ele software au rolul de a controla motoarele respectiv
servo motorul pe cele trei axe, Ox ,Oy și Oz. Cu ajutorul aplicației Gcode, mașina poate fi controlată
de către utilizator și permite acestuia să modifice în funcție de preferință schema ce se dorește a fi
printată.

Mașina -unealtă este formată din două axe principale care sunt controlate de motoarele 28BYJ –
48, iar acestea la rândul lor de către drivere -le ULN2003 și un suport aflat pe axa Oy alcătuit dintr –
un servo motor ce face posibilă mișcarea pe Oz a instrumentului de scris.

Proiectarea mașinii -unealtă prezintă avantaje într -un mod benfic omului: programele
numerice se modifică mult mai ușor decât programele fixate prin modele sau șabloane; crește calitatea
produsului și se elimină existența u nor erori de reglare manuală și se poate trece la conducerea
automată a preceselor de fabricare. Ca orice sistem, proiectarea mașinii prezintă și câteva dezavantaje:
costul ridicat al pieselor și echipamentelor necesare pentru construirea mașinii și prezen ța unui
personal specializat pentru realizarea programelor și intervenție în cazul defectării aparatului.

16

Capitolul 1 – Platforma Arduino

17
Arduino este o companie care se ocupă cu fabricarea plăcuțelor de dezvoltare bazate pe
microcontrolere, dar și cu parte de software pentru funcționalitatea acestor plăcuțe. Partea software
constă întru -un mediu de dezvoltare, programarea făcându -se cu aju torul limbajelor C/C++.

1.1 Descriere Arduino Uno
Arduino Uno est e o placă de dezvoltare, ea având la bază microcontrolerul A Tmega328 și
funcționează la o frecvență maximă de 16 Mhz. Platforma poate fi alimentată pe portul USB cu o
tensiune de 5VDC sau pe portul de alimentare externă sau pinul Vin cu o tensiune între 7 și 12 VDC
.

Fig. 1.1 Platforma Arduino Uno

Platforma conține 14 pini digitali de intrare sau ieșire, dintre care 6 pot fi folosiți ca ieșire
PWM, 6 intrări anlogice, o mufă de alimentare, comunicare serială prin USB , un buton de RESET și
antetul ICSP . Placa funcționează la o tensiune de 3.3V, însă toți pinii sunt protejați pentru tensiuni
mai mari de 5V. Prin fiecare pin poate trece maxim 40mA și au o rezistență internă cuprinsă între 20
și 50 KOhms. Memoria platformei de dezvoltare este de 32Kbytes de memorie flash și de 2Kbytes
memorie SRAM. Rolul butonului de RESET este de a restarta programul trimis de plăcuță de către
utilizator. Platforma are o siguranță care protejează porturile USB ale calculatorului de scurtcircuit
sau suprasarcină . Dacă se aplică un curent mai mare de 500mA la portul USB, siguranța se va rupe
și împiedică conectarea până la scurtcircuit sau suprasarcină. ICSP este un protocol folosit pentru a
programa microcontroler ul, iar pinii sunt folosiți pentru programare arduin o de către alt arduino dacă
portul USB nu este disponibil. [1]

18
Microcontroler ATmega328
Tensiune alimentare (recomandată) 7-12V
Tensiune alimentare (limită) 6-20V
Curentul maxim/pin 40A
Pini digitali (intrare/ieșire) 14
Pini analogici 6
Tabel 1.1 Specificații Arduino Uno

1.1.1 Descriere microcontroler ATmega328 P-PU
Microcontrolerele sunt dispozitive ce sunt alcătuite din periferice și unitatea de procesare ce
au rolul de a controla funcționalitatea circuitelor electronice. Placa de dezvoltar e Arduino Uno
folosește microcontrolerul ATmega328, fiind unul din cele mai folosite microcontrolere deoarece
acesta se poate înlocui, în cazul în care s -a defectat. Teniunsea de alimentare este cuprinsă în
intervalul 1.8 și 5.5V, frecvența maximă pe care o poate atinge este de 20Mhz și are o memorie flash
de 32Kbytes respectiv 2Kbytes de memorie SRAM. Microcontrolerul conține 28 de pini, fiecare
dintre aceștia având una sau mai multe funcționalități. [2]

Fig. 1.1 .1 Pinii microcontrolerului ATmega328

19
1.2 Descriere mediu de dezvoltare Arduino
Mediu de dezvoltare Arduino este o aplicație care suportă limbajul C/C++, folosind reguli
speciale pentru structurarea codului. Această aplicație poate fi utilizată pe orice sistem de operare,
cum ar fi Windows, Linux sau macOS. Locul în care programele s crise se salvează se numeste
sketchbook (eng. sketches ). Pentru setarea pinilor în modul de intrare sau ieșire, programatorului îi
sunt puse la dispoziție diferite librării pe care le poate folosi cu diferite scopuri.
Aplicația folosește pentru utilizarea mediului de dezvoltare două funții esențiale: setup() și
loop(). Rolul primei funcții este de a inițializa variabilele și de a seta pinii în unul din cele două
moduri: INPUT sau OUTPUT. Această funcție este apelată la pornirea platformei Arduino sau în
cazul resetării acesteia. Codul principal al programului este scris în cea de a doua funcție, iar aceasta
are rolul de a rula continuu până la oprirea platformei.

Fig. 1.2 Mediul de dezvoltare Arduino

Mediul de dezvoltare Arduino are trei componente principale:
• Editor text – în această secțiune se scrie cod, în limbajul C++ simplificat ;
• Zona de mesaje – în această zonă sunt afiș ate mesajele de eroare;
• Zona de utilități – în această loc se găsesc butoane pentru verificare, trimiterea
codu lui pe placă.

20
Pe placa de dezvoltare, pentru transmiterea informației se poate folosi comunicarea serială
asincronă. În comunicarea serială, un rol foarte important îl are receptorul/transmițătorul univeral
asincron(eng. UART), acesta reprezentând circu itul ciclic care transformă informația de la intrare din
paralelă în serială, tranformarea fiind reversibilă. Acesta este alcătuit din trei componente:
• Generatorul de rata de boud – are rolul de a genera un semnal de ceas, local, mult mai
mare decât cel folosit pentru controlul UART ;
• Modul de recepție – primește mesajele serial și le paralelizează ;
• Modul de trimitere – convertește informația primită în biți seriali în funcție de formatul
utilizat .[3]

1.3 Componente electronice
1.3.1 Driver motoare ULN 2003
Pentru a putea controla motoarele platformei am ales utilizarea unui driver bazat pe integratul
ULN2003. Driver -ul este alcătuit din patru LED -uri pentru a indica ce bobină este alimentată în
momentul funcționării, o priză cu cinci fire ce face leg ătura cu motorul pas cu pas, un jumper de
pornire/oprire pentru a permite alimentarea motorului, cipul ULN2003 și patru intrări de control care
trebuie să fie conectate la patru pini digitali . [4]

Fig. 1. 3.1 Driver ULN2003

21
1.3.2 Motorul 28BYJ -48
Motorul 28BYJ -48 este un motor controlat de mai multe bobine electromagnetice. Peste
arborele central sunt mai mulți magneți montați, iar bobinele ce înconjoară arborele sunt date
alternativ de curent sau nu, astfel creând câmpuri magnetice care resping sa u atrag magneții de pe
arbore, cauzând rotirea motorului. Motoarele pas cu pas sunt de două feluri: unipolare și bipolare.
Motorul 28BYJ -28 are cinci sau șase fire și patru bobine, iar prin împreunarea racordurilor bobinelor
se formează cablul de alimentar e. Aceste motoare sunt unipolare deoarece puterea intră pe acest po l
mereu. [5]

Tensiunea nominală 5V
Numărul de faze 4
Viteza variației raportului 1/64
Frecvența 100Hz
Unghiul pasului 5.625°/64
Tabel 1. 3.2 Specificații motor 28BYJ -48

Pentru a determina cu ce viteză trebuie să meargă motorul aplicăm formula: număl de pași =
numărul de pași într -o singură revoluție * raportul de transmisie.

Fig. 1. 3.1 Schema electrică a motorului 28BYJ -48 cu driver -ul ULN2003

1.3.3 Servo motorul FS90B
Pentru a putea controla mișcarea instrumentului de scris pe O z, vom folosi un servo motor
cu greutatea mică pentru a nu împiedica mișcarea suportului pe O y. Servo motorul poate roti 90° în
fiecare direcție, iar aceasta se livrează împreună cu trei tipuri de brațe, fiecare folosindu -se în
funcție de necesitate.[6]
Tensiunea 4.8-6V
Greutate 14.7g
Viteza 0.1secunde
Tabel 1.3. 3 Specificații servo motor FS90B

22
Capitolul 2 – Mașina -unealtă

2.1 Arhitectura sistemului
Întregul sistem este format din mai multe componente : placaje de lemn, țevi de inox, motoare pas
cu pas, drivere pentru motoare, servo motor, platforma de dezvoltare Arduino Uno și aplicația Gcode
de control a platformei mobile.

Fig. 2.1 Arhitectura sistemului

Diagrama de mai sus indică direcția fiecărui semnal de propagare în sistem. Se poate observa
că motoarele sunt conectate la drivere, iar acestea la rândul lor sunt conectate la platforma Arduino
Uno. Servo motorul este conectat direct la placa de dezvoltare Arduino . Pentru controlul acesteia,
aplica ția Gcode va comunica cu ajutorul cablului USB, cu microcontrolerul. Acesta, la rândul său, în
funcție de comanda primită, va comanda motoarele.

2.2 Implementare Hardware
Pentru a susține întregul proiect s e folosește un placaj de lemn, peste care s e constr uiesc cele
trei axe X,Y și Z cu ajutorul unor bare de inox susținute de 4 bucăți de lemn, acestea fiind prinse două
câte două. Primul motor este așezat la mijlocul unui stâlp orizontal, iar cu ajutorul unui fir texti l așezat
de-a lungul celor doi stâlpi se poate face mișcarea pe O x, a placajului secundar. Cel de -al doilea motor
este așezat pe unul din stălpii verticali, iar cu ajutorul firului textil așezat pe mijloc se poate face
mișcarea suportului din lemn pe O y. Servo motorul este așezat pe suport , iar acesta are rolul de a
ridica instrumentul de scris, astfel fiind posibilă mișcare pe O z.

23

Fig. 2.2.1 Placajul de bază

Fig. 2.2.2 Bare de inox și stâlpi de susținere

24

Fig. 2.2.3 Susținere a stâlpilor pe O x

Fig. 2.2.4 Susținerea stâlpilor pe Oy

25

Fig. 2.2.5 Prinderea motoarelor și a servo motorului

Dimensiuniile fiecărei componente sunt conform tabelului:
Componentă Lungime Lățime Înălțime Diametru
Placaj bază 60cm 52cm 0.5cm –
Stâlpi Ox 24cm 1.5cm 3cm –
Bare Ox 42cm – – 1cm
Stâlpi Oy 4cm 1cm 16cm –
Bare Oy 35cm – – 1cm
Placaj mobil 30cm 22cm 0.5cm –
Suport Oz 3cm 0.5cm 12cm –
Tabel 2.2 Dimensiune componente

26

27
BIBLIOGRAFIE

[1] https://www.farnell.com/datasheets/1682209.pdf – accesat la data de 0 4.06.2018

[2] http://www.futurlec.com/Atmel/ATMEGA328P -PU.shtml – accesat la data de 04.06.2018

[3] ISSN: 2277 128X, Review on Serial Communication by UART, International Journal of
Advanced Research in Computer Science and Software Engineering, Volume 3, Issue1, January
2013

[4] http://archive.fabacademy.org/2017/fablabegypt/students/468/files/output -devices/Stepper –
motor -ULN -driver.pdf – accesat la data de 06.06.2018

[5] http://robocraft.ru/files/datasheet/28BYJ -48.pdf – accesat la data de 06.06.2018

[6] http://www.ee.ic.ac.uk/pcheung/teaching/DE1_EE/stores/sg90_datasheet.pdf – accesat la
data de 06.06.2018

28
Anexa 1
Cod sursă Arduino
#include <Servo.h>
#include <Stepper.h>

#define LINE_BUFFER_LENGTH 512

const int penZUp = 40;
const int penZDown = 80;

const int penServoPin = 6;

const int stepsPerRevolution = 3600;

Servo penServo;

Stepper myStepperY(stepsPerRevolution,
5,3,4,2);
Stepper myStepp erX(stepsPerRevolution,
11,9,10,8);

struct point {
float x;
float y;
float z;
};

struct point actuatorPos;

float StepInc = 1;
int StepDelay = 0;
int LineDelay = 50;
int penDelay = 50;

float StepsPerMillimeterX = 100.0;
float StepsPerMillimeterY = 100.0;

float Xmin = 0;
float Xmax = 100;
float Ymin = 0;
float Ymax = 100;
float Zmin = 0;
float Zmax = 1;

float Xpos = Xmin;
float Ypos = Ymin;
float Zpos = Zmax;

boolean verbose = false;

void setup() {
Serial.begin( 9600 );

penServo.attach(penServoPin);
penServo.write(penZUp);
delay(200);

myStepperX.setSpeed(200);
myStepperY.setSpeed(200);
Serial.println("Mini CNC Plotter
alive and kicking!");
Serial.print("X range is from ");
Serial.print(Xmin);
Serial.print(" to ");
Serial.print(Xmax);
Serial.println(" mm.");
Serial.print("Y range is from ");
Serial.print(Ymin);
Serial.print(" to ");
Serial.print(Ymax);
Serial.prin tln(" mm.");
}

void loop()
{
delay(200);
char line[ LINE_BUFFER_LENGTH ];
char c;
int lineIndex;
bool lineIsComment, lineSemiColon;

lineIndex = 0;
lineSemiColon = false;
lineIsComment = false;

while (1) {

while ( Serial.availabl e()>0 ) {
c = Serial.read();
if (( c == ' \n') || (c == ' \r')
) {
if ( lineIndex > 0 ) {
line[ lineIndex ] = ' \0';
if (verbose) {
Serial.print( "Received :
");
Serial.println( line );
}
processIncomingLine( line,
lineIndex );
lineIndex = 0;
}
else {

}
lineIsComment = false;
lineSemiColon = false;
Serial.println("ok");
}
else {
if ( (lineIsComment) ||
(lineSemiColon) ) { // Throw away
all comment characters
if ( c == ')' )
lineIsComment = false; // End of
comment. Resume line.
}
else {

29
if ( c <= ' ' ) {
// Throw away whitepace and control
characters
}
else if ( c == '/' ) {
// Block delete not supported. Ignore
character.
}
else if ( c == '(' ) {
// Enable comments flag and ignore all
characters until ')' or EOL.
lineIsComment = true;
}
else if ( c == ';' ) {
lineSemiColon = true;
}
else if ( lineIndex >=
LINE_BUFFER_LENGTH -1 ) {
Serial.println( "ERROR –
lineBuffer overflow" );
lineIsComment = false;
lineSemiColon = false;
}
else if ( c >= 'a' && c <=
'z' ) { // Upcase lowercase
line[ lineIndex++ ] = c –
'a'+'A';
}
else {
line[ lineIndex++ ] = c;
}
}
}
}
}
}

void processIncomingLine( char* line ,
int charNB ) {
int currentIndex = 0;
char buffer[ 64 ];
// Hope that 64 is enough for 1
parameter
struct point newPos;

newPos.x = 0.0;
newPos.y = 0.0;

// Needs to interpret
// G1 for moving
// G4 P300 (wait 150ms)
// G1 X60 Y30
// G1 X30 Y50
// M300 S30 (pen down)
// M300 S50 (pen up)
// Discard anything with a (
// Discard any other command!

while( currentIndex < charNB ) { switch ( line[ curre ntIndex++ ] )
{ // Select command, if
any
case 'U':
penUp();
break;
case 'D':
penDown();
break;
case 'G':
buffer[0] = line[ currentIndex++
]; // /! \ Dirty – Only works
with 2 digit commands
// buffer[1] = line[
currentIndex++ ];
// buffer[2] = ' \0';
buffer[1] = ' \0';

switch ( atoi( buffer ) ){
// Select G command
case 0:
// G00 & G01 – Movement or fas t
movement. Same here
case 1:
// /!\ Dirty – Suppose that X
is before Y
char* indexX = strchr(
line+currentIndex, 'X' ); // Get X/Y
position in the string (if any)
char* indexY = strchr(
line+currentIndex, 'Y' );
if ( indexY <= 0 ) {
newPos.x = atof( indexX +
1);
newPos.y = actuato rPos.y;
}
else if ( indexX <= 0 ) {
newPos.y = atof( indexY +
1);
newPos.x = actuatorPos.x;
}
else {
newPos.y = atof( indexY +
1);
indexY = ' \0';
newPos.x = atof( indexX +
1);
}
drawLine(newPos.x, newPos.y );
//
Serial.println("ok");
actuatorPos.x = newPos.x;
actuatorPos.y = newPos.y;
break;
}
break;
case 'M':
buffer[0] = line[ currentIndex++
]; // /!\ Dirty – Only works
with 3 digit commands

30
buffer[1] = line[ currentIndex++
];
buffer[2] = line[ currentIndex++
];
buffer[3] = ' \0';
switch ( atoi( buffer ) ){
case 300:
{
char* indexS = strchr(
line+currentIndex, 'S' );
float Spos = atof( indexS +
1);
//
Serial.println("ok");
if (Spos == 30) {
penDown();
}
if (Spos == 50) {
penUp();
}
break;
}
case 114:
// M114 – Repport position
Serial.print( "Absolute
position : X = " );
Serial.print( actuatorPos.x );
Serial.print( " – Y = " );
Serial.println( actuatorPos.y
);
break;
default:
Serial.print( "Command not
recognized : M");
Serial.println( buffer );
}
}
}

}

void drawLine(float x1, float y1) {

if (verbose)
{
Serial.print("fx1, fy1: ");
Serial.print(x1);
Serial.print(",");
Serial.print(y1);
Serial.println("");
}

if (x1 >= Xmax) {
x1 = Xmax;
}
if (x1 <= Xmin) { x1 = Xmin;
}
if (y1 >= Ymax) {
y1 = Ymax;
}
if (y1 <= Ymin) {
y1 = Ymin;
}

if (verbose)
{
Serial.print("Xpos, Ypos: ");
Serial.print(Xpos);
Serial.print(",");
Serial.print(Ypos);
Serial.println("");
}

if (verbose)
{
Serial.print("x1, y1: ");
Serial.print(x1);
Serial.print(",");
Serial.print(y1);
Serial.println("");
}

// Convert coordinates to steps
x1 = (int)(x1*StepsPerMillimeterX);
y1 = (int)(y1*StepsPerMillimeterY);
float x0 = Xpos;
float y0 = Ypos;

// Let's find out the change for
the coordinates
long dx = abs(x1 -x0);
long dy = abs(y1 -y0);
int sx = x0<x1 ? StepInc : -StepInc;
int sy = y0<y1 ? StepInc : -StepInc;

long i;
long over = 0;

if (dx > dy) {
for (i=0; i<dx; ++i) {
myStepperX.step(sx);
over+=dy;
if (over>=dx) {
over-=dx;
myStepperY.step(sy);
}
delay(StepDelay);
}
}
else {
for (i=0; i<dy; ++i) {
myStepperY.step( sy);
over+=dx;
if (over>=dy) {
over-=dy;
myStepperX.step(sx);

31
}
delay(StepDelay);
}
}

if (verbose)
{
Serial.print("dx, dy:");
Serial.print(dx);
Serial.print(",");
Serial.print(dy);
Serial.println("");
}

if (verbose)
{
Serial.print("Going to (");
Serial.print(x0);
Serial.print(",");
Serial.print(y0);
Serial.println(")");
}

delay(LineDelay);

Xpos = x1;
Ypos = y1;
}

void penUp() {
penServo.write(penZUp);
delay(LineDelay);
Zpos=Zmax;
if (verbose) {
Serial.println("Pen up!");
}
}
void penDown() {
penServo.write(penZDown);
delay(LineDelay);
Zpos=Zmin;
if (verbose) {
Serial.println("P en down.");
}
}

Anexa 2
Cod sursă Gcode
import java.awt.event.KeyEvent;
import javax.swing.JOptionPane;
import processing.serial.*;

Serial port = null;

// select and modify the appropriate
line for your operating system
// leave as null to use interactive
port (press 'p' in the program)
String portname = null; //String portname = Serial.list()[0];
// Mac OS X
//String portname = "/dev/ttyUSB0"; //
Linux
//String portname = "COM6"; // Windows

boolean streaming = false;
float speed = 0.001;
String[] gcode;
int i = 0;

void openSerialPort()
{
if (portname == null) return;
if (port != null) port.stop();

port = new Serial(this, portname,
9600);

port.bufferUntil(' \n');
}

void selectSerialPort()
{
String result = (String)
JOptionPane.s howInputDialog(frame,
"Select the serial port that
corresponds to your Arduino board.",
"Select serial port",
JOptionPane.QUESTION_MESSAGE,
null,
Serial.list(),
0);

if (result != null) {
portname = result;
openSerialPort();
}
}

void setup()
{
size(600, 400);
openSerialPort();
}

void draw()
{
background(155);
fill(0);
int y = 24, dy = 12;
text("INSTRUCTIONS", 12, y); y +=
dy;
text("p: select serial port", 12,
y); y += dy;
text("1: set speed to 0.001 inches
(1 mil) per jog", 12, y); y += dy;
text("2: set speed to 0.010 inches
(10 mil) per jog", 12, y); y += dy;
text("3: set speed to 0.100 inches
(100 mil) per jog", 12, y); y += dy;

32
text("arrow keys: jog in x-y plane",
12, y); y += dy;
text("page up & page down: jog in z
axis", 12, y); y += dy;
text("$: display grbl settings", 12,
y); y+= dy;
text("h: go home", 12, y); y += dy;
text("0: zero machine (set home to
the current location)", 12, y); y +=
dy;
text("g: stream a g -code file", 12,
y); y += dy;
text("x: stop streaming g -code (this
is NOT immediate)", 12, y); y += dy;
y = height – dy;
text("current jog speed: " + s peed +
" inches per step", 12, y); y -= dy;
text("current serial port: " +
portname, 12, y); y -= dy;
}

void keyPressed()
{
if (key == '1') speed = 0.001;
if (key == '2') speed = 0.01;
if (key == '3') speed = 0.1;

if (!streaming) {
if (keyCode == LEFT)
port.write("G91 \nG20\nG00 X-" + speed
+ " Y0.000 Z0.000 \n");
if (keyCode == RIGHT)
port.write("G91 \nG20\nG00 X" + speed +
" Y0.000 Z0.000 \n");
if (keyCode == UP)
port.write("G91 \nG20\nG00 X0.000 Y" +
speed + " Z0.000 \n");
if (keyCode == DOWN)
port.write("G91 \nG20\nG00 X0.000 Y -" +
speed + " Z0.000 \n");
if (keyCode ==
KeyEvent.VK_PAGE_UP)
port.write("G91 \nG20\nG00 X0.000
Y0.000 Z" + speed + " \n");
if (keyCode ==
KeyEvent.VK_PAGE_DOWN)
port.write("G91 \nG20\nG00 X0.000
Y0.000 Z-" + speed + " \n");
if (key == 'h')
port.write("G90 \nG20\nG00 X0.000
Y0.000 Z0.000 \n");
if (key == 'v')
port.write("$0=75 \n$1=74\n$2=75\n");
//if (key == 'v')
port.write("$0=100 \n$1=74\n$2=75\n");
if (key == 's')
port.write("$3=10 \n");
if (key == 'e')
port.write("$16=1 \n");
if (key == 'd')
port.write("$16=0 \n"); if (key == '0') openSerialPort();
if (key == 'p')
selectSerialPort();
if (key == '$')
port.write("$$ \n");
}

if (!streaming && key == 'g') {
gcode = null; i = 0;
File file = null;
println("Loading file…");
selectInput("Select a file to
process:", "fileSelected", file);
}

if (key == 'x') streaming = false;
}

void fileSelected(File selection) {
if (selection == null) {
println("Window was closed or the
user hit cancel.");
} else {
println("User selected " +
selection.getAbsolutePath());
gcode =
loadStrings(selection.getAbsolutePath(
));
if (gcode == null) return;
streaming = true;
stream();
}
}

void stream()
{
if (!streaming) return;

while (true) {
if (i == gcode.length) {
streaming = false;
return;
}

if (gcode[i].trim().length() == 0)
i++;
else break;
}

println(gcode[i]);
port.write(gcode[i] + ' \n');
i++;
}

void serialEvent(Serial p)
{
String s = p.readStringUntil(' \n');
println(s.trim());

if (s.trim().startsWith("ok"))
stream();

33
if (s.trim().startsWith("error"))
stream(); // XXX: really?
}