Ingeniería Biomédica
Laboratorio de Programación 2
Practica 2
Entradas y salidas digitales
(6 Horas)
Nombre: Yañez Herrera Paulo Gael
Expediente: 328559
Grupo: 41
Fecha: 27 de marzo de 2025
1
1. OBJETIVO
El alumno aprenderá a implementar el código de programación para controlar las entradas
y salidas digitales del microcontrolador PIC18F4550, así como simular el circuito utilizando la
herramienta de simulación ISIS Professional.
2. MARCO TEÓRICO
1. Características principales del microcontrolador PIC18F4550.
El PIC18F4550 es un microcontrolador de 8 bits de la familia PIC18 de Microchip
Technology, diseñado para aplicaciones que requieren conectividad USB y procesamiento
eficiente.
Sus principales características incluyen:
• Frecuencia de operación de hasta 48 MHz.
• 32 KB de memoria Flash, 2 KB de RAM y 256 bytes de EEPROM.
• Módulo USB 2.0 Full-Speed para comunicación con computadoras.
• Conversión ADC de 10 bits con 10 canales disponibles.
• Interfaces de comunicación: USART, SPI e I²C.
• 35 pines de entrada/salidas configurables.
• Modos de bajo consumo (Sleep e Idle) y protección del código mediante fusibles de
seguridad (Microchip Technology, 2021).
2. Definición de pines y puertos de un microcontrolador.
Los pines de un microcontrolador son las conexiones físicas a través de las cuales se
comunican con el mundo exterior. Dependiendo de su configuración, pueden actuar
como entradas, salidas, alimentación o pines de comunicación.
Los puertos son grupos de pines organizados en conjuntos de 8 bits que pueden
manejar múltiples señales simultáneamente. Por ejemplo, el PIC18F4550 tiene puertos
A, B, C, D y E, cada uno con funciones específicas, como entradas analógicas, señales
digitales o líneas de comunicación
3. Definición de entradas y salidas digitales de un microcontrolador.
Las entradas digitales permiten recibir señales del entorno, interpretándolas como
valores lógicos alto (1) o bajo (0). Se utilizan para leer el estado de botones, sensores o
señales de otros dispositivos.
Las salidas digitales envían señales a otros componentes, como LEDs, motores o
pantallas. Un microcontrolador puede activar o desactivar una salida configurando un pin
en alto (5V) o bajo (0V).
4. Definición de ciclo infinito.
2
Un ciclo infinito es una estructura de control en programación que se ejecuta
repetidamente sin una condición de finalización. En microcontroladores, se usa para que
el programa principal siga funcionando indefinidamente hasta que se apague o se
reinicie el sistema.
5. Definición de contador digital.
Un contador digital es un circuito secuencial que avanza su estado en respuesta a pulsos
de reloj. Puede ser de tipo ascendente, descendente o bidireccional, y se usa en
aplicaciones como medición de tiempo, generación de señales y conversión de datos.
6. ¿Qué es y cómo funciona un motor a pasos?
El motor a pasos es un dispositivo electromecánico que convierte una serie de impulsos
eléctricos en desplazamientos angulares discretos, lo que significa que es capaz de
avanzar una serie de grados (paso) dependiendo de sus entradas de control.
Su funcionamiento es similar a los motores eléctricos comunes, que sólo giran cuando se
aplica el voltaje, pero a diferencia de estos cuentan con más de 2 estatores lo que divide una
rotación completa (360°) en un gran número de pasos rotacionales. En el siguiente ejemplo
tenemos 4 estatores a los que su polaridad varía en secuencia, obteniendo 4 pasos
3. MATERIALES Y EQUIPAMIENTO
1. Software: ISIS Professional, C CCS Compiler
4. METODOLOGÍA
Checkpoint 1-------------------------------------------------------------------------------------------------------
Implementar y simular un programa para mostrar un contador de carrera libre de 8 bits. El
valor del contador se debe mostrar en el puerto D y debe cambiar cada 25 ms, además de
mostrar la cuenta negada en el puerto B. Incluir dos entradas digitales en los pines E0 y E1
para controlar el inicio y el sentido de la cuenta, respectivamente, tal como lo muestra la
siguiente tabla:
Bajo Alto
Pin E0 Detener contador Iniciar contador
Pin E1 Disminuir cuenta Aumentar cuenta
------------------------------------------------------------------------------------------------------------------------------
Para esta práctica, además de usar ISIS Professional, vamos a hacer uso del CCS C Compiler
especializado para programar microcontroladores PIC utilizando el lenguaje de programación
C.
3
En la codificación, primero incluimos el archivo específico para el PIC18F4550, que da acceso
a funciones y recursos del microcontrolador. Luego, configuramos los fusibles y establecemos
que el microcontrolador funcione con un reloj y cristal a 4 MHz. Entre las líneas 6 y 9 se
incluyen librerías estándar para facilitar la programación. En las líneas 12 y 13 declaramos dos
variables de 8 bits sin signo (cont y cont_neg), inicializadas en 0, que se usarán como
contadores de 8 bits, uno para el contador normal y otro para el contador negado.
A partir de la línea 18, empieza nuestra función principal del programa, la línea 21 envía
valores a los pines del puerto d, en este caso cada que (cont) cambia, output_d(cont)
actualiza inmediatamente los pines del puerto D.
La línea 22 indica que cont_neg es el complemento de cont, es decir, el inverso de todos sus
bits. Así, cuando cont aumenta, cont_neg disminuye, y cuando cont disminuye, cont_neg
aumenta. En la línea 23, cada vez que cont_neg cambia, output_b(cont_neg) actualiza
automáticamente los pines del puerto B con el nuevo valor.
En la línea 25 iniciamos un bucle infinito que ejecuta el código continuamente mientras el
microcontrolador esté encendido. En la línea 28, se verifica el estado del pin E0; si está en 0
no hace nada, pero si está en 1, ejecuta el bloque dentro del if. En la línea 31, se lee el estado
del pin E1; si está en 0, se reduce el valor de cont. Si E1 es 1 (línea 36), se incrementa cont
en 1. En la línea 40, cont_neg se actualiza como 255 - cont, invirtiendo todos los bits. Las
líneas 42 y 43 muestran los valores actualizados en los puertos D y B. Finalmente, en la línea
45, se agrega un delay de 25 ms.
Ahora pasaremos al diseño del circuito para observar cómo funciona el código.
Primeramente, se observa que agregamos el microcontrolador PIC18F4550.
Tenemos conectado el cristal de cuarzo en el pin RA6/OSC2/CLKO y OSC1/CLK1 que se usa
para generar la frecuencia del reloj del microcontrolador ajustado a 4MHZ al igual que el
PIC18F4550.
4
En la imagen de la izquierda, en la pestaña de editar el componente del PIC18F4550,
ajustamos la frecuencia del procesador a 4 MHz en "Processor Clock Frequency" y en
"Program File" cargamos el código compilado en CCS C Compiler, con extensión .cof. Luego,
damos OK para aplicar los cambios. También, se incluye un botón asignado como Master
Clear Reset, conectado al pin RE3/MCLR/VPP, que permite reiniciar el microcontrolador.
En la imagen de la derecha, en la pestaña de edición del cristal, ajustamos su frecuencia a 4
MHz y damos OK. Además, agregamos terminales a los pines del microcontrolador que
utilizaremos en este checkpoint para mejorar el manejo y organización.
También observamos dos terminales en los pines E0 y E1, configurados como puntos de
conexión con resistencias pull-down. Según las instrucciones de la tabla, si pin_e0 está en
reposo, el contador permanece detenido; al presionar el pulsador, el contador comenzará a
contar. Para el pin_e1, si está en reposo, el contador disminuirá; al presionar el pulsador, el
contador incrementará.
Además, se muestran los indicadores LED tipo Bargraph mostrando el estado lógico de los
pines de los puertos conectados, encendiendo los LEDs correspondientes cuando el nivel de
voltaje es alto.
5
En la parte izquierda, el puerto D representa nuestro contador, mientras que el puerto B
muestra el contador negado. Como se puede ver, el puerto B refleja el valor inverso del puerto
D. Para verificar que el cambio a 25 ms se está efectuando correctamente, añadimos un
osciloscopio, ajustamos a 25 ms y observamos que las señales son inversas, con una
duración de 25 ms en cada ciclo.
Checkpoint 2 --------------------------------------------------------------------------------------------------
Implementar y simular un programa para ejecutar un contador de pulsos positivos de 0 a
99. La cantidad de pulsos se mostrarán utilizando dos displays de 7 segmentos conectados al
puerto B para las unidades y al puerto D para las decenas, respectivamente. El programa
tendrá 5 entradas digitales, el pin A0 es el pulso que se agregará a la cuenta, el pin A1
determina el sentido de la cuenta (bajo para disminuir y alto para aumentar), el pin A2
determina la cantidad que se agrega a la cuenta (1 para bajo y 2 para alto), el pin C0 reinicia
la cuenta en 0 y el pin C1 asigna la cuenta en 99.
-------------------------------------------------------------------------------------------------------------------------
6
En esta parte de la codificación, usaremos la plantilla del programa anterior, modificando
algunos valores. Mantendremos el uso de #include <184550.h>. En la segunda línea,
cambiaremos de XT a HS para utilizar un cristal de alta velocidad (High-Speed). En la línea 3,
configuraremos el reloj y el cristal a 20 MHz, manteniendo las librerías del programa anterior.
A partir de la línea 13 tenemos las variables que vamos a ocupar, tenemos en la línea 13 y 14
variables para guardar el estado anterior y actual del pin_a0 del microcontrolador inicializadas
en 0
En la línea 16, se declara una variable para detectar un flanco de subida. Entre las líneas 18 y
20, se definen variables enteras sin signo de 8 bits: la línea 18 actúa como contador, la línea
19 almacena el dígito de las decenas y la línea 20 el dígito de las unidades. Estas dos últimas
se usan para mostrar números de dos cifras en un display de 7 segmentos.
La línea 21 contiene un arreglo de 10 valores de enteros sin signo de 8 bits, que almacena los
códigos hexadecimales para mostrar los números del 0 al 9 en el display.
Las líneas 23, 24, 26 y 27 son similares a las líneas 13 y 14, y se usan para guardar el estado
anterior y actual de los pines C0 y C1.
En la línea 31, se utiliza una estructura switch con 8 casos. Si el caso es "n", retorna un valor
hexadecimal que representa la configuración de segmentos para mostrar el número "n" en el
display de 7 segmentos. El caso default devuelve la configuración hexadecimal para mostrar
el número 9 en el display.
A partir de la línea 57, comienza la función principal del programa. En la línea 60, se establece
un bucle infinito, lo que significa que el código se ejecutará continuamente mientras el
microcontrolador esté encendido.
7
En las líneas 63 y 64, capturamos el estado del pin: pin_a0_ant almacena el estado previo de
pin_a0, mientras que pin_a0_act lee su estado actual. Esto es crucial para detectar cambios
en la señal (flancos de subida o bajada).
En el bloque de líneas 67 a 70, se detecta un flanco de subida (cuando la señal pasa de 0 a 1)
y se activa la variable flanco_subida_flag, estableciéndola en 1. En el bloque de líneas 72 a
74, se detecta un flanco de bajada (cuando la señal pasa de 1 a 0), pero solo si previamente
hubo un flanco de subida (flanco_subida_flag == 1). Una vez detectado, se resetea la bandera
flanco_subida_flag a 0.
El siguiente bloque de código, entre las líneas 77 y 113, modifica el valor de cont según el
estado de pin_a1 y pin_a2. Si pin_a1 está en alto (1), el contador se incrementa dependiendo
del estado de pin_a2. Si pin_a2 está en bajo (0), se incrementa en 1 (+1); si pin_a2 está en
alto (1), se incrementa en 2 (+2).
Además, se establece una condición límite para evitar que cont supere 99. Si el incremento es
de 1, cont debe ser menor que 99; si el incremento es de 2, cont debe ser menor que 98, lo
que evita el desbordamiento del contador.
Si pin_a1 está en bajo (0), el contador se disminuye según el estado de pin_a2. Si pin_a2 está
en bajo (0), se decrementa en 1 (-1); si pin_a2 está en alto (1), se decrementa en 2 (-2).
A partir de la línea 122, el bloque de código indica que, si el pin_c0 cambia de 0 a 1, el
contador cont se reinicia a 0.
En la línea 130, el siguiente bloque establece que, si el pin_c1 cambia de 0 a 1, el contador
cont se ajusta a 99.
En las líneas 140 y 141 se obtiene la decena del número cont dividiendo entre 10.0, si cont =
42, dec = 4.2 (pero se usará solo el entero 4) y se envía el valor de las decenas a un display
usando output_d(display[dec]).
8
De igual manera en la línea 143 y 144, Se obtiene la unidad de cont usando el módulo %10, si
cont = 42, uni = 2. Se envía el valor de las unidades al otro segmento del display
output_b(display[uni]).
Para finalizar, en la línea 145 y 146, el output_toggle(pin_e0) selecciona cuál de los dos
dígitos se enciende, cuando pin_e0 = 1, se muestra el dígito de las decenas
(output_d(display[dec])), cuando pin_e0 = 0, se muestra el dígito de las unidades
(output_b(display[uni])).
El delay_ms(100) permite que el ojo humano no perciba el parpadeo y vea ambos números al
mismo tiempo.
En la parte del circuito vamos a mantener el PIC18F4550 con el cristal ajustados a 20MHz y el
Master Clear Reset, conectaremos terminales en los pines que ocuparemos para este
checkpoint para facilitar las conexiones y se vea más ordenado además insertaremos el nuevo
archivo .cof para cargar el código al microcontrolador.
También se observan 3 terminales (puntos de conexión) de los pines A0, A1 y A2 conectados
en configuración pull-down, siguiendo las instrucciones.
Si A0 está en estado bajo, el contador no aumenta. Si está en alto, dependiendo de los
estados de A1 y A2, el contador aumentará en +1 o +2, con dirección ascendente o
descendente.
Si A1 está en bajo, se disminuye la cuenta; si está en alto, se aumenta.
Si A2 está en bajo, el cambio es de 1 unidad; si está en alto, el cambio es de 2 unidades.
De igual manera, se observan 2 terminales de los pines C0 y C1 conectados de forma pull
Down, el pin C0 reinicia la cuenta a 0 cuando está en alto, y el pin C1 cuando está en alto
asigna la cuenta a 99.
Aquí se muestran varias cifras significativas del funcionamiento en conjunto del programa.
En todos Pin A0 es el pulso, los pines A1, y A2 son configuraciones de sentido y cantidad.
CANTIDADES EN 1
Pin A1 en alto la cuenta aumenta, pin A2 en bajo cantidad en 1 (Aumento en 1)
9
Pin A1 en bajo la cuenta disminuye, pin A2 en bajo cantidad en 1 (Disminuye -1)
CANTIDADES EN -2
Pin A1 en alto, sentido en aumento, pin A2 en alto cantidad en 2 (Aumenta en 2)
Pin A1 en bajo, sentido en disminuir, pin a2 en alto cantidad en 2 (Se disminuye -2)
10
CUENTA A 0 Y CUENTA A 99
En la imagen de la izquierda si C1 está en alto asigna la cuenta a 99, en la imagen de la
derecha si C0 está en alto, la cuenta reinicia a 0.
Checkpoint 3-------------------------------------------------------------------------------------------------------
Implementar y simular un programa para detectar los números primos de un número de 4
bits. El número se ingresa en la parte alta del puerto D y se determina si es un número primo
utilizando operadores bit a bit (bitwise) y las funciones canónicas reducidas en maxtérminos y
mintérminos obtenidas de la práctica anterior. El código también debe determinar si un
número es primo utilizando operadores de control (condicionales o ciclos). El resultado de la
detección correspondiente se mostrará en los pines D0, D1 y D2 para las funciones en
mintérminos, maxtérminos y operadores de control, respectivamente.
-------------------------------------------------------------------------------------------------------------------------
En la codificación, reutilizamos la plantilla del programa anterior y añadimos #use fast_io(d) en
la línea 4 para controlar manualmente la dirección de los pines del puerto D con set_tris_d().
Mantenemos las librerías para facilitar la programación. En la línea 14, declaramos una
variable entera sin signo de 8 bits (0-255).
Entre las líneas 16 y 19, definimos variables de 1 bit (A, B, C y D), inicializadas en 0. Las
líneas 21 y 22 contienen variables de 1 bit para mintérminos y maxtérminos, enviadas a los
pines D0 y D1 para activar o desactivar salidas según las condiciones lógicas.
11
Finalmente, en la línea 24, div_flag determina si el número n es primo (0) o no (1), cambiando
a 1 si n es divisible por otro número.
A partir de la línea 30, comienza la función principal del programa. En la línea 33,
set_tris_d(0xf0) configura los primeros 4 pines (D0-D3) como salidas y los últimos 4 pines (D4-
D7) como entradas, permitiendo que el número n se ingrese en la parte alta del puerto D.
En la línea 38, se lee el puerto D y se desplazan los bits 4 posiciones a la derecha, de modo
que n solo almacene los bits D4-D7. En el bloque de líneas 40 a 43, se utiliza la operación
AND bit a bit (&) para enmascarar cada bit, y luego se desplaza (>>) para asignarlo
correctamente. Así, A representa el bit más significativo y D el menos significativo.
En la línea 45, indicamos que f_min se obtiene utilizando una función lógica en mintérminos,
basada en la tabla de verdad generada en la práctica anterior, y se envía el resultado al pin
D0.
En la línea 46, indicamos que f_max se obtiene con una función lógica en maxtérminos, que
es equivalente a la de mintérminos pero en su forma complementaria, y se envía el resultado
al pin D1.
12
Función en maxterminos Función en minterminos
En el bloque de las líneas 51 a 57, se inicializa div_flag = 0, asumiendo que n es primo, se
usa un ciclo for para probar divisibilidad desde 2 hasta n-1. Si n es divisible por algún número,
div_flag = 1 y se rompe el ciclo.
Y por último en el bloque de la línea 61 a 67, Si div_flag sigue siendo 0 (es decir, n no tuvo
divisores), se considera primo y el pin D2 se enciende. Si n es 1, el pin D2 se apaga.
En la parte del circuito vamos a mantener el PIC18F4550 con el cristal ajustados a 20MHz y el
Master Clear Reset, conectaremos terminales en los pines que ocuparemos para este
checkpoint para facilitar las conexiones y se vea más ordenado además insertaremos el nuevo
archivo .cof para cargar el código al microcontrolador.
13
Agregamos de igual manera nuestros indicadores led, conectados en los pines D0, D1 y D2.
(D0 – Mintérminos, D1- Maxtérminos, D2- Operadores de Control)
Las terminales de los pines D4, D5, D6 y D7 se usarán en el display de 7 segmentos como
se muestra en la imagen. De igual manera, se observan las terminales de los pines
conectados de forma Pull Down, el código extrae el número de los pines D4-D7 y se
convierte a un formato compatible con el display.
Por ejemplo:
Si todos los botones están en bajo → 0000 (0 en decimal).
Si solo D4 está en alto → 0001 1 en hexadecimal.
14
Si solo D5 está en alto → 0010 2 en hexadecimal. (Y como es primo, nuestros indicadores
led encienden)
Si D7 y D5 están en alto → 1010 (A en hexadecimal).
Si todos están en alto → 1111 (f en hexadecimal).
15
Checkpoint 4-------------------------------------------------------------------------------------------------------
Implementar y simular un programa para controlar el sentido del giro y la velocidad de dos
motores a pasos unipolares.
La velocidad está definida por el retardo de encendido de las bobinas del motor a pasos, el
cual se muestra en la siguiente tabla:
Pin D0 Pin D1 Pin D2 Delay (ms)
0 0 0 OFF
0 0 1 10
0 1 0 50
0 1 1 100
1 0 0 250
1 0 1 500
1 1 0 750
1 1 1 1000
El sentido de giro está definido por los pines D3 Y D4, tal como se muestra en las siguientes
tablas:
Motor 1 Motor 2
Bajo Alto Bajo Alto
Pin Sentido Sentido Pin Sentido Sentido
D3 Horario Antihorario D4 Horario Antihorario
La secuencia de pasos estará definida por los pines D5 y D6, tal como se muestra en las
siguientes tablas:
Motor 1 Motor 2
Bajo Alto Bajo Alto
Pin Pasos Medios Pin Pasos Medios
D5 Completos Pasos D6 Completos Pasos
Finalmente, los motores deben conectarse en el puerto B, donde el motor 1 estará conectado
en la parta baja del puerto y el motor 2 se conectará en la parte alta.
--------------------------------------------------------------------------------------------------------------------------
En la codificación, reutilizamos la plantilla del programa anterior, y mantenemos las librerías
para facilitar la programación. En la línea 14 tenemos entrada_data como una variable de 8
bits para almacenar los datos leídos del puerto D, en la línea 15 motor_vel almacena la
velocidad del motor, extraída de los bits D0-D2 de entrada_data y en la línea 16 retardo
Guarda el tiempo de retardo en milisegundos para ajustar la velocidad del motor.
16
En la línea 18 tenemos un arreglo que almacena la secuencia de activación de bobinas
para el modo de medios pasos cada valor en el arreglo indica qué bobinas deben
encenderse en un determinado paso del motor, utilizando una representación de 4 bits
(donde cada bit corresponde a una bobina específica.
La línea 19 es un arreglo que almacena los tiempos de retardo en milisegundos para
controlar la velocidad del motor según la configuración de D0 a D2.
En el siguiente bloque de líneas de la 22 a la 28 son Variables para controlar la posición y el
modo de operación de ambos motores.
En la línea 34 empieza nuestra función principal del programa, la línea 37 Inicia un bucle
infinito con while (true), y en la línea 41 se usa input_d() para leer el estado actual del puerto D
ademas asi se incluyen todos los pines del puerto. La línea 43 extrae los bits D0 a D2 de
entrada_data usando AND ( & ) con 0x07, esto determina la velocidad del motor con base en
la tabla de retardos.
En la línea 45 y 47 si motor_vel es 0, se apagan los motores, en caso de que sea distinto que
0, empiezan las condicionantes del motor 1.
17
En la línea 54 a 82, tenemos una condición para el sentido horario, que si se cumple une
sentido horario con medios pasos o con pasos completos. Si no se cumple para el sentido
horario, pasa a sentido antihorario, nuevamente con otra condicionante de medios pasos y
sentido antihorario y pasos completos con sentido antihorario.
Repetimos los mismos pasos para el motor 2, sentido horario (Medios pasos, y pasos
completos) y sentido antihorario (Medios pasos y pasos completos).
En la línea 183 el motor2_out se desplaza 4 bits a la izquierda para ocupar la parte alta del
puerto B y se combina con motor1_out usando | (OR bit a bit) para enviar la señal
resultante al puerto B para activar los motores.
Para finalizar el código en la línea 186 se reorganizan los bits de motor_vel para obtener el
índice correcto del retardo en la tabla retardado además de Introduce un retardo en
milisegundos según la velocidad seleccionada en la línea 187.
18
En la parte del circuito vamos a mantener el PIC18F4550 con el cristal ajustados a 20MHz y el
Master Clear Reset, conectaremos terminales en los pines que ocuparemos para este
checkpoint para facilitar las conexiones y se vea más ordenado además insertaremos el nuevo
archivo .cof para cargar el código al microcontrolador.
También, podemos observar 7 terminales (Puntos de conexión) de los pines D0, D1 y D2
conectados de forma pull down, que son aquellos que definen la velocidad de los motores
como viene en la tabla. Los pines D3 y D5 son sentido y secuencia del motor uno y los pines
D4 y D6 son sentido y secuencia del motor dos.
También, tenemos los 2 motores agregados a la simulación, conectados con los pines B0 a
B3 en el motor 1 y los pines B4 a B7 en el motor 2.
Ahora para ver cómo funciona el circuito conectamos osciloscopios con los pines de los
motores así se podemos observar el retardo, si el motor está haciendo pasos completos o
medios pasos.
Vamos a tomar algunos valores de la tabla para verificar con el osciloscopio que están
teniendo el retardo indicado, vamos a ocupar los calores de 10 ms, 500ms, y 1seg.
Ejemplos:
19
10 ms, pin D0 y D1 en bajo, D2 en alto
Motor 1 y Motor 2
500 ms, pin D0 y D2 en alto, D1 en bajo.
Motor 1 y Motor 2
20
1000ms (1 seg), todos los pines en alto.
Motor 1 y 2
Pasos completos y Medios Pasos en motor 1 a 500ms
Sentido Horario y sentido antihorario en motor 2 a 500ms
21
5. EVALUACIÓN
1. ¿Qué es lo que contiene el archivo PIC18F4550.h?
El archivo PIC18F4550.h es una biblioteca de encabezado específica para el
microcontrolador PIC18F4550, que incluye definiciones de registros, configuraciones de
fusibles, control de interrupciones y macros necesarias para interactuar con el hardware
del dispositivo. Facilita la programación al proporcionar acceso a los registros de control
de puertos, temporizadores y otros periféricos, permitiendo una integración eficiente del
microcontrolador en el código.
Microchip Technology Inc. (2019). PIC18F4550 Data Sheet. Recuperado de
[Link]
2. Defina el uso de los fusibles XT, HS, NOWDT y NOPROTECT
1. XT: Este fusible configura el microcontrolador para utilizar un cristal de baja frecuencia
como fuente de reloj. El valor predeterminado para configuraciones de reloj con
cristales o resonadores de 4-16 MHz. Ideal para aplicaciones que no requieren alta
velocidad de procesamiento.
2. HS: Este fusible configura el microcontrolador para usar un cristal de alta velocidad
(High-Speed) como fuente de reloj. Se utiliza para fuentes de reloj con frecuencias
superiores a 4 MHz, generalmente hasta 20 MHz o más. Este fusible proporciona una
mejor estabilidad en aplicaciones que requieren un mayor rendimiento del
microcontrolador.
3. NOWDT: Este fusible desactiva el Watchdog Timer (WDT), que es un temporizador que
reinicia el microcontrolador en caso de que el software quede bloqueado. Al
configurarlo como NOWDT (sin WDT), el microcontrolador no reiniciará
automáticamente en caso de un error o fallo de ejecución, lo que puede ser útil en
aplicaciones donde no se desea un reinicio por error.
4. NOPROTECT: Este fusible desactiva la protección de código de programa, permitiendo
que el código sea leído y modificado desde el exterior del microcontrolador. Al
configurar NOPROTECT, se desactiva la protección contra copia o modificación del
código, lo que puede ser útil para proyectos de desarrollo, pero representa un riesgo de
seguridad en productos finales.
22
3. ¿Cuál es el propósito del ciclo infinito contenido en la función principal del código de
programación del microcontrolador?
Garantizar que el microcontrolador ejecute continuamente las instrucciones del programa
mientras esté encendido. Este ciclo permite que el sistema permanezca activo y responda
a eventos o cambios de estado sin detenerse, gestionando de manera constante la
interacción con los periféricos (como puertos de entrada/salida, temporizadores, etc.).
Además, facilita la ejecución de tareas repetitivas o la espera de señales externas,
asegurando que el microcontrolador no entre en un estado de inactividad.
4. ¿Cuál es la frecuencia de trabajo máxima del microcontrolador PIC18F4550?
La frecuencia de trabajo máxima del microcontrolador PIC18F4550 es 48 MHz. Esta
frecuencia se alcanza cuando se utiliza un oscilador externo, como un cristal o resonador,
configurado adecuadamente, y el reloj se multiplica mediante un PLL (Phase-Locked Loop)
interno.
5. ¿Cuántos y cuáles son los archivos generados por el compilador? Describa cada uno.
Son 10 mas el archivo en .c:
.ccspjt: Este archivo es específico de proyectos en el entorno de desarrollo del
compilador CCS. Generalmente contiene información relacionada con la configuración del
proyecto, como el archivo de configuración, las opciones de compilación y otros parámetros
del proyecto.
.cof: Este es el archivo de salida del compilador que contiene el código objeto, datos y
direcciones de memoria para la programación del microcontrolador.
.err: Contiene los mensajes de error generados durante el proceso de compilación.
.esym: Este archivo contiene información de símbolos utilizados en el programa.
.hex: Es el archivo de código máquina en formato hexadecimal que contiene el programa
que se va a cargar al microcontrolador.
.lst: Este archivo de listado contiene el código fuente junto con el código de máquina y
las direcciones de memoria correspondientes.
.sta: Este archivo puede contener información sobre el estado del compilador o el
proceso de compilación, como los pasos realizados o los estados de las configuraciones.
.sym: Este archivo contiene información sobre los símbolos utilizados en el programa,
como las variables y funciones definidas.
.tre: Este archivo se utiliza para almacenar información sobre el árbol de ejecución de las
funciones o el flujo de control en el programa.
.xsym: Similar al archivo .sym, el archivo .xsym almacena información detallada sobre
los símbolos del programa, pero puede estar más orientado a un análisis de depuración o una
herramienta externa.
23
6. ¿Cuáles archivos generados por el compilador se utilizan para simular y programar el
código en el microcontrolador?
Los archivos .cof y .hex son los principales utilizados tanto para la simulación como para
la programación del microcontrolador.
.cof (Common Object File): Contiene el código binario intermedio, datos y direcciones
de memoria necesarios para la simulación y carga en el microcontrolador. Es utilizado
en entornos de depuración y simulación, y también es el archivo principal cargado al
microcontrolador durante el proceso de programación.
.hex (Intel Hex File): Contiene el código máquina en formato hexadecimal, que es
compatible con la mayoría de las herramientas de programación de microcontroladores.
Este archivo es el estándar para cargar el programa al microcontrolador utilizando
programadores.
6. CONCLUSIONES
Durante esta práctica, aprendí a controlar las entradas y salidas digitales del
microcontrolador PIC18F4550, así como a simular su funcionamiento en ISIS Professional. Al
inicio, fue un desafío comprender la relación entre las entradas y salidas, especialmente en la
configuración de los puertos y la interacción con los botones. Sin embargo, con la práctica, fui
entendiendo mejor la estructura del código y su impacto en el circuito.
A lo largo del proceso, también surgieron errores, como en la cuenta regresiva y la
configuración del retardo, que me obligaron a analizar y corregir el código. Esto no solo
fortaleció mi lógica de programación, sino que también me permitió mejorar mis habilidades de
detección y solución de problemas. Asimismo, comprendí la importancia de factores como la
configuración del cristal para el correcto funcionamiento del sistema.
Más allá de los conocimientos técnicos adquiridos, esta práctica ayudó a desarrollar un
pensamiento más estructurado y lógico. Aprender a identificar errores y corregirlos de manera
metódica refuerza la capacidad de analizar problemas de manera eficiente. Este tipo de
ejercicios no solo mejoran la comprensión del hardware y software, sino que también
fortalecen la habilidad de razonar y construir soluciones optimizadas, fundamentales en
cualquier área de la ingeniería.
24
Referencias:
Texas Instruments. (n.d.). Logic guide. Recuperado el [03-03-2025], de
[Link]
Tutospoo. (s. f.). Ciclos infinitos. Recuperado de [Link]
java/estructuras-repetitivas/ciclos-infinitos/
Stepper motors, stepper motor drivers, stepper motor controllers and speed control stepper
motors. (s/f). Oriental Motor U.S.A. Corp. de [Link]
motors/[Link]
Microchip Technology. (n.d.). Driving LEDs with microcontrollers. Recuperado el [03-03-2025],
de [Link]
25
