Ejercicios Emu8086

11. Escribir un programa en ensamblador que muestre un mensaje por pantalla mediante interrupciones: 2. 3. ;----------------------------------------------------------------------------4. ;Definicion del segmento de datos 5. ;----------------------------------------------------------------------------6. DATOS SEGMENT 7. 8. saludo db "Hola mundo!!!","$" 9. 10. DATOS ENDS 11. 12. ;----------------------------------------------------------------------------13. ;Definicion del segmento de codigo 14. ;----------------------------------------------------------------------------15. CODE SEGMENT 16. assume cs:code,ds:datos 17. 18. START PROC 19. mov ax,datos ; 20. mov ds,ax ;Inicializar 21. 22. mov dx,offset saludo ;Cargar la direccion del saludo 23. mov ah,9 ;Opcion que va a servir a la interrupcion 21h para 24. ;indicar que debe mostrar por pantalla el offset 25. ;que hay en DX hasta que encuentre el caracter '$' 26. int 21h ;Interrupcion que lo mostrara por pantalla 27. 28. mov ax,4C00h ; 29. int 21h ;Terminar el programa 30. 31. START ENDP 32. 33. CODE ENDS 34. END START 35. 36. Escribir un programa en ensamblador que muestre un mensaje por pantalla accediendo a la memoria de video (0B800h): 37. 38. ;----------------------------------------------------------------------------39. ;Definicion del segmento de datos 40. ;----------------------------------------------------------------------------41. DATOS SEGMENT 42. saludo db "Hola mundo!!!" 43. DATOS ENDS 44. 45. ;----------------------------------------------------------------------------46. ;Definicion del segmento de pila 47. ;----------------------------------------------------------------------------48. PILA SEGMENT STACK "STACK" 49. DB 40 DUP(0) 50. PILA ENDS 51. 52. ;----------------------------------------------------------------------------53. ;Definicion del segmento extra 54. ;----------------------------------------------------------------------------55. EXTRA SEGMENT 56. RESULT DW 0,0 57. EXTRA ENDS 58. 59. ;----------------------------------------------------------------------------60. ;Definicion del segmento de codigo 61. ;----------------------------------------------------------------------------62. CODE SEGMENT 63. assume cs:code,ds:datos,es:extra,ss:pila 64. 65. START PROC 66. ;Inicializamos los registros de segmento 67. mov ax,datos 68. mov ds,ax 69. mov ax,pila 70. mov ss,ax 71. mov ax,extra 72. mov es,ax 73. ;Fin de las inicializaciones 74. 75. ;Limpiamos la pantalla 76. mov ax,0B800h ;En esta direccion comienza la memoria de video 77. mov es,ax ;Lo cargamos en el segmento extra 78. xor di,di ;Ponemos DI=0. Esto equivale a mov di,0, pero 79. ;xor di,di consume 3 ciclos de reloj y con mov 4 80. mov cx,80*25 ;El tamaño total es 2000 (80 lineas x 25 columnas) 81. 82. b_clear: ;Bucle que se encargara de recorrer los 2000 83. ;caracteres de la pantalla para limpiarla 84. mov al,20h ;20h=" " Rellenar la pantalla con espacios 85. mov ah,1bh ;Fondo azul, letras blancas 86. mov es:[di],ax 87. inc di 88. inc di 89. loop b_clear 90. 91. mov ax,0B800h 92. mov es,ax 93. mov si,offset saludo 94. mov di,(80*7+17)*2 ;Linea 7, caracter 18 95. mov cx,13 96. 97. b_saludo: ;Bucle que se encargara de recorrer los 2000 98. ;caracteres de la pantalla para limpiarla 99. mov al,[si] 100. mov ah,1bh ;Fondo azul, letras blancas 101. mov es:[di],ax 102. inc si ;Pasamos a apuntar a la siguiente letra del saludo 103. inc di 104. inc di 105. loop b_saludo 106. 107. 108. mov ax,4C00h ; 109. int 21h ;Terminar el programa 110. 111. START ENDP 112. 113. CODE ENDS 114. END START 115. 116. Este programa pide el nombre al usuario y lo muestra por pantalla: 117. 118. ;----------------------------------------------------------------------------119. ;Definicion del segmento de datos 120. ;----------------------------------------------------------------------------121. DATOS SEGMENT 122. mensaje db "Ejercicios disponibles en: www.victorsanchez2.net" 123. pregunta_nombre db "Cual es tu nombre?: " 124. nombre db 64 DUP(0) 125. DATOS ENDS 126. 127. ;----------------------------------------------------------------------------128. ;Definicion del segmento de pila 129. ;----------------------------------------------------------------------------130. PILA SEGMENT STACK "STACK" 131. db 40h DUP(0) 132. PILA ENDS 133. 134. ;----------------------------------------------------------------------------135. ;Definicion del segmento extra 136. ;----------------------------------------------------------------------------137. EXTRA SEGMENT 138. RESULT DW 0,0 139. EXTRA ENDS 140. 141. ;----------------------------------------------------------------------------142. ;Definicion del segmento de codigo 143. ;----------------------------------------------------------------------------144. CODE SEGMENT 145. assume cs:code,ds:datos,es:extra,ss:pila 146. 147. START PROC 148. ;Inicializamos los registros de segmento 149. mov ax,datos 150. mov ds,ax 151. mov ax,pila 152. mov ss,ax 153. mov ax,extra 154. mov es,ax 155. ;Fin de las inicializaciones 156. 157. ;Limpiamos la pantalla 158. mov ax,0B800h ;En esta direccion comienza la memoria de video 159. mov es,ax ;Lo cargamos en el segmento extra 160. xor di,di ;Ponemos DI=0. Esto equivale a mov di,0, pero 161. ;xor di,di consume 3 ciclos de reloj y con mov 4 162. mov cx,80*25 ;El tamaño total es 2000 (80 lineas x 25 columnas) 163. 164. b_clear: ;Bucle que se encargara de recorrer los 2000 165. ;caracteres de la pantalla para limpiarla 166. mov al,20h ;20h=" " Rellenar la pantalla con espacios 167. mov ah,1bh ;Fondo azul, letras blancas 168. mov es:[di],ax 169. inc di 170. inc di 171. loop b_clear 172. 173. ;Mostramos un mensaje 174. mov si,offset mensaje 175. mov di,(80*10+10)*2 ;Linea 10, columna 10 176. mov cx,49 ;Tamaño del mensaje 177. 178. b_saludo: ;Bucle que se encargara de recorrer los 2000 179. ;caracteres de la pantalla para limpiarla 180. mov al,[si] 181. mov ah,1bh ;Fondo azul, letras blancas 182. mov es:[di],ax inc di 201. int 21h . . mov bx. 227.1bh .(80*12+10)*2 . mov ah. mov dx.nombre[1] . inc si . letras blancas 197. mov ax. inc di 186. mov nombre[0]. mov es:[di]. inc si . inc di 185.ax 198.2 214. mensaje db "Ejercicios disponibles en: www. jne muestra_nombre 218. CODE ENDS 225. loop b_saludo 187. loop b_pide_nombre 202. mov ah. 220.----------------------------------------------------------------------------230.offset pregunta_nombre 190.victorsanchez2. .64 . END START 226. 224.Terminar el programa 221.Maximo numero de caracteres 207. El mismo programa que antes. inc bx 216. 188. .offset nombre 206. muestra_nombre: 212. 229. mov di.Bucle que se encargara de recorrer los 2000 194.net" .0Ah 205. int 21h . inc di 200.0 210. 209.nombre[bx+2] 213.Pasamos a apuntar a la siguiente letra del saludo 184. DATOS SEGMENT 233. 211. . 219. 203.Mensaje al usuario para que introduzca su nombre 189. mov si.Linea 12.Fondo azul. columna 10 191. mov ah. mov al. .4C00h . mov cx.Almacenamos el nombre 204.Escribir un caracter del nombre 215. mov dl. 193. 222. START ENDP 223.Pasamos a apuntar a la siguiente letra del saludo 199. pero ahora con llamadas a funciones: 228.[si] 196.caracteres de la pantalla para limpiarla 195.Definicion del segmento de datos 231. int 21h 208.Compara con el numero de caracteres 217. cmp bl. .183.----------------------------------------------------------------------------232. b_pide_nombre: .20 192. DATOS ENDS 237.Pide el nombre al usuario 267. call muestra_mensaje .----------------------------------------------------------------------------241. EXTRA SEGMENT 249.----------------------------------------------------------------------------253. mov ax. . 238.----------------------------------------------------------------------------246. . .----------------------------------------------------------------------------239. .Definicion del segmento de pila 240. call limpia_pantalla .ES:extra. 252. inicializa_seg 277. . RESULT DW 0. . 245. . . 275. 272.Muestra por pantalla el nombre del usuario 268. . .0 250. CODE SEGMENT 256.----------------------------------------------------------------------------255. assume CS:code. . int 21h . 270. call pide_nombre .----------------------------------------------------------------------------259. nombre db 256 DUP(0) 236. START ENDP 273.Inicializa los registros de segmento 264. pregunta_nombre db "Cual es tu nombre?: " 235. 258. in: 279. .----------------------------------------------------------------------------261. . PILA ENDS 244. call muestra_nombre .SS:pila 257. call inicializa_seg . out: Los registros de segmento quedan inicializados . . 263. . PILA SEGMENT STACK "STACK" 242. db 40h DUP(0) 243.----------------------------------------------------------------------------248. Procedimiento inicial 260. 274.Limpiamos la pantalla 265.4C00h .Definicion del segmento extra 247.234.Terminar el programa 271. .DS:datos.Definicion del segmento de codigo 254.----------------------------------------------------------------------------276. 269. EXTRA ENDS 251. 278.Mensaje de informacion 266. START PROC 262. . Lo cargamos en el segmento extra 315. machaca: AX. inicializa_seg proc near 285.Inicializar DI a 0 316. mov ah.El tamaño total es 2000 (80 lineas x 25 columnas) 317. push ax .extra 291. SS.280. . in: 302. 318.ax 292. . . mov ax. mov es:[di]. .ax . 286. 297.Fondo azul. 307. ES 281. 301. mov ax. DS. mov ax. 298. . make: Inicializa los registros de segmento 282.pila 289. ES 304.Guardar en la pila las variables que queremos 311.20h . ret 294. machaca: DI.datos 287.0B800h . out: 303.ax 288. 293. inicializa_seg endp 296. 310.80*25 .Bucle que se encargara de recorrer los 2000 319. . mov ss. mov ds.----------------------------------------------------------------------------299. . . accediendo a la memoria de video 306.conservar para cuando salgamos de la funcion 312. mov ax. 295. loop b_clear 326. letras blancas 322.20h=" " Rellenar la pantalla con espacios 321. limpia_pantalla 300. mov cx. . mov al.----------------------------------------------------------------------------284. . .ax 290.ax 323. mov es. la pantalla. 313.En esta direccion comienza la memoria de video 314. inc di 325.1bh . . . . push cx .caracteres de la pantalla para limpiarla 320.----------------------------------------------------------------------------308. make: Limpia la pantalla escribiendo espacios en las 80x25 posiciones de 305. . . mov es. b_clear: . xor di. 283. limpia_pantalla proc near 309. inc di 324.di . muestra_mensaje 336.Linea 10. inc di 363. pop es 366.Pasamos a apuntar a la siguiente letra del saludo 361. 350. . 330.guardamos 329. encontrar los ejercicios 342. make: Muestra un mensaje por pantalla indicando en que pagina se pueden 341. .----------------------------------------------------------------------------335.[si] 358.Tamaño del mensaje 354. . . inc di 362. pop cx . in: 338. 337. ret 331. pop ax . inc si .offset mensaje 352. loop b_saludo 364. b_saludo: . 369.----------------------------------------------------------------------------374. out: 339.Bucle que se encargara de recorrer los 2000 356. pop ax 368. 365. letras blancas 359. 346.ax 360.49 . . . mov es:[di]. . pop cx 367.----------------------------------------------------------------------------344. mov di.327. mov cx. pide_nombre 375.Fondo azul. mov ah. push cx 348. .1bh . . limpia_pantalla endp 333. 373. . columna 10 353. push ax 347. mov al. ret 370. 351.Importante sacarlas en orden contrario al que las 328. 355. 376. muestra_mensaje endp 372. . 334. mov si. . SI 340. 371. in: . 332. .caracteres de la pantalla para limpiarla 357. . push es 349. machaca: DI.(80*10+10)*2 . . 343. muestra_mensaje proc near 345. offset nombre 407. 389. mov cx. pop ax 413. . .Maximo numero de caracteres 408. push cx 386. inc si .Almacenamos el nombre 405. . mov si. muestra_nombre proc near .Fondo azul. 381. . SI. .1bh . 388. in: nombre contiene el nombre de usuario que se ha introducido 422.0Ah 406. mov ah. b_pide_nombre: . .Pasamos a apuntar a la siguiente letra del saludo 400.----------------------------------------------------------------------------419. 394. . push ax 385. . . 414. 410.377. SI 424. pop cx 412. make: Muestra el nombre al usuario por pantalla 425. loop b_pide_nombre 403. pop es 411. int 21h 409. pide_nombre endp 417. 404. machaca: DI. . .[si] 397. machaca: DI.caracteres de la pantalla para limpiarla 396. muestra_nombre 420. inc di 401. DX 379. ret 415.(80*12+10)*2 .ax 399. columna 10 392.20 393.Bucle que se encargara de recorrer los 2000 395. . 384. pide_nombre proc near 383.Linea 12. 418. letras blancas 398. out: 378.Mensaje al usuario para que introduzca su nombre 390.----------------------------------------------------------------------------382. inc di 402. mov al. . out: 423. make: Pide el nombre al usuario para que lo introduzca por pantalla 380.64 . mov nombre[0]. mov ah. .offset pregunta_nombre 391.----------------------------------------------------------------------------427. mov di. mov es:[di]. 416. mov dx. 421. 426. . push es 387. . . mov di. . 458.Fondo azul. . mov es:[di].Cuenta el numero de caracteres .1bh 442. 429. inc dx 444. mostrar_nombre: 440. 454.[si] 441.----------------------------------------------------------------------------467. db 40h dup(0) 478.ax 435. .428. 471. 456. CODE ENDS 460. ret 455. 459. 433.----------------------------------------------------------------------------465.Definicion del segmento de datos 466. END START 461.Numero del que calcularemos su factorial 470. 439. 450. PILA SEGMENT STACK "STACK" 477. pop cx 452. dato db 3 . mov si. pop ax 453. letras blancas . mov ah.dx 436. muestra_nombre endp 457. inc di 446. mov ax. 464.0B800h 434.nombre[1] caracteres 448. . . DATOS ENDS 472.Linea 12. 469.----------------------------------------------------------------------------474.ax 443. 462. push cx 431. mov al. xor dx. cmp dl. inc si 445. DATOS SEGMENT 468. . mov es. pop es 451. push es 432.offset nombre+2 437. jne mostrar_nombre 449. inc di 447.Definicion del segmento de pila 475. 473.Comparar con el numero de Programa que calcula el factorial de 3 y lo muestra por pantalla: 463. push ax 430. columna 31 .(80*12+31)*2 438.----------------------------------------------------------------------------476. . . PILA ENDS 479. call calcula_factorial .pila 525. .----------------------------------------------------------------------------483. 487. . 522.----------------------------------------------------------------------------520.Definicion del segmento de codigo 489.SS:pila 492.dato 501. out: Los registros de segmento quedan inicializados 516. inicializar proc near 521.2 palabras (4 bytes) 485.Definicion del segmento extra 482. CODE SEGMENT 491. 519. 497. call muestra_factorial . . result dw 0.extra 527. 495.Carga el puntero de pila con el valor mas alto 499.----------------------------------------------------------------------------488.0 .Calcula el faltorial de dato 502.ES:extra. inicializar 513. SS. . . . START ENDP 510. . . DS. call inicializar .4C00h .----------------------------------------------------------------------------490.datos 523. mov cl.Almacenar el resultado en factorial 503.----------------------------------------------------------------------------512. .ax 528. mov ax. . . .Muestra el valor del factorial 504.480. mov ax. 514. mov sp. machaca: AX.----------------------------------------------------------------------------481.Variable para guardar el factorial 494. mov es.ax 524. 493. factorial db 0 . mov ss.64 . . mov ax. 508.al . mov factorial.Inicializa los registros de segmento 498. 505. in: 515. ES 517.Terminar el programa 507. mov ax. mov ds. assume CS:code. 500.ax 526. 506. EXTRA ENDS 486.DS:datos. START PROC 496. 511. 509. make: Inicializa los registros de segmento 518. . . . int 21h . EXTRA SEGMENT 484. ----------------------------------------------------------------------------534. factor: 550.0B800h 575. muestra_nombre 561. out: Devuelve en AX el resultado de calcular el factorial 538.Obtener el valor en ASCII ('0'=30h) 579. calcula_factorial endp 558. 536. mov dl. xor ch. mov di. ret 530. make: Inicializa los registros de segmento y el puntero de pila 540. 531. . machaca: AX. mov dh. . .30h .1bh 580. muestra_factorial proc near 569. dec cx 552. . 554. mov es:[di]. add dl. push ax 571. SI 565. . in: nombre contiene el nombre de usuario que se ha introducido 563.1 545.----------------------------------------------------------------------------568. CX 539.529.Apuntar a la memoria de video 576. 544. push cx 572. push es 573. . . out: 564.(80*12+31)*2 . . machaca: DI. . .dx .0 . . . calcula_factorial proc near 543.factorial 577. 562. 567. . ret 556. 557. calcula_factorial 535. 541. 533. 549. . je fin .ax . mov ax. mov es. mul cx 551. columna 31 578.----------------------------------------------------------------------------560. inicializar endp 532.ch 546. in: CL contiene el dato 537. mov ax.Linea 12. 559. make: Muestra el valor del factorial por pantalla 566. 570.----------------------------------------------------------------------------542. . jne factor 553. cmp cx. 574.terminamos 548. . . . fin: 555.Si el numero es 0 547. CODE ENDS 591. 3. START PROC 12. muestra_factorial endp 589.Ponemos bx a 0 15. mov ax. se incrementa 2 veces porque 19. .consume menos ciclos de reloj del procesador 20. mov ds:[bx]. END START 592.bx . xor bx. pop ax 585. 586.----------------------------------------------------------------------------8. pinta_caracter: 17.----------------------------------------------------------------------------6. 11. 16. mov ds.En lugar de sumar 2. pop es 583.Definición del segmento de codigo 7. 24. jl pinta_caracter . 590.Escribir el carácter en su coordenada 18. mov ax. cmp bx. int 21h . assume cs:code 10. 25. . ret 587.byte ptr "V" .pantalla 14.Si bx<4000 volvemos a pintar otro carácter 23. inc bx . 5. 588. Escribir un programa que escriba el mismo carácter en las 2000 posiciones de la pantalla: 2. pop cx 584. 2 1.ax . .Direccion física de comienzo de la pantalla 4. 21. pantalla EQU 0B800h . inc bx .4C00h .2000*2 . 582.Terminar el programa 26. .Cargar la dirección de la coordenada 0.581. .0 de la 13.pantalla .por eso bx va a llegar hasta 4000 22. CODE SEGMENT 9.Cada posicion de la pantalla son 2 bytes. Copiar el carácter obtenido por toda la pantalla 51. . int 21h .27. mov ds:[1998*2].bx 45. pinta_caracter: 48. mov ds.Obtener el carácter de la coordenada 0.1995*2 .pantalla 44.Definición del segmento de codigo 37. Todo lo que veremos en el TD va a estar en hexadecimal. mov dx.----------------------------------------------------------------------------38. END START 31. CODE ENDS 30. Con el TD podremos ir viendo como el registro AX va aumentando hasta llegar a 37 en hexadecimal. . 33. Hacer un programa que coja el carácter que se encuentre en la coordenada 0.0 de la 43. 57. END START 66. inc bx 49.byte ptr "T" .ds:[bx] .0 46.nuestro mensaje 56. 59.En los ultimos 4 caracteres escribimos 55. mov ax. inc bx 50. xor bx. 62.ax . CODE SEGMENT 39. pantalla EQU 0B800h 34. Veremos ahora un programa que realiza la suma de los números 1+2+3+4+5+6+7+8+9+10=55=37h. 60. mov ds:[bx]. CODE ENDS 65.dx . No todos los programas que hagamos tienen por qué mostrar algo por la pantalla. que va a ser el equivalente a 55 en decimal.0 de la pantalla en ese momento y lo copie por toda la pantalla. START ENDP 63.----------------------------------------------------------------------------36.4C00h . 58. En los últimos 4 caracteres mostrar la palabra ETSI: 32. mov ds:[1997*2].byte ptr "I" . 35. 41.byte ptr "S" .pantalla .Cargar la dirección de la coordenada 0.Dejamos los ultimos 4 caracteres sin rellenar 52. La salida de esta suma se irá guardando en el acumulador (AX).Terminar el programa 61. mov ds:[1999*2]. assume cs:code 40. Nos vemos en la necesidad ya de empezar a manejar el Turbo Debugger. START ENDP 28. cmp bx. 29. mov ds:[1996*2]. mov ax. 47. jl pinta_caracter 53. Al .byte ptr "E" . 54. 64. . START PROC 42. : Descripcion: 73.Definición del segmento de codigo . creado fichero %1. : 70. tasm /zi %1.obj 96. echo *** error: falta nombre del modulo fuente *** 83. crear modulo 74.principio puede parecernos un poco raro y no saber muy bien a que equivale. : objeto y debuggearlo..asm no existe *** 87. linkar y ejecutar el programa. goto fin 84. goto fin 88. 97. Claro está que todo esto puede hacerse paso por paso. la única diferencia es que en lugar de td %1 debemos poner un %1 para que lo ejecute. echo *** error en programa fuente *** 92.Para debuggear un programa puede utilizarse únicamente el programa deb. : Ensamblar modulo fuente principal de un programa.asm goto ensam 86. .----------------------------------------------------------------------------. :error 82. pero poco a poco iremos aprendiendo a pensar en hexadecimal y binario :D. : Fichero: deb. De esta manera t. echo . para el cual veremos su resultado en el TD.bat 71. goto fin 93. :mensa 94.bat.bat que he venido utilizando durante mi aprendizaje del ensamblador: .. : 72. :fin Este archivo de procesamiento por lotes lo que hace es ensamblar el archivo. : 78. :---------------------------------------------------------------------77.bat: 67. cada uno verá lo que prefiere. 90. linkarlo y por ultimo lanzar el Turbo Debugger para nuestro archivo. goto check 81. echo off 79. if z%1 == z goto error 80. 99. :check 85.bat lo que hace es ensamblar. Con estos programas ya estamos preparados para hacer frente al siguiente ejemplo. :---------------------------------------------------------------------69. if exist %1. 68. pero bueno. : 76. Antes de nada les voy a mostrar los archivos . tlink /v %1 95.obj goto mensa 91. echo *** error: fichero %1. td %1 98. if exist %1. 75. :ensam 89. Mi fichero t.bat no se diferencia en casi nada de deb. .Definición del segmento de codigo 120.Sumar 1+.0 116.4C00h 21h . .----------------------------------------------------------------------------119. .es:extra..ss:pila 123. EXTRA ENDS 117.----------------------------------------------------------------------------105.cx cx cx. .Inicializar add inc cmp jne ax. . Realizar un programa que limpie la pantalla dejando el fondo azul y los caracteres rojos: 101. . assume cs:code..+10=37h mov int ax. . PILA SEGMENT STACK "STACK" 108. db 40h dup(0) 109. pantalla EQU 0B800h 103.----------------------------------------------------------------------------CODE SEGMENT assume CS:code START: xor mov ax. .----------------------------------------------------------------------------112.Definición del segmento extra 113. 118. . . . . . 100.11 suma . 111.ax cx. .. EXTRA SEGMENT 115. PILA ENDS 110.----------------------------------------------------------------------------114. La teoría la explicaremos después de ver el ejemplo.Terminar el programa suma: CODE ENDS END START El siguiente programa es algo más sofisticado y potente.----------------------------------------------------------------------------121. CODE SEGMENT 122.----------------------------------------------------------------------------107. 102.1 .Definición del segmento de pila 106. result dw 0. . 104. 0C200h si quisiesemos poner el fondo rojo con letras verdes. Teoría para entender el ejercicio: STOSW: Se transfiere el registro AX a la palabra ES:[DI].Componente azul del fondo 3 . cld 127. Esto lo logramos con las instrucciones CLD o STD. mov es. caracteres rojos con . CODE ENDS 141. xor di. En este caso las 2000 posiciones. Si la bandera de dirección es cero (DF=0).0001110000000000b 132. DI se actualiza en dos unidades. 6 . 140. START ENDP 139. . son las 80x25 posiciones de la pantalla.Componente verde del fondo 4 . Cada número o letra hexadecimal equivale a un nibble (4 bits): código atributo (1 byte).Equivalente a: mov . int 21h 137. DI se incrementa. 126. rep stosw 134.Terminar el programa Si quisiesemos poner los atributos de otra forma sólo hay que cambiar una línea.di 130. 138.pantalla 128. se decrementa.1100001000000000b ó mov ax.Repetirlo las 2000 veces . mov ax. En CX hemos especificado el número de elementos de la cadena.4C00h 136. END START . Los bits son los siguientes: 7 .Fondo azul. ax.124.1C00h intensidad 131. mov ax. Para indicar en la memoria de pantalla como queremos el fondo y los caracteres podemos hacerlo en sus 8 bits. Para indicar el carácter tenemos otros 8 bits. mov cx.ax 129.DF=0 (incrementar DI) . si DF=1.Utilizado para indicar si el carácter parpadea o no.2000 133.Componente rojo del fondo 5 . START PROC 125.Intensidad en los caracteres . por ejemplo: mov ax. mov ax. 135. Podríamos ponerla de la siguiente manera. mov ds.Definicion del segmento de codigo 17. . mov cx.Numero de caracteres que contiene la tabla ASCII 28.----------------------------------------------------------------------------11. Realizar un programa que muestre la tabla de caracteres ASCII por pantalla: 2.----------------------------------------------------------------------------6. 21.256 . . . . . .PANTALLA 23. CODE SEGMENT 19. . 25. PANTALLA equ 0B800h 7.ax 24. assume CS:code.Componente verde del carácter 0 .----------------------------------------------------------------------------16.bx 26. db 40h dup(0) 13. 1. 8.----------------------------------------------------------------------------18. xor al. . xor bx. 3. Programa que muestra la tabla de caracteres ASCII por pantalla 5. código carácter (1 byte): Podemos elegir de la tabla ASCII aquel carácter que prefiramos. hemos activado el componente azul del fondo.Definicion del segmento de pila 10. mov ax. si queremos volver a tener nuestra pantalla como antes. Si quiesiesemos que apareciese el carácter 'V' en el fondo pues cogeríamos el 56h.Componente rojo del carácter 1 . SS:pila 20. la intensidad y el componente rojo de los caracteres. . PILA ENDS 14. Como carácter elegimos el 00h. START: 22. basta con un un simple: C:\>cls Volveremos a tener la pantalla con letras blancas sobre fondo negro.----------------------------------------------------------------------------4. 15. que en la tabla ASCII va a equivaler a dejar el fondo sin ningún carácter.Componente azul del carácter Como vemos en nuestro ejemplo (0001 1100 0000 0000). . PILA SEGMENT STACK "STACK" 12.2 .al 27.----------------------------------------------------------------------------9. Cuando ejecutemos el programa. 58. db 40h dup(0) 50. ponerlo con fondo blanco y rellenarlo con caracteres 'V': 42.4C00h 37. loop mostrar_ascii 35.Bytes por linea 73.----------------------------------------------------------------------------48. 39. 52. 62. START: 59.Numero de lineas que vamos a tener 64. mov dl. mov cx. 45. PANTALLA equ 0B800h 44.2 bytes por columna 76. mov ax.----------------------------------------------------------------------------55. 68.Primera columna 69.----------------------------------------------------------------------------53.PANTALLA 60. .Pasar al siguiente caracter . CODE ENDS 40.Primera linea en la que empezaremos a pintar 63.Definicion del segmento de codigo 54. .10 . mov al. PILA SEGMENT STACK "STACK" 49. BucleLineas: 66. BucleColumnas: 72. . mov al.2 . SS:pila 57. 71. mov bx. END START .Por el numero de linea 74.Definicion del segmento de pila 47. mostrar_ascii: 30.al pantalla 31. mov ax.0 . mov ds.Por el numero de columna . mov cx. .0 .29.80*2 . inc al 34. mov dh. mul dl . inc bx 33. 43.Terminar el programa 41.20 . push cx 67. mov [bx]. int 21h 38. mul dh . CODE SEGMENT 56.ax 61.Numero de columnas 70.Escribirlo en la coordenada de la . 36.----------------------------------------------------------------------------46. . 65. . PILA ENDS 51. inc bx 32. .Pasar a la siguiente coordenada .ax 75. . assume CS:code. Este programa se encarga de dibujar un cuadrado en la pantalla. CODE SEGMENT 119. . DeseaContinuar db cr.77.cr. 78.lf 105.----------------------------------------------------------------------------111. LetraErronea db ' La tecla pulsada es incorrecta. 93. . db'$' 104. add mov inc loop bx. mov ax. DATOS SEGMENT 100. .Definicion del segmento de datos 98.4C00h 87. CODE ENDS 90.datos 123. assume CS:code. .Recuperamos el contador de las lineas 83. . int 21h 88.lf 103.'.----------------------------------------------------------------------------97. 80. DS:datos. 82.----------------------------------------------------------------------------116. continuando db ' Continuando. END START . .cr.ax . . START: 122..----------------------------------------------------------------------------118. DATOS ENDS 107. db 40h dup(?) 113.Siguiente columna pop cx . 96. Este programa le pregunta al usuario si desea continuar o no hasta que se pulse la tecla 'N' o 'n': 92.lf.. inc dl 84.alimentacion de linea 95. .'.----------------------------------------------------------------------------109. SS:pila 120. PILA ENDS 114. 86.'Desea continuar? S/N: ' 101. 79. 108.Definicion del segmento de pila 110. db'$' 102. mov ds.7056h dh BucleColumnas .----------------------------------------------------------------------------99.retorno de carro 94. 89.Fondo blanco y letra 'V' .Definicion del segmento de codigo 117. cr equ 13 . loop BucleLineas 85. 81.ax word ptr [bx]. PILA SEGMENT STACK "STACK" 112. 115. lf equ 10 . db'$' 106. . 121. mov ax.Pasar a la siguiente linea 91. je inicio 147.LetraErronea 134. . PANTALLA equ 0B800h 168. 167. lea dx. int 21h desea continuar 141. . 132. 'S' 146. lea dx. 'n' 153.La tecla pulsada no es 'S'. je salir 154. .DeseaContinuar 139. je inicio 149.Desea continuar . END START . jmp continuar CONTINUAR 125. terminamos . Realizar un programa que cambie todas las letras de la pantalla a minusculas: 166.y mostrarla por pantalla . INICIO: 127. . 159.9 introducida 135.Se va a mostrar un mensaje de . 145. . . . .Mensaje de que seguimos en el .Esperar a que se pulse una tecla . Saltamos 157. cmp al.1 143. . 126. cmp al. 158. 'N' 151. mov ah.continuando 128. int 21h 136.124. jmp continuar desea continuar 131. error. cmp al. int 21h 162. int 21h 144. 150. 's' 148. lea dx. mov ax. cmp al. . 's'.----------------------------------------------------------------------------170. mov ah. . .a la etiqueta ERROR 165. . ERROR: 133. 169. .Definicion del segmento de pila . mov ah. mov ah.Salto para preguntar si se . salir: 160.No desea continuar.9 129. 4C00h 161.Mostrar pregunta para ver si . 163. CODE ENDS 164.no es correcta . jmp error 'N' ni 'n' 156. 155. int 21h programa 130.Saltamos a la etiqueta .Mensaje de que la letra . 142. 137.9 140. CONTINUAR: 138. je salir 152. 32 .tabla ASCII de las mayusculas a las minusculas 199. 182.171. assume CS:code.DS apunta a la direccion de la pantalla 185. 194.----------------------------------------------------------------------------172. . PILA SEGMENT STACK "STACK" 173. 176. 206. xor bx. 207.Terminamos el programa 208.byte ptr 'Z' .Escribimos en la pantalla el caracter cambiado 200. 184. .al . CODE ENDS 210. CODE SEGMENT 180.----------------------------------------------------------------------------179. . mov ds. .pantalla .Si no es asi pasamos al siguiente caracter 196. .Pasamos a la siguiente coordenada 204. mov al. inc bx . jb siguiente .en la coordenada indicada 192. .ds:[bx] . PILA ENDS 175. 189.----------------------------------------------------------------------------177.Para pasar de mayusculas a minusculas 197.2000 . add al.Obtenemos el caracter que hay en la pantalla 191. .ax .Comprobar que este entre la letra 'A' 193.hay que sumar 32 para movernos en la 198. cmp al. mov cx. siguiente: 202. .byte ptr 'A' . int 21h .Definicion del segmento de codigo 178. END START 4 . inc bx .4C00h . 203. mov ax. mov ax. START: 183. cmp al.bx 187. db 40h dup(0) 174. SS:pila 181. 186. ja siguiente . 209. loop cambia_minus 205. cambia_minus: 190.y la letra 'Z' 195.a minusculas 201.80 filas x 25 columnas 188. mov ds:[bx]. . . END START 33. cwd .Convertir una palabra en doble palabra 22.cociente (al/10) 39.4C00h 29.Convertir una palabra en doble palabra 27.----------------------------------------------------------------------------42. neg al .4 .Vamos a ver diferentes ejemplos de instrucciones para entenderlas un poco mejor.resto (al/10) 40. 16. mov ah.----------------------------------------------------------------------------4. 3. assume CS:code. igual que en caso anterior 25. . SS:pila 15.Convertir un byte en palabra 21. PILA SEGMENT STACK "STACK" 7.----------------------------------------------------------------------------11. 28. solo para ver que al convertir 18. al <.basura. 38. db 40h dup(0) 8. . CODE ENDS 32.5 20. cbw . 31. . cwd . . . mov ax. . . CODE SEGMENT 14. mov ah. Ejemplo de la instruccion: AAM (ajuste ASCII en multiplicación) 34.No sirve para nada.----------------------------------------------------------------------------- . ah <. 41. . mov al.----------------------------------------------------------------------------6. . 1. 10. int 21h 30. START: 17.al pasa a ser un numero negativo (complemento a 2) 24. 43.----------------------------------------------------------------------------13.3 . 23. Ejemplo de las instrucciones: CBW y CWD 2.Definicion del segmento de codigo 12. . Programa que prueba la instruccion: AAM 37. .en palabra o doble palabra se machacan los registros 19. Será bueno tener un libro al lado para saber qué hace cada instrucción.Convertir un byte en palabra 26. . .Definicion del segmento de pila 5. cbw . 35.----------------------------------------------------------------------------36. PILA ENDS 9. assume CS:code 48.----------------------------------------------------------------------------70. mov ax.----------------------------------------------------------------------------79.AX=0009h 89.----------------------------------------------------------------------------81. add al.En el cociente hay un 4 y en el resto un 5 55. START PROC 85. mul cl . add al. Programa que muestra el uso de la instruccion AAA. .5 53. . 87.1 . . mov cl.Definicion del segmento de codigo 80.8 . 64.SS:pila 83. Ejemplo de la instruccion: AAA (ajuste ASCII en suma) 63. 49. assume CS:code. . 86. . CODE SEGMENT 82. 88. 78. aam . . . .9 52. db 40h dup(0) 76.8 . 71. Se utiliza para ajustar el resultado despues de una suma 68. .Resultado es ax=0405 56. . aaa . . CODE ENDS 61.Definicion del segmento de codigo 45.Definicion del segmento de pila 73. START: 50.2 . . . mov ax. PILA SEGMENT STACK "STACK" 75.----------------------------------------------------------------------------74. PILA ENDS 77. . instruccion de suma.----------------------------------------------------------------------------72. 60. . END START 62. int 21h 59. 57. 51. CODE SEGMENT 47. mov ax.----------------------------------------------------------------------------65. de dos numeros decimales en formato ASCII 69.44. Esta instruccion convierte 66.Resultado: ax=002D 54.4c00h 58. el contenido de AL en un numero decimal ASCII (desempaquetado) tras una 67. 84. 90.----------------------------------------------------------------------------46. mov al. . ----------------------------------------------------------------------------120.resto (al/0Ah) 118. Ejemplo de la instruccion: AAA (ajuste ASCII en suma).1 94. Programa que prueba la instruccion: AAA 115. Ejercicio: examen ETCII .9 101. mov ax. int 21h 140.91.7 97. aaa . add ax. . . 122. START ENDP 108. start: 130.4C00h 105. . .----------------------------------------------------------------------------123.Terminar el programa 111. aaa 100.191h 133.Definicion del segmento de codigo 124.AX=0109h .16h 132.cociente (al/0Ah) 117. add al. CODE SEGMENT 127. CODE ENDS 110. add al. al <. 104. aaa 98. 129. .7/11/01 121. . 107. 113.AX=0105h . add al. . int 21h 106. aaa 102. 116. CODE ENDS .7h 136. 109. . assume CS:code 128. . mov bx. .AX=0204h 137. aaa 92. . 131. END START .----------------------------------------------------------------------------114. .----------------------------------------------------------------------------125.AX=0107h 135. Del examen de ETCII del año 2001: 112. 141. .AX=0002h .8 96. mov ax. add al. . 138. .bx 134. aaa .AX=0100h . 126. mov ax. . add ax. 103. aaa 95.4c00h 139. ah <. mov ax. . .4 99. 119. mov ax.AX=0208h .11110001b 93. START: 162. . . PILA SEGMENT STACK "STACK" 152. END START Ejemplo que muestra la diferencia entre las instrucciones: AAA y DAA 144. CODE SEGMENT 159.Definicion del segmento de pila 150. . db 40h dup(0) 153.----------------------------------------------------------------------------146. 166. 175. 172. PILA SEGMENT STACK "STACK" 183.Definicion del segmento de codigo 157. mov al. add al.7 170. mov ax. 161.142.----------------------------------------------------------------------------149. 145. Programa que prueba las instrucciones: AAA y DAA 147.----------------------------------------------------------------------------148.Definicion del segmento de pila 181. .----------------------------------------------------------------------------158. . mov al. . END START 177.----------------------------------------------------------------------------156. 143. . add al. PILA ENDS 154.ax 167.Definicion del segmento de codigo . xor ax. .----------------------------------------------------------------------------151. 186. 179. .----------------------------------------------------------------------------182. SS:pila 160.5 163. .4C00h 173. daa . . int 21h 174. PILA ENDS 185.7 164. Ejemplo de la instrucción NEG (convertir a complemento a 2): 178. db 40h dup(0) 184. 155. . assume CS:code.----------------------------------------------------------------------------180.----------------------------------------------------------------------------187. aaa . 168.Ajuste BCD empaquetado 171.5 169. . CODE ENDS 176. .Ajuste BCD no empaquetado 165. PILA ENDS 210.----------------------------------------------------------------------------214.Definicion del segmento de codigo 213. 226.----------------------------------------------------------------------------207. 223. .----------------------------------------------------------------------------189. CODE ENDS 201. 217.Convertir a su complemento a 2 222.----------------------------------------------------------------------------212. int 21h 225. 200. . . . 197. assume CS:code. END START 5 . not al . mov ax.4C00h 224. neg al . END START 202. . START: 218.8 220.----------------------------------------------------------------------------205. 204. CODE SEGMENT 215.Convertir a su complemento a 2 196. 211. int 21h 199. assume CS:code. SS:pila 216. db 40h dup(0) 209. mov ax. .8 195. PILA SEGMENT STACK "STACK" 208. 221. 194.Definicion del segmento de pila 206. 219. START: 193. mov al. CODE ENDS 227.4C00h 198. mov al. 192. SS:pila 191. Otra forma de convertir a complemento a 2 mediante las instrucciones NOT e INC: 203. . inc al .188. CODE SEGMENT 190. START: 41.----------------------------------------------------------------------------4. . CS:code. DATOS ENDS 19. . . 34. . EXTRA SEGMENT 31. db 40h dup(0) 25. PILA SEGMENT STACK "STACK" 24.----------------------------------------------------------------------------35.Definicion del segmento extra 29. 40. . después rellene toda la pantalla con '*' y por último vuelva a dejar la pantalla como estaba: 2. Realizar un programa que guarde el estado de la pantalla con todos sus caracteres.----------------------------------------------------------------------------37.Programa que guarda el estado de la pantalla con todos sus caracteres. PILA ENDS 26. DATOS SEGMENT 15.Reservar una variable para guardar toda la 17. . 20. 11.informacion de la pantalla 18.rellena toda la pantalla con '*' y por ultimo vuelve a dejar la pantalla como 6. mov ax.----------------------------------------------------------------------------28. 9.----------------------------------------------------------------------------30.Definicion del segmento de datos 13.Definicion del segmento de codigo 36. .----------------------------------------------------------------------------21. . . .estaba 7. 16. SS:pila 39. CODE SEGMENT 38.----------------------------------------------------------------------------14.0 32. PANTALLA equ 0B800h 10. EXTRA ENDS 33. . despues 5.----------------------------------------------------------------------------23.Definicion del segmento de pila 22. 27. . . . RESULT DW 0. pantalla_bak db 80*25*2 DUP(?) .PANTALLA . .----------------------------------------------------------------------------8. assume DS:datos.1. . 3.----------------------------------------------------------------------------12. . . Mover el contenido de la direccion de memoria apuntada 54. 70. 44. pop es . 71.Los 4000 bytes de la pantalla 81.pantalla_bak 56. 43. int 16h . 82.Numero de bytes que tenemos que copiar 50. .ah . 78. mov cx. 77.pantalla_bak .ax di.Direccion para incrementar DI y SI 51. xor ah. Realizar un programa que devuelva la primera posición en que se ha encontrado un carácter dado: 92. movsb . loop backup 57. END START 91. 74. movsb . loop llena 68. . 48. inc bx 67. 60. push ds .bx . . 49. 59. 52.pantalla_bak 76. backup: 53. mov [bx]. push es . xor di. 72. pop ds . 89. int 21h 88.Llenar la pantalla de '*' 62.si ax. 86. mov ds. llena: 64. restaura: .Intercambiar DS y ES 73. 58.80*25 . 83. en este caso la variable 55. mov al. inc bx 66. 46.di 75. cld .42.ax 65.Esperar a que se pulse una tecla 79. 45.ax xor mov mov lea si. 63. 47.'*' .por SI a la apuntada por DI. xor bx. loop restaura . mov ah. CODE ENDS 90. 80.datos es. lea si. 61. mov cx.Volver a dejar la pantalla como al principio 85.Apuntar a la variable mov cx.80*25*2 . 69.70h .4000 . mov ax. 84.4C00h 87. 137. . assume cs:code. .ax 132. CARACTER equ 'v' 98. msg_caracter db "El caracter: " 105. . mov ax.datos 131.extra 135. CODE SEGMENT 126.----------------------------------------------------------------------------94.Inicializamos los registros de segmento 130.----------------------------------------------------------------------------102.Limpiamos la pantalla .pila 133. msg_posicion db "Se encuentra en la posicion: " 106. 97. RESULT DW 0. mov ax.Definicion del segmento extra 117.ax 134. .0 120.ax 136. .victorsanchez2. mov es. . . . PILA ENDS 114. 115. EXTRA SEGMENT 119.ss:pila 127. 108. . DATOS ENDS 107. 122.93.es:extra. . .Devuelve la primera posicion en que se ha encontrado el caracter a buscar 95.----------------------------------------------------------------------------116. EXTRA ENDS 121. . mov ax.----------------------------------------------------------------------------96.Definicion del segmento de pila 110. DATOS SEGMENT 103. START PROC 129.Definicion del segmento de codigo 124. .ds:datos. PILA SEGMENT STACK "STACK" 112.----------------------------------------------------------------------------123. mensaje db "www.----------------------------------------------------------------------------125. mov ss. .----------------------------------------------------------------------------118. . 99. db 40h DUP(0) 113. 128. .net" 104. mov ds.----------------------------------------------------------------------------109. .Definicion del segmento de datos 101.----------------------------------------------------------------------------111.----------------------------------------------------------------------------100. mov cx.Total de caracteres de mensaje 173. 170.Terminar el programa 181.80*25 .Ponemos DI=0 141. lea si.22 .4C00h . START ENDP 183.mensaje . mov di. 182.CARACTER .Total de caracteres de mensaje 165. xor al.----------------------------------------------------------------------------185. add cl. 162.0Fh .Lo cargamos en el segmento extra 140.Colocar el offset de mensaje en si 159. 179.Total de caracteres de mensaje 160.Colocarnos al final del msg_caracter 168. rep stosw 145.(80*4)*2 .CARACTER . lea si.al .cl 178.0B800h .Mostrarlo por pantalla 166.138.Colocarnos al final del msg_posicion 176. 152. mov di. 157.0=" " Rellenar la pantalla con blancos 143.Fondo negro. mov al. mov ah.Mostrar el CARACTER por pantalla 169.13 . call pinta .Preparar CL para mostrar el caracter por pantalla 155. 153. mov di.0B800h .(80*5)*2 .Guardarlo para recuperarlo despues 156. 167. lea si.Buscar la posicion en que se encuentra el CARACTER 151.msg_caracter .Cargar el offset 164.Ponernos en la quinta fila 171.Nos colocamos en la cuarta fila 163.Mostrarlo por pantalla 174. mov ax. mov es. mov cx. lea si. mov byte ptr es:[di].di .(80*2)*2 . 146.Longitud maxima para buscar (longitud de 'mensaje') 149. mov ax. call busca_fin .(80*5+29)*2 .Colocarnos al inicio de la memoria de video 154.msg_posicion . . pop cx .Mostrarlo por pantalla 161.mensaje .En esta direccion comienza la memoria de video 139. mov cx.Cargar el offset 172. mov es:[di].Cargar el mensaje donde buscaremos 147. call pinta .80 lineas x 25 columnas 142. 175.22 . busca_fin .Recuperar la posicion en que se encontraba CARACTER 177. mov ax. 180.30h . 184.(80*4+13)*2 .ax . int 21h .ax .29 . xor di. mov di. . mov es. mov cx. call pinta . 150.Cargar el caracter a buscar 148. letras blancas 144. mov cx. mov di.Colocarnos en la segunda fila 158. push cx . push ax 237. 187. 227. mov es. repnz scasb .ax . .Calcular la longitud 213.Guardar la longitud en CX 214. 203. 204. . sub dx. mov di. . mov ax. pop ax . mov dx. .dx . pinta proc near 235. . .Recuperar el caracter que nos han pedido 210.Direccion incremental 209. SI contiene la cadena que debemos buscar 189. . cld . DI contiene la direccion donde se ira mostrando el mensaje 229. .----------------------------------------------------------------------------234. pop di 220. mov cx. . dado en AL 193. push dx 199. 236. machaca: CX 191. push di 198. . make: Muestra por pantalla el mensaje dado 233.Buscar el caracter pedido 212. push si . busca_fin proc near 196. . push si 201. push ax .cx .186. 197. out: 231. . out: En CX se guarda la posicion donde se ha encontrado el caracter 190. 205. push ax 202. 195. push es 200. . 222. .Copiar DS:SI en ES:DI 206. pop es 218.ds . pop si 217.cx . in: AL contiene el caracter que debemos buscar 188. 215. .si . CX contiene el numero de iteraciones a realizar 230. busca_fin endp 223.----------------------------------------------------------------------------225. machaca: CX 232. make: Devuelve en CX la primera posicion donde se ha encontrado el caracter 192.Guardarlo en la pila para no perderlo 211. in: SI contiene el offset del mensaje a mostrar 228. pop ax 216. pop dx 219. . . ret 221. . 207.----------------------------------------------------------------------------194. 224.Copiar el limite en otro registro 208. pinta 226. Programa que muestra la sucesion de codigos ASCII en la esquina superior . pinta endp 256. intercambiando los caracteres cada medio segundo . pop ax 253. Os recomiendo que aprendais bien las características de los programas residentes y programación del RTC antes de intentar comprender este ejercicio por completo.derecha de la pantalla. push di 239. apuntes o lo que sea y lo domineis con soltura. pop si 252. Este programa ya es algo más complejo que los anteriores ya que empezamos a trabajar con programas residentes y el RTC.Mostrarlo por pantalla 259. Al escribir esto veremos como aparece el programa de nombre ASCII.238. inc di 248. .----------------------------------------------------------------------------.[si] 244. 242. mov al. .ax 245.0Fh 241. al ser .4K. . loop pintar 249. Hacer un programa que muestre la sucesión de códigos ASCII en la esquina superior derecha de la pantalla. Este tipo de ejercicios van un nivel más allá. intercambiando los caracteres cada medio segundo. 255. que ocupa 0. ret 254. END START . pop di 251. 250. . . y si de verdad no comprendeis bien este tipo de ejercicios es mejor que os cojais libros. 240. inc di 247. Un comando que os puede servir de ayuda es: MEM /C Con este podemos saber los programas que hay residentes en nuestra memoria.COM. pintar: 243. hay que hacerlo con unas banderas distintas: C:\>tasm archivo C:\>tlink /t archivo C:\>archivo . Para ensamblar y ejecutar este programa.Fondo negro y letras blancas . inc si 246. CODE ENDS 258. . mov es:[di]. mov ah. 257. .71h .Recuperar los registros iret letras endp instalar proc far cli . .----------------------------------------------------------------------------PANTALLA equ 0b800h .0A1h al..Leer el RTC mov mov mov mov inc mov ax. .----------------------------------------------------------------------------CODE SEGMENT assume CS:code org 100h .es:[di] al es:[di].Habilitar las interrupciones .al 0A0h.cs . .Lo mostramos por pantalla cli mov out out sti al.Inhabilitar las interrupciones .Dejar las 100h primeras posiciones para el PSP START: jmp instalar .Guardamos los registros en la pila mov out in al.Guardamos en AX lo que hay en la esquina .Bifurcar a la rutina de instalacion letras proc far push ax push es push di .ax .Pasamos al siguiente caracter .Definicion del segmento de codigo .ax di.ax . . mov es.20h 20h.al al.ax . .Leer el PIC esclavo .11111110b . .79*2 ax.0Ch 70h.Guardar el offset mov es:[70h*4+2].Inhabilitar las interrupciones xor ax.y el segmento de la rutina in and al.al pop pop pop di es ax .PANTALLA es.offset letras .Poner a 0 ES mov es:[70h*4].----------------------------------------------------------------------------. Definicion del segmento de pila .instalar int 27h instalar endp CODE ENDS END START 260.0Bh 70h. por lo tanto usamos las banderas habituales.Activamos las interrupciones periodicas .----------------------------------------------------------------------------.al .71h al.Activamos IR0 in and out al.Habilitar las interrupciones lea dx. Algo muy importante es el programa que sirve para desinstalar y restaurar todo lo que hizo el programa anterior.Vamos a escribir en el registro B del RTC mov out mov segundo out mov out in or out sti . .21h al. .----------------------------------------------------------------------------.Lo indicamos en el registro A del RTC al.Desactiva las interrupciones periodicas del RTC y elimina el programa anterior . Si no lo hacemos seguirá mostrándose la sucesión de los caracteres ASCII mientras mantengamos encendido el ordenador.Leer el PIC maestro . si volvemos a escribir "MEM /C" veremos que nuestro programa ha desaparecido. .al .Los simbolos se intercambian cada medio 71h.Vamos a escribir en el registro A del RTC .Activado al.0Ah 70h. Después de ensamblar y ejecutar el programa con: C:\>tasm /zi archivo C:\>tlink /v archivo C:\>archivo Este programa no es . .11111011b 21h.2Fh .al al.----------------------------------------------------------------------------.COM. ya no se encuentra residente en memoria. .al . Después de ejecutarlo.out 0A1h.de la memoria.al al.al .01000000b 71h. Definicion del segmento de codigo . machaca: . interrupcion del RTC al PIC esclavo.Antes de proceder a desinstalarlo comprobamos si existe cmp word ptr es:[70h*4].----------------------------------------------------------------------------EXTRA SEGMENT RESULT DW 0. desconecta la . make: Desinstala las interrupciones periodicas (PIE). . restaura los vectores de .----------------------------------------------------------------------------CODE SEGMENT ASSUME CS:CODE.----------------------------------------------------------------------------.Definicion del segmento extra .0 je FIN ..0 EXTRA ENDS .----------------------------------------------------------------------------PILA SEGMENT STACK "STACK" DB 40h dup(0) PILA ENDS . . in: .Inhabilitar las interrupciones .Terminar el programa START ENDP .4C00h 21h . out: .SS:pila START PROC FAR call desinstalar mov int ax.----------------------------------------------------------------------------desinstalar PROC push ax push es push ds cli . . desinstalar .----------------------------------------------------------------------------.----------------------------------------------------------------------------. interrupcion y desinstala el programa residente . Hallar cual es el valor de AX tras la segunda instrucción AAA: 2.Restaurar los vectores de interrupcion ax.programa a desinstalar ax.7/11/01 4.ax es. 21h .Poner CS a 0 mov mov mov int mov mov mov int .49h .al and al.ax .ax .ax es:[70h*4].10111111b out 71h.ax . es. ah.Poner el offset a 0 es:[70h*4+2].Copia en DS el segmento de codigo del ds.ax . .mov al.49h .es:[70h*4+2] . .0A1h OR al.ax .Registro B del PIC . . 3. 21h . Ejercicio: examen ETCII . 1.Leer el PIC esclavo .Desinstalar el PSP ax. ah.0Bh out 70h. . es.desconectamos la interrupcion del RTC al xor mov mov mov xor mov mov .00000001B out 0A1h.al PIC esclavo .Deshabilitamos las interrupciones .ds .Desinstalar CS sti FIN: pop pop .Habilitar las interrupciones pop ds es ax ret desinstalar ENDP CODE ENDS END START 6 Estos ejercicios van a ser algo más complejos y son del nivel que se va a exigir a aquellos que estén cursando la asignatura de ETCII en la Universidad Autónoma de Madrid.al periodicas (PIE) in al.ax ax.ds:[2Ch] . .Desinstalar el programa residente ax. 28. END START 26. mov bx.----------------------------------------------------------------------------31. Hallar cual es el valor de AX tras la segunda instrucción AAA: 27. . aaa 18. mov bx. 21. END START 51. CODE ENDS 25. assume CS:code 11.16h 15.----------------------------------------------------------------------------54.4c00h 47. 24. Hallar el valor de AX tras la instrucción "div bl": 52.----------------------------------------------------------------------------33. add ax.123h 40.Definicion del segmento de codigo 7.7h 19. int 21h 23. mov ax. start: 13. CODE SEGMENT 10. 49.----------------------------------------------------------------------------6. aaa 43. 14.5. 9. . aaa 45.Febrero 2000 29. 34. 46. . mov ax. start: 38.Definicion del segmento de codigo 32. 53.5h 44. . . assume CS:code 36. int 21h 48. .77h 41. . 30. aaa 20. CODE ENDS 50.4c00h 22. .191h 16.bx 42. 12. 39.Definicion del segmento de pila . add ax.----------------------------------------------------------------------------8. mov ax. Ejercicio: examen ETCII . CODE SEGMENT 35. mov ax.bx 17. add ax. add ax. . 37. 78. START: 93. 71.5 96. aam 98. div bl 76. 77. assume CS:code 91. 82. int 21h 101.55. . 60. mov bx. CODE SEGMENT 64. mov ax. 102.----------------------------------------------------------------------------56. mov ax.----------------------------------------------------------------------------89.Definicion del segmento de codigo 88. Hallar el valor de AX tras la instrucción "daa": . CODE ENDS 83. . Hallar el valor de AX tras la instrucción "aam": 85.4C00h . mov ax. PILA ENDS 59. END START 84.----------------------------------------------------------------------------87.9 95.Definicion del segmento de codigo 62. mov ss. START PROC 67. . END START 104. 80.Inicializamos los registros de segmento 68. aad 74.Terminar el programa 79.ax 70. 66.----------------------------------------------------------------------------61. . int 21h . mov ah. mov ax. 99. . 105. .905h 72. . mov cl. assume cs:code. 94.2h 73.ss:pila 65. . mul cl 97. CODE ENDS 103. mov al. 92. START ENDP 81.4c00h 100. 86. CODE SEGMENT 90.pila 69. PILA SEGMENT STACK "STACK" 57.----------------------------------------------------------------------------63.10h 75. db 40h DUP(0) 58. END START 7 Las soluciones y archivos fuente de todos los ejercicios podéis obtenerlos escribiéndome un e-mail para pedírmelos. START ENDP 131. CODE SEGMENT 117. mov ax. daa 126. . add ax. 121.23h 122. . int 21h . . START PROC 120. 10. . 130. xor ah.----------------------------------------------------------------------------4.----------------------------------------------------------------------------13. . PILA ENDS 112. PILA SEGMENT STACK "STACK" 7.ah 125. PILA SEGMENT STACK "STACK" 110. 127. 119. 128. 132. mov ax. .bx 124.Terminar el programa 129. Hallar el valor de AX tras la instrucción "mov ax.Definicion del segmento de pila 5. db 40h DUP(0) 8. .----------------------------------------------------------------------------109. CODE ENDS 133.4C00h .77h 123.----------------------------------------------------------------------------114.----------------------------------------------------------------------------6.Definicion del segmento de codigo 115. . . 3.----------------------------------------------------------------------------107.[bp+1]": 2. CODE SEGMENT . .----------------------------------------------------------------------------11.----------------------------------------------------------------------------116. PILA ENDS 9. 1. .ss:pila 118.Definicion del segmento de codigo 12.106.Definicion del segmento de pila 108. assume cs:code. db 40h DUP(0) 111. 113. mov bx. . 31. mov ax. mov cx.37FFh 22.[bp+1]": 36.----------------------------------------------------------------------------38. END START 35. push bx 25.bx 23. . START PROC 51.----------------------------------------------------------------------------45. int 21h . . db 40h DUP(0) 42. . mov ss. xor bx. . mov ax. int 21h . 62. mov bp. START ENDP 66.pila 19. mov bp.Definicion del segmento de pila 39. 50.pila 53. 16. . 28. CODE ENDS 34.14. xor bx. push ax 58. START PROC 17. PILA SEGMENT STACK "STACK" 41. .Inicializamos los registros de segmento 18.ss:pila 49.----------------------------------------------------------------------------40. mov ax.3759h 56. Hallar el valor de AX tras la instrucción "mov ax. .ax 20. CODE SEGMENT 48.4C00h .Inicializamos los registros de segmento 52. 55. 65. 63.Definicion del segmento de codigo 46. .[bp+1] 61.ss:pila 15.4C00h . assume cs:code. assume cs:code. mov ax. mov ax. 37.bx 57. 29.sp 26. mov ax. PILA ENDS 43.ax 54. mov ax. . 21. 44.Terminar el programa 64. START ENDP 32.[bp+1] 27. push cx 24.sp 60. push bx 59. 33.Terminar el programa 30. mov ss.----------------------------------------------------------------------------47. . .Definicion del segmento de codigo 87.Terminar el programa 110. PILA ENDS 77. PILA SEGMENT STACK "STACK" 75.----------------------------------------------------------------------------81.0Fh 99. xor cx. . std 103.ES:extra.----------------------------------------------------------------------------79. CODE SEGMENT 89. 109.0F0h 101. 85.cx 100.----------------------------------------------------------------------------74. db 40h DUP(0) 76.Definicion del segmento extra 80. START PROC 95. stosb 107. START ENDP 112. mov al. Procedimiento inicial 93. 78. CODE ENDS 68. 96. mov es.40h 97. EXTRA ENDS 84. END START 69. EXTRA SEGMENT 82. 91. 113.bx 106. 108. . . mov bx. mov byte ptr ds:[si].67. mov di.----------------------------------------------------------------------------94. .0 83. . . cld 98.4C00h . . .si 104.----------------------------------------------------------------------------86. assume CS:code. CODE ENDS 114. . mov ax. RESULT DW 0. mov si.----------------------------------------------------------------------------92.ds 105. END START .----------------------------------------------------------------------------72. 111. 71. . Hallar el valor de AX tras la instrucción "stosb": 70.SS:pila 90. int 21h . rep scasb 102.Definicion del segmento de pila 73.----------------------------------------------------------------------------88. mov ax.Definicion del segmento de pila 126. . END START 156. 124. Otro ejercicio como el anterior: 157.----------------------------------------------------------------------------125.4C00h .ax 141.----------------------------------------------------------------------------132.Terminar el programa 151. 117.Definicion del segmento de datos 160.Inicializamos los registros de segmento 139. DATOS SEGMENT 162. db 40h DUP(0) 129.pila 142. 150. .5 147. . 131. mov ds. START PROC 138.----------------------------------------------------------------------------118. texto db "Esto_es_una_cadena_de_texto". CODE SEGMENT 135. 144. . mov ax.offset texto 145.----------------------------------------------------------------------------127. 154. PILA ENDS 130. CODE ENDS 155.0 . texto db "Cadena_de_texto" 122. 152.ss:pila 136. PILA SEGMENT STACK "STACK" 128. . rep lodsw 148.datos 140. . 149. cld 146. .----------------------------------------------------------------------------120. START ENDP 153. mov ax. mov si. .Definicion del segmento de datos 119.115.ax 143.----------------------------------------------------------------------------161. mov ss. 158. . . Hallar el valor de AX tras la instrucción "rep lodsw": 116. DATOS SEGMENT 121. DATOS ENDS 123. int 21h . mov cx. assume cs:code.----------------------------------------------------------------------------159.----------------------------------------------------------------------------134. .ds:datos. .Definicion del segmento de codigo 133. 137. . ----------------------------------------------------------------------------203. mov ds.----------------------------------------------------------------------------175.163.Terminar el programa 193. 172. CODE ENDS 197. . Las instrucciones de cadena son bastante potentes y como podreis ver es mejor saber manejarlas con soltura: 199. DATOS SEGMENT 204.----------------------------------------------------------------------------168.Definicion del segmento de codigo 174. .ax 184.pila 183. .Inicializamos los registros de segmento 180. .19h 187. mov ax. .----------------------------------------------------------------------------166. mov si. add si. . 207.----------------------------------------------------------------------------- .----------------------------------------------------------------------------173.----------------------------------------------------------------------------201. Y otro más.ss:pila 177.Definicion del segmento de pila 209. rep lodsw 190. CODE SEGMENT 176. db 40h DUP(0) 170.ax 182. 185. DATOS ENDS 206. PILA SEGMENT STACK "STACK" 169. . 165. mov ax. 178.5 189. DATOS ENDS 164. 200. . . PILA ENDS 171.Definicion del segmento de datos 202. END START 198. START ENDP 195. 196. . mov ss.4C00h . .datos 181. START PROC 179.ds:datos. 191. 194. texto db "Cadena_de_texto" 205. 192. mov ax.Definicion del segmento de pila 167.offset texto 186. . mov cx. std 188. assume cs:code. int 21h . .----------------------------------------------------------------------------208. mov cx. PILA ENDS 213.ss:pila 219. .Terminar el programa 235. mov bx.----------------------------------------------------------------------------217. mov ax.----------------------------------------------------------------------------215. db 40h DUP(0) 247.0Dh 229.pila 258.210. mov ax. CODE ENDS 239.10h . START PROC 221. .Definicion del segmento de codigo 216. int 21h . CODE SEGMENT 218. .----------------------------------------------------------------------------252.ax 259.----------------------------------------------------------------------------245. assume cs:code. mov ss.ax 224. 249. 238. 255. .ax 226. .pila 225. Hallar el valor de AX tras salir del bucle: 241.Inicializamos los registros de segmento 257. add si.----------------------------------------------------------------------------250. PILA SEGMENT STACK "STACK" 211.Inicializamos los registros de segmento 222. 236. .Definicion del segmento de codigo 251.offset texto 228. 260. . rep lodsw 232. db 40h DUP(0) 212.ds:datos. std 230. mov ax. mov ds.5 231. END START 240. PILA SEGMENT STACK "STACK" 246. CODE SEGMENT 253. mov ss. PILA ENDS 248. START ENDP 237.Definicion del segmento de pila 244. . START PROC 256. mov si. . 227.ss:pila 254. . mov ax.4C00h . 220.datos 223. assume cs:code. 242. . 234.----------------------------------------------------------------------------243. 214. 233. db'$' 19. 3. . 272.'Desea continuar? S/N: ' 16. cr equ 13 .Definicion del segmento de datos 13.----------------------------------------------------------------------------12. .lf 20. .bx 265.retorno de carro 9.261. . db'$' 17.. mov cx.alimentacion de linea 10. lf equ 10 .0FFFFh 263.----------------------------------------------------------------------------14. continuando db ' Continuando.lf. . L1: 264. . 23. DATOS ENDS 22. PILA ENDS 29. add ax.----------------------------------------------------------------------------7. END START . . loop L1 266. PILA SEGMENT STACK "STACK" 27.Programa que le pregunta al usuario si desea continuar o no hasta que se pulse 5.. xor ax.----------------------------------------------------------------------------26.Terminar el programa 8 1. DeseaContinuar db cr.la tecla 'N' o 'n' 6.lf 18. DATOS SEGMENT 15. CODE ENDS 273.cr. . 267. db 40h dup(?) 28. db'$' 21.'.----------------------------------------------------------------------------4.'. mov ax.cr.4C00h 268.----------------------------------------------------------------------------24. . . 8. El siguiente programa le pide al usuario la confirmación de si desea continuar y dependiendo de la respuesta se hará una cosa u otra: 2. . 11.ax 262. 270.Definicion del segmento de pila 25. int 21h 269. START ENDP 271. . LetraErronea db ' La tecla pulsada es incorrecta. Salto para preguntar si se desea continuar 46.Esperar a que se pulse una tecla 58. 54. mov ah. cmp al. 67. lea dx. START: 37. 'N' . . cmp al. 68. je salir .9 . je inicio . terminamos 69. 57.LetraErronea . CONTINUAR: 53. int 21h .Definicion del segmento de codigo 32.datos 38. jmp continuar .ax 39. DS:datos. 's'. cmp al.30.y mostrarla por pantalla 59. Saltamos 72. .9 . 43. mov ah. jmp continuar . 55. int 21h 77. mov ah. mov ds. 's' . 65. . 62. int 21h . assume CS:code. lea dx.continuando . cmp al. int 21h .Mostrar pregunta para ver si desea continuar 56. 61. int 21h . je inicio . . 74. . 47. mov ah. 'N' ni 'n' 71.no es correcta 51. ERROR: 48. je salir .1 . 'n' .a la etiqueta ERROR 73.----------------------------------------------------------------------------33.Mensaje de que seguimos en el programa 45. 49.9 .Mensaje de que la letra introducida 50. 60. CODE SEGMENT 34. 'S' .Saltamos a la etiqueta CONTINUAR 40. 66.Se va a mostrar un mensaje de error. 36. SS:pila 35. 44.----------------------------------------------------------------------------31. 4C00h 76.Desea continuar 64. mov ax. . jmp error . lea dx. 70. 41. salir: 75. mov ax. INICIO: 42.DeseaContinuar . 63.No desea continuar. 52.La tecla pulsada no es 'S'. Ponemos el fondo blanco 112. 82. CODE SEGMENT 95.----------------------------------------------------------------------------85.Definicion del segmento de codigo 93. 122.78. mov ds.Si no es negro lo ponemos 108. 121. 117. .----------------------------------------------------------------------------94. START: 98.COM (no os olvideis de compilar con las banderas antes mencionadas).70h . 113. CODE ENDS 79. 104. END START 80. .ax 100. mov ax.PANTALLA 99.4C00h 115. 84.----------------------------------------------------------------------------92. END START 119. . . . CambiaFondo: 111. PANTALLA ROJO LETRA_ROJA LETRA_AZUL AZUL equ equ equ equ equ 0b800h 4 'V' 'S' 1 . 124. caracter 5 101. PANTALLA equ 0B800h 83. 107. 123.07h .directamente al fondo 103. CODE ENDS 118.Definicion del segmento de pila 86. 110.----------------------------------------------------------------------------87.(80*24+5)*2+1 . siendo una letra roja y la otra azul: 120. db 40h dup(0) 89. . assume CS:code.Ultima linea. . . mov bx. SS:pila 96. mov byte ptr [bx]. mov byte ptr [bx]. fin: 114. 97. Este programa cambia el color de fondo de una posición determinada de pantalla.07h . 125. jmp fin 109. mov ax.Vemos si el fondo es negro 105. Si se ejecuta varias veces seguidas veremos como cambia de blanco a negro y viceversa: 81. En este caso se trata de mostrar las letras V y S con un intervalo de medio segundo. cmp byte ptr [bx]. Otro programa . jz CambiaFondo 106. 91. int 21h 116.Utilizamos el '+1' para acceder 102. PILA ENDS 90. PILA SEGMENT STACK "STACK" 88. mov ah.Bifurcar a la rutina de instalacion 136.la 'V' de color rojo 167. cli . push di . out 70h. 168. 137.Guardar en ES:[DI] que hemos puesto la letra 171.ROJO . .Definicion del segmento de codigo 129. 134.79*2 . cmp ah. CODE SEGMENT 131. 138.Guardamos los registros en la pila 153. mov ax. 154. push ax . letras proc far 149.----------------------------------------------------------------------------130. assume CS:code 132.ax . in: 142. 127. mov di. . 146.AZUL . mov al. . . mov ah.126. mov ax.Si era azul ahora debemos mostrar 166.71h . . make: Hace que se intercambien las letras V y S cada medio segundo en 145.0Ch .pantalla 161. jmp instalar .Dejar las 100h primeras posiciones para el PSP 133. 157.Terminar el procedimiento 173.----------------------------------------------------------------------------148.LETRA_AZUL 170.de color azul 172. . 147. push es . je muestra_v_rojo . 174. . org 100h .Guardamos en AX lo que hay en la esquina 164. mov al. . START: 135. .Esquina superior derecha 163. 141. .Leer el RTC 159. . machaca: 144.es:[di] . 165. 151. 152. letras 140. in al. muestra_v_rojo: 175. mov es:[di]. 158.AZUL 169. . colores diferentes.al .Inhabilitar las interrupciones 155.----------------------------------------------------------------------------128. . out: 143. 150.----------------------------------------------------------------------------139. mov es.ax 162. 160. 156. jmp fin . . Inhabilitar las interrupciones 207. 217.Activamos IR0 216. xor ax.Leer el PIC maestro 218. . out 71h.Vamos a escribir en el registro B del RTC . 187. 183. 188. 189. mov es:[di].Poner a 0 ES 210. 219. 223. and al. instalar 197.ax .11111011b . out 21h.Activado 220. . mov es:[70h*4+2].cs . fin: 181. iret 192.Vamos a escribir en el registro A del RTC 222.de color rojo 179.LETRA_ROJA 177.ax .Leer el PIC esclavo 214. 191. 215.21h .Lo indicamos en el registro A del RTC 225. machaca: ax. .20h . . .Habilitar las interrupciones 186. out 0A1h. es 201. 206. 185.----------------------------------------------------------------------------204.al . mov es. pop ax . letras endp 193.al .176. mov al. 194. 226. 195. 203. mov al.0A1h . 221.Los simbolos se intercambian cada medio segundo 224. out: 200. .al .----------------------------------------------------------------------------196. . out 20h. 209. mov al. 198. in: 199.EOI al maestro y al esclavo 184.11111110b . .al . sti . pop di . out 70h.2Fh . in al. 208.Guardar en ES:[DI] que hemos puesto la letra 178. 213.y el segmento de la rutina 212. pop es .0Ah .offset letras . and al.ax . 182. out 0A0h. cli . mov es:[70h*4]. . 180. mov al. .al . dx.Recuperar los registros 190. instalar proc 205. in al.0Bh . mov al.al . make: Instala el programa dejandolo residente 202.Guardar el offset 211. . mov cx.Dejar residente 241.ss:pila 263. xor ax.71h 229.227. El siguiente ejercicio de examen nos pide conocer la instrucción scasb. 239. . 232. DATOS SEGMENT 247.Definicion del segmento de pila 253.Activamos las interrupciones periodicas .----------------------------------------------------------------------------246.Definicion del segmento de datos 245. 258. .----------------------------------------------------------------------------259.Cadena2 275. . . 264.al 231. CODE ENDS 240.10h 273. .ds:datos. . . lea dx. . lea si.Definicion del segmento de codigo 260. int 27h 236.datos 267.ax 272. . db 40h DUP(0) 256. . lea di. assume cs:code. .pila 269. . PILA SEGMENT STACK "STACK" 255. 237. in al. Cadena2 db 50 dup(?) 249. out 71h. sti 233.Cadena1 274.al 228.----------------------------------------------------------------------------254.----------------------------------------------------------------------------261. mov ax. mov ss. Cadena1 db 50 dup(0) 248.01000000b 230. CODE SEGMENT 262. 271. . mov ax.ax 268.Inicializamos los registros de segmento 266.instalar 235. END START . or al. PILA ENDS 257. 243. out 70h. instalar endp 238.----------------------------------------------------------------------------244.----------------------------------------------------------------------------252. 234.ax 270. DATOS ENDS 250. otro: . 251. START PROC 265. Hallar cuál es el valor de AX tras la instrucción NOP: 242.Habilitar las interrupciones . mov ds. 276. push ds 277. inc ax 278. pop es 279. scasb 280. loop otro 281. nop 282. 283. mov ax,4C00h 284. int 21h 285. 286. START ENDP 287. 288. CODE ENDS 289. END START ;AX=10h, SI=0, DI=42h ; ;Terminar el programa 290. Otro ejercicio como el anterior, pero usando la instrucción repne. Recordar que la instrucción LOOP primero decrementa y despues compara CX con 0, así que cuidado con este ejercicio: 291. 292. ;----------------------------------------------------------------------------293. ;Definicion del segmento de datos 294. ;----------------------------------------------------------------------------295. DATOS SEGMENT 296. Cadena1 db 50 dup(0) 297. Cadena2 db 50 dup(?) 298. DATOS ENDS 299. 300. ;----------------------------------------------------------------------------301. ;Definicion del segmento de pila 302. ;----------------------------------------------------------------------------303. PILA SEGMENT STACK "STACK" 304. db 40h DUP(0) 305. PILA ENDS 306. 307. ;----------------------------------------------------------------------------308. ;Definicion del segmento de codigo 309. ;----------------------------------------------------------------------------310. CODE SEGMENT 311. assume cs:code,ds:datos,ss:pila 312. 313. START PROC 314. ;Inicializamos los registros de segmento 315. mov ax,datos 316. mov ds,ax 317. mov ax,pila 318. mov ss,ax 319. 320. xor ax,ax 321. mov cx,10h 322. lea si,Cadena1 323. lea di,Cadena2 324. otro: 325. push ds 326. inc ax 327. pop es 328. repne scasb 329. loop otro 330. nop 331. 332. mov ax,4C00h 333. int 21h 334. 335. START ENDP 336. 337. CODE ENDS 338. END START ; ;Terminar el programa 339. Hallar cual es el contenido de las posiciones de memoria: 1000, 1001, 1002 y 1003 tras la ejecucion del bucle: 340. 341. ;----------------------------------------------------------------------------342. ; Ejercicio 1: examen ETCII - 12/02/96 343. ;----------------------------------------------------------------------------344. 345. ;----------------------------------------------------------------------------346. ;Definicion del segmento de codigo 347. ;----------------------------------------------------------------------------348. CODE SEGMENT 349. assume CS:code 350. 351. START: 352. 353. ;Inicializar 354. mov byte ptr ds:[1000h],0 355. mov byte ptr ds:[1001h],0 356. mov byte ptr ds:[1002h],0 357. mov byte ptr ds:[1003h],0 358. 359. mov si,1000h 360. mov cx,4 361. l1: 362. add [si],si 363. inc si 364. loop l1 365. 366. mov ax,4C00h 367. int 21h 368. 369. CODE ENDS 370. END START 371. Hallar el contenido de SI tras la ejecución de los bucles: 372. 373. ;----------------------------------------------------------------------------- 374. ; Ejercicio: examen ETCII - 12/02/96 375. ;----------------------------------------------------------------------------376. 377. ;----------------------------------------------------------------------------378. ;Definicion del segmento de codigo 379. ;----------------------------------------------------------------------------380. CODE SEGMENT 381. assume CS:code 382. 383. START: 384. 385. mov si,0 386. mov cx,4 387. L2: push cx 388. mov cx,100h 389. L1: dec cx 390. inc si 391. loop l1 392. pop cx 393. loop l2 394. 395. mov ax,4C00h 396. int 21h 397. 398. CODE ENDS 399. END START 9 1. Otro problema de examen. Hallar el valor de AX tras la instrucción mov ax,word ptr ds:[3] 2. 3. ;----------------------------------------------------------------------------4. ;Definicion del segmento de datos 5. ;----------------------------------------------------------------------------6. DATOS SEGMENT 7. dw 3Ah,7Bh,9Ch 8. db 34h,76h,65h 9. org 1 10. db 67h,31h,56h,"SE ACABO" 11. DATOS ENDS 12. 13. ;----------------------------------------------------------------------------14. ;Definicion del segmento de pila 15. ;----------------------------------------------------------------------------16. PILA SEGMENT STACK "STACK" 17. db 40h DUP(0) 18. PILA ENDS 19. 20. ;----------------------------------------------------------------------------21. ;Definicion del segmento de codigo 22. ;----------------------------------------------------------------------------23. CODE SEGMENT 24. assume cs:code,ds:datos,ss:pila 25. 26. START PROC 27. ;Inicializamos los registros de segmento 28. mov ax,datos 29. mov ds,ax 30. mov ax,pila 31. mov ss,ax 32. 33. mov ax,word ptr ds:[3] 34. 35. mov ax,4C00h ; 36. int 21h ;Terminar el programa 37. 38. START ENDP 39. 40. CODE ENDS 41. END START 42. Muy similar al anterior: 43. 44. ;----------------------------------------------------------------------------45. ;Definicion del segmento de datos 46. ;----------------------------------------------------------------------------47. DATOS SEGMENT 48. dw 3Ah,7Bh,9Ch 49. db 34h,76h,65h 50. org 2 51. db 67h,31h,56h,"SE ACABO" 52. DATOS ENDS 53. 54. ;----------------------------------------------------------------------------55. ;Definicion del segmento de pila 56. ;----------------------------------------------------------------------------57. PILA SEGMENT STACK "STACK" 58. db 40h DUP(0) 59. PILA ENDS 60. 61. ;----------------------------------------------------------------------------62. ;Definicion del segmento de codigo 63. ;----------------------------------------------------------------------------64. CODE SEGMENT 65. assume cs:code,ds:datos,ss:pila 66. START PROC 68. EXTRA SEGMENT 98.SS:pila 106.pila 72. 87. 85. . EXTRA ENDS 100.----------------------------------------------------------------------------108. .ES:extra. int 21h . . mov ax. .febrero 2002 86.1Fh 113. CODE ENDS 82. 77. db 40h DUP(0) 92. END START 83. 101.Definicion del segmento de codigo 103. PILA ENDS 93.4C00h .67. START ENDP 80. PILA SEGMENT STACK "STACK" 91. . mov ax. 81. .0 99.----------------------------------------------------------------------------110. RESULT DW 0.datos 70. mov ds. push ax .----------------------------------------------------------------------------97.ax 71. mov ax. Ejercicio: examen ETCII .Inicializamos los registros de segmento 69. mov ss. 107. mov ax.----------------------------------------------------------------------------90. . 94. . .----------------------------------------------------------------------------104. push ax 114.ax 73. 76. 112. .----------------------------------------------------------------------------102. inc sp 115. mov ax.word ptr ds:[3] 75. . .----------------------------------------------------------------------------95. ¿Cuál es el valor de AX tras la instrucción NOP?: 84. 74.Terminar el programa 78. START PROC 111.Definicion del segmento extra 96. . assume CS:code. .Definicion del segmento de pila 89. CODE SEGMENT 105. 79. Procedimiento inicial 109.----------------------------------------------------------------------------88. END START . Estos ejercicios de pilas suelen tener truco la mayoría de las veces . mov ax. CODE ENDS 127.[bp+3] 154. dec sp 117.0FA45h 150. 156. mov al. 143. 137.Terminar el programa 158.pila 146.Terminar el programa 128.----------------------------------------------------------------------------138.ss:pila 142.ax 147. mov ax. .----------------------------------------------------------------------------131. PILA SEGMENT STACK "STACK" 134. . START ENDP 160. . END START 163.Inicializamos los registros de segmento 145.4C00h . nop 120. 126. mov ax.sp 153. . mov ss. Hallar el valor de AX tras la instrucción NOP: 129. pop ax 119. pop ax 118. .----------------------------------------------------------------------------140. START PROC 144. mov bx. push ax 152.Definicion del segmento de codigo 139.116. 148. mov bp. 161. PILA ENDS 136. int 21h . START ENDP 125. . push bx 151. 121.) Hallar el valor de AX tras el último POP: 164. int 21h 123.4C00h 122. db 40h DUP(0) 135. . assume cs:code. 159. . Muy importantes también son los ejercicios de pila. 157. . 130. mov al. CODE ENDS 162.5 149. 124. nop 155.----------------------------------------------------------------------------133. CODE SEGMENT 141.Definicion del segmento de pila 132. 9. assume cs:code 8. START PROC 10.ss:pila 177. pop ax 186. push 63h 185. PILA ENDS 171. Hallar el valor de AX tras la instrucción div bl: 2. stc .----------------------------------------------------------------------------6.----------------------------------------------------------------------------166. . assume cs:code.bx 14. .Definicion del segmento de codigo 5. .----------------------------------------------------------------------------4. CODE SEGMENT 176. mov al.Definicion del segmento de codigo 174. 190. CODE ENDS 195.pila 181. mov ss.ax 182. 178. 172.0D7h 13. . 194. . mov ah. . mov ax. inc sp 187.----------------------------------------------------------------------------173.1 12. PILA SEGMENT STACK "STACK" 169.Inicializamos los registros de segmento 180.Terminar el programa 191. 11.4C00h . . mov ax.----------------------------------------------------------------------------168. push 0F34h 184. . int 21h . CODE SEGMENT 7. 183. 189. db 40h DUP(0) 170. END START 10 1. START ENDP 193. xor bx.Definicion del segmento de pila 167. 192. . 3. .165. pop ax 188. START PROC 179.----------------------------------------------------------------------------175. Cadena2 db 80 dup("@").offset Cadena1 57. . 22. 36. . .Definicion del segmento de datos 30. mov ax. 19. . 24. START ENDP 23. una llena de '5' y otra de '@': 27. assume cs:code.----------------------------------------------------------------------------31.15. 49.----------------------------------------------------------------------------29.1 17. .Definicion del segmento de codigo 45. mov ah. . CODE ENDS 25. db 40h DUP(0) 41. rcr bx. mov ax. 56. mov ax.ax 55. mov ah. 43. PILA SEGMENT STACK "STACK" 40.Inicializamos los registros de segmento 51. rcr bx.offset Cadena2 61. . 60.Terminar el programa 26. mov dx. mov ss. START PROC 50. . END START . Cadena1 db 80 dup("5").----------------------------------------------------------------------------46. DATOS ENDS 35. De nuevo un ejercicio sencillito para dejar a un lado los exámenes (por el momento) y relajarnos un poco y ver otra forma de inicializar variables."$" 33. CODE SEGMENT 47.----------------------------------------------------------------------------39. 28.9 58. int 21h . mov ds. div bl 18. int 21h 59. PILA ENDS 42.datos 52. mov dx. .----------------------------------------------------------------------------37. int 21h 21. .----------------------------------------------------------------------------44. .ss:pila 48. DATOS SEGMENT 32."$" 34.1 16.9 62. Este programa muestra dos líneas.pila 54.Definicion del segmento de pila 38.ds:datos.4C00h 20.ax 53. 67. int 21h 66. int 21h .0 78. DATOS ENDS 79.----------------------------------------------------------------------------76. . . 69. repnz scasb 107. cld 103. . push ds 101.----------------------------------------------------------------------------83. pop es 102.Definicion del segmento de pila 82.4C00h 65.----------------------------------------------------------------------------74.4C00h 104. mov cx. . .ax 97. START ENDP 68. mov ds.----------------------------------------------------------------------------90.4C00h . . . Volvemos con más instrucciones de cadena y otro ejercicio de examen.datos 96. 64. 80.ds:datos. assume cs:code. Hallar el valor de CX tras la instrucción repnz scasb: 72.0. CODE SEGMENT 91. 109.pila 98. texto db "Esto es un texto". mov ax.Definicion del segmento de codigo 89. START PROC 94. . PILA ENDS 86. 87. mov ss. END START . . 73.Inicializamos los registros de segmento 95.63. mov ax.----------------------------------------------------------------------------81. . db 40h DUP(0) 85. 100. CODE ENDS 70.ss:pila 92. mov ax.Terminar el programa 71. 108. DATOS SEGMENT 77. START ENDP . 93. 111.ax 99.----------------------------------------------------------------------------88. mov ax. .Definicion del segmento de datos 75.14h 106."Y este otro". PILA SEGMENT STACK "STACK" 84. mov ax.Terminar el programa 110. lea di.texto 105. ."ot" lea di. 117.Definicion del segmento de codigo .Inicializamos los registros de segmento mov ax.cadena repnz scasw mov int ax.----------------------------------------------------------------------------.ax mov cx. ¿Que es lo que encuentra el programa? "to" de la palabra "Esto" "ot" de la palabra "otra" 116. END START 115.datos mov es.----------------------------------------------------------------------------DATOS SEGMENT cadena db "Esto es otra cadena" DATOS ENDS .4C00h 21h .ds:datos.112.----------------------------------------------------------------------------.ax cld mov ax.----------------------------------------------------------------------------. .Definicion del segmento de pila . CODE ENDS 114.Definicion del segmento de datos .----------------------------------------------------------------------------CODE SEGMENT assume cs:code.datos mov ds.Terminar el programa START ENDP CODE ENDS END START Hallar el valor de AX tras la instrucción mov al. 113.ss:pila START PROC .byte ptr tabla[si]: .----------------------------------------------------------------------------PILA SEGMENT STACK "STACK" db 40h DUP(0) PILA ENDS .100h mov ax. Definicion del segmento de pila .[si] ax.Terminar el programa START ENDP CODE ENDS END START Instrucción JMP Propósito: Salto incondicional .ax xor mov sub mov si.Inicializamos los registros de segmento mov ax.Definicion del segmento de codigo .4C00h 21h . .si ax.----------------------------------------------------------------------------CODE SEGMENT assume cs:code.Definicion del segmento de datos .----------------------------------------------------------------------------.----------------------------------------------------------------------------PILA SEGMENT STACK "STACK" db 40h DUP(0) PILA ENDS .datos mov ds.ax mov ax.10001101b.4F5h DATOS ENDS .'A'.byte ptr tabla[si] mov int ax.[si] al.----------------------------------------------------------------------------DATOS SEGMENT db 10.'Dk'.16 tabla dw 15.----------------------------------------------------------------------------.32.ss:pila START PROC .45h.ds:datos.----------------------------------------------------------------------------.'27'..pila mov ss. Instrucción JB (JNAE) Propósito: salto condicional Sintaxis: JB etiqueta Salta si está abajo o salta si no está arriba o si no es igual. El salto se efectua si CF esta desactivada. Esto significa que el salto se realiza solo si la bandera CF esta desactivada o si la bandera ZF esta desactivada (que alguna de las dos sea igual a cero). . Instrucción JA (JNBE) Propósito: Brinco condicional Sintaxis: JA Etiqueta Después de una comparación este comando salta si está arriba o salta si no está abajo o si no es igual. Instrucción JAE (JNB) Propósito: salto condicional Sintaxis: JAE etiqueta Salta si está arriba o si es igual o salta si no está abajo.Sintaxis: JMP destino Esta instrucción se utiliza para desviar el flujo de un programa sin tomar en cuenta las condiciones actuales de las banderas ni de los datos. El salto se efectúa si CF está activado o si ZF está activado (que cualquiera sea igual a 1). El salto se efectua si ZF está desactivada. El salto se realiza si ZF está activada. . se toma en cuenta el signo. Instrucción JBE (JNA) Propósito: salto condicional Sintaxis: JBE etiqueta Salta si está abajo o si es igual o salta si no está arriba.Se efectúa el salto si CF esta activada. Instrucción JG (JNLE) Propósito: salto condicional. Instrucción JNE (JNZ) Propósito: salto condicional Sintaxis: JNE etiqueta Salta si no es igual o salta si no es cero. Instrucción JE (JZ) Propósito: salto condicional Sintaxis: JE etiqueta Salta si es igual o salta si es cero. Sintaxis: JG etiqueta Salta si es más grande o salta si no es menor o igual. El salto ocurre si ZF = 0 u OF = SF. Sintaxis: JGE etiqueta Salta si es más grande o igual o salta si no es menor que. Instrucción JGE (JNL) Propósito: salto condicional. Sintaxis: JLE etiqueta Salta si es menor o igual o salta si no es más grande. El salto se efectúa si SF es diferente a OF. se toma en cuenta el signo. El salto se realiza si SF = OF Instrucción JL (JNGE) Propósito: salto condicional. se toma en cuenta el signo. El salto se realiza si ZF = 1 o si SF es diferente a OF . Sintaxis: JL etiqueta Salta si es menor que o salta si no es mayor o igual. se toma en cuenta el signo. Instrucción JLE (JNG) Propósito: salto condicional. Sintaxis: JC etiqueta Salta si hay acarreo. se toman en cuenta las banderas. Sintaxis: JNP etiqueta . se toma en cuenta el estado de las banderas. toma en cuenta el estado de las banderas. El salto se realiza si CF = 1 Instrucción JNC Propósito: salto condicional. Instrucción JNO Propósito: salto condicional. Instrucción JNP (JPO) Propósito: salto condicional. Sintaxis: JNO etiqueta Salta si no hay desbordamiento.Instrucción JC Propósito: salto condicional. El salto se efectua si OF = 0. Sintaxis: JNC etiqueta Salta si no hay acarreo. El salto se efectúa si CF = 0. se toma en cuenta el estado de las banderas. Salta si no hay paridad o salta si la paridad es non. El salto se efectúa si SF = 0. Sintaxis: JNP etiqueta Salta si el signo esta desactivado. Instrucción JO Propósito: salto condicional. El salto se realiza si OF = 1. El salto ocurre si PF = 0. toma en cuenta el estado de las banderas. Instrucción JS Propósito: salto condicional. toma en cuenta el estado de las banderas. El salto se efectúa si PF = 1. Instrucción JNS Propósito: salto condicional. . Sintaxis: JO etiqueta Salta si hay desbordamiento (overflow). Instrucción JP (JPE) Propósito: salto condicional. Sintaxis: JP etiqueta Salta si hay paridad o salta si la paridad es par. toma en cuenta el estado de las banderas. toma en cuenta el estado de las banderas. Instrucción LOOPE Propósito: Generar un ciclo en el programa considerando el estado de ZF Sintaxis: LOOPE etiqueta Esta instrucción decrementa CX en 1. Instrucción LOOP Propósito: Generar un ciclo en el programa. Sintaxis: LOOP etiqueta La instrucción loop decrementa CX en 1. Si CX es diferente a cero y ZF es igual a 1. considerando el estado de ZF Sintaxis: LOOPNE etiqueta Esta instrucción decrementa en uno a CX y transfiere el flujo del programa solo si ZF es diferente a 0. Instrucción DEC . El salto se efectúa si SF = 1. entonces el flujo del programa se transfiere a la etiqueta indicada como operando.Sintaxis: JS etiqueta Salta si el signo está prendido. Instrucción LOOPNE Propósito: Generar un ciclo en el programa. y transfiere el flujo del programa a la etiqueta dada como operando si CX es diferente a 1. Se utilizan DI como indice para el segmento extra de la cadena fuente y SI como indice de la cadena destino. fuente Con esta instrucción la cadena de caracteres fuente se resta de la cadena destino. Sintaxis: CMP destino. fuente Esta instrucción resta el operando fuente al operando destino pero sin que éste almacene el resultado de la operación. Instrucción INC Propósito: Incrementar el operando. Sintaxis: CMP destino. solo se afecta el estado de las banderas. . Instrucción CMPS (CMPSB) (CMPSW) Propósito: Comparar cadenas de un byte o palabra. Sintaxis: INC destino La instrucción suma 1 al operando destino y guarda el resultado en el mismo operando destino. Instrucción CMP Propósito: Comparar los operandos.Propósito: Decrementar el operando Sintaxis: DEC destino Esta operación resta 1 al operando destino y almacena el nuevo valor en el mismo oeprando. Instrucción CLI Propósito: Limpiar bandera de interrupción Sintaxis: CLI CLI pone en cero la bandera de interrupciones. Instrucción CLC Propósito: Limpiar bandera de acarreo.Solo se afecta el contenido de las banderas y tanto DI como SI se incrementan. Una interrupción enmascarable es aquella cuyas funciones son desactivadas cuando IF = 0. lo pone en cero. Instrucción CLD Propósito: Limpiar bandera de dirección Sintaxis: CLD La instrucción CLD pone en cero el bit correspondiente a la bandera de dirección. o sea. Sintaxis: . Instrucción CMC Propósito: Complementar la bandera de acarreo. Sintaxis: CLC Esta instrucción apaga el bit correspondiente a la bandera de acarreo. desabilitando así aquellas interrupciones enmascarables. CMC Esta instrucción complementa el estado de la bandera CF. y si es 1 la instrucción la iguala a 0. Sintaxis: STD La instrucción STD pone la bandera DF en 1. Instrucción STC Propósito: Activar la bandera de acarreo. . Sintaxis: STC Esta instrucción pone la bandera CF en 1. Podemos decir que unicamente "invierte" el valor de la bandera. si CF = 0 la instrucción la iguala a 1. Sintaxis: STI La instrucción activa la bandera IF. Instrucción STD Propósito: Activar la bandera de dirección. esto habilita las interrupciones externas enmascarables (las que funcionan unicamente cuando IF = 1 ). Instrucción STI Propósito: Acticar la bandera de interrupción. "$" .ponemos si en 0 comienzo: mov al. quiere decir que son iguales jz final: inc x loop comienzo final: mov dx. msg2[0] .posicion de la letra coincidente + di. al . al .si no coincide mandar a seguir inc di .si es el fin de la cadena mandar a final jz final cmp msg[si]. 0 .Ejercicio 1: Escribir un código que verifique si dos cadenas son iguales org 100h comienzo: mov si. msg2[di] mov bx. x mov al.comparar letra por letra las cadenas. "$" .comparar si encuentra la primera letra de la cadena jne seguir mov di.si es el fin de la cadena y el programa llego aca quiere decir que la cadena es parte de la palabra jz resultado loop comprobar . offset msg3 mov ah. msg2[si] cmp msg[si].si es el final y el programa llega aca. 1 .incrementar di para seguir recorriendo cadena cmp msg2[di]. al .poner en 1 di comprobar: mov al.bucle para recorrer cadena . 9 int 21h fin: ret msg db "hello world $" msg2 db "hello world $" msg3 db "Son iguales $" x dw 0 Ejercicio 2: Escribir un código que verifique si una cadena es subcadena de otra. comparar con la cadena jne seguir ."$" . si uno no coincide manda directamente a fin y termina el programa jne fin: cmp msg[si]. Por ejemplo: “la Mu” es subcadena de “Hola Mundo”.copiar la primera letra de la palabra a al cmp msg[si]. La cadena: “233″ es subcadena de la cadena “2122432234″ org 100h mov si. di cmp msg[si+bx]. msg2[di] . offset msg3 .copiar msg3 a dx mov ah. offset msg3 . Por ejemplo: todas las letras de la cadena “casa” se encuentran en “escaso”. 9 .bucle principal para recorrer palabra resultado: mov dx.bucle para recorrer seguir: inc si .poner en 0 di comprobar: mov al. "$" . 0 . 0 .copiar msg2 con su posicion a al cmp msg[si].bucle principal para recorrer palabra resultado: mov dx. al .si se encuentra entonces continua inc di .si es que llega al final y no encontro coincidencia. 9 .para seguir recorriendo la palabra loop comienzo . entonces ya termina el programa jz final loop comprobar ."$" .seguir: inc si .si es el fin de la cadena mandar a final jz resultado mov di.copiar msg3 a dx mov ah.preparar ah con 9 para la interrupcion 21h int 21h .comparar msg con su posicion con al jz seguir . Pero no todas las letras de “cerro” se en cuentran en “recanate” org 100h mov si.mostrar contenido en dx final: ret msg db "cerro$" msg2 db "recanate$" msg3 db "Si se encuentran todos los caracteres$" .para seguir recorriendo la palabra loop comienzo .incrementar di para seguir recorriendo cadena cmp msg2[di].mostrar contenido en dx final: ret msg db "Hola Mundo$" msg2 db "ola$" msg3 db "Si es subcadena$" Ejercicio 3: Escribir un código que verifique que todas los caracteres de una cadena se encuentran en otra.preparar ah con 9 para la interrupcion 21h int 21h .ponemos si en 0 comienzo: cmp msg[si]. 1 int 21h cmp al. sin utilizar una variable auxiliar. "$" jz seguir mov bl.13 jz resultado: cmp al. 0 cadAnum: cmp cad[si]. 9 . al .preparar ah con 9 para la interrupcion 21h int 21h .limpia la pantalla mov al. ORG 100H mov si. cad[si] inc si loop cadAnum seguir: .00h . 0 lectura: mov ah.mostrar contenido en dx ret Ejercicio 5: Escribir un programa que tome una cadena que representa un número decimal y escriba su equivalente octal org 100h .incrementa si fin3: jmp lectura resultado: mov ah. '0' add al.si tecla no es mayor a 47 ir a fin3 (tecla <= 47) jng fin3 mov bx[si]. terminada en ENTER.si tecla es mayor a 57 entonces ir a fin3 (tecla > 57) ja fin3 cmp al.Ejercicio 4: Escribir una programa que reciba una cadena ingresada por teclado. "$" mov dx. 57 .si es un digito entonces guardo en bx inc si . 10 mul bl sub cad[si]. inicio de programa mov si.03h int 10h mov bx[si]. 0 mov al.47 . offset bx mov ah. Luego que elimine todos los caracteres que no son dígitos. mov ah.dividir al con bl mov oct[si].incrementar si loop pasar fina: cmp ah.inc' . ah . 0 jnz final mov oct[si]. 9 .copiar a la cadena oct el resultado sobrante de la division inc si . '0' add al. "$" jz seguir mov bl. 0 mov al. 0 mov al. la primera y la tercera representan un número y la segunda una operación.int 21h .mov dx. “21″ e imprima el resultado “308″ org 100h .Incluye funciones de libreria emu8086 .Convertir segunda cadena a numero mov si.mov cx.mostrar contenido en dx ret cad db "64$" oct db 0 Ejercicio 6: Escribir un programa que tome tres cadenas. "$" jz seguir2 mov bl. 10 mul bl sub cad1[si]. 10 . inicio de programa include 'emu8086. DEFINE_PRINT_STRING DEFINE_PRINT_NUM DEFINE_PRINT_NUM_UNS mov si. cad1[si] inc si loop cadAnum seguir: mov aux1.preparar ah con 9 para la interrupcion 21h . al . por ejemplo: “329″. 0 mov bl. 0 . DEFINE_SCAN_NUM .Convertir primera cadena a numero cadAnum: cmp cad1[si]. offset res . 8 pasar: div bl . si mov si. al final: . 0 cadAnum2: cmp cad3[si]. “-”. al mov al. ax mov ah. bl jmp fin suma: add al.msg int 21h mov ax.mul bl sub cad3[si].09 lea dx. offset msg mov ah. "/" jz divi resta: sub al. bx call PRINT_NUM ret cad1 db "10$" cad2 db "-" cad3 db "2$" aux1 db ? aux2 dw ? msg dw "El resultado es: $" Ejercicio 7: Escribir un programa que imprima X en la pantalla hasta que se presiones ESC. '0' add al. cad3[si] inc si loop cadAnum2 seguir2: mov bl. "*" jz multi cmp cad2.realizar operaciones normalmente teniendo ya los dos numeros decimales cmp cad2. bl jmp fin multi: mul bl jmp fin divi: div bl jmp fin fin: mov bx. 9 int 21h . "-" jz resta cmp cad2. print a welcome message: mov dx. name "keybrd" org 100h . aux1 . "+" jz suma cmp cad2. cx mov bx. get keystroke from keyboard: . "$" pos db 1 end Ejercicio 8: Escribir un programa que ordene un vector de mayor a menor.0Ah db "You may hear a beep". 9 bucle2: .carriage return.0 mov bl. 2 int 10h .============================ exit: ret msg db "Type anything. name "arreglo-mayor" org 100h mov cx. (remove from the buffer) mov ah. check for keystroke in .".1 mov cx. eternal loop to get . pos mov bh. cx mov cx.Imprimimos una x int 10h mov ah.09h inc pos .".. 1 int 16h jz wait_for_key . and print keys: wait_for_key: .". 0Dh.".0Ah db "[Enter] .line feed.0Ah.0Ah db " when buffer is overflown. 0Dh. 0Dh.". 8 bucle1: mov c. 1bh jz exit jmp wait_for_key .============================ . 0eh int 10h .. print the key: mov ah.. 0Dh.0Ah db "[Ctrl]+[Enter] . 0Dh. pos mov dl. press 'esc' to exit: cmp al. 0 int 16h .1 mov ah. keyboard buffer: mov dh.'X' mov bh.0Ah db "Press Esc to exit. 0 mov ah. 0Dh.Movemos el cursor mov al. cont mov MCM. v[si-1] cmp ah.al .12.Copiar v[8] en dl . nro1 .si el nro2 no es multiplo del contador regresa a bucle1 parte2: .Copiar dh en v[8] mov cx.si el nro1 y el nro2 son multiplos del contador mov al.Si mov dh. dh seguir: loop bucle2 v[8] < v[7] no hacer nada.incrementar el contador jmp bucle .1 .0 mov al. Programa que calcula el MCD y MCM de dos numeros decimales (soporta numeros de 8 bits o 1 byte) mov cont.5. sino: .compara si el resto de la division del contador con el nro2 es 0 je parte2 jmp bc .cont mov bl.nro1 div bl cmp ah.0 mov al.0 .una vez que tengamos el MCM primero multiplicar nro1 * nro 2 mov al.Copiar v[7] en dh .con ese resultado.fin del programa .mov si. dividir por el MCM de nro1 y nro2 y tenemos el MCD mov bl.si el resto de la division del contador con el nro1 es igual 0 je parte1 bc: inc cont .v[bx-1] jnge seguir .32.Copiar dl en v[7] .21. al ret . nro2 mul bl mov bl.si nro1 es multiplo del contador mov ah. c loop bucle1 ret v db 2.cont mov bl. v[si-1] mov v[bx-1]. MCM div bl mov MCD.0 .91 c dw 0 Ejercicio 9: Escribir un programa que halle el MCM Y MCD .32. dl mov v[si-1]. v[bx-1] mov dl.bucle hasta que encuentre el MCM parte1: .nro2 div bl cmp ah.98. cx mov ah.guarda el MCM jmp parte3 .64.inicializar variable cont en 1 bucle: mov ah.ir a final parte3: . leer archivo leer: mov bx. int 10h cx color . name "archivo3" org 100h mov al.numero1 decimal nro2 db 60 .cont = contador MCM db 0 .DX = row... 1 mov dx.Change color for a single pixel .en esta variable se guarda el MCD nro1 db 48 .numero2 decimal Ejercicio 10: Escribir un programa que dibuje una diagonal en la pantalla. ax .CX = column fin: ret color db 1 Ejercicio 11: Escribir un programa que lea un archivo y cuente cuantas palabras terminan con la letra a. bucle1: mov dx. 0 int 10h . offset archivo . mov al. 101 . mov ah.si no paso mover a lo que le dio el SO jmp leer error: .modo de acceso para abrir arhivo.1 mov al. add color. mov cx. .AL = pixel color 0ch . modo lectura/escritura mov dx.para cambiar colores jmp bucle1 . . handle mov cx.offset lugar de memoria donde esta la variable mov ah. set graphics video mode. 13h mov ah. si se prendio la bandera c ir a error mov handle.en esta variable se guarda el MCM MCD db 0 .cont db 0 .llamada a la interrupcion DOS jc error . 3dh .llegar hasta 100 x 100 (va en diagonal) jz fin inc cx .set pixel cmp cx. offset leido mov ah. 3fh int 21h . 2 .. 0 .se intenta abrir el archivo int 21h . "a" . leido[0] cmp dl.cerramos archivo mov bx.txt".guardar en aux lo que hay en dl para comparar en la proxima vuelta jmp leer FIN: . handle mov ah. " " . dl .identificador del arhivo aux db "$" cont db 0 .si no es espacio entonces ir a abajo mostrar: cmp aux.si es 0 entonces va a fin para cerrar archivo . 0 . 0 .Detectar palabras que terminan con a mov dl.cmp ax.ascii del nombre del archivo leido db "$" handle dw ? .si es espacio entonces ir a mostrar jmp abajo . 3eh int 21h ret archivo db "C:\prueba.si es a entonces incrementar contador abajo: mov aux.compara si el anterior es a jnz abajo inc cont .ax queda en 0 cuando llega a EOF jz FIN .comparar si es espacio jz mostrar .