Universidad Tecnológica Nacional

Transcripción

1 Universidad Tecnológica Nacional Facultad Regional San Nicolás Proyecto Digitales III Técnicas Agujereadora Angular con Avance en dos Dimensiones Semiautomática Integrantes: Groba, Diego Nicolás. Peruchena, Claudio. Docentes: Ing. Poblete, Felipe Sr. González, Mariano

2 INDICE 1. Descripción General 1.1. Introducción Pág Interfaz con el usuario Pág Operación Pág Hardware 2.1. Diagrama en Bloques Pág Circuitos Esquemáticos Pág Características del Microcontrolador Atmel Pág Descripción de los circuitos Pág Circuitos Impresos Pág SOFTWARE 3.1. Software Microcontrolador Pág Entorno de desarrollo Pág Sistema Operativo Pág Programa Principal - Subrutinas Pág Main.C Pág Motor.C Pág Serie.C Pág Macros51.H Pág Defines51.H Pág Software PC Pág Sistema Operativo Pág Programa Principal Pág Modificaciones Pág Desarrollo e Inconvenientes del Proyecto Pág Especificaciones Pág Imágenes del Proyecto Pág Referencias Pág Hojas de Datos Pág Referencias de Material Adicional Pág Bibliografía Pág. 57 Apéndice 1 Pág

3 1. Descripción General 1.1. Introducción El presente trabajo muestra el prototipo de una plataforma de dos coordenadas, la cual utiliza un sistema basado en el microcontrolador ATMEL 89S8252, de la familia de 8051 de INTEL, realizando la función de sistema de control, enviando las respectivas ordenes, para ubicar la plataforma en los diferentes puntos a lo largo de los respectivos recorridos. Los puntos son programados con anterioridad por el operario interactuando con el teclado. Como el operador indica la secuencia a realizar, el programa entrega al uc cada uno de los desplazamientos que deben realizar los motores paso a paso. Este tipo de control se ha realizado implementando una computadora personal, el software utilizado es lenguaje C, este envía las instrucciones que luego el uc recibirá e interpretara dicha acción a realizar, específicamente el puerto serie conectado con la placa del microcontrolador. Dichos motores contarán con dos sensores de posición por cada motor, uno para posicionamiento inicial y otro para fin de carro. Los motores serán excitados por una etapa de potencia construida para dicho fin y cuyo diseño está explicado en las páginas siguientes. Características: 2 salidas de control para motores paso a paso unipolares(x e Y). Expandible a 4 motores (Contemplado en el Set de Instrucciones). 4 entradas para sensores (fin de carrera, comienzo de carrera). Leds indicadores de función. Salida para prendido y apagado bomba de refrigeración. Comunicación serie full duplex, control de flujo por software (Xon/Xoff) RS-232C

4 Esquema Mecánico Básico 1.2. Interfaz con el usuario Mediante un protocolo de comunicación se reciben mensajes de estado con la información de los motores (petición de posición X, petición de posición Y, modo de velocidad, etc) y se transmiten comandos para los motores (avanzar x, retroceder x, mover a posición inicial X/Y, mover a posición Final X/Y, Velocidad, etc.) Operación Se realizo un programa (software) en lenguaje C el cual mediante un Set de instrucciones realiza la ejecución de una rutina determinada, encargado de ubicar la plataforma para agujereado del material en los puntos específicos

5 2.Hardware 2.1. Diagrama en Bloques

6 2.2. Circuitos Esquemáticos Los esquemáticos fueron realizados por el Software de edición Eagle V4.11 Microcontrolador y Comunicación RS-232 Circuito Esquemático

7 Etapa de Sensado Circuito Esquemático

8 Etapa de Potencia Circuito Esquemático

9 Fuente Circuito Esquemático

10 2.3. Características del Microcontrolador Atmel AT89S bit Microcontroller with 8K Bytes Flash Compatible with MCS-51 Products 8K Bytes of In-System Reprogrammable Downloadable Flash Memory SPI Serial Interface for Program Downloading Endurance: 1,000 Write/Erase Cycles 2K Bytes EEPROM Endurance: 100,000 Write/Erase Cycles 4V to 6V Operating Range Fully Static Operation: 0 Hz to 24 MHz Three-level Program Memory Lock 256 x 8-bit Internal RAM 32 Programmable I/O Lines Three 16-bit Timer/Counters Nine Interrupt Sources Programmable UART Serial Channel SPI Serial Interface Low-power Idle and Power-down Modes Interrupt Recovery From Power-down Programmable Watchdog Timer Dual Data Pointer Power-off Flag 2.4. Descripción de los circuitos La etapa de potencia tiene el objeto de excitar a las fases de los motores unipolares (Ver funcionamiento de motores paso a paso en Apéndice 1). Para la etapa de potencia se utilizaron 8 transistores en configuración darlington (TIP 120), 4 transistores para cada uno de los respectivos motores operando en la zona de corte y saturación. Algunas de las características de estos transistores son : diodo interno en antiparalelo para protección por contracorriente, amplificación de corriente en factor de 1000 y corriente máxima en colector 8 amperios. La fuente utilizada para alimentar la etapa de potencia es de 12 [Volts] y 2 [A]. La conexión de esta etapa se realizo al Puerto 0 del AT89S8252 y se dividió de la siguiente forma: P0.0 Motor X, Fase 1 P0.1 Motor X, Fase 2 P0.2 Motor X, Fase 3 P0.3 Motor X, Fase 4 P0.4 Motor Y, Fase 4 P0.5 Motor Y, Fase

11 P0.6 Motor Y, Fase 2 P0.7 Motor Y, Fase 1 Para sensado de Inicio y Fin de carro se utilizó un sensor óptico TCST2103. La interconexión con el Microcontrolador se realizó mediante las interrupciones INT0 (P3.2) para el Motor X y la INT1 (P3.3) para el MotorY, ya que un ingreso de interrupción puede ser dado por comienzo o por fin, se muestrea el estado de los sensores en la parte baja del P1. Inicio X P1.0 Fin X P1.1 Inicio Y P1.2 Fin Y P1.3 INT0 ( Motor X ) P3.2 INT1 ( Motor Y ) P

12 2.5. Circuitos Impresos Microcontrolador y Comunicación RS-232 Circuito Impreso Circuito Impreso con componentes

13 Circuito Armado Etapa de Potencia Circuito Impreso

14 Circuito Impreso con componentes Circuito Armado

15 Fuente 12 [V] x 2 [A] Circuito Impreso Circuito Impreso con Componentes

16 Circuito Armado Nota: El circuito de sensado fue realizado en una plaqueta universal

17 3.Software 3.1. Software Microcontrolador Entorno de desarrollo El programa que controla los procesos del sistema se desarrolló con la herramienta de desarrollo Keil µvision V2.30. Para enviar las instrucciones desde la PC y el Hardware se utiliza comunicación Serie RS 232. Para dicha etapa se utilizó el MAX232 y el siguiente Set de instrucciones. Set de Instrucciones Set de Instrucciones PC uc 1º Byte Tx 2º Byte Tx 3º Byte Tx Observaciones Mover Inicio Motor X Mover Inicio Motor Y No Asignada P P P P P P P P P P P P P P P P Retroceder Motor X, P Pasos P P P P P P P P P P P P P P P P Retroceder Motor Y, P Pasos P P P P P P P P P P P P P P P P No Asignada P P P P P P P P P P P P P P P P Avanzar Motor X, P Pasos P P P P P P P P P P P P P P P P Avanzar Motor Y, P Pasos P P P P P P P P P P P P P P P P No Asignada Mover a Fin Motor X Mover a Fin Motor Y No Asignada V V Modo Velocidad Motor X V V Modo Velocidad Motor Y V V No Asignada Prender Bomba Apagar Bomba Petición Posición Motor X Petición Posición Motor Y No Asignada

18 Set de Instrucciones uc PC 1º Byte Tx 2º Byte Tx 3º Byte Tx Observaciones P P P P P P P P P P P P P P P P Posición Motor X, P Pasos P P P P P P P P P P P P P P P P Posición Motor Y, P Pasos P P P P P P P P P P P P P P P P No Asignada V V Modo Velocidad Motor X V V Modo Velocidad Motor Y V V No Asignada Petición de Reset Error Sistema Operativo El sistema operativo que se utilizo para el desarrollo es el W98SE Programa Principal La metodología que se utilizo en el proceso secuencial para la realización del software tuvo en cuenta las características del proceso, buscando siempre su desarrollo real, para la aplicación coherente de los objetivos planteados. Los subprogramas se enuncian a continuación en un orden lógico. Funciones Utilizadas: void InicializarMotores (void); bit AvanUnPaso (bit); bit RetroUnPaso (bit); void DemoraPaso (unsigned char); unsigned char RetrocederMotor (unsigned char); unsigned char AvanzarMotor(unsigned char); unsigned char MoverInicio (unsigned char); unsigned char MoverFin (unsigned char); void AnalizaIntX (void); void AnalizaIntY (void); void InicializarSerie (void); void IntSerie (void); unsigned char CantidadEnColaRecepcion (void);

19 unsigned char RetirarDatoColaRecepcion (void); unsigned char AgregarDatoColaTransmision (unsigned char); void InicializarInterrupciones (void); Se inicializan las interrupciones y los motores. Para ello se utilizaron las subrutinas InicializarInterrupciones, InicializarSerie, e InicializarMotores. Luego mediante la funcion CantidadEnColaRecepcion se consulta el buffer de la Comunicación Serie. Cuando este recibe alguna instrucción (3 bytes) mediante un Switch Case se ejecuta la funcion correspondiente, por ejemplo AvanzarMotor, MoverFin, MoverInicio, RetrocederMotor. Para mover los motores se utilizaron las funciones básicas RetroUnPaso y AvanUnPaso. Luego de ejecutar la instrucción correspondiente se contesta con ÉXITO o ERROR según corresponda, para este proceso se utilizo la subrutina AgregarDatoColaTransmision. Las funciones AnalizaIntX y AnalizaIntY se utilizan para analizar las interrupciones Externas ( INT0 -> MotorX y INT1 ->MotorY ). En cada una de ellas se analiza cual es el sensor que interrumpió, los cuales se realimentan en la parte baja del Puerto1, y si corresponde o no tomar alguna accion como bloquear el sistemas, o detener el movimiento de algun motor, etc. Todos estos procesos se repiten mediante un while(1) y siempre el sistema queda esperando por alguna Instrucción para ejecutar

20 Main.c : /* Inclusión de Archivos */ #include <Macros51.h> // Incluyo Archivo con Macros de Uso General #include <Defines51.h> // Incluyo Archivo con Defines para 8051 /* Funciones y Variables Externas */ /* Funciones de los Motores */ extern void InicializarMotores (void); // Inicializa los Motores, Busca sensor de comienzo extern bit AvanUnPaso (bit); // Avanzar un Paso extern bit RetroUnPaso (bit); // Retroceder un Paso extern void DemoraPaso (unsigned char); // Demora para velocidades extern unsigned char RetrocederMotor (unsigned char,unsigned char,unsigned char); // Retroceder Motor extern unsigned char AvanzarMotor(unsigned char,unsigned char,unsigned char); // Avanzar Motor extern unsigned char MoverInicio (unsigned char); // Mover al Inicio extern unsigned char MoverFin (unsigned char); // Mover a Fin extern void AnalizaIntX (void); // Interrupcion Sensor Inicio X - Fin X extern void AnalizaIntY (void); // Interrupcion Sensor Inicio Y - Fin Y /* Funciones de Comunicacion Serie */ extern void InicializarSerie (void); // Inicializar Control de Comunicación Serie extern void IntSerie (void); // Control de Comunicación Serie extern unsigned char CantidadEnColaRecepcion (void); // Cantidad de Datos en la Cola de Recepción extern unsigned char RetirarDatoColaRecepcion (void); // Retirar Dato de la Cola de Recepción extern unsigned char AgregarDatoColaTransmision (unsigned char); // Agregar Dato a la Cola de Transmisión /* Declaración de Prototipos */ void Main (void); // Programa Principal void InicializarInterrupciones (void); // Inicializar Interrupciones void IntExtern0 (void); // Atención de Externa 0 void IntExtern1 (void); // Atención de Externa 1 void IntTimer1 (void); // Atención de Interrupción de Timer 1 /*

21 - Cristal y Reloj de la CPU */ #define DIVcLOCK 12 // Divisor interno de Reloj #define FRECxTAL // Freceuncia del Cristal en Hz #define FRECcLOCK (FRECxTAL / DIVcLOCK) // Frecuencia de Reloj Interno en Hz /* Equs correspondientes a las Interrupciones */ /* Equs de Com Serie */ #define IPiNICIAL 0 // Interrupt Priority Register // Selecciono todas las Interrupciones con Prioridad Baja #define IPiNICIAL 0 // Interrupt Priority Register // Selecciono todas las Interrupciones con Prioridad Baja #define IEiNICIALsERIE (EAmAS ESmAS) // Interrupt Enable Register // Seteo el Bit de Habilitación General de Interrupciones y el Bit // de Habilitación de la Interrupción de Comunicación Serie #define TMODiNICIAL1 T1mOD2 // Timer/Counter Mode Control Register // Selecciono el Modo de Operación 2 para el Timer 1 #define TCONiNICIAL1 TR1mAS // Timer/Counter Control Register // Arranco la cuenta del el Timer 1 #define SCONiNICIAL (SMO1mAS RENmAS) // Serial Control Register // UART de 8 bits (velocidad variable) // Habilito la Recepción del Puerto Serie #define PCONiNICIAL 0 // Control de Consumo // Duplicador de Baud Rate en "0" // Consumo Normal /* Equs de IRQ EXT */ #define TCONiNICIALiEXT (IT1mAS) #define IEiNICIALiEXT (EAmAS EX0mAS EX1mAS) #define ENABLE 1 #define DISABLE 0 /* Interrupción del Timer 1 para Comunicación Serie */ #define BAUDrATE 1200 // Velocidad de Comunicación Serie en "1/S" #define DOSeXPsMOD (1 << ((PCONiNICIAL & SMODmAS) >> SMODbIT)) #define CUENTArECARGAtIM1 (0x100 - (((FRECcLOCK / 32) / BAUDrATE) * DOSeXPsMOD)) // Cuenta de Recarga del Timer 1 #define CANTvELOCIDADES

22 unsigned char code TablaVelocidad [CANTvELOCIDADES] = 0x01, 0x04, 0x11, 0x0B; // Tabla de velocidades que es pedido por la funcion demora(while) unsigned int data pasox, pasoy, pasoz; // Recorre la tabla de medio Paso o un Paso unsigned char data modvelmotor; // Modo de Velocidad de pedida bit data inicmotorx, finmotorx, inicmotory, finmotory; // Sensores bit data inicializa; // Flag para inicializar /* Programa Principal */ /* Función: void Main (void); - Acción: Inicializa Procesos - Espera las instrucciones y las ejecuta */ void Main (void) unsigned char datorx1, datorx2, datorx3; // Varible para almacenar la Instrucción inicializa = ACTIVO; // Activo, definido en macros ACTIVO = 1 pasox = 0; pasoy = 0; //pasoz = 0; // Contador para llevar la cuenta de los pasos X // Contador para llevar la cuenta de los pasos Y // Contador para llevar la cuenta de los pasos Z modvelmotor = 0; // Maxima Velocidad InicializarInterrupciones(); InicializarSerie(); InicializarMotores(); // Inicializar Interrupciones // Inicializar Control de Comunicación Serie // Inicializa los Motores inicializa = PASIVO; // PASIVO=0 while (1) while (CantidadEnColaRecepcion () >= 3) // Itero por siempre // Espero hasta recibir una Instrucción datorx1 = RetirarDatoColaRecepcion (); // Primer Byte, Retiro el Dato de la Cola de Recepción datorx2 = RetirarDatoColaRecepcion (); // Segundo Byte, Retiro el Dato de la Cola de Recepción datorx3 = RetirarDatoColaRecepcion (); // Tercer Byte, Retiro el Dato de la Cola de Recepción switch (datorx1)

23 case 0x00: AgregarDatoColaTransmision (MoverInicio(datoRx1)); //Instruccion -> Mover a Inicio X break; case 0x01: AgregarDatoColaTransmision (MoverInicio(datoRx1)); //Instruccion -> Mover a Inicio Y break; case 0xFC: AgregarDatoColaTransmision (MoverFin(datoRx1)); //Instruccion -> Mover a Fin X break; case 0xFD: AgregarDatoColaTransmision (MoverFin(datoRx1)); //Instruccion -> Mover a Fin Y break; case 0x0C: AgregarDatoColaTransmision (RetrocederMotor(datoRx1,datoRx2,datoRx3)); break; //Instruccion -> Retroceder Motor X case 0x0D: AgregarDatoColaTransmision (RetrocederMotor(datoRx1,datoRx2,datoRx3)); break; //Instruccion -> Retroceder Motor Y case 0x0E: AgregarDatoColaTransmision (RetrocederMotor(datoRx1,datoRx2,datoRx3)); break; //Instruccion -> Retroceder Motor Z case 0x20: AgregarDatoColaTransmision (AvanzarMotor(datoRx1,datoRx2,datoRx3)); break; //Instruccion -> Avanzar Motor X case 0x21: AgregarDatoColaTransmision (AvanzarMotor(datoRx1,datoRx2,datoRx3)); break; //Instruccion -> Avanzar Motor Y /* Función: void InicializarInterrupciones (void); - Acción: Inicializa los registros asociados a las interrupciones */ void InicializarInterrupciones (void) inicmotorx = PASIVO; finmotorx = PASIVO; inicmotory = PASIVO; finmotory = PASIVO; // Inicializacion TIMER1 para Com Serie TL1 = CUENTArECARGAtIM1; // Cargo la parte baja del Timer 1 TH1 = CUENTArECARGAtIM1; // Cargo la parte alta del Timer 1 TMOD = ( TMODiNICIAL1 ); // Inicializo Timer/Counter Mode Register TCON = ( TCONiNICIAL1 TCONiNICIALiEXT ); // Inicializo Timer/Counter Control Register SCON = SCONiNICIAL; PCON = PCONiNICIAL; // Inicializo Serial Control Register // Inicializo Control de Consumo IP = IPiNICIAL; // Inicializo Interrupt Priority Register IE = ( IEiNICIALsERIE IEiNICIALiEXT); // Inicializo Interrupt Enable Register

24 void IntExtern0 (void) interrupt INTeXT0 AnalizaIntX (); //Analiza que sensor Interrumpio IT0 = 1; //Modo de Interrupcion por flancos descendentes void IntExtern1 (void) interrupt INTeXT1 AnalizaIntY (); //Analiza que sensor Interrumpio IT1 = 1; //Modo de Interrupcion por flancos descendentes

25 Motor.c : /* SUBRUTINA DEL MOVIMIENTO DE LOS MOTORES */ /* Inclusión de Archivos */ #include <Macros51.h> // Incluyo Archivo con Macros de Uso General #include <Defines51.h> // Incluyo Archivo con defines para 8051 /* Funciones Auxiliares */ extern unsigned char AgregarDatoColaTransmision (unsigned char); void InicializarMotores ( void); // Inicializacion / Posicionamiento bit AvanUnPaso (bit); // Avance de un paso bit RetroUnPaso (bit); // Retroceso de un paso void DemoraPaso (unsigned char); // Impone la demora entre paso y paso => Velocidad bit VerifPaso (void); // Verifica la secuencia correcta de los motores unsigned char RetrocederMotor (unsigned char,unsigned char,unsigned char); // Retroceder Motor unsigned char AvanzarMotor(unsigned char,unsigned char,unsigned char); // Avanzar Motor unsigned char MoverInicio (unsigned char); // Mover al Inicio unsigned char MoverFin (unsigned char); // Mover a Fin void AnalizaIntX (void); void AnalizaIntY (void); void SystemError (void); // Interrupcion Sensor Inicio X - Fin X // Interrupcion Sensor Inicio Y - Fin Y // Error del Sistema extern unsigned char code TablaVelocidad[]; // Elijo de la tabla la velocidad extern unsigned int data pasox, pasoy, pasoz; // Recorre la tabla de 1/2 o un Paso extern unsigned char data modvelmotor; // Modo de Velocidad de pedida extern bit data inicmotorx, finmotorx, inicmotory, finmotory; // Sensores extern bit data inicializa; // Flag para inicializar unsigned int data pasosretro, pasosavan; unsigned char data motorretro, motoravan; unsigned char data flagpasox, flagpasoy, flagpasoz; unsigned char code TablaPasosMotorX [LONGpASOSmOTORx] = 0x0C, // b 0x09, // b 0x03, // b 0x06; // b Pasos del MotorX D C B A A B C D unsigned char code TablaPasosMotorY [LONGpASOSmOTORy] =

26 0x60, // b Pasos del MotorY 0xE0, // b D C B A A B C D 0xC0, // b 0xD0, // b 0x90, // b 0xB0, // b 0x30, // b 0x70; // b void InicializarMotores (void) DIRPIN (INTiNICx, INTiNICxdIR); DIRPIN (INTfINx, INTfINxdIR); DIRPIN (INTiNICy, INTiNICydIR); DIRPIN (INTfINy, INTfINydIR); flagpasox = PASOiNIC; flagpasoy = PASOiNIC; // Cargo con 0 flagpasox // Cargo con 0 flagpasoy DIRPORT (MOTORESpORT, SALIDA); ACC = MOTORESiNIC; MOVAP (MOTORESpORT, MOTORESaCT); // Inicializo las Entradas y las Salidas if(inicmotorx == PASIVO) do RetroUnPaso(MOTORX); DemoraPaso(TablaVelocidad[0]); while(inicmotorx == PASIVO); // Muevo el Motor X hasta que encuentre el sensor de inicio if(inicmotory == PASIVO) do RetroUnPaso(MOTORY); DemoraPaso(TablaVelocidad[3]); return; while(inicmotory == PASIVO); // Muevo el Motor Y hasta que encuentre el sensor de inicio bit VerifPaso (void) if((flagpasox > LONGpASOSmOTORx) (flagpasox < PASOiNIC)) return ERROR; if((flagpasoy > LONGpASOSmOTORy) (flagpasoy < PASOiNIC)) return ERROR; return EXITO;

27 bit AvanUnPaso (bit Motor) if(verifpaso()==error) return ERROR; if(motor == MOTORX) flagpasox++; if(flagpasox == LONGpASOSmOTORx) flagpasox = PASOiNIC; ACC=(P0 & 0xF0) + TablaPasosMotorX [flagpasox]; if(motor == MOTORY) flagpasoy++; if(flagpasoy == LONGpASOSmOTORy) flagpasoy = PASOiNIC; ACC=(P0 & 0x0F) + TablaPasosMotorY [flagpasoy]; MOVAP (MOTORESpORT, MOTORESaCT); // Activo los pines de P0 que segun correspondan //al motor X/Y return EXITO; bit RetroUnPaso (bit Motor) if(verifpaso()==error) return ERROR; if(motor == MOTORX) if(flagpasox == PASOiNIC) flagpasox = LONGpASOSmOTORx - 1; else flagpasox--; ACC=(P0 & 0xF0) + TablaPasosMotorX [flagpasox]; if(motor == MOTORY) if(flagpasoy == PASOiNIC) flagpasoy = LONGpASOSmOTORy - 1; else flagpasoy--; ACC=(P0 & 0x0F) + TablaPasosMotorY [flagpasoy]; MOVAP (MOTORESpORT, MOTORESaCT); return EXITO;

28 void DemoraPaso (unsigned char demora) unsigned char demora1,demora2,demora3; for(demora1=0; demora1 < demora; demora1++) for(demora2=0; demora2<36; demora2++) for(demora3=0; demora3<33; demora3++); return; unsigned char RetrocederMotor (unsigned char datorx1,unsigned char datorx2,unsigned char datorx3) unsigned int cont; pasosretro = ((datorx2) * (0x100)); // Paso Rx2 a la parte alta para poder formar los dos bytes pasosretro = (pasosretro + datorx3); // Le sumo la parte baja motorretro = (datorx1 & 0x03); if (motorretro == MOTORX ) if(pasosretro > pasox) return (INSTeRROR); for(cont=0; cont < pasosretro; cont++) RetroUnPaso(MOTORX); pasox --; DemoraPaso(TablaVelocidad[0]); if(pasox < MAXpASOSx) finmotorx = PASIVO; if (motorretro == MOTORY ) if(pasosretro > pasoy) return (INSTeRROR); for(cont=0; cont < pasosretro; cont++) RetroUnPaso(MOTORY); pasoy --; DemoraPaso(TablaVelocidad[3]); if(pasoy < MAXpASOSy) finmotory = PASIVO; return(instexito);

29 unsigned char AvanzarMotor (unsigned char datorx1,unsigned char datorx2,unsigned char datorx3) unsigned int cont; pasosavan = ((datorx2) * (0x100)); bytes pasosavan = (pasosavan + datorx3); // Paso Rx2 a la parte alta para poder formar los dos // Le sumo la parte baja motoravan = (datorx1 & 0x03); if (motoravan == MOTORX ) if((pasosavan + pasox) > MAXpASOSx ) return (INSTeRROR); for(cont=0; cont < pasosavan; cont++) AvanUnPaso(MOTORX); pasox ++; DemoraPaso(TablaVelocidad[0]); if(pasox > PASOiNIC) inicmotorx = PASIVO; if (motoravan == MOTORY ) if((pasosavan + pasoy) > MAXpASOSy ) return (INSTeRROR); for(cont=0; cont < pasosavan; cont++) AvanUnPaso(MOTORY); pasoy ++; DemoraPaso(TablaVelocidad[3]); if(pasoy > PASOiNIC) inicmotory = PASIVO; return(instexito); unsigned char MoverInicio (unsigned char datorx1) //unsigned int pasosretrox, pasosretroy; //pasosretrox = pasox; //pasosretroy = pasoy; motorretro = (datorx1 & 0x03); if (motorretro == MOTORX ) if (pasox == 0 ) return (INSTeRROR); while(inicmotorx == PASIVO)

30 RetroUnPaso(MOTORX); //pasox --; DemoraPaso(TablaVelocidad[0]); if(pasox < MAXpASOSx) finmotorx = PASIVO; pasox=0; if (motorretro == MOTORY ) if (pasoy == 0 ) return (INSTeRROR); while(inicmotory == PASIVO) RetroUnPaso(MOTORY); // pasoy --; DemoraPaso(TablaVelocidad[3]); if(pasoy < MAXpASOSy) finmotory = PASIVO; pasoy=0; return(instexito); unsigned char MoverFin (unsigned char datorx1) unsigned int pasosavanx, pasosavany; pasosavanx = pasox; pasosavany = pasoy; motoravan = (datorx1 & 0x03); if (motoravan == MOTORX ) if(pasox == MAXpASOSx) return (INSTeRROR); while(finmotorx == PASIVO) AvanUnPaso(MOTORX); pasox ++; DemoraPaso(TablaVelocidad[0]); if(pasox > PASOiNIC) inicmotorx = PASIVO; if (motoravan == MOTORY ) if(pasoy == MAXpASOSy) return (INSTeRROR); while(finmotory == PASIVO) AvanUnPaso(MOTORY); pasoy ++; DemoraPaso(TablaVelocidad[3]);

31 if(pasoy > PASOiNIC) inicmotory = PASIVO; return(instexito); // Analisis de las Interrupciones Externas void AnalizaIntX (void) IFACT (INTiNICx, INTiNICxaCT) if(pasox > PASOiNIC) SystemError(); else inicmotorx = ACTIVO; //Si sensor de Inicio == ACT return; IFACT (INTfINx, INTfINxaCT) //Si sensor de Fin == ACT if(pasox < MAXpASOSx) if(inicializa == PASIVO) SystemError(); else finmotorx = ACTIVO; void AnalizaIntY (void) IFACT (INTiNICy, INTiNICyaCT) if(pasoy > PASOiNIC) SystemError(); else inicmotory = ACTIVO; //Si sensor de Inicio == ACT IFACT (INTfINy, INTfINyaCT) if(pasoy < MAXpASOSy) if(inicializa == PASIVO) else finmotory = ACTIVO; return; //Si sensor de Fin == ACT SystemError(); void SystemError (void) DIRPORT (MOTORESpORT, SALIDA); ACC = MOTORESiNIC; MOVAP (MOTORESpORT, MOTORESaCT); AgregarDatoColaTransmision (INSTsYSTEMeRROR); // Apago el Puerto de los Motores //Envio Instruccion de Error de Sistema while(1) //Loop Infinito. return;

32 Serie.c : /* Inclusión de Archivos */ #include <Macros51.h> // Incluyo Archivo con Macros de Uso General #include <Defines51.h> // Incluyo Archivo con defines para 8051 /* Declaración de Prototipos */ void InicializarSerie (void); // Inicializar Control de Comunicación Serie void IntSerie (void); // Control de Comunicación Serie void InicializarColaRecepcion (void); // Inicializar Cola de Recepción unsigned char CantidadEnColaRecepcion (void); // Cantidad de Datos en la Cola de Recepción unsigned char RetirarDatoColaRecepcion (void); // Retirar Dato de la Cola de Recepción unsigned char AgregarDatoColaRecepcion (unsigned char); // Agregar Dato a la Cola de Recepción void InicializarColaTransmision (void); // Inicializar Cola de Transmisión unsigned char CantidadEnColaTransmision (void); // Cantidad de Datos en la Cola de //Transmisión unsigned char RetirarDatoColaTransmision (void); // Retirar Dato de la Cola de Transmisión unsigned char AgregarDatoColaTransmision (unsigned char); // Agregar Dato a la Cola de Transmisión /* Defines correspondientes a Comunicación Serie */ #define LONGITUDcOLArECEPCION 40 // Longitud de la Cola de Recepción #define LONGITUDcOLAtRANSMISION 40 // Longitud de la Cola de Transmisión #define COLAlLENA ERROR // Señalización de Cola Llena #define COLAvACIA ERROR // Señalización de Cola Vacía #define NO 0 // Señalización de Verdadero #define SI 1 // Señalización de Falso /* Reserva de Variables */ // Reservas en RAM Interna de Acceso Directo unsigned char data colarecepcion [LONGITUDcOLArECEPCION]; // Cola en la que se Almacenan los Datos unsigned char data cantidadcolarecepcion; // Contador de Datos Almacenados en la Cola unsigned char data * data entradacolarecepcion; // Puntero para la Entrada de Datos a la Cola unsigned char data * data salidacolarecepcion; // Puntero para la Salida de Datos de la Cola unsigned char data colatransmision [LONGITUDcOLAtRANSMISION]; // Cola en la que se Almacenan los Datos unsigned char data cantidadcolatransmision; // Contador de Datos Almacenados en la Cola unsigned char data * data entradacolatransmision;// Puntero para la Entrada de Datos a la Cola unsigned char data * data salidacolatransmision; // Puntero para la Salida de Datos de la Cola bit data TxEnCurso; // Transmisión En Curso SI/NO /*

33 - Programa */ /* Función: void InicializarSerie (void); - Acción: Inicializa la Cola de Recepción, - Inicializa la Cola de Transmisión, - Inicializa variables de Control de Comunicación Serie */ void InicializarSerie (void) InicializarColaRecepcion (); InicializarColaTransmision (); TxEnCurso = NO; // Inicializo la Cola de Recepción // Inicializo la Cola de Transmisión // Señalizo Transmisión En Curso NO return; /* Función: void IntSerie (void) interrupt INTsER - Acción: Analiza los Flag de Recepción y Transmisión. - Si entró por Recepción resetear RI, Procesar la Recepción. - Si entró por Transmisión resetear TI, Procesar la Transmisión */ void IntSerie (void) interrupt INTsER if (RI == SI) // Verifico si ha Interrumpido por Recepción RI = 0; // Reseteo Flag de Recepción AgregarDatoColaRecepcion (SBUF); // Almaceno el Dato Recibido en la Cola de //Recepción return; // Salgo if (TI == SI) // Verifico si ha Interrumpido por Transmisión TI = 0; // Reseteo Flag de Transmisión if (CantidadEnColaTransmision ()!= 0) // Verifico si Hay más Datos que Transmitir SBUF = RetirarDatoColaTransmision(); else TxEnCurso = SI; TxEnCurso = NO; // Transmito Dato Almacenado en la Cola de //Transmisión // Señalizo Transmisión En Curso SI // Señalizo Transmisión En Curso NO return; /*

34 - Función: void InicializarColaRecepcion (void); - Acción: Inicializa el Contador de Datos Almacenados en la Cola, - Inicializa el Puntero para la Entrada de Datos a la Cola, - Inicializa el Puntero para la Salida de Datos de la Cola */ void InicializarColaRecepcion (void) cantidadcolarecepcion = 0; // Inicializo Contador de Datos Almacenados entradacolarecepcion = colarecepcion; // Inicializo el Puntero para la Entrada de Datos salidacolarecepcion = colarecepcion; // Inicializo el Puntero para la Salida de Datos return; /* Función: unsigned char CantidadEnColaRecepcion (void); - Acción: Retorna el Contador de Datos Almacenados en la Cola */ unsigned char CantidadEnColaRecepcion (void) return (cantidadcolarecepcion); // Retorno Contador de Datos Almacenados en la Cola /* Función: unsigned char AgregarDatoColaRecepcion (unsigned char dato); - Acción: Recibe un Dato, Si la Cola está Llena señaliza y retorna. Si hay lugar en la Cola Almacena el Dato recibido en ella, Incrementa el Contador de Datos Almacenados en la Cola, Actualiza el Puntero de Ingreso de Datos a la Cola, Señaliza que ha podido y retorna */ unsigned char AgregarDatoColaRecepcion (unsigned char dato) if (cantidadcolarecepcion >= LONGITUDcOLArECEPCION) // Verifico si la Cola No está Llena return (COLAlLENA); // Retorno Cola Llena *entradacolarecepcion = dato; // Almaceno el Dato en la Cola cantidadcolarecepcion ++; // Incremento Contador de Datos Almacenados en la Cola if (++entradacolarecepcion >= (colarecepcion + LONGITUDcOLArECEPCION)) // Incremento Puntero para la Entrada de Datos a la Cola // Verifico Si No llegué al fin de la Cola entradacolarecepcion = colarecepcion; // Inicializo Puntero para la //Entrada de Datos a la Cola rreturn (EXITO); // Retorno Exito /*

35 - Función: unsigned char RetirarDatoColaRecepcion (void); - Acción: Si la Cola está Vacía señaliza y retorna. - Si hay Datos en la Cola recupera un Dato de ella, - Decrementa el Contador de Datos Almacenados en la Cola, Actualiza el Puntero de Egreso de Datos de la Cola, Retorna el Dato retirado de la Cola */ unsigned char RetirarDatoColaRecepcion (void) char dato; if (cantidadcolarecepcion == 0) return (COLAvACIA); dato = *salidacolarecepcion; cantidadcolarecepcion --; Almacenados en la Cola // Verifico si la Cola está Vacía // Retorno Cola Vacía // Recupero el Dato de la Cola // Decremento Contador de Datos if (++salidacolarecepcion >= (colarecepcion + LONGITUDcOLArECEPCION)) // Incremento Puntero para la Salida Datos de la Cola // Verifico Si No llegué al fin de la Cola salidacolarecepcion = colarecepcion; // Inicializo Puntero para la Salida de //Datos de la Cola return (dato); // Retorno el Dato /* Función: void InicializarColaTransmision (void); - Acción: Inicializa el Contador de Datos Almacenados en la Cola, - Inicializa el Puntero para la Entrada de Datos a la Cola, - Inicializa el Puntero para la Salida de Datos de la Cola */ void InicializarColaTransmision (void) cantidadcolatransmision = 0; entradacolatransmision = colatransmision; salidacolatransmision = colatransmision; return; // Inicializo Contador de Datos //Almacenados // Inicializo el Puntero para la Entrada de //Datos // Inicializo el Puntero para la Salida de //Datos /* Función: unsigned char CantidadEnColaTransmision (void); - Acción: Retorna el Contador de Datos Almacenados en la Cola */ unsigned char CantidadEnColaTransmision (void) return (cantidadcolatransmision); // Retorno Contador de Datos Almacenados en la Cola /*

36 - Función: unsigned char AgregarDatoColaTransmision (unsigned char dato); - Acción: Recibe un Dato, - Si la Cola está Llena señaliza y retorna. Si hay lugar en la Cola Almacena el Dato recibido en ella, - Incrementa el Contador de Datos Almacenados en la Cola, Actualiza el Puntero de Ingreso de Datos a la Cola, Señaliza que ha podido y retorna */ unsigned char AgregarDatoColaTransmision (unsigned char dato) if (cantidadcolatransmision >= LONGITUDcOLAtRANSMISION) // Verifico si la Cola No está Llena return (COLAlLENA); // Retorno Cola Llena *entradacolatransmision = dato; // Almaceno el Dato en la Cola cantidadcolatransmision ++; // Incremento Contador de Datos Almacenados en la Cola if (++entradacolatransmision >= (colatransmision + LONGITUDcOLAtRANSMISION)) // Incremento Puntero para la Entrada de Datos a la Cola // Verifico Si No llegué al fin de la Cola entradacolatransmision = colatransmision; // Inicializo Puntero para la Entrada de Datos a la Cola EA = 0; // Deshabilito las Interrupciones if (TxEnCurso == NO) TI = 1; EA = 1; return (EXITO); // Verifico si NO Hay Transmisión en Curso // En tal caso Genero la Interrupción de // Comunicación Serie por Transmisión // Habilito las Interrupciones // Atomizo esta parte del programa => FIN // Retorno Exito /* Función: unsigned char RetirarDatoColaTransmision (void); - Acción: Si la Cola está Vacía señaliza y retorna. - Si hay Datos en la Cola recupera un Dato de ella, Decrementa el Contador de Datos Almacenados en la Cola, Actualiza el Puntero de Egreso de Datos de la Cola, Retorna el Dato retirado de la Cola */ unsigned char RetirarDatoColaTransmision (void) char dato; if (cantidadcolatransmision == 0) return (COLAvACIA); // Verifico si la Cola está Vacía // Retorno Cola Vacía dato = *salidacolatransmision; // Recupero el Dato de la Cola cantidadcolatransmision --; // Decremento Contador de Datos Almacenados en la Cola if (++salidacolatransmision >= (colatransmision + LONGITUDcOLAtRANSMISION)) // Incremento Puntero para la Salida Datos de la Cola // Verifico Si No llegué al fin de la Cola salidacolatransmision = colatransmision; // Inicializo Puntero para la Salida de Datos de la Cola

37 return (dato); // Retorno el Dato

38 Macros51.h /* Defines de propósito general */ #define EXITO 0 #define ERROR 1 #define SALIDA 0 // Port de Salida #define ENTRADA 1 // Port de Entrada #define BAJO 0 #define ALTO 1 // Activo Bajo // Activo Alto #define PASIVO 0 // Pasivo #define ACTIVO 1 // Activo /* Macro para manejo de bits */ /* Macro: DIRección de un PIN - Acción: Si el bit N de un port es Entrada lo fuerza a Alto, si no no hace nada. - DIRPIN (portbit, ENTRADA) - DIRPIN (portbit, SALIDA) */ #define DIRPIN(portNumeroBitNumero, direccion) if (direccion == ENTRADA) portnumerobitnumero = ALTO /* Macro: ACTivar un PIN - Acción: Activa el bit N de un port en función de su nivel de actividad. - ACTPIN (portbit, BAJO) - ACTPIN (portbit, ALTO) */ #define ACTPIN(portNumeroBitNumero, activo) if (activo == BAJO) portnumerobitnumero = BAJO; else portnumerobitnumero = ALTO /* Macro: PASivar un PIN - Acción: Pasiva el bit N de un port en función de su nivel de actividad. - PASPIN (portbit, BAJO) - PASPIN (portbit, ALTO) */ #define PASPIN(portNumeroBitNumero, activo) if (activo == BAJO) portnumerobitnumero = ALTO; else portnumerobitnumero = BAJO

39 /* Macro: If bit is ACTive -Acción: Ejecuta si el nivel del bit N de un port es ACTIVO en función de su nivel de actividad - IFACT (portbit, BAJO) - IFACT (portbit, ALTO) */ #define IFACT(portNumeroBitNumero, activo) if (portnumerobitnumero == activo) /* Macro: If bit is PASsive -Acción: Ejecuta si el nivel del bit N de un port es PASIVO en función de su nivel de actividad - JPAS (portbit, BAJO) - JPAS (portbit, ALTO) */ #define IFPAS(portNumeroBitNumero, activo) if (portnumerobitnumero!= activo) /* Macro para manejo de bytes */ /* Macro: DIRección del Port - Acción: Si los 7 bits de un port son Entradas los fuerza a Alto, si no no hace nada. - - DIRPORT (port, ENTRADA) - DIRPORT (port, SALIDA) */ #define DIRPORT(portNumero, direccion) if (direccion == ENTRADA) portnumero = 0xFF /* Macro: MOVer Acumulador al Port -Acción: Mover el contenido del acumulador a un port en función de su nivel de actividad del -mismo. - MOVAP (port, BAJO) - MOVAP (port, ALTO) */ #define MOVAP(portNumero, activo) if (activo == BAJO) ACC = ~ACC; portnumero = ACC

40 /* Macro: MOVer Port al Acumulador - Acción: Mover el contenido de un port al acumulador en función de su nivel de actividad - - del mismo. - MOVPA (port, BAJO) - MOVPA (port, ALTO) */ #define MOVPA(portNumero, activo) ACC = portnumero; if (activo == BAJO) ACC = ~ACC /* Macro: MOVer Variable al Port - Acción: Mover el contenido de la variable a un port en función de su nivel de actividad - - del mismo. - MOVVP (variable, port, BAJO) - MOVVP (variable, port, ALTO) */ #define MOVVP(variable, portnumero, activo) if (activo == BAJO) variable = ~variable; portnumero = variable /* Macro: MOVer Port a la Variable - Acción: Mover el contenido de un port a una variable en función de su nivel de - actividad del mismo. - MOVPV (port, BAJO, variable) - MOVPV (port, ALTO, variable) */ #define MOVPV(portNumero, activo, variable) variable = portnumero; if (activo == BAJO) variable = ~variable

41 Defines51.h /* Interrupt Vectors */ #define INTeXT0 0 // Interrupción Externa 0 #define INTtIM0 1 // Interrupción de Timer 0 #define INTeXT1 2 // Interrupción Externa 0 #define INTtIM1 3 // Interrupción de Timer 1 #define INTsER 4 // Interrupción del Puerto Serie 0 /* Port 0 Register */ sfr P0 = 0x80; // Port 0 /* Port 1 Register */ sfr P1 = 0x90; // Port 1 /* Port 2 Register */ sfr P2 = 0xA0; // Port 2 /* Port 3 Register */ sfr P3 = 0xB0; // Port 3 sbit RD = 0xB7; // Control de de Lectura sbit WR = 0xB6; // Control de Escritura sbit T1 = 0xB5; // Entrada de Timer 1 sbit T0 = 0xB4; // Entrada de Timer 0 sbit INT1 = 0xB3; // Interrupción Externa 1 sbit INT0 = 0xB2; // Interrupción Externa 0 sbit TXD = 0xB1; // Salida de Datos Serie sbit RXD = 0xB0; // Entrada de Datos Serie /* Program Status Word Register */ sfr PSW = 0xD0; // Palabra de Estado del Programa

42 /* PSW */ sbit CY = 0xD7; // Acarreo sbit AC = 0xD6; // Acarreo Auxiliar sbit F0 = 0xD5; // Flag 0 sbit RS1 = 0xD4; // Selección de Registros 1 sbit RS0 = 0xD3; // Selección de Registros 0 sbit OV = 0xD2; // Desborde sbit P = 0xD0; // Paridad /* Accumulator Register */ sfr ACC = 0xE0; // Acumulador /* B Auxiliar Register */ sfr B = 0xF0; // Registro Auxiliar B /* Stack Pointer Register */ sfr SP = 0x81; // Puntero a la Pila /* Data Pointer Register */ sfr DPL = 0x82; // Puntero de Datos Byte menos significativo sfr DPH = 0x83; // Puntero de Datos Byte más significativo /* Power Control Register */ sfr PCON = 0x87; // Control de Consumo #define SMODbIT 7 // Bit Duplicador de Baud Rate #define SMODmAS (1 << SMODbIT) // Máscara correpondiente #define PDbIT 1 #define PDmAS (1 << PDbIT) // Bit Power Down // Máscara correpondiente #define IDLbIT 0 // Bit Idle Mode #define IDLmAS (1 << IDLbIT) // Máscara correpondiente

43 /* Timer/Counter Control Register */ sfr TCON = 0x88; // Control de Temporizadores/Contadores sbit TF1 = 0x8F; // Desborde del Timer 1 #define TFbIT 7 // Bit de Desborde del Timer 1 #define TFmAS (1 << TFbIT) // Máscara correpondiente // Bit en "1" indica Desborde del Timer 1 sbit TR1 = 0x8E; // Arranque del Timer 1 #define TR1bIT 6 // Bit de Arranque del Timer 1 #define TR1mAS (1 << TR1bIT) // Máscara correpondiente // Bit en "1" Arranca el Timer 1 sbit TF0 = 0x8D; // Desborde del Timer 0 #define TF0bIT 5 // Bit de Desborde del Timer 0 #define TF0mAS (1 << TF0bIT) // Máscara correpondiente // Bit en "1" indica Desborde del Timer 0 sbit TR0 = 0x8C; // Arranque del Timer 0 #define TR0bIT 4 // Bit de Arranque del Timer 0 #define TR0mAS (1 << TR0bIT) // Máscara correpondiente // Bit en "1" Arranca el Timer 0 sbit IE1 = 0x8B; // Transición de la Interrupción Externa 1 #define IE1bIT 3 // Bit de Transición de la Interrupción Externa 1 #define IE1mAS (1 << IE1bIT) // Máscara correpondiente // Bit en "1" indica Transición sbit IT1 = 0x8A; // Tipo de Disparo de la Interrupción Externa 1 #define IT1bIT 2 // Bit de Tipo de Disparo de la Interrupción Externa 1 #define IT1mAS (0 << IT1bIT) // Máscara correpondiente // Bit en "1" para Detección por Nivel Bajo // Bit en "0" para Detección por Flanco Descendente sbit IE0 = 0x89; // Transición de la Interrupción Externa 0 #define IE0bIT 1 // Bit de Transición de la Interrupción Externa 0 #define IE0mAS (1 << IE0bIT) // Máscara correpondiente // Bit en "1" indica Transición sbit IT0 = 0x88; // Tipo de Disparo de la Interrupción Externa 0 #define IT0bIT 0 // Bit de Tipo de Disparo de la Interrupción Externa 0 #define IT0mAS (0 << IT0bIT) // Máscara correpondiente // Bit en "1" para Detección por Nivel Bajo // Bit en "0" para Detección por Flanco Descendente /* Timer/Counter Mode Control Register */ sfr TMOD = 0x89; // Control de Modo de Temporizadores/Contadores #define G1bIT 7 // Bit de Habilitación de Cuenta del Timer 1 #define G1mAS (1 shl G1bIT) // Máscara correpondiente // Bit en "1" Timer 1 Habilitado si INT1 y TR1bIT es "1" // Bit en "0" Timer 1 Habilitado si TR1bIT es "1"

44 #define CT1bIT 6 // Bit de Selección de Función del Timer 1 #define CT1mAS (1 << CT1bIT) // Máscara correpondiente // Bit en "1" para Contador // Bit en "0" para Temporizador #define M11bIT 5 // Bit 1 de Selección de Modo del Timer 1 #define M11mAS (1 << M11bIT) // Máscara correpondiente #define M01bIT 4 // Bit 0 de Selección de Modo del Timer 1 #define M01mAS (1 << M01bIT) // Máscara correpondiente #define G0bIT 3 // Bit de Habilitación de Cuenta del Timer 0 #define G0mAS (1 << G0bIT) // Máscara correpondiente // Bit en "1" Timer 1 Habilitado si INT0 y TR0bIT es "1" // Bit en "0" Timer 0 es habilitado si TR0bIT es "1" #define CT0bIT 2 // Bit de Selección de Función del Timer 0 #define CT0mAS (1 << CT0bIT) // Máscara correpondiente // Bit en "1" para Contador // Bit en "0" para Temporizador #define M10bIT 1 // Bit 1 de Selección de Modo del Timer 0 #define M10mAS (1 << M10bIT) // Máscara correpondiente #define M00bIT 0 // Bit 0 de Selección de Modo del Timer 0 #define M00mAS (1 << M00bIT) // Máscara correpondiente #define T1mOD0 0 // Timer 1 como Contador de 13 bits #define T1mOD1 M01mAS // Timer 1 como Contador de 16 bits #define T1mOD2 M11mAS // Timer 1 como Contador de 8 bits de Recarga Automática #define T1mOD3 (M11mAS M01mAS) // Timer 1 permanece Detenido no disponible #define T0mOD0 0 // Timer 0 como Contador de 13 bits #define T0mOD1 M00mAS // Timer 0 como Contador de 16 bits #define T0mOD2 M10mAS // Timer 0 como Contador de 8 bits de Recarga Automática #define T0mOD3 (M10mAS M00mAS) // Timer 0 low y High como Contadores de 8 bits /* Timer/Counter 0 Register */ sfr TL0 = 0x8A; // Temporizador/Contador 0 Byte menos significativo sfr TH0 = 0x8C; // Temporizador/Contador 0 Byte más significativo /* Timer/Counter 1 Register */ sfr TL1 = 0x8B; // Temporizador/Contador 1 Byte menos significativo sfr TH1 = 0x8D; // Temporizador/Contador 1 Byte más significativo

45 /* Interrupt Enable Control Register */ sfr IE = 0xA8; // Control de Habilitación de Interrupciones // Bit en "1" Habilita la interrupción asociada // Bit en "0" Deshabilita la interrupción asociada sbit EA = 0xAF; // Habilitación General de Interrupciones #define EAbIT 7 #define EAmAS (1 << EAbIT) // Bit de Habilitación General de Interrupciones // Máscara correpondiente sbit ES = 0xAC; // Habilitación de Interrupción del Puerto Serie #define ESbIT 4 // Bit de Habilitación de Interrupción del Puerto Serie #define ESmAS (1 << ESbIT) // Máscara correpondiente sbit ET1 = 0xAB; // Habilitación de Interrupción del Timer 1 #define ET1bIT 3 // Bit de Habilitación de Interrupción del Timer 1 #define ET1mAS (1 << ET1bIT) // Máscara correpondiente sbit EX1 = 0xAA; // Habilitación de la Interrupción Externa 1 #define EX1bIT 2 // Bit de Habilitación de la Interrupción Externa 1 #define EX1mAS (1 << EX1bIT) // Máscara correpondiente sbit ET0 = 0xA9; // Habilitación de Interrupción del Timer 0 #define ET0bIT 1 // Bit de Habilitación de Interrupción del Timer 0 #define ET0mAS (1 << ET0bIT) // Máscara correpondiente sbit EX0 = 0xA8; // Habilitación de la Interrupción Externa 0 #define EX0bIT 0 // Bit de Habilitación de la Interrupción Externa 0 #define EX0mAS (1 << EX0bIT) // Máscara correpondiente /* Interrupt Priority Control Register */ sfr IP = 0xB8; // Control de Prioridad de Interrupciones // Bit en "1" asigna Prioridad Alta a la interrupción asociada // Bit en "0" asigna Prioridad Baja a la interrupción asociada sbit PS = 0xBC; // Prioridad del Puerto Serie #define PSbIT 4 #define PSmAS (1 << PSbIT) // Bit de Prioridad del Puerto Serie // Máscara correspondiente sbit PT1 = 0xBB; // Prioridad del Timer 1 #define PT1bIT 3 // Bit de Priordad del Timer 1 #define PT1mAS (1 << PT1bIT) // Máscara correspondiente sbit PX1 = 0xBA; // Prioridad de la Interrupción Externa 1 #define PX1bIT 2 // Bit de Priordad de la Interrupción Externa 1 #define PX1mAS (1 << PX1bIT) // Máscara correspondiente sbit PT0 = 0xB9; // Prioridad del Timer 1 #define PT0bIT 1 // Bit de Priordad del Timer 1 #define PT0mAS (1 << PT0bIT) // Máscara correspondiente sbit PX0 = 0xB8; // Prioridad de la Interrupción Externa

46 #define PX0bIT 0 // Bit de Priordad de la Interrupción Externa 1 #define PX0mAS (1 << PX0bIT) // Máscara correspondiente /* Serial Control Register */ sfr SCON = 0x98; // Control de Puerto Serie sbit SM0 = 0x9F; // Selección de Modo del Puerto Serie #define SM0bIT 7 // Bit 0 de Selección de Modo del Puerto Serie #define SM0mAS (1 << SM0bIT) // Máscara correpondiente sbit SM1 = 0x9E; // Selección de Modo del Puerto Serie #define SM1bIT 6 // Bit 1 de Selección de Modo del Puerto Serie #define SM1mAS (1 << SM1bIT) // Máscara correpondiente sbit SM2 = 0x9D; // Selección de Modo del Puerto Serie #define SM2bIT 5 // Bit 2 de Selección de Modo del Puerto Serie #define SM2mAS (1 << SM2bIT) // Máscara correpondiente sbit REN = 0x9C; // Habilitación de la Recepción del Puerto Serie #define RENbIT 4 // Bit 0 de Habilitación de la Recepción del Puerto Serie #define RENmAS (1 << RENbIT) // Máscara correpondiente // Bit en "1" Habilita de Recepción del Puerto Serie // Bit en "0" Deshabilita de Recepción del Puerto Serie sbit TB8 = 0x9B; // 9no Bit a Transmitir en Modo 2 o 3 #define TB8bIT 3 // Bit 9no a Transmitir en Modo 2 o 3 #define TB8mAS (1 << TB8bIT) // Máscara correpondiente sbit RB8 = 0x9A; // 9no Bit Recibido en Modo 2 o 3 o Stop Bit en Modo 1 #define RB8bIT 2 // Bit 9no Bit Recibido en Modo 2 o 3 o Stop Bit en Modo 1 #define RB8mAS (1 << RB8bIT) // Máscara correpondiente sbit TI = 0x99; // Indicador de Dato Transmitido #define TIbIT 1 // Bit Indicador de Dato Transmitido #define TImAS (1 << TIbIT) // Máscara correpondiente // Bit en "1" para Indicar Dato Transmitido sbit RI = 0x98; // Indicador de Dato Recibido #define RIbIT 0 // Bit Indicador de Dato Recibido #define RImAS (1 << RIbIT) // Máscara correpondiente // Bit en "1" para Indicar Dato Recibido #define SMO0mAS 0 // Registro de Desplazamiento (velocidad fija) #define SMO1mAS SM1mAS // UART de 8 bits (velocidad variable) #define SMO2mAS SM0mAS // UART de 9 bits (velocidad fija) #define SMO3mAS (SM0mAS SM1mAS) // UART de 9 bits (velocidad variable) /* Serial Data Buffer Register */ sfr SBUF = 0x99; // Buffer de Datos del Puerto Serie

47 #define MOTORX 0 #define MOTORY 1 #define MOTORZ 2 #define MOTORT 3 #define DISPLAY1 0 #define DISPLAY2 1 #define DISPLAY3 2 #define DISPLAY4 3 #define CEROaSCII 48 /* Motores */ #define LSBmASC #define MSBmASC 0x0F 0xF0 #define MAXpASOSx #define MAXpASOSy 40 #define MAXpASOSz 0 #define INSTeRROR 0xFF // Error en la Instruccion #define INSTeXITO 0x00 // Exito en la Instruccion #define INSTsYSTEMeRROR 0xEE // Error de sistema - Peticion de Reinicio /* Interrupcion Inicio Motor X */ /* Interrupciones Externas */ #define INTiNICxrEG P1 // Port: P0 / P1 / P3 /... #define INTiNICxbIT 0 // Bit: 0 / 1 / 2 /... #define INTiNICxdIR ENTRADA // Dirección: ENTRADA / SALIDA #define INTiNICxaCT BAJO // Activida: ALTO / BAJO #define INTiNICxmAS (1 << INTiNICxbIT) // Byte de Máscara // Port ^ Bit sbit INTiNICx = INTiNICxrEG ^ INTiNICxbIT; /* Interrupcion Fin Motor X */ #define INTfINxrEG P1 // Port: P0 / P1 / P3 /... #define INTfINxbIT 1 // Bit: 0 / 1 / 2 /... #define INTfINxdIR ENTRADA // Dirección: ENTRADA / SALIDA #define INTfINxaCT BAJO // Activida: ALTO / BAJO #define INTfINxmAS (1 << INTfINxbIT) // Byte de Máscara // Port ^ Bit sbit INTfINx = INTfINxrEG ^ INTfINxbIT; /* Interrupcion Inicio Motor Y

48 */ #define INTiNICyrEG P1 // Port: P0 / P1 / P3 /... #define INTiNICybIT 2 // Bit: 0 / 1 / 2 /... #define INTiNICydIR ENTRADA // Dirección: ENTRADA / SALIDA #define INTiNICyaCT BAJO // Activida: ALTO / BAJO #define INTiNICymAS (1 << INTiNICybIT) // Byte de Máscara // Port ^ Bit sbit INTiNICy = INTiNICyrEG ^ INTiNICybIT; /* Interrupcion Fin Motor Y */ #define INTfINyrEG P1 // Port: P0 / P1 / P3 /... #define INTfINybIT 3 // Bit: 0 / 1 / 2 /... #define INTfINydIR ENTRADA // Dirección: ENTRADA / SALIDA #define INTfINyaCT BAJO // Activida: ALTO / BAJO #define INTfINymAS (1 << INTfINybIT) // Byte de Máscara // Port ^ Bit sbit INTfINy = INTfINyrEG ^ INTfINybIT; /* Salida para Motores */ #define MOTORESpORT P0 // Port: P0 / P1 / P3 /... #define MOTORESdIR SALIDA // Dirección: ENTRADA / SALIDA #define MOTORESaCT ALTO // Activida: ALTO / BAJO #define MOTORESiNIC 0xFF #define PASOiNIC 0x00 #define LONGpASOSmOTORx 4 #define LONGpASOSmOTORy 8 #define LONGpASOSmOTORz 8 // Motor X a 1 Paso // Motor Y a 1/2 Paso // Motor Y a 1/2 Paso

49 3.2. Software PC Se desarrollo el programa bajo el Turbo C++ versión Sistema Operativo El sistema operativo que se utilizo para correr la Aplicación de prueba es el W98SE Programa Principal Este programa es una muestra de los desplazamientos que realiza la maquina para el agujereado de seis piezas, retornando luego al inicio para el comienzo de un nuevo proceso. # include <stdio.h> # include <conio.h> # include <dos.h> # include <stdlib.h> # define COM1 0x3F8 # define A 10 # define B 2000 # define C void InicializarSerie (void); void main (void) int i=0,r=1; clrscr(); for(i=0 ; i<6 ; i++) clrscr(); printf("\n\n\t\t\t\t Plantilla: %d",i+1); outportb(com1,0x20); delay(a); outportb(com1,0x31); delay(a); outportb(com1,0xa2); delay(a); // Comienzo de la primera instrucción // Mando tres Bytes es decir una instrucción outportb(com1,0x21); // Comienzo de otra instrucción delay(a); outportb(com1,0x00); delay(a); outportb(com1,0x07); // fin de la segunda instrucción printf("\n\n\t\t\t Proceso de Agujereado Ranura %d",r); delay(c); outportb(com1,0x21); delay(a); outportb(com1,0x00); delay(a); outportb(com1,0x1d);

50 delay(a); outportb(com1,0x20); delay(a); outportb(com1,0x01); delay(a); outportb(com1,0x0a); printf("\n\n\t\t\t Proceso de Agujereado Ranura %d",r+1); delay(c); outportb(com1,0x01); //Mover a Inicio Motor Y delay(a); outportb(com1,0x00); delay(a); outportb(com1,0x00); delay(b); getche(); outportb(com1,0x00); //Mover a Inicio Motor X delay(a); outportb(com1,0x00); delay(a); outportb(com1,0x00); clrscr(); gotoxy(32,12); printf("proceso Terminado"); void InicializarSerie (void) outportb(com1+1,0x00); outportb(com1+3,0x80); outportb(com1+1,0x00); outportb(com1,0x60); outportb(com1+3,0x0b); //8 bits de datos //Paridad //1 bits de stop inportb(com1); inportb(com1+5); //Sin Interrupciones //Seteo el DLAB=1 //Seleccion de 1200 Baudios //Cargo la parte alta del divisor y luego la baja //Lectura falsa del RBR //Lectura falsa del LSR 4.Modificaciones

51 Unos de los problemas que necesita un cambio, surgió de la pregunta, que pasa si el Sensor de Inicio esta dañado? Antes de responder a esta pregunta haremos una breve descripción de cómo actúa el sistema con el software que ya tiene cargado. Si simulamos mientras el sistema se esta posicionando en busca del sensor de inicio la introducción de un objeto que cierre el sensor, el sistema se detendrá (Suponiendo que no ha llegado al inicio aún), sin arrojar error alguno, pero en vista a lo ocurrido estamos en presencia de un error, ya que comenzaríamos el proceso si haber posicionado correctamente el carro porta piezas al cero absoluto. Cabe aclarar que si bien esto es un error y el proceso no es un proceso automático, siempre habrá un operario antes de dar el Start, que sabrá o no si comenzará la rutina de agujereado o si requiere alguna atención el sistema. Otras de las seguridades que posee el sistema es que el software esta chequeando constantemente donde se encuentra posicionado, es decir que si por algún error mientras esta corriendo la aplicación se interrumpe algún sensor este detendrá el proceso, en este caso lo que hace el sistema es resetearse, es decir dejar inactivo el sistema sin ninguna alimentación en sus motores, pero será una decisión a tomar mas adelante si conviene resetear o dejar intacto el sistema en ese instante determinado entrando en un bucle infinito (While 1). Solución de Hardware: Se nos ocurre esta solución para el problema planteado anteriormente. Cada vez que el sistema deba posicionarse al inicio, este podría hacerlo siempre retrocediendo la cantidad máxima de pasos que posee su recorrido, ante esta solución surge otro interrogante, Que pasa si estaba posicionado en el centro y se lo hizo retroceder la máxima cantidad de pasos mientras el sensor esta inactivo por alguna razón? La propuesta se divide en una mecánica y otra electrónica: Propuesta Mecánica: Se le agregaría un sistema de embrague que actúe por torque cuando el carro intente seguir de largo y lo paralice enviando una señal de alarma de algún tipo. Propuesta Electrónica: Bajo la misma consigna dada (Retroceder la máxima cantidad de pasos) se nos ocurre que se podría detectar el consumo (Algún pico de corriente) cuando el sistema quiera seguir retrocediendo y ya se encuentre en el inicio y tomar una decisión ; por lo tanto sería una solución (No sabemos si es factible) pero en el caso de serlo sería mas económica al tener que reproducir la electrónica por cada motor que posee el sistema

52 5.Desarrollo e Inconvenientes Temporales del Proyecto El desarrollo del proyecto fue de aproximadamente seis meses y medio, lo que tomando como promedio 3 horas de trabajo diarias da 585 horas, el cual tuvo un costo aproximado de $ 570 (Pesos). Algunos de los inconvenientes que fueron surgiendo a lo largo del desarrollo dividiendo la etapa mecánica de la electrónica fueron: Etapa Mecánica: Se utilizaron caños estructurales de 2x1 mm y 2x2mm, planchuela en L trafilado para las guías del carro, planchuelas planas, tornillos varios, etc. La maqueta sufrió varias modificaciones a lo largo del desarrollo en lo que se refiere a la disposición de los elementos mencionados que en principio se disponían en una estructura mas rígida, la cual fue modificada para que pueda obtenerse un despiece total de ella y así realizar el mantenimiento necesario sobre un problema en particular (cabe destacar esta notable característica que posee el sistema) Se utilizo una varilla roscada de uso comercial de 1,2 mm de paso en principio la cual dificultaba el traslado del carro de avance, la misma fue reemplazada por otra varilla de 1,7 mm de paso la cual posee mayor diámetro y por lo tanto mayor rigidez, mejorando notablemente el desplazamiento buscado. Dificultad para encontrar motores paso a paso que pudieran cumplir con los requisitos que se habían impuesto en el proyecto. Problemas para alinear el carro de desplazamiento con sus guías y tornillo, para que este pudiera desplazarse con un mínimo de rozamiento. En principio el sistema basculante fue montado sobre bujes el cual posteriormente fue reemplazado por rodamientos, mejorando su capacidad de movimiento con menor fricción. Debido al torque necesario para el sistema basculante, hubo que recurrir a un sistema de engranajes para una reducción, en la que hubo inconvenientes a la hora de encontrar soluciones comerciales, ya que no había disponible engranajes con las características buscadas. Finalmente se utilizaron engranajes de despiece que se acercaron al ideal buscado. Obteniéndose una relación de 4:1. Nota: Cabe mencionar que se le solicito motores paso a paso, a la persona encargada del Laboratorio de Electrónica Sr. Germán, el cual no tubo inconvenientes a la hora de conseguirnos y prestarnos unos motores, si bien los mismos fueron probados, pero no fueron utilizados por no cumplir con las especificaciones buscadas

53 Etapa Electrónica: Si bien los problemas surgidos en el armado y diseño de la electrónica son muy numerosos daremos un breve comentario. Para el desarrollo de las plaquetas se utilizo el software de edición Eagle, en el cual hubo que aprender a utilizarlo ya que ninguno contaba con experiencia en este software de edición. En primera instancia se utilizo el protoboard para el chequeo previo de las distintas etapas, no así en la etapa de potencia ya que esta posee un consumo importante para montaje en protoboard (por razones de seguridad). Para el diseño de la etapa de potencia fue consultado el Ing. Monje (Profesor de Electrónica aplicada III y Electrónica de Potencia)

54 6.Especificaciones Para dar una idea del error que se comete en este sistema mecánico desarrollado, se tomo solo el desplazamiento de avance (Tornillo), donde se realizaron varias pruebas y en diferentes tiempos. Con las pruebas realizadas se obtuvieron los siguientes registros para distintos recorridos obteniéndose: Desplazamiento Enviado Instrucción enviada de PC uc Desplazamiento Real 10 mm 0x011A Primer Registro 10 mm 282 Pasos Segundo Registro 10 mm Tercer Registro 10 mm 100 mm 0x0B08 Primer Registro 106 mm 2824 Pasos Segundo Registro 106 mm Tercer Registro 106 mm 170 mm 0x12C0 Primer Registro 181 mm 4800 Pasos Segundo Registro 181 mm Tercer Registro 181 mm 270 mm 0x1DC8 Primer Registro 286 mm 7624 Pasos Segundo Registro 288 mm Tercer Registro 287 mm Caracterizando el error relativo referido al patrón: e i Para X = 10 mm obtenemos un error relativo ( 10 ± 0 ) mm Para X = 100 mm obtenemos un error relativo ( 100 ± 6,00 ) mm Para X = 170 mm obtenemos un error relativo ( 170 ± 6,47 ) mm Para X = 270 mm obtenemos un error relativo ( 270 ± 6,29 ) mm = X X i p X p = El Software del microcontrolador será el encargado de corregir estos errores

55 7.Imágenes del Proyecto

56 8.Referencias 8.1. Hojas de datos TIP 120 NPN Darlington Transistor - Medium Power Linear Switching Applications - AT89S8252 Microcontrolador Atmel - PM55L-048 Motores CD4011BC Quad 2-Input NAND Buffered B Series Gate CD4050BC Hex Non-Inverting Buffer - SN74HCT541 Octal Buffers and line drivers with 3 State Outputs MAX232 +5V-Powered, Multichannel RS-232 Drivers/Receivers TCST2103 Tansmissive Optical Sensor with Phototransistor Output Referencias de Material Adicional Intel(R) MCS51 Microcontrollers COM Derivative Microcontrollers microcontroller FAQ microcontroller-faq.htm APENDICE 1 extraído de

57 9. Bibliografía C /C++ Manual de Referencia - HERBERT SCHILDT Editorial McGraw-Hill Introducción a los Microcontroladores Ing. ADOLFO GONZALEZ VAZQUEZ - Editorial McGraw-Hill The 8051 Microcontroller MacKenzie Prentice Hall 1992 Programming and Interfacing the 8051 Microcontroller Yeralan & Ahluwalia Addison Wesley 8051/251 Microcontroller Development Tools

58 Apéndice 1 Motores paso a paso INTRODUCCIÓN En numerosas ocasiones es necesario convertir la energía eléctrica en energía mecánica, esto se puede lograr, por ejemplo, usando los motores de corriente continua. Pero cuando lo deseado es posicionamiento con un elevado grado de exactitud y/o una muy buena regulación de la velocidad, se puede contar con una gran solución: utilizar un motor paso a paso. El desarrollo de la presente investigación tiene por objeto dar a conocer los principios básicos de funcionamiento de este tipo de motores, sus características constructivas y las formas básicas de hacer funcionar los motores por medio de dispositivos microcontroladores. Sus principales aplicaciones se pueden encontrar en robótica, tecnología aeroespacial, control de discos duros, flexibles, unidades de CD-ROM o de DVD e impresoras, en sistemas informáticos, manipulación y posicionamiento de herramientas y piezas en general. Los motores paso a paso son ideales para la construcción de mecanismos en donde se requieren movimientos muy precisos. La característica principal de estos motores es el hecho de poder moverlos un paso a la vez por cada pulso que se le aplique. Este paso puede variar desde 90 hasta pequeños movimientos de tan solo 1.8, es decir, que se necesitarán 4 pasos en el primer caso (90 ) y 200 para el segundo caso (1.8 ), para completar un giro completo de 360. Estos motores poseen la habilidad de poder quedar enclavados en una posición o bien totalmente libres. Si una o más de sus bobinas están energizadas, el motor estará enclavado en la posición correspondiente y por el contrario quedará completamente libre si no circula corriente por ninguna de sus bobinas. El motor paso a paso está constituido esencialmente por dos partes: a) Una fija llamada "estator", construida a base de cavidades en las que van depositadas las bobinas que excitadas convenientemente formarán los polos norte-sur de forma que se cree un campo magnético giratorio. b) Una móvil, llamada "rotor" construida mediante un imán permanente, con el mismo número de pares de polos, que el contenido en una sección de la bobina del estator; este conjunto va montado sobre un eje soportado por dos cojinetes que le permiten girar libremente. Imagen del Rotor

59 Imagen de un estator de 4 bobinas Si por el medio que sea, conseguimos excitar el estator creando los polos N-S, y hacemos variar dicha excitación de modo que el campo magnético formado efectúe un movimiento giratorio, la respuesta del rotor será seguir el movimiento de dicho campo, produciéndose de este modo el giro del motor. Puede decirse por tanto que un motor paso a paso es un elemento que transforma impulsos eléctricos en movimientos de giro controlados, ya que podremos hacer girar al motor en el sentido que deseemos y el número de vueltas y grados que necesitemos. PRINCIPIO DE FUNCIONAMIENTO Los motores eléctricos, en general, basan su funcionamiento en las fuerzas ejercidas por un campo electromagnético y creadas al hacer circular una corriente eléctrica a través de una o varias bobinas. Si dicha bobina, generalmente circular y denominada estator, se mantiene en una posición mecánica fija y en su interior, bajo la influencia del campo electromagnético, se coloca otra bobina, llamada rotor, recorrida por una corriente y capaz de girar sobre su eje, esta última tenderá a buscas la posición de equilibrio magnético, es decir, orientará sus polos NORTE-SUR hacia los polos SUR-NORTE del estator, respectivamente. Cuando el rotor alcanza esta posición de equilibrio, el estator cambia la orientación de sus polos, aquel tratará de buscar la nueva posición de equilibrio; manteniendo dicha situación de manera continuada, se conseguirá un movimiento giratorio y continuo del rotor y a la vez la transformación de una energía eléctrica en otra mecánica en forma de movimiento circular. Aún basado en el mismo fenómeno, el principio de funcionamiento de los motores de corriente continua, los motores paso a paso son más sencillos si cabe, que cualquier otro tipo de motor eléctrico. La figura 1 intenta ilustrar el modo de funcionamiento de un motor paso a paso, suponemos que las bobinas L1 como L2 poseen un núcleo de hierro dulce capaz de imantarse cuando dichas bobinas sean recorridas por una corriente eléctrica. Por otra parte el imán M puede girar libremente sobre el eje de sujeción central

60 Paso 1 (a) Paso 2 (b) Paso 3 (c) Paso 4 (d) Figura 1. Principio de funcionamiento de un motor paso a paso Inicialmente, sin aplicar ninguna corriente a las bobinas (que también reciben el nombre de fases) y con M en una posición cualquiera, el imán permanecerá en reposo si no se somete a una fuerza externa. Si se hace circula corriente por ambas fases como se muestra en la Figura 1(a), se crearán dos polos magnéticos NORTE en la parte interna, bajo cuya influencia M se desplazará hasta la posición indicada en dicha figura. Si invertimos la polaridad de la corriente que circula por L1 se obtendrá la situación magnética indicada en la Figura 1(b) y M se verá desplazado hasta la nueva posición de equilibrio, es decir, ha girado 90 grados en sentido contrario a las agujas del reloj. Invirtiendo ahora la polaridad de la corriente en L2, se llega a la situación de la Figura 1 (c) habiendo girado M otros 90 grados. Si, por fin, invertimos de nuevo el sentido de la corriente en L1, M girará otros 90 grados y se habrá obtenido una revolución completa de dicho imán en cuatro pasos de 90 grados. Por tanto, si se mantiene la secuencia de excitación expuesta para L1 y L2 y dichas corrientes son aplicadas en forma de pulsos, el rotor avanzará pasos de 90 grados por cada pulso aplicado. Por lo tanto se puede decir que un motor paso a paso es un dispositivo electromecánico que convierte impulsos eléctricos en un movimiento rotacional constante y finito dependiendo de las características propias del motor. El modelo de motor paso a paso que hemos analizado, recibe el nombre de bipolar ya que, para obtener la secuencia completa, se requiere disponer de corrientes de dos polaridades, presentando tal circunstancia un inconveniente importante a la hora de diseñar el circuito que controle el motor. Una forma de paliar este inconveniente es la representada en la Figura 2, obteniéndose un motor unipolar de cuatro fases, puesto que la corriente circula por las bobinas en un único sentido

61 Si inicialmente se aplica la corriente a L1 y L2 cerrando los interruptores S1 y S2, se generarán dos polos NORTE que atraerán al polo SUR de M hasta encontrar la posición de equilibrio entre ambos como puede verse en la Figura 2(a). Si se abre posteriormente S1 y se cierra S3, por la nueva distribución de polos magnéticos, M evoluciona hasta la situación representada en la Figura 2(b). Figura 2.- Principio básico de un motor unipolar de cuatro fases Siguiendo la secuencia representada en la Figuras 2 (c) y (d), de la misma forma se obtienen avances del rotor de 90 grados habiendo conseguido, como en el motor bipolar de dos fases, hacer que el rotor avance pasos de 90 grados por la acción de impulsos eléctricos de excitación de cada una de las bobinas. En uno y otro caso, el movimiento obtenido ha sido en sentido contrario al de las agujas del reloj; ahora bien, si las secuencias de excitación se generan en orden inverso, el rotor girará en sentido contrario, por lo que fácilmente podemos deducir que el sentido de giro en los motores paso a paso es reversible en función de la secuencia de excitación y, por tanto, se puede hacer avanzar o retroceder al motor un número determinado de pasos según las necesidades

62 El modelo de motor paso a paso estudiado, salvo su valor didáctico, no ofrece mayor atractivo desde el punto de vista práctico, precisamente por la amplitud de sus avances angulares. Una forma de conseguir motores Paso a Paso de paso mas reducido, es la de aumentar el número de bobinas del estator, pero ello llevaría a un aumento del coste y del volumen y a pérdidas muy considerable en el rendimiento del motor, por lo que esta situación no es viable. Hasta ahora y para conseguir la solución más idónea, se recurre a la mecanización de los núcleos de las bobinas y el rotor en forma de hendiduras o dientes, creándose así micropolos magnéticos, tantos como dientes y estableciendo las situaciones de equilibrio magnéticos con avances angulares mucho menores, siendo posible conseguir motores de hasta de 500 pasos. Bobinado de un motor paso a paso de una disquetera, en el que pueden apreciarse bobinados, el imán permanente se ha desmontado para poder ver el interior del motor que está montado sobre la propia placa de circuito impreso TIPOS DE MOTORES PASO A PASO Hay dos tipos básicos de motores Paso a Paso, los BIPOLARES que se componen de dos bobinas y los UNIPOLARES que tienen cuatro bobinas. Externamente se diferencian entre sí por el número de cables. Los bipolares solo tienen cuatro conexiones dos para cada bobina y los unipolares que normalmente presentan seis cables, dos para cada bobina y otro para alimentación de cada par de éstas, aunque en algunos casos podemos encontrar motores unipolares con cinco cables, básicamente es lo mismo, solo que el cable de alimentación es común para los dos pares de bobinas

63 Esquema Motor UNIPOLAR Esquema Motor BIPOLAR Motores Unipolares: En este tipo de motores, todas las bobinas del estator están conectadas en serie formando cuatro grupos. Esta a su vez, se conectan dos a dos, también en serie, y se montan sobre dos estatores diferentes, tal y como se aprecia en la Figura 3. Según puede apreciarse en dicha figura, del motor paso a paso salen dos grupos de tres cables, uno de los cuales es común a dos bobinados. Los seis terminales que parten del motor, deben ser conectados al circuito de control, el cual, se comporta como cuatro conmutadores electrónicos que, al ser activados o desactivados, producen la alimentación de los cuatro grupos de bobinas con que está formado el estator. Si generamos una secuencia adecuada de funcionamiento de estos interruptores, se pueden producir saltos de un paso en el número y sentido que se desee. Figura 3.- Control de motor Unipolar Motores Bipolares: En este tipo de motores las bobinas del estator se conectan en serie formando solamente dos grupos, que se montan sobre dos estatores, tal y como se muestra en la Figura 4. Según se observa en el esquema de este motor salen cuatro hilos que se conectan, al circuito de control, que realiza la función de cuatro interruptores electrónicos dobles, que nos permiten variar la polaridad de la alimentación de las bobinas. Con la activación y desactivación adecuada de dichos interruptores dobles, podemos obtener las secuencias adecuadas para que el motor pueda girar en un sentido o en otro

64 Figura 4.- Control de motor Bipolar La existencia de varios bobinados en el estator de los motores de imán permanente, da lugar a varias formas de agrupar dichos bobinados, para que sean alimentados adecuadamente. Estas formas de conexión permiten clasificar los motores paso a paso en dos grandes grupos: Desde el punto de vista de su construcción existen los siguientes tipos de motores paso a paso: 1.- De reluctancia variable (V.R.): Los motores de este tipo poseen un rotor de hierro dulce que en condiciones de excitación del estator y bajo la acción de su campo magnético, ofrecen menor resistencia a ser atravesado por su flujo en la posición de equilibrio. Su mecanización es similar a los de imán permanente y su principal inconveniente radica en que en condiciones de reposos (sin excitación) el rotor queda en libertad de girar y, por lo tanto, su posicionamiento de régimen de carga dependerá de su inercia y no será posible predecir el punto exacto de reposo. El tipo de motor de reluctancia variable o V.R. (figura 5) consiste en un rotor y un estator cada uno con un número diferente de dientes. Ya que el rotor no dispone de un magneto permanente el mismo gira libremente, o sea que no tiene torque de detención

65 Figura 5.- Vista de sección de un motor por pasos de reluctancia variable 2.- De magneto Permanente: es el modelo en el que rotor es un imán permanente en el que se mecanizan un número de dientes limitado por su estructura física. Ofrece como principal ventaja que su posicionamiento no varía aún sin excitación y en régimen de carga. El motor de magneto permanente (PM) o tipo enlatado (figura 6) es quizá el motor por pasos mas ampliamente usado para aplicaciones no industriales. En su forma mas simple, el motor consiste en un rotor magneto permanentemente magnetizado radial y en un estator similar al motor V.R. Debido a las técnicas de manufactura usadas en la construcción del estator, los mismos se conocen a veces como motores de polo de uñas o claw pole en Inglés. Figura 6.- Vista en sección de un magneto permanente 3.- Híbridos: Son combinación de los dos tipos anteriores; el rotor suele estar constituido por anillos de acero dulce dentado en un número ligeramente distinto al del estator y dichos anillos montados sobre un imán permanente dispuesto

66 axialmente. El tipo Híbrido es probablemente el más usado de todos los motores por pasos. Originalmente desarrollado como un motor PM sincrónico de baja velocidad su construcción es una combinación de los diseños V.R. y P.M. El motor Híbrido consiste en un estator dentado y un rotor de tres partes (apilado simple). El rotor de apilado simple contiene dos piezas de polos separados por un magneto permanente magnetizado, con los dientes opuestos desplazados en una mitad de un salto de diente (figura 7) para permitir una alta resolución de pasos. Figura 7 El incremento de demanda de los sistemas de motor por pasos de reducido ruido acústico, con una mejora en el desempeño al mismo tiempo con reducción de costos fue satisfecho en el pasado con los dos tipos principales de motores por pasos Híbridos. El tipo 2(4) fases que ha sido generalmente implementado en aplicaciones simples y el de 5 fases ha probado ser ideal para las tareas más exigentes. Las ventajas ofrecidas por los motores de 5 fases incluían: Mayor resolución Menor ruido acústico Menor resonancia operacional Menor torque de frenado. A pesar de que las características de los motores de 5 fases ofrecían muchos beneficios, especialmente en micro pasos, el creciente número de conmutaciones de alimentación y el cableado adicional requerido tenían un efecto adverso en el costo del sistema. Con el avance de la electrónica permitiendo circuitos de cada vez mayor grado de integración y mayores características, la fábrica SIG Positec vio una oportunidad y tomó la iniciativa en el terreno desarrollando tecnología de punta en motores por pasos

67 Figura 8.- Secciones ilustrativas de las laminaciones y rotores para motores de 2, 3 y 5 fases El motor Híbrido de 3 fases: A pesar de ser similar en construcción a otros motores por pasos (ver figura 8), la implementación de la tecnología de 3 fases hizo posible que el número de fases del motor sean reducidas dejando al número de pares de polos del rotor y a la electrónica determinar la resolución (pasos por revolución)

68 Figura 9.- Corte de sección de un motor por pasos Híbrido ( 3 fases ) Dado que la tecnología de 3 fases ha sido usada por décadas como un método efectivo de generación de campos rotativos, las ventajas de éste sistema son evidentes en sí. El motor por pasos de 3 fases fue por lo tanto una progresión natural que incorporó todas las mejores características de un sistema de 5 fases a una significativa reducción de costo