UNIVERSIDAD AUTÓNOMA DE BAJA CALIFORNIA
INGENIERIA EN COMPUTACIÓN
2019-2
Reporte Practica No. 1
Alumno
Chacón Chávez Giovanni Emmanuel
Matricula
1237208
Materia
Microprocesadores y Microcontroladores
16 de agosto de 2019.
Práctica No. 1
Introducción al intérprete 80X86 sobre la plataforma T-Juino
Objetivo: El alumno se familiarizará con el intérprete 80X86 (modo 16bits) sobre la
plataforma T-Juino. Esto con el fin de desarrollar programas en lenguaje
ensamblador para dicha plataforma.
Material:
• Computadora Personal (PC)
• Programa Edito de texto (ASCII), TASM y TLINK
• Tarjeta T-Juino (con intérprete 80x86)
• Manejador FTDI instalado
Equipo:
• Computadora Personal
• Programa emulador de terminal
Introducción
La tarjeta T-Juino es una plataforma de hardware basada en un PCB con un
microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de
microcontroladores en proyectos multidisciplinarios.
T-Juino fue diseñado para ser compatible con la plataforma libre llamada Arduino
(específicamente Arduino Mega) y el sistema SM8088 de UABC. El hardware
consiste en una placa con un microcontrolador Atmel AVR con sus puertos de
entrada/salida expuesto mediante conectores. El microcontrolador utilizado en el
diseño es el Atmega1280 y para el desarrollo de software se puede utilizar entornos
de desarrollo libres como Arduino IDE, Wiring o WinAVR+ Programmer notepad.
Es importante remarcar que una diferencia con la plataforma Arduino es que en T-
Juino se cuenta con una máquina virtual (VM88) del procesador 80x86 de 16 bits
desarrollada en UABC. Esta máquina lo hace compatible con los programas
ejecutables que fueron desarrollados para la plataforma SM8088 basada en el
procesador clásico de Intel 80C88.
Desarrollo:
a) Conecte la tarjeta T-Juino a la computadora personal (PC) mediante el cable
USB conecte y asegúrese que haya sido reconocido como un puerto serie.
b) Ejecute un programa emulador de terminal (p.e. MTTTY) y configure la
comunicación serie a 19200,8, N,1 (Velocidad 19200 Baud, 8 bits de datos,
No paridad y 1 bit de paro.).
c) Seleccione el puerto serie a utilizar correspondiente al puerto donde haya
sido reconocido T-Juino.
d) Una vez establecidos todos los parámetros proceda a realizar la
comunicación mediante el botón de “Connect”
e) Si la comunicación es exitosa aparecerá el símbolo de interrogación junto
con el de mayor que (?>). En ese comento presione la tecla ENTER para
entrar en modo “monitor”. Nota: Puede presionar el botón de RESET de T-
Juino para intentarlo de nuevo.
f) El modo monitor presenta la pantalla de inicio mostrada en Figura 2 y estando
en ese modo se puede interactuar con el intérprete.
Los comandos aceptados en este modo se pueden mostrar mediante la tecla ? que
corresponde al comando de help.
Nota: no todos los comandos desplegados están implementados y algunos se
encuentra en proceso de su implementación.
Los comandos del modo monitor se muestran a continuación.
*clear C <range>
dump D <range>
*enter E address <list>
*fill F range list
go G
help ?
input I port
load L
*move M range address
output O port value
ports P
quit Q
register R <register value>
trace T
unassemble U <range>
version V
zero (rst) Z
* - in process
Comandos
d – dump: hace un desplegado del contenido de un rango de memoria, el
desplegado se hace en formato decimal y ASCII (si el contenido es
desplegable).
g – go: ejecuta el programa que se encuentra cargado en la memoria a partir
de la dirección 100h.
?– help: muestra la lista de comandos permitidos en el modo monitor. i –
input: leer un byte de un puerto dado.
l – load: carga en memoria un archivo (programa) a partir de la dirección
100h.
o – output: escribe un byte a un puerto dado.
p – ports: muestra el valor actual de los puertos de entrada-salida (E/S).
q – quit: sale del modo monitor e inicia el modo de ejecución.
r – registers: muestra el valor actual de todos los registros del procesador,
además puede ser usado para modificar los registros del procesador.
t – trace: ejecutar la instrucción apuntado por el CS:IP y muestra los valores
resultantes de los registros.
u –unassemble: desensambla un rango de memoria dado mostrando los
mnemómicos correspondiente.
v – version: muestra la versión del interprete que se encuentra cargada en T-
Juino.
z – reset: realiza un reset sobre el intérprete inicializando todos sus registros
en cero excepto IP que lo inicializa en 100h.
1) Basándose en listado 1 crear in archivo texto llamado pra1.asm.
Listado 1
.model tiny
;----- Insert INCLUDE "filename" directives here
;----- Insert EQU and = equates here
locals
.data
Mens DB 'Hola Mundo',10,13,0
.code
org 100h
;*************************************************************
; Procedimiento principal
;*************************************************************
principal proc
mov sp,0fffh ; inicializar SP (Stack Pointer)
@@ini0: mov dx,1
@@ini1: mov cx,dx
@@sigue: mov al,'x'
call putchar
loop @@sigue
mov al,10
call putchar
mov al,13
call putchar
inc dx
cmp dx,20
jbe @@ini1
jmp @@ini0
ret ; nunca se llega aquí
endp
;***************************************************************
; procedimientos
;***************************************************************
putchar proc
push ax
push dx
mov dl,al
mov ah,2 ; imprimir carácter DL
int 21h ; usando servicio 2 (ah=2)
pop dx ; del int 21h
pop ax
ret
endp
end principal ; fin de programa (file)
2) Descargue los programas tasm.exe, tlink.exe de moodle (curso
Microprocesadores y Microcontroladores en http://uabc-io.net) y deposítelos
en un directorio exclusivo de trabajo (por ejemplo. C:\uPuC\).
3) Ensamble el programa prac1.asm mediante la línea de comando:
C:\uPuC>tasm prac1.asm
Esto generará el archivo prac1.obj
4) Encadena el archivo obj para generar programa .com mediante la línea de
comando:
C:\uPuC> tlink /t prac1.obj
Esto generará el archivo ejecutable prac1.com
5) Cargar y ejecutar el programa pract1 en T-Juino
1. Elaborar un diagrama de flujo para ejecutar un programa sobre la tarjeta
T-Juino (incluyendo el caso en el que no cuenta con el intérprete del
8088).
2. Terminar la implementación del juego de “Bulls and Cows” en base al
código dado en el sitio [bull_cows.asm]. Cumpliendo con las siguientes
funcionalidades:
a) Implementar el procedimiento “evalGuess” en base a las instrucciones
dadas en el código.
b) Implementar el flujo del juego, donde el final del juego es dado por las
siguientes dos condiciones:
i. Ganaste: Se aciertan los 4 dígitos en sus posiciones correctas,
o
ii. Perdiste: Se da después de exceder 8 intentos de adivinar la
secuencia.
Conclusiones y Comentarios.
El desarrollo de esta práctica consistió en aprender a usar un interprete x88 para
poder ejecutar aplicaciones desarrolladas bajo este entorno (Ensamblador x88), en
una placa que contiene un microcontrolador ATMEGA1280 o 2560, según sea el
caso.
Primeramente, tuvimos una introducción a esta plataforma conociendo sus
características, tales como: uso de memoria, uso de pila, entre otras. Después,
vimos como adaptar un programa codificado en Ensamblador x88, para que pudiera
ejecutarse en dicha plataforma. Esto se logra cargando en la tarjeta un intérprete
que es el encargado de tomar las instrucciones de nuestro programa .ASM y
convertirlas al formato en el que el microprocesador de la tarjeta puede ejecutarlas.
Finalmente, todo lo mencionado anteriormente se aplicó en la realización de un
algoritmo que le da su funcionamiento a un juego que se llama toros y vacas, el cual
se explica a continuación:
Toros y vacas es un juego tradicional a lápiz y papel para dos jugadores, cuyo
objetivo es adivinar un número constituido por cuatro dígitos.
En una hoja de papel, un jugador escribe un número de 4 dígitos y lo
mantiene en secreto. Las cifras deben ser todas diferentes, no se debe repetir
ninguna dentro del mismo número. El otro jugador trata de adivinar el número
secreto en varios intentos que son anotados y numerados. En cada intento
anota una cifra de cuatro dígitos completa, ésta es evaluada por el jugador
que guarda el número secreto. Si un dígito está presente y se encuentra en
el lugar correcto es evaluada como un toro, si un dígito está presente pero se
encuentra en un lugar equivocado es evaluada como una vaca. La evaluación
se anota al lado del intento. El otro jugador gana cuando, es este caso, el
numero de toros es 4 y el numero de vas en 0, en cualquier otro caso el
jugador pierde después de un determinado número de intentos
Uno de los problemas que se me presento al momento de estas realizando y
probando mi código, era el hecho de que el algoritmo lograba contar las vacas
correctamente, pero a pesar de saber que estaba introduciendo datos correctos, no
lograba contar los toros. Básicamente, mi algoritmo consta de los siguientes pasos:
1. El registro SI apunta a la primera posición (primer digito) de la cifra secreta,
mientras que DI a la primera posición de la cifra con la que se intenta adivinar.
2. Lo que apunta SI se compara con lo que apunta DI, si son iguales esto quiere
decir que por ahora, un digito del intento se encuentra en la cifra secreta y
este sería una vaca.
3. Para saber si se trata se un toro, se debe evaluar si los dígitos apuntados por
SI y DI se encuentra en la misma posición. Esto podría hacerse comparando
SI con DI directamente, pero esto no es correcto, ya que estos indican
posiciones de memoria, mas no posiciones en un arreglo. Cabe destacar que,
es importante tener esto en cuenta, ya que por ello mi algoritmo no lograba
contabilizar los toros, a pesar de que estos existieran.
Para hacer esto, hice uso de BX como contador de posiciones auxiliar. BL se
incrementa cuando DI lo hace, mientras que BH lo hacer cuando cambia SI.
Otra cosa que tome en consideración es que DI debe regresar a su valor
original cada vez que se incremente SI, para logar esto use BP para
auxiliarme en el cambio de DI y preservar el valor de este último.
4. Si las posiciones no coinciden, evidentemente se trata de una vaca. Pero si
estas coinciden se trata de un toro.
5. Si los puntos 2 y 4 no se cumplen, el algoritmo analiza los siguientes dígitos.
