ex7 de sistemes electrònics digitals - upcdigsys.upc.es/ed/sed/grups_classe/05-06_q1/2at4/... ·...

EX7: MICRO Pràctica 3: Temporitzador. Versió 1

1

EX7 de Sistemes Electrònics Digitals

GRUP: 2 Components: -Carlos Asensio Ruiz -Oscar Sánchez Cañadas -Raquel García Sánchez DATA: 02/12/05 Descripció breu de les aportacions realitzades : Análisis de programas en ensamblador. Análisis de circuito de actuación de la carga potencia y comportamiento de sus componentes. Compilación y simulación del proyecto mediante Proteus. Ampliación del proyecto: subrutinas de temporización, saltos indexados, tablas de datos. Ventajas e inconvenientes. TEMPS D’ESTUDI I DE PREPARACIÓ DE L’EXERCICI:

Sessions TGA a l’aula: 2h Sessions TGB al laboratori 4h Sessions TGC fora de l’horari 3h Treball individual Estudiant 1: Estudiant 2: Estudiant 3: Estudiant 4:

6h 4h 4h

Temps total (per estudiant) 16h CONTINGUT DE L’EXERCICI

MICRO_PRÀCTICA 3: TEMPORITZADOR. VERSIÓ 1 ...................................................................4 DESCRIPCIÓ DE LA PRÀCTICA: ...................................................................................................................4 CONCEPTES RELACIONATS AMB AQUESTA PRÀCTICA/PROBLEMA:.............................................................4 MATERIAL NECESSARI...............................................................................................................................4 GUIÓ INICIAL DE LA PRÀCTICA / PROBLEMA: .............................................................................................4

El projecte a dissenyar .........................................................................................................................4 L’anàlisi del circuit d’actuació de la càrrega de potència...................................................................5 La compilació inicial del projecte ........................................................................................................5 El procés de “debugging” a través de l’execució pas a pas ...............................................................6 El muntatge del prototip .......................................................................................................................6 L’ampliació del projecte (programació en assemblador) ....................................................................6

EPSC – SED: Sistemes Electrònics Digitals

2

ANÁLISIS DEL PROGRAMA EN ENSAMBLADOR ..........................................................................7

ANÁLISIS DEL CIRCUITO DE ACTUACIÓN DE LA CARGA DE POTENCIA............................8

COMPILACIÓN INICIAL DEL PROYECTO.....................................................................................12

PROCESO DE “DEBUGGING” ............................................................................................................12

AMPLIACIÓN DEL PROYECTO.........................................................................................................15 CÓDIGO EN ENSAMBLADOR .....................................................................................................................19 CÁLCULO DE CICLOS MÁQUINA..............................................................................................................23 SIMULACIÓN EN PROTEUS .......................................................................................................................24

CONCLUSIONES....................................................................................................................................26


3

MOLT IMPORTANT: Aquest curs s’espera de vosaltres que ja prepareu i editeu textos de certa qualitat, per tant: preneu aquest document de plantilla d’estils i formats. Amplieu-lo i modifiqueu-lo per plantejar, desenvolupar, solucionar i verificar el funcionament del vostre disseny. Passeu el corrector ortogràfic i repasseu la gramàtica tant si escriviu en anglès, castellà o català. Fixeu-vos també que l’índex de contingut de l’exercici es genera automàticament si respecteu els estils: Normal, Títol 1, Títol 2 i Títol 3. D’una forma similar, heu de respectar l’estil del peu de figura (Llegenda) i les referències creuades a les figures que s’actualitzen automàticament quan n’inseriu de noves. Consulteu-nos també qualsevol dubte que tingueu sobre l’edició de documents i aquesta plantilla en particular. Tingueu en compte les anotacions i indicacions que us han fet els professors en els vostres treballs previs, per tal de no cometre les mateixes errades en aquest treball ACTIVITATS Qui Què Com Quan Grup de treball cooperatiu

Edició impresa (primera versió) de l’informe de l’exercici. Imprimiu la pàgina 1 i 2 amb l’índex i a partir de la pàgina 6

Amb la plantilla i seguint el documents de criteris de qualitat

Abans de la data límit

Els professors o els companys a través d’una correcció creuada

Correcció de la primera versió

Amb la plantilla d’avaluació

Com a màxim una setmana desprès del lliurament de la primera versió impresa

(amb caràcter voluntari)1 Grup de treball cooperatiu

Edició electrònica (segona versió) del document complet amb la incorporació de les millores assenyalades pels correctors

Amb un generador de fitxers PDF

Com a màxim una setmana desprès del lliurament de la correcció. S’enviarà per correu electrònic als professors.

Professors Penjar a la web de SED el document per evidenciar el treball desenvolupat

A través d’un enllaç al document a l’apartat de Grups de Classe

Durant el quadrimestre

1 És clar que la realització d’aquesta feina addicional millora la qualificació de l’exercici


4

MICRO_Pràctica 3: Temporitzador. Versió 1

Descripció de la pràctica:

Es tracta de realitzar l’edició, compilació, simulació i gravació d’un programa senzill en llenguatge assemblador sobre un PIC16F84A, abans de passar al tema de les interrupcions. En aquesta ocasió també s’introduirà l’anàlisi del driver de potència que activa un motor de corrent continu a través dels senyals produïts pel sistema microcontrolador. A més. es farà un pas més cap a la clarificació del projecte assemblador a través de la utilització de noves directives i l’estructuració del programa amb subrutines. El grup de treball usarà la seva iniciativa per acabar el projecte amb més prestacions. S’usarà l’entorn de desenvolupament integrat MPLAB-IDE i també el laboratori virtual Proteus-VSM, per verificar el funcionament final del disseny abans de la gravació final del microcontrolador. El prototip final es muntarà finalment al laboratori sobre la placa PIC Millennium Board de BlueBird Electronics , la PICDEM2 DE Microchip, o bé directament sobre el vostre board de pràctiques. Conceptes relacionats amb aquesta pràctica/problema:

L’arquitectura interna del sistema microcontrolador PIC16F84A; el repertori d’instruccions en assemblador; la utilització de directives d’assemblador; la utilització de subrutines per clarificar el programa; el control dels ports d’entrada i sortida per senyals digitals; la generació de retards aproximats; el càlcul del temps de cicle de programa; l’activació de càrregues de potència connectades al sistema microcontrolador. Material necessari

- PIC 16F84A - Visualitzador de 7 segments - LED’s vermells o verds - Altres components senzill del kit de pràctiques de quadrimestre 1A

Guió inicial de la pràctica / problema:

El projecte a dissenyar

A) Doneu tots els passos necessaris per arrencar el projecte “PIC_ASM_Practica_2” mostrat a la Fig. 1. Imprimiu-vos i analitzeu el programa assemblador que governa el PIC. Dibuixeu el seu diagrama de flux.


5

DIS[6..0]

DIS6DIS5DIS4DIS3DIS2DIS1DIS0

TIMER

CCT001

S1

S2TIME_OUT

ON

TRIGGER

RESET

VDC

Q1BC547

DIS[6..0]

b

g

a

1N914

R210k

DC-MOTOR

48V

R12

2.2k

RELE6V

Vdc1

B148V

GND

VDC

Fig. 1 Projecte a dissenyar a través d’un microcontrolador PIC

L’anàlisi del circuit d’actuació de la càrrega de potència

B) Analitzeu el circuit de la càrrega, expliqueu el seu funcionament i proveu-lo en Proteus-VSM per veure com s’acciona el motor a través d’un polsador. Calculeu el corrent de base IBQ1, de col·lector ICQ1 i el corrent del motor2 quan està activat. Verifiqueu els valors obtinguts a través de la simulació. Descriviu l’efecte d’amplificador de corrent i d’aïllament galvànic que realitzen el transistor i relé per actuar sobre la càrrega de potència amb separació de masses.

La compilació inicial del projecte

C) Compileu el projecte inicial amb MPLAB i imprimiu el report com el de la Fig. 2 que us dóna per comprovar que a partir d’ara podeu ampliar el disseny amb les vostres instruccions. Es recomana penjar el directori del projecte prop del directori arrel del disc dur, per exemple: C:\SED_PRACT/PIC\PIC_ASM_Practica_2

Fig. 2 Exemple de resultat de la construcció total del projecte (Build All)

2 Cerqueu a la bibliografia o bé a la Internet com està dissenyat un motor de corrent continu i quines són les equacions que governen el seu funcionament.


6

El procés de “debugging” a través de l’execució pas a pas

D) Proveu a través del Proteus-VSM el funcionament pas a pas del programa i la col·locació de “breakpoints” per aturar el programa a l’adreça o instrucció desitjada. Vegeu també la finestra que mostra el contingut de les variables que useu en la subrutina de temporització.

El muntatge del prototip

E) Graveu a través del mateix MPLAB amb el programador PICSTART (o bé amb el vostre propi gravador) un PIC 16F84A i munteu el circuit directament en el vostre board de laboratori. Podeu suposar, per simplificar que en lloc d’un relé i la càrrega teniu un simple LED.

F) (Extra) Imprimiu l’esquema de la targeta d’entrenament BlueBird PIC- Millennium3.

Modifiqueu el circuit, tant el connexionat com el programa, si fa falta, per tal de fer córrer el disseny sobre aquesta targeta i així no haver d’usar el board de laboratori que sempre acostuma a portar problemes de contactes.

L’ampliació del projecte (programació en assemblador)

G) Calculeu exactament els temps associats a cada instrucció per tal de programar amb exactitud els 15 segons de temporització4. Descobriu la fórmula que us permet variar fàcilment aquest període de temporització i expliqueu de quines variables depèn. Com podríeu millorar la precisió del sistema temporitzador?

H) Dissenyeu codi assemblador per tal de representar amb els segments del visualitzador una certa

seqüència mentre està temporitzant. Per exemple, la seqüència de segments representada a la Fig. 3 que segueix el sentir de gir horari. Podeu fer, per exemple que els segments s’il·luminin cada 0,5 s.

1) 2) 3) 4) 5) 6) 1) ,etc.

Fig. 3 Seqüència de segments mentre temporitza per indicar activitat.

3 La documentació de la targeta PIC MILLENNIUM juntament amb el seu esquema la teniu disponible a la Unitat didàctica 2.5 de SED 4 Estudieu per exemple el “Capítulo 12: Subrutinas de retardo” del llibre “Microcontrolador PIC16F84, desarrollo de projectos”, E. Palacios, F. Remiro, J. L. López, RA-MA, 2004, referenciat també a la web de SED i que té també una web associada i molta informació sobre programació en assemblador del PIC.


7

Análisis del programa en ensamblador

Hemos impreso y analizado el código llegando a este diagrama de flujo:

Fig. 4 Diagrama de flujo del código en ensamblador

START

CONFIGURAR PORTB CONFIGURAR PORTA

S2 PULSADO?

SI

DESACTIVAR TIMER_OUT NO TEMPORIZAR VISUALIZAR TEMPORIZAR

NO

ACTIVAR TIMER OUT

TEMPORIZAR 7s

DESACTIVAR TIMER OUT

S2 SOLTADO?

NO

SI

NO TEMPORIZAR VISUALIZAR TEMPORIZAR

1

1


8

En el PIC se ha configurado la línea RA0 como la salida Timer_out, la línea RA1 como la entrada S2 y las líneas RB[1..7] como salida para los segmentos del display.

Fig. 5 Líneas de conexión en el PIC

Análisis del circuito de actuación de la carga de potencia

Mediante la salida del Timer_out controlamos el comportamiento de un motor de corriente continua. Tenemos un circuito de carga de potencia que es el que situamos entre la salida del PIC y el motor.

Fig. 6 Circuito de actuación de carga de potencia


9

Analizamos la parte del circuito que está conectado al PIC, y calculamos la corriente de base IB y la corriente de colector IC. Para ello nos basamos en las ecuaciones fundamentales del transistor BC547 cuyo esquema es el siguiente:

Fig. 7 Esquema de las partes del transistor

Siendo VBE = 0.85V y VO = 5V (voltaje de salida del PIC cuando tiene activada su salida a nivel alto) tenemos que:

mAR

VVI BEOB 89,1

102,285,05

312

=⋅

−=

−=

Y sabemos que: BC II ⋅= β Hemos medido la corriente IC en el Proteus, mediante un amperímetro (Current probe):

Fig. 8 Corriente de Colector medida en Proteus

Por lo que nuestro parámetro de amplificación de corriente ( β ) es:


10

η⋅=

VPI

81,361089,11058,69

3

3

=⋅⋅

== −

−

B

C

II

β

Comprobamos el valor de IB en Proteus:

Fig. 9 Corriente IB medida en Proteus

La corriente que circula por el motor, según el Proteus es:

Fig. 10 Corriente que circula por el motor dc

Este valor de corriente no lo hemos podido comprobar teóricamente ya que no sabemos con exactitud de qué manera modela el Proteus este motor internamente. Una ecuación que podemos utilizar para calcular la corriente absorbida por un motor eléctrico de corriente continua es: P = potencia motor (kW). V = tensión de linea (V). η = rendimiento del motor.


11

El aislamiento galvánico que realizan el transistor y el relé nos facilita una separación de masas sobre el circuito de la carga y el circuito del PIC, es decir, al ser las corrientes con las que trabajamos en el circuito de carga del orden de amperios y las corrientes del circuito del PIC del orden de miliamperios, nos conviene mantener separados los puntos de referencia de ambos circuitos ya que así evitaremos cualquier tipo de inconveniente a la hora de que funcionen adecuadamente.


12

Compilación inicial del proyecto

Compilamos el proyecto en el MPLAB, con la opción Project -> Build All y tendremos el siguiente archivo resumen de la operación realizada:

Fig. 11 Resultado compilación del proyecto

Con esto nos habrá creado un fichero *.HEX que será el que utilizaremos para grabar en nuestro PIC mediante un grabador.

Proceso de “debugging”

Una vez ya compilado el proyecto, vamos al Proteus-VSM para hacer una ejecución paso a paso mediante el Debugger. Vamos a colocar un breakpoint en la instrucción que se ejecuta justo cuando presionamos el pulsador del Trigger y observaremos la ejecución del código instrucción por instrucción con la tecla F11. Dos instrucciones más tarde del breakpoint observamos en la Fig. 12 como se ha cambiado el valor del PORTA con lo que hemos activado el circuito que hará moverse al motor. A continuación nos vamos a la subrutina de retardo. Una vez hemos ejecutado las instrucciones de inicio de la subrutina y estamos en el “bucle_delay1” podemos apreciar en la Fig. 13 dentro de la CPU Data Memory como se han cargado los valores que le hemos asignado (Delay2 d’200’ = h’68’ y Delay1

d’249’ = h’F9’) en las posiciones que asignamos en el código: 0x0C y 0x0D.


13

Fig. 12 Primer breakpoint en el código ensamblador

Fig. 13 Valores de las variables de la subrutina de retardo cargados en memoria

En la Fig. 14 dejamos correr la simulación hasta el siguiente breakpoint y podemos ver como está el segmento ‘a’ del display encendido, indicando que se está ejecutando la temporización.


14

Fig. 14 Segmento del display indicando temporización

En la siguiente figura ( Fig. 15 ) vemos como las variables de memoria están a cero y como el segmento del display que está encendido es el ‘g’, indicando que la temporización ha terminado.

Fig. 15 Simulación una vez concluidas las rutinas de temporización


15

cmf

Tiempo ⋅⋅=14

Ampliación del proyecto

Vamos a ampliar nuestro proyecto inicial de manera que la temporización sea de 15 segundos y para ello nos basamos en los ciclos máquina. El ciclo máquina es la unidad básica de tiempo que utiliza el PIC y se corresponde con 4 ciclos de reloj en el PIC16F84A. En nuestro caso, la frecuencia del reloj es de 4 MHz, por lo que la duración de un ciclo de reloj es de 0,25 μs y la de un ciclo máquina de 1 μs. De aquí podemos deducir el tiempo que el PIC tarda en ejecutar una tarea es: Siendo:

• f, la frecuencia del oscilador. • cm, el número de ciclos máquina que tarda en ejecutar la tarea.

Las instrucciones que procesa el PIC necesitan 1 ciclo máquina para ejecutarse, excepto las de salto (goto, call, return, etc) que necesitan de dos ciclos máquina. Vamos a crear un fichero llamado “RETARDO_15S.INC” donde estará el código de nuestra subrutina de retardo que incluiremos en nuestro programa principal, ganando claridad y legibilidad en el código. Esta rutina estará compuesta por una rutina principal de retardo de 15 segundos y otra subrutina que incluiremos dentro de esta para que cada vez que pasen 0,5 segundos nos vaya activando los distintos segmentos del display, de forma que de una sensación de movimiento. El funcionamiento de la subrutina que nos retardará 15 segundos esta basado en una estructura de bucles mediante tres lazos anidados. El lazo interior nos retarda un total de 1ms. El lazo intermedio repite el lazo interior 100 veces, por lo que tendremos 100 ms = 0,1 s. Y por último el lazo exterior repetirá el lazo intermedio 150 veces, teniendo así los 15 segundos deseados. El funcionamiento de esta subrutina de retardo nos quedará más claro si observamos su diagrama de flujo que ya incluye la llamada a la subrutina secundaria de activación de los segmentos del display. Podemos observar las líneas que encierran a los tres bucles y como gracias a tan solo tres contadores conseguimos aumentar el número de iteraciones que realizaremos en total.


16

Fig. 16 Diagrama de flujo de la subrutina “RETARDO_15S.INC”

Call Retardo_15s

Contador Activación Display = CNTLED Contador Segmento Display = MAXLEDACT

Contador ContN = RN

ACTIVACIÓN DISPLAY

Contador ContM = RM

Contador ContK = RK

Pequeño Tiempo de Espera

Decrementa ContK

ContK = 0 ?

NO

SI

Decrementa ContM

ContM = 0 ?

Decrementa ContN

ContN = 0 ?

NO

NO

SI

SI

RETURN


17

Para la subrutina secundaria de Activación Display aprovechamos el diseño de la subrutina principal: sabemos que cada vez que se ejecute la instrucción que llama a la subrutina secundaria habrán transcurrido 0,1 s. Tan solo tenemos que usar un contador que vaya de cinco a cero para saber cuando han transcurrido 0,5 s. Cuando ya sabemos que han transcurrido esos 0,5 s y queremos activar un segmento del display, tenemos otro contador que llega hasta 6 (el display tiene 7 segmentos, pero el segmento ‘g’ no lo encendemos). En función del valor que tenga este contador activaremos un segmento u otro del display. El diagrama de flujo de esta subrutina es el siguiente:

Fig. 17 Diagrama de flujo de la subrutina secundaria que determina cuando iluminar los segmentos del display

Call ACTIVACIÓN DISPLAY

Decrementar contador Activación Display

Act. Display

= 0 ?

NORETURN

SI

Contador Activación Display = CNTLED

ILUMINACIÓN DISPLAY

Decrementar contador Segmento Display

Seg. Display

= 0 ? Contador Segmento Display = MAXLEDACT

SI

NO

RETURN


18

Observamos el funcionamiento de esta subrutina que se usa de los servicios de la subrutina “Iluminación Display” para visualizar el segmento que toca. El funcionamiento de esta última subrutina está basado en los llamados saltos indexados. Un salto indexado es una técnica que permite resolver problemas que puedan ser representados mediante una tabla de verdad. En nuestro PIC utilizamos la instrucción addwf PCL,f . Con esta instrucción lo que hacemos es sumarle al registro PCL (contador del programa, próxima dirección de memoria a la que iremos) el contenido del acumulador W, con lo que la siguiente dirección a la que saltaremos será a la PCL+W. En nuestro caso, el valor que añadiremos al W para que nos sirva como salto será el valor del contador Segmento Display, que solo toma valores del ‘6’ al ‘0’. Combinamos la técnica del salto indexado con el manejo de tablas de datos, es decir, hacemos que el salto indexado lo haga un subrutina, por lo que usaremos la instrucción retlw k ( Return with k in W), cuyo funcionamiento es similar al return: retorna (sale) de la función con el valor k en el acumulador. En nuestro caso, crearemos una tabla con los valores en binario que usaremos para encender cada uno de los segmentos del display. Vemos su implementación en código ensamblador en la siguiente figura.

Fig. 18 Código ensamblador de la subrutina para seleccionar el segmento de display que se iluminará


19

Vemos como antes de entrar en la subrutina de iluminación del segmento, cargamos el W con el valor del contador que nos hará de índice para saltar a una posición u otra de la tabla de datos que tenemos creada con los distintos valores en binario de los segmentos del display. Cuando entremos en la subrutina, ejecutaremos la instrucción que sumará el contenido de W al registro PCL. En el primer caso, cuando el contador “LEDACT” =’6’, saltaremos a la posición de memoria PCL+6, con lo que ejecutaremos solo la instrucción retlw que queremos, en este caso la correspondiente al segmento ‘a’.

Código en ensamblador

El código en ensamblador de nuestro fichero de subrutina “RETARDO_15S.INC” es el siguiente:

;**************** LIBRERIA DE RETARDO DE 15 SEGUNDOS *********************************** ; ; Esta subrutina esta compuesta de 2 subrutinas: la primera nos retarda 15 segundos y la ; segunda, ke va dentro de la primera, nos dirá cuando activar un segmento u otro del display ; cada 0,5 segundos, dando sensación de movimiento. La activación la hacemos mediante otra subrutina, ; usando saltos indexados y tablas de datos. ; ;DEFINICIONES -------------------------- RN EQU d'150' ; valor de RN RM EQU d'100' ; valor de RM RK EQU d'249' ; valor de RK CNTLED EQU d'5' ; valor Maximo del Contador de LEDs MAXLEDACT EQU d'6' ; valor Maximo de LEDs que giraran ;VARIABLES ----------------------------- CBLOCK ContK ; Variable del bucle interior, de 1 ms ContM ; Variable del bucle intermedio, de 100 ms ContN ; Variable del bucle exterior, de 15 s ContLED ; Variable que nos contará los 0,5 s LEDACT ; Variable que nos dira que segmento del display iluminar ENDC ;RETARDO 15 SEGUNDOS ------------------- Retardo_15s ; La llamada "call" aporta 2 cm movlw CNTLED ; Pongo el Valor Maximo del contador en W movwf ContLED ; y lo paso a la variable ContLED movlw MAXLEDACT ; Pongo el valor Maximo a los LEDs que giraran movwf LEDACT movlw RN ; Aporta 1 cm movwf ContN ; Aporta 1 cm R1Decima_BucleExterno2 call Baile_LED movlw RM ; Aporta RNx1 cm movwf ContM ; Aporta RNx1 cm R1Decima_BucleExterno


20

movlw RK ; Aporta RMxRNx1 cm movwf ContK R1Decima_BucleInterno nop ; Aporta RKxRMxRNx1 cm decfsz ContK,F ; (RK-1)xRMxRNx1 cm si no salta + RMxRNx2 cm al saltar goto R1Decima_BucleInterno ; Aporta (RK-1)xRMxRNx2 cm decfsz ContM,F ; Aporta (RM-1)xRNx1 cm si no salta + RNx2 cm al saltar goto R1Decima_BucleExterno ; Aporta (RM-1)xRNx2 cm decfsz ContN,F ; Aporta (RN-1)x1 cm si no salta + 2 cm al saltar goto R1Decima_BucleExterno2 ; Aporta (RN-1)x2 cm return ; Aporta 2 cm ; ; En total, esta subrutina tarda: ; Para RN = 150, RM = 100 y RK = 249 ; Ciclos Maquina = 2 + 1 + 2 + (2 + 4xRN + 4xRNxRM + 4xRKxRMxRN) = 15000607 cm ; Tiempo = (4 x cm )x( 1 / 4MHz) = 15 segundos. ; --------------------------- ; Subrutina saber cuando tenemos que iluminar el segmento que toque del LED ; --------------------------- Baile_LED decfsz ContLED ; decremento el contador, solo quiero entrar 1 de cada 5 veces return CambiarLED movlw CNTLED ; restauro el valor maximo movwf ContLED movf LEDACT,W ; Cargo el acumulador con el valor del LED que toque iluminar call Led_Actual ; Vamos a la rutina de seleccionar el valor del segmento del display que toque movwf PORTB ; Lo visualizamos decfsz LEDACT ; Decremento el valor del LED. Si llega a cero voi a Fijar_MAX_LED return Fijar_MAX_LED movlw MAXLEDACT ; Restauro el valor Maximo del contador de LEDs movwf LEDACT return ; --------------------------- ; Subrutina para seleccionar el LED que toca iluminar ; --------------------------- Led_Actual addwf PCL,F ; Sumo al registro PCL el contenido de W, con lo que nos hara un salto indexado.< Codigos retlw b'10000000' ; g --> no se usará, gracias al contador, pero hay que ponerlo ; para que el salto del PCL pueda encontrar la ultima instruccion, la de la 'a' retlw b'01000000' ; f retlw b'00100000' ; e retlw b'00010000' ; d retlw b'00001000' ; c retlw b'00000100' ; b retlw b'00000010' ; a

Fig. 19 Código ensamblador del fichero “RETARDO_15S.INC”


21

El código en ensamblador de nuestro programa principal, desde el que incluiremos el fichero de subrutina anterior.

; ************************************************************************************** ; TÍTOL I DESCRIPCIÓ ; ***************************** TITLE "Temporitzador. Primera versió" ; ************************************************************************************** ; SELECCIÓ DEL PIC ; **************************** LIST p=16F84A ; Aquesta directiva de l’assemblador amb l’opció p ; selecciona el PIC ; ************************************************************************************** ; DEFINICIONS PRÒPIES DEL PIC ; **************************** INCLUDE <P16F84A.INC> ; Inclou les definicions del PIC seleccionat: tots els bits ; i registres importants, amb nom molt semblant al datasheet ; ************************************************************************************** ; DEFINICIONS ; **************************** FLASH_RESET EQU 000h ; Primera posició de la FLASH: Es on es va quan ; es prem el MCLR_L (reset general) FLASH_PROGRAMA EQU 005h ; Primera posició de la FLASH útil ; per instal·lar el programa POLSADOR EQU 1 ; Línia del port A on hi ha el polsador CBLOCK 0x0C ; Aquesta directiva d'assemblador CBLOCK-ENDC ; és com un conjunt de directives EQU DELAY1 ; retards per la temportizació DELAY2 DELAY3 ENDC ; ************************************************************************************** ; PROGRAMA PRINCIPAL ; **************************** ORG FLASH_PROGRAMA ; Posició de la SRAM del PIC on començarà el programa Start ; Etiqueta que indica la primera posició del programa ; ----- Configurar el port B com a sortida ; El registre TRISB està al bank 1 de la memòria RAM (0086h) bsf STATUS,RP0 ; Per tal d'adreçar-lo directament, cal configurar el bit 5 ; del registre d'estat STATUS. movlw h'00' movwf TRISB ; Configura el PORT_B com sortida movlw h'FE' movwf TRISA ; Configura RA0 com sortida la sortida TIMER_OUT ; Configura RA1 (POLSADOR) i les altres línies com entrades bcf STATUS,RP0 ; Torna a l'adreçament del bank 0; posa a '0' el bit 5


22

clrf PORTA ; Posa a 0 el registre PORTA on hi ha TIMER_OUT movlw b'10000000' ; il·lumina el segment "g" per indicar que no temporitza ; i s'està inactiu movwf PORTB Loop btfsc PORTA,POLSADOR ; ----- Si hi ha S2 polsat(RA1 = 0) saltem a temporitzar goto Loop ; Mentre no s'hagi premut S2 (RA1 = 1) el programa es queda ; en aquest llaç sense fer res més movlw b'00000001' ; activa la sortida TIMER_OUT movwf PORTA ; Salta a la subrutina de temporitzar 15 s que també activa ; els diferents segments cada 0,5 s. call Retardo_15s ; vamos a la subrutina de Retado de 15 segundos movlw b'00000000' ; desactiva la sortida TIMER_OUT movwf PORTA ; quan ja s'ha acabat la temporització ... Debounce

btfss PORTA,POLSADOR ; Comprova si s'ha deixat de prémer la tecla S2 goto Debounce ; Si encara RA4 = 0, espera i es queda en el llaç movlw b'10000000' ; torna a indicar inactivitat (segment "g") movwf PORTB goto Loop ; Ja s'ha deixat anar la tecla (RA4 = 1) i torna cap al llaç ; principal. ; Fixeu-vos que el sistema de multiplexatge dels displays ; depèn de si tenim el pulsador premut o no??? ; Això s'ha de millorar !! (interrupcions programades) INCLUDE "RETARDO_15S.inc" ;Incluimos el fichero de subrutina ; ************************************************************************************** ; VECTOR DE RESET ; **************************** ORG FLASH_RESET ; Quan es prem el MCLR_L, el programa va goto Start ; ************************************************************************************** ; BITS DE CONFIGURACIÓ GENERAL PER AL PROGRAMADOR ; **************************** __CONFIG _XT_OSC & _PWRTE_ON & _CP_OFF & _WDT_OFF ; Rellotge exterior a cristall de quars XT (_XT_OSC) ; Usarem el temporitzador d'arrencada Power-Up Timer(_WRTE_ON) ; No usarem el Watch-Dog Timer (_WDT_OFF) ; No protegirem el codi (_CP_OFF) END ; Directiva que marca el fi del programa font ; **************************************************************************************

Fig. 20 Código ensamblador del programa principal


23

Cálculo de Ciclos Máquina

Para conocer la duración de nuestro código de subrutina, calculamos el número total de ciclos máquina que utilizamos. En la subrutina principal, de retardo 15 segundos, el número total de ciclos máquina es: Para RN = 150, RM = 100 y RK = 249 Ciclos Máquina = 2 + 1 + 2 + (2 + 4xRN + 4xRNxRM + 4xRKxRMxRN) = 15000607 cm Tiempo = (4 x cm )x( 1 / 4MHz) = 15,000607 segundos. Cuando a esta rutina la añadimos la subrutina de visualizar el segmento del display, que iluminará un segmento cada 0.5s, nos aumentaran el número de ciclos máquina, por lo que la subrutina durará más tiempo. Mediante el MPLAB podemos contar el número de ciclos máquina que tarda nuestro código en ejecutarse y gracias a la fórmula para calcular el tiempo que dedujimos al principio de la ampliación del proyecto, sabremos cuantos segundos tarda en ejecutarse nuestra rutina completa de retardo. En la opción Debugger StopWatch abrimos la utilidad de contar ciclos. Situamos un breakpoint en el programa principal justo en la llamada a la subrutina de retardo.

Fig. 21 Breakpoint en la llamada a la subrutina de retardo

Si pulsamos en Debugger -> Step Over saltaremos en el programa principal a la siguiente instrucción, pero ejecutando toda la subrutina de retardo, con lo que en


24

el Stopwatch nos aparecerá el numero de ciclos máquina y de segundos que ha empleado.

Fig. 22 Números de ciclos máquina y tiempo total de la subrutina

Nos ha salido un total de 15001734 cm, mientras que al calcular solo la rutina de retardo 15s sin que nos mostrara los segmentos del display eran 15000607cm, por tanto, tenemos 1127 cm “de más”, es decir, el código que hemos añadido tarda 1127cm en ejecutarse, que son 1,127ms. Este tiempo no es apreciable para nosotros pero representan 1127 ciclos máquina más de ejecución en nuestra CPU. Hemos decidido dejar la subrutina de esta manera, que en total nos retarda 15,001734 segundos, ya que el nivel de precisión que necesitamos no apreciaremos que los 15 segundos no son exactos. Ajustar el código para que haga exactamente 15,0 segundos es una tarea bastante complicada que resolveremos en próximas prácticas empleando interrupciones y periféricos.

Simulación en Proteus

Vamos a simular la ampliación de nuestro proyecto en Proteus. Si ejecutamos la simulación observamos como el motor está girando durante los 15 segundos que tenemos activada la temporización y como los segmentos del display se van iluminando cada 0,5s alternativamente. En la primera figura vemos iluminados el segmento ‘a’ y el motor encendido activado gracias al relé.


25

Fig. 23 Primer segmento del display iluminado y motor activado

Si nos fijamos solo en el display, veremos como se van iluminando los segmentos cada 0,5 segundos.

Fig. 24 Secuencia de iluminación de los segmentos del display

Una vez terminan los 15 segundos ó si pulsamos el reset, el segmento que se iluminará para marcar que no temporiza es el ‘g’ y el motor dejará de girar, al desactivarse la salida del TIMER_OUT.


26

Conclusiones

Hemos visto como esta forma de hacer la temporización no es una manera óptima ya que estamos usando nuestro microprocesador solo para una tarea: perder el tiempo. No podemos ejecutar otra tarea, ya que tenemos el procesador ocupado ejecutando instrucciones para perder el tiempo deseado. Esto lo cambiaremos cuando utilicemos el concepto de interrupciones, con lo que usaremos un periférico (TIMER0) para hacer la tarea la tarea de temporizar teniendo el procesador libre para otras tareas. Además, conseguir precisión en la realización de este tipo de retardos es una tarea bastante compleja ya que una vez hemos diseñado la subrutina principal de retardo 15 segundos (no exactos), hemos tenido que añadirle la subrutina para iluminar los segmentos del display. Esto nos ha llevado a tener que “retocar” el diseño de la subrutina principal para que durara menos ciclos máquina y así se pudiera compensar con los que añadimos al introducirle la subrutina secundaria. Estos “retoques” son bastante complejos, bastante “chapuzas” y también dependen del nivel de precisión que requiera nuestro sistema.

ex7 de sistemes electrònics digitals - upcdigsys.upc.es/ed/sed/grups_classe/05-06_q1/2at4/... ·...

Documents