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

Universidad Tecnológica Nacional - frsn.utn.edu.ar angular.pdf · la cual utiliza un sistema basado en el microcontrolador ATMEL 89S8252, de la familia de 8051 de INTEL, ... (Contemplado

Embed Size (px)

Citation preview

Técnicas Digitales III - Informe de Proyecto

2005 1

Universidad Tecnológica Nacional

Facultad Regional San Nicolás

Proyecto Técnicas Digitales III

Agujereadora Angular con Avance en dos

Dimensiones Semiautomática Integrantes: Groba, Diego Nicolás. Peruchena, Claudio. Docentes: Ing. Poblete, Felipe Sr. González, Mariano

Técnicas Digitales III - Informe de Proyecto

2005 2

INDICE 1. Descripción General 1.1. Introducción Pág. 3 1.2. Interfaz con el usuario Pág. 4 1.3. Operación Pág. 4 2. Hardware

2.1. Diagrama en Bloques Pág. 5 2.2. Circuitos Esquemáticos Pág. 6 2.3. Características del Microcontrolador Atmel Pág. 10 2.4. Descripción de los circuitos Pág. 9 2.5. Circuitos Impresos Pág. 12 3. SOFTWARE 3.1. Software Microcontrolador Pág. 17 3.1.1 Entorno de desarrollo Pág. 16 3.1.2 Sistema Operativo Pág. 18 3.1.3 Programa Principal - Subrutinas Pág. 18 3.1.3.1 Main.C Pág. 20 3.1.3.2 Motor.C Pág. 25 3.1.3.3 Serie.C Pág. 32 3.1.3.4 Macros51.H Pág. 38 3.1.3.5 Defines51.H Pág. 41

3.2. Software PC Pág. 49 3.3. Sistema Operativo Pág. 49

3.4. Programa Principal Pág. 49

4. Modificaciones Pág. 51 5. Desarrollo e Inconvenientes del Proyecto Pág. 52 6. Especificaciones Pág. 54 7. Imágenes del Proyecto Pág. 55 8. Referencias Pág. 56

8.1 Hojas de Datos Pág. 56 8.2 Referencias de Material Adicional Pág. 56

9. Bibliografía Pág. 57 Apéndice 1 Pág. 58

Técnicas Digitales III - Informe de Proyecto

2005 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.

Técnicas Digitales III - Informe de Proyecto

2005 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.).

1.3. 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.

Técnicas Digitales III - Informe de Proyecto

2005 5

2.Hardware

2.1. Diagrama en Bloques

Técnicas Digitales III - Informe de Proyecto

2005 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

Técnicas Digitales III - Informe de Proyecto

2005 7

Etapa de Sensado

Circuito Esquemático

Técnicas Digitales III - Informe de Proyecto

2005 8

Etapa de Potencia

Circuito Esquemático

.

Técnicas Digitales III - Informe de Proyecto

2005 9

Fuente

Circuito Esquemático

Técnicas Digitales III - Informe de Proyecto

2005 10

2.3. Características del Microcontrolador Atmel AT89S8252 8-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 3

Técnicas Digitales III - Informe de Proyecto

2005 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 ) � P3.3

Técnicas Digitales III - Informe de Proyecto

2005 12

2.5. Circuitos Impresos

Microcontrolador y Comunicación RS-232

Circuito Impreso

Circuito Impreso con componentes

Técnicas Digitales III - Informe de Proyecto

2005 13

Circuito Armado

Etapa de Potencia

Circuito Impreso

Técnicas Digitales III - Informe de Proyecto

2005 14

Circuito Impreso con componentes

Circuito Armado

Técnicas Digitales III - Informe de Proyecto

2005 15

Fuente 12 [V] x 2 [A]

Circuito Impreso

Circuito Impreso con Componentes

Técnicas Digitales III - Informe de Proyecto

2005 16

Circuito Armado

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

Técnicas Digitales III - Informe de Proyecto

2005 17

3.Software

3.1. Software Microcontrolador

3.1.1. 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

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Mover Inicio Motor X

0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Mover Inicio Motor Y

0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 No Asignada

0 0 0 0 1 1 0 0 P P P P P P P P P P P P P P P P Retroceder Motor X, P Pasos

0 0 0 0 1 1 0 1 P P P P P P P P P P P P P P P P Retroceder Motor Y, P Pasos

0 0 0 0 1 1 1 0 P P P P P P P P P P P P P P P P No Asignada

0 0 1 0 0 0 0 0 P P P P P P P P P P P P P P P P Avanzar Motor X, P Pasos

0 0 1 0 0 0 0 1 P P P P P P P P P P P P P P P P Avanzar Motor Y, P Pasos

0 0 1 0 0 0 1 0 P P P P P P P P P P P P P P P P No Asignada

1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 Mover a Fin Motor X

1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 Mover a Fin Motor Y

1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 No Asignada

1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 V V Modo Velocidad Motor X

1 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 V V Modo Velocidad Motor Y

1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 V V No Asignada

0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Prender Bomba

0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Apagar Bomba

1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Petición Posición Motor X

1 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Petición Posición Motor Y

1 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 No Asignada

Técnicas Digitales III - Informe de Proyecto

2005 18

Set de Instrucciones – uC ���� PC

1º Byte Tx 2º Byte Tx 3º Byte Tx Observaciones

0 0 0 0 1 1 0 0 P P P P P P P P P P P P P P P P Posición Motor X, P Pasos

0 0 0 0 1 1 0 1 P P P P P P P P P P P P P P P P Posición Motor Y, P Pasos

0 0 0 0 1 1 1 0 P P P P P P P P P P P P P P P P No Asignada

1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 V V Modo Velocidad Motor X

1 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 V V Modo Velocidad Motor Y

1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 V V No Asignada

1 1 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Petición de Reset

1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Error

3.1.2. Sistema Operativo El sistema operativo que se utilizo para el desarrollo es el W98SE.

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

Técnicas Digitales III - Informe de Proyecto

2005 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.

Técnicas Digitales III - Informe de Proyecto

2005 20

3.1.3.1 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 /* ---------------------------------------

Técnicas Digitales III - Informe de Proyecto

2005 21

- Cristal y Reloj de la CPU - ------------------------------------- */ #define DIVcLOCK 12 // Divisor interno de Reloj #define FRECxTAL 11059200 // 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 4

Técnicas Digitales III - Informe de Proyecto

2005 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; // Contador para llevar la cuenta de los pasos X pasoY = 0; // Contador para llevar la cuenta de los pasos Y //pasoZ = 0; // Contador para llevar la cuenta de los pasos Z modVelMotor = 0; // Maxima Velocidad InicializarInterrupciones(); // Inicializar Interrupciones InicializarSerie(); // Inicializar Control de Comunicación Serie InicializarMotores(); // Inicializa los Motores inicializa = PASIVO; // PASIVO=0 while (1) { // Itero por siempre while (CantidadEnColaRecepcion () >= 3) // 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){

Técnicas Digitales III - Informe de Proyecto

2005 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; // Inicializo Serial Control Register PCON = PCONiNICIAL; // Inicializo Control de Consumo IP = IPiNICIAL; // Inicializo Interrupt Priority Register IE = ( IEiNICIALsERIE | IEiNICIALiEXT); // Inicializo Interrupt Enable Register }

Técnicas Digitales III - Informe de Proyecto

2005 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 }

Técnicas Digitales III - Informe de Proyecto

2005 25

3.1.3.2 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); // Interrupcion Sensor Inicio X - Fin X void AnalizaIntY (void); // Interrupcion Sensor Inicio Y - Fin Y void SystemError (void); // 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] = { Pasos del MotorX 0x0C, // 00001100b D C B A A B C D 0x09, // 00001001b 0x03, // 00000011b 0x06}; // 00000110b unsigned char code TablaPasosMotorY [LONGpASOSmOTORy] = {

Técnicas Digitales III - Informe de Proyecto

2005 26

0x60, // 01110000b Pasos del MotorY 0xE0, // 00110000b D C B A A B C D 0xC0, // 10110000b 0xD0, // 10010000b 0x90, // 11010000b 0xB0, // 11000000b 0x30, // 11100000b 0x70}; // 01100000b void InicializarMotores (void) { DIRPIN (INTiNICx, INTiNICxdIR); DIRPIN (INTfINx, INTfINxdIR); DIRPIN (INTiNICy, INTiNICydIR); DIRPIN (INTfINy, INTfINydIR); flagPasoX = PASOiNIC; // Cargo con 0 flagPasoX flagPasoY = PASOiNIC; // Cargo con 0 flagPasoY DIRPORT (MOTORESpORT, SALIDA); // Inicializo las Entradas y las Salidas ACC = MOTORESiNIC; MOVAP (MOTORESpORT, MOTORESaCT); 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]); } while(inicMotorY == PASIVO); // Muevo el Motor Y hasta que encuentre el sensor de inicio return; } bit VerifPaso (void) { if((flagPasoX > LONGpASOSmOTORx)||(flagPasoX < PASOiNIC)) { return ERROR; } if((flagPasoY > LONGpASOSmOTORy)||(flagPasoY < PASOiNIC)) { return ERROR; } return EXITO; }

Técnicas Digitales III - Informe de Proyecto

2005 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; }

Técnicas Digitales III - Informe de Proyecto

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

Técnicas Digitales III - Informe de Proyecto

2005 29

unsigned char AvanzarMotor (unsigned char datoRx1,unsigned char datoRx2,unsigned char datoRx3) { unsigned int cont; pasosAvan = ((datoRx2) * (0x100)); // Paso Rx2 a la parte alta para poder formar los dos bytes pasosAvan = (pasosAvan + datoRx3); // 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) {

Técnicas Digitales III - Informe de Proyecto

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

Técnicas Digitales III - Informe de Proyecto

2005 31

} if(pasoY > PASOiNIC) inicMotorY = PASIVO; } return(INSTeXITO); } // Analisis de las Interrupciones Externas void AnalizaIntX (void) { IFACT (INTiNICx, INTiNICxaCT) //Si sensor de Inicio == ACT if(pasoX > PASOiNIC) SystemError(); else inicMotorX = ACTIVO; IFACT (INTfINx, INTfINxaCT) //Si sensor de Fin == ACT if(pasoX < MAXpASOSx) { if(inicializa == PASIVO) SystemError(); } else finMotorX = ACTIVO; return; } void AnalizaIntY (void) { IFACT (INTiNICy, INTiNICyaCT) //Si sensor de Inicio == ACT if(pasoY > PASOiNIC) SystemError(); else inicMotorY = ACTIVO; IFACT (INTfINy, INTfINyaCT) //Si sensor de Fin == ACT if(pasoY < MAXpASOSy) { if(inicializa == PASIVO) SystemError(); } else finMotorY = ACTIVO; return; } void SystemError (void) { DIRPORT (MOTORESpORT, SALIDA); // Apago el Puerto de los Motores ACC = MOTORESiNIC; MOVAP (MOTORESpORT, MOTORESaCT); AgregarDatoColaTransmision (INSTsYSTEMeRROR); //Envio Instruccion de Error de Sistema while(1){} //Loop Infinito. return; }

Técnicas Digitales III - Informe de Proyecto

2005 32

3.1.3.3 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 /* --------------------

Técnicas Digitales III - Informe de Proyecto

2005 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 (); // Inicializo la Cola de Recepción InicializarColaTransmision (); // Inicializo la Cola de Transmisión TxEnCurso = NO; // 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(); // Transmito Dato Almacenado en la Cola de //Transmisión TxEnCurso = SI; // Señalizo Transmisión En Curso SI } else TxEnCurso = NO; // Señalizo Transmisión En Curso NO } return; } /* ----------------------------------------------------------------------------------------------------------------------

Técnicas Digitales III - Informe de Proyecto

2005 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 } /* ---------------------------------------------------------------------------------------------------------------------------

Técnicas Digitales III - Informe de Proyecto

2005 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) // Verifico si la Cola está Vacía return (COLAvACIA); // Retorno Cola Vacía dato = *salidaColaRecepcion; // Recupero el Dato de la Cola cantidadColaRecepcion --; // Decremento Contador de Datos Almacenados en la Cola 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; // Inicializo Contador de Datos //Almacenados entradaColaTransmision = colaTransmision; // Inicializo el Puntero para la Entrada de //Datos salidaColaTransmision = colaTransmision; // Inicializo el Puntero para la Salida de //Datos return; } /* -------------------------------------------------------------------------------------------------------------------- - 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 } /* ------------------------------------------------------------------------------------------------------------------------------

Técnicas Digitales III - Informe de Proyecto

2005 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) // Verifico si NO Hay Transmisión en Curso TI = 1; // En tal caso Genero la Interrupción de // Comunicación Serie por Transmisión EA = 1; // Habilito las Interrupciones // Atomizo esta parte del programa => FIN return (EXITO); // 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) // Verifico si la Cola está Vacía return (COLAvACIA); // 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

Técnicas Digitales III - Informe de Proyecto

2005 37

return (dato); // Retorno el Dato }

Técnicas Digitales III - Informe de Proyecto

2005 38

3.1.3.4 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 // Activo Bajo #define ALTO 1 // 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

Técnicas Digitales III - Informe de Proyecto

2005 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

Técnicas Digitales III - Informe de Proyecto

2005 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

Técnicas Digitales III - Informe de Proyecto

2005 41

3.1.3.5 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

Técnicas Digitales III - Informe de Proyecto

2005 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 // Bit Power Down #define PDmAS (1 << PDbIT) // Máscara correpondiente #define IDLbIT 0 // Bit Idle Mode #define IDLmAS (1 << IDLbIT) // Máscara correpondiente

Técnicas Digitales III - Informe de Proyecto

2005 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"

Técnicas Digitales III - Informe de Proyecto

2005 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

Técnicas Digitales III - Informe de Proyecto

2005 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 // Bit de Habilitación General de Interrupciones #define EAmAS (1 << EAbIT) // 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 // Bit de Prioridad del Puerto Serie #define PSmAS (1 << PSbIT) // 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 1

Técnicas Digitales III - Informe de Proyecto

2005 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

Técnicas Digitales III - Informe de Proyecto

2005 47

/* -------------------------------------- - Motores -

------------------------------------- */ #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 #define LSBmASC 0x0F #define MSBmASC 0xF0 #define MAXpASOSx 15000 #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

/* -------------------------------------- - Interrupciones Externas -

-------------------------------------- */ /*---------------------------------------- Interrupcion Inicio Motor X ----------------------------------------*/ #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

Técnicas Digitales III - Informe de Proyecto

2005 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 // Motor X a 1 Paso #define LONGpASOSmOTORy 8 // Motor Y a 1/2 Paso #define LONGpASOSmOTORz 8 // Motor Y a 1/2 Paso

Técnicas Digitales III - Informe de Proyecto

2005 49

3.2. Software PC

Se desarrollo el programa bajo el Turbo C++ versión 3.0.

3.3. Sistema Operativo

El sistema operativo que se utilizo para correr la Aplicación de prueba es el W98SE.

3.4. 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 15000 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); // Comienzo de la primera instrucción delay(A); outportb(COM1,0x31); delay(A); outportb(COM1,0xA2); // Mando tres Bytes es decir una instrucción delay(A); 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);

Técnicas Digitales III - Informe de Proyecto

2005 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); } 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"); getche(); } void InicializarSerie (void) { outportb(COM1+1,0x00); //Sin Interrupciones outportb(COM1+3,0x80); //Seteo el DLAB=1 outportb(COM1+1,0x00); //Seleccion de 1200 Baudios outportb(COM1 ,0x60); //Cargo la parte alta del divisor y luego la baja outportb(COM1+3,0x0B); //8 bits de datos //Paridad //1 bits de stop inportb(COM1); //Lectura falsa del RBR inportb(COM1+5); //Lectura falsa del LSR }

4.Modificaciones

Técnicas Digitales III - Informe de Proyecto

2005 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.

Técnicas Digitales III - Informe de Proyecto

2005 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.

Técnicas Digitales III - Informe de Proyecto

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

Técnicas Digitales III - Informe de Proyecto

2005 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: 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 El Software del microcontrolador será el encargado de corregir estos errores.

=

=

pX

pX

iX

ie

Técnicas Digitales III - Informe de Proyecto

2005 55

7.Imágenes del Proyecto

Técnicas Digitales III - Informe de Proyecto

2005 56

8.Referencias

8.1. Hojas de datos

� TIP 120 NPN Darlington Transistor - Medium Power Linear Switching Applications - www.fairchildsemi.com

� AT89S8252 – Microcontrolador Atmel - www.atmel.com

� PM55L-048 – Motores

http://www.minebea.co.jp/english/product/rotary/pm_stepping_i.html

� CD4011BC Quad 2-Input NAND Buffered B Series Gate www.fairchildsemi.com

� CD4050BC Hex Non-Inverting Buffer - www.fairchildsemi.com

� SN74HCT541 Octal Buffers and line drivers with 3 State Outputs

www.ti.com

� MAX232 +5V-Powered, Multichannel RS-232 Drivers/Receivers www.maxim.com

� TCST2103 Tansmissive Optical Sensor with Phototransistor Output

www.vishay.com

8.2. Referencias de Material Adicional

� Intel(R) MCS51 Microcontrollers http://developer.intel.com/design/mcs51/

� 8052.COM - 8051 Derivative Microcontrollers

http://www.8052.com/chips.phtml

� 8051 microcontroller FAQ http://microcontroller.com/embedded/references/faqs/8051- microcontroller-faq.htm

� APENDICE 1 extraído de www.monografias.com.ar

Técnicas Digitales III - Informe de Proyecto

2005 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

Técnicas Digitales III - Informe de Proyecto

2005 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

Técnicas Digitales III - Informe de Proyecto

2005 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.

Técnicas Digitales III - Informe de Proyecto

2005 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.

Técnicas Digitales III - Informe de Proyecto

2005 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.

Técnicas Digitales III - Informe de Proyecto

2005 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.

Técnicas Digitales III - Informe de Proyecto

2005 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.

Técnicas Digitales III - Informe de Proyecto

2005 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.

Técnicas Digitales III - Informe de Proyecto

2005 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

Técnicas Digitales III - Informe de Proyecto

2005 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.

Técnicas Digitales III - Informe de Proyecto

2005 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).

Técnicas Digitales III - Informe de Proyecto

2005 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.

Técnicas Digitales III - Informe de Proyecto

2005 69

Un problema que se nos puede plantear es como saber cual es cada polo de la bobina, ya que los colores no están estandarizados. Así que tomamos el tester y leemos el valor (resistencia) de todos los polos (supongamos que las bobinas son de 30 Ohm.), el común (alimentación) con cada polo de bobina leerá 30 Ohm y entre polos de la misma bobina 60 Ohm., por eliminación nos será fácil encontrar los polos de las bobinas. Si nos equivocamos no pasa nada, solo que el motor no girará. Cambiando el orden de dos de los polos de una bobina cambiamos el sentido de giro. El orden para el controlador del CeNeCé según esquema Unipolar es:

+v1 A1 B1 A2 B2 +v2

Si el motor solo tiene cinco cables, el común de alimentación se puede conectar a cualquiera de los lados. Hay que tener en cuenta que los motores unipolares de seis u ocho hilos, pueden hacerse funcionar como motores bipolares si no se utilizan las tomas centrales, mientras que los de cinco hilos no podrán usarse jamás como bipolares, porque en el interior están conectados los dos cables centrales.

PARÁMETROS DE LOS MOTORES PASO A PASO

Desde el punto de vista mecánico y eléctrico, es conveniente conocer el significado de algunas de las principales características y parámetros que se definen sobre un motor paso a paso:

� Par dinámico de trabajo ( Working Torque): Depende de sus características dinámicas y es el momento máximo que el motor es capaz de desarrollar sin perder paso, es decir, sin dejar de responder a algún impulso de excitación del estator y dependiendo, evidentemente, de la carga.

Generalmente se ofrecen, por parte del fabrican, curvas denominadas de arranque sin error (pull-in) y que relaciona el par en función el número de pasos.

Hay que tener en cuenta que, cuando la velocidad de giro del motor aumenta, se produce un aumento de la f.c.e.m. en él generada y, por tanto, una disminución de la corriente absorbida por los bobinados del estator, como consecuencia de todo ello, disminuye el par motor.

� Par de mantenimiento (Holding Torque): Es el par requerido para desviar, en régimen de excitación, un paso el rotor cuando la posición anterior es estable ; es mayor que el par dinámico y actúa como freno para mantener el rotor en una posición estable dada

Técnicas Digitales III - Informe de Proyecto

2005 70

� Para de detención ( Detention Torque): Es una par de freno que siendo propio de los motores de imán permanente, es debida a la acción del rotor cuando los devanados del estator están desactivados.

� Angulo de paso ( Step angle ): Se define como el avance angular que se produce en el motor por cada impulso de excitación. Se mide en grados, siendo los pasos estándar más importantes los siguientes:

Grados por impulso de excitación

Nº de pasos por vuelta

0,72º 500

1,8º 200

3,75º 96

7,5º 48

15º 24

� Número de pasos por vuelta: Es la cantidad de pasos que ha de efectuar el rotor para realizar una revolución completa; evidentemente es

Donde NP es el número de pasos y α el ángulo de paso.

� Frecuencia de paso máximo (Maximum pull-in/out): Se define como el máximo número de pasos por segundo que puede recibir el motor funcionando adecuadamente.

� Momento de inercia del rotor: Es su momento de inercia asociado que se expresa en gramos por centímetro cuadrado.

� Par de mantenimiento, de detención y dinámico: Definidos anteriormente y expresados en miliNewton por metro.

CONTROL DE LOS MOTORES PASO A PASO

Para realizar el control de los motores paso a paso, es necesario generar una secuencia determinada de impulsos. Además es necesario que estos impulsos sean capaces de entregar la corriente necesaria para que las bobinas del motor se exciten, por lo general, el diagrama de bloques de un sistema con motores paso a paso es el que se muestra en la Figura 10.

Técnicas Digitales III - Informe de Proyecto

2005 71

Figura 10.- Diagrama de bloques de un sistema con motor paso a paso

SECUENCIA DEL CIRCUITO DE CONTROL

Existen dos formas básicas de hacer funcional los motores paso a paso atendiendo al avance del rotor bajo cada impulso de excitación:

� Paso completo (full step): El rotor avanza un paso completo por cada pulso de excitación y para ello su secuencia ha de ser la correspondiente a la expuesta anteriormente, para un motor como el de la Figura 2, y que es presentada de forma resumida en la Tabla 1 para ambos sentidos de giro, las X indican los interruptores que deben estar cerrados (interruptores en ON), mientras que la ausencia de X indica interruptor abierto (interruptores en OFF).

Paso

S1 S2 S3 S4 Paso S1 S2 S3 S4

1 X X 1 X X

2 X X 2 X X

3 X X 3 X X

4 X X 4 X X

1 X X 1 X X

Sentido horario (a) Sentido antihorario (b)

Tabla 1.- Secuencia de excitación de un motor paso a paso completo

� Medio paso (Half step): Con este modo de funcionamiento el rotor avanza medio paso por cada pulso de excitación, presentando como principal ventaja una mayor resolución de paso, ya que disminuye el avance angular (la mitad que en el modo de paso completo). Para conseguir tal cometido, el modo de excitación consiste en hacerlo alternativamente sobre dos

Técnicas Digitales III - Informe de Proyecto

2005 72

bobinas y sobre una sola de ellas, según se muestra en la Tabla 2 para ambos sentidos de giro.

Excitación de Bobinas Excitación de Bobinas Paso

S1 S2 S3 S4

Paso

S1 S2 S3 S4

1 X X 1 X X

2 X 2 X

3 X X 3 X X

4 X 4 X

5 X X 5 X X

6 X 6 X

7 X X 7 X X

8 X 8 X

1 X X 1 X X

Sentido horario (a) Sentido antihorario (b)

Tabla 2.- Secuencia de excitación de un motor Paso a Paso en medio paso Según la Figura 2 al excitar dos bobinas consecutivas del estator simultáneamente, el rotor se alinea con la bisectriz de ambos campos magnéticos; cuando desaparece la excitación de una de ellas, extinguiéndose el campo magnético inducido por dicha bobina, el rotor queda bajo la acción del único campo existente, dando lugar a un desplazamiento mitad. Sigamos, por ejemplo, la secuencia presentada en la Tabla 2: en el paso 1, y excitadas las bobinas L1 y L2 de la Figura 2 mediante la acción de S1 y S2, el rotor se situaría en la posición indicada en la Figura 2 a; en el paso 2, S1 se abre, con lo que solamente permanece excitada L2 y el rotor girará hasta alinear su polo sur con el norte generado por L2. Supuesto que este motor tenía un paso de 90 grados, en este caso sólo ha avanzado 45 grados. Posteriormente, y en el paso 3, se cierra S3, situación representada en la Figura 2 b, con lo que el rotor ha vuelto a avanzar otros 45 grados. En definitiva, los desplazamientos, siguiendo dicha secuencia, son de medio paso. La forma de conseguir estas secuencias puede ser a través de un circuito lógico secuencial, con circuitos especializados o con un microcontrolador.

Técnicas Digitales III - Informe de Proyecto

2005 73

APLICACIONES DE LOS MOTORES PASO A PASO

• Taxímetros. • Disk-drive. • Impresoras. • Plotters. • Brazo y Robots completos. • Patrón mecánico de velocidad angular. • Registradores XY. • Relojes Eléctricos. • Casetes Digitales. • Control Remoto. • Máquinas de escribir electrónicas. • Manipuladores. • Posicionamiento de válvulas en controles industriales. • Posicionamiento de piezas en general. • Bombas impelentes en aplicaciones de electromedicina.

CARACTERÍSTICAS

• Larga vida. • Velocidad de respuesta elevada (<1ms). • Posicionamiento dinámico preciso. • Reinicialización a una posición preestablecida. • Frecuencia de trabajo variable. • Funcionamiento sincrónico bidireccional. • Sincronismo unidireccional en régimen de sobrevelocidad. • Carencia de escobillas. • Insensibilidad al choque en régimen dinámico, a la regulación de la fuente

de alimentación.