SISTEMAS EMBEBIDOS

Fase 1: Cdigos assembler:

Tipos
assembler

de

Assembler cruzados

Instrucciones simblicas
Una instruccin
en ensamblador consta de cdigos de
operacin, operaciones, operandos y
Comentarios.
La etiqueta
, es el smbolo que aadido a una
instruccin permite que se pueda
referenciar
Simblicamente en el programa.
El cdigo de operacin
, es generalmente un smbolo, aunque
en algunos sistemas es un
entero octal, hexadecimal o decimal que
indica la operacin que se quiere
realizar.
El campo operando
,
es un campo de direccin de datos que
puede estar dividido en varios
subcampos de acuerdo con la
constitucin interna de la computadora
correspondiente.
El comentario
, que no es obligatorio, no es procesado
por el ensamblador. Nos dice que
las instrucci
ones pueden ser de formato fijo, formato
libre y formato mixto.
ORG
Esta pseudo instruccin que proporcione
informacin acerca de alguna parte
de la traduccin.
LDA SUB
Instruccin que permite cargar el
sustraendo a AC. El nomb
re simblico de la
operacin es LDA.
SUB
Indica que es un smbolo de direccin.
CMA
Instruccin de maquina que representa
un complemento.
INC
Instruccin que indica un incremento a
AC.
ADD MIN
Permite sumar el minuendo a AC.
MIN
El valor binario de la parte de direccin
debe obtenerse un smbolo de

2
direccin MIN.
STA DIF
Permite almacenar la diferencia.
DIF
El valor binario de la parte de direccin
debe obtenerse un smbolo de
direccin DIF.
HLT
Instruccin que nos permite detener la
computadora.
DEC N
Este es un nmero decimal con signo N
para convertirse en binario.
Dos lneas del programa simblico
especifican operando decimales con la
pseudo
instruccin DEC.
HEX 0
La diferencia se encuent
ra almacenada aqu.
END
Fin del programa simblico y nos indica
que ya no hay lneas para traducir.
TABLA DE INSTRUCCIONES
Smbolo
Cdigo hexadecimal
Descripcin
AND
0u8
Aplicar AND M a AC
ADD
1o9
Sumar M a AC, acarrear E
LDA
2oA
Cargar AC desde M
STA
3oB
Almacenar AC en M
BUN
4oC
Brincar en forma condicional a M
BSA
5oD
Salvar la direccin de retorno en M
ISZ
6oE
Incrementar M y saltar si hay un cero
CLA
7800
Borrar a AC
CLE
7400
Borrar E
CMA
7200
Complementar a AC
CME
7100
Complementar E
CIR
7080
Circular a la derecha E y AC
CIL
7040
Circular a la izquierda E y AC

3
INC
7020
Incrementar AC
SPA
7010
Brincar si AC es positivo
SNA
7008
Brincar si AC es negativo
SZA
7004
Brincar si AC es cero
SZE
7002
Brincar si E es cero
HLT
7
001
Introducir y borrar bandera
OU
F400
Sacar informacin y borrar bandera
SKI
F200
Saltar si la bandera de entrada esta
activada
SKO
F100
Saltar si la bandeja de salida esta
activada
ION
F080
Habilitar la interrupcin
IOF
F040
Deshabilitar interrupcin

De una fase
residentes

demores

SEGMENT
ASSUME CS:demores, DS:demores
ORG 100h

inicio:
JMP main
controla_int08 PROC
PUSHF
CALL CS:ant_int08 ; llamar al gestor
normal de INT 8
STI
CMP CS:in10,0
JNE fin_int08
; estamos dentro de
INT 10h
;
; Colocar aqu el proceso a ejecutar
18,2 veces/seg.
; que puede invocar funciones de INT
10h
fin_int08:
IRET
controla_int08 ENDP
controla_int10 PROC
INC CS:in10

; indicar entrada en

4
INT 10h
PUSHF
CALL CS:ant_int10
DEC CS:in10
; fin de la INT 10h
IRET
controla_int10 ENDP
in10
DB 0
; mayor de 0 si hay
INT 10h
ant_int08
LABEL DWORD
ant_int08_off DW ?
ant_int08_seg DW ?
ant_int10
LABEL DWORD
ant_int10_off DW ?
ant_int10_seg DW ?
; Dejar residente hasta aqu.
main:

PUSH ES
MOV AX,3508h
INT 21h
; obtener vector de

INT 8
MOV ant_int08_seg,ES
MOV ant_int08_off,BX
MOV AX,3510h
INT 21h
; obtener vector de
INT 10h
MOV ant_int10_seg,ES
MOV ant_int10_off,BX
POP ES
LEA DX,controla_int08
MOV AX,2508h
INT 21h
; nueva rutina de INT
8
LEA DX,controla_int10
MOV AX,2510h
INT 21h
; nueva rutina de INT
10h
PUSH ES
MOV ES,DS:[2Ch]

; direccin del

entorno
MOV AH,49h
INT 21h

; liberar espacio de

entorno
POP ES
LEA DX,main

; fin del cdigo

ADD DX,15

; redondeo a

MOV CL,4
SHR DX,CL
MOV AX,3100h

; bytes -> prrafos

; terminar

residente
prrafo

residente
INT 21h
demores

ENDS
END inicio

Fig 1. Programa principal

Fig.2 carpeta include.

Fig 3.compilacion:

El operador AND (&)

:
El operador AND compara dos bits; si los dos son 1 el resultado es 1,
en otro caso el resultado ser 0
El operador OR (
|
)
:
El operador OR compara do
s bits; si cualquiera de los dos bits es 1,
entonces el resultado es 1; en otro caso ser 0
El operador XOR (
^
)
:
El operador OR exclusivo o XOR, dar como resultad
o un 1 si
cualquiera de los dos operandos es 1, pero no los dos a la vez
operador de complemento (
~operadores de desplazamiento a nivel de bit (
<<
y
>>
)
:

Desplazan a la
izquierda o a la
derecha un nmero especificado de bits. En un desplazamiento a la izquierda los
bits que
sobran por el lado izquierdo se descartan y se rellenan los nuevos espacios con
ceros. De
manera anloga pasa con los desplazamientos a la derecha.
Operadores lgicos:
)
:
Este operador devuelve como resultado el
complemento a uno del operando

Operadores relacionales:

Comparacin de operadores:

Tipos y tamao de datos:

Los compiladores C presentan iferentes tamaosen los datos comunes y lo suelen
hacer a considerando la eficiencia de cada procesador. Pero se deben tener unas
rigurosidades asi:
sizeof
(char) <=
sizeof
(short) <=
sizeof
(int) <=
sizeof
(long)
Donde:
1.char :con tamao suficiente para el conjunto de caracteres bsico.
2.short :al menos de 16 bits
3.long: de al menos de 32bits
Con el fin de evitar conflictos en los tamaos de las variables al traspasar cdigo
desde una plataforma a otra, el estndar C99 (Es la revisin de 1999 de C)
incluy los siguientes tipos de datos:
int8_t, int16_t, int32_t, int64_t -uint8_t, uint16_t, uint32_t, uint64_tDonde int8_t es
un entero de 8 bits incluyendo el signo,int16_t es uno de 16 bits, etc.
Las anteriores definiciones se encuentran en un header llamado stdint.h y
solucionan el inconveniente anterior siempre y cuando el compilador sea
compatible con C99 dentro de estos operadores se encuentran los modificadores y
son:
el static, el voltil,const.

El punto flotante:
los nmeros en coma flotante son usados, normalmente, para aproximar valores
analgicos y continuos, por que dan una mayor resolucin que los enteros. Las
variables tipo float tienen el valor mximo 3.4028235E+38, y mnimo pueden
alacanzar el -3.4028235E+38. Ocupan 4bytes (32bits).
Los punteros:
Se puede decir que el puntero es como una flecha apuntando a otra variable. Esa
variable no es ms que una direccin de memoria, el puntero indicara pues
donde estaa almacenado el valor de la variable a la que apunta.
Entonces al declarar un puntero lo que se hace es reservar espacio para
almacenar una direccin de memoria, no el contenido de la variable .
Declaracin de punteros:
el puntero es una variable. Asi pues los punteros podrian dar la impresin de que
son elementos separados de las variables. No es as. Son variables, y se le puede
asignar nuevos valores, e incluso realizar algunas operaciones aritmticas tiles
con ellos. Una variable de tipo puntero est ntimamente ligada con el tipo al que
apunta. Por ende, en la declaracin, se escribe el nombre del tipo al que apuntar
el puntero, seguido de asterisco, y por ltimo, el nombre del puntero.
Ejemplo:
int
*p_entero;
float
*p_real;
char
*c
aracter;
operadores de contenido y de indireccion:
El operador de indireccin &: se utiliza para referirse a la direccin de una
variable, as el cdigo siguiente :
/* Reservamos 4 bytes para almacenar una direccin de memoria
*/int*p_entero;/* Reservamos 4 bytes para almacenar un entero */
int
entero;
/* Escribimos en la variable p_entero la direccin de entero */
p_entero = &entero;

El operador *:
se utilizar para manejar la direccin a la que apunta un puntero. Se Podra llamar
el operador de acceso. Tanto el operador de acceso, como el de indireccin,
funcionan en notacin prefija. Asi:
int
*p_entero;
int
entero1,
entero2;
entero1 = 2;
entero2 = 5;
p_entero = &entero1;
entero1 = *p_entero + entero2;
Funciones:
Declaracin y definicin
declaracin: prototipo (interfaz), funcin abstracta.
definicin: la funcin misma.
Ejemplos:
int optimo(int a, int b);
int optimo(int a, int b)
{
int aux = a;
/* cuerpo... */
return aux;
}
Del tipo prototipo , definicin y llamada:
int optimo(int a, int b);
main(){
/* codigo... */
c = optimo(a,b);
}
int optimo(int a, int b)
{
/* cuerpo... */
return aux;
}

10

11