INSTITUTO TEGNOLOGICO SUPERIOR DE

SAN ANDRES TUXTLA

MATERIA: INTRODUCCION A LA PROGRAMACIÒN

UNIDAD VI (INFORME DE INVESTIGACIÒN)

6.1 PROGRAMACIÒN DE PUERTOS DE LA COMPUTADORA

6.2 ELABORACIÒN DE INTERFASES

6.3 CONTROL DE INTERFASES A TRAVES DE

COMPUTADORA

DOCENTE: SERGIO PELAYO VAQUERO

ALUMN@: JOSELYN CHIPOL SINACA

CARRERA: INGENIERIA ELECTROMECANICA

SEMESTRE: PRIMER SEMESTRE

GRUPO:102 B

FECHA DE ENTREGA: 09 DE ENERO, 2023

PERIODO ESCOLAR: SEPTIEMBRE – ENERO 2023

SAN ANDRES TUXTLA, VER.

 INTRODUCCIÒN

En un esquema de transmisión de datos en serie, un dispositivo envía datos a otro

bit uno a la vez a través de un cable. Por otro lado, en un esquema de transmisión
de datos en paralelo, un dispositivo envía datos a otro dispositivo a una velocidad
de n número de bits a través de n número de cables en cualquier momento.

Un sistema de comunicación paralelo típico puede ser unidireccional

(unidireccional) o bidireccional (bidireccional). El mecanismo más simple utilizado
por los puertos paralelos de PC es unidireccional y se describe primero.
Distinguimos entre dos elementos: la parte emisora y la parte receptora. El remitente
coloca información en la línea de datos y notifica al receptor que la información está
disponible. Luego, el receptor lee la información en la línea de datos y notifica al
remitente que tiene la información.

Por eso en este documento se presentará los sistemas que uno maneja en la
programación de puertos e interfases en la computadora
 6.1 PROGRAMACIÒN DE PUERTOS DE LA COMPUTADORA

Un puerto en la computadora es por donde la información fluye hacia dentro o hacia

fuera. Los dispositivos Hardware como la impresora o modem pueden ser llamados
puertos, un puerto que manda información fuera de tu computadora puede ser el
monitor o la impresora. Un puerto que recibe información sería el modem o
un scanner.
Se dividen en 2 tipos:
a) Puertos físicos de la computadora:
Son conectores integrados en tarjetas de expansión ó en la tarjeta principal
"Motherboard" de la computadora; diseñados con formas y características
electrónicas especiales, utilizados para interconectar una gran gama de dispositivos
externos con la computadora, es decir, los periféricos. Usualmente el conector
hembra estará montado en la computadora y el conector macho estará integrado en
los dispositivos ó cables. Varía la velocidad de transmisión de datos y la forma física
del puerto acorde al estándar y al momento tecnológico.
Anteriormente los puertos venían integrados exclusivamente en tarjetas de
expansión denominadas tarjetas controladoras, posteriormente se integraron en la
tarjeta principal "Motherboard" y tales controladoras perdieron competencia en el
mercado, pero actualmente se siguen comercializando sobre todo para servidores.
b) Puertos lógicos de la computadora:
Son puntos de acceso entre equipos para el uso de servicios y flujo de datos entre
ellos, ejemplos el puerto 21 correspondiente al servicio FTP (permite el intercambio
de archivos) ó el puerto 515 que está asociado con el servicio de impresión.
Clasificación de los puertos para computadora (físicos)
Los puertos generalmente tienen más de un uso en la computadora e inclusive en
dispositivos que no se conectan directamente al equipo, por lo que no hay una
clasificación estricta, sin embargo, se pueden dividir en 7 segmentos básicos:
1) Puertos de uso general: son aquellos que se utilizan para conectar diversos
dispositivos independientemente de sus funciones (impresoras, reproductores MP3,
bocinas, pantallas LCD, ratones (Mouse), PDA, etc.)

 Puerto eSATA
 Puerto USB
 Puerto FireWire ó IEEE1394
 Puerto SCSI
 Puerto paralelo / LPTx
 Puerto serial / COMx2)
Puertos para impresoras: soportan solamente la conexión de impresoras y
algunos Plotter.

3) Puertos para teclado y ratón: su diseño es exclusivo para la conexión de

teclados y ratones (Mouse).

• Puerto miniDIN - PS/2

• Puerto DIN - PS/1

4) Puertos para dispositivos de juegos: permiten la conexión de palancas,

almohadillas y volantes de juego.

• Puerto de juegos Gameport (DB15

5) Puertos de video permiten la transmisión de señales procedentes de la

tarjeta de video hacia una pantalla ó proyector.

: Puerto DisplayPort (transmite video, sonido y datos de manera simultánea)

• Puerto HDMI (transmite video, sonido y datos de manera simultánea)

• Puerto DVI
• Puerto S-Video
• Puerto VGA
• Puerto RCA
• Puerto CGA
• Puerto EGA

6) Puertos de red: permiten la interconexión de computadoras por medio de

cables.

• Puerto RJ45 (para red local LAN)

• Puerto RJ11 (para red telefónica)
• Puerto de red BNC
• Puerto de red DB15

7) Puertos de sonido: permiten la conexión de sistemas de sonido como

bocinas, amplificadores, etc.

• Puerto Jack 3.5"

(Los puertos lógicos de la computadora)
Al conectar un equipo a la red, este forma parte de la misma, y con ello adquiere
necesidades de comunicación con Switches, Servidores, otras computadoras, etc.
por lo que se asigna un identificador electrónico denominado IP (Internet Protocol),
que consiste en su versión IPv4, de 4 bloques de máximo 4 dígitos, como ejemplo
192.168.108.32, con lo cual se presenta e identifica con el equipo destino.
En Internet debido a la gran cantidad de servicios que se ofrecen, es necesario
diferenciarlos, por lo que se utilizan los denominados puertos (independientemente
de los puertos físicos de la computadora). Estos son un tipo de puertos lógicos, son
puntos de acceso entre los equipos que les permitirán ó no, transferir información
entre sí. Se han contabilizado hasta 65,000 puertos para las conexiones, siendo
algunos estratégicos para ciertas actividades e incluso críticos.
Estos puertos pueden ser protegidos por medio de Software especializado en ello y
también por medio de Firewall (Corta fuegos: que se encarga de filtrar la información
que circula entre las redes).
 6.2 ELABORACIÒN DE INTERFASES

La interfaz es de dos tipos que ellos son:

Interfaz Paralelo
Una interfaz paralela transfiere datos en la forma de uno o varios bytes en la paralela
a o del dispositivo. Asuma un ordenador 16 bites, direccionable por el byte, donde
la entrada - salida controlada del programa es usada con asincrónico del ducto, y el
cronometraje de transferencias de ducto es unos. Contiene memorias intermedias
de datos separadas para insumo y producción y hay un registro de estado asociado
con cada memoria intermedia.
Interfaz Consecutivo
Una interfaz consecutiva transmite y recibe datos un bit a la vez. Una interfaz
consecutiva contiene el mismo recorrido de control y dirección que la interface
paralela, pero con una adición controla para transferir datos en serie entre registros
y el dispositivo de entrada - salida. Aquí, un chip es usado, que es un barco de
circuito integrado que contiene todo el recorrido lógico para la conversión paralela y
consecutiva requerida. Los dos registros y las banderas de estado son incluidos en
el chip.
Para su realización es:
 Uso inmediato
 Diseño minimalista
 Distinción clara de los elementos
 Atención a las glosas o textos
 Minimizar el uso del teclado y de comandos especiales
 Evitar diálogos innecesarios
 Prevención de errores
 Flexibilidad ante todo
 Manejo de preferencias de usuario
Un buen interfaz:
 Disminuye la resistencia natural del usuario a utilizar la aplicación.
 Reduce los tiempos de aprendizaje.
 Reduce los errores de uso.
 Mejora la percepción pública del software.
 Mejora la calidad de vida de los usuarios (facilita su labor).
 6.3 CONTROL DE INTERFASES A TRAVES DE
COMPUTADORA

Las interfaces de control se podrían así definir como placas multifunción de

E/S (entrada/salida) en configuración externa (es decir, no son placas instalables
en ninguna bahía de expansión del PC), que se conectan con el PC mediante
alguno de los puertos de comunicaciones propios del mismo (paralelo, serie o
USB, generalmente) y sirven de interfaz entre el mismo y los sensores y
actuadores de un sistema de control.

Las interfaces proporcionan, de forma general, una o varias de las siguientes

funciones:

1. entradas analógicas, que convierten niveles analógicos de voltaje o de

corriente en información digital procesable por el ordenador. A este tipo de
entradas se pueden conectar distintos sensores analógicos, como por
ejemplo una LDR.
2. salidas analógicas, que convierten la información digital en corriente o
voltaje analógicos de forma que el ordenador pueda controlar sucesos del
"mundo real". Su principal misión es la de excitar distintos actuadores del
equipamiento de control: válvulas, motores, servomecanismos, etc.
3. entradas y salidas digitales, usadas en aplicaciones donde el sistema de
control sólo necesita discriminar el estado de una magnitud digital (por
ejemplo, un sensor de contacto) y decidir la actuación o no de un elemento
en un determinado proceso, por ejemplo, la activación/desactivación de una
electroválvula.
4. recuento y temporización, algunas tarjetas incluyen este tipo de circuitos
que resultan útiles en el recuento de sucesos, la medida de frecuencia y
amplitud de pulsos, la generación de señales y pulsos de onda cuadrada, y
para la captación de señales en el momento preciso.

Algunas de las interfaces de control más avanzadas cuentan, además de con la

electrónica precisa para el acondicionamiento y la conversión de las señales, con
sus propios microprocesador y memoria. Así, con capaces hasta de almacenar
pequeños programas de control transmitidos desde un PC que luego pueden
ejecutar independientemente de su conexión a éste.
 CONCLUSIÓN
El mundo que nos rodea está en constante cambio y cada vez es más moderno y
eficiente en el campo informático. Por la misma razón, algunos conectores y puertos
están obsoletos, como en el caso de Din, DVI, que solo se encuentra en dispositivos
más antiguos. Un conector se utiliza generalmente para diferentes conexiones, p.
B. Audio, videocámaras, controladores de juegos, computadoras en red,
impresoras, teclados, video digital, etc. Puedo señalar que actualmente el USB es
uno de los más utilizados, el cual ha reemplazado a varios conectores como Din,
MiniDin, serial. Cada conector y puerto se caracteriza por su forma y número de
pines, además su velocidad varía según el dispositivo y el uso que se le dé.

Hasta aquí se ha visto que los lenguajes de programación son un simbolismo que
nos permite expresar la solución de nuestros problemas en operaciones básicas
(instrucciones).
La computadora ejecuta las instrucciones que hemos dado antes en forma de
programa. Sin embargo, los programas escritos en este lenguaje en particular deben
traducirse a un lenguaje de máquina que la computadora pueda entender
directamente.
Hay muchos idiomas predefinidos y se han escrito traductores; las reglas (sintaxis)
y palabras utilizadas por cada uno son definidas por organismos internacionales,
otras por el constructor.
 INSTITUTO TEGNOLOGICO SUPERIOR DE
SAN ANDRES TUXTLA

MATERIA: INTRODUCCION A LA PROGRAMACIÒN

UNIDAD VI (EJEMPLO DE CODIGO)

6.1 PROGRAMACIÒN DE PUERTOS DE LA COMPUTADORA

6.2 ELABORACIÒN DE INTERFASES

6.3 CONTROL DE INTERFASES A TRAVES DE

COMPUTADORA

DOCENTE: SERGIO PELAYO VAQUERO

ALUMN@: JOSELYN CHIPOL SINACA

CARRERA: INGENIERIA ELECTROMECANICA

SEMESTRE: PRIMER SEMESTRE

GRUPO:102 B

FECHA DE ENTREGA: 09 DE ENERO, 2023

PERIODO ESCOLAR: SEPTIEMBRE – ENERO 2023

SAN ANDRES TUXTLA, VER.

 EJEMPLO DE CODIO DE ARDUINO DE SEGUIDOR DE LINEA

//Código desarrollado por LEANTEC ROBOTICS&ELECTRONICS

//Esta permitido el uso de este código por cualquier usuario que lo necesite.
//Esta prohibido el usode este código con ánimo de lucro.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////
//
//
// CALIBRAR EL ROBOT DETRO DE LA LÍNEA NEGRA (ENCENDER DENTRO DE LA LÍNEA)
//
//
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////

// Incluimos la librería de los motores

#include <LEANTEC_ControlMotor.h>
// Configuramos los pines que vamos a usar
ControlMotor control(2,3,7,4,5,6); // MotorDer1,MotorDer2,MotorIzq1,MotorIzq2,PWM_Derecho,PWM_Izquierdo

#define PIN_LDR1 2 // Define el pin analog de LDR 1

#define PIN_LDR2 3 // Define el pin analog de LDR 2
#define PIN_FL1 0 // Define el pin analog de IR 1 (Este sensor no se usa en este programa)
#define PIN_FL2 1 // Define el pin analog de IR 2 (Este sensor no se usa en este programa)
#define P_MUERTO 10 // Valor que tendrá que superar el cambio de luz para que gire el robot +/- P_MUERTO

#define GIRO_LINEA 50 // Máximo giró que realizará el sensor (entre 0 y 100), 100 sería parado girando sobre su eje
#define GIRO_FUERA 100 // Giro que hace el robot cuando se sale de la línea

#define VELOCIDAD_NORMAL 255 // Velocidad a la que se desplazará el robot dentro de la línea

#define VELOCIDAD_BAJA 200 // Velocidad a la que se desplaza el robot cuando sale un sensor fuera de la línea
#define VELOCIDAD_BAJA_GIRO 150 // Velocidad a la que gira el robot para localizar la línea cuando se ha salido los
dos sensores

int OFFSET_LDR1 = 0; // (Este sensor no se usa en este programa)

int OFFSET_LDR2 = 0; // (Este sensor no se usa en este programa)
int OFFSET_FL1 = 0; // Ajusto el punto central del sensor para que los dos estén iguales (en este caso, se ajusta
solo al iniciar el robot
int OFFSET_FL2 = 0; // Ajusto el punto central del sensor para que los dos estén iguales (en este caso, se ajusta
solo al iniciar el robot

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////
// Estos valores de abajo no es necesario cambiarlos
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////
int sensores[4]; // Array donde se guardarán los valores
int valor_neutro=0; // Este valor se entiende que es el valor en negro, por lo que se debe calibrar en negro.
int velocidad=255; // Velocidad a la que se desplaza el robot
int direccion_anterior=0; // Recuerda que sensor se salío de la línea para girar en el sentido correcto y localizar
la línea de nuevo

#define LDR1 0 // Define la posición en el ARRAY donde se guardará el valor de la LDR 1 (Este sensor no se usa en
este programa)
#define LDR2 1 // Define la posición en el ARRAY donde se guardará el valor de la LDR 2 (Este sensor no se usa en
este programa)
#define FL1 2 // Define la posición en el ARRAY donde se guardará el valor de la IR 1
#define FL2 3 // Define la posición en el ARRAY donde se guardará el valor de la IR 2
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////

void leer_sensores();
int calcula_diferencia();
void mostrar_valores();

//----------------------------- Configuramos Ardunio ---------------------------------------

//------------------------------------------------------------------------------------------
void setup(void){
// Iniciamos el puerto de comunicación
Serial.begin(9600);

//********************************* Calibramos los sensores ****************************************************/ /

leer_sensores(); // Leemos sensores con los OFFSET a 0
if(sensores[FL1] > sensores[FL2]){ // Comprobamos si FL1 es mayor que FL2
 OFFSET_FL1 = 0; // Como FL1 es mayor, sumamos a FL2
OFFSET_FL2 = sensores[FL1]-sensores[FL2]; // Sumamos a FL2 la diferencia para que esten igualadas las dos
}
else{ // Si hemos llegado aquí, es porque LDR2 o igual que FL1
OFFSET_FL2 = 0; // Como FL2 es mayor, sumamos a FL1
OFFSET_FL1 = sensores[FL2]-sensores[FL1]; // Sumamos a FL1 la diferencia para que esten igualadas las dos
}
//**************************************************************************************************************/ /
valor_neutro= sensores[FL1]; // Almacenamos unos de los sensores (Ambos son iguales en este punto) como
valor_neutro.
// Si ambos sensores sobrepasan este valor + P_MUERTO, se entiende que el robot esta
fuera de línea por completo
}
//--------------------------- Arrancamos el programa ---------------------------------------
//------------------------------------------------------------------------------------------
void loop(void)
{
leer_sensores(); // Leemos los sensores con los OFFSET ya calculados
//mostrar_valores(); // Mostramos los valores por si tenemos que comprobar algún dato
control.Motor(velocidad,calcula_diferencia()); // Movemos el robot a la velocidad seleccionada y el giro calculado
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////
// Mostramos los valores por el monitor
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////
void mostrar_valores(){
Serial.print(" OFF_1 = " ); // Imprimimos el OFFSET del FL1
Serial.print(OFFSET_FL1);
Serial.print(" OFF_2 = " ); // Imprimimos el OFFSET del FL2
Serial.print(OFFSET_FL2);
Serial.print(" FL_1 = " ); // Imprimimos el valor del FL1
Serial.print(sensores[FL1]);
Serial.print(" FL_2 = " ); // Imprimimos el valor del FL2
Serial.print(sensores[FL2]);
Serial.print(" DIF = " ); // Imprimimos la diferencia entre el sensor 1 y el sensor 2
Serial.println(calcula_diferencia());
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////
// Leemos los sensores y ajustamos los OFFSET
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////
void leer_sensores(){
sensores[LDR1]=analogRead(PIN_LDR1)+OFFSET_LDR1; // Leemos y guardamos el valor del sensor con el OFFSET
incluido
if(sensores[LDR1]<0){sensores[LDR1] = 0;} // Comprobamos que con el OFFSET no sea menor de 0
 else if(sensores[LDR1] > 1023){sensores[LDR1] = 1023;} // Comprobamos que con el OFFSET no sea mayor de 0

sensores[LDR2]=analogRead(PIN_LDR2)+OFFSET_LDR2; // Leemos y guardamos el valor del sensor con el OFFSET

incluido
if(sensores[LDR2]<0){sensores[LDR2] = 0;} // Comprobamos que con el OFFSET no sea menor de 0
else if(sensores[LDR2] > 1023){sensores[LDR2] = 1023;} // Comprobamos que con el OFFSET no sea mayor de 0

sensores[FL1]=analogRead(PIN_FL1)+OFFSET_FL1; // Leemos y guardamos el valor del sensor con el OFFSET

incluido
if(sensores[FL1]<0){sensores[FL1] = 0;} // Comprobamos que con el OFFSET no sea menor de 0
else if(sensores[FL1] > 1023){sensores[FL1] = 1023;} // Comprobamos que con el OFFSET no sea mayor de 0

sensores[FL2]=analogRead(PIN_FL2)+OFFSET_FL2; // Leemos y guardamos el valor del sensor con el OFFSET

incluido
if(sensores[FL2]<0){sensores[FL2] = 0;} // Comprobamos que con el OFFSET no sea menor de 0
else if(sensores[FL2] > 1023){sensores[FL2] = 1023;} // Comprobamos que con el OFFSET no sea mayor de 0
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////
// Calculamos la diferencia que hay de un sensor a otro
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////
int calcula_diferencia(){
int valor; // En esta variable almacenamos el valor positivo o negativo del resultado de la función

if((sensores[FL1] > valor_neutro + P_MUERTO)&&(sensores[FL2] > valor_neutro + P_MUERTO)){

 if(direccion_anterior==0){valor=100;}
else{valor=-100;}
velocidad = VELOCIDAD_BAJA_GIRO;
}
else{
valor = sensores[FL2]-sensores[FL1]; // Restamos el valor de la FL 2 al valor de la FL 1, la dirección se calcula
viendo si el valor es positivo o negativo.

if((valor > P_MUERTO) || (valor < -P_MUERTO)){// Si el valor cambia por encima de P_MUERTO el robot cambiará de
posición según la diferencia de un sensor a otros
velocidad = VELOCIDAD_BAJA;
if (valor > 0) {valor= GIRO_LINEA;direccion_anterior=0;} // Giramos a la derecha para entrar de nuevo en la
línea
if(valor < 0){valor = -GIRO_LINEA;direccion_anterior=1;} // Giramos a la izquierda para entrar de nuevo en la
línea
}
else { // Si el cambio es menor al punto muerto, el robot no gira
valor = 0; // Dejamos que el robot sigua recto
velocidad = VELOCIDAD_NORMAL; // El robot avanza a esta velocidad dentro de la línea
}
}

return valor; // Devolvemos el valor

}
 INSTITUTO TEGNOLOGICO SUPERIOR DE
SAN ANDRES TUXTLA

MATERIA: INTRODUCCION A LA PROGRAMACIÒN

UNIDAD VI (IMPORTANCIA DE LA PROGRAMACIÒN DE

PUERTOS Y CONTROL EN LA INTERFAZ EN ING.
ELECTROMECANICA)

DOCENTE: SERGIO PELAYO VAQUERO

ALUMN@: JOSELYN CHIPOL SINACA

CARRERA: INGENIERIA ELECTROMECANICA

SEMESTRE: PRIMER SEMESTRE

GRUPO:102 B

FECHA DE ENTREGA: 09 DE ENERO, 2023

PERIODO ESCOLAR: SEPTIEMBRE – ENERO 2023

SAN ANDRES TUXTLA, VER.

 IMPORTANCIA EN LA PROGRAMACIÓN DE PUERTOS Y
CONTROL ….
Los puertos de comunicación en las PC son de particular interés para los futuros
ingenieros en electromecánica, ya que permiten que las computadoras personales
se utilicen para controlar todo tipo de circuitos electrónicos utilizados principalmente
en actividades de automatización de procesos, adquisición de datos, tareas
repetitivas, etc. que requieren precisión.

Además, aporta al perfil del Ingeniero Electromecánico la capacidad para desarrollar

aplicaciones de software, la sensibilidad y conocimientos para hacer uso eficiente
de las herramientas de programación de alto nivel.

Es un soporte a otras, más directamente vinculadas con desempeños profesionales;

se inserta en la primera mitad de la trayectoria escolar; antes de cursar aquéllas a
las que da soporte. De manera particular, lo trabajado en esta se aplica en el estudio
de los temas: introducción a la programación por computadora, el lenguaje y su
entorno integrado de desarrollo, programación en software de aplicación y
programación de interfaz.

Y lo es necesario con el paso de los años se incrementan las posibilidades de

adquirir nuevos conocimientos en cada tipo de ingeniería y es por eso que, dentro
de la programación en puertos, control y la interfaz que consiste en variables de
instrucciones, según diferentes lenguajes formatos y equipo, ejecutadas por una
computadora para la solución rápida exacta y controlada de un problema
identificado para lograr los objetivos prefijados.