Está en la página 1de 19

ESTUDIANTE: ACARAPI LECOÑA WILSON

CARRERA: INGENIERÍA ELECTRÓNICA


SEMESTRE: CUARTO
FECHA DE EVENTO: 05-06-2019

La paz - Bolivia
pág. 1
INTRODUCCIÓN.

En este proyecto daremos a conocer la importancia de un CNC hoy en día con


la ingeniería moderna, ya que una máquina-herramienta ha jugado un papel
fundamental en el desarrollo tecnológico del mundo hasta el punto de que no es una
exageración decir que la tasa del desarrollo de máquinas herramientas gobierna
directamente la tasa del desarrollo industrial. En la actualidad, encontramos máquinas
CNC en casi todas partes, que ya no solo abarcan los grandes establecimientos
industriales, sino también talleres de todo tipo, tanto de pequeña como mediana
envergadura. Prácticamente no existe ámbito alguno de un proceso de fabricación
que no dependa de estas poderosas y versátiles máquinas.

Una máquina CNC es muy importante en las industrias ya que esta máquina
se puede utilizar para cualquier proceso de manufactura, el principal objetivo de la
maquina CNC es el hacer la operaciones de manufactura en menor tiempo y tener
más producción ya que los trabajadores están limitados para hacer una mayor
producción, además estas máquinas hacen el trabajo con calidad, precisión y pueden
tener una cierta repetibilidad del proceso de trabajo. Nuestro proyecto es básicamente
una mini maquina CNC, la cual tiene la capacidad de poder realizar cualquier tipo de
dibujo en 2d que es básicamente la impresión de un dibujo en calidad. Una de las
ventajas de tener una mini CNC que realice dibujos es, que ya no hay que
preocuparnos de la calidad del dibujo y la precisión manual, ya que teniendo esta
máquina podrá realizar sin ningún problema lo que se busca en el proceso de trabajo,
porque la mini CNC estará programada para que pueda realizar cada una de las
ordenes que le dará la computadora, como por ejemplo las coordenadas donde debe
de trabajar el lápiz. La mini CNC trae muchos beneficios para el usuario como lo que
hemos mencionado antes que es la calidad, el tiempo y una mejor producción.

pág. 2
MOTORES PASO A PASO

Los motores paso a paso (P-P) pueden verse como motores eléctricos sin sistema de
conmutación. Típicamente, todas las bobinas del motor están en el estator y el rotor
es, o un imán permanente o, en el caso de motores de reluctancia variables, un bloque
de algún material magnéticamente blando. Toda la conmutación debe ser manejada
externamente por el controlador del motor y, habitualmente, los motores y
controladores están diseñados para que el motor pueda ser mantenido en una
posición o rotar en uno u otro sentido. La mayoría de estos motores pueden ser
manejados a frecuencias de audio permitiendo un giro rápido y, con un controlador
apropiado, pueden ser arrancados y parados en posiciones controladas.

Para algunas aplicaciones existe una posibilidad de elección entre el uso de


servomotores y de motores P-P. Ambos tipos ofrecen prestaciones similares para
posicionamientos precisos, pero difieren en algunos aspectos. Los servomotores
requieren sistemas de realimentación analógica. Típicamente, esto involucra un
potenciómetro para proporcionar realimentación acerca de la posición del rotor, y
alguna circuitería para dirigir corriente a través del motor de forma inversamente
proporcional a la diferencia entre la posición actual y la deseada. La elección entre
uno u otro tipos de motor dependen fundamentalmente de la aplicación.

ARDUINO

Arduino es una plataforma de desarrollo basada en una placa electrónica de


hardware libre que incorpora un microcontrolador re-programable y una serie de
pines hembra, los que permiten establecer conexiones entre el microcontrolador y
los diferentes sensores y actuadores de una manera muy sencilla (principalmente
con cables dupont).

pág. 3
Una placa electrónica es una PCB (“Printed Circuit Board”, “Placa de Circuito
Impreso” en español). Las PCBs superficies planas fabricadas en un material no
conductor, la cual costa de distintas capas de material conductor. Una PCB es la
forma más compacta y estable de construir un circuito electrónico. Así que la placa
Arduino no es más que una PCB que implementa un determinado diseño de
circuitería interna, de esta forma el usuario final no se debe preocupar por las
conexiones eléctricas que necesita el microcontrolador para funcionar, y puede
empezar directamente a desarrollar las diferentes aplicaciones electrónicas que
necesite.

OBJETIVO

Conocer el lenguaje de programación del control numérico, aprender los conceptos


esenciales sobre mecanizado, adquirir los conocimientos sobre puntos de
referencia, los orígenes del control numérico o el control de las herramientas de
corte, son sólo algunos de los objetivos que te capacitarán para crear un programa
de control numérico CNC y efectuar su posterior verificación gráfica.

En la actualidad puedes encontrar diferentes cursos de formación en esta materia


que te capacitarán para emprender la programación de controles numéricos, siendo
el control Sinumerik de la popular y prestigiosa empresa Siemens el más conocido y
prestigioso de todos.

Entre las principales salidas profesionales del Control Numérico CNC destacan
inventores, proyectistas, delineantes, rectificadores, torneros, fresadores, etcétera.
Es decir, todos aquellos profesionales dedicados al diseó, fabricación y/o montaje de
piezas y/o conjuntos industriales.

pág. 4
OBJETIVO ESPECIFICO

Adoptar terminología en el ámbito de la industrialización y automatización en el área


de ingeniería electrónica.

Entender el funcionamiento de estos controladores específicos para poder


aprovechar todo su potencial en aplicaciones industriales de producción.

Investigar los diferentes softwares de manejo de bases de datos

MATERIALES:

- 1 ARDUINO UNO

- SHIELD V1 L293D

pág. 5
- 2 LECTORES DVDs DE PC

- 1 SERVO MOTOR

pág. 6
PROCEDIMIENTO:
Primero desmontamos los DVD hasta dejar libre los motores paso a paso que tienen
este tipo de lectores dejándolos así:

Luego lo armamos en una base firme puede ser del material que senos sea más fácil
utilizar en mi caso use madera mdf de 15 mm y escuadrar bien la estructura para el
carril y motores así:

pág. 7
Ahora que lo armamos bien hacemos la prueba los motores paso a paso de los
lectores y el motor servo. Esta llegaría a ser el circuito y las conexiones:

Una vez terminado de armar nuestro control numérico computarizado (CNC) nos
vamos al software que lo haremos con arduino después de instalar el driver
controlador d nuestro módulo shield L293D.

SOFTWARE:

ESTE ES EL CÓDIGO PARA ARDUINO QUE USE PARA ESTE PROYECTO


#include <Servo.h>
#include <AFMotor.h>

#define LINE_BUFFER_LENGTH 512

pág. 8
char STEP = MICROSTEP ;

// Servo position for Up and Down


const int penZUp = 60;
const int penZDown = 20;
const int penServoPin =10 ;
Servo penServo;

const int stepsPerRevolution = 100; // Debería ser adecuado para los steppers de DVD, puede variar
AF_Stepper myStepperY(stepsPerRevolution,1);
AF_Stepper myStepperX(stepsPerRevolution,2);

/* Structures, global variables */


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

// Current position of plothead


struct point actuatorPos;

// Drawing settings, should be OK


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

// Motor a pasos avanza 1mm


// Utilice el Sketch para avanzar 100 pasos, mida la longitud del carril
// Calcular los pasos por mm empleados para recorrer dicha distancia (longitud del carril)
float StepsPerMillimeterX =50.0;
float StepsPerMillimeterY = 30.0;

// Límites de la CNC, en mm
// Podria ir hasta 50 mm si se calibra bien (depende de la longitud del carril)
float Xmin = 0;
float Xmax = 40;
float Ymin = 0;
float Ymax = 40;
float Zmin = 0;
float Zmax = 1;

float Xpos = Xmin;


float Ypos = Ymin;
float Zpos = Zmax;

pág. 9
// Set to true to get debug output.
boolean verbose = false;

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

/**********************
* void setup() - Initialisations
***********************/
void setup() {

Serial.begin( 9600 );
penServo.attach(penServoPin);
penServo.write(penZUp);
delay(100);

// Decrease if necessary
myStepperX.setSpeed(600);
myStepperY.setSpeed(600);

// Set & move to initial default position


// TBD
// Notifications!!!
Serial.println("Mini CNC Plotter listo para imprimir");
Serial.print("El rango X es de");
Serial.print(Xmin);
Serial.print(" a ");
Serial.print(Xmax);
Serial.println(" mm.");
Serial.print("El rango Y es de");
Serial.print(Ymin);
Serial.print(" a ");
Serial.print(Ymax);
Serial.println(" mm.");
}

/**********************
* void loop() - Main loop
***********************/
void loop()
{

delay(100);

pág. 10
char line[ LINE_BUFFER_LENGTH ];
char c;
int lineIndex;
bool lineIsComment, lineSemiColon;

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

while (1) {

// Recepción de datos (Gcode)por puerto serie


while ( Serial.available()>0 ) {
c = Serial.read();
if (( c == '\n') || (c == '\r') ) { // End of line reached
if ( lineIndex > 0 ) { // Line is complete. Then execute!
line[ lineIndex ] = '\0'; // Terminate string
if (verbose) {
Serial.print( "Recibido ");
Serial.println( line );
}
processIncomingLine( line, lineIndex );
lineIndex = 0;
}
else {
// Empty or comment line. Skip block.
}
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 {
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" );

pág. 11
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[ currentIndex++ ] ) { // 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

pág. 12
case 0: // G00 & G01 - Movement or fast 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 = actuatorPos.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
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 = " );

pág. 13
Serial.println( actuatorPos.y );
break;
default:
Serial.print( "Command not recognized : M");
Serial.println( buffer );
}
}
}

/*********************************
* Draw a line from (x0;y0) to (x1;y1).
* int (x1;y1) : Starting coordinates
* int (x2;y2) : Ending coordinates
**********************************/
void drawLine(float x1, float y1) {

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

// Bring instructions within limits


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);

pág. 14
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.onestep(sx,STEP);
over+=dy;
if (over>=dx) {
over-=dx;
myStepperY.onestep(sy,STEP);
}
delay(StepDelay);
}
}
else {
for (i=0; i<dy; ++i) {
myStepperY.onestep(sy,STEP);
over+=dx;
if (over>=dy) {
over-=dy;
myStepperX.onestep(sx,STEP);
}

pág. 15
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 before any next lines are submitted


delay(LineDelay);
// Update the positions
Xpos = x1;
Ypos = y1;
}

// Raises pen
void penUp() {
penServo.write(penZUp);
delay(penDelay);
Zpos=Zmax;
digitalWrite(15, LOW);
digitalWrite(16, HIGH);
if (verbose) {
Serial.println("Pen up!");

}
}
// Lowers pen
void penDown() {
penServo.write(penZDown);
delay(penDelay);
Zpos=Zmin;
digitalWrite(15, HIGH);
digitalWrite(16, LOW);

pág. 16
if (verbose) {
Serial.println("Pen down."); } }
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

Luego de copilar el código al arduino usamos un ejecutable que se abre con jaba
para poder mandar a imprimir al a nuestra cnc.
El ejecutable es GCTRL.

Para que el ejecutable mande una imagen a imprimir la imagen debe estar en
formato (gcode) para convertir imágenes en gcode que pueda reconocer el
ejecutable y posteriormente mandar a imprimir usamos el programa inkscape que
que es este:

pág. 17
Ahora ya teniendo una imagen vector izada con el inkscape mandamos a imprimir

pág. 18
CONCLUCION:
Con el desarrollo del proyecto se logró apreciar cómo funciona el CNC y los tipos de
grabados que ejecuta con el programa y todos los tipos, herramientas, principios de
funcionamiento y además aplicaciones que se le podrá dar a la maquinas
herramienta denominadas torno y fresadora.

Las máquinas-herramienta hacen el trabajo industrial más sencillo, práctico y


económico para la organización que las emplea. Es una forma de hacer un trabajo
eficaz, eficiente y efectivo. Con esta técnica se han podido lograr diferentes
objetivos con más exactitud y precisión que antes, cuando se utilizaba la mano de
obra humana.

WEB GRAFÍA:

https://www.youtube.com/watch?v=Q5ma1HDuotk&t=66s

https://www.instructables.com/id/Mini-CNC-Machine-Arduino-Based-Adafruit-Driver-Mot/

https://www.youtube.com/watch?v=Uyisg1a7rLg

https://github.com/fmdavid/miniCNC

https://www.labdomotic.com/2019/04/30/youtube-guida-software-cnc-diy/

pág. 19