Instituto Tecnológico Superior de Valladolid

6”A”

Manuel Elías Berzunza Pérez

18070013

Ingeniería en sistemas computacionales.

Lenguajes de Interfaz.

Juan Bernando Alfonso

 Programar dispositivos a través de los puertos
serial, paralelo, hibrido y usb.

Puertos Seriales.
Comunicación serial en lenguaje ensamblador. En lenguaje ensamblador, se
puede acudir a la interrupción 14H de la ROMBIOS para configurar, leer, escribir o
simplemente para conocer el estado del puerto; cada una de estas cuatro
opciones es un servicio de la interrupción, y se seleccionan a través del registro
AH. La figura 1 muestra los valores que debe contener el registro AH para invocar
cada uno de los servicios. En todos los casos, el registro DX debe contener el
número del puerto serie; el primero de ellos, COM1 se especifica como 00h.

Ejemplo:
En este ejemplo se  utiliza el lenguaje ensamblador para configurar el puerto serial
para 1200 baudios, sin bit de paridad, sin bit de parada y 8 bits, realizando el
siguiente programa:
mov ah,0  →    Servicio 00 de INT 14h: inicializa el puerto
mov a1,83 →    configuración: 1200 baudios, no paridad, sin bit de parada, 8 bits
de datos
mov dx,00 →    Selecciona el puerto COM1
int 14          →   Interrupción del BIOS
mov ah,4c  →   Servicio 4ch de INT 21h: terminar
int 21          →   Interrupción servicio del DOS
Puerto Paralelo

Conocido también con el nombre de CENTRONICS INTERFACE transmite los

datos en paralelo mediante un bus de 8 líneas más las líneas de control del
protocolo y del estado de la impresora, esto nos permite disponer de varias líneas
digitales que podremos controlar independientemente y de forma inmediata
mediante las instrucciones de control de puertos (por ejemplo: outportb(), 
inportb()  en C++). Esto hace que podamos, de forma muy sencilla, controlar
directamente dispositivos electrónicos como pueden ser Leds, microreles,
pulsadores, etc...

    El puerto paralelo tiene dos inconvenientes fundamentales; el primero es que

cada vez menos PC los llevan incorporado y el segundo es que cuando
trabajamos con un sistema operativo Windows XP, NT y 2000, necesitamos un
driver que nos permita acceder a los puertos.

Descripción Física Del Conector.

 El puerto paralelo del pc dispone de un conector subD de 25 pines hembra al que
normalmente conectamos un cable Centronics de impresora que en un extremo
tiene el conector SubD 25 pines macho y por el otro un conector Centronics de 36
pines. La asignación de pines, tanto en el conector D-25 como en el Centronics es
la siguiente:

Pin
Pin
Nº
Nº(Centronics Línea Puerto SPP Dirección Registro(bit)
(D-
)
25)
Entrada/
1 1 -Strobe Control(0)
Salida
2 2 D0 Salida Datos(0)
 Datos(1)
3 3 D1 Salida
4
4 D2 Salida Datos(2)

5
5 D3 Salida Datos(3)
6
6 D4 Salida Datos(4)
7
7 D5 Salida Datos(5)
8
8 D6 Salida Datos(6)
9
9 D7 Salida Datos(7)
10
10 -Ack Entrada Estado(6)
11
11 Busy Entrada Estado(7)
12
12 Paper-out Entrada Estado(5)
13
13 Select Entrada Estado(4)
14 Entrada/
14 -Auto-Linefeed Control(1)
Salida
15
32 -Error Entrada Estado(3)
16 Entrada/
31 -Initialize Control(2)
Salida
17 Entrada/
36 -SelecPrinter Control(3)
Salida
18-
25 19-30 GND TIERRA   

Acceso A Los Puertos.

 Para el control de estas líneas utilizamos tres puertos que están direccionados
según la siguiente tabla:
 Puerto Dirección Dirección
LPT1 LPT2
Datos 378H 278H
Estado 379H 279H
Control 37AH 27AH

 Con estas dos tablas podemos modificar o leer cualquiera de las líneas del puerto
paralelo mediante el uso de las instrucciones de acceso a puerto, para C++ estas
son outportb e inportb, para Delphi no hay, por lo que tendrás que usar los dos
procedimientos siguientes:

Ejemplo:
Este es un programa para enviar distintas secuencias al puerto paralelo y así
tener efectos con Leds.

Programación en Ensamblador Ejemplo de escritura en puertos

Este programa tiene como función demostrar como se puede escribir datos en un
puerto, en este caso usamos el puerto paralelo del PC el cual es sencillo de visualizar
conectando 8 leds a los pines 2 a 9 cada uno en serie con una
resistencia de 220 ohms, los datos visualizados corresponden a las valores
ASCII de la tecla presionada.
el programa termina cuando se presiona *
Declaración del segmento de pila
STACK SEGMENT PARA STACK 'STACK'
DB 256 DUP(0) 256 BYTES DE ESPACIO EN EL STACK
STACK ENDS
ASSUME CS:COD ,DS:COD
COD SEGMENT
; Mensajes
MES1 DB
MES2 DB 'OPRIMA * PARA SALIR','$'
MES3 DB 'ADIOS','$'
MENSAJE DW 0
MAIN PROC FAR
MOV AX,CS
MOV DS,AX
Escribir mensaje inicial
EJEMPLO DE ACCESO A PUERTOS VILLARREAL ROMERO MAGDALENA JULIO 15 DE 2013
OPRIMA * PARA SALIR
MOV MENSAJE,OFFSET MES1
 CALL
ESCRIBIR
MOV MENSAJE,OFFSET MES2
CALL ESCRIBIR
Bucle principal que captura los caracteres del teclado y envía su valor ASCII
al bus de datos del puerto paralelo el corresponde a la dirección 378h
bucle:
LEE EL CARACTER DEL TECLADO
MOV AH,1
MOV DL,0FFH
INT 21H
Verifica si el carácter corresponde al * para salir del programa
CMP AL,'*' Compara el valor de AL con el valor ASCII del asterisco
JE ADIOS si la anterior comparación dio igual saltar a adiós
MOV DX,378H DIRECCION DEL PUERTO PARALELO
El comando OUT tiene como función escribir en el puerto cuya dirección de 16 bits
se encuentra almacenada en DX, el valor a escribir de 8 bits se almacena en AL
OUT DX,AL
JMP bucle
MAIN ENDP
Rutina para desplegar mensajes
ESCRIBIR PROC NEAR
PUSH AX
PUSH DX
MOV AH,09H
MOV DX,MENSAJE
INT 21H

MOV AH,06
MOV DL,0DH
INT 21H
MOV AH,06H
MOV DL,0AH
INT 21H
POP DX
POP AX
RET
ESCRIBIR ENDP
Rutina de salida
ADIOS:
Se escribe un return o alimentacion de linea
MOV AH,06
MOV DL,0DH
INT 21H
MOV AH,06H
MOV DL,0AH
INT 21H
Se escribe adiós.
MOV MENSAJE,OFFSET MES3
CALL ESCRIBIR
La funcio 4CH de la inte 21HF devuelve el control al sistema operativo
MOV AH,4CH
INT 21H
COD ENDS
END MAIN
Programación Híbrida o puerto hibrido

La programación híbrida proporciona un mecanismo por medio del cual podemos

aprovechar las ventajas del lenguaje ensamblador y los lenguajes de alto nivel,
todo esto con el fin escribir programas más rápidos y eficientes.
En esta sección se mostrará la forma para crear programas híbridos utilizando el
lenguaje ensamblador y Turbo Pascal.
Turbo Pascal permite escribir procedimientos y funciones en código ensamblador
e incluirlas como parte de los programas en lenguaje Pascal; para esto, Turbo
Pascal cuenta con dos palabras reservadas: Assembler y Asm.
Assembler permite indicarle a Turbo Pascal que la rutina o procedimiento que
seestá escribiendo está totalmente escrita en código ensamblador.

Ejemplo:

Procedimiento híbrido:
Procedure Limpia_Pantalla;
Assembler;
AsmMov AX,0600h
 Mov
BH,18h
Mov CX,0000h
Mov DX,184Fh
Int 10h
End;
El procedimiento del listado 23 utiliza la función 06h de la Int 10h del BIOS para
limpiar la pantalla, este procedimiento es análogo al procedimiento ClrScr de la
unidad CRT de Turbo Pascal.

Ejemplo:
Procedure Limpia_Pantalla;                        →             Declaracion del
procedimiento en Pascal. Assembler;                                                    →            
Instrucción que indica que el código estará escrito en ensamblador. AsmMov
AX,0600h                                        →            Mover 0600h al registro AX. Int 10h   
→             Iniciar servicio 06h de la interrupción 10h, es decir, limpiar pantalla. End 
→             Fin del procedimiento.
El código del ejemplo anterior está escrito para Turbo Pascal, a pesar de que
parece ser un programa de ensamblador.

Puerto USB.

Línea serial universal de transporte de datos. Es un conector rectangular de 4

terminales que permite la transmisión de datos entre una gran gama de
dispositivos externos (periféricos) con la computadora; por ello es considerado
puerto; mientras que la definición de la  Real Academia Española de la lengua es
"toma de conexión universal de uso frecuente en las computadoras".
El Bus Universal en Serie o USB por sus siglas en inglés, es un bus estándar
industrial que define los cables, conectores y protocolos utilizados en bus para
conectar, comunicar y proveer de alimentación eléctrica a dispositivos y
periféricos.
Fue creado por las empresas que buscaban unificar la forma de conectar
periféricos a los equipos, y aunque su versión 1.0 se publicó en 1996, no fue sino
hasta 1998 con la especificación 1.1 que se comenzó a utilizar de forma masiva.
La utilización del puerto USB en ensamblador es con los objetivos principales de
reorientar la utilización de los periféricos para que tengan mejor rendimiento y
 utilizar al
máximo sus capacidades, así como poder crear nuevos periféricos

// DESCRIPCIÓN: Esta aplicación trata de demostrar el proceso de

// transferencia USB 2.0 tipo bulk utilizando el chip EZ-USB SX2. Para ello
// tomamos una imagen BMP, la enviamos a la placa EZ-USB SX2, y la
// recibimos de la misma a través de endpoints bulk. Posteriormente
// se muestra el resultado obtenido, así como estadísticas de la
// transferencia.
//
// Se supone que la EEPROM de la EZ-USB FX tiene almacenado el firmware
// xmaster, y que la conexión de las placas FX y SX2 es la descrita
// en el ejercicio 3 de la Memoria. Asimismo, se supone que la SX2 está
// correctamente conectada al PC, y que ha sido detectada e identificada
// satisfactoriamente.
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "UnidadPrincipal.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
#include "CyAPI.h"
#include <time.h>
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
// Abrimos la imagen que se enviará por puerto USB a la EZ-USB SX2
TFileStream *source = new TFileStream("source.bmp", fmOpenRead);
// Creamos el fichero destino
TFileStream *target = new TFileStream("target.bmp", fmCreate);
// Los paquetes se enviarán en trozos de 512 bytes
const int packetSize = 512;
// La rutina de transferencia USB (XferData) requiere un tipo LONG
LONG pckSize = packetSize;
// Los buffer de salida y entrada serán de tipo "char"
char outBuffer[packetSize];
char inBuffer[packetSize];
int devices, vID, pID, d = 0;
 // En el
bitmap cargaremos la imagen recibida
Graphics::TBitmap *bitmap = new Graphics::TBitmap;
// que será pintada con unas dimensiones de 800x600
TRect destArea = TRect((ClientWidth-800)/2,45,
(ClientWidth+800)/2,600+45);
int temp; // Variable auxiliar
double tmp; // Variable auxiliar6.6. USANDO LA API DE CYPRESS—CYAPI 67
AnsiString stringAux; // Variable auxiliar
// Limpiamos el área de dibujo inicial
Canvas->FillRect(destArea);
// Abrimos el dispositivo USB de Cypress
CCyUSBDevice *USBDevice = new CCyUSBDevice(Handle);
devices = USBDevice->DeviceCount();
// Buscamos la placa EZ-USB SX2
do {
USBDevice->Open(d);
vID = USBDevice->VendorID;
pID = USBDevice->ProductID;
d++;
} while ((d < devices) && (vID != 0x04b4) && (pID != 0x1002));
// Calculamos los trozos de 512 bytes que serán enviados
temp = source->Size/packetSize;
ProgressBar1->Visible = true;
ProgressBar1->Max = temp+1;
// Almacenamos el valor temporal al inicio del proceso de transferencia
clock_t t1 = clock();
USBDevice->BulkOutEndPt->TimeOut = 500;
source->Read(outBuffer, packetSize);
// Enviamos los paquetes de 512 bytes
for(int i = 0; i < temp; i++) {
// Leemos un paquete desde el archivo fuente
source->Read(outBuffer, packetSize);
// Lo transferimos al primer endpoint tipo bulk de salida
USBDevice->BulkOutEndPt->XferData(outBuffer, pckSize);
// Lo recuperamos del primer endpoint tipo bulk de entrada
USBDevice->BulkInEndPt->XferData(inBuffer, pckSize);
// Y lo almacenamos en el archivo destino
target->Write(inBuffer, packetSize);
// Incrementando la barra de progreso consecuentemente
ProgressBar1->Position = i;
}
// Si queda un paquete de menos de 512 bytes será enviado seguidamente
temp = source->Size % packetSize;
if (temp) {
source->Read(outBuffer, temp);
USBDevice->BulkOutEndPt->XferData(outBuffer, pckSize);
USBDevice->BulkInEndPt->XferData(inBuffer, pckSize);
target->Write(inBuffer, temp);
}
// NOTA: Aunque el tamaño de paquete del último trozo debería ser
// inferior a "packetSize", si no se transfieren paquetes de 512 bytes
// se ha observado que el firmware "xmaster" no opera correctamente.
 // No
obstante, no se escriben nada más que los "temp" primeros bytes en
// el archivo destino.
// Almacenamos el valor temporal al finalizar el proceso de transferencia
clock_t t2 = clock();
delete target; // Liberamos el handle del archivo destino,68 CAPÍTULO 6. MARCO
DE TRABAJO PARA LA PROGRAMACIÓN USB
bitmap->LoadFromFile("target.bmp"); // lo cargamos en el bitmap
Canvas->StretchDraw(destArea, bitmap); // y lo mostramos en pantalla
// A continuación mostraremos cierta información de la transferencia
Canvas->Font->Color = clRed;
Canvas->Font->Size = 12;
Canvas->Font->Style = TFontStyles()<< fsBold;
tmp = (double) 2*source->Size/1024;
stringAux = "Kilobytes transferidos: " + FormatFloat("0.0",tmp) + " kB";
Canvas->TextOut(120,70, stringAux);
tmp = (t2-t1)/CLK_TCK;
stringAux = "Tiempo empleado: " + FormatFloat("0.0",tmp) + " segundos";
Canvas->TextOut(120,90, stringAux);
tmp = (2*source->Size/1024)/tmp;
stringAux = "Throughput: " + FormatFloat("0.0",tmp) + " kB/s";
Canvas->TextOut(120,110, stringAux);
// Téngase en cuenta que en el throughput intervienen distintos
// factores, a saber: tasa de transferencia hacia y desde la
// EZ-USB SX2 y tiempo de procesado de la EZ-USB FX
ProgressBar1->Visible = false;
USBDevice->Close(); // Cerramos el dispositivo,
 delete
bitmap; // liberamos el handle del bitmap
delete source; // y el del archivo fuente

CONCLUSIONES

A mi punto de vista puede decir que este tipo de programación para

dispositivos ya sea paralelo, serial, hibrida o puerto USB es de gran ayuda para
la comunicación entre el usuario y algún dispositivo lo hace de manera más
amena. Además de que el lenguaje de programación tiene un grado de
complejidad, pero que actualmente esta herramienta de programación nos da
bastantes ventas como por ejemplo poder comunicar un robot por medio de
instrucciones.

También creo que el lenguaje ensamblador a pesar de ser más rápido es eficaz
a la hora de implementarlo claro que se debe saber del tema; por ejemplo, la
electrónica donde los recursos de los aparatos son limitados y es necesario
utilizar lenguaje ensamblador.
 Después
de esto se puede decir que como se tiene acceso a casi todo el hardware de la
computadora vía interrupciones de software, tiene posibilidades que se puedan
programar virus.

 Se pueden programar drivers para cualquier dispositivo.

 Programarse micro controladores
 Crear compiladores
 Tener la posibilidad de poder acceder directamente a los dispositivos de
entrada y/o salida.

Bibliografía:

http://es.scribd.com/doc/120689070/Ensamblador

http://bbeltran.cs.buap.mx/EnsambladorDisco.pdf

http://www.ramonmedina.name/files/universidad/ac/ac0001.PDF

http://es.scribd.com/doc/120689070/Ensamblador#download

http://www.mcbtec.com/programacion_del_dspic.htm

http://lenguajes-interfaz-2013.blogspot.mx/