Practica de Arquitectura

UNIVERSIDAD POLITCNICA SALESIANA
SEDE GUAYAQUIL
DOCUMENTO DE PRCTICAS
JOSUE MONCAYO
AO LECTIVO
PERIODO 50
Prctica 1: Uso del simulador
1. Comprensin del programa asignado y explicacin de cada instruccin.
MOV BL,80
PUSH BL
main:
POP AL
XOR AL,0
PUSH AL
OUT 03
MOV AL,30
CALL 90
; ---------------------------------------------------
MOV CL,20
Bang:
DEC CL
JZ Main
IN 03
CMP AL,80
JZ turnOn
CMP AL,81
JZ turnOff
CMP AL,0
JZ turnOn
turnOff:
MOV AL,0
OUT 03
jmp Bang
turnOn:
MOV AL,80
OUT 03
jmp Bang
; ---------------------------------------------------
ORG 90
PUSH AL
delay:
DEC AL
JNZ delay
POP AL
RET
; ---------------------------------------------------
END
; ---------------------------------------------------
Prctica 2: Programacin en lenguaje ensamblado
1. Copiar el texto del programa modificado, explicar su funcionalidad,

Mostrar la ejecucin (printscreen)
CLO
MOV BL,80
PUSH BL
main:
MOV CL, 80
POP AL
OR AL,0
PUSH AL
OUT 03
MOV AL,0
CALL 90
; ---------------------------------------------------
MOV CL,40
Bang:
DEC CL
JZ Main
IN 03
CMP AL,80
JZ turnOn
CMP AL,81
JZ turnOff
CMP AL,20
JZ turnOn
turnOff:
MOV AL,20
OUT 03
jmp Bang
turnOn:
MOV AL,80
OUT 03
jmp Bang
; ---------------------------------------------------
ORG 90
PUSH AL
delay:
DEC AL
JNZ delay
POP AL
RET
; ---------------------------------------------------
END
; ---------------------------------------------------
Prctica N3
1.- Complete la siguiente tabla:
Instrucciones Significado Tipo de

direccionamiento
MOV AX,1B Transfiere AX,al registro 1B Transferencia de

datos
ADD AX,BX Aade BX al registro AX Aritmticas
ADD [BL], 5 Aade 5 a la direccin BL Aritmticas
SUB BX,DX Restar BX de DX Aritmticas
MOV BL, [BO] Transfiere lo que est en la Transferencia de

direccin[BO] al registro BL datos
INC BX Incrementa en una al registro BX,a la Aritmticas

memoria RAM
JMP 102 Saltar la etiqueta 102 Salto
2.- Elabore un cuadro de diferencias y semejanzas entre las arquitecturas CISC y

RISC.
Arquitecturas Semejanzas Diferencias
CISC los dos procesadores realiza un computadoras con un conjunto de

conjunto de instrucciones instrucciones complejos
RISC los dos procesadores realiza un computadoras con un conjunto de
conjunto de instrucciones instrucciones reducidos
3.- Elabore el Diagrama de Gantt de las instrucciones del documento

a.- Diagrama secuencial
b.- Paralelismo
c.- Segmentacin
LOAD A,M
LOAD B,M
SUB C<-A-B
NOOP
STORE C
4.- Del chuletario de instrucciones, indique una instruccin de cada tipo
SALTO CONDICIONAL : IF
SALTO INCONDICIONAL : JMP
SALIDA A PUERTOS : OUT

ENTRADA A PUERTOS: IN
Y LGICO: AND
O LGICO : OR
5.- Escriba los nombres de 3 procesadores RISC y CISC vigentes

RISC
El procesador SPARC de Sun Microsystems.
El procesador UltraSPARC de Fujitsu.
Los procesadores XAP usados en muchos chips wireless de poco consumo (Bluetooth,
wifi) de CSR.
CISC
MIPS, Millions Instruction Per Second.
PA-RISC, Hewlett Packard.
SPARC, Scalable Processor Architecture, Sun Microsystems.
POWER PC, Apple, Motorola e IBM.
6.- cuales son las arquitecturas definidas por la taxonomia de Flynn.

Una instruccin, un dato (SISD) [Single Instruction Single Data] computador
secuencial que no explota el paralelismo en las instrucciones ni en flujos de datos.
Ejemplos de arquitecturas SIS son las mquinas con uni-procesador o monoprocesador
tradicionales como el PC o los antiguos mainframe.
Mltiples instrucciones, un dato (MISD) [Multiple Instruction Single Data] poco
comn debido al hecho de que la efectividad de los mltiples flujos de instrucciones
suele precisar de mltiples flujos de datos. Sin embargo, este tipo se usa en situaciones
de paralelismo redundante, como por ejemplo en navegacin area, donde se necesitan
varios sistemas de respaldo en caso de que uno falle. Tambin se han propuesto algunas
arquitecturas tericas que hacen uso de MISD, pero ninguna lleg a producirse en masa.
Una instruccin, mltiples datos (SIMD) [Single Instruction Multiple Data] un
computador que explota varios flujos de datos dentro de un nico flujo de instrucciones
para realizar operaciones que pueden ser paralelizadas de manera natural. Por ejemplo,
un procesador vectorial.
Mltiples instrucciones, mltiples datos (MIMD) [Multiple Instruction Multiple Data]
varios procesadores autnomos que ejecutan simultneamente instrucciones
diferentes sobre datos diferentes. Los sistemas distribuidos suelen clasificarse como
arquitecturas MIMD; bien sea explotando un nico espacio compartido de memoria, o
uno distribuido.
Practica N4: USO DEL MICROCONTROLADOR- PROYECTO DE ARDUINO
Fuente:http://www.aprendiendoarduino.com/
1.- Crear cuenta en simulador de arduino
https://circuits.io/circuits/5447022-the-unnamed-circuit/edit
2.- Cambiar a la pantalla de edicin del cdigo en lenguaje de programacin del

star trek
#include <LiquidCrystal.h>
// Left LCD
LiquidCrystal lcd1(7, 8, 9, 10, 11, 12);
// Right LCD
LiquidCrystal lcd2(1, 2, 3, 4, 5, 6);
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
// NeoPixel Ring 24
#define PIN 13
#define NUMPIXELS 24
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB +
NEO_KHZ800);
int delayval = 50;
long previousMillis = 0;
long interval = 950;
int seconds = 0;
int hour = 0;
int hourButtonState = 0;
int minButtonState = 0;
byte full[8] = {
B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111,
};
byte halfL[8] = {
B11111, B11111, B11111, B11111, B00000, B00000, B00000, B00000,
};
byte halfR[8] = {
B00000, B00000, B00000, B00000, B11111, B11111, B11111, B11111,
};
// the setup routine runs once when you press reset:
void setup() {
// set button pins
pinMode(14, INPUT); // set minute
pinMode(15, INPUT); // set hour
// make custom characters
lcd1.createChar(0, halfR);
lcd1.createChar(1, halfL);
lcd1.createChar(2, full);
lcd2.createChar(0, halfR);
lcd2.createChar(1, halfL);
lcd2.createChar(2, full);
// set LCD1 size
lcd1.begin(16,2);
// set LCD2 size
lcd2.begin(16, 2);
// pixel ring
pixels.begin();
// initial setup
lcd1.clear();
num0lcd1();
lcd2.clear();
num0lcd2();
//pixels.setPixelColor(17, pixels.Color(0,150,0));
//pixels.setPixelColor(18, pixels.Color(0,150,0));
pixels.show();
}
// the loop routine runs over and over again forever:
void loop() {
hourButtonState = digitalRead(15);
minButtonState = digitalRead(14);
if (hourButtonState == HIGH) {
hour++;
runClock ();
}
if (minButtonState == HIGH) {
seconds++;
runClock ();
}
unsigned long currentMillis = millis();
if (currentMillis - previousMillis > interval) {
if (seconds == 59) {
seconds = 0;
if (hour == 11) {
hour = 0;
} else {
hour ++;
}
} else {
seconds ++;
}
previousMillis = currentMillis;
runClock ();
}
delay(10);
}
void runClock () {
if (seconds == 0) {
lcd1.clear();
num0lcd1();
lcd2.clear();
num0lcd2();
}
if (seconds == 1 || seconds == 11 || seconds == 21 || seconds == 31 ||
seconds == 41 || seconds == 51) {
lcd1.clear();
num1lcd1();
}
lcd1.clear();
num2lcd1();
}
lcd1.clear();
num3lcd1();
}
lcd1.clear();
num4lcd1();
}
lcd1.clear();
num5lcd1();
}
lcd1.clear();
num6lcd1();
}
lcd1.clear();
num7lcd1();
}
lcd1.clear();
num8lcd1();
}
lcd1.clear();
num9lcd1();
}
lcd1.clear();
num0lcd1();
lcd2.clear();
num1lcd2();
}
lcd1.clear();
num0lcd1();
lcd2.clear();
num2lcd2();
}
lcd1.clear();
num0lcd1();
lcd2.clear();
num3lcd2();
}
lcd1.clear();
num0lcd1();
lcd2.clear();
num4lcd2();
}
lcd1.clear();
num0lcd1();
lcd2.clear();
num5lcd2();
}
if (hour == 0) {
pixels.setPixelColor(15, pixels.Color(0,0,0));
pixels.show();
}
if (hour == 1) {
pixels.show();
}
if (hour == 2) {
pixels.show();
}
if (hour == 3) {
pixels.show();
}
if (hour == 4) {
pixels.show();
}
if (hour == 5) {
pixels.show();
}
if (hour == 6) {
pixels.show();
}
if (hour == 7) {
pixels.show();
}
if (hour == 8) {
pixels.show();
}
if (hour == 9) {
pixels.show();
}
if (hour == 10) {
pixels.show();
}
if (hour == 11) {
pixels.show();
}
}
void num0lcd1 () {
lcd1.setCursor(0,0);
lcd1.write(byte(2)); // full
lcd1.setCursor(0, 1);
lcd1.write(byte(2));
lcd1.write(byte(0)); // half right
lcd1.write(byte(1)); // half left
}
void num1lcd1 () {
}
void num2lcd1 () {
}
void num3lcd1 () {
}
void num4lcd1 () {
}
void num5lcd1 () {
}
void num6lcd1 () {
}
void num7lcd1 () {
}
void num8lcd1 () {
}
void num9lcd1 () {
}
void num0lcd2 () {
}
void num1lcd2 () {
}
void num2lcd2 () {
}
void num3lcd2 () {
}
void num4lcd2 () {
}
void num5lcd2 () {
}
3.- Crear un diagrama y agregar componentes electrnicos

Minimo agregue 5 componentes entre: Un arduino uno, un led, una resistencia, un
amplificador o parlante y una bateria de 9v.
Grupo 1.- Alarma con arduino
1.
https://aprendiendoarduino.wordpress.com/2017/06/29/proyecto-sistema-de-
alarma/
https://github.com/jecrespo/Aprendiendo-Arduino-
Proyectos/commit/acbd10363b36d0454a772c8f8998193a19122c38
+#include
<MsTimer2.h>
+#define DEBUG 1
+#define NOTE_C5 523 //Frecuencia de sonido del

buzzer
+
#define TIEMPO_PRE_ALARMA 10000 //Tiempo que

permanece en pre-alarma
+#define TIEMPO_LDR 5000 //Tiempo en que el

LDR est activo antes de pasar a pre-alarma
+#define UMBRAL_LDR 900 //Umbral de disparo

de prealarma del LDR (AJUSTAR el valor del umbral
para que detecte la alarma segn iluminacin recinto)
//ESTADOS
-boolean alarma = 0; //Cuando est en alarma
-boolean pre_alarma = 0; //Cuando detecta una

condicin de alarma y no ha llegado a prealarma
+#define NORMAL 0
+#define PRE_ALARMA 1
+#define ALARMA 2
+//PINES
+#define PIN_TILT 2
+#define PIN_LED 3
+#define PIN_BOTON 4
+#define PIN_BUZZER 5
+#define PIN_LDR A0
+
+//PINES TECLADO
+//PASSWORD
+#define PASSWORD 761254
+//Variable con el estado
+int estado = NORMAL; //Inicio en estado normal
+//Variables temporales
+unsigned long tiempo_deteccion = 0;
+unsigned long tiempo_prealarma = 0;
void setup() {
+#if DEBUG
+ Serial.begin(9600);
+ Serial.println("Inicializando...");
+#endif
+ pinMode(PIN_TILT, INPUT_PULLUP);
+ pinMode(PIN_LED, OUTPUT);
+ pinMode(PIN_BOTON, INPUT_PULLUP);
+ //inicializo el estado
+ comprueba_tilt(NORMAL);
+ comprueba_ldr(NORMAL);
+#if DEBUG
+ Serial.println("Sistema en Servicio.");
+ Serial.println("-----------------");
+#endif
void loop() {
- comprueba_flanco_tilt();
- comprueba_ldr();
- estado();
+ switch (estado) {
+ case NORMAL:
+ comprueba_tilt(NORMAL);
+ comprueba_ldr(NORMAL);
+ break;
+ case PRE_ALARMA:
+ lee_teclado();
+ break;
+ case ALARMA:
+ if (!comprueba_tilt(ALARMA) &&
!comprueba_ldr(ALARMA) && comprueba_boton())
+ actualiza_alarma(NORMAL);
+ break;
+ }
+#if DEBUG
+ imprime_valiables();
+#endif
+}
+boolean comprueba_tilt(int valor_estado) {
+ //Devuelve 1 si est activo y 0 si no est activo
+ int valor_tilt = digitalRead(PIN_TILT); //es un

INPUT_PULLUP activo = 0
+#if DEBUG
+ Serial.println("Valor_tilt = " + (String)valor_tilt);

+#endif
+ //NORMAL
+ if ((valor_estado == NORMAL) && (valor_tilt)) { //Tilt

activado en vertical leo 1 al poner en vertical
+ actualiza_alarma(PRE_ALARMA);
+ return 1;
+ }
+ //ALARMA
+ if ((valor_estado == ALARMA) && (valor_tilt)) //Tilt

activado en vertical leo 1
+ return 1;
+ if ((valor_estado == ALARMA) && (!valor_tilt)) //Tilt

normal, en horizontal lee GND
+ return 0;
-void comprueba_flanco_tilt(){
+boolean comprueba_ldr(int valor_estado) {

+ //ldr a mayor luz menos resistencia
+ int valor_ldr = analogRead(PIN_LDR);
+#if DEBUG
+ Serial.println("Valor_ldr = " + (String)valor_ldr);
+#endif
+ //NORMAL
+ if ((valor_estado == NORMAL) && (valor_ldr >

UMBRAL_LDR)) {
+ if (tiempo_deteccion == 0)
+ tiempo_deteccion = millis();
+ else if ((millis() - tiempo_deteccion) >

TIEMPO_LDR) {
+ tiempo_deteccion = 0;
+ actualiza_alarma(PRE_ALARMA);
+ }
+#if DEBUG
+ if (tiempo_deteccion > 0)
+ Serial.println("tiempo_deteccion = " +
(String)(millis() - tiempo_deteccion));
+#endif
+ return 1;
+ }
+ if ((valor_estado == NORMAL) && (valor_ldr <=

UMBRAL_LDR)) {
+ tiempo_deteccion = 0;
+ return 0;
+ }
+ //ALARMA
+ if ((valor_estado == ALARMA) && (valor_ldr >

UMBRAL_LDR))
+ return 1;
+ if ((valor_estado == ALARMA) && (valor_ldr <=

UMBRAL_LDR))
+ return 0;
+}
+void lee_teclado() {
+ //compruebo si ha pasado el tiempo para alarma

+ if ((millis() - tiempo_prealarma) >
TIEMPO_PRE_ALARMA) {
+ tiempo_prealarma = 0;
+ actualiza_alarma(ALARMA);
+ return 0;
+ }
+#if DEBUG
+ Serial.println("tiempo_prealarma = " +
(String)(millis() - tiempo_prealarma));
+ Serial.println("Leo Teclado");
+#endif
+ //Si es correcta la clave
+ //tiempo_prealarma = 0;
+ //actualiza_alarma(ALARMA);
-void comprueba_ldr(){
+boolean comprueba_boton() {

+ int valor_boton = digitalRead(PIN_BOTON);
+#if DEBUG
+ Serial.println("valor_boton = " +
(String)valor_boton);
+#endif
+ if (valor_boton == 0) //INPUT_PULLUP
+ return 1;
+ else
+ return 0;
-void estado(){
+void actualiza_alarma(int valor_nuevo_estado) {
+ //Paso de un estado a otro
+ estado = valor_nuevo_estado;
+ switch (estado) {
+ case NORMAL:
+ Serial.println("ENTRO EN ESTADO NORMAL");
+ digitalWrite(PIN_LED, LOW);
+ noTone(PIN_BUZZER);
+ break;
+ case PRE_ALARMA:
+ Serial.println("ENTRO EN ESTADO PRE-

ALARMA");
+ tiempo_prealarma = millis();
+ MsTimer2::set(1000, blink); // 1000ms period
+ MsTimer2::start();
+ break;
+ case ALARMA:
+ Serial.println("ENTRO EN ESTADO ALARMA");
+ MsTimer2::stop();
+ digitalWrite(PIN_LED, LOW);
+ tone(PIN_BUZZER, NOTE_C5);
+ envia_SMS();
+ break;
+ }
}
+void envia_SMS() {
+#if DEBUG
+ Serial.println("Mando SMS");
+#endif
+}
+void blink()
+{
+ static boolean output = HIGH;
+#if DEBUG
+ Serial.println("Blink");
+ output ? Serial.println("beep") : Serial.println("no

beep");
+#endif
+ digitalWrite(PIN_LED, output);
+ output ? tone(PIN_BUZZER, NOTE_C5) :

noTone(PIN_BUZZER);
+ output = !output;
+}
+
+void imprime_valiables() { //para debug
+ delay(1000); //Para leer por pantalla
+ Serial.println("-----------------");
+ Serial.print("Estado = ");
+ switch (estado) {
+ case NORMAL:
+ Serial.println("NORMAL");
+ break;
+ case PRE_ALARMA:
+ Serial.println("PRE_ALARMA");
+ break;
+ case ALARMA:
+ Serial.println("ALARMA");
+ break;
+ }
+}
2.
https://fabricadigital.org/2015/11/como-hacer-una-alarma-con-un-sensor-de-
movimiento-pir-un-buzzer-y-un-led/
void setup() {
pinMode(4,INPUT); // PIR
pinMode(10,OUTPUT); // LED
pinMode(6,OUTPUT); // Buzzer
void loop() {
if (digitalRead(4) == HIGH) {
digitalWrite(10, HIGH);
digitalWrite(6, HIGH);
delay(500);
digitalWrite(10, LOW);
delay(500);
} else {

Practica de Arquitectura

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Practica de Arquitectura

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD POLITCNICA SALESIANA

1. Copiar el texto del programa modificado, explicar su funcionalidad,

1.- Complete la siguiente tabla:

Instrucciones Significado Tipo de

MOV AX,1B Transfiere AX,al registro 1B Transferencia de

ADD AX,BX Aade BX al registro AX Aritmticas

ADD [BL], 5 Aade 5 a la direccin BL Aritmticas

SUB BX,DX Restar BX de DX Aritmticas

MOV BL, [BO] Transfiere lo que est en la Transferencia de

INC BX Incrementa en una al registro BX,a la Aritmticas

JMP 102 Saltar la etiqueta 102 Salto

2.- Elabore un cuadro de diferencias y semejanzas entre las arquitecturas CISC y

Arquitecturas Semejanzas Diferencias

CISC los dos procesadores realiza un computadoras con un conjunto de

3.- Elabore el Diagrama de Gantt de las instrucciones del documento

SALIDA A PUERTOS : OUT

5.- Escriba los nombres de 3 procesadores RISC y CISC vigentes

6.- cuales son las arquitecturas definidas por la taxonomia de Flynn.

2.- Cambiar a la pantalla de edicin del cdigo en lenguaje de programacin del

3.- Crear un diagrama y agregar componentes electrnicos

Grupo 1.- Alarma con arduino

+#define NOTE_C5 523 //Frecuencia de sonido del

#define TIEMPO_PRE_ALARMA 10000 //Tiempo que

+#define TIEMPO_LDR 5000 //Tiempo en que el

+#define UMBRAL_LDR 900 //Umbral de disparo

-boolean alarma = 0; //Cuando est en alarma

-boolean pre_alarma = 0; //Cuando detecta una

+#define PASSWORD 761254

+//Variable con el estado

+int estado = NORMAL; //Inicio en estado normal

+unsigned long tiempo_deteccion = 0;

+unsigned long tiempo_prealarma = 0;

+boolean comprueba_tilt(int valor_estado) {

+ //Devuelve 1 si est activo y 0 si no est activo

+ int valor_tilt = digitalRead(PIN_TILT); //es un

+ Serial.println("Valor_tilt = " + (String)valor_tilt);

+ if ((valor_estado == NORMAL) && (valor_tilt)) { //Tilt

+ if ((valor_estado == ALARMA) && (valor_tilt)) //Tilt

+ if ((valor_estado == ALARMA) && (!valor_tilt)) //Tilt

+boolean comprueba_ldr(int valor_estado) {

+ //ldr a mayor luz menos resistencia

+ int valor_ldr = analogRead(PIN_LDR);

+ Serial.println("Valor_ldr = " + (String)valor_ldr);

+ if ((valor_estado == NORMAL) && (valor_ldr >

+ else if ((millis() - tiempo_deteccion) >

+ if ((valor_estado == NORMAL) && (valor_ldr <=

+ if ((valor_estado == ALARMA) && (valor_ldr >

+ if ((valor_estado == ALARMA) && (valor_ldr <=

+ //compruebo si ha pasado el tiempo para alarma

+ //Si es correcta la clave

+ //Devuelve 1 si est activo y 0 si no est activo

+void actualiza_alarma(int valor_nuevo_estado) {

+ //Paso de un estado a otro

+ Serial.println("ENTRO EN ESTADO PRE-

+ MsTimer2::set(1000, blink); // 1000ms period

+ Serial.println("ENTRO EN ESTADO ALARMA");

+ static boolean output = HIGH;

+ output ? Serial.println("beep") : Serial.println("no

+ output ? tone(PIN_BUZZER, NOTE_C5) :

+ delay(1000); //Para leer por pantalla

También podría gustarte