UNIVERSIDAD TÉCNICA DE AMBATO

FACULTAD DE INGENIERÍA EN SISTEMAS, ELECTRÓNICA E

INDUSTRIAL

CARRERA DE INGENIERÍA EN ELECTRÓNICA Y COMUNICACIONES

MICROCONTROLADORES

SEPTIMO ELECTRONICA “A”

PRÁCTICA #05

“CONTROL SERIAL Y CONTROL DE MOTORES”

INTEGRANTES:
Guerrero Daniel
Mesías Andy
Moya Carlos
Ortiz Oscar
Tipanquiza Hennry

Fecha de Envío: Lunes, 23 de abril del 2018

Fecha de Entrega: Lunes, 07 de mayo del 2018

Docente: Ing. Edgar Patricio Córdova Córdova

MARZO 2018 / AGOSTO 2018

AMBATO - ECUADOR
1. TEMA:
“COMUNICACIÓN SERIAL Y CONTROL DE MOTORES”

2. OBJETIVOS:

a. OBJETIVO GENERAL
 Diseñar el sistema micro controlado para el mando de motores mediante comunicación
serial entre el microprocesador y el computador.

b. OBJETIVOS ESPECÍFICOS
 Diseñar un programa en PIC C Compiler para el mando de motores mediante
comunicación serial entre el microprocesador y el computador.

 Simular en Proteus el circuito diseñado para la verificación de su correcto

funcionamiento.

 Implementar el sistema micro controlado para el mando de motores mediante

comunicación serial entre el microprocesador y el computador.

3. FUNDAMENTACIÓN TEÓRICA:

MOTOR DC:

Un motor de corriente continua convierte la energía eléctrica en mecánica. Se compone de dos

partes: el estator y el rotor. El estator es la parte mecánica del motor donde están los polos del
imán. El rotor es la parte móvil del motor con devanado y un núcleo, al que llega la corriente a
través de las escobillas.

Cuando la corriente eléctrica circula por el devanado del rotor, se crea un campo electromagnético.
Este interactúa con el campo magnético del imán del estator. Esto deriva en un rechazo entre los
polos del imán del estator y del rotor creando un par de fuerza donde el rotor gira en un sentido de
forma permanente. Si queremos cambiar el sentido de giro del rotor, tenemos que cambiar el
sentido de la corriente que le proporcionamos al rotor; basta con invertir la polaridad de la pila o
batería. [1]

Figura 1 Motor DC
MOTOR A PASOS:

Un motor paso a paso es un dispositivo electromecánico que convierte una serie de pulsos
eléctricos en desplazamientos angulares, lo que significa que es capaz de girar una cantidad de
grados (paso o medio paso) dependiendo de sus entradas de control.

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.

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 energizada, 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. En este artículo trataremos solamente los motores P-P del tipo de imán permanente,
ya que estos son los más usados en robótica.

Figura 2 Motor a pasos

PRINCIPIO DE FUNCIONAMIENTO DE UN MOTOR A PASOS:

Básicamente los motores a pasos están constituidos normalmente por un rotor sobre el que van
aplicados distintos imanes permanentes y por un cierto número de bobinas excitadoras bobinadas
en su estator. Las bobinas son parte del estator y el rotor es un imán permanente. Toda la
conmutación (o excitación de las bobinas) deber ser externamente manejada por un controlador.

Existen dos tipos de motores paso a paso de imán permanente:

BIPOLAR

Este tipo de motor tiene generalmente cuatro cables de salida. Necesitan ciertos trucos para ser
controlados, debido a que requieren del cambio de dirección del flujo de corriente a través de las
bobinas en la secuencia apropiada para realizar un movimiento. [2]
UNIPOLAR

Estos motores suelen tener 6 o 5 cables de salida, dependiendo de su conexionado interno. Este
tipo se caracteriza por ser más simple de controlar.

Figura 3 Motor a pasos unipolar y bipolar

SECUENCIA DE MOTORES PASO A PASO:

SECUENCIA NORMAL

Con esta secuencia el motor siempre avanza un paso por vez debido a que siempre existen 2
bobinas activadas, con esta secuencia se obtiene un alto torque de paso y retención.

Figura 4 Secuencia de encendido de las bobinas en una secuencia normal

SECUENCIA WAVE DRIVE (PASO COMPLETO)

En esta secuencia se activa solo una bobina por vez, lo que ocasiona que el eje del motor gire hacia
la bobina activa, En algunos motores esto brinda un funcionamiento más suave, pero en caso
contrario el torque de paso y retención es menor.
 Figura 5 Secuencia de encendido de las bobinas en una secuencia de paso completo

SECUENCIA MEDIO PASO

En esta secuencia se activan las bobinas de tal manera que se combinan las secuencia anteriores,
el resultado que se obtiene es un paso más corto (la mitad del paso de las secuencias anteriores),
primero se activan 2 bobinas y posterior mente solo 1 y así sucesivamente.

Figura 6 Secuencia de encendido de las bobinas en una secuencia de medio paso

SECUENCIA PARA MANEJAR UN MOTOR A PASOS BIPOLAR

Como se dijo, estos motores requieren de la inversión de la corriente que circula por sus bobinas
en una secuencia determinada. Cada inversión de polaridad provoca el movimiento del eje en un
paso, El sentido de giro está determinado por la secuencia seguida. [3]

Figura 7 Secuencia de manejo de un motor a paso bipolar

TECLADO MATRICIAL:

Un teclado matricial es un simple arreglo de botones conectados en filas y columnas, de modo

que se pueden leer varios botones con el mínimo número de pines requeridos. Un teclado matricial
4x4 solamente ocupa 4 líneas de un puerto para las filas y otras 4 líneas para las columnas, de este
modo se pueden leer 16 teclas utilizando solamente 8 líneas de un micro controlador. Si asumimos
que todas las columnas y filas inicialmente están en alto (1 lógico), la pulsación de un botón se
puede detectar al poner cada fila a en bajo (0 lógico) y checar cada columna en busca de un cero,
si ninguna columna está en bajo entonces el 0 de las filas se recorre hacia la siguiente y así
secuencialmente.

Figura 8 Teclado Matricial

PANTALLA LCD:

El LCD (Liquid Crystal Dysplay) o pantalla de cristal líquido es un dispositivo empleado para la
visualización de contenidos o información de una forma gráfica, mediante caracteres, símbolos o
pequeños dibujos dependiendo del modelo. Está gobernado por un microcontrolador el cual dirige
todo su funcionamiento.

En este caso vamos a emplear un LCD de 16x2, esto quiere decir que dispone de 2 filas de 16
caracteres cada una. Los píxeles de cada símbolo o carácter, varían en función de cada modelo.

Figura 9 Pantalla LCD

Comunicación RS-232

El protocolo RS-232 es una norma o estándar mundial que rige los parámetros de uno de los modos
de comunicación serial. Por medio de este protocolo se estandarizan las velocidades de transferencia
de datos, la forma de control que utiliza dicha transferencia, los niveles de voltajes utilizados, el tipo
de cable permitido, las distancias entre equipos, los conectores, etc.

Además de las líneas de transmisión (Tx) y recepción (Rx), las comunicaciones seriales poseen otras
líneas de control de flujo (Hands-hake), donde su uso es opcional dependiendo del dispositivo a
conectar. [4]

Figura 10 Comunicación RS-232

FTDI

Este dispositivo permite la conversión de transmisiones serie RS-232 o TTL a señales USB, con el
fin de permitir la compatibilidad de dispositivos heredados con los ordenadores modernos.

Simple placa conversora de serie a USB con el conocido chip FT232 de FTD, junto con dos diodos
led indicadores de actividad.

Los pines disponibles en placa son GND, 5V, RX, TX y DTR

Se puede utilizar para alimentar y programar directamente una placa Arduino Pro o cualquier otro
dispositivo que tenga un puerto UART TTL. Permite programar las placas oficiales y clonadas
Arduino funcionando a 5V.

Figura 11 Módulo FTDI

Putty

PuTTY es un cliente SSH y Telnet con el que podemos conectarnos a servidores remotos iniciando
una sesión en ellos que nos permite ejecutar comandos. El ejemplo más claro es cuando empleamos
PuTTY para ejecutar comandos en un servidor VPS y así poder instalar algún programa o configurar
alguna parte del servidor. [5]

Figura 12 Putty

4. MATERIALES Y EQUIPOS:

 PICs 16F887

 Computador

 Programa PIC C COMPILER

 Programa PROTEUS

 Protoboard

 Pantalla LCD 16x2

 Motor a pasos

 Motor DC

 Quemador pickit2

 Teclado matricial 4x4

 Driver motor a pasos

 Diodos led

 Putty_0-65
 Módulo FTDI
5. DIAGRAMAS Y ESQUEMAS:

DIAGRAMA CONTROL SERIAL MOTOR A PASOS Y MOTOR DC

6. DESARROLLO:

El programa de control de un motor DC y un motor a pasos debe cumplir las siguientes condiciones:

 Mediante comunicación serial se selecciona el tipo de sistema para control, ya sea mediante
comunicación serial utilizando la interfaz “Putty” o mediante el teclado matricial.

 En ambos metodos de control se disponen las siguientes condiciones:

o Si se selecciona la opcion de motor DC se selecciona el tipo el sentido de giro, ya sea

sentido horario o sentido anti horario.
o Si se selecciona la opcion de motor a pasos, se tiene la opcion de control de sentido de
giro, ya sea izquierda o derecha; además el tipo de paso que va a realizar, ya sea:
simple, medio o doble. El sistema cuenta con la opcion de control de motor a pasos
mediante “retardos”, en esta opción se asigna un tiempo de retardo para el
funcionamiento del motor.
Todas las condiciones indicadas anteriormente funcionan tanto para el control desde PC como para
control utilizando el teclado matricial.
DIAGRAMA DE FLUJO CONTROL SERIAL MOTOR A PASOS Y MOTOR DC
 DESARROLLO DEL CÓDIGO DE PROGRAMACIÓN

Primero declaramos la librería del PIC a utilizar, en este caso, el “16F887”; continuamente se colocan
las directivas de los fusibles, a su vez las directivas del oscilador interno que opera a 4MHz. Se
definen los pines que serán utilizados para la emisión de datos hacia el display LCD. Se incluyen
además las librerías de teclado y LCD. Finalizando con la declaración de los pines a utilizar y los
parámetros necesarios para la comunicación serial.
#include <16f887.h>
#FUSES INTRC,NOWDT,NOPUT,MCLR,NOPROTECT,NOCPD,NOBROWNOUT,NOIESO,NOFCMEN,NOLVP
#use delay(clock=4M)
#define LCD_DB4 PIN_D4
#define LCD_DB5 PIN_D5
#define LCD_DB6 PIN_D6
#define LCD_DB7 PIN_D7
#define LCD_RS PIN_D2
#define LCD_E PIN_D3
#include <lcd1.c>
#include <teclado.c>
#use standard_io(e)
#use standard_io(a)
#use standard_io(c)
#use fast_io(b)
#use rs232(baud=9600, xmit=pin_C6, rcv=pin_C7, bits=8, parity=N)

En esta sección se declaran las variables tipo “CHAR” y tipo “long int” que se utilizarán dentro de la
programación. Ademas la variable “tie” será la encargada de indicar el tiempo de espera para los
métodos posteriores. Finalizando, la variable “i” se utilizará como acumulador en la sección de
ingreso de retardo por teclado.

CHAR dato, dato1, rest, dato2, dato3, dato4, dato5 = '0';

long int num,numero,numero2,numero1;
int tie=50,i=0;

“INT_rda” es la interrupción serial, esta será utilizada para ingresar los datos mediante teclado al
sistema. Se asigna un void de comunicación serial siendo “dato” la variable encargada de este
proceso.

#INT_rda
void serial()
{
dato = getc ();
}

Para la ejecución de los pasos, se ha tomado en cuenta las condiciones de funcionamiento de las
bobinas del motor a pasos indicadas anteriormente; cada paso está definido en un sentido de giro ya
sea este sentido izquierda o derecha. Estos métodos son utilizados por los controles mediante PC y
mediante PIC.

void paso_simple_izquierda()
{
output_a (8);
delay_ms (tie);
 output_a (4);
delay_ms (tie);
output_a (2);
delay_ms (tie);
output_a (1);
delay_ms (tie);
}
void paso_simple_derecha()
{
output_a (1);
delay_ms (tie);
output_a (2);
delay_ms (tie);
output_a (4);
delay_ms (tie);
output_a (8);
delay_ms (tie);
}
void paso_medio_izquierda()
{
output_a (8);
delay_ms (tie);
output_a (12);
delay_ms (tie);
output_a (4);
delay_ms (tie);
output_a (6);
delay_ms (tie);
output_a (2);
delay_ms (tie);
output_a (3);
delay_ms (tie);
output_a (1);
delay_ms (tie);
output_a (9);
delay_ms (tie);
}
void paso_medio_derecha()
{
output_a (9);
delay_ms (tie);
output_a (1);
delay_ms (tie);
output_a (3);
delay_ms (tie);
output_a (2);
delay_ms (tie);
output_a (6);
delay_ms (tie);
output_a (4);
delay_ms (tie);
output_a (12);
delay_ms (tie);
output_a (8);
 delay_ms (tie);
}
void paso_doble_izquierda()
{
output_a (12);
delay_ms (tie);
output_a (6);
delay_ms (tie);
output_a (3);
delay_ms (tie);
output_a (9);
delay_ms (tie);
}
void paso_doble_derecha()
{
output_a (9);
delay_ms (tie);
output_a (3);
delay_ms (tie);
output_a (6);
delay_ms (tie);
output_a (12);
delay_ms (tie);
}
void retardos()
{
output_a (12);
delay_ms (numero);
output_a (6);
delay_ms (numero);
output_a (3);
delay_ms (numero);
output_a (9);
delay_ms (numero);
}

Para realizar la conversion de dato “string” a numérico, se utiliza el método “trans”, el cual es el
encargado de asignar a la variable “num”, el dato que se esta asignando en formato “string” a
numérico.

void trans()
{
IF (dato == '1'){num = 1; }
IF (dato == '2'){num = 2; }
IF (dato == '3'){num = 3; }
IF (dato == '4'){num = 4; }
IF (dato == '5'){num = 5; }
IF (dato == '6'){num = 6; }
IF (dato == '7'){num = 7; }
IF (dato == '8'){num = 8; }
IF (dato == '9'){num = 9; }
IF (dato == '0'){num = 0; }
}
El método “calculo” es el encargado de realizar el cálculo y posicionamiento de las variables que se
ingresen por teclado. En esta condición se indican las unidades, decenas y centenas que serán
utilizadas en la variable “numero”; cabe recalcar que este método es utilizado en ambos controles.

void calculo()
{
IF (i == 1)
{
numero = num;
numero1 = num;
}
IF (i == 2)
{
numero = numero1 * 10 + num;
numero2 = num;
IF (num == 0) numero2 = 10;
}
IF (i == 3)
{
numero = numero1 * 100 + numero2 * 10 + num;
IF (numero2 == 10) numero = numero1 * 100 + num;
}}

El método apagado permite al sistema comenzar desde “0” para volver a ser utilizado.

VOID apagado()
{
lcd_putc ("\f");
lcd_gotoxy (1, 1);
lcd_putc ("APAGADO");
puts ("\f Conexion Establecida\r");
puts ("Pulsa SPACE para Opciones de Control");
output_e (0);
dato5 = '0', dato1 = '0', dato2 = '0', dato3 = '0', dato4 = '0';
}

El método “menu” Indica las opciones para comenzar el funcionamiento, ya sea mediante “PC” o
mediante “PIC”.

VOID menu()
{

puts ("\f Opciones de Control\r\r");

puts ("Pulsa P para menu control desde la PC (Computadora) \r\r");
puts ("Pulsa M para menu control desde la PIC (Microcontrolador) \r\r");
puts ("Ingrese solamente letras minusculas");
lcd_gotoxy (1, 1);
lcd_putc ("\f MENU");
lcd_gotoxy (1, 2);
lcd_putc ("Opciones de Control");
}
El método “encendido” se utiliza para indicar la selección de motor DC ya sea mediante control
“PC” o “PIC”.

VOID encendido()
{
lcd_putc ("\f");
lcd_gotoxy (1, 1);
lcd_putc ("SISTEMA ON");
lcd_gotoxy (1, 2);
output_e (1);
lcd_putc ("1:DE 1:IZ b:OFF ");
puts ("\f SISTEMA ENCENDIDO\r\r");
puts (" PRESIONE 1 PARA GIRO DERECHA\r");
puts (" PRESIONE 2 PARA GIRO IZQUIERDA\r");
puts (" PRESIONE b PARA APAGAR EL MOTOR\r");
puts ("PULSA q PARA SALIR AL MENU PRINCIPAL\r\r");
}

El método “delay” indica el momento en que se utiliza la opcion de retardos para motor a pasos.

VOID delay()
{
lcd_putc ("\f");
lcd_gotoxy (1, 1);
lcd_putc ("Retardo en ms: ");
output_e (0);
puts ("\f SISTEMA ENCENDIDO\r\r");
puts (" INGRESE RETARDO EN MS\r");
}
El metodo “control PC” es el metodo principal de funcionamiento cuando se utiliza el sistema
controlado desde la computadora. Cabe recalcar que el proceso es el mismo para el control desde
“PIC”, con la única diferencia que los datos se muestran en el display LCD, limitando su visualización
mediante puerto serial.

VOID control_PC()
{
lcd_init ();
lcd_gotoxy (1, 1);
lcd_putc ("\f MENU");
lcd_gotoxy (1, 2);
lcd_putc ("Control desde PC");
output_a (0);
puts ("\f MENU CONTROL COMPUTADOR\r\r");
puts (" Presione a para Motor DC\r");
puts (" Presione d para Motor a pasos\r");
puts (" Presione b para apagar el sistema\r");
dato5 = '0', dato1 = '0', dato2 = '0', dato3 = '0', dato4 = '0';

Para el comienzo, se indica en la pantalla que tipo de dispositivo se desea controlar, ya sea motor
DC o motor a pasos. Para el control de motor DC, se indican las opciones de selección de sentido de
giro, ya sea en sentido horario o sentido anti horario.

WHILE (true)
 {
serial ();
IF (dato == 'a')
{
encendido ();
dato = '0';
dato1 = 'a';
}
IF (dato1 == 'a'&&dato == '1')
{
dato = '0';
output_e (4);
lcd_putc ("\f ");
lcd_gotoxy (1, 1);
lcd_putc ("GIRO DERECHA");
puts ("\f");
puts ("\f CONTROL DESDE EL COMPUTADOR\r\r");
puts (" MOTOR ENCENDIDO GIRO DERECHA\r");
puts (" PRESIONE 2 PARA GIRO IZQUIERDA\r");
puts (" PRESIONE b PARA APAGAR EL SISTEMA\r");
puts (" PRESIONE d PARA PASAR A MOTOR A PASOS\r");
}
IF (dato1 == 'a'&&dato == '2')
{
dato = '0';
output_e (2);
lcd_putc ("\f ");
lcd_gotoxy (1, 1);
lcd_putc ("GIRO IZQUIERDA");
puts ("\f CONTROL DESDE EL COMPUTADOR\r\r");
puts (" MOTOR ENCENDIDO GIRO IZQUIERDA\r");
puts (" PRESIONE 1 PARA GIRO DERECHA\r");
puts (" PRESIONE b PARA APAGAR EL SISTEMA\r");
puts (" PRESIONE d PARA PASAR A MOTOR A PASOS\r");
}

Para finalizar el funcionamiento de un ciclo se indican varias condiciones; si se ingresa “b”, se

ingresa al método “apagado”.

IF (dato == 'b')
{
apagado ();
dato = '0';
break;
}
IF (dato1 == 'a'&&dato == 'q')
{
dato = '0';
rest = 1;
}

Si la opción ingresada es “d”, se procede a la selección de los modos de operación del motor a pasos.
Posteriormente si se ingresa “L” se selecciona funcionamiento por pasos; si se ingresa “R”, se
selecciona la opción de ingreso de delay.
En la opción “pasos”, los sentidos de giro y opciones de “paso simple, medio paso y paso doble” se
indican en un inicio, se selecciona una de ellas para su funcionamiento.
Cabe indicar que en cada selección de paso se utilizan 2 variables “dato3”, la cual se compara con el
valor ingresado actualmente; y la variable “dato5”, la cual es la encargada de realizar el
funcionamiento de cada ciclo.

IF (dato == 'd')
{
dato = '0';
dato1 = 'd';
lcd_putc ("\f ");
lcd_gotoxy (1, 1);
lcd_putc ("MOTOR A PASOS");
puts ("\f CONTROL DESDE EL COMPUTADOR\r\r");
puts (" MOTOR A PASOS\r");
puts (" PARA PASOS PRESS - > L\r");
puts (" PARA RETARDO PRESS - > R\r");
}
IF (dato1 == 'd'&&dato == 'l')
{
dato = '0';
dato3 = 'i';
lcd_putc ("\f ");
lcd_gotoxy (1, 1);
lcd_putc ("MOTOR PASOS");
puts ("\f CONTROL DESDE EL COMPUTADOR\r\r");
puts (" MOTOR A PASOS\r");
puts ("SELECCIONE IZQUIERDA\r");
puts ("SELECCIONE SIMPLE - > t\r");
puts ("SELECCIONE MEDIO - > y\r");
puts ("SELECCIONE DOBLE - > u\r");
puts ("SELECCIONE DERECHA\r");
puts ("SELECCIONE SIMPLE - > g\r");
puts ("SELECCIONE MEDIO - > h\r");
puts ("SELECCIONE DOBLE - > j\r");
}
IF (dato3 == 'i'&&dato == 't')
{
dato = '0';
dato5 = '1';
}
IF (dato5 == '1')
{
paso_simple_izquierda ();
}
IF (dato3 == 'i'&&dato == 'y')
{
dato = '0';
dato5 = '2';
}
IF (dato5 == '2')
{
paso_medio_izquierda ();
 }
IF (dato3 == 'i'&&dato == 'u')
{
dato = '0';
dato5 = '3';
}
IF (dato5 == '3')
{
paso_doble_izquierda ();
}
IF (dato3 == 'i'&&dato == 'g')
{
dato = '0';
dato5 = '4';
}
IF (dato5 == '4')
{
paso_simple_derecha ();
}
IF (dato3 == 'i'&&dato == 'h')
{
dato = '0';
dato5 = '5';
}
IF (dato5 == '5')
{
paso_medio_derecha ();
}
IF (dato3 == 'i'&&dato == 'j')
{
dato = '0';
dato5 = '6';
}
IF (dato5 == '6')
{
paso_doble_derecha ();
}

En esta sección se indica el método de funcionamiento de motor a pasos utilizando “retardos”; en este
caso se realiza el llamado a los métodos anteriores “trans y calculo”. Estos dos métodos serán los
encargados de realizar el ingreso del número mediante comunicación serial para su visualización en
la interfaz de “putty” y en la pantalla LCD.

IF (dato1 == 'd'&&dato == 'r')

{
dato = '0';
dato4 = '1';
delay ();
}
IF (dato4 == '1')
{
i = 0;
WHILE (i <= 3)
{
 INT valor = kbhit ();
IF (valor == 1)
{
IF (dato == ' '){goto re; } i++;
trans ();
printf ("%li", num);
calculo ();
}
}
dato4 = 2;
}

En este caso se indica que para la visualización de la variable “numero” será mostrada con diferente
tipo de dato; para la visualización en la pantalla de “putty” se utilizó el dato “long int”, mientras que
para la visualización en la pantalla LCD se utilizó el formato “long undefined”.

IF (dato4 == '2')
{
re:
dato4 = '3';
printf ("\r el retardo es de %li ", numero);
printf (lcd_putc, "\f Retardos de %lu", numero);
}
IF (dato4 == '3')
{
retardos ();
}
}
}

El método “control_PIC” es similar al metodo “control_PC” ya que ambos cumplen con el mismo
formato de funcionamiento; con la única condición de que los datos adquiridos se realizará mediante
teclado matricial, para ello se utiliza la instrucción “dato=kbd_getc()”. Para este caso la mayoría de
las visualizaciones se realizan en la pantalla LCD más ya no en la pantalla de terminal de “Putty”.

VOID control_PIC()
{
lcd_init ();
lcd_putc ("\f");
lcd_gotoxy (1, 1);
lcd_putc ("1: Motor DC");
lcd_gotoxy (1, 2);
output_e (1);
lcd_putc ("2:M Pasos b:OFF ");
puts ("\f MENU CONTROL PIC\r\r");
puts (" Presione 1 para Motor DC\r");
puts (" Presione 2 para Motor a pasos\r");
dato5 = '0', dato1 = '0', dato2 = '0', dato3 = '0', dato4 = '0';
WHILE (true)
{
dato = kbd_getc ();
IF (dato == '1'&&dato1 != 'a'&& dato1 != 'd')
{
 encendido ();
dato = '0';
dato1 = 'a';
}
IF (dato1 == 'a'&&dato == '1')
{
dato = '0';
output_e (4);
lcd_putc ("\f ");
lcd_gotoxy (1, 1);
lcd_putc ("GIRO DERECHA");
puts ("\f");
puts ("\f CONTROL DESDE EL COMPUTADOR\r\r");
puts (" MOTOR ENCENDIDO GIRO DERECHA\r");
puts (" PRESIONE 4 PARA GIRO IZQUIERDA\r");
puts (" PRESIONE B PARA APAGAR EL SISTEMA\r");
puts (" PRESIONE d PARA PASAR A MOTOR A PASOS\r");
}
IF (dato1 == 'a'&&dato == '2')
{
dato = '0';
output_e (2);
lcd_putc ("\f ");
lcd_gotoxy (1, 1);
lcd_putc ("GIRO IZQUIERDA");
puts ("\f CONTROL DESDE EL COMPUTADOR\r\r");
puts (" MOTOR ENCENDIDO GIRO IZQUIERDA\r");
puts (" PRESIONE 3 PARA GIRO DERECHA\r");
puts (" PRESIONE b PARA APAGAR EL SISTEMA\r");
puts (" PRESIONE d PARA PASAR A MOTOR A PASOS\r");
}
IF (dato == 'B')
{
dato = '0';
apagado () ;
BREAK;
}
IF (dato == '2'&& dato1 != 'd')
{
dato = '0';
dato1 = 'd';
lcd_putc ("\f ");
lcd_gotoxy (1, 1);
lcd_putc ("Pasos --> 1");
lcd_gotoxy (1, 2);
lcd_putc ("Retardos --> 2");
puts ("\f CONTROL DESDE EL COMPUTADOR\r\r");
puts (" MOTOR A PASOS\r");
puts (" PARA PASOS PRESS - > 1\r");
puts (" PARA RETARDO PRESS - > 2\r");
}

IF (dato1 == 'd' && dato == '1')

{
 dato = '0';
dato3 = 'i';
lcd_putc ("\f ");
lcd_gotoxy (1, 1);
lcd_putc ("iz s1 m2 d3");
lcd_gotoxy (1, 2);
lcd_putc ("der s4 m5 d6");
puts ("\f CONTROL DESDE EL COMPUTADOR\r\r");
puts (" MOTOR A PASOS\r");
puts ("SELECCIONE IZQUIERDA\r");
puts ("SELECCIONE SIMPLE - > 1\r");
puts ("SELECCIONE MEDIO - > 2\r");
puts ("SELECCIONE DOBLE - > 3\r");
puts ("SELECCIONE DERECHA\r");
puts ("SELECCIONE SIMPLE - > 4\r");
puts ("SELECCIONE MEDIO - > 5\r");
puts ("SELECCIONE DOBLE - > 6\r");
}
IF (dato3 == 'i'&&dato == '1')
{
dato = '0';
dato5 = '1';
}
IF (dato5 == '1')
{
paso_simple_izquierda ();
}
IF (dato3 == 'i'&&dato == '2')
{
dato = '0';
dato5 = '2';
}
IF (dato5 == '2')
{
paso_medio_izquierda ();
}
IF (dato3 == 'i'&&dato == '3')
{
dato = '0';
dato5 = '3';
}
IF (dato5 == '3')
{
paso_doble_izquierda ();
}
IF (dato3 == 'i'&&dato == '4')
{
dato = '0';
dato5 = '4';
}
IF (dato5 == '4')
{
paso_simple_derecha ();
}
 IF (dato3 == 'i'&&dato == '5')
{
dato = '0';
dato5 = '5';
}
IF (dato5 == '5')
{
paso_medio_derecha ();
}
IF (dato3 == 'i'&&dato == '6')
{
dato = '0';
dato5 = '6';
}
IF (dato5 == '6')
{
paso_doble_derecha ();
}
IF (dato1 == 'd'&&dato == '2')
{
dato = '0';
dato4 = '1';
delay ();
}
IF (dato4 == '1')
{
i = 0;
WHILE (i <= 3)
{
dato= kbd_getc();
IF (dato != 0)
{
IF (dato == 'C'){goto re; } i++;
trans ();
lcd_gotoxy (1+i, 2);
lcd_putc(dato);
printf ("%li", num);
calculo ();
}
}
dato4 = 2;
}
IF (dato4 == '2')
{
re:
dato4 = '3';
printf ("\r el retardo es de %li ", numero);
printf (lcd_putc, "\f Retardos de %lu", numero);
}
IF (dato4 == '3')
{
retardos ();
}
}}
El ciclo “main” es el ciclo principal de funcionamiento de sistema, en el mismo se indican las
condiciones de funcionamiento del mismo. Se inicializan las variables de trabajo como son: puerto B
para entrada de datos, puerto “A y E” para salida. El funcionamiento principal de este ciclo se basa
en el ingreso de la variable “dato”; esta es la encargada de permitir la ejecución de las diferentes
líneas de código asociadas a cada función.

VOID main ()
{
set_tris_b (0x01); //DECLARACION DEL PUERTO B COMO ENTRADA
set_tris_a (0b00000000);
set_tris_e (0b00000000);
port_b_pullups (true);
lcd_init ();
kbd_init ();
enable_interrupts (INT_rda);
enable_interrupts (global);
output_a (0);
output_e (0);
lcd_gotoxy (1, 1);
lcd_putc ("\f Comunicacion");
lcd_gotoxy (1, 2);
lcd_putc (" Serial PIC - PC");
puts ("\f Conexion Establecida\r");
puts ("Pulsa SPACE para Opciones de Control");
WHILE (true)
{
serial ();
IF (dato == ' '){ menu (); dato = '0'; }
IF (dato == 'p'){control_PC (); dato = '0'; }
IF (dato == 'm'){control_PIC (); dato = '0'; }
}
}
7. ANÁLISIS Y RESULTADOS:

a. Resultados esperados:
 Mediante el control utilizando el computador, el encendido y control de sentido de giro
del motor DC cumple con las condiciones de funcionamiento; además el motor a pasos en
su modalidad a pasos realiza su funcionamiento de manera correcta, ejecutando cada paso
simple, medio o doble de acuerdo a las condiciones establecidas.

 Utilizando el control sistema mediante teclado matricial las condiciones de

funcionamiento tanto para motor DC como para motor cumplen en su totalidad con las
condiciones especificadas de funcionamiento.

b. Resultados obtenidos:
 En el caso de control del sistema utilizando la interfaz del software “Putty”, se utilizó la
variable “dato” para el ingreso, ya que esta variable está asociada directamente a la
interrupción de comunicación serial, el ingreso de datos y el funcionamiento de las
diferentes etapas es mucho más rápido.

 En la etapa de ingreso de retardos mediante “PC” se observa un tiempo de retardo ya que

para la visualización de los datos en pantalla se debe almacenar los mismos, este proceso
aumenta el tiempo de ejecución del programa por lo que tiende a demorarse.

 El control del sistema mediante teclado matricial cumple con todas las condiciones de
funcionamiento, ya sea para control de motor DC como para funcionamiento de motor a
pasos; en esta sección cabe recalcar que al ser la pantalla del display limitada, se debe
minimizar la visualización de caracteres en la misma por lo que la presentación de los
métodos es un poco más corta.

8. CONCLUSIONES:

 Mediante el Compilador PIC C realizamos el programa que permitirá la conexión entre el

computador y el microcontrolador, obteniendo los resultados esperados.

 Proteus simulador nos permitió crear una interfaz donde se puso a prueba el programa
obtenido anteriormente, mediante la implementación de los componentes necesarios para una
correcta verificación del circuito expuesto antes de llevar a cabo la parte física.
  En la implementación física del sistema micro controlado para el mando de motores mediante
comunicación serial entre el microprocesador y el computador, se puso en consideración todos
los conocimientos adquiridos tanto de manera teórica, como de manera practica en el
desarrollo de esta actividad, comprobando el correcto funcionamiento del sistema
implementado.

9. RECOMENDACIONES:

 Es recomendable una correcta lógica en la programación realizada para de esta manera no

tener percances en el funcionamiento de los sistemas a implementarse.

 Se recomienda revisar la conexión al PIC y al computador de los diferentes elementos, y

así evitar posibles fallas.

10. BIBLIOGRAFÍA:

[1] S. Eduardo, Electrónica digital y microprocesadores, Madrid: Biblos Industria Gráfica, S.L.,
1993.
[2] D. Benchimol, Microcontroladores, Funcionamiento, programacion y aplicaciones practicas,
Buenos Aires: Fox Andina, 2011.
[3] J. Angulo, MICROCONTROLADORES «PIC» Diseño práctico de aplicaciones, Madrid:
McGraw Hill, 2003.
[4] J. Caipa, Introduccion a la programacion de microcontroladores PIC en CCS C, Miami:
Bluebird Electronics, 2002.
[5] H. Singh, Making PIC microcontroller instruments and controllers, New York: McGraw Hill,
2009.