Está en la página 1de 11

Facultad de Ciencias Informáticas – FACCI

Estudiantes
Kevin Anthony Anzules Castro
Karolyn Valeria Barreiro Santana
Bryan Alberto Herrera Macías

Proyecto Lenguaje Ensamblador


Ejercicios

Nivel:
Quinto “A”

Asignatura:
Organización y Arquitectura del Computador

Docente:
Ing. Viviana García Macías

2017 – 2018 (2)


Introducción
Al hablar del lenguaje ensamblador, nos referimos a uno de los lenguajes de bajo nivel utilizados
para escribir programas informáticos, el cual constituye la representación más directa del código
máquina específico para cada arquitectura de microprocesador. Una computadora digital o,
mejor dicho, su parte física, sólo distingue datos de tipo binario, es decir, los valores a los que
se denomina valor 0 y valor 1. Para representar datos que contengan una información se utilizan
una serie de unos y ceros cuyo conjunto indica dicha información.

La información que hace que el hardware de la computadora realice una determinada actividad
se llama instrucción. Por consiguiente una instrucción es un conjunto de unos y ceros. Las
instrucciones en conjunto, equivalen a acciones elementales de la máquina, por lo que al
conjunto de dichas instrucciones que son interpretadas directamente por la máquina se le
denomina lenguaje máquina o código objeto.

La importancia del lenguaje ensamblador radica en que se trabaja directamente con el


microprocesador; por lo cual se debe de conocer el funcionamiento interno de este, se tiene la
ventaja de que en él se puede realizar cualquier tipo de programas que en los lenguajes de alto
nivel no se los puede realizar. Además, los programas en ensamblador ocupan menos espacio
en memoria.

En el presente proyecto, se realizaron 3 diferentes tipos de ejercicios en lenguaje ensamblador,


para demostrar en detalles: el código, la estructura y las instrucciones que generalmente se
utilizan en este tipo de lenguaje de bajo nivel. La computadora no entiende directamente el
lenguaje ensamblador, es necesario traducirle al lenguaje máquina; por lo que se utilizó un
programa ensamblador, con el cual se pudo realizar fácilmente dicha conversión de código
fuente a código objeto, simplemente digitando el código del lenguaje ensamblador.
Objetivos

Objetivo General

Desarrollar por medio de un lenguaje ensamblador, para de esta manera demostrar los
conocimientos adquiridos a través de una práctica básica de desarrollo ensamblador.

Objetivos Específicos

 Analizar los posibles 3 ejercicios a realizar en Mplab.


 Realizar un esquema para el desarrollo de los ejercicios.
 Desarrollar la codificación de los ejercicios en el programa.
 Verificar su correcto desarrollo en el programa Proteus.
Ejercicio #1

Desarrollar en lenguaje ensamblador un ejercicio acerca del funcionamiento de


un semáforo.

_CONFIG 0x318
List p=16f628a
; creamos 3 variables para el retardo del semáforo
P EQU 0x21
N EQU 0x22
M EQU 0x23
; Utilizamos la dirección de memoria para la asignación de variables
BSF STATUS, 5
CLRF TRISB
BCF STATUS, 5
MOVLW D'7'
MOVWF CMCON; creamos la configuración del puerto
CLRF PORTB; La cual solo configuraremos el puerto B
PRINCIPAL
; LED VERDE
MOVLW B'00000001'
MOVWF PORTB
MOVLW D'15'
MOVWF P
CALL RETARDO
; CAMBIO PARPADEO DE EN ESTADO ALTO Y BAJO PARA EL CAMBIO DE COLOR
MOVLW B'00000001'
MOVWF PORTB
MOVLW D'2'
MOVWF P
CALL RETARDO
MOVLW B'00000000'
MOVWF PORTB
MOVLW D'2'
MOVWF P
CALL RETARDO
MOVLW B'00000001'
MOVWF PORTB
MOVLW D'2'
MOVWF P
CALL RETARDO
MOVLW B'00000000'
MOVWF PORTB
MOVLW D'2'
MOVWF P
CALL RETARDO
MOVLW B'00000001'
MOVWF PORTB
MOVLW D'2'
MOVWF P
CALL RETARDO
; LED AMARILLO HACE CAMBIO A COLOR Y EL TIEMPO SE CAMBIA
MOVLW B'00000010'
MOVWF PORTB
MOVLW D'5'
MOVWF P
CALL RETARDO
; LED ROJO HACE EL CAMBIO DE COLOR Y EL TIEMPO QUE TARDA
MOVLW B'00000100'
MOVWF PORTB
MOVLW D'10'
MOVWF P
CALL RETARDO
GOTO PRINCIPAL
; TENEMOS QUE TENER ENCUENTA QUE SIEMPRE HACE EL LLAMADO AL RETARDO
; AHORA CREAMOS LA SUBRUTINA DEL RETARDO
; TENEMOS QUE TENER EN CUENTA QUE TODOS LOS MICROCONTROLADORES POSSEN
MICRORELOJ
; LA CUAL TRABAJAN CON NUMERO DE CLICOS DE RELOJ PARA SU EJECUCIÓN TIENE EL
CICLO MAQUINA
; LA CUAL ES 4 VECES EL CICLO RELOJ

RETARDO
; REGRESAMOS AL SIGUIENTE BUCLE QUE TENDRÁ DE VALOR 80 QUE SERÁ EL RETARDO
A 1 DECIMA DE SEGUNDO
TRES
MOVLW D'80'
MOVWF M
DOS
; TENEMOS UNA VARIABLE CON VALOR DE 250 Y CADA QUE SE EJECUTE EJECURA 2
INSTRUCCIONES MUERTAS
; CUANDO SE ENCUENTRA LA BANDERA ACTIVADA REGRESA CON 3 MIROSEGUNDOS Y
SE EJECUTARAN A 1,2 MS
MOVLW D'250'
MOVWF N
;
UNO
; ESTOS LOS DEFINIMOS PARA EMPEZAR
NOP
NOP
; ESTE ES UN BUCLE QUE HACE UN DECREMENTO EN 1 SOBRE 1 REGISTRO HASTA QUE
SEA 0
; Y PREGUNTA POR UNA BANDERA HASTA QUE LLEGUE A 0
; Y CUANDO ESTA EN 0 SE SALTA DE INSTRUCCION Y NO LO ESTA CONTINUA CON LA
SIGUIENTE
DECFSZ N,1
GOTO UNO
DECFSZ M,1
GOTO DOS
DECFSZ P,1
GOTO TRES
RETURN
END

Ejercicio #2

Desarrollar en lenguaje ensamblador un ejercicio que permita ejecutar un


temporizador.

List p=16F886 ; Tipo de procesador.


Include "P16F886.INC" ; Definiciones de registros internos.
; Ajusta los valores de las palabras de configuración durante el ensamblado. Los bits no
empleados
; Adquieren el valor por defecto. Estos y otros valores se pueden modificar según las
necesidades
__config _CONFIG1,_LVP_OFF&_PWRTE_ON&_WDT_OFF&_EC_OSC&_FCMEN_OFF&_BOR_OF
; Palabra 1 de configuración
__config _CONFIG2, _WRT_OFF&_BOR40V ;
Palabra 2 de configuración
Valor equ .20 ; Constante para temporizar 1 seg (50mS*20)
Temp equ 0x020 ; Variable para la temporización
org 0x00 ; Vector de RESET
goto Inicio
org 0x05

;*******************************
;Delay: El Timer 0 realiza un retardo de 50mS que se repite tantas veces como se indica en
la
;constante valor
Delay movlw Valor
movwf Temp ;Nº de veces a temporizar 50 mS
Delay_1 movlw ~.195
movwf TMR0 ;Inicia el Timer 0 con 195 (195*256=49.9mS)
bcf INTCON,T0IF ;Repone flag del TMR0
Delay_2 btfss INTCON,T0IF ;Fin de los 50mS ??
goto Delay_2 ;No, el TMR0 no ha terminado
decfsz Temp,F ;Decrementa el contador. Fin de
temporización ??
goto Delay_1 ;No, el TMR0 temporiza otros 50 mS
return ;Si, final de la temporización
; Programa principal
Inicio clrf PORTB ; Borra los latch de salida
bsf STATUS,RP0
bsf STATUS,RP1 ;Selecciona banco 3
clrf ANSEL ;Puerta A digital
clrf ANSELH ;Puerta B digital
bcf STATUS,RP1 ;Selecciona banco 1
movlw b'11111110'
movwf TRISB ;RB0 se configura como salida
movlw b'00111111'
movwf TRISA ;RA5:RA0 se configuran como entrada
movlw b'00000111'
movwf OPTION_REG ;TMR0 con reloj interno y preescaler de 256

bcf STATUS,RP0 ;Selecciona banco


;Este es el cuerpo principal del programa. Espera a que en RA0 se detecte un flanco
descendente
Loop btfsc PORTA,0 ;RA0=0 ??
goto Loop ;No, esperar
bsf PORTB,0 ;Si activar RB0
call Delay ;Temporizar
bcf PORTB,0 ;Desactivar RB0
goto Loop ;Repetir el proceso
end
Ejercicio #3

Desarrollar en lenguaje ensamblador un ejercicio que permita hacer girar un


motor a distintas velocidades.

;+----------------------------------------------------------------------+
;| ENCABEZADO |
;+----------------------------------------------------------------------+
LIST p = 16F84 ; Usar el PIC16F84A-04/P
RADIX HEX ; Todo en hexadecimal
;+----------------------------------------------------------------------+
;| VARIABLES |
;+----------------------------------------------------------------------+
w equ 0 ; Cuando d=0 el destino es w
f equ 1 ; Cuando d=1 el destino es f
PUERTOA equ 0x05 ; Dirección del Puerto A
PUERTOB equ 0x06 ; Dirección del Puerto B
ESTADO equ 0x03 ; Dirección del Estado
PCL equ 0x02 ; Dirección de PCL
Aux1 equ 0x0D
Aux2 equ 0x0E
npaso equ 0x20 ; Dirección del reg que lleva el conteo
de los pasos.

;+-----------------------------------------------------------------------------+
;| CONFIGURACIÓN DEL PUERTO B COMO SALIDA |
;| Y EL PUERTO A COMO DE SALIDA |
;+-----------------------------------------------------------------------------+
ORG 0x00 ; Dirección de inicio
BSF ESTADO,5 ; Pasarse al Banco 1
MOVLW 0x00
MOVWF PUERTOB ;Establecer el Puerto B como de
salida
MOVLW 0x0F
MOVWF PUERTOA ;Puerto A como de entrada RA0-
RA3
BCF ESTADO,5 ;Volver al banco 0
;+----------------------------------------------------------------------+
;| PROGRAMA PRINCIPAL |
;+----------------------------------------------------------------------+
;inicio
Inicio CLRF npaso ;Borrar contenido de npaso
Test BTFSS PUERTOA,0 ;El bit 0 del puerto A es 1?
GOTO Inicio ;No, ir a inicio
BTFSC PUERTOA,1 ;Si,El bit 1 del puerto A es 0?
GOTO VelMax ;No, gira a vel max
BTFSC PUERTOA,2 ;Si, el bit 2 del puerto A es 0?
GOTO VelMin ;No, gira a vel min
GOTO Inicio ;Si, vuelve al testeo
;fin
;+----------------------------------------------------------------------+
;| GIRA MOTOR A VEL MAX |
;+----------------------------------------------------------------------+
;inicio
VelMax MOVF npaso,w ;Pasar a W el contenido de contador
CALL TablaD ;Llamar la tabla de pasos
MOVWF PUERTOB ;Mandar al Puerto B el valor obtenido
CALL Retardo1 ;llamar la subrutina de retardo
INCF npaso,f ;Incrementar npaso = npaso + 1
MOVLW 0x04 ;Mover b'00000100' a W
XORWF npaso,w ;Hacer ope XOR cuenta con W
BTFSS ESTADO,2 ;¿El contador es igual a 4?
GOTO Test ;No,va a ciclo
GOTO Inicio ;Si, regresa al testeo
;fin
;+----------------------------------------------------------------------+
;| GIRA MOTOR A VEL MIN |
;+----------------------------------------------------------------------+
;inicio
VelMin MOVF npaso,w ;Pasar a W el contenido de contador
CALL TablaD ;Llamar la tabla de pasos
MOVWF PUERTOB ;Mandar al Puerto B el valor obtenido
CALL Retardo ;Llamar la subrutina de retardo1
INCF npaso,f ;Incrementar npaso = npaso + 1
MOVLW 0x04 ;Mover b'00000100' a W
XORWF npaso,w ;Hacer ope XOR cuenta con W
BTFSS ESTADO,2 ;¿El contador es igual a 4?
GOTO Test ;No,va a ciclo
GOTO Inicio ;Si, regresa al testeo
;fin
;+----------------------------------------------------------------------+
;| RETARDO DE 60 mlSeg |
;+----------------------------------------------------------------------+
Retardo MOVLW .33 ; 1 set number of repetitions (B)
MOVWF Aux1 ;1|

PLo MOVLW .60 ; 1 set number of repetitions (A)


op1
MOVWF Aux2 ;1|
PLoop2 CLRWDT ; 1 clear watchdog
CLRWDT ; 1 cycle delay
DECFSZ Aux2,1 ; 1 + (1) is the time over? (A)
GOTO PLoop2 ; 2 no, loop
DECFSZ Aux1,1 ; 1 + (1) is the time over? (B)
GOTO PLoop1 ; 2 no, loop
CLRWDT ; 1 cycle delay
RETURN ; 2+2 Done
;fin
;+----------------------------------------------------------------------+
;| RETARDO DE 30 mlSeg |
;+----------------------------------------------------------------------+
Retardo1 MOVLW .15 ; 1 set number of repetitions (B)
MOVWF Aux1 ;1|
PLoop1 MOVLW .30 ; 1 set number of repetitions (A)
MOVWF Aux2 ;1|
PLoop2 CLRWDT ; 1 clear watchdog
CLRWDT ; 1 cycle delay
DECFSZ Aux2,1 ; 1 + (1) is the time over? (A)
GOTO PLoop2 ; 2 no, loop
DECFSZ Aux1,1 ; 1 + (1) is the time over? (B)
GOTO PLoop1 ; 2 no, loop
CLRWDT ; 1 cycle delay
RETURN ; 2+2 Done
;fin
;+----------------------------------------------------------------------+
;| TABLA MOTOR GIRA A LA DERECHA |
;+----------------------------------------------------------------------+
TablaD ADDWF PCL,f
RETLW B'00001001' ;09
RETLW B'00000011' ;03
RETLW B'00000110' ;06
RETLW B'00001100' ;0C

END ;Fin del programa


Conclusiones
 La importancia del lenguaje ensamblador radica en que se trabaja directamente
con el microprocesador; por lo cual se debe de conocer el funcionamiento
interno de este, se tiene la ventaja de que en él se puede realizar cualquier tipo
de programas que en los lenguajes de alto nivel no se los puede realizar.
 La información que hace que el hardware de la computadora realice una
determinada actividad se llama instrucción. Por consiguiente una instrucción es
un conjunto de unos y ceros.