1

Facultad de telemática

SISTEMAS EMBEBIDOS

4°H

PUENTE MEDINA JOSE MARCOS

Profesor

PRÁCTICA #2

“Calculadora aritmética binaria de 13bits”

EQUIPO #4:

-Alexis Alcaraz Tafoya

-Mayré Orelly Valencia Fletes

-Jonni Eduardo Aguilar

-Aldo Orlando Ayala Gaspar

Introducción

2

En este documento estaremos llevando a cabo una revisión lo más

completa posible de cómo fue que implementamos una calculadora

aritmética binaria, veremos el proceso que tuvimos que hacer para

poder llegar a implementarla, así como también algunas pruebas que

realizamos para verificar el funcionamiento correcto de la calculadora.

Hablaremos un poco sobre algunas características del

microcontrolador que utilizamos para armar nuestra práctica el cual

tiene integrada una función para poder hacer uso de las

interrupciones.

Objetivo

3

Diseñar y programar una calculadora aritmética utilizando los puertos

de entrada y salida del PIC18f4620, la calculadora deberá realizar

operaciones sencillas como suma, resta, multiplicación y división, así

como también tiene que mostrar números negativos en complemento

a 2, además de que la calculadora tendrá que ser montada y puesta

en función.

Índice

Calculadora aritmética práctica #2-------------------------------------------------------------- 5

Características eléctricas-------------------------------------------------------------------------- 6

4

Verificación-------------------------------------------------------------------------------------------- 7

Interrupciones----------------------------------------------------------------------------------------10

Competencias--------------------------------------------------------------------------------------- 11

Observaciones---------------------------------------------------------------------------------------14

Conclusiones-----------------------------------------------------------------------------------------15

Bibliografía--------------------------------------------------------------------------------------------16

Calculadora aritmética práctica #2

● Realizamos nuestro informe de requerimientos. ● Conociendo lo que necesitamos empezamos a hacer el

pseudocódigo. ● Realizamos nuestro código. ● Después armamos el sistema gráfico del circuito en proteus

conectando todos los componentes necesarios en cada puerto

5

correspondiente, usando resistencias entre el microcontrolador y

los leds, también agregamos los botones para manipular los

datos.

● Cargamos el archivo del programa en el proteus para hacer pruebas.

● Después fue prueba y error haciéndole modificaciones al pseudocódigo junto con el código hasta encontrar el mejor funcionamiento posible.

● Teniendo ya el esquema en proteus continuamos a montarlo en una protoboard basándonos en el diagrama del proteus.

● Utilizamos el programa bootloader para programar el pic e hicimos las pruebas necesarias.

Características eléctricas

+Vdd: Tensión positiva de alimentación.(Drenador) -Vss: Tensión conectada a tierra o negativa de alimentación.(Surtidor) +Vcc: (Colector) -Vee: (Emisor) Máxima corriente de salida bajo(PIN) 25mA Máxima corriente de salida alto(PIN) 25mA.

6

Máxima corriente de salida para el vss pin 300mA. Máxima corriente de entrada para el vdd pin 250mA Máxima corriente de salida alto(PUERTO A) 80mA. Máxima corriente de salida bajo(PUERTO A) 50mA. Máxima corriente de salida alto(PUERTO B) 150mA. Máxima corriente de salida bajo(PUERTO B) 100mA.

Verificación

Primera

Resta (1b - 10b)

A la hora de realizar la siguiente operación (1b - 10b) nos da como

resultado los primeros 8 bits en alto, afectando también los botones,

ya que estos dejan de funcionar.

7

Solución

Tuvimos que cambiar la forma en que declaramos los botones, en un

principio se declararon de esta forma: interruptor=input_b(); con esto

estamos diciendo que la variable “interruptor” era igual a lo que entra

por el puerto “B” y después hacíamos la evaluación de la variable con

un switch, pero cuando mostrabamos un resultado que abarcaba hasta

los 2 primeros bits del puerto “B”, provocándose un cambio de estado

en alto, hacía que la variable “interruptor” sea equivalente a una

cantidad la cual no está dentro de la evaluación de los casos del

switch y que además no tiene caso agregarla ya que si lo hiciéramos

estaríamos haciendo mucho más extensa la evaluación y no tiene

caso hacerlo así.

Cambiamos ese código por la declaración de control IF, y hacemos

una evaluación directa de los botones en los pines del pic, y así nos

evitamos volver a tener el mismo problema que teníamos

anteriormente.

Este sería el nuevo código:

if(input(pin_b4)==0)

interruptor=1;

if(input(pin_b5)==0)

interruptor=2;

if(input(pin_b6)==0)

interruptor=3;

if(input(pin_b7)==0)

8

interruptor=4;

Segunda

Multiplicación (0111 1111b x 1000 0000b).

A la hora de realizar esta multiplicación nos debería de dar como

resultado: 11 1111 1000 0000b, por lo tanto, se tendría que poner en

alto los últimos 6 bits porque el resultado lo estamos truncando a solo

13 bits, pero en este caso el problema es que solo está encendiendo

el bit número 8.

Solución

En este caso era un problema simple ya que solo teníamos que

modificar el ancho de las variables antes de hacer cualquier operación

o hacerle lo que llamamos un casting, que es una conversión de

variables, por lo tanto, cada operación quedaría de esta forma:

resultado=(int16)datoC - (int16)datoD;

Tercera

Resta (011100b – 100001b)

Al realizar esta receta nos tendría que dar como resultado un número

negativo ya que el puerto “C” está fungiendo como el minuendo de la

9

resta y el puerto “D” es el sustraendo, por lo tanto, el minuendo es

menor que el es sustraendo así que como resultado tendría que

mostrar un número negativo directamente en complemento a 2, es

decir, que nosotros no tuvimos que hacer la programación para

calcular el complemento a 2, ya que la ALU del pic por naturaleza

muestra todos los números negativos en complemento a 2 y esto no

solo es para la resta sino que también funciona para cualquier

operación que realice.

Interrupciones

Una interrupción es un aviso provocado por un módulo del PIC, por un cambio en el estado de un pin o un recordatorio de que ha pasado un cierto tiempo. Como su nombre indica este aviso interrumpirá la tarea que se este haciendo en ese momento y pasaremos a ejecutar una rutina de servicio o gestión de la interrupción. Existen varios tipos de interrupciones, pero nosotros estaremos usando la Interrupción por cambio de estado lógico en el puerto “B” en los pines RB4 a RB7. La ventaja de utilizar interrupciones es que mientras se espera a que se presente el evento que produce la interrupción el microcontrolador puede estar ejecutando cualquier otra tarea. De ese modo el micro no esta ciclado en una sola tarea sino que puede seguir trabajando en otras hasta que una interrupción haga que el programa salte y ejecute la tarea que se quiera y al terminarla el programa continuará su

10

ejecución en el punto en el que se encontraba en el momento de presentarse la interrupción. Para habilitar las interrupciones por cambio de estado de RB4-RB7.

La directiva usada es #INT_RB y se debe acompañar de las siguientes funciones:

Habilitar el bit de habilitación global de interrupciones GIE del registro INTCON (enable_interrupts (GLOBAL)).

● GIE: Permiso global de interrupción. 1 – Permite todas las interrupciones. 0 – Prohíbe todas las interrupciones.

Habilitar el bit correspondiente a cada interrupción particular (enable_interrupts (INT_RB)).

● RBI: Permiso de interrupción por cambio de estado en RB7:RB4. 1 – Permite la interrupción. 0 –Prohíbe está interrupción.

Limpiar la bandera correspondiente a la interrupción habilitada para evitar falsas interrupciones. Cuando esto suceda es fundamental que en dicha posición tengamos un código válido para gestionar la interrupción. A dicho código se le denomina rutina de servicio de la interrupción (Interrupt Service Routine o ISR).

Competencias

1. ¿Qué lógica reciben las entradas de datos para las operaciones aritméticas con los interruptores en configuración Pull-Down?, justifique la respuesta. En la configuración pull down, cuando el circuito está en reposo, la caída de tensión en la resistencia es prácticamente 0V (low o cero lógico), en cambio si pulsamos P1, dejará pasar la corriente y tendremos una diferencia de potencial de 5V (high o uno lógico).

2. ¿Qué es el efecto de rebote en los interruptores de presión? Y ¿cómo fue eliminado este efecto en el diseño electrónico? Es un efecto mecánico-eléctrico que se presenta cuando se cierra o se abre un interruptor, aunque uno sabe que se está presionando el botón, a nivel microscópico hay pequeños rebotes mecánicos, es decir el contacto se cierra y se abre varias veces antes de quedar en la

11

posición final. Esto se traduce en un pequeño tren de impulsos en lugar de un cambio de nivel simple. El fenómeno se puede dar tanto al cerrar el circuito como al abrirlo.

Este efecto fue eliminado utilizando un arreglo RC, el cual conectamos a la salida del botón una resistencia a tierra y un capacitor a la corriente.

3. ¿Qué técnica fue empleada en el programa para monitorizar la actividad de los interruptores de presión que seleccionan la operación aritmética a ejecutar? Utilizamos el método de interrupciones por cambio de estado lógico en los puertos RB7:RB4.

4. ¿Cuál es la máxima magnitud sin signo (en su equivalente decimal) posible de representar con 13 bits? 0 a 8,191.

5. ¿Cuál es el rango de representación en C-2 para n=13 bits?

-4,09610 ≤ X ≥ 4,09510

6. Represente -22510 en C-2 para n=13 bits. 1 1111 0001 1111

7. Calcular la resistencia necesaria para suministrar 6.5 mA a uno de los 13 LEDs, considerando VOH =5.0V y VD = 1.8V. 5.0v - 1.8v = 3.2v R=Vr/I R= 3.2v/6.5mA R= 492ohm

8. ¿Cuáles son las directivas de preprocesamiento mínimas indispensables para compilar un programa funcional en lenguaje C? Todas las directivas de preprocesador o comandos inician con un #. La directiva #define especifica un nombre que será reemplazado por un cierto valor en todos los lugares del programa donde se haga referencia. La directiva de preprocesador #include se usa para “incluir” las declaraciones de otro fichero en la compilación. Cuando el preprocesador encuentra una línea #include <fichero>, entonces reemplaza esta línea por el fichero incluido. #fuses Esta directiva define qué fusibles deben establecerse en la parte cuando está programado. #use.

12

9. ¿Qué es el proceso de depuración? El proceso de prueba suele desvelar errores, un término genérico que abarca todo lo que hace su programa que no se esperaba que hiciese. Al proceso de suprimir estos errores del programa se conoce como la depuración.

10. Indique diferencias, ventajas y desventajas de la simulación y la emulación. El simulador imita el funcionamiento del programa, el emulador imita los sistemas de hardware como un pic, la ventaja del simulador es que podemos ver el comportamiento del proyecto antes de ensamblarlo y asi estar seguro de que no hay errores y al final ensamblarlo. La ventaja del emulador es que podemos usar para ver el funcionamiento de algún sistema que no se conocía, la desventaja es que podría no imita el 100% de lo que quiere emular.

una desventaja del simulador es que hay casos en que un bug pueda afectar en el funcionamiento del proyecto.

11. ¿Por qué razón es importante la simulación antes de la programación del firmware en el sistema embebido? Para comprobar el funcionamiento del programa y detectar errores en el mismo.

13

Observaciones

Lo que más me causó curiosidad fue el tema de las interrupciones ya que nunca había escuchado que se realizan interrupciones; otro tema que igual me causo curiosidad fue la realización de la práctica de manera física.

-Mayré Orelly Valencia Fletes

Durante la práctica se me hizo muy interesante el comprender el funcionamiento de la calculadora binaria, y trabajar con el complemento A2, así como el análisis de las interrupciones, ya que son algo complejas de entender, pero muy útiles ya

que ahorran trabajo y código. -Alexis Alcaraz Tafoya

Durante la práctica, observamos que el funcionamiento del esquema funcionaba en ciertos puntos al hacer operaciones, había errores y se tuvo que modificar el

código, y volver a hacer el test. -Aldo Orlando Ayala Gaspar

Al realizar la práctica tuvimos la necesidad de implementar resistencias para

protección del micro, pero procurando no afectar el rango del voltaje entre 2,2V y 5V para así alcanzar lo que sería el 1 lógico, por eso conectamos resistencias

para suministrar los switches y además del otro extremo conectamos otras resistencias a tierra para que así no quedarán flotando los pines y con esto dimos

lugar a lo que sería un divisor de voltaje lo que quiere decir que una parte del

14

voltaje se reparte a la resistencia y otra entra al pic, así que las resistencias no tienen que ser muy grandes para que podamos alcanzar el 1 lógico.

Jonni Eduardo Aguilar

Conclusiones

Esta práctica logre comprender la funcionalidad de una calculadora por medio del PIC, vimos algunos métodos para lograr que funcionara, hubo errores al hacer el test y se tuvo que modificar el código, pero en algunos casos las operaciones si las realizaba bien. -Aldo Orlando Ayala Gaspar Al realizar esta práctica comprendí cómo funciona realmente una calculadora binaria; para programar era hacerlo con la lógica normal de una calculadora, pero de manera binaria, pero al realizar la práctica de manera física fue algo más tedioso, ya que cualquier movimiento brusco o inconsciente podíamos desconectar algún cable, circuito o led; por tal motivo fue algo más tedioso esta realización. -Mayré Orelly Valencia Fletes

15

Conocí algunos conceptos nuevos para mí dentro de la programación del PIC para

esta práctica, como lo es el PullDown, Efecto Rebote, Directivas De Pre-

Procesamiento, y sobre todo las Interrupciones, cómo es que se activan y se

manejan cada una de ellas y los diferentes tipos que podemos utilizar. Fue un

poco tedioso para mi, ya que no tenía bien definido estos conceptos, y me

producían errores al momento de pasarlo a código, de ahí en más fue interesante

el comprender cómo es que funciona una calculadora binaria desde operaciones

básicas.

-Alexis Alcaraz Tafoya

Con esta práctica aprendí cómo usar y administrar los puertos para establecerlos

de cualquier forma en que sean necesarios, también la importancia del uso de

resistencias para proteger la corriente que entra al microcontrolador y algo muy

importante, el complemento a 2, ya que este por default ya viene integrado por

naturaleza en los microcontroladores para mostrar números negativos.

Jonni Eduardo Aguilar

Bibliografía

https://www.tutorialesprogramacionya.com/cmasmasya/detalleconcepto.php?punto

=55&codigo=186&inicio=45

https://trucosinformaticos.wordpress.com/2012/10/14/como-usar-include-en-c-y-c/

https://arde.cc/foro/viewtopic.php?t=2305

https://programarfacil.com/blog/arduino-blog/resistencia-pull-up-y-pull-down/

https://www.fing.edu.uy/inco/cursos/firmware/teorico/clase05-manejoES.pdf

http://www.cortoc.com/p/digital.html

https://www.ibm.com/support/knowledgecenter/es/SSQ2R2_9.5.1/com.ibm.etools.

pl1.win.doc/topics/debug.html

16

http://www.aquihayapuntes.com/indice-practicas-pic-en-c/interrupcion-cambio-de-

estado-rb4-rb7.html

http://www.circuitoselectronicos.org/2011/03/manejo-de-interrupciones-en-los.html