ING.

MECATRONICA
NOMBRE DEL TRABAJO:
Banco De Ejercicios T2

PRESENTADO POR:
García Casiano. Marco Antonio
Mariano Meléndez Cirilo

N0. CONTROL:
20TE0717*
20TE0644*

DOCENTE:
ING. Luis Juárez Ramiro

MATERIA:
FECHA:
Microcontroladores
06/10/2023

SEMESTRE:
Séptimo

1
Tabla de contenido
INTRODUCCION ............................................................................................................................................................... 3
Banco De Ejercicios Tema 2 ............................................................................................................................................. 4
Ejercicio 1 .................................................................................................................................................................... 4
Programación - Explicación del código ............................................................................................................................ 6
Creación del circuito ejercicio 1 ....................................................................................................................................... 8
Electrónica – Explicación de componentes en proteus .................................................................................................... 9
RESULTADO FINAL EJERCICIO 1 FUNCIONANDO .............................................................................................................10
EJERCICIO 2 ....................................................................................................................................................................11
2.- Realizar un programa para que, al pulsar el botón, se encienda la lámpara alimentada con corriente alterna. .......11
CODIGO ..........................................................................................................................................................................11
EXPLICACION DEL CODIGO – PROGRAMACION ..............................................................................................................12
Explicación circuito en proteus .......................................................................................................................................14
Resultados del ejercicio 2 - FUNCIONANDO ...................................................................................................................15
Referencias .....................................................................................................................................................................17

2
 INTRODUCCION

La programación de microcontroladores es una disciplina fundamental en la electrónica y la ingeniería

de sistemas embebidos. Los microcontroladores son pequeños dispositivos electrónicos que se utilizan
para controlar una variedad de sistemas y dispositivos en la vida cotidiana, desde electrodomésticos
hasta automóviles y dispositivos médicos. Programar un microcontrolador implica escribir software
específico que le indique al microcontrolador cómo realizar ciertas tareas y operaciones. En esta
introducción, exploraremos los conceptos básicos de la programación de microcontroladores:
¿Qué es un microcontrolador?: Un microcontrolador es un pequeño chip de silicio que contiene una
unidad central de procesamiento (CPU), memoria, periféricos de entrada/salida y otros componentes
necesarios para ejecutar programas y controlar dispositivos. Los microcontroladores son altamente
eficientes en términos de consumo de energía y tamaño, lo que los hace ideales para aplicaciones
embebidas. Lenguajes de programación: Para programar un microcontrolador, se utilizan lenguajes
de programación específicos. Los lenguajes comunes para la programación de microcontroladores
incluyen C y C++, aunque algunos microcontroladores también admiten lenguajes como Python y Java.
Entorno de desarrollo: Para escribir, compilar y cargar programas en un microcontrolador,
necesitarás un entorno de desarrollo integrado (IDE, por sus siglas en inglés). Ejemplos populares de
IDEs para microcontroladores incluyen Arduino IDE, MPLAB X IDE, y PlatformIO. Programación de
periféricos: Los microcontroladores están diseñados para interactuar con el mundo exterior a través
de sus periféricos. Esto puede incluir puertos de entrada/salida (GPIO), UART (comunicación serial),
ADC (conversión analógico-digital), PWM (modulación por ancho de pulso) y más. La programación
de estos periféricos es esencial para controlar dispositivos externos. Flujo de control y lógica: Al
programar un microcontrolador, es importante comprender los conceptos de flujo de control y lógica.
Esto implica tomar decisiones en el código, repetir tareas y responder a eventos externos. Depuración
y pruebas: La depuración es una parte crucial de la programación de microcontroladores. Los IDEs
suelen ofrecer herramientas para depurar programas y verificar que funcionen correctamente. Las
pruebas exhaustivas son esenciales antes de implementar un sistema en el mundo real.
Optimización y eficiencia: Dado que los recursos de los microcontroladores son limitados en
términos de memoria y potencia de cálculo, la optimización del código es fundamental. Los
programadores deben escribir código eficiente y utilizar recursos de manera efectiva.
La programación de microcontroladores es una habilidad altamente demandada en la industria de la
electrónica y la ingeniería, ya que se utiliza en una amplia gama de aplicaciones. Desde proyectos de
bricolaje hasta sistemas industriales avanzados, la capacidad de programar microcontroladores abre
muchas oportunidades para la creación de dispositivos inteligentes y sistemas embebidos.

3
 Banco De Ejercicios Tema 2
Ejercicio 1

Objetivo: realizar el programa para controlar los circuitos siguientes

1.- Programar el microcontrolador de la imagen para que contabilice del 0 al 9, se incremente la cuenta
cada que se pulse el pulsador NA. Al llegar al 9 reiniciar con el 0.

Solución del problema

Paso 1: con ayuda del c compiler vamos a realizar la programación para poder controlar a base de
pulsos el incremento de los números del 0 al 9 y de ahí que regrese a comenzar de 0. Pare ello
abriremos el c compiler e indicaremos que crearemos un nuevo archivo de código, como se muestra
en la imagen.

4
A continuación, copiaremos e incrustaremos el siguiente código en el c compiler para poder seguir y
al final compilar y no marcara errores.

5
 Programación - Explicación del código

Este es un programa en lenguaje ensamblador para un microcontrolador PIC16F84A. El objetivo

principal del programa parece ser mostrar un contador en un display de 7 segmentos conectado al
puerto B del microcontrolador, y cuando se presiona un botón conectado al pin RA0 (puerto A, pin 0),
el contador se incrementa.

Aquí está la explicación del código línea por línea:

LIST P=16F84A: Esta línea especifica el microcontrolador PIC que se está utilizando, en este caso,
el PIC16F84A.
INCLUDE <P16F84A.INC>: Esta línea incluye el archivo de encabezado para el PIC16F84A, que
contiene definiciones de registros y constantes utilizadas por el microcontrolador.
CBLOCK 0X0C: Esta sección define un bloque de registros de uso general. En este caso, solo se
define un registro llamado "Contador" que se utilizará para llevar un registro del valor del contador.
ENDC: Esta línea indica el final del bloque de registros de uso general.
ORG 0: Establece el origen del programa en la dirección de memoria 0.
bsf STATUS,RP0: Establece el bit RP0 en el registro STATUS, lo que significa que se selecciona
el banco de registros 1 para la próxima instrucción.
movlw 0x00: Mueve el valor 0x00 al registro de trabajo (WREG).
movwf TRISB: Copia el valor de WREG al registro TRISB, configurando así el puerto B como salida.
bsf TRISA,RA0: Establece el bit RA0 en el registro TRISA, configurando el pin RA0 como entrada.
bcf STATUS,RP0: Borra el bit RP0 en el registro STATUS, cambiando de vuelta al banco de
registros 0.
clrf Contador: Borra el registro Contador (inicializa el contador en cero).
clrf PORTB: Borra el puerto B (inicializa el display de 7 segmentos en apagado).
Bucle: Etiqueta para un bucle infinito.
btfsc PORTA,RA0: Verifica si el pin RA0 está en 0 (botón presionado).
goto $-.1: Si el botón está presionado, se ejecutará esta instrucción de salto a la dirección actual
menos una instrucción, lo que crea un ciclo de espera hasta que el botón se suelte.
btfss PORTA,RA0: Verifica si el pin RA0 está en 1 (botón liberado).
goto $-.1: Si el botón está liberado, se ejecutará esta instrucción de salto, creando otro ciclo de
espera.

6
 movf Contador,W: Mueve el valor de Contador al registro de trabajo (WREG).
call TABLA: Llama a la subrutina TABLA con el valor de Contador como argumento.
movwf PORTB: Mueve el valor desde WREG al puerto B para mostrar el valor del contador en el
display de 7 segmentos.
incf Contador,F: Incrementa el valor de Contador en 1.
movlw .10: Carga el valor 10 en WREG.
subwf Contador,W: Sustrae el valor en WREG de Contador y almacena el resultado en WREG.
btfsc STATUS,Z: Verifica si el bit de cero (Z) en el registro STATUS está configurado. Si es cero,
salta al bucle.
clrf Contador: Borra el registro Contador si el resultado fue cero (vuelve a 0).
goto Bucle: Salta de nuevo al bucle infinito.
TABLA: Esta es una subrutina que utiliza la instrucción addwf PCL,F para realizar un salto a una
tabla de valores en la memoria programada a continuación. Esta tabla almacena los valores de los
segmentos para mostrar los dígitos del 0 al 9 en el display de 7 segmentos.
DT 0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x67: Esta línea define la tabla de valores
para los dígitos del 0 al 9 en formato hexadecimal. Cada valor representa qué segmentos del display
de 7 segmentos deben encenderse para mostrar un dígito específico.
END: Indica el final del programa.

7
 Creación del circuito ejercicio 1

Ahora una vez copiado e incrustado el programa en nuestro c compiler procedemos a compilar y si no
hay errores quiere decir que ya quedo el código listo para ocupar en proteus 8. Ahora procedemos a
abrir el proteus y comenzar a estructurar el circuito de la imagen de arriba es decir quedaría asi.

8
 Electrónica – Explicación de componentes en proteus

Para crear un circuito en Proteus donde un microcontrolador PIC16F628A incrementa un display de 0

a 9 y luego regresa a cero cuando se pulsa un botón, necesitarás los siguientes componentes:

PIC16F628A: Este será el microcontrolador que controlará el display y responderá al botón.

Display de 7 segmentos de anodo común: Utilizaremos este componente para mostrar los dígitos
del 0 al 9.
Botón: Este botón se presionará para incrementar los dígitos en el display.
Resistencias: Puedes necesitar resistencias para limitar la corriente a los segmentos del display y
al botón.
Cristal de reloj (opcional): Si deseas utilizar un oscilador externo para el microcontrolador.

A continuación, te proporcionaré una explicación general de cómo configurar este circuito en Proteus:
• Coloca todos los componentes en la ventana de diseño de Proteus.
• Conecta el pin VDD (alimentación) del PIC16F628A a 5V y el pin VSS (tierra) a GND.
• Conecta un oscilador de 4 MHz (si estás usando un oscilador externo) a los pines OSC1 y OSC2
del PIC16F628A.

• Conecta los pines RA0 a RA6 del PIC16F628A a los segmentos del display de 7 segmentos.
Asegúrate de utilizar resistencias limitadoras para cada segmento.
• Conecta el ánodo común del display al voltaje positivo (5V) y el cátodo común a través de una
resistencia a tierra (GND).
• Conecta un botón entre un pin GPIO del PIC16F628A y tierra (GND). Asegúrate de usar una
resistencia pull-up para este pin para evitar flotación.

Programa el PIC16F628A con el código necesario para realizar la secuencia de contar de 0 a 9 y

luego volver a 0 cuando se presiona el botón. El código dependerá del lenguaje de programación que
estés utilizando (por ejemplo, C, Assembly, etc.). Asegúrate de configurar adecuadamente los pines
de entrada y salida del PIC. Simula el circuito en Proteus para verificar su funcionamiento. Asegúrate
de observar el comportamiento del display y cómo reacciona cuando se pulsa el botón.
Una vez que hayas configurado el circuito y programado el microcontrolador correctamente, deberías
ser capaz de observar el comportamiento deseado: el display incrementará de 0 a 9 cuando se
presione el botón y luego volverá a 0 para comenzar de nuevo.

9
RESULTADO FINAL EJERCICIO 1 FUNCIONANDO

10
 EJERCICIO 2

2.- Realizar un programa para que, al pulsar el botón, se encienda la lámpara

alimentada con corriente alterna.

CODIGO
Ahora bien comenzaremos por copiar el código que a continuación se pondrá en la siguiente imagen,
para ello primero abriremos nuestro programa c compiler para poder incrustar el código y probarlo.

11
 EXPLICACION DEL CODIGO – PROGRAMACION

El código proporcionado es un programa escrito en lenguaje C específicamente para un

microcontrolador PIC18F4550. Este código controla un relé en función del estado de un botón
pulsador. Aquí hay una descripción detallada del código:

#include <18f4550.h>: Incluye el archivo de encabezado para el microcontrolador PIC18F4550.

Este archivo contiene definiciones de registros y configuraciones específicas del microcontrolador.
#fuses XT, NOPROTECT, NOWDT, NOBROWNOUT, PUT, NOLVP: Establece las configuraciones
de los fusibles del microcontrolador. Estas configuraciones determinan aspectos como el tipo de
oscilador (XT en este caso), la protección de código, la vigilancia del perro guardián (WDT), la
protección contra caídas de voltaje y otros.
#use delay(internal=4MHz): Configura el reloj interno del microcontrolador a 4 MHz. Esto se utiliza
para establecer la velocidad de funcionamiento del microcontrolador y de las funciones de retraso.
Definición de los registros de memoria para PORTA y PORTB:
#byte PORTA = 0xf80: Asigna la dirección de memoria 0xf80 al nombre PORTA. Esto se utiliza
para acceder a los pines de salida del puerto A.
#byte PORTB = 0xf81: Asigna la dirección de memoria 0xf81 al nombre PORTB. Esto se utiliza
para acceder a los pines de entrada/salida del puerto B.
Definiciones de macros:
#define Rele PORTA,0: Define un macro llamado Rele que se traduce en el primer bit (bit 0) del
puerto A. Este bit se usa para controlar el relé.
#define Push PORTB,0: Define un macro llamado Push que se traduce en el primer bit (bit 0)
del puerto B. Este bit se usa para leer el estado del botón pulsador.
void main(): Inicia la función principal del programa.
BOOLEAN start = 0;: Declara una variable booleana llamada start e inicializa su valor en 0.
Configuración de los pines como entradas o salidas:
SET_TRIS_A(0);: Configura todos los pines del puerto A como salidas.
SET_TRIS_B(0b00000001);: Configura el primer pin del puerto B como entrada y el resto como
salidas.
PORTA = 0;: Inicializa todos los pines del puerto A en 0.
while(TRUE): Inicia un bucle infinito que se ejecutará continuamente.
Control del botón pulsador:

12
 Si el botón (bit 0 del puerto B) se detecta como presionado (bit_test(Push)), se realiza lo siguiente:
Se espera un retraso de 200 ms (delay_ms(200)) para evitar la detección de rebotes del botón.
Luego, se verifica nuevamente si el botón está presionado en un bucle while para asegurarse de
que el botón se haya soltado completamente.
Cuando el botón se suelta, se invierte el valor de la variable start (start = !start) para cambiar su
estado.
Control del relé:
El relé (bit 0 del puerto A) se activa o desactiva según el valor de la variable start. Si start es
verdadero, se establece el bit (bit_set(Rele)); de lo contrario, se borra (bit_clear(Rele)).
El programa ejecutará este bucle infinito y cambiará el estado del relé cada vez que se presione el
botón pulsador. Esto permite controlar un dispositivo externo conectado al relé a través de la
entrada/salida del puerto A del microcontrolador.

Una vez insertado y configurado el código procedemos a abrir proteus pata hacer el circuito para ello
haremos el dibujo del ejercicio 2 y quedara de la siguiente manera.

13
 Explicación circuito en proteus

Para crear un programa que permita encender una lámpara alimentada con corriente alterna (CA) en
Proteus al pulsar un botón, necesitarás un microcontrolador como Arduino para controlar la lámpara.
A continuación, te proporciono un ejemplo de programa y una descripción general de cómo realizar
esto:

Materiales necesarios:
Placa Arduino (por ejemplo, Arduino Uno).
Lámpara incandescente o LED con su respectiva resistencia de limitación de corriente si es
necesario.
Botón pulsador.
Fuente de alimentación CA.

Pasos para crear el programa:

Conecta la lámpara y el botón a la placa Arduino:
Conecta uno de los extremos de la lámpara al pin de salida digital de Arduino (por ejemplo, Pin
8) y el otro extremo a GND.
Conecta un extremo del botón a GND y el otro extremo al pin de entrada digital de Arduino (por
ejemplo, Pin 2). Asegúrate de usar una resistencia pull-up o pull-down según corresponda para evitar
fluctuaciones en el estado del botón.

Configura los pines:

const int lampPin = 8; // Pin de salida para la lámpara
const int buttonPin = 2; // Pin de entrada para el botón

En el setup(), configura los pines como entrada o salida:

void setup() {
pinMode(lampPin, OUTPUT);
pinMode(buttonPin, INPUT_PULLUP); // Usamos resistencia pull-up interna
}
En el loop(), verifica si el botón está presionado y, si es así, enciende la lámpara:
void loop() {
if (digitalRead(buttonPin) == LOW) {

14
 digitalWrite(lampPin, HIGH); // Enciende la lámpara
} else {
digitalWrite(lampPin, LOW); // Apaga la lámpara
}
}

Carga el programa en tu placa Arduino utilizando el entorno de desarrollo Arduino.

Ahora, cuando pulses el botón conectado a tu placa Arduino en Proteus, la lámpara debería
encenderse. Asegúrate de que la fuente de alimentación CA esté conectada correctamente a la
lámpara para que funcione en el simulador de Proteus.

Recuerda que Proteus es un simulador de circuitos, por lo que podrás verificar el funcionamiento de
tu circuito y programa antes de implementarlo en hardware real.

Resultados del ejercicio 2 - FUNCIONANDO

Ahora bien, una vez terminado de crear el circuito en proteus, procederemos a correr el programa,
para ello antes cargamos el archivo. hex del c compiler, damos doble clic en el pic y en program file
buscamos el archivo .hex de nuestro código y listo le damos play para simular y observamos como
enciende y apaga la lampara.

15
Una vez que hayas completado con éxito la simulación en Proteus y estés seguro de que tu circuito y
código funcionan como se esperaba, puedes proceder a implementarlos en hardware real siguiendo
el mismo diseño y conexiones. Recuerda siempre tomar precauciones de seguridad al trabajar con
corriente alterna y componentes eléctricos en la vida real.

16
(Proteus) (usershop@redusers.com, Servicio de atención al lector: usershop@redusers.com)
(proteus) (proteus e. y., electronica y proteus) (Pasos) (navegador) (C,
rogramación PIC en C) (C P. d., Programación de microcontroladores PIC con Lenguaje C)
Otro Idioma
(manual, c compiler manual) (C++, Un IDE multiplataforma para C y C++ ) (Easy)

Referencias
C, P. d. (Programación de microcontroladores PIC con Lenguaje C). Programación de microcontroladores PIC con
Lenguaje C. Obtenido de
http://repositorio.espe.edu.ec/bitstream/21000/15406/1/Programaci%C3%B3n%20de%20microcontralores%20
tomo%201.pdf

C, r. P. (rogramación PIC en C). rogramación PIC en C. rogramación PIC en C. Obtenido de

http://www.aquihayapuntes.com/programacion-pic-en-c.html?start=10

C++, U. I. (Un IDE multiplataforma para C y C++ ). Un IDE multiplataforma para C y C++ . Obtenido de
https://www.jetbrains.com/es-es/clion/

Easy, P. D. (s.f.). PCB Design & Simulation Made Easy. Obtenido de https://www.labcenter.com/

manual, c. c. (c compiler manual). c compiler manual. Obtenido de

https://www.ccsinfo.com/downloads/ccs_c_manual.pdf

navegador, l. 1. (s.f.). los 10 mejores compiladores de C en línea para ejecutar código en el navegador. Obtenido de
https://geekflare.com/es/best-online-c-compilers/

Pasos, P. C. (s.f.). PIC C Compiler Primeros Pasos. Obtenido de

https://controlautomaticoeducacion.com/microcontroladores-pic/pic-c-compiler/

proteus, e. y. (electronica y proteus). electronica y proteus. Obtenido de

https://www.enerxia.net/portal/index.php?option=com_content&view=article&id=406:electronica-proteus-
simulador-digital-y-analogico&catid=61&Itemid=142

Proteus, S. d. (s.f.). Simulación de un circuito en Proteus. Obtenido de Una vez que hayas completado con éxito la
simulación en Proteus y estés seguro de que tu circuito y código funcionan como se esperaba, puedes proceder
a implementarlos en hardware real siguiendo el mismo diseño y conexiones. Recuerda siempre tomar precauc

proteus, u. d. (s.f.). uso de software proteus. Obtenido de http://e-spacio.uned.es/fez/eserv/taee:congreso-2004-

1034/S1F05.pdf

usershop@redusers.com, S. d. (Servicio de atención al lector: usershop@redusers.com). Servicio de atención al lector:

usershop@redusers.com. Obtenido de
https://www.latecnicalf.com.ar/descargas/material/informaticaelectronica/Proteus%20Introduccion.pdf

17