Universidad nacional de San Agustín

Facultad de ingeniería de producción y servicios

Escuela profesional de ingeniería electrónica

Curso: arquitectura de computadoras laboratorio

Turno:
“B” Miércoles de 10:40 a 12:20 pm
Título:
Informe Final Proyecto CNC

Apellidos y nombres: CUI: Firma

Abarca Jahuira Flavio 20130493
Huayra Sumaria Enrique 20133054
Yauricasa Marin Ludwig Kevin 20130469
Docente:
Ing. Erasmo Sulla Espinoza

Fecha de entrega:
Lunes 10/12/18

1
Índice:
1. Especificaciones técnicas del proyecto en forma completa …………………………..3
2. Diagrama de
bloques…………………………………………………………………………..6
3. Morfología del
sistema………………………………………………………………………...7
4. Esquemático completo del
sistema…………………………………………………………7
4.1 Esquemático del control de motor paso a
paso…………………………………………7
4.2 Esquemático del control de motor
DC………………………………………………........7
5. PCB de los circuitos con nombres de los
integrantes……………………………………8
6. Software de instalación……………………………………………………………………….8
6.1 Tareas
preestablecidas………………………………………………………………………8
6.2 Interfaz……………………………………………………………………………………........9
7. Aportes y aplicaciones en general………………………………………………………….9
8. Conclusiones y recomendaciones………………………………………………………….9
9. Anexos……………………………………………………………………………………........10
9.1 Fotos estructura CNC y placas
PCB……………………………………………………...10
9.2 Programa del PIC……………………………………………………………………………11

2
1. ESPECIFICACIONES TECNICAS DEL PROYECTO EN FORMA COMPLETA
El siguiente CNC se realizó según especificaciones que se requerían en el laboratorio

 Uso del controlador USB 18F4550

 Motor PAP para el eje X
 Motor PAP para el eje Y
 Motor DC para el eje z
 Programa compilado
 Entradas y salidas digitales
 Deben programarse tareas específicas, el programa tiene que estar compilado y
con instalador.
A. Microcontrolador PIC 18F4550
Características:

 Arquitectura RISC avanzada Harvard: 16 bits con 8 bits de datos

 77 interrupciones
 Hasta 64kKbytes de programa (hasta 2 Mbytes en ROMless)
 Hasta 3968 bytes de RAM y 1KBytes de EEPROM
 Frecuencia máxima de reloj de 40Mhz. Hasta 10 MIPS
 Pila de 32 niveles
 Múltiples fuentes de alimentación
 Periféricos de comunicación avanzados

3
B. Motor PAP
En los motores paso a paso debemos diferenciar los motores unipolares de los bipolares.
Los motores unipolares se llaman así porque la corriente que circula por los diferentes
bobinados siempre circula en el mismo sentido. En los motores bipolares para que
el motor funcione la corriente que circula por los bobinados cambia de sentido

4
en función de la tensión que se aplica. Por lo que un mismo bobinado puede tener en uno
de sus extremos distinta polaridad (bipolar).
Algunos motores tienen los bobinados de tal manera que en función de puentes pueden
convertirse en unipolares o bipolares.
Lo más importante de un motor es saber el tipo de motor que es, la potencia, el número
de pasos, el par de fuerza, la tensión de alimentación y poco más si son motores
sencillos.

Unipolar: Estos motores suelen tener 6 o 5 cables de salida, dependiendo de su

conexionado interno (ver figura 2). Este tipo se caracteriza por ser más simple de
controlar. En la figura 4 podemos apreciar un ejemplo de conexionado para controlar un
motor paso a paso unipolar mediante el uso de un ULN2803, el cual es una array de
8 transistores tipo Darlington capaces de manejar cargas de hasta 500mA. Las entradas
de activación (Activa A, B, C y D) pueden ser directamente activadas por un
microcontrolador.

Secuencia Normal: Esta es la secuencia más usada y la que generalmente recomienda

el fabricante. Con esta secuencia el motor avanza un paso por vez y debido a que
siempre hay al menos dos bobinas activadas, se obtiene un alto torque de paso y de
retención.

5
2. DIAGRAMA DE BLOQUES

PC

PIC 18F4550

DRIVER DRIVER DRIVER

LP
DRIVER
R
MOTOR PASO MOTOR PASO MOTOR DC
A PASO A PASO
6
3. MORFOLOGIA DEL SISTEMA
El siguiente CNC está constituido por materiales como: MDF, correderas telescópicas,
varilla enroscada.

 Eje x, con un motor PAP y correderas telescópicas que mueven una perfil de
aluminio, dicho motor tiene una resolución de 36 pasos por milímetro
 Eje y con un motor PAP y correderas telescópicas que mueven una base de mdf,
dicho motor tiene una resolución de 36 pasos por milímetro
 Eje z con un motor DC.
4. ESQUEMATICO COMPLETO DEL SISTEMA
Conexión del PIC 18F4550 y los motores paso a paso usando los driver puente H.
4.1 ESQUEMATICO DEL CONTROL DE MOTOR PASO A PASO

Fig1. Esquema interfaz para control de motor paso a paso

4.2 ESQUEMATICO DEL CONTROL DE MOTOR DC

Fig. 2. Esquema interfaz para control de motor corriente continua

7
5. PCB DEL LOS CIRCUITOS CON NOMBRES DE LOS INTEGRANTES

6. SOFTWARE DE INSTALACIÓN
El programa es completamente ejecutable, la comunicación se hace mediante puerto
USB.
Interfaz creado en Visual Basic, que nos permite crear nuestro entorno de manera fácil y
práctica, para nuestro entorno crearemos botones de acciones instantáneas,
Antes de todo, lo primero que tenemos que hacer es agregar la clase easyHID.csal
proyecto de Visual Basic que habíamos creado antes. A través de ella podremos llamar a
las diferentes funciones de control que se encuentran en easyHID.dll, una librería
proporcionada por la empresa MecaniqueUK para el control de dispositivos USB
mediante protocolo HID. Para poder agregar la clase tenemos que agregar al directorio
donde se encuentra nuestro proyecto 2 archivos: mcHID.dll (Librería de control) y
easyHID.cs(Clase con las funciones de control definidas).
Y después ya se puede empezar a programar en CCs

8
6.1 TAREAS PREESTABLECIDAS

- Empezar en el origen.
- Dibujar cuadrado.
- Dibujar triangulo: triángulo equilátero y triangulo rectángulo.
- Dibujar círculo.
- Dibujar rectángulo.
- Regresa a la posición inicial.
- Posicionarse en un punto de origen.
6.2. INTERFAZ

7. APORTES Y APLICACIONES EN GENERAL

 El siguiente trabajo tiene una muy confiable estabilidad lo que hace pueda tener
una aplicación más práctica.
 Aplicaciones como una maquina fresadora, impresora 3D, etc.
8. CONCLUSIONES Y RECOMENDACIONES

 Se logró implementar la comunicación vía USB gracias a un entorno de trabajo

creado en Visual Basic con el cual es posible mandar y recibir datos del PIC hacia
la PC y viceversa.
 La precisión se logró calculando el número de pasos del motor PAP al que
equivale un milímetro de recorrido para el eje angular.
 La precisión lograda funciona perfectamente bien, esto hace que nuestro proyecto
se asemeje aún más a otros con acabados mucho más comerciales y de
aplicaciones industriales.
 Es factible trabajar con dos motores PAP para una precisión más exacta, además
que el sistema de control es más fácil

9
9. ANEXOS
9.1 Fotos estructura CNC y placas PCB

Fig. 9.1 Driver

Fig. 9.2 Conexión Drivers y microcontrolador

Fig. 9.3 Estructura CNC

10
9.2 Programa del PIC
#include <18F4550.h> // Definición de registros internos del PIC18F4550.
//#DEVICE ADC=8 // CAD a 8 bits, justificación a a la derecha.
//#DEVICE ADC=16 // CAD a 10 bits, justificación a a la izquierda.

#fuses NOMCLR,HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN,NOPBADEN

// NOMCLR: No vamos ha usar el PIN MCLR, el reset se hará por software.

// HSPLL: Utilizaremos un cristal de alta velocidad en conjunto con el PLL.
// NOWDT: No vamos a usar el perro guardian.
// NOPROTECT: Memoria no protejida contra lecturas.
// NOLVP: No utilizamos el modo de programación con bajo voltaje.
// NODEBUG: No utilizamos código para debugear.
// USBDIV: signfica que el clock del usb se tomará del PLL/2 = 96Mhz/2 = 48Mhz.
// PLL1: significa que el PLL prescaler dividirá la frecuencia del cristal. para HS = 20Mhz, PLL = 5.
// con esto se obtiene: 20Mhz/5 = 4Mhz.
// CPUDIV1: El PLL postscaler decide la división en 2 de la frecuencia de salida del PLL de 96MHZ, si queremos 48MHZ, lo
dejamos como está.
// VREGEN: habilita el regulador de 3.3 volts que usa el módulo USB.
// NOPBADEN: Todo el Puerto B como I/O digitales.

// Usamos una frecuencia de trabajo de 48Mhz.

#use delay(clock=20000000)

//=================================================================================================
=======

//=================================================================================================
=======

// Incluimos librerías utilizadas por la aplicación.

#include <pic18_usb.h> // Drivers's USB del PIC18F2550.
#include <Descriptor_easyHID.h> // Descriptores HID del proyecto.
#include <USB.c> // Funciones del USB.
#include <math.h>

// Usamos fast_io.
#use fast_io(a)
#use fast_io(b)
#use fast_io(c)
#use fast_io(d)
#use fast_io(e)

#BYTE TRISB = 0x86

#BYTE TRISC = 0x87
#BYTE TRISD = 0x88
#BYTE TRISE = 0x89
#BYTE PORTB = 0x81
#BYTE PORTC = 0x82
#BYTE PORTD = 0x83
#BYTE OPTION_REG = 0x81

void DistanciaDerechaX(void);
void DistanciaIzquierdaX(void);
void DistanciaDerechaY(void);
void DistanciaIzquierdaY(void);
void ActivaSalida(void);
void Cuadrado(void);

11
void Triangulo(void);
void TrianguloRectangulo(void);
void Circulo(void);
void EjeZSube(void);
void EjeZBaja(void);
void Origen(void);
void Acumulador(void);
float CalculaDer(float);
float CalculaIzq(float);

void USB_debug(){

OUTPUT_LOW(PIN_E0);
OUTPUT_HIGH(PIN_E1);
usb_wait_for_enumeration(); // Espera a ser enumerado por el host.
OUTPUT_HIGH(PIN_E0);
OUTPUT_LOW(PIN_E1);
}

//=====================================FUNCIONES==========================================
===================
// Variables globales.

const int8 VectorDerecha[4] = {0b01111001,0b01111010,0b01110110,0b01110101};

const int8 VectorIzquierda[4] = {0b10110101,0b10110110,0b10111010,0b10111001};
const int8 VectorZ[3] = {0b00000101,0b00000110,0b00000000};

float DDx,DIx,DDy,DIy,yTope1,yTope2,yTope3,yTope4,lado,base;
int32 i,j,k,l,t,p,inc,inc2,inc3,inc4;
float NumPasosDX,NumPasosIX,NumPasosDY,NumPasosIY,LadoC,LadoT,Radio,LadoTMedio;
float Altura,Bases;
float SumaDDx=0;
float SumaDDy=0;
float SumaDIx=0;
float SumaDIy=0;
int32 RestoDx,RestoIx,RestoDy,RestoIy;
int8 recibe[USB_EP1_RX_SIZE]; // Declaramos la variable recibe de 32 bytes.
int8 envia[USB_EP1_TX_SIZE];
int8 figura;

void main(void) // Función Principal.

{
PORT_b_PULLUPS(0);

set_tris_b(0b00000000); //PortB
set_tris_a(0b11111000);
set_tris_d(0b00000000); //PortD
set_tris_e(0b00000000);

//PORTB = 0x00;
//PORTA = 0x00;
//PORTD = 0x00;

envia[2]=0;
envia[4]=0;

12
output_b(0x00);
//output_a(0xF8);
output_d(0x00);
OUTPUT_LOW(PIN_E0);
OUTPUT_LOW(PIN_E1);
// OUTPUT_LOW(PIN_E2);

usb_init(); // Inicializamos el stack USB.

usb_task(); // Habilita el periferico usb y las interrupciones.
USB_debug(); // Nos muestra el estado de conección del USB.

while (TRUE) // Bucle infinito.

{

if(usb_enumerated())// Si el dispositivo está configurado...

{
goto leer_datos;
mover_1era_coor:
delay_ms(3);

//---------------------------------------------------------------------------
//CUADRADO
if (figura == 1)
{
delay_ms(5);
LadoC=lado;
EjeZBaja();
Cuadrado();
output_b(0x00);
output_d(0x00);
EjeZSube();
}
//TRIANGULO
if (figura == 2)
{
delay_ms(5);
LadoT=lado;
EjeZBaja();
Triangulo();
output_b(0x00);
output_d(0x00);
EjeZSube();
}
//CIRCULO
if (figura == 3)
{
delay_ms(5);
Radio=lado;
EjeZBaja();
Circulo();
output_b(0x00);
output_d(0x00);
EjeZSube();
}

if (figura == 4)
{
delay_ms(5);

13
DIx=lado;
SumaDIx=DIx+SumaDIx;
EjeZBaja();
DistanciaIzquierdaX();
output_b(0x00);
output_d(0x00);
EjeZSube();
}
if (figura == 5)
{
delay_ms(5);
DDx=lado;
SumaDDx=DDx+SumaDDx;
EjeZBaja();
DistanciaDerechaX();
output_b(0x00);
output_d(0x00);
EjeZSube();
}
if (figura == 6)
{
delay_ms(5);
DDy=lado;
SumaDDy=DDy+SumaDDy;
EjeZBaja();
DistanciaDerechaY();
output_b(0x00);
output_d(0x00);
EjeZSube();
}
if (figura ==7)
{
delay_ms(5);
DIy=lado;
SumaDIy=DIy+SumaDIy;
EjeZBaja();
DistanciaIzquierdaY();
output_b(0x00);
output_d(0x00);
EjeZSube();
}
if (figura == 8)
{
delay_ms(5);
Altura=lado;
Bases=base;
EjeZBaja();
TrianguloRectangulo();
output_b(0x00);
output_d(0x00);
EjeZSube();
}
if (figura == 9)
{
delay_ms(5);
Origen();
output_b(0x00);
output_d(0x00);
EjeZBaja();

14
 EjeZSube();
SumaDDx=0;
SumaDDy=0;
SumaDIx=0;
SumaDIy=0;
}
}
leer_datos:
{
if (usb_kbhit(1)) // Si hay un paquete de datos del host.. en el buffer lo tomamos y guardamos en la
variable data.
{
usb_get_packet(1, recibe, USB_CONFIG_HID_RX_SIZE); // En el buffer lo tomamos del EP1 y lo
guardamos en la variable recibe....
lado = recibe[2];
figura = recibe[3];
base = recibe[4];
delay_ms(3);

goto mover_1era_coor;
}
goto leer_datos;
}
}
}

void Cuadrado(void ){

DDy=LadoC;
DistanciaDerechaY();

DIx=LadoC;
DistanciaIzquierdaX();

DIy=LadoC;
DistanciaIzquierdaY();

DDx=LadoC;
DistanciaDerechaX();

void Triangulo(void ){

LadoTMedio=LadoT*2;

for(t=0; t<LadoTMedio;t++){

DDy=sqrt(3)*0.25;
DistanciaDerechaY();
DIx=0.25;
DistanciaIzquierdaX();

DDy=sqrt(3)*0.25;
DistanciaDerechaY();
DIx=0.25;
DistanciaIzquierdaX();

15
DIy=sqrt(3)*0.25;
DistanciaIzquierdaY();

for(t=0; t<LadoTMedio;t++){
DIx=0.25;
DistanciaIzquierdaX();
DIy=sqrt(3)*0.25;
DistanciaIzquierdaY();

}
DDx=LadoT;
DistanciaDerechaX();
}

void TrianguloRectangulo(void){

DDx=Bases;
DistanciaDerechaX();

DDy=Altura;
DistanciaDerechaY();

for(p=0; p<Bases*4;p++){
DIx=0.25;
DistanciaIzquierdaX();
DIy=(Altura/Bases)*0.25;
DistanciaIzquierdaY();
}

void Origen(void){
if(SumaDDx>=SumaDIx){
DIx=SumaDDx-SumaDIx;
DistanciaIzquierdaX();
}
else{
DDx=SumaDIx-SumaDDx;
DistanciaDerechaX();
}

if(SumaDDy>=SumaDIy){
DIy=SumaDDy-SumaDIy;
DistanciaIzquierdaY();

}
else{
DDy=SumaDIy-SumaDDy;
DistanciaDerechaY();
}
}

void Circulo(void ){

for(inc=1; inc<=Radio*4;inc++){

16
DIx=0.25;
DistanciaIzquierdaX();
yTope1 = CalculaDer(inc*0.25);
DDy=yTope1;
DistanciaDerechaY();
}

for( inc2=1; inc2<=Radio*4; inc2++){

yTope2 = CalculaIzq(inc2*0.25);
DIy=yTope2;
DistanciaIzquierdaY();
DIx=0.25;
DistanciaIzquierdaX();
}

for( inc3=1; inc3<=Radio*4; inc3++){

DDx=0.25;
DistanciaDerechaX();

yTope3 = CalculaDer(inc3*0.25);
DIy=yTope3;
DistanciaIzquierdaY();
}

for( inc4=1; inc4<=Radio*4; inc4++){

yTope4 = CalculaIzq(inc4*0.25);
DDy=yTope4;
DistanciaDerechaY();

DDx =0.25;
DistanciaDerechaX();
}

float CalculaDer(float x1 ){

float y1;

y1 = sqrt((pow(Radio,2))-(pow(Radio-x1,2)))-sqrt((pow(Radio,2))-(pow(Radio-x1+0.25,2)));

return y1;

float CalculaIzq(float x2 ){

float y2;

y2 = sqrt((pow(Radio,2))-(pow(x2-0.25,2)))-sqrt((pow(Radio,2))-(pow(x2,2)));

return y2;

17
void DistanciaDerechaX(void )
{

NumPasosDX = DDx*143;

for(i=0; i<NumPasosDX;i++){

RestoDx = i%4;
OUTPUT_B(VectorDerecha[RestoDx]);
ActivaSalida();
}
output_b(0x00);
}

void DistanciaIzquierdaX(void ){

NumPasosIX = DIx*143;

for(j=0;j< NumPasosIX;j++){

RestoIx = j%4;
OUTPUT_B(VectorIzquierda[RestoIx]);
ActivaSalida();
}
output_b(0x00);
}
void DistanciaDerechaY(void )
{
NumPasosDY = DDy*142;

for(k=0; k<NumPasosDY;k++){

RestoDy = k%4;
OUTPUT_D(VectorDerecha[RestoDy]);
ActivaSalida();
}
output_d(0x00);
}

void DistanciaIzquierdaY(void ){

NumPasosIY = DIy*142;

for(l=0;l< NumPasosIY;l++){

RestoIy = l%4;
OUTPUT_D(VectorIzquierda[RestoIy]);
ActivaSalida();
}
output_d(0x00);
}
void ActivaSalida(void)
{
delay_ms(5);
}

18
 void EjeZSube(void){

OUTPUT_A(VectorZ[0]);
delay_ms(1200);
OUTPUT_A(VectorZ[2]);
delay_ms(1200);
}
void EjeZBaja(void){
OUTPUT_A(VectorZ[1]);
delay_ms(1200);
OUTPUT_A(VectorZ[2]);
delay_ms(1200);

19
20