Nombre de la asignatura: Laboratorio de Programación de Avanzada

Nombre de la práctica: Manejo de entradas y salidas digitales

Nombre de los estudiantes:

García Delgado Héctor Alfonso

González Herrera Omar Santiago

Solís Ríos Daniel Arturo

Número de práctica: 1

Total de horas: 2 Hrs.

Objetivos

• Configurar los pines del microcontrolador para operar como entradas simples o salidas
simples (SISO), al igual puertos como entradas o salidas.
• Desarrollar un programa que recibirá señales de entradas y a partir de estas, manipular
acciones visuales (leds) del microcontrolador mediante conocimientos de programación
básica.
• Comprender la implementación de la jerarquía de tareas en la programación mediante la
prioridad en las lecturas de las entradas.

Descripción de la práctica

El estudiante debe ser capaz de configurar adecuadamente el microcontrolador para el uso de

señales de entrada, estas a su vez controlaran: “la selección”, “paro” e “inicio” de cuatro distintas
secuencias de salida del microcontrolador (uC), que se visualizaran mediante diodos emisores de luz
(led). Debido a que las secuencias se ejecutaran de manera cíclica por tiempo indefinido, el alumno
deberá contemplar la cuestión de la jerarquía en la lectura de entradas, con la finalidad de dar
prioridad al botón de paro y que ejecute la acción de manera inmediata sin importar la secuencia
que se ejecute, así como solo iniciar una secuencia mediante el botón de Inicio sin importar si los
botones de selección son alterados mientras se corre una secuencia, una vez este activada una
secuencia, esta podrá cambiarse por otra mediante el paro de la misma y dar inicio a la nueva
secuencia.
Consideraciones para la elaboración

• Las secuencias de salida serán determinadas por el alumno.

• La programación de la prioridad debe ser en código C, sin el uso de etiquetas ni
interrupciones.
• Los botones deben ejecutar acciones de maneras inmediatas, sin necesidad de ser
presionados por mucho tiempo o múltiples ocasiones.

Marco teórico

Las entradas y salidas digitales, o para ser más general, la habilidad para monitorear y controlar
hardware directamente, es la principal característica de los microcontroladores. Como
consecuencia prácticamente todos los microcontroladores tiene al menos 1-2 pines de I / O digital.
Los pines de I / O están generalmente agrupados en puertos de 8 pines. Los pines pueden ser de
solo entrada, de solo salida, o-más comúnmente-bidireccional, es decir, capacidad para ser entrada
y salida. Si leemos el nivel de voltaje de un pin con un multímetro (con respecto a GND), veremos
un voltaje análogo, sin embargo, el microcontrolador lo digitaliza por mapeo a uno de dos estados,0
lógico o 1 lógico.

La funcionalidad de la entrada digital es usada siempre que la señal monitoreada deba ser
interpretada digitalmente, esto es, cuando solo cambien entre dos valores “alto” (correspondiente
al 1 lógico) y “bajo” (correspondiente al 0 lógico). Siempre que la señal deba ser monitoreada como
“alto” y “bajo” dependerá de su nivel de voltaje, el cual estará determinado en las especificaciones
del microcontrolador.

Debemos tomar en cuenta que los pines de salida son más críticos que los pines de entrada en
sentido de que dependen fuertemente de una protección de corriente externa. Después de todo,
se puede conectar una salida a GND, ajustar la salida a 1, y hacer un corto circuito. Aunque los
microcontroladores pueden soportar un cortocircuito por un tiempo breve (generalmente menos
de un segundo), un corto puede eventualmente destruir el microcontrolador.

Proteus fue desarrollado por Labcenter Electronics, es un software con el cual se puede generar
fácilmente un esquemático, desarrollar en PCB y simular microprocesadores. Es un entorno
diseñado para la realización completa de proyectos de construcción de equipos electrónicos en
todas sus etapas: diseño, simulación, depuración, y construcción. Es una herramienta para la
elaboración avanzada de esquemas electrónicos, que incorpora una librería de más de 6000
modelos de dispositivos digitales y analógicos.
EQUIPO Y MATERIALES

- Software para programación

- Software de simulación

- Programador de microcontrolador

- Microcontrolador

- 4 push buttons

- 16 leds

-20 resistencias de 220 o 330 ohms

DESARROLLO DE LA PRÁCTICA

1. Escribir el programa para el microcontrolador de la Figura 1, considerando:

a) Seleccionar el uC adecuado para la práctica, configuración necesaria para operar el
uC y frecuencia de reloj.
b) La selección de los pines de entrada y salida quedará a consideración del alumno.
c) La secuencia de salida que se encuentre activa podrá ser detenida en cualquier
momento, es decir, sin importar que la secuencia haya o no terminado.
d) La secuencia solo inicia después de un paro y al presionar el botón de inicio.
2. Desarrollar la simulación del circuito (de acuerdo al diagrama de bloques, Figura 1),
tomando en cuenta los siguiente:
a) Se tendrán dos botones que servirán como señales de entrada para la elección de
la secuencia de salida (los casos se representan en binario), un botón de inicio y un
botón de paro.
b) Ocho LEDs conectados a las salidas seleccionadas del microcontrolador servirán
para visualizar las secuencias de salida.
3. Realizar la conexión del circuito y programar el microcontrolador.
Resultados de la práctica

-Diagrama a bloques de la lógica secuencial del programa.

-Descripción breve del código.

Para la realización del código del programa se utilizaron funciones while e if para generar una
toma de decisiones en cuanto a los botones utilizados para que cada uno de estos encendiera una
serie de 16 LED’s con diferente secuencia, utilizando entradas y salidas para el encendido y
apagado de cada LED utilizando un retraso para que se lograra ver el cambio y así generar la
secuencia deseada en un tiempo indefinido.
-Cómo fue la programación para dar prioridad
a cada botón de la práctica.

Se realizo mediante una sentencia if, donde

mientras el botón no fuera presionado dicha
sentencia se seguiría cumpliendo y seguiría
corriendo la secuencia en la que se encuentra,
si se llegara a presionar un botón entraba
dentro de un while y sumaba uno a nuestra
variable de referencia “i”, el programa
regresaba a la sentencia while anterior donde
se encontraba la referencia “i” y al no cumplir
su sentencia se brincaba hasta el siguiente
botón con sentencia if.

Figura 1. Primeras líneas de código del programa.

Figura 2. Circuito realizado en Proteus

-Conflictos presentes en el desarrollo y simulación.

Se tuvieron problemas en la realización del código para el cambio de las secuencias mediante el uso
de los botones, se solucionó de forma lógica utilizando distintas funciones de programación, así
como también aprovechando el PIC.
-Comparativa entre los resultados de la simulación y el circuito real.

Para esta práctica sólo se realizó la simulación del programa mediante Proteus.

Conclusiones de la práctica

Omar: A lo largo de esta práctica aprendí grandemente acerca de las múltiples herramientas que se
tienen para poder crear circuitos, plantear líneas de código para realizar una función específica e
implementar el código diseñado dentro de la simulación de un circuito. Más específicamente,
mediante el programa Proteus, pude ver el funcionamiento y las interconexiones que lleva un
circuito mínimo para que funcione de manera adecuada, además que, una vez terminado el circuito,
se tiene la posibilidad de ejecutar el código diseñado y comprobar que dicho código se está
ejecutando como se había planteado. En cuanto al PIC C Compiler, éste es un programa igualmente
útil ya que nos permite usar el lenguaje C/C++ para poder diseñar las líneas de código que van a
funcionar de cierta forma.

Con estas dos herramientas y los conocimientos acerca de la programación, se pudo realizar esta
primer practica relacionada con el uso y programación de múltiples LED’s para que realicen una
determinada secuencia al momento de presionar uno de los cuatro botones.

Héctor: Con la realización de esta práctica aprendí como se pueden programar una serie de LED’s
mediante un código en C++ para variar la forma en que prenden cada uno con entradas y salidas y
al final obtener una secuencia, a su vez se aprendió el manejo y uso del software Proteus para
realizar la simulación de las secuencias programadas y así comprender el armado de un circuito ,
utilizando los componentes que proporciona Proteus y viendo cómo se conectan a cada puerto para
que se prendan los LED’s y conectar estos a cada botón utilizado, para que así se realice cada
secuencia por separado y saber si está funcionando correctamente.
Daniel: Al realizar la práctica aplicamos nuestros conocimientos de programación y a su vez la
utilización de circuitos, esta fue de gran ayuda para comenzar con el curso ya que nos aportó las
bases y conocimientos mediante la teoría y práctica como el PIC recibe señales, así como también
las envía y como utilizando la programación podemos llegar a manipular componentes electrónicos
con líneas de código específicas y como realizar secuencias en este caso 4 secuencias sencillas de
LED’s que serían un envió de señal y 4 botones que cambian la secuencia a mostrar lo cual el PIC lo
interpreta como una entrada de señal cambiando así de una secuencia a otra.
Conclusión de equipo: Mediante esta practica hicimos uso de los conocimientos previos de
programación y los aplicamos a programación de componentes, realizando en la práctica el código
para encender y apagar LED’s, utilizando entradas y jerarquía de operaciones para lograr realizar
varias secuencias para después controlarlas mediante el uso de botones. Se aprendió a manejar el
software de Proteus y todas las funciones que puedes utilizar aprendiendo a su vez el armado y
funcionamiento de un circuito con el uso de un microcontrolador PIC y el programador PIC C
Compiler, todo esto para realizar la simulación del programa y verificar su funcionamiento antes de
armarlo en físico.
Bibliografía
García E. (2008). Compilador C CCS y simulador PROTEUS para microcontroladores PIC: Alfa Omega.
Grindling G. & Weiss B. (2007). Introduction to Microcontrollers. Vienna University of Technology.
#include <18f4550.h> //C4 if(input(pin_A2)) if(input(pin_A3))
#fuses PLL1, CPUDIV1, XT, output_high(pin_C4); { {
NOPROTECT, NOWDT, NOLVP delay_ms(X); while (input(pin_A2)); while (input(pin_A3));
i++; i++;
output_low(pin_C4); } }
#use delay(clock = 1M, crystal = //C5 } }
4M) output_high(pin_C5); while (i==2) while (i==3)
delay_ms(X); { {
VOID MAIN () output_low(pin_C5); //B0 //B0
{ //C6 output_high(pin_B0); output_high(pin_B0);
INT X=100,i=0; output_high(pin_C6); delay_ms(X); delay_ms(X);
output_low(pin_B0); output_low(pin_B0);
delay_ms(X); //B1 //B1
WHILE(true) output_low(pin_C6); output_high(pin_B1); output_high(pin_B1);
{ //C7 delay_ms(X); delay_ms(X);
if (input(pin_A0)) output_high(pin_C7); output_low(pin_B1); output_low(pin_B1);
{ delay_ms(X); //B2 //C1
while (input(pin_A0)); output_low(pin_C7); output_high(pin_B2); output_high(pin_C1);
while (i==0) //D0 delay_ms(X); delay_ms(X);
output_low(pin_B2); output_low(pin_C1);
{ output_high(pin_D0); //B3 //C2
output_high(pin_B0); delay_ms(X); output_high(pin_B3); output_high(pin_C2);
delay_ms(X); output_low(pin_D0); delay_ms(X); delay_ms(X);
output_low(pin_B0); output_low(pin_B3); output_low(pin_C2);
//B1 if(input(pin_A1)) //B4 //B2
output_high(pin_B1); { output_high(pin_B4); output_high(pin_B2);
delay_ms(X); while (input(pin_A1)); delay_ms(X); delay_ms(X);
output_low(pin_B4); output_low(pin_B2);
output_low(pin_B1); i++; //B5 //B3
//B2 } output_high(pin_B5); output_high(pin_B3);
output_high(pin_B2); } delay_ms(X); delay_ms(X);
delay_ms(X); while (i==1) output_low(pin_B5); output_low(pin_B3);
output_low(pin_B2); { //B6 //C4
//B3 //C0 output_high(pin_B6); output_high(pin_C4);
output_high(pin_B3); output_high(pin_C0); delay_ms(X); delay_ms(X);
output_low(pin_B6); output_low(pin_C4);
delay_ms(X); delay_ms(X); //B7 //C5
output_low(pin_B3); output_low(pin_C0); output_high(pin_B7); output_high(pin_C5);
//B4 //B1 delay_ms(X); delay_ms(X);
output_high(pin_B4); output_high(pin_B1); output_low(pin_B7); output_low(pin_C5);
delay_ms(X); delay_ms(X); //D0 //B4
output_low(pin_B4); output_low(pin_B1); output_high(pin_D0); output_high(pin_B4);
//B5 //C2 delay_ms(X); delay_ms(X);
output_low(pin_D0); output_low(pin_B4);
output_high(pin_B5); output_high(pin_C2); //C7 //B5
delay_ms(X); delay_ms(X); output_high(pin_C7); output_high(pin_B5);
output_low(pin_B5); output_low(pin_C2); delay_ms(X); delay_ms(X);
//B3 output_low(pin_C7); output_low(pin_B5);
//B6 output_high(pin_B3); //C6 //C6
output_high(pin_B6); delay_ms(X); output_high(pin_C6); output_high(pin_C6);
delay_ms(X); output_low(pin_B3); delay_ms(X); delay_ms(X);
output_low(pin_C6); output_low(pin_C6);
output_low(pin_B6); //C5 //C5 //C7
//B7 output_high(pin_C5); output_high(pin_C5); output_high(pin_C7);
output_high(pin_B7); delay_ms(X); delay_ms(X); delay_ms(X);
delay_ms(X); output_low(pin_C5); output_low(pin_C5); output_low(pin_C7);
output_low(pin_B7); //B5 //C4 //B6
//C0 output_high(pin_B5); output_high(pin_C4); output_high(pin_B6);
output_high(pin_C0); delay_ms(X); delay_ms(X); delay_ms(X);
output_low(pin_C4); output_low(pin_B6);
delay_ms(X); output_low(pin_B5); //C2 //B7
output_low(pin_C0); //C7 output_high(pin_C2); output_high(pin_B7);
//C1 output_high(pin_C7); delay_ms(X); delay_ms(X);
output_high(pin_C1); delay_ms(X); output_low(pin_C2); output_low(pin_B7);
delay_ms(X); output_low(pin_C7); //C1
output_low(pin_C1); //B7 output_high(pin_C1); if(input(pin_A4))
delay_ms(X); {
//C2 output_high(pin_D0);
output_low(pin_C1); while (input(pin_A4));
output_high(pin_C2); delay_ms(X); //C0 i++;
delay_ms(X); output_low(pin_D0); output_high(pin_C0); }
output_low(pin_C2); delay_ms(X); }
output_low(pin_C0); }
}
}