LABORATORIO DE SISTEMAS DIGITALES II - OCW...

LABORATORIO DE SISTEMAS DIGITALES II

PRÁCTICA 1

Departamento de Sistemas Electrónicos y de Control Curso 2005/06

MANEJO DEL ENTORNO DE DESARROLLO (I PARTE)

Laboratorio de Sistemas Digitales II Práctica 1: MANEJO DEL ENTORNO DE DESARROLLO (I PARTE)

-2-


-3-

INDICE

1.- INTRODUCCIÓN............................................................................................................... 4

2.- OBJETIVOS DE LA PRÁCTICA. ....................................................................................... 5

3.-DESARROLLO DE LA PRÁCTICA..................................................................................... 6

EJERCICIO 1: FUNCIÓN FACTORIAL( ) ............................................................................... 7

EJERCICIO 2: FUNCIÓN LETRA_NIF( ).............................................................................. 15

EJERCICIO 3: FUNCIÓN RETARDO_1MS( ) ...................................................................... 18

EJERCICIO 4: FUNCIÓN NATURAL_A_ASCII( )................................................................. 21

ANEXO 1: RESTRICCIONES DE LA VERSIÓN DE EVALUACIÓN .................................... 22

ANEXO 2: “QUICK START” µVISION2................................................................................. 23

ANEXO 3: TIPOS DE DATOS EN EL COMPILADOR C51 .................................................. 31

ANEXO 4: TIPOS DE MEMORIA.......................................................................................... 32

ANEXO 5: FUNCIÓN SPRINTF( ) ........................................................................................ 33

HOJAS DE RESULTADOS.................................................................................................... 35


-4-

PRÁCTICA 1

MANEJO DEL ENTORNO DE DESARROLLO

(I PARTE)

1.- Introducción. Existen diversos entornos de desarrollo de programas para la familia de microcontroladores MCS-51; uno de los más utilizados es el “PK51 Professional Developer's Kit” de Keil Software. Este entorno integra los siguientes componentes:

• µVision2 IDE • A51 Macro Assembler • C51 ANSI C Compiler • BL51 Code Banking Linker/Locator • OH51 Object-HEX Converter • OC51 Banked Object Converter • RTX51 Tiny Real-time Kernel • µVision2 Debugger • MON51 Target Monitor • ISD51 In-System Debugger

Además dispone de versiones especiales del compilador, ensamblador y linker (“CX51 ANSI C Compiler”, “AX51 Macro Assembler” y “LX51 Linker/Locator”) que soportan características adicionales de los miembros de la familia MCS-51 más recientes. A lo largo del laboratorio de esta asignatura se utilizará el entorno “PK51 Professional Developer's Kit” en su versión de evaluación para desarrollar y depurar programas en lenguaje C para microcontroladores de la familia MCS-51. El anexo 1 recoge las limitaciones de esta versión de evaluación. En esta primera práctica se hace especial hincapié en el manejo de “µVision2 IDE” (Integrated Development Environment - Entorno Integrado de Desarrollo), “µVision2 Debugger” (Depurador) y “C51 ANSI C Compiler” (Compilador de ANSI C). En el anexo 2 se incluye la guía de inicio rápido “Quick Start" de µVision2, sobre dicho anexo se recomienda:

• Una primera lectura antes de comenzar la práctica para tener un conocimiento general de las posibilidades de µVision2.

• La consulta de las barras de botones de construcción del ejecutable (página 3), de edición (página 4) y de depuración (página 5) durante el desarrollo de la práctica, hasta que quede aprendida la funcionalidad de cada botón.

• Su estudio en profundidad al finalizar la práctica, para comprender en detalle las posibilidades de µVision2.


-5-

Una documentación más extensa sobre el conjunto de las herramientas de desarrollo PK51 puede encontrarse en los ficheros GS51.PDF y C51.PDF, disponibles en la página WEB de la asignatura o en la publicación: “Getting Started with µVision2 and the C51 Microcontroler Development Tools”. Una información más detallada, así como la última versión de µVision, se encuentra en: www.keil.com. Como requisito previo a la realización de la práctica es necesario conocer programación en lenguaje C (más concretamente ANSI C) y tener experiencia en la realización de programas en C en cualquier entorno de desarrollo. Habitualmente se aprende a programar en lenguaje C realizando programas que se ejecutan sobre un ordenador personal PC; es decir se realizan programas que finalmente van a ser ejecutados por el microprocesador x86 que incorpora el PC. Los programas realizados se ejecutan bajo un sistema operativo (MS-DOS, Windows, Linux, etc.) que ya está ejecutándose en el ordenador; el sistema operativo proporciona funciones de acceso a dispositivos de E/S (discos, puertos de comunicaciones, teclado, monitor, etc.), de manejo de la memoria, etc. Al realizar programas para un microcontrolador, el programa que realizamos suele ser el único software que ejecutará el microcontrolador; es decir no hay sistema operativo y todo el control y manejo del Hardware se hará desde el propio programa que se está realizando. En estas ocasiones, se utiliza el ordenador personal PC como herramienta para la creación y depuración de los programas, pero su ejecución final no la lleva cabo el microprocesador del PC, por el contrario es el microcontrolador (en un hardware diferente) el encargado de ejecutar el programa que se ha realizado. Para facilitar la tarea de depuración los fabricantes de microcontroladores facilitan simuladores para PC que permiten probar los programas sin necesidad de disponer del HW en el que se encuentra el microcontrolador. Uno de estos simuladores es el que se empleará para esta primera práctica. Hay que hacer notar que al no tratarse del HW final es posible que el comportamiento del programa no sea exactamente el mismo en el simulador que en el HW. En esta práctica la fase de depuración de programa se va a realizar en el PC mediante simuladores del microcontrolador; controlando la ejecución del programa mediante puntos de ruptura y observando los valores que toman las variables definidas en el programa. En esta práctica se desarrollarán y depurarán programas en lenguaje C mediante µVision2 sin profundizar en las implicaciones que tiene el hecho de que dichos programas se realizan para ser ejecutados por un microcontrolador; cuestión que se abordará en profundidad en la siguiente práctica.

2.- Objetivos de la práctica. Los objetivos de esta práctica se pueden resumir en los siguientes puntos:

• Conocer y manejar µVision2 IDE y µVision2 Debugger para desarrollar programas en lenguaje C y ejecutarlas en el simulador del C51.


-6-

• Conocer y utilizar los tipos de variables del compilador C51 así como los modificadores del tipo de memoria en que se almacenarán dichas variables.

• Utilizar el “performance analyzer” de µVision2 para medir el tiempo de ejecución de funciones escritas en lenguaje C.

• Realizar, depurar y optimizar algunas funciones de lenguaje C que se utilizarán en prácticas posteriores

3.-Desarrollo de la práctica.

Los pasos a seguir para desarrollar programas en el entorno de Keil para la familia MCS-

51 son: 1.- Crear un proyecto, seleccionar el microcontrolador para el cual se va a desarrollar el programa y configurar las opciones adecuadas al sistema sobre el que se ejecutará el programa. 2.- Crear los ficheros fuente en lenguaje C (*.C) o en lenguaje ensamblador (*.A51). 3.- Construir la aplicación, compilando los ficheros *.C, ensamblando los ficheros *.A51 y linkando todos los ficheros objetos en un único ejecutable. 4.- Corregir los errores en los ficheros fuente. 5.- Depurar y comprobar el funcionamiento de la aplicación desarrollada sobre un simulador. En este caso el código se ejecuta sobre un simulador. Un simulador es una aplicación del

entorno “PK51 Professional Developer’s Kit” que permite probar el funcionamiento de un programa desarrollado para el microcontrolador sin necesidad de disponer de un HW que contenga dicho microcontrolador.

En el tipo de programa que se va a desarrollar en esta práctica el comportamiento del

simulador sería exactamente el mismo que al ejecutarlo sobre un microcontrolador. Sin embargo hay que ser consciente que se trata de una simulación por lo que el comportamiento una vez que se ejecute el programa sobre el microcontrolador real puede variar.

Antes de proceder a la realización de la práctica, y como norma general en las prácticas posteriores, deberá entregar un informe con los listados correspondientes de cada uno de los programas que debe editar para su posterior simulación, ejecución y depuración en el entorno. El listado se entregará al profesor de laboratorio al inicio de cada sesión, no siendo recomendable que el alumno edite por primera vez el programa durante la clase de laboratorio.


-7-

En la figura 1 se observa el diagrama de bloques del proceso a seguir con las herramientas a utilizar en cada caso. Cabe destacar que todos los pasos necesarios se realizan dentro del entorno µVision2, si bien el aspecto y las opciones disponibles en este programa cambian cuando se pasa del modo de edición y creación (Editor&Make) al modo de depuración (Debugger).

Figura 1. Ciclo de desarrollo software

En los siguientes apartados se plantea la realización y depuración de algunos programas en lenguaje C de forma guiada, con el objetivo de descubrir y manejar el entorno µVision2, algunas opciones del compilador C51 y el simulador de microcontroladores de la familia 8051. En prácticas posteriores se profundizará en su estudio y se conocerán el resto de los componentes de este sistema de desarrollo.

Ejercicio 1: Función factorial( ) Descargar de la página de la asignatura el fichero FACTORIAL.ZIP y descomprimirlo en una nueva carpeta llamada FACTORIAL, que contendrá todos los ficheros que se manejan en este ejercicio 1. Visualizar el contenido de la carpeta FACTORIAL y comprobar que existen, al menos, los siguientes archivos: factorial.txt: es un fichero de texto con la descripción del objetivo del ejercicio. factorial.Uv2: es un fichero de proyecto de µVision2. fun_factorial.C: es el fichero fuente en lenguaje C con la función factorial( ) y el programa principal orientado a depurar dicha función.


-8-

Haciendo doble clic en el fichero factorial.Uv2 se ejecutará el entorno µVision2 y se abrirá el proyecto factorial. Igual resultado se obtiene si se ejecuta µVision2 desde el icono del escritorio (o desde el menú de inicio) y posteriormente se selecciona el menú Project y en la opción “Open project” se selecciona el archivo factorial.Uv2. Se obtendrá una pantalla similar a la figura 2.

Figura 2. Proyecto: factorial.Uv2

En la parte superior de la ventana se encuentran la barra de menús y las barras de

botones; debajo de las barras de botones se encuentran dos ventanas: la de la izquierda es la ventana de proyecto representa los ficheros que forman parte del proyecto, la de la derecha visualiza los ficheros abiertos (en este caso el fichero fun_factorial.C); en la parte inferior se visualiza la barra de estado y sobre dicha barra aparece la ventana de salida. Todas las ventanas se pueden anclar en la pantalla o hacerlas flotantes y situarlas en cualquier lugar de la pantalla, de forma muy similar a otros programas en el sistema operativo Windows.

El fichero fun_factorial.C se visualiza con las palabras reservadas en lenguaje

C resaltadas en color azul, el contenido de este fichero se muestra en la figura 3.


-9-

Figura 3. Fichero: fun_factorial.C

El contenido de este fichero será un punto de partida para elaborar un programa que

cumpla los requisitos fijados en el fichero factorial.txt, este fichero se puede abrir haciendo doble clic en el nombre del mismo (o bien en el icono) de la ventana de proyecto, el texto de dicho fichero es:

Figura 4. Fichero: factorial.TXT

La barra de botones de construir proyecto (compilación, ensamblado, linkado y creación del ejecutable) se muestra en la figura 5.

Proyecto Factorial: depuración de la función factorial() El objetivo del proyecto es depurar una función llamada factorial() que calcula el factorial de un número natural comprendido entre cero y N (ambos incluidos). Se determinará el máximo valor de N con los tipos de variables disponibles en el compilador C51 versión de evaluación. Si la función factorial() recibe como parámetro un número mayor que N devolverá como resultado cero, indicando que no pudo realizarse el cálculo.


-10-

Figura 5. Barra de botones de construir proyecto

Pulsando el botón de construir proyecto “Build Target” se procesan todos los ficheros del proyecto en curso asociados al “Target1” que esté seleccionado en el menú desplegable “Select current Target of the project”; es decir: compilan los ficheros *.C, se ensamblan los ficheros *.A51 y se linkan todos los ficheros objetos generados en un único ejecutable. Las opciones restantes permiten reconstruir el proyecto cuando han existido modificaciones en el proyecto en curso (Rebuild Target), modificar opciones en el “Target” actual (Target Options Dialog), detener el proceso (Stop Build Process) o compilar tan solo el fichero fuente que se encuentra activo (Translate Current File). Antes de continuar, analice detenidamente el programa mostrado en la figura 3, si detecta algún error de sintaxis no lo corrija por ahora; siga los pasos que se indican a continuación y corrija dichos errores cuando el compilador los detecte.

Pulse el botón “Build Target” y observe los resultados obtenidos en la ventana de salida; aparecerán varios errores, localice el primero de todos ellos haciendo doble clic en dicho error y el cursor se posicionará en el fichero fuente que tiene el error, en la línea donde se ha detectado dicho error. Corrija el error y vuelva a construir el proyecto; si aparecen nuevos errores corríjalos de igual forma hasta que no haya errores de sintaxis. En la edición de los ficheros fuentes resulta de utilidad la barra de botones de edición que se muestra en la figura 6.

Figura 6. Barra de botones de edición

Cuando consiga construir el proyecto sin errores visualizará una ventana de salida similar

a la figura 7. Observe en dicha ventana que se informa sobre el tamaño del programa, detallando los siguientes valores:

1 Se denomina Target a una configuración particular de la tarjeta en la que se encuentra el microcontrolador. Esta configuración permite por ejemplo definir la cantidad de memoria externa de la que dispone la tarjeta del laboratorio. Un estudio detallado de las posibilidades de configuración de estas posibilidades se estudiará en la práctica 2.


-11-

data=49.0 Bytes.bits de memoria de datos interna utilizados para las variables. xdata=0 Bytes de memoria de datos externa utilizados para las variables. code=388 Bytes de memoria de código que ocupa el programa.

Figura 7. Ventana de salida; resultado de la construcción del proyecto

Una vez obtenido el ejecutable sin errores hay que comprobar el funcionamiento del

programa; para ello se ha de pulsar el botón “Start/Stop debug sesion”:

/Stop debug sesionStart/Stop debug sesion

Figura 8. Botón de “debug”

Pulse dicho botón. Aparecerá una ventana que informa que se está utilizando la versión de

evaluación, haga clic en el botón “Aceptar” de dicha ventana.

Figura 9. µVision2 en modo “debug”


-12-

Observe que el aspecto de µVision2 ha cambiado (modo de depuración). En la ventana de

proyecto se visualizan los registros del modelo de programación de la CPU. En la ventana del fichero fuente aparece una flecha amarilla, a la izquierda del código, indicando la siguiente instrucción a ejecutar; en este caso será la primera sentencia de lenguaje C ejecutable en el programa principal. También aparece una nueva ventana en la parte inferior, es la ventana de “Watch and call stack”, en la que se visualizan de forma automática las variables locales a la función que se está ejecutando (en este caso la función main). Si esta ventana no aparece, actívela pulsando el botón “Watch window” (ver figura 11).

Para comprobar el funcionamiento del programa interesa visualizar cómodamente los arrays; mueva la ventana de “Watch and call stack”, haciendo clic en el lado izquierdo de la misma y arrastrándola a otro lugar de la pantalla; haga doble clic en el nombre de los arrays para desplegar sus valores y con el botón de la derecha seleccione como sistema de numeración el decimal (ver figura 10).

Figura 10. Cambio de sistema de numeración en las variables

En la ventana de “Watch”, además de visualizar las variables locales, se pueden definir

expresiones que se evaluarán a cada paso que se de en la ejecución de los programas; para introducir una expresión hay que seleccionar una de las solapas Watch #1 o Watch #2, hacer un clic en el texto: “type F2 to edit”, pulsar la tecla F2 y escribir la expresión. Ejemplos de expresiones que se podrían utilizar con las variables del programa principal son:


-13-

resultados[2] i+1 pruebas[i]

La visualización de las distintas variables que se definen en el proyecto y su evolución en la ejecución paso a paso del programa debe servir como un paso más en la depuración ya que permite detectar posibles errores en tiempo de ejecución de la aplicación.

Observe también que los botones de la barra de construcción del ejecutable aparecen

desactivados y aparece la barra de botones de depuración.

Figura 11. Barra de botones de “debug"

Desde esta barra de botones se puede controlar la ejecución del programa:

• Reseteando el microcontrolador (Reset CPU), en este caso el simulador. • Continuando la ejecución del programa (Run). • Deteniendo la ejecución (Halt Execution). • Ejecutando instrucción a instrucción, entrando en las funciones (Step Into). • Ejecutando instrucción a instrucción, ejecutando las funciones como una única

sentencia (Step Over). • Ejecutando hasta finalizar el bloque actual (Step Out). • Ejecutando hasta la línea del cursor (Run till Cursor line). Compruebe el funcionamiento del programa ejecutando paso a paso las sentencias de

lenguaje C y observando la evolución de las variables; observe que al entrar en la función factorial( ) se visualizan las variables de dicha función en la ventana de Watches solapa Locals.

Verifique que existe un error en tiempo de ejecución en el programa que hace que el

factorial de cualquier número resulte ser cero. Para detectar el error será conveniente poner un punto de ruptura en la función factorial (); esto se hace situando el cursor en la línea donde se quiere parar la ejecución y pulsando el botón “Toggle Break” de la barra de botones de edición (ver figura 12). Los puntos de ruptura también se pueden poner (y quitar) haciendo doble clic en una línea de código.


-14-

Figura 12. Barra de botones de edición; botones de manejo de puntos de ruptura

Los botones relacionados con los puntos de ruptura permiten:

• Poner o quitar un punto de ruptura en la línea del cursor (Toggle Break). • Quitar todos los puntos de ruptura (Kill all Breaks). • Habilitar o deshabilitar un punto de ruptura en la línea del cursor (Enable/Disable). • Deshabilitar todos los puntos de ruptura (Disable all). Un punto de ruptura situado en una línea de código se indica mediante un cuadradito a la

izquierda de la ventana del fichero; dicho cuadrado es de color rojo cuando el punto de ruptura está habilitado y es de color blanco cuando está deshabilitado. Además de los puntos de ruptura, a la izquierda de cada ventana de código aparecen otros símbolos para señalar que la línea ha sido marcada (Bookmark), valor actual del contador de programa (Current PC, next statement), etc. (ver figura 13).

Si necesita volver a ejecutar el programa asegúrese de pulsar el botón “Reset CPU” y a

continuación el botón “Run” para ejecutar todo el código hasta encontrar el primer punto de ruptura habilitado, momento en el que se detendrá la ejecución y podrá observar los valores que tienen las variables. Tenga en cuenta que si no hay ningún punto de ruptura situado en el programa, este se ejecuta sin mostrar ninguna información quedando en un bucle infinito debido a la sentencia “while(1)” del final del mismo.

Figura 13. Indicaciones a la izquierda de la ventana de código

Una vez detectado el error, cambie el código fuente para que la función calcule

correctamente el factorial, con las especificaciones del fichero factorial.TXT (figura 4). Puede realizar los cambios directamente en el modo de depuración (en el que se encuentra), pero necesitará volver a construir la aplicación desde el modo de edición/construcción y pasar por cada una de las fases realizadas anteriormente, ya que de lo contrario se estará depurando un programa anterior a las modificaciones realizadas. Para salir del modo de depuración pulse en el botón “Debug” de la barra de botones de edición.


-15-

Construya de nuevo la aplicación, pase al modo de depuración, ejecute paso a paso o bien utilice puntos de ruptura y verifique que los resultados que se obtienen en el array resultados[] son ahora correctos. Determine el máximo número natural (N) del cual se puede calcular el factorial con los tipos de datos utilizados hasta ahora en el programa. Conteste el apartado 1.1 de las hojas de resultados.

Consultando el anexo 3, en el que se detallan los tipos de variables permitidos en el

compilador C51, modifique el código fuente eligiendo para cada variable el tipo más adecuado siguiendo estos criterios:

- Utilizar el modificador “unsigned” si la variable sólo puede tomar valores positivos y

“signed” en caso contrario. - Entre los tipos char, int y long utilizar aquel que menor número de bytes de memoria

utilice y permita almacenar todos los posibles valores que pueda tomar la variable correspondiente.

Con los nuevos tipos elegidos determine en valor del máximo número natural (N) del cual

se puede calcular el factorial. Conteste el apartado 1.2 de las hojas de resultados. Observe y anote en la tabla del apartado 1.2 de las hojas de resultado el tamaño del programa ejecutable para cada uno de los tipos definidos de la variable empleada. Ejercicio 2: Función letra_NIF( )

En este segundo ejercicio se desarrollará un programa en lenguaje C que incluya una función llamada letra_NIF() que calcule la letra del NIF correspondiente a un DNI.

El algoritmo a utilizar para determinar la letra que le corresponde a un DNI consiste

en calcular el resto de la división del DNI por 23, que será un número entre 0 y 22; tomando dicho valor como índice de la siguiente tabla se obtiene la letra del NIF:

char letras_NIF[23]="TRWAGMYFPDXBNJZSQVHLCKE";

En esta ocasión se seguirán todos los pasos necesarios para realizar el programa,

empezando por crear el proyecto, escribiendo el programa en lenguaje C, construyendo la aplicación y depurando. Todos los archivos de este proyecto se almacenarán en una nueva carpeta llamada NIF; antes de seguir adelante cree dicha carpeta.

Ejecute µVision2, si no está en ejecución todavía, y compruebe que automáticamente

se carga el último proyecto desarrollado. Cierre dicho proyecto con la opción Close Project del menú Project. Cree ahora un nuevo proyecto de nombre: letra_NIF, seleccionando Project New Project.

Después de elegir la carpeta que albergará el proyecto y poner un nombre al mismo

aparece una ventana que permite elegir el microcontrolador para el cual se desea crear la aplicación. Agrupados por fabricantes se dispone de un listado muy completo de la familia MCS-51. En este caso se elegirá el microcontrolador de Intel 8051AH (tenga en cuenta que este modelo no se corresponde con el que se empleará en prácticas posteriores).


-16-

Como se muestra en la figura 14, al confirmar la selección del microcontrolador a utilizar el entorno le preguntará acerca de si desea incluir el código correspondiente al “startup” en su proyecto, responda pulsando el botón “si” a esta petición para que se incluya dicho fichero. El citado código “startup” es un programa que incluye de forma automática el “enlazador” y que es el encargado de inicializar algunos de los recursos del microcontrolador concreto que se haya seleccionado y de configurar los aspectos básicos (la pila, el banco de registros, etc). Este código se encuentra escrito en ensamble y se debe ejecutar antes de la función main() que contiene nuestro programa.

Figura 14. Ventana para la inclusión del “startup”.

Cree ahora un fichero y en él escriba las sentencias de lenguaje C para realizar la

función letra_NIF( ) y el programa principal dedicado a probar el funcionamiento de dicha función con diversos valores de DNI. Guarde dicho archivo en la carpeta del proyecto con el nombre letras_NIF.C, al guardarlo con extensión *.C se resalta la sintaxis de lenguaje C.

Ahora hay que incluir ese fichero en el proyecto, para ello es necesario manejar

algunas opciones de la ventana de proyecto. En primer lugar se observa que un proyecto tiene una tarjeta por defecto de nombre Target 12; se pueden definir varias tarjetas cada una con un microcontrolador, un mapa de memoria y opciones de creación de los ejecutables diferentes.

Este proceso se realiza cuando se define las propiedades del proyecto dentro del menú

“project”, en el cual se selecciona entre los distintos tipos de microcontrolador, mapa de memoria, frecuencia del cristal y las distintas opciones de compilación, ensamblado, linkado y fichero ejecutable.

Dentro de cada Target se encuentran los ficheros fuentes y de texto, organizados en

grupos de ficheros; en proyectos pequeños será suficiente con un grupo (Source Group 1), mientras que en proyectos grandes puede ser útil definir varios grupos.

Haciendo clic con el botón derecho del ratón sobre Source Group 1 se despliega un

menú de opciones que permite añadir ficheros al grupo (ver figura 15). Siga estos pasos e incluya el fichero letras_NIF.C en la carpeta Source Group 1 del proyecto.

Ahora podrá construir el ejecutable y depurarlo siguiendo los pasos descritos en el

ejercicio 1. Siga dichos pasos y compruebe el funcionamiento del programa; conteste al apartado 2.1 de las hojas de resultados.

2 Recuerde que un Target permite definir las características concretas que posee la tarjeta en la que se encuentra el microcontrolador.


-17-

Figura 15. Añadir ficheros a un grupo

En los microcontroladores la memoria disponible suele estar muy limitada,

habitualmente se dispone de unos pocos Kilobytes de memoria de programa y unos cientos de bytes de memoria para datos; es por esto que al desarrollar programas para microcontroladores es importante tratar de optimizar el uso de la memoria. En el ejercicio 1 se hicieron cambios en los tipos de las variables para optimizar el uso de la memoria de datos.

Una forma de optimizar el uso de la memoria en este ejemplo (tanto memoria de

datos como memoria de código) consiste en almacenar los arrays constantes con las letras del NIF en memoria de código, en vez de hacerlo en memoria de datos; en este caso resulta adecuado ya que el array de letras del NIF no cambia durante la ejecución del programa. El compilador C51 permite elegir en qué tipo de memoria se almacenan las variables, las distintas opciones se recogen en el anexo 4.

Modifique la declaración del array letras_NIF[23] para que se almacene en

memoria de código; construya de nuevo el ejecutable y observe el uso que se hace ahora de la memoria. Apreciará que las variaciones encontradas no afectan tan sólo a los 24 bytes necesarios para almacenar el array, al moverlos de la memoria de datos a la de código. Esto se debe a que el programa resultado de la compilación es distinto (distintos direccionamientos, distinto código de “startup”, etc) y por lo tanto el impacto sobre la utilización de la memoria es mayor de lo que cabría esperar. Las particularidades de estos aspectos se explicarán en prácticas posteriores. Conteste al apartado 2.2 de las hojas de resultados.


-18-

Ejercicio 3: Función retardo_1ms( ) Las funciones de retardo son utilizadas habitualmente en los programas para manejar

microcontroladores; consisten en un conjunto de sentencias cuya ejecución se desarrolla en un tiempo conocido.

En esta ocasión se desarrollará una función de lenguaje C que tarde un 1 milisegundo,

aproximadamente en ejecutarse sobre un microcontrolador 8051AH de Intel a 12MHz. Se utilizarán las herramientas de µVision2 para medir tiempos de ejecución.

Todos los ficheros de este ejercicio se guardarán en una carpeta llamada RETARDO,

cree ahora dicha carpeta. Ejecute µVision2, si no está en ejecución todavía, cierre el proyecto actual y genere uno nuevo con nombre Funcion_Retardo, dentro de la carpeta RETARDO. Elija como microcontrolador el mismo que se utilizó en el ejercicio 2.

Escriba el código fuente en lenguaje C, que incluya la función retardo_1ms( ), y el

programa principal que sirva para depurar dicha función. La función simplemente debe realizar un bucle que consuma el tiempo de ejecución deseado, por otro lado el programa principal debe incluir varias llamadas a la función retardo_1ms (al menos 3) para que posteriormente se puedan realizar medidas del tiempo real de ejecución de esta función. Guarde el fichero con el nombre función_retardo.C.

Antes de construir el ejecutable y pasar al modo de depuración es necesario fijar la

frecuencia del reloj del microcontrolador; para ello pulse el botón de opciones de la tarjeta (Target Options Dialog) situado en la barra de construcción del proyecto y se desplegará una ventana similar a la de la figura 16.

Dentro de las opciones de la tarjeta, en la solapa Target se especifican todas las

particularidades de la tarjeta para la cual se está realizando el código: mapas de memoria externa, bancos de memoria, frecuencia del oscilador, etc. En el resto de solapas se especifican opciones del compilador, ensamblador, linker, etc. que se utilizarán al construir el ejecutable para esa tarjeta. En prácticas posteriores se profundizará en estas opciones, ahora tan solo hay que asegurarse de que la frecuencia del oscilador es de 12 MHz.

Figura 16. Opciones de configuración de la tarjeta


-19-

Construya el ejecutable y pulse el botón de Debug para pasar al modo depuración. Active la ventana “Performance Analyzer” pulsando el correspondiente botón de la

barra de Debug y aparecerá una nueva ventana similar a la figura 17. Sobre dicha ventana pulsar con el botón de la derecha del ratón y seleccionar la opción Setup PA; en la nueva ventana que aparece incluir la función retardo_1ms( ) seleccionándola de la lista Function Symbols de la derecha y pulsando el botón Define (ver figura 18).

Figura 17. Performance Analyzer

Figura 18. Configuración del PA (Performance Analyzer)


-20-

Ejecute el programa poniendo un punto de ruptura en la última función del programa principal donde lo permita el depurador y observe que el Performance Analyzer indica en todo momento que porcentaje de tiempo dedica la CPU a cada una de las funciones definidas, y qué porcentaje de tiempo dedica al resto del código (unspecified). Al finalizar la ejecución o pararla se puede seleccionar cada una de las funciones definidas y en la parte inferior se informa de los tiempos de ejecución de dichas funciones. En la figura 19 se observa el resultado del análisis para la función retardo_1ms(), cuando se ha ejecutado 3 veces (count: 3) y los tiempos mínimo, máximo, medio y total de ejecución de dicha función (en segundos). En este caso se ha procedido a realizar un bucle en el programa principal que ejecuta tres veces (llama tres veces a la función retardo_1ms), con objeto de realizar un PA más eficiente.

Análisis estadístico de la función retardo_1ms.

Figura 19. Resultados de PA tras 3 ejecuciones de la función_retardo_1ms( )

En la figura 19 también se observa que un 75% del tiempo total de CPU se ha

dedicado a la ejecución de la función: retardo_1ms( ) mientras que el 25% restante se ha dedicado a funciones sin especificar3. Por otra parte la ejecución de la función, en el ejemplo de la figura, dura 0,4 segundos aproximadamente, por lo que habrá que modificar dicha función para que se ejecute en 0,001 segundos, dividiendo en número de iteraciones que realice la función por 400 aproximadamente. Siguiendo este tipo de estrategias pruebe los siguientes tipos de variables: unsigned int y unsigned long; y obtenga el número de iteraciones necesarias para ajustar el tiempo de ejecución de la función a un milisegundo aproximadamente. Para cada valor de prueba rellene la tabla del apartado 3.1 de las hojas de resultados. 3 Dentro de estas funciones sin especificar se encuentra el código que se añade para el startup.


-21-

Ejercicio 4: Función Natural_a_ASCII( ) En este ejercicio se desarrollará y depurará una función que será necesaria en

prácticas posteriores; se trata de expresar números naturales en un array de caracteres. Codifique la función denominada Natural_a_ASCII_1 que reciba como parámetros:

- un puntero a la dirección de comienzo de un array de 4 caracteres y - un entero sin signo.

Dicha función no devolverá ningún valor. El resultado de la ejecución será tal que en la primera posición del array se

almacenará el código ASCII del dígito de los millares del número, en la segunda posición se almacenará el carácter correspondiente a las centenas, en la tercera las decenas y en la cuarta las unidades.

Si los millares son cero se almacenará un espacio en blanco en lugar del carácter ‘0’,

si los millares y las centenas son cero se almacenarán espacios en blanco en las posiciones correspondientes e igualmente si millares, centenas y decenas son cero. El carácter correspondiente a las unidades siempre será un carácter numérico, entre ‘0’ y ‘9’. Si el valor del número natural es mayor que 9999, en las cuatro primeras posiciones del array se almacenarán el carácter ‘*’, indicando que el número natural está fuera de rango.

Todos los ficheros de este ejercicio se guardarán en una carpeta llamada

NAT_A_ASCII, cree ahora dicha carpeta. Ejecute µVision2, si no está en ejecución todavía, cierre el proyecto actual y genere

uno nuevo con nombre Natural_a_ASCII_1, dentro de la carpeta NAT_A_ASCII. Elija como microcontrolador el mismo que se utilizó en el ejercicio 2.

Escriba el código fuente en lenguaje C, que sirva para depurar una función, llamada

Natural_a_ASCII_1( ) y que cumpla con las especificaciones anteriores sin utilizar funciones de las librerías de lenguaje C.

Construya el ejecutable y compruebe que funciona correctamente al menos para los siguientes números enteros: 0, 20, 107, 3000, 8421, 9999, 10000 y 63211; anote los caracteres ASCII obtenidos en cada caso en las hojas de resultados y complete las cuestiones del apartado 4.1.

Cree un nuevo proyecto en la misma carpeta (NAT_A_ASCII) con el nombre

Natural_a_ASCII_2. Partiendo del código desarrollado en Natural_a_ASCII_1 (es decir utilizando el mismo programa principal), escriba el código fuente de una nueva función llamada Natural_a_ASCII_2( ), que cumpla con las especificaciones anteriores utilizando funciones de librería de lenguaje C. La librería de C que puede resultar de interés en este ejercicio es la de entrada/salida estándar (STDIO.H); y particularmente la función sprintf() (ver anexo 5). Construya el ejecutable y compruebe que funciona correctamente con los mismos números enteros que se utilizaron en la función Natural_a_ASCII_1( ). Para comprender por completo la utilización de la función sprintf(), debe remitirse a la página 290 del C51.pdf, el cual puede accederse desde el entorno en la pestaña “books” en la ventana de proyectos. Complete el apartado 4.2 de las hojas de resultados.


-22-

ANEXO 1: Restricciones de la versión de evaluación PK51/C51 Compiler - RESTRICTIONS IN THE EVAL VERSION

1. The 8051 compiler, assembler, linker, and debugger are limited to 2 Kbytes of object code but source code can be any size. Programs generating more than 2 Kbytes of object code will not compile, assemble, or link.

2. The debugger supports 2 Kbyte files or smaller.

3. The startup code generated includes LJMPs and code generated cannot be used in

single-chip devices supporting less than 2K of program space (for example, Philips 750/751/752).

4. Programs begin at offset 0x0800 and code generated with the evaluation software

cannot be programmed into single-chip devices.

5. No hardware support is available for multiple DPTR registers.

6. No support is available for user libraries or floating point arithmetic.

7. The following Code Banking Linker, Library Manager and RTX-51 Tiny Real-Time Operating System, which are present in the PK51 Full Version, are not included in the PK51/C51 Eval Version.

8. It is not possible to generate assembler source files or use in-line assembler

features.


-31-

ANEXO 3: Tipos de datos en el compilador C51

Los tipos de datos permitidos en el compilador C51 son:

Tipo de dato Bits Bytes Rango de valores

bit 1 — 0 a 1

signed char 8 1 -128 a +127

unsigned char 8 1 0 a 255

enum 8 / 16 1 or 2 -128 a +127 o -32768 a +32767

signed short 16 2 -32768 a +32767

unsigned short 16 2 0 a 65535

signed int 16 2 -32768 a +32767

unsigned int 16 2 0 a 65535

signed long 32 4 -2147483648 a 2147483647

unsigned long 32 4 0 a 4294967295

float 32 4 ±1.175494E-38 a ±3.402823E+38


-32-

ANEXO 4: Tipos de memoria En los ficheros de lenguaje C para el compilador C51 se puede especificar en qué

memoria se almacenará cada variable definida, utilizando las siguientes palabras reservadas:

Palabra reservada Descripción del tipo de memoria

code Memoria de programa (64 KBytes)

data Memoria interna de datos con direccionamiento directo; acceso rápido a las variables (128 bytes).

idata Memoria interna de datos con direccionamiento indirecto; acceso a todo el espacio de direccionamiento interno (256 bytes).

bdata Memoria interna de datos direccionable a nivel de bit; permite mezclar accesos de bit y de byte (16 bytes).

xdata Memoria de datos externa (64 KBytes)

Ejemplos:

char xdata mensaje[5]; /* en memoria externa de datos*/ char code mensaje[5] = “Hola”; /* en memoria de código */ char data mensaje[5]; /* en memoria interna de datos */


-33-

ANEXO 5: Función sprintf( )


-34-


-35-

LABORATORIO SISTEMAS DIGITALES II

HOJAS DE RESULTADOS Práctica 1

Grupo: Alumno: Puesto:

Fecha:

EJERCICIO 1: FUNCIÓN FACTORIAL() 1.1. Función factorial() con variables tipo “int” Código de la función factorial sin errores: Uso de la memoria:

data= xdata= code=

Valor de N = 1.2. Función factorial() con otros tipos de variables Tipos de las variables: Función main ()

Tipo Variable

pruebas[]

resultados[]

i

Función factorial ()


-36-

Tipo Variable o función

num

total

factorial()

Uso de la memoria con otros tipos de datos:

data= xdata= code=

Nuevo valor de N = Código final de la función factorial: Comparación del fichero ejecutable con distintos tipos de variable para los arrays “pruebas” y “resultados”. Anotar las conclusiones obtenidas

Tipo Tamaño ejecutable

Unsigned char

Unsigned int

Unsigned long


-37-

EJERCICIO 2: FUNCIÓN LETRA_NIF( ) 2.1. Función letra_nif ( ) con array en memoria de datos Listado del fichero letras_NIF.C: Uso de la memoria:

data= xdata= code=

Pruebas realizadas:

DNI Letra NIF

2.2. Función letra_nif ( ) con array en memoria de código Uso de la memoria con el array en memoria de código:

data= xdata= code=


-38-

Comparando las cantidades de memoria utilizadas con el array en memoria de datos (apartado 2.1) y con el array en memoria de código (apartado 2.2), conteste a las siguientes preguntas: - ¿En qué caso se utiliza más memoria de datos? Razone la respuesta - ¿En qué caso se utilizan más bytes de memoria de programa? Razone la respuesta EJERCICIO 3: FUNCIÓN RETARDO_1MS( ) 3.1. Retardo de 1ms Pruebas realizadas: Tipo de Variable Número de

iteraciones Tiempo de ejecución de la función Retardo_1ms()

Listado de la función Retardo_1ms() con la duración de la función ajustada a 1 milisegundo empleando el tipo de variable que considere más adecuado: Uso de la memoria:

data= xdata=


-39-

code= EJERCICIO 4: FUNCIÓN NATURAL_A_ASCII( ) 4.1. Función Natural_a_ASCII_1(). Sin funciones de librería Código de la función Natural_a_ASCII_1(): Uso de la memoria:

data= xdata= code=

Tiempo medio de ejecución de la función Natural_a_ASCII_1():


-40-

Pruebas realizadas:

Valor Resultado obtenido

0

20

107

3000

8421

9999

10000

63211

4.2. Función Natural_a_ASCII_2(). Con funciones de librería Código de la función Natural_a_ASCII_2(): Uso de la memoria:

data= xdata= code=


-41-

Tiempo medio de ejecución de la función Natural_a_ASCII_2(): ¿Cuál de las dos funciones utilizaría? Razone la respuesta considerando criterios de menor uso de memoria y de mayor velocidad de ejecución.

LABORATORIO DE SISTEMAS DIGITALES II - OCW...

Documents

Transcript of LABORATORIO DE SISTEMAS DIGITALES II - OCW...