Exposiciones finales del dia 22/05/2018 equipos 3 y 4

Puerto serie:

Un puerto serie o puerto en serie es una interfaz de comunicaciones de datos digitales, frecuentemente utilizado por computadoras y periféricos, donde la información es transmitida bit a bit, enviando un solo bit a la vez; en contraste con el puerto paralelo que envía varios bits simultáneamente.
La comparación entre la transmisión en serie y en paralelo se puede explicar usando una analogía con las carreteras: una carretera tradicional de un único carril (en una carretera de ida y vuelta) por cada sentido corresponde a la transmisión en serie, y una carretera autovía con varios carriles por sentido corresponde a la transmisión en paralelo, siendo los vehículos los bits que circulan por el cable.
A través de este tipo de puerto la comunicación se establece usando un protocolo de transmisión asíncrono. En este caso, se envía en primer lugar una señal inicial anterior al primer bit de cada byte, carácter o palabra codificada. Una vez enviado el código correspondiente, se envía inmediatamente una señal de parada (stop) después de cada palabra codificada.
La señal de inicio (start) sirve para preparar al mecanismo de recepción o receptor, la llegada y registro de un símbolo, mientras que la señal de stop sirve para predisponer al mecanismo de recepción para que tome un descanso y se prepare para la recepción del nuevo símbolo.
La típica transmisión start-stop es la que se usa en la transmisión de códigos ASCII a través del puerto RS-232, como la que se establece en las operaciones con teletipos.

Exposiciones finales del dia 21/05/2018 equipos 1 y 2

Puerto paralelo:

Es una interfaz entre un ordenador y un periférico. El puerto paralelo transmite la información byte por byte, es decir que los 8 bits de datos que forman un byte viajan juntos. Un ejemplo de puerto paralelo es el puerto de la impresora. El Puerto Paralelo solo fue creado y usado para la interfaz de las impresoras y la P.C. hoy en día vemos que es uno de los mas usados para conectar diversos periféricos a su PC por su alta velocidad y fiabilidad en la transmisión de datos por lo cual, ha ido perfeccionandose cada día más.

Mucho antes de que el puerto paralelo normal con sus extensiones de altas velocidades y perfeccionamientos hubieran evolucionado, incluso antes de que IBM liberara su primer PC hacia el mercado, varias aplicaciones tenían necesidad de una interfaz simple de alta velocidad para la obtención de datos. Entre las primeras áreas que abrazaron tales conexiones está la instrumentación científica. Con tal objetivo la compañía Hewlett-Packard desarrolló su propia interface paralela HP-BIRF.El diseño se hizo tan popular que el IEEE(Instituto de Ingenieros Eléctricos y Electrónicos) lo adoptó como norma en 1978 con un nombre menos propietario GP-IB(Bus de Interface de Propósito General). El 30 de marzo de 1994, la IEEE aprobó su puerto paralelo normal, IEEE-1284-1994. La norma incluyó todos los modos básicos y planes del puerto paralelos que incluyen ECP y EPP. Se sometió a las Normas Nacionales Americanas se instituyó y aprobó como una norma el 2 de septiembre de 1994.

Diseño

El IEEE-488 comprende 16 conexiones separadas para mover datos y órdenes entre los dispositivos electrónicos. Ocho de estas conexiones llevan datos en un verdadero bus de 8 bits. Tres líneas proporcionan handshaking y mando de flujo entre los varios dispositivos que se unen juntos. Las siguientes cinco líneas permiten el arbitraje y dirección de las conexiones del bus. El conector normal también proporciona ocho conexiones de tierra. Los datos y flujo de los órdenes entre los dispositivos unidos en las ocho líneas de los datos asincrónicamente, son gobernados por las señales de hanshaking. El conector normal usado por el sistema de GPIB se parece al conector B del puerto paralelo pero tiene solo 24 conexiones.

IEEE 1284 1994

Este estándar proporciona una comunicación bidireccional de alta velocidad entre un PC y un periférico externo, estableciendo una comunicación entre 50 y 100 veces más rápida que el original puerto paralelo. Por supuesto es totalmente compatible con todos los periféricos existentes para puertos paralelos. El estándar 1284 define 5 modos de transferencia de datos. Cada modo proporciona un método de transferencia de datos hacia el exterior (PC a periférico), hacia el interior (periférico a PC) o bidireccional (dúplex).

Especificaciones

Tiene 8 cables para mandar simultáneamente todos los bits que conforman un byte. Esta interface es rápida y usualmente reservada para impresoras.
bit 0 bit 1 bit 2 bit 3 bit 4 bit 5 bit 6 bit 7
El principal problema del puerto paralelo es que sus cables no pueden ser extendidos para cualquier longitud sin amplificar la señal, o que ocurran errores en los datos

Ubicaciones

Los Puertos paralelos se pueden encontrar en:
-Interconstruidos en los motherboards actuales.
-En tarjetas controladoras multipuerto.
-En tarjetas sencillas de puerto paralelo (actualmente descontinuadas).
-Interconstruido en tarjetas de vídeo MDA, HGC o CGA (actualmente discontinuados)

Conectores

El puerto paralelo puede utilizar uno de los tres tipos de conectores definidos por el estándar IEEE 1284:
1. 1284 tipo A es un conector hembra de 25 patitas de tipo D. Es el utilizado en las impresoras
2. 1284 tipo B que es un conector de 36 patitas de tipo centronics y lo encontramos en la mayoría de las impresoras.
3. 1284 tipo C es un conector similar al 1284 tipo B pero más pequeño, con mejores propiedades eléctricas y mecánicas.

Tipos

Ante IEEE 1284, los puertos paralelos podrían ser divididos en cuatro tipos:
-Unidireccional (4 bits).
-Bidireccional (8 bits).
-Puerto paralelo extendido (EPP).
-Puerto paralelo con capacidades extendidas (ECP)

Puerto paralelo unidireccional (4 bits)

El único puerto paralelo disponible en la IBM-PC original era usado para enviar información de la computadora a un dispositivo, tal como la impresora. La naturaleza unidireccional del puerto paralelo original es porque su uso primario era enviar datos a la impresora. Aunque nunca había sido utilizado como puerto de entrada, había un esquema donde 4 de las líneas podían ser usadas como una conexión de entrada de 4 bits. Los puertos unidireccionales son capaces de transmitir velocidades de aproximadamente 40-60 Kbytes por segundo

Puerto paralelo bidireccional (8 bits)

Fue introducido en 1987 con la entrada de las computadoras PS/2 de IBM. Estos puertos pueden enviar y recibir 8 bits utilizando las 8 líneas estándar de datos y son considerablemente más rápidos que los puertos de 4 bits. Su velocidad está entre los 80 y 300 Kbytes / Seg.

Puerto paralelo extendido (EPP)

Opera casi a la velocidad del bus ISA y ofrece un incremento de hasta 10 veces la velocidad de transmisión sobre un puerto paralelo convencional. El EPP es específicamente diseñado para periféricos del puerto paralelo tales como adaptadores de red, unidades de disco externas, unidades de cinta, scanners etc. Su velocidad de transferencia está entre 1 y 2 Mbytes / seg.

Puerto paralelo con capacidades extendidas (ECP)

Desarrollado por Microsoft y HP. Como el EPP, el ECP ofrece un mayor rendimiento para el puerto paralelo. No como el puerto EPP, el ECP no está hecho para soportar periféricos portátiles para las PC’s, su propósito es soportar una conexión a impresoras de muy alto rendimiento.

 Video de programa que enciende leds con emu8086:https://www.youtube.com/watch?v=ImamnvO1YOE

Puerto USB :

Universal Serial Bus, una interfaz que permite la conexión de periféricos a diversos dispositivos, entre los cuales se encuentran los ordenadores y los teléfonos móviles.

El puerto USB, por lo tanto, es un componente que tiene la finalidad de conectar distintos dispositivos entre sí. Una impresora, un mouse (ratón), una webcam y unos altavoces son algunos ejemplos de periféricos que pueden conectarse a un puerto USB, sin olvidar los cada vez más populares discos duros externos y las clásicas llaves de memoria (pendrives).

Aunque existen diversos adaptadores, lo más recomendable es utilizar dispositivos que cuenten con el conector USB para facilitar el proceso de conexión y traslado de los mismos. El puerto USB puede entenderse como una entrada en la que sólo pueden ingresar aquellos artefactos con la ficha apropiada. Así como existen ciertos modelos de mouse que pueden conectarse a un puerto USB, otras clases de mouse presentan características diferentes y deben conectarse a otro puerto (PS/2).
Una de las grandes ventajas del puerto USB es que no exige reiniciar el sistema para reconocer que un periférico ha sido conectado. De este modo, el dispositivo en cuestión puede conectarse y usarse (plug-and-play). La tecnología USB también cuenta con la capacidad de detectar el programa informático que se necesita para que el dispositivo funcione, procediendo automáticamente a su instalación. Entre los aspectos más cuestionados del puerto USB, en cambio, se encuentra su ancho de banda reducido para transferir los datos.

Macros.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

Conexion de python con mysql ejemplo completo

Descargar codigo y base de datos:

https://drive.google.com/open?id=1kFSVbkYJQMiGOiZYMEPHf1i79jEUm0kN

Conexion python mysql y pip

pip instalado:

Importacion de libreria pymysql y lineas de codigo para la conexion:

Librerias para conectar python y mysql:

pymysql
mysql
myslqdb


Vídeos de ayuda:
https://www.youtube.com/watch?v=1zv9DXy8FiM
https://www.youtube.com/watch?v=1VV1ludVeBk&t=34s
https://dev.mysql.com/doc/connector-python/en/connector-python-example-connecting.html

Ejemplo con interfaz y base de datos biblioteca--insertar

Ejemplo de procedimientos almacenados :loop

CREATE DEFINER=`root`@`localhost` PROCEDURE `lolop`(in num int)
BEGIN
DECLARE x INT;
SET x = 0;
loop_label: LOOP
insert into editoriales (nombre_edi)
values (rand());
SET x = x + 1;
IF x >= num
THEN
LEAVE loop_label;
END IF;
END LOOP;
END

Ejemplos de procediemientos almacenados

Ejemplo con case:

CREATE DEFINER=`root`@`localhost` PROCEDURE `PROCESOS_alumnos`(in _numcon int,
in _nombreA varchar(10),
in _apellidoP varchar(10),
in _apellidoM varchar(10),
in _correo varchar(20),
in accion varchar(20))
BEGIN
case accion
when "nuevo" then
insert into alumnos(num_control,Nombre_A,apellido_p,apellido_m,correo)
values (_numcon,_nombreA,_apellidoP,_apellidoM,_correo);
when "editar" then
update alumnos set
Nombre_A=_nombreA ,apellido_p=_apellidoP,apellido_m=_apellidoM,correo=_correo
where num_control=_numcon;

when "eliminar" then
delete from alumnos where num_control=_numcon;

when "consultar" then
select *from alumnos where num_control=_numcon;
end case;
END


Ejemplo delete

CREATE DEFINER=`root`@`localhost` PROCEDURE `delete_procedure`(in hj int)
BEGIN
delete  from editoriales where ideditoriales=hj;
END

Ejemplo insert

 CREATE DEFINER=`root`@`localhost` PROCEDURE `insert_procedure`(in vg varchar(10))
BEGIN
insert into editoriales (nombre_edi)
values (vg);
END

Ejemplo  select 1

CREATE DEFINER=`root`@`localhost` PROCEDURE `mostrartodo_procedure`()
BEGIN
select * from editoriales;
END

Ejemplo  select 2

 
CREATE DEFINER=`root`@`localhost` PROCEDURE `select_procedure`(in hj int)
BEGIN
select * from editoriales where ideditoriales=hj;
END


Ejemplo update

CREATE DEFINER=`root`@`localhost` PROCEDURE `update_procedure`(in vh int , in th varchar(19))
BEGIN
update editoriales
set nombre_edi= th where ideditoriales=vh;
END

ejemplo 3-Macros- Multiplicacion de numeros de 2 digitos

; You may customize this and other start-up templates;
; The location of this template is c:\emu8086\inc\0_com_template.txt
;Eduardo Pablo Aquino Sanchez
org 100h

multi macro chra,chrb,chrx,chr3,chr2,chr1
   mov al,chra    ;al = chr4
   mov bl,chrb    ;bl = chr2
   mul bl         ;AL = chr3*chr2 (BL*AL)
   mov Ah,0h      ;
   AAM            ;ASCII Adjusment
   mov ac,AH      ;ac = AH (Acarreo)
   mov r2,AL      ;r2 = AL       (Unidad del resultado)

   mov al,chra    ;AL = chr4
   mov bl,chrx    ;BL = chr1
   mul bl         ;AL = chr1*chr3 (BL*AL)
   mov r1,al      ;r1 = AL       (Decena del resultado)
   mov bl,ac      ;BL = Acarreo anterior
   add r1,bl      ;r1 = r1+ac (r1 + Acarreo)
   mov ah,00h     ;
   mov al,r1      ;AL = r1 (Asignaci?n para el ajust)
   AAM            ;ASCII Adjustment
   mov r1,al      ;r1 = AL
   mov ac,ah      ;ac = AH (Acarreo para la Centena del resultado)
  
   mov al,chr3    ;al = chr3
   mov bl,chr2    ;bl = chr2
   mul bl         ;AL = chr3*chr2 (BL*AL)

   AAM            ;ASCII Adjusment
   mov ac2,AH      ;ac2 = AH (Acarreo)
   mov r4,AL      ;r4 = AL       (Unidad del resultado)

   mov al,chr3    ;AL = chr3
   mov bl,chr1    ;BL = chr1
   mul bl         ;AL = chr1*chr3 (BL*AL)
   mov r3,al      ;r3 = AL       (Decena del resultado)
   mov bl,ac2      ;BL = Acarreo anterior
   add r3,bl      ;r3 = r1+ac (r1 + Acarreo)
   mov ah,00h     ;
   mov al,r3      ;AL = r3(Asignaci?n para el ajust)
   AAM            ;ASCII Adjustment
   mov r3,al      ;r3 = AL
   mov ac2,ah      ;ac2 = AH (Acarreo para la Centena del resultado)
  
  
  
  
  
endm

suma macro r1_,r4_,ac_,r3_,ac2_
   mov al,r1_;=9               ;99
   mov bl,r4_;=1              ;x99
   add al,bl            ;----------------
   aAm                       ;891
   mov r1,al;=00            ;891
   mov r4,ah;=01            ;------------------------
                           ; 8901
   mov al,ac_;=8
   mov bl,r3_;=9
   add al,bl
   add al,r4
   aAm
   mov ac,al;=8
   mov r3,ah;=1

   mov al,ac2_;=8
   mov bl,r3;=1
   add al,bl
   aAm
   mov ac2,al;=09
   mov r3,ah;=0
endm

imprime macro ac2_,ac_,r1_,r2_
   mov ah,02h
   mov dl,ac2_
   add dl,30h
   int 21h        ;Mostramos ac (millar)

   mov ah,02H
   mov dl,ac_
   add dl,30h
   int 21h        ;Mostramos r1 (centena)

   mov ah,02H
   mov dl,r1_
   add dl,30h
   int 21h        ;Mostramos r2 (decena)

   mov ah,02H
   mov dl,r2_
   add dl,30h
   int 21h        ;Mostramos r2 (Unidad)

endm

.model small ;Modelo de memoria m?s utilizado

.stack

.data        ;definición de datos(variables), donde se almacenara información
   chr1  db ?
   chr2  db ?
   chr3  db ?
   chr4  db ?
   r1    db ?
   r2    db ?
   r3    db ?
   r4    db ?
   ac    db 0
   ac2   db 0
   aca   db 0
   aca2  db 0

.code


.startup
   mov ax,@data  ;almacenamos lo que esta en el segento data  
   mov ds,ax     ;movemos ax a ds
   mov ah,00h     ;Function(Set video mode)
   mov al,03      ;Mode 80x25 8x8 16
   int 10h        ;Interruption Video

   mov ah,01h     ;Function(character read)
   int 21h        ;Interruption DOS functions
   sub al,30h     ;ajustamos valores
   mov chr1,al    ;[chr1].chr2 * chr3 = ac.r1.r2

   mov ah,01h     ;Function(character read)
   int 21h        ;Interruption DOS functions
   sub al,30h     ;Ajustamos valores
   mov chr2,al    ;chr1.[chr2] * chr3 = ac.r1.r2

   mov ah,02h     ;Function(character to send to standard output)
   mov dl,'*'     ;Character to show
   int 21h

   mov ah,01h     ;Function(Read character)
   int 21h        ;Interruption DOS Functions
   sub al,30h     ;Transform(0dec = 30hex)
   mov chr3,al    ;chr1.chr2 * [chr3] = ac.r1.r2

   mov ah,01h     ;Function(Read character)
   int 21h        ;Interruption DOS Functions
   sub al,30h     ;Transform(0dec = 30hex)
   mov chr4,al    ;chr1.chr2 * [chr3] = ac.r1.r2

   mov ah,02h     ;Character to send to standar output
   mov dl,'='     ;
   int 21h        ;Interruption DOS functions

   ;Realizamos operaci?n

   ;parte 1 multiplicar
   multi chr4,chr2,chr1,chr3,chr2,chr1
  



   ;parte 3   Suma de los resultados
   suma r1,r4,ac,r3,ac2
  
  
               


   ;Mostramos resultado
   imprime ac2,ac,r1,r2
  
  

.exit
end

Ejemplo macros 2-modificado

; You may customize this and other start-up templates; 
; The location of this template is c:\emu8086\inc\0_com_template.txt
org 100h

gotoxy macro fila,col  ;macro que  pone el cursor en la posicion deseada   
    mov ah,02h    ;funcion imprimir caracter     
    mov dh,fila   ;ingresamos la coordenada de x      
    mov dl,col    ;ingresamos la coordenada de y      
    mov bh,0h     ;numero de pagina         
    int 10h       ;interrupcion  
    endm          ;fin del macro
 
pantalla macro que  ;macro que imprime el primer caracter de la palabra escrita          
    mov ah,02h      ;funcion  imprimir caracter 
    mov dl,offset que   ;ponemos el mensaje en dl     
    int 21h             ;interrupcion
    endm                ;fin del macro
 
imprime macro eztryng   ;macro que imprime los mensajes que le enviemos    
    mov dx,offset eztryng  ;ponemos elmensaje en dx
    mov ah,9                ;funcion imprimir variable
    int 21h                 ;interrupcion
    endm                    ;fin del macro
 
.data    ;segmento de datos con  variables
    mensaje  DB "INGRESE UN CARACTER: ",13,10,"$"  
    mensaje2  DB "INGRESE X del 0 al 9: ",13,10,"$"  
    mensaje3  DB "INGRESE Y del 0 al 9: ",13,10,"$"
    mensaje4  DB "Que letra quieres",13,10,"$"   
    caracter  DB ?     
    varx  DB ?      
    vary  DB ?
    vaa   db 0
    vtext db 100 dup('$')   ;Declaracion del vector
 
       
.code  ;segmento de codigo 
    
    startup: ;funcion de inicio 
    mov ax,@data  ;almacenamos lo que esta en el segento data   
    mov ds,ax     ;movemos ax a ds
    imprime mensaje  ;llamamos al macro imprime y le enviamos la variable mensaje   
    mov si,00h       ;limpiamos el registro si
    mov caracter,0   ;limpiamos la variable caracter         
    leer:            ;inicio de la funcion leer

        mov ax,0000  ;limpiamos ax             
        mov ah,01h   ;fincion de ingreso de caracter con impresion del mismo en pantalla            
        int 21h      ;interrupcion   
        mov caracter[si],al  ;ponemos el caracter tecleado en el arreglo caracter       
        inc si       ;incrementamos si     
        cmp al,0dh   ;comparamos al=salto de linea         
        ja leer      ;de no ser igual repite la funcion leer para ingresar otro caracter   
        jb leer      ;en caso de que al=salto de linea continua el programa
        ;mov cx,si     
        mov ah,02h   ;funcion imprimir caracter       
        mov dl,10    ;imprimimos un salto de linea  
        int 21h      ;interrupcion
        imprime caracter ;llamamos al macro imprime y le enviamos la variable caracter
        mov ah,02h       ;funcion imprime caracter   
        mov dl,10         ;imprimimos un salto de linea
        int 21h           ;interrupcion
        imprime mensaje2  ;llamamos al macro imprime y le enviamos la variable mensaje2
        mov ax,0000       ;limpiamos ax
        mov ah,01h        ;fincion de ingreso de caracter con impresion del mismo en pantalla 
        int 21h           ;interrupcion  
        sub al,30h        ;le restamos 30h al caracter ingresado para transformarlo en un numero
        mov bl,al         ;ponemos el numero en bl
        mov varx,al       ;ponemos el numero en varx  
        imprime mensaje3  ;llamamos al macro imprime y le enviamos la variable mensaje3  
        mov ah,01h        ;fincion de ingreso de caracter con impresion del mismo en pantalla 
        int 21h           ;interrupcion  
        sub al,30h        ;le restamos 30h al caracter ingresado para transformarlo en un numero
        mov bl,al         ;ponemos el numero en bl
        mov vary,al       ;ponemos el numero en vary     
        mov ax,0003h      ;funcion que limpia la pantalla   
        int 10h           ;interrupcion 
        imprime mensaje4
        mov ah,01h        ;fincion de ingreso de caracter con impresion del mismo en pantalla 
        int 21h           ;interrupcion  
        sub al,30h        ;le restamos 30h al caracter ingresado para transformarlo en un numero 
        gotoxy vary,varx  ;llamamos al macro gotoxy y le enviamos las variables vary y varx
        mov ah,00          ;limpiamos la parte alta de ax
        mov si,ax          ;ingresamos en si la posicion del caracter que deseamos imprimir
        
        ;kol:          
         pantalla caracter[si] ;llamamos al macro pantalla y le enviamos el caracter en la posicion deseada 
         ;inc si  
        ;loop kol           
        
        mov ah,01h   ;funcion de captura con impresion en pantalla       
        int 21h      ;interrupcion    
        mov ax,4c00h ;funcion de fin       
        int 21h      ;interrupcion   
         
end startup          ;fin

Ejemplo macros:

Multiplicacion de numeros de 2 cifras emu8086

; You may customize this and other start-up templates;
; The location of this template is c:\emu8086\inc\0_com_template.txt
;Eduardo Pablo Aquino Sanchez
org 100h

 .model small ;Modelo de memoria m?s utilizado
.stack

.data        ;definición de datos(variables), donde se almacenara información
.code
   chr1  db ?
   chr2  db ?
   chr3  db ?
   chr4  db ?
   r1    db ?
   r2    db ?
   r3    db ?
   r4    db ?
   ac    db 0
   ac2   db 0 
   aca   db 0
   aca2  db 0
.startup
   ;cls
   mov ah,00h     ;Function(Set video mode)
   mov al,03      ;Mode 80x25 8x8 16
   int 10h        ;Interruption Video

   mov ah,01h     ;Function(character read)
   int 21h        ;Interruption DOS functions
   sub al,30h     ;ajustamos valores
   mov chr1,al    ;[chr1].chr2 * chr3 = ac.r1.r2

   mov ah,01h     ;Function(character read)
   int 21h        ;Interruption DOS functions
   sub al,30h     ;Ajustamos valores
   mov chr2,al    ;chr1.[chr2] * chr3 = ac.r1.r2

   mov ah,02h     ;Function(character to send to standard output)
   mov dl,'*'     ;Character to show
   int 21h

   mov ah,01h     ;Function(Read character)
   int 21h        ;Interruption DOS Functions
   sub al,30h     ;Transform(0dec = 30hex)
   mov chr3,al    ;chr1.chr2 * [chr3] = ac.r1.r2
 
   mov ah,01h     ;Function(Read character)
   int 21h        ;Interruption DOS Functions
   sub al,30h     ;Transform(0dec = 30hex)
   mov chr4,al    ;chr1.chr2 * [chr3] = ac.r1.r2

   mov ah,02h     ;Character to send to standar output
   mov dl,'='     ;
   int 21h        ;Interruption DOS functions

   ;Realizamos operaci?n
 
   ;parte 1 multiplicar el primer digito del segundo numero por todo el primer numero
   mov al,chr4    ;al = chr4
   mov bl,chr2    ;bl = chr2
   mul bl         ;AL = chr3*chr2 (BL*AL)
   mov Ah,0h      ;
   AAM            ;ASCII Adjusment
   mov ac,AH      ;ac = AH (Acarreo)
   mov r2,AL      ;r2 = AL       (Unidad del resultado)

   mov al,chr4    ;AL = chr4
   mov bl,chr1    ;BL = chr1
   mul bl         ;AL = chr1*chr3 (BL*AL)
   mov r1,al      ;r1 = AL       (Decena del resultado)
   mov bl,ac      ;BL = Acarreo anterior
   add r1,bl      ;r1 = r1+ac (r1 + Acarreo)
   mov ah,00h     ;
   mov al,r1      ;AL = r1 (Asignaci?n para el ajust)
   AAM            ;ASCII Adjustment
   mov r1,al      ;r1 = AL
   mov ac,ah      ;ac = AH (Acarreo para la Centena del resultado)
 
   ;parte 2      multiplicar el segundo digito de el segundo numero por todo el primer numero
   mov al,chr3    ;al = chr3
   mov bl,chr2    ;bl = chr2
   mul bl         ;AL = chr3*chr2 (BL*AL)
 
   AAM            ;ASCII Adjusment
   mov ac2,AH      ;ac2 = AH (Acarreo)
   mov r4,AL      ;r4 = AL       (Unidad del resultado)

   mov al,chr3    ;AL = chr3
   mov bl,chr1    ;BL = chr1
   mul bl         ;AL = chr1*chr3 (BL*AL)
   mov r3,al      ;r3 = AL       (Decena del resultado)
   mov bl,ac2      ;BL = Acarreo anterior
   add r3,bl      ;r3 = r1+ac (r1 + Acarreo)
   mov ah,00h     ;
   mov al,r3      ;AL = r3(Asignaci?n para el ajust)
   AAM            ;ASCII Adjustment
   mov r3,al      ;r3 = AL
   mov ac2,ah      ;ac2 = AH (Acarreo para la Centena del resultado)
 
   ;parte 3   Suma de los resultados             
   mov al,r1;=9               ;99
   mov bl,r4;=1              ;x99
   add al,bl            ;----------------
   aAm                       ;891
   mov r1,al;=00            ;891
   mov r4,ah;=01            ;------------------------
                           ; 8901
   mov al,ac;=8
   mov bl,r3;=9
   add al,bl
   add al,r4
   aAm
   mov ac,al;=8
   mov r3,ah;=1
 
   mov al,ac2;=8
   mov bl,r3;=1
   add al,bl
   aAm
   mov ac2,al;=09
   mov r3,ah;=0
 
   ;Mostramos resultado
   mov ah,02h
   mov dl,ac2
   add dl,30h
   int 21h        ;Mostramos ac (millar)

   mov ah,02H
   mov dl,ac
   add dl,30h
   int 21h        ;Mostramos r1 (centena)

   mov ah,02H
   mov dl,r1
   add dl,30h
   int 21h        ;Mostramos r2 (decena)
 
   mov ah,02H
   mov dl,r2
   add dl,30h
   int 21h        ;Mostramos r2 (Unidad)
.exit
end

Resumen de la unidad 2 :Arquitectura de un gestor de bases de datos

ESTRUCTURA DE LA MEMORIA:

Es la estructura de memoria compartida que contienen datos e información de control para una
instancia de una base de datos, cada instancia tiene sus propias estructuras de memoria y se
localiza en la memoria virtual del computador. Las estructuras de memoria se denominan System
Global Area (SGA) la cual es un área compartida por todos los usuarios y se divide en tres partes:


Arear de Memoria rápida (Dtabase buffer cache): mantiene los bloques de datos leídos
directamente de los archivos de datos. Cuando se procesa una consulta, el servidor busca los
bloques de datos requeridos en esta estructura. Si no se encuentra, el proceso servidor lee el
bloque de la memoria secundaria y coloca una copia. Está organizada en dos listas:
– Lista de sucios: bloques que han sufrido modificaciones y no han sido escritos en disco.
– Lista de menos recientemente usados: mantiene los bloques libres, los bloques a los que se
está accediendo actualmente y los bloques sucios que aún no han sido remitidos a la lista
de sucios.
 
Área de registro de rehacer (Redo log buffer): es un buffer circular que mantiene todos los
cambios que han sido realizados sobre la base de datos por operaciones de insert, update,
delete, create, alter y drop. Las entradas de este buffer contienen toda la información
necesaria para reconstruir los cambios realizados a la base de datos por medio de cualquier
instrucción (el bloque que ha sido cambiado, la posición de cambio y el nuevo valor). El uso es
estrictamente secuencial.


Shared Pool: es una caché que mejora el rendimiento ya que almacena parte del diccionario de datos y el parsing de algunas consultas en SQL.

En esta zona se encuentran las sentencias SQL que han sido analizadas. El análisis sintáctico de las sentencias SQL lleva su tiempo y Oracle mantiene las estructuras asociadas a cada sentencia SQL analizada durante el tiempo que pueda para ver si puede reutilizarlas.
Antes de analizar una sentencia SQL, Oracle mira a ver si encuentra otra sentencia exactamente igual en la zona de SQL compartido. Si es así, no la analiza y pasa directamente a ejecutar la que mantiene en memoria. De esta manera se premia la uniformidad en la programación de las aplicaciones. La igualdad se entiende que es lexicográfica, espacios en blanco y variables incluidas.
La base de datos Oracle asigna memoria a la shared pool cuando una nueva instrucción sql se analiza. El tamaño de esta memoria depende de la complejidad de la instrucción. Si toda la shared pool ya ha sido asignada la base de datos Oracle puede liberar elementos de la shared pool hasta que haya suficiente espacio libre para nuevas sentencias. Al liberar un elemento de la shared pool el sql asociado debe ser recompilado y reasignado a otra área de sql compartida la próxima vez que se ejecute.
El contenido de la zona de SQL compartido es:

• Las sentencias SQL y PL/SQL (texto de la sentencia)
• Plan de ejecución de la sentencia SQL.
• Lista de objetos referenciados.

Los pasos de procesamiento de cada petición de análisis de una sentencia SQL son:

• Comprobar si la sentencia se encuentra en el área compartida.
• Comprobar si los objetos referenciados son los mismos.
• Comprobar si el usuario tiene acceso a los objetos referenciados.Si no, la sentencia es nueva, se analiza y los datos de análisis se almacenan en la zona de SQL compartida.

Dividido en:

Library cache

Incluye los espacios comunes de SQL, áreas privadas de SQL (en el caso de una configuración de servidor compartido), los procedimientos PL/SQL y paquetes, y las estructuras de control, tales como bloqueos.

Data Dictionary Cache

También conocido como Dictionary Cache o Row Cache, almacena la información de uso más reciente sobre el diccionario de datos. Es una colección de tablas y vistas que contienen información referente a la base de datos como los nombres y tipos de datos de las columnas de las tablas, usuarios, passwords y privilegios. Durante la fase de compilación, esta información es necesaria para resolver los nombres de los objetos utilizados en un comando SQL y para validar los privilegios de acceso.

Video: https://www.youtube.com/watch?v=fKOnylu4tmA

Large Pool

El administrador de la base de datos puede configurar esta área de memoria opcional, para proveer localidades más amplias de memoria para:

• Memoria de sesiones.
• Procesos de I/O del servidor
• Backups de la base de datos y operaciones de recuperación.

Al asignar espacios dentro de large pool para un servidor compartido, Oracle puede usar la shared pool principalmente para guardar en caché las sentencias compartidas de sql y evitar la sobrecarga causada por la disminución de la caché de sql compartida. Además la memoria para backup y operaciones de recuperación y para procesos de I/O del servidor es asignada en buffers de algunos cientos de kilobytes, por lo que la large pool mucho más capaz de satisfacer dicha demanda de memoria que la shared pool.

Java Pool

La memoria java pool es usada en la memoria del servidor para todas las sesiones que utilicen código java y datos en la JVM. Esta memoria es usada de diferentes maneras dependiendo del modo en el que la base de datos esté corriendo.

Streams Pool

Esta memoria es usada exclusivamente por flujos de Oracle. Esta almacena colas de mensajes y provee memoria para que los flujos de Oracle capturen procesos y los apliquen. A menos que se configure específicamente, el tamaño de esta memoria empieza en cero. El tamaño de la streams pool crece dinámicamente como sea necesario cuando los flujos de Oracle son usados.

Video: https://www.youtube.com/watch?v=HJQF2AtpTA4

ARCHIVOS: 

Los Archivos de Datos (Datafiles): sirve para el almacenamiento físico de las tablas, índices y
procedimientos, estos son los únicos que contienen los datos de los usuarios de la base de datos.

Archivos de Control (control files): tiene la descripción física y dirección de los archivos para el arranque correcto de la base de datos

Archivos de Rehacer (redo log files): tienen los cambios que se han hecho a la base de datos
para recuperar fallas o para manejar transacciones. Debe esta conformado por dos grupos como
mínimo y cada grupo debe esta en discos separados. El principal propósito de estos archivos es deservir de respaldo de los datos en la memoria RAM.

Archivos fuera de línea (archived files): archivos opcionales donde se pueda guardar
información vieja de los archivos de rehacer, convenientes para respaldos de base de datos

LOS PROCESOS: 

Procesos de Base o de Soporte: se encargan de traer datos desde y hacia la estructura de
memoria (SGA), cada uno tiene su propia área de memoria; los procesos de este tipo son los
siguientes:

Database Writer (DBWR): se encarga de copiar los bloques desde el buffer cache hasta la
memoria secundaria.

Log Writer (LGWR): escribe las entradas desde el Log Buffer a disco. La escritura de
bloques del Redo Log Buffer a disco ocurre secuencialmente y bajo las siguientes reglas:
– Cuando el Redo Log está lleno en un 33% o más.
– Cuando oucrre un time-out (cada tres segundos).
– Antes de que el DBWR escriba algún bloque modificado a disco.
– Cuando una transacción se compromete.

Checkpoint (CKPT): encargado de notificar al DBWR para que se escriban en los archivos
de datos todos los bloques contenidos en la lista de sucios. Este proceso es invocado en
intervalos de tiempo determinados. El CKPT es opcional, si no existe las funciones son
realizadas por el LGWR.

System Monitor (SMON): Encargado de realizar un proceso de recuperación rápida cada
vez que una instancia es inicializada. Esta labor incluye limpieza de las estructuras de datos
de soporte a la ejecución de consultas y llevar a la base de datos a un estado estable
previo a la ejecución de aquellas transacciones que no hayan culminado exitosamente.
También se encarga de desfragmentar el espacio físico de almacenamiento uniendo
bloques de datos libres en la memoria secundaria.

Process Monitor (PMON): lleva la pista de los procesos de la base de datos y efectúa
labores de limpieza (liberar recursos y bloques ocupados en los cache’s) si alguno de ellos
termina prematuramente.

Archiver (ARCH): copia las bitácoras activas cuando éstas se encuentran llenas. Este
proceso se encuentra activo sólo cuando el DBMS se encuentra operando en modo
ARCHIVELOG, el único modo que admite recuperación de los datos frente a fallas del
sistema.

Recoverer (RECO): resuelve transacciones distribuidas que se encuentran pendientes
debido a la red o a fallas ocurridas en la base de datos distribuida.

Dispatcher (Dnnn): se crea por cada sesión de trabajo activa; es responsable de enrutar
los requerimientos desde el proceso usuario, al cual se encuentra asociado, hacia los
procesos servidores y retornar la respuesta al proceso de usuario adecuado. Estos
procesos se crean solo cuando se ejecuta con la opción multithreading.

Procesos de Usuario: se encarga de ejecutar el código de aplicación del usuario y manejar el perfil del usuario con sus variables de ambiente. Estos procesos no se pueden comunicar
directamente con la base de datos, por lo que la comunicación la establecen mediante
procesos de servidores.

Procesos de Servidores: estos procesos ejecutan las órdenes SQL de los usuarios y llevan los
datos del buffer caché para que los procesos de usuario puedan tener acceso a los datos.

2.1.3 Requerimientos para instalación de la base de datos.
Antes de instalar cualquier SGBD es necesario conocer los requerimientos de hardware y software, el posible software a desinstalar previamente, verificar el registro de Windows y el entorno del sistema, así como otras características de configuración especializadas como pueden ser la reconfiguración de los servicios TCP/IP y la modificación de los tipos archivos HTML para los diversos navegadores.

Se presenta a continuación una serie de requerimientos mínimos de hardware y software para instalar oracle 11g Express y MySQL estándar versión 5.1. en Windows Seven y Ubuntu 10.

2.1.4 Instalación del software de BD en modo transaccional
Debido al constante crecimiento de datos que generan las empresas hoy en día, se ha vuelto muy necesaria la búsqueda de nuevas plataformas para almacenar y analizar la información, ambientes que consuman menos recursos, que sean más escalables y que provean una alta disponibilidad. La solución consiste en el procesamiento paralelo de los datos de una base de datos.

Una base de datos en modo transaccional significa que la BD será capaz de que las operaciones de inserción y actualización se hagan dentro de una transacción, es un componente que procesa información descomponiéndola de forma unitaria en operaciones indivisibles, llamadas transacciones, esto quiere decir que todas las operaciones se realizan o no, si sucede algún error en la operación se omite todo el proceso de modificación de la base de datos, si no sucede ningún error se hacen toda la operación con éxito.

Una transacción es un conjunto de líneas de un programa que llevan insert o update o delete. Todo aquél software que tiene un log de transacciones (que es la "bitácora" que permite hacer operaciones de commit o rollback), propiamente es un software de BD; aquél que no lo tiene (v.g. D-Base), propiamente no lo es. Todo software de base de datos es transaccional; si el software de la BD no es "transaccional", en realidad NO es un "software" de BD; en todo caso, es un software que emula el funcionamiento de un verdadero software de BD. Cada transacción debe finalizar de forma correcta o incorrecta como una unidad completa. No puede acabar en un estado intermedio.

Se usan las siguientes métodos :

• ·       Begin TRans para iniciar la transacción
• ·       CommitTrans para efectuar los cambios con éxito
• ·       RollbackTrans para deshacer los cambios

Y depende que base de datos uses para efectuar las operaciones pero, es la misma teoría para cualquier BD.

Una vez que se sabe la forma de ingresar comandos, es el momento de acceder a una base de datos.

Suponga que en su hogar posee varias mascotas y desea registrar distintos tipos de información sobre ellas. Puede hacerlo si crea tablas para almacenar sus datos e introduce en ellas la información deseada. Entonces, podrá responder una variedad de preguntas acerca de sus mascotas recuperando datos desde las tablas. Los pasos serían:

• Crear una base de datos

• Crear una tabla

• Introducir datos en la tabla

• Recuperar datos desde la tabla de varias maneras

• Emplear múltiples tablas
2.1.5 Variables de Ambiente y archivos importantes para instalación.

Para instalar MySQL como primer instancia el archivo primordial es el que se descarga de la Web de MySQL. El proceso para instalar MySQL desde un archivo ZIP es el siguiente:
1. Extraer el contenido del archivo dentro del directorio de instalación deseado.

2. Crear un archivo de opciones.

3. Elegir un tipo de servidor MySQL

4. Iniciar el servidor MySQL.

5. Establecer la seguridad de las cuentas de usuario por defecto.

---

2.1.6 Procedimiento general de instalación de un DBMS

https://www.blogger.com/blogger.g?blogID=2605600142034265127#editor/target=post;postID=1936041526765777001;onPublishedMenu=allposts;onClosedMenu=allposts;postNum=22;src=postname

2.1.7 Procedimiento para configuración de un DBMS.
Para configurar nuestro DBMS podemos acceder a las siguientes pantallas, para Oracle o MySQL.
El esquema de una base de datos (en inglés, Database Schema) describe la estructura de una Base de datos, en un lenguaje formal soportado por un Sistema administrador de Base de datos (DBMS). En una Base de datos Relacional, el Esquema define sus tablas, sus campos en cada tabla y las relaciones entre cada campo y cada tabla.
Oracle generalmente asocia un 'username' como esquemas en este caso SYSTEM y HR (Recursos humanos).

Como conclusion podemos decir que una base de datoss esta compuesta por elementos que:
1.- Ayudan a manejar la informacion de forma rapida
2.-ayudan a no perder informacion
3.- almacenan informacion
4.- elementos de recuperacion
 

Explicación de los comandos Commit y Rollback (video)

Arquitectura de un sistema gestor de bases de datos

http://naps.com.mx/blog/arquitectura-de-un-sistema-gestor-de-bases-de-datos/

Ejemplo ciclos emu8086

org 100h



.model small

.stack 64

.data



mensaje db 10,13 ,"Dame un numero",10,13,"$"

mensaje2 db 10,13 ,"Dame un la potencia",10,13,"$"

n1 db 0

n2 db 0

n3 db 0

.code



inicio:     ;función inicio



 mov ax,@data ;Movemos el segmento data a ax

 mov ds,ax ; Movemos lo que esta en ax a ds

 mov dx,offset mensaje ;Imprimimos el primer mensaje parte 1

 mov ah, 09h ;Imprimimos el primer mensaje parte 2

 int 21h ;Imprimimos el primer mensaje parte 3



 mov ah,01     ;pausa y espera a que el usuario presione una tecla

 int 21h        ;interrupción para capturar

 sub al,30h   ;lo que el usuario presiono se guarda en al y se le resta 30h para convertirlo a un numero

 mov n1,al ;Movemos lo que esta en al a la variable n1

 mov n3,al  ;Movemos lo que esta en al a la variable n3



 mov ah, 09h ;imprimimos el mensaje 2 parte 1

 mov dx,offset mensaje2  ;imprimimos el mensaje 2 parte 2

 int 21h  ;imprimimos el mensaje 2 parte 3

 mov ah,01     ;pausa y espera a que el usuario presione una tecla

 int 21h           ;interrupcion para capturar

 sub al,30h     ;lo que el usuario presiono se guarda en al y se le resta 30h para convertirlo a un numero

 mov n2,al     ;Guardamos lo que el usuario preciono el n2





 mov cl,al ; movemos lo que esta en al a cl para decirle al ciclo cuantas vueltas va a dar

 sub cl,1 ;le restamos 1 para que no de una vuelta de mas





call ciclo ;llamada a ciclo



ciclo:  ;Funcion

 call ciclo1 ;llamada el procediemto 1



ciclo1 proc near : ;procedimiento ciclo

  mov al,n1 ;potencia parte 1

  mov bh,n3 ;potencia parte 2

  mul bh ;potencia parte 3



  mov n1,al



  loop ciclo1 ;loop a la funcion ciclo

 



  mov ax,4c00h ;fin parte 1

  int 21h; fin parte 2



fin: ;funcion fin

 mov ax,4c00h      ;funcion que termina el programa

 int 21h

end inicio

Programa-Ensamblador en pantalla - Manipulación de pantalla

Programa documentado:



https://drive.google.com/open?id=1XUd_pYgMQAmwMZrECZGg3Nu6KhKDwBUK
-------------

Ejemplo de tablas relacionadas mysql

Programas del dia 20/02/018. Manejo del colores

FIN_4c00H EQU 4c00h
DOS_21h EQU 21h
BIOS_10h EQU 10h

pila segment stack
    Dw 100 DUP('0')
pila ends

codigo segment
    CLS proc Far
    assume CS:codigo,SS:pila
    CAll limpia
    mov ax,FIN_4c00H
    int DOS_21h
    CLS ENDP
limpia proc near
 mov ax,0600h
 mov bh,0Ah
 mov cx,001h
 mov dx,484fh
 int BIOS_10h
 ret
 limpia endp
codigo ends
end CLS
---------------------------------------------------------------------------------------------
org 100h

mov ah ,06h
mov bh, 9fh
mov cx ,0000h
mov dx,484fh

int 10h

mov ah,02h
mov bh ,00h
mov dx ,0000h
int 10h

int 21h
mov ax,4c00h
int 21h



ret
--------------------------------------------------------------------------------------------------
org 100h

.data
msg DB "color","$"

.code

mov ah ,06h
mov bh, 9fh
mov cx ,0000h
mov dx,484fh

int 10h

mov ah,02h
mov bh ,00h
mov dx ,0000h
int 10h

mov ax,@data
mov dx,ax
lea dx,msg
mov ah,9h
int 21h

mov ax,4c00h
int 21h

Programas del dia 19/02/018

include 'emu8086.inc'
name "Muestra"
org 100h

call suma
call inicio
call resta
call final

inicio:
mov ax,20h
mov bx,13h
ret

suma:
add ax,1AAh
add bx,11ch
add ax,bx
ret

resta:
sub ax,3h
sub bx,2h
ret

final:

mov ax,4c00h
int 21h
ret


end
-------------------------------------------------------------------------
org 100h

 
CR EQU 13
lf EQU 10
imprimir EQU 9
fin EQU 4c00h
dos EQU 21h

.data
    txt DB 'ejemplos',CR,lf,'$'
   

.stack 100h
  

.code
  
    inicio:mov ax,@data
    mov ds,ax
    mov dx,offset txt
    mov ah,imprimir
    int dos
    mov ax,fin
    int dos

end inicio

ret
---------------------------------------------------------------------------------------
org 100h

 
CR EQU 13
lf EQU 10
imprimir EQU 9
fin EQU 4c00h
dos EQU 21h

.data
    txt DB 'ejemplos',CR,lf,'$'
   

.stack 100h
  

.code
  
    inicio proc
    mov ax,@data
    mov ds,ax
    mov dx,offset txt
    mov ah,imprimir
    int dos
    mov ax,fin
    int dos

end inicio

ret
------------------------------------------------------------------------------------------------
include 'emu8086.inc'
name "Muestra"
org 100h

call suma
call inicio
call resta
call final

inicio proc
mov ax,20h
mov bx,13h
ret

suma proc
add ax,1AAh
add bx,11ch
add ax,bx
ret

resta proc
sub ax,3h
sub bx,2h
ret

final proc

mov ax,4c00h
int 21h
ret


end
-----------------------------------------------------------------------------------------------------------------------

Ejemplo: Ingresar datos desde el teclado en emu8086

MongoDB-NoSQL

Apache Derby

Ejemplos en emu8086 del dia 07/02/018

XAMPP

Ejemplo registros bandera