Fundamentos de Informatica

Fundamentos de Informática
Tabla de Contenidos
1. GESTIONA EL HARDWARE Y SOFTWARE DE UNA COMPUTADORA ....................................... 5
DETERMINAR LOS PERIFÉRICOS INTERNOS Y EXTERNOS DE UNA PC ............................................................ 6

1.1. INSTALACIÓN DE SOFTWARE DE DIAGNÓSTICO ..................................................................................... 6
1.2. DETERMINANDO LAS CARACTERÍSTICAS DEL HARDWARE DE UNA COMPUTADORA ..................................... 8
1.3. GENERANDO REPORTES DEL EQUIPO ............................................................................................... 12
1.4. DETERMINANDO LAS CARACTERÍSTICAS DEL FABRICANTE DEL PRODUCTO ............................................... 13
ADMINISTRA EL HARDWARE DE UNA COMPUTADORA.......................................................................... 16
1.5. ADMINISTRA LAS PARTICIONES Y DISCOS DUROS DEL EQUIPO ............................................................... 16
ADMINISTRA EL SOFTWARE DE UNA COMPUTADORA .......................................................................... 18
1.6. INSTALACIÓN DEL SISTEMA OPERATIVO WINDOWS............................................................................ 18
FUNDAMENTO TEÓRICO ............................................................................................................... 24
PROCESAMIENTO DE DATOS ..................................................................................................................... 24
ANTECEDENTES HISTÓRICOS..................................................................................................................... 25
HARDWARE .......................................................................................................................................... 31
ARQUITECTURA DE UN COMPUTADOR ....................................................................................................... 31
MAINBOARD ......................................................................................................................................... 35
MEMORIA PRINCIPAL ............................................................................................................................. 36
MEMORIA AUXILIAR ............................................................................................................................... 37
PERIFÉRICOS ......................................................................................................................................... 40
PROCESO DE ARRANQUE DE UNA COMPUTADORA ....................................................................................... 41
SISTEMA OPERATIVO .............................................................................................................................. 44
MICROSOFT WINDOWS .......................................................................................................................... 44
APLICACIONES DE WINDOWS ................................................................................................................... 47
NÚCLEO DEL SISTEMA ............................................................................................................................. 48
LENGUAJE DE PROGRAMACIÓN ................................................................................................................. 48
PROGRAMA .......................................................................................................................................... 50
2. MANEJO DE LAS TIC......................................................................................................... 52
DETERMINA LOS ELEMENTOS, TIPOS, TOPOLOGÍA Y CONFIGURACIÓN DE UNA RED DE COMPUTADORAS ........... 53
2.1. CONFIGURAR NOMBRE DEL EQUIPO Y GRUPO DE TRABAJO ................................................................. 53
2.2. CONFIGURAR LA CONEXIÓN DEL ÁREA LOCAL ................................................................................... 55
ADMINISTRA INFORMACIÓN Y SERVICIOS DE INTERNET ......................................................................... 60
2.3. COMPARTE INFORMACIÓN EN UNA RED DE ÁREA LOCAL ..................................................................... 60
PUBLICA ARTÍCULOS EN EL INTERNET Y EMPLEA PROGRAMAS DE GESTIÓN DE ARCHIVOS. .............................. 62
2.4. CÓMO CREAR UN BLOG EN WORDPRESS.COM .................................................................................. 62
FUNDAMENTO TEÓRICO ......................................................................................................... 68
REDES DE COMPUTADORAS ..................................................................................................................... 68
TIPOS DE REDES ..................................................................................................................................... 68
COMPONENTES BÁSICOS DE UNA RED........................................................................................................ 68
MODELO SE REFERENCIA OSI .................................................................................................................. 70
MODELO SE REFERENCIA TCP-IP ............................................................................................................. 72
TOPOLOGÍA DE REDES ............................................................................................................................. 73
DIRECCIONAMIENTO IP ........................................................................................................................... 74
SERVICIOS EN INTERNET .......................................................................................................................... 80
Programa Nacional de Informática 1

3. REPRESENTACIÓN DE UN PROBLEMA EMPLEANDO ALGORITMOS ..................................... 88
REPRESENTACIÓN DE PROBLEMAS CON ALGORITMOS. ........................................................................ 89

3.1 OBTENER EL PROMEDIO DE DOS NÚMEROS ENTEROS .......................................................................... 89
3.2 MOSTRAR EL RESULTADO DE UN EXAMEN.......................................................................................... 91
3.3. CALCULAR LA CAPACIDAD DE UN DOCUMENTO .................................................................................. 93
SOLUCIÓN DE PROBLEMAS CON ALGORITMOS. .................................................................................. 95
3.4. CALCULAR LA CANTIDAD DE DISCOS NECESARIOS PARA GUARDAR UN DOCUMENTO ................................. 95
3.5. AVERIGUAR SI EL USUARIO DEL PROGRAMA ES MAYOR DE EDAD ........................................................... 97
3.6. DETERMINAR LA EDAD DEL MAYOR ................................................................................................. 99
3.7. DETERMINAR LAS HORAS EXTRAS TRABAJADAS POR UNA PERSONA ..................................................... 102
RESUELVE PROBLEMAS EMPLEANDO LÓGICA SECUENCIAL. ................................................................... 106
3.8. MOSTRAR EL RESULTADO DEL INCREMENTO DE LOS N PRIMEROS NÚMEROS ........................................ 106
3.9. ESCOGER UNA OPCIÓN Y EJECUTAR UNA PARTE DEL PROGRAMA ......................................................... 109
FUNDAMENTO TEÓRICO ....................................................................................................... 112
CONCEPTO DE ALGORITMO .................................................................................................................... 112
RESOLUCIÓN DE PROBLEMAS Y USO DE ALGORITMOS ................................................................................. 113
ANÁLISIS DEL PROBLEMA ....................................................................................................................... 113
DISEÑO DEL ALGORITMO ....................................................................................................................... 114
PROGRAMACIÓN DEL ALGORITMO .......................................................................................................... 115
REPRESENTACIÓN DE ALGORITMOS ........................................................................................................ 116
PSEUDOCÓDIGO .................................................................................................................................. 117
ORGANIGRAMAS.................................................................................................................................. 117
ESTRUCTURAS DE CONTROL ................................................................................................................... 119
ESTRUCTURAS SECUENCIALES................................................................................................................. 119
ESTRUCTURAS SELECTIVAS ..................................................................................................................... 120
ESTRUCTURAS REPETITIVAS ................................................................................................................... 121
REPRESENTANDO UN PROBLEMA CON ALGORITMOS .................................................................................. 121
4. SOLUCIONA PROBLEMAS EMPLEANDO LENGUAJES DE PROGRAMACIÓN ....................... 125
RESUELVE PROBLEMAS EMPLEANDO OPERADORES MATEMÁTICOS. ........................................................ 126

4.1 OBTENER EL PROMEDIO DE DOS NÚMEROS ENTEROS ........................................................................ 126
4.2 CALCULAR EL ÁREA DE UN TRIANGULO ............................................................................................ 128
4.3. CALCULAR EL RESULTADO DE UN EXAMEN ...................................................................................... 129
RESUELVE PROBLEMAS EMPLEANDO INSTRUCCIONES CONDICIONALES .................................................... 131
4.4. CALCULAR LA MAYORÍA DE EDAD DEL USUARIO ............................................................................... 131
4.5. CALCULAR LAS HORAS EXTRAS ACUMULADAS POR UN TRABAJADOR .................................................... 133
RESUELVE PROBLEMAS EMPLEANDO CONDICIONES MÚLTIPLES ............................................................. 135
4.6. DETERMINAR AL MAYOR DE DOS NÚMEROS .................................................................................... 135
4.7. SELECCIONANDO OPCIONES ......................................................................................................... 137
MICROSOFT. NET FRAMEWORK ............................................................................................................. 139
LENGUAJE DE PROGRAMACIÓN VISUAL BASIC.NET .................................................................................... 141
ESTRUCTURA DE UN PROGRAMA VB.NET ................................................................................................ 142
VARIABLES .......................................................................................................................................... 143
CREACIÓN DE UN PROYECTO DE CONSOLA DE APLICACIÓN........................................................................... 149
LA CLASE CONSOLE............................................................................................................................... 150
CONCATENACIÓN. ................................................................................................................................ 152
OPERADORES DEL LENGUAJE .................................................................................................................. 153

OPERADORES ARITMÉTICOS ................................................................................................................... 153

OPERADORES ABREVIADOS DE ASIGNACIÓN .............................................................................................. 154
OPERADORES DE COMPARACIÓN ............................................................................................................ 156
LA FUNCIÓN ASC( ) .............................................................................................................................. 156
LA FUNCIÓN CHR( ) .............................................................................................................................. 156
OPERADORES LÓGICOS Y A NIVEL DE BIT................................................................................................... 157
ESTRUCTURAS DE SELECCIÓN ................................................................................................................ 160
ESTRUCTURA DE CONTROL IF ................................................................................................................. 160
ESTRUCTURA DE CONTROL CASE ............................................................................................................. 162
5. REALIZA PROGRAMACIÓN ESTRUCTURADA .................................................................... 164
RESUELVE PROBLEMAS EMPLEANDO CONDICIONES REPETITIVAS. .......................................................... 165

5.1. MOSTRAR LA SUMATORIA DE LOS PRIMEROS NÚMEROS.................................................................... 165
5.2. INGRESANDO VARIOS REGISTROS SIMULTÁNEAMENTE ...................................................................... 167
RESUELVE PROBLEMAS EMPLEANDO ESTRUCTURAS REPETITIVAS. ......................................................... 169
5.3. TRABAJANDO CON REGISTROS ...................................................................................................... 169
DESARROLLA PROGRAMAS CON ARREGLOS .................................................................................... 172
5.4. ARREGLO UNIDIMENSIONAL........................................................................................................ 172
5.5. TRABAJANDO CON ARREGLOS ...................................................................................................... 174
5.6. TRABAJANDO CON PROCEDIMIENTOS ............................................................................................ 176
5.7. PASO DE PARÁMETROS A PROCEDIMIENTOS .................................................................................... 178
ESTRUCTURAS DE REPETICIÓN................................................................................................................ 179
ESTRUCTURA DE CONTROL WHILE ........................................................................................................... 179
ESTRUCTURA DE CONTROL DO ............................................................................................................... 180
ESTRUCTURA DE CONTROL FOR .............................................................................................................. 182
ARRAYS .............................................................................................................................................. 183
RUTINAS DE CÓDIGO............................................................................................................................. 184
PROCEDIMIENTOS ................................................................................................................................ 184
PROCEDIMIENTO SUB ........................................................................................................................... 185
LLAMADA A UN PROCEDIMIENTO SUB...................................................................................................... 186
PROCEDIMIENTO FUNCTION .................................................................................................................. 187
LLAMADA A UN PROCEDIMIENTO FUNCTION ............................................................................................. 188
PASO DE PARÁMETROS A PROCEDIMIENTOS .............................................................................................. 189
6. REALIZA PROGRAMAS DE APLICACIÓN............................................................................ 192
DESARROLLA PROYECTOS DE APLICACIÓN EN WINDOWS .................................................................... 193

6.1. PROMEDIANDO NÚMEROS........................................................................................................... 193
6.2. CONCATENANDO CARACTERES ..................................................................................................... 195
6.3. SELECCIONANDO OPCIONES......................................................................................................... 197
6.4. TRABAJANDO CON ARREGLOS ...................................................................................................... 199
6.5. TRABAJANDO CON CLUSTERS ....................................................................................................... 202
6.6. GRÁFICANDO UN CLUSTER........................................................................................................... 204
CREACIÓN DE FORMULARIOS E INTERFACES DE USUARIO EN WINDOWS .................................................. 206
6.7. CONTROLANDO LA TEMPERATURA ................................................................................................ 206
6.8. CONTROL DE NIVEL PARA UN TANQUE ........................................................................................... 208
6.9. CONVIRTIENDO TEMPERATURA..................................................................................................... 212
6.10. EDITOR DE TEXTO..................................................................................................................... 215

6.11. CREANDO UN SUB VI................................................................................................................ 218

6.12. TRABAJANDO CON UN SUB VI .................................................................................................... 222
INSTRUMENTACIÓN VIRTUAL .................................................................................................................. 225
LABVIEW........................................................................................................................................... 225
PANEL FRONTAL................................................................................................................................... 227
DIAGRAMA DE BLOQUES ....................................................................................................................... 227
BARRA DE HERRAMIENTAS ..................................................................................................................... 228
CONTROLES E INDICADORES DEL PANEL FRONTAL ....................................................................................... 228
CONTROLES NUMÉRICOS ....................................................................................................................... 229
CONTROLES BOOLEANOS ....................................................................................................................... 229
CONTROLES DE CADENA DE CARACTERES .................................................................................................. 231
ARRAYS .............................................................................................................................................. 231
CLUSTERS ........................................................................................................................................... 232
INDICADORES GRÁFICOS ........................................................................................................................ 232
ESTRUCTURAS Y ELEMENTOS DE PROGRAMACIÓN ...................................................................................... 233
ESTRUCTURA WHILE ........................................................................................................................... 233
ESTRUCTURA FOR ............................................................................................................................... 235
ESTRUCTURA CASE .............................................................................................................................. 235
SECUENCIAS ........................................................................................................................................ 236
CUADROS DE FORMULA ........................................................................................................................ 237
CREACIÓN DE UN PROGRAMA EN LABVIEW ............................................................................................. 238

TAREA
1. Gestiona el Hardware y
software de una
Computadora
En esta tarea el participante conocerá los elementos que forman una
computadora personal PC y la función que cada uno de ellos tiene,
instalará un Sistema Operativo para administrar los recursos del
hardware del computador e instalará software de diagnostico y
aplicación
El mundo de hoy, está inmerso en una nueva revolución

tecnológica basada en la informática, que encuentra su
principal impulso en el acceso y en la capacidad de
procesamiento de información sobre todos los temas y sectores
de la actividad humana. El conjunto de tecnologías que se
concentran alrededor de las computadoras personales, de las
tecnologías de la información y de la comunicación, es sin duda
la innovación que más ha influido en el desarrollo de la vida
social.
Esta última década ha sido extraordinariamente rica en

avances técnicos y científicos, se ha visto el crecimiento en
otras tecnologías decisivas, como la electrónica, los medios
audiovisuales y ha culminado con la implantación de estas
nuevas tecnologías, que han revolucionado el uso y la
manipulación de la información y se han constituido, a la vez,
en vehículos de comunicación

Equipos y Materiales:
 Computador Pentium 4 o superior
 Sistema operativo Windows XP o superior
 Software de Diagnostico Everest Home Editión
Orden de Ejecución:
 Instalación de los diferentes equipos a nivel físico

 Instalación del Software de Diagnostico Everest Home Editión
Determinar los periféricos internos y externos de una

PC
1.1. Instalación de software de diagnóstico.

El Programa Everest Home Editión permitirá identificar las diferentes
características del Hardware de la computadora, entre ellos Memoria,
Mainboard, disco Duro, etc. Antes de mostrar sus características realizaremos
su instalación siguiendo estos pasos:
Primero instalaremos el programa Everest home Edition en el computador,
este programa es un freeware (software de distribución libre), ofrece uno de
los diagnósticos más preciso, después de descargar el programa procedemos
a guardarlo en una carpeta por ejemplo: Everest, el archivo descargado tiene
por nombre everesthome220.exe. Le damos doble clic y continuamos con el
proceso de instalación seleccionamos el idioma para la instalación, de
preferencia el idioma español
Luego se nos presenta la ventana de descripción del programa indicando la

versión a instalarse, presionamos el botón siguiente

En la siguiente ventana el fabricante del software presenta los términos y

alcances de su aplicación en una licencia de usuario, para continuar con la
instalación debemos aceptar el acuerdo y luego presionar el botón siguiente
A continuación el asistente de instalación nos muestra la ruta en la que se

instalará el programa y sus archivos, debemos mantener esta opción y
presionar el botón siguiente
Como paso siguiente seleccionar si queremos que el programa tenga un

ícono en el escritorio y si tendrá un acceso directo en los programas de inicio

Finalmente se producirá el proceso de descarga de archivos al computador y

después de unos instantes el Everest quedara instalado.
1.2. Determinando las características del Hardware

de una computadora
Una vez instalado el programa, lo ejecutamos, aparecerá una ventana de
exploración del hardware, en ella obtendremos directamente información
acerca de la tarjeta Madre, el microprocesador, la BIOS, el Chipset, la
configuración AGP, Memoria RAM y dispositivos de almacenamiento. Para ello
ejecutamos la opción: Menú/ Everest Vx.xx/ Computadora/ Resumen

A continuación veremos otras opciones del programa:
CPU detalla las características del Microprocesador como Reloj del CPU,
Velocidad de Bus, Capacidad de la memoria Cache debemos seleccionar
la Opción: Motherboard/ CPU
Motherboard muestra las características del fabricante, Propiedades de

Bus, Propiedades de Bus de Memoria, como Reloj del CPU, seleccionar
la Opción: Motherboard/ Motherboard

Chipset las características del Puente Porte, controlador de Memoria, etc.

seleccionar la Opción: Motherboard/ chipset
Monitor detalla la información del adaptador de video, drivers de video,

monitor, número de serie, modos de video que soporta y la lista de
características de direct3D se encuentran en la opción: Monitor/ Video de
Windows.
La opción almacenamiento, muestra la información de los discos duros

unidades de disco ópticas instaladas, incluyendo las características de
auto detección IDE, monitores del estado S.M.A.R.T. del disco e

información de las particiones: Monitor/ Video de Windows, podemos

ubicar esta opción en Almacenamiento/ almacenamiento de Windows
Red, Multimedia, dispositivos de Hardware muestra la información de

los adaptadores de red, detección de la dirección MAC, lista de
direcciones IP, DNS, lista de direcciones IP teclado, mouse, controladores
de juego,
Monitoreo de Hardware Muestra la información acerca de los sensores

del sistema, temperatura del CPU, GPU, estado del cooler, monitoreo
continuo de los voltajes del CPU; GPU, AGP, DRAM, soporte para los
módulos de memoria

1.3. Generando Reportes del Equipo

El Generador de reportes es un método fácil de usar, capaz de producir
documentos de reporte del sistema, para ser usados como perfiles de pre-
configuración o selección personalizada de información.
Existen tres tipos de archivos de reporte: texto plano, HTML personalizable y

MHTML que incluye iconos que son ideales para propósitos de impresión,
además pueden generarse reportes electrónicos de impresión que pueden
enviarse vía correo electrónico, usando el protocolo SMTP, también soporta
MAPI y protocolos de Outlook, estos pueden enviarse con un solo clic usando
tecnología de internet Explorer 4.0 o superior, a continuación vamos a generar
un modelo de reporte de tipo MHTML con es asistente, seguiremos los
siguientes pasos:
Primero seleccionaremos la opción Informe / asistente de Informes ubicada en
la barra de menú

Luego escogeremos la opción: Solamente resumen del sistema luego

presionamos el botón de siguiente
Ahora seleccionaremos uno de los tipos de informe disponible
Finalmente tendremos el reporte del resumen del sistema, el cual puede ser
impreso o enviado por correo electrónico.
1.4. Determinando las características del

fabricante del producto
En ocasiones es importante saber las características de la computadora del
mismo fabricante del producto, por ejemplo para aumentar la memoria RAM
instalada, cambiar de procesador, etc. En los pasos siguientes detallaremos
como determinar las características para una computadora con una
Mainboard Intel DG41RQ:

Escribimos el comando DXDIAG en la ventana de ejecutar programas
Con los datos del fabricante y modelo de Mainboard, buscaremos en

Google, el navegador nos indicará una la lista de sitios encontrados, entre
ellos el fabricante del producto www.intel.com
En la Página Web del fabricante podemos encontrar las características

principales del equipo.

Ingresaremos al link con las especificaciones del chipset.
En la ventana del Chipset, seleccionar la opción de Diagramas del Sistema,

el diagrama que observamos indica todas las características técnicas del
equipo, en la ventana de Chipset estas características se muestran en
detalle indicando la compatibilidad del Mainboard con diferentes
tecnologías.

Administra el Hardware de una computadora
1.5. Administra las particiones y discos duros del

equipo
En esta actividad el participante aprenderá a usar la herramienta Administrador

de equipos para gestionar los discos, administrar las particiones, renombrarlas
y cambiar su capacidad, para ello seguiremos los siguientes pasos
Seleccionamos el botón de inicio, seleccionamos de las propiedades del equipo

la opción administrar
Se abrirá el programa de administración de equipos, para ver el estado del los

discos y particiones escoger la opción de administración de discos.
Podemos observar la relación de discos y unidades instaladas

Para formatear una unidad haremos clic sobre ella y seleccionaremos la opción
de formatear
Para cambiar el tamaño de un disco podemos usar las opciones de reducir,

extender volumen
Después de hacer clic en la opción de reducir espacio veremos un cuadro

consultando el espacio del disco. Luego aparece por defecto la cantidad de
espacio que deseamos particionar, como se muestra en la imagen, el
espacio que podemos editar para elegir nuestra partición nueva, esa la vamos
a cambiar.

Para eliminar una unidad podemos emplear la opción de eliminar volumen
Administra el Software de una computadora
1.6. Instalación del Sistema Operativo Windows

Antes de instalar Windows 7 si lo vas a instalar en un computadora que tiene
Windows XP o Windows Vista debes de respaldar toda tu información
preferentemente en una unidad externa o grabarla en DVD’s o CD’s, es muy
importante que tengas en cuenta que se van borrar todos los programas,
documentos, imágenes, música, videos, etc., que tengas en tu computadora,
por lo que seré necesario que copies todos esos archivos a un disco duro
externo para que no los pierdas en el proceso, en cuanto a los programas
tendrás que reinstalarlos
Los requerimientos mínimos para instalar Windows 7 son:
 Procesador a 1 GHz de 32-bits (x86) o 64-bits (x64)

 1 GB de memoria RAM si es de (32-bits) / y 2 GB RAM si es de (64-bits)

 16 GB de espacio disponible en disco duro para (32-bits) / o 20 GB para

(64-bits)
 Tarjeta de video que soporte DirectX 9
Enciende tu computadora e introduce el DVD de instalación de Windows 7,

cuando aparezca en la pantalla un mensaje que diga “presiona cualquier tecla
para arrancar desde la unidad de DVD o CD”
Esperar a que cargue la interfaz de la instalación y cuando haya cargado

preguntará el idioma que deseas instalar, el formato de la hora y la moneda
dependiendo de tu país y el tipo de teclado que tienes y das clic en siguiente.

Después de eso solamente tienes que hacer clic en el botón instalar y el

instalador comenzará a trabajar por sí solo expandiendo los archivos e
instalando Windows .
La computadora se reiniciará después de haber completado el paso 3, pedirá

los datos, como el nombre de usuario y el nombre de la PC.
Continuara con la instalación de archivos.

Ahora tienes que introducir la clave de Windows 7, si te registraste en el sitio

de Microsoft entonces puedes usar el número de serie que te dieron gratis.
Después te pedirá la contraseña de tu usuario, la puedes dejar en blanco para

que no tenga contraseña.

En este paso te pregunta cómo quieres que sea tu configuración de

actualizaciones automáticas.
Finalmente tienes que elegir la zona horaria del lugar donde estás y la fecha.

Terminando esto Windows 7 se iniciará por primera vez y a disfrutarlo.

Fundamento Teórico:
Procesamiento de datos
Procesar los datos, consiste en someterlos a un conjunto de operaciones

tales como selección, ejecución de cálculos, etc. de forma que nos permita
extraer conclusiones de los datos que manipulamos. Por tanto, procesar
información es transformar datos primarios en información organizada,
significativa y útil.
En el concepto de procesar, entran ejemplos tan diversos como la obtención de

las raíces en una ecuación de segundo grado o el control de un cohete en
vuelo, a partir de todos los datos físicos del sistema. Nótese, que el
concepto de procesador es más amplio que el de computador, ya que existen
procesadores que no son computadores: Un termostato a partir del dato de
la temperatura tiene como salida el control del aire acondicionado y nuestro
propio sistema cardiovascular, a partir de los datos sensoriales reacciona
adaptándose a las distintas circunstancias.
De acuerdo con lo anterior, para procesar datos, el computador debe

ser capaz de realizar ciertos tipos de operaciones:
 Entrada de datos: Suministrar información al computador desde su

entorno exterior (ej. pulsar el teclado, o leer un código de barras).
 Salida de datos: Obtener información de un computador. (ej.
Visualizar los resultados en una pantalla o impresora).
 Almacenamiento: Hacer una copia permanente de la información
con el objetivo, que el computador pueda emplearla de nuevo (ej.
copiar en cintas y discos magnéticos).
 Recuperación: Leer de nuevo la información almacenada (en cinta
o discos magnéticos).
 Transmisión: Transferir la información a otro computador a través de una
red de comunicación de datos.
 Recepción: Recibir la información enviada por otro computador.

 Tratamiento: Operaciones sobre datos, tales como la ordenación,

selección, combinación, reclasificación, así como la ejecución de
cálculos, que permita obtener la información deseada.
Antecedentes históricos
En 1982, la revista TIME nombró “hombre del año” a la computadora. La noticia

supuso un impacto cultural importante y oficializó el hecho de que esta
máquina es un personaje más de la historia de la humanidad. Aunque
considerada como un paradigma de la etapa moderna y con sólo 30 años de
verdadera historia (hasta mediados de los años 60 las computadoras eran
caras y para usos muy específicos que sólo las grandes instituciones y
universidades podían permitirse) su empleo, de una u otra forma, ha ocupado y
preocupado a muchas de las cabezas que aportaron a la historia de la ciencia.
El hecho de que nuestro estado actual de avance tecnológico haya permitido
su construcción, no debe ocultar los esfuerzos hechos desde los inicios del
pensamiento científico.
 Ábacos
Creados para satisfacer la necesidad de contar con un elemento mecánico que
ayude a las personas en sus tareas de manipulación numérica, o lo que es lo
mismo una máquina que ejecute algoritmos de forma más o menos automática
es realmente antigua. Todos los historiadores coinciden en citar como
antecedente de lo que hoy llamamos computador al ábaco; instrumento
utilizado para la suma y la resta, desde hace 4000 años. Este consiste en un
conjunto de alambres que llevan ensartados unas cuentas móviles, colocadas
en un marco rectangular cruzado por una barra horizontal que atraviesa los
alambres.
Cada una de las cuentas situadas por encima de la barra horizontal vale cinco,
y cada cuenta situada bajo la barra vale uno. Si comenzamos por la parte de la
derecha y nos vamos moviendo hacia la izquierda, el primer alambre
representa el dígito de las unidades; el segundo, el de las decenas; y
sucesivamente las centenas, los millares, etc. Borramos o ponemos a cero el
ábaco separando todas las cuentas de la barra horizontal. Introducimos los
números moviendo las cuentas correspondientes hacia esa barra, comenzando
por el dígito situado más hacia la
derecha, y moviéndonos hacia la izquierda, este artilugio resulta de especial
interés para ayudar a sumar o restar dos números.

La entrada de datos se hace a través de una persona, que también se encarga

de la ejecución y control del algoritmo de suma o resta correspondiente, la
salida de datos es consecuencia de la observación de las cuentas, por lo que
esta máquina seria un sistema de almacenamiento, que necesita de un experto
humano para procesar información (suma y resta).
 Calculadoras Mecánicas
A medida que las distintas otras ramas científicas se desarrollaron, se puso en
evidencia la necesidad de optimizar la capacidad de cálculo habida cuenta de
lo dificultoso de las operaciones que se tenían que llevar a cabo. Ello hizo que
muchos matemáticos se plantearan el desarrollo de instrumentos que
facilitaran al menos teóricamente esta labor. Así, John Napier, que recordamos
por los logaritmos neperianos, publicó un estudio en 1617 que describía la
utilización de cuentas con una marca especial, para realizar multiplicaciones y
divisiones (la obra matemática de Napier condujo mucho más adelante al
desarrollo de la regla de cálculo, venerable instrumento que durante muchos
años fue para algunos de nosotros la “máquina” primaria para llevar a cabo
cálculos complejos). En 1642, Blaise Pascal inventó la primera “sumadora”
real, parecida a las calculadoras mecánicas que se popularizarían en nuestros
años sesenta. Se trataba de una compleja combinación de ruedas, engranajes
y ventanas a través de las cuales aparecían los números. A finales del siglo
XVII, otro famoso matemático, Gottfried Leibnitz, desarrolló una máquina
parecida, pero más avanzada; podía sumar, restar multiplicar y dividir
mecánicamente, e incluso sacar raíces cuadradas.
A pesar de la ingeniosidad de estos planteamientos mecánicos, hasta 1820 no

se pudo disponer de la tecnología que permitiera la aparición de las primeras

máquinas comerciales capaces de efectuar las cuatro operaciones

matemáticas básicas. En la máquina de Leibnitz, se produce un avance
respecto al ábaco, puesto que el algoritmo esta ya incorporado en la propia
estructura de la máquina y además respecto a la de Pascal supone un
incremento en flexibilidad, pues el usuario puede seleccionar, la operación que
desea llevar a cabo. Sin embargo, en su tiempo no pasaron de ser meras
curiosidades, sin posibilidad de aplicación práctica
 Computadores Electromecánicos
A comienzos del siglo XIX se producen aportaciones, curiosamente ligadas a la
resolución de problemas de naturaleza no numérica. En 1801, Joseph
Jacquard, inventó un telar controlado mediante instrucciones almacenadas
según un código representado en tarjetas perforadas; de esta forma, el
algoritmo que sigue la máquina podrá cambiarse fácilmente para conseguir un
dibujo distinto sobre la tela. La máquina de Jacquard incorporó varios
elementos básicos que constituyen los computadores actuales.
La idea de usar en tarjetas perforadas, para guardar tanto números como
instrucciones datos indujo, en 1835, a Charles Babbage, a inventar un
computador digital matemático de tipo mecánico que recibió el nombre de
máquina analítica. Babbage utilizó las tarjetas perforadas para programar su
máquina, que podía utilizar los resultados de un cálculo como entrada del
siguiente y que era capaz de manejar cálculos repetitivos, que más adelante
llamaremos bucles. Un logro, aun más significativo, de la máquina analítica fue
que, en vez de seguir las instrucciones del programa en la secuencia prefijada,
podía saltar de una a otra (los programadores actuales hablamos de
bifurcaciones condicionales).
Aunque los computadores actuales están basados en muchos de los principios que
Babbageutilizó, en su tiempo no existía ningún procedimiento que pudiera mover su
cada vez más complejo artilugio mecánico. Una vez más, la tecnología no era la
adecuada para el desarrollo teórico propuesto y el trabajo de Babbage se saldó con un
fracaso, sólo mitigado por el apoyo de Ada Lovelace, hija de Lord Byron, considerada
como la primera programadora de la historia y en cuyo honor el lenguaje de
programación ADA lleva su nombre.

El concepto de la tarjeta perforada para almacenar programas y datos llegó a prender,

y Herman Hollerith para procesar el censo de 1890 en EEUU la recuperó con notable
éxito (consiguió un ahorro de tiempo de varios meses) al incorporarla a máquinas
alimentadas eléctrica y no mecánicamente. Hollerith puso las bases de una de las
empresas que más adelante se integraría en la International Business Machines
(IBM).En paralelo, George Boole (1815-1864), el fundador de la teoría de la lógica
matemática, nos legó un álgebra para representar cantidades lógicas e investigó las
operaciones que se pueden realizar con estas variables (álgebra de Boole). La lógica
booleana es la base teórica tanto para el diseño de circuitos electrónicos como para
muchas técnicas de programación, aunque difícilmente, pudo ser Boole consciente de
la trascendencia práctica de su teoría..
 Computadores Electrónicos
La electrónica empieza con la válvula o tubo de vacío (un bulbo de vidrio, donde una
placa de metal calentada por un filamento emite electrones que se desplazan en el
vacío debido a una diferencia de potencial entre el cátodo y el ánodo). El primer
computador digital electrónico utilizaba tubos de vacío y podía realizar una
multiplicación en unos 2,8 milisegundos. Fue desarrollado en 1946 por un equipo de la
Universidad de Pennsylvania. Esta máquina recibió el nombre de ENIAC, (Electronic
Numerical Integrator and Computer) su primera aplicación, a pesar de la finalización
de la guerra, fue el cálculo de las tablas de tiro de la artillería. El ENIAC se
programaba cambiando manualmente los conectores y manipulando conmutadores, lo
que, como podemos imaginar, requería gran cantidad de tiempo, por lo que su uso
casi no traspasó el ámbito académico. De hecho, éstas máquinas no tuvieron ningún
impacto comercial, aunque sentaron claramente las bases del diseño de los
computadores actuales. Cuando en 1947 tiene lugar, en los laboratorios Bell, la
invención del transistor (más pequeño que la válvula, menor consumo y mayor
fiabilidad) se posibilita el paso del computador, de pieza experimental de laboratorio, a
dispositivo con ciertas posibilidades comerciales.
Otro avance tecnológico posterior, los circuitos integrados, permitieron integrar

en un único sustrato de silicio cientos de transistores (actualmente esta
integración es ya del orden de millones, en los llamados chips2), con lo que
quedaron sentadas las bases de los computadores actuales. A pesar de que
quedaban muchos problemas por resolver, a principios de los años sesenta, las
ideas y las tecnologías estaban ya maduras y se trataba de seguir una evolución,
cuyos resultados no han dejado de sorprendernos hasta ahora. El computador es
uno de los elementos claves de la actual revolución científico-industrial y su papel,
en la historia de la humanidad, no será menor que el que jugaron en su día, la
rueda, el motor de explosión o la energía nuclear
 Computadores Industriales
La aplicación del computador en el control de procesos supone un salto

tecnológico enorme que se traduce en la implantación de nuevos sistemas de

control en el entorno Industria y posibilita el desarrollo de la navegación espacial.
Desde el punto de vista de la aplicación de las teorías de control automático el
computador no está limitado a emular el cálculo realizado en los reguladores
analógicos El computador permite la implantación de avanzados algoritmos de
control mucho más complejos como pueden ser el control óptimo o el control
adaptativo. El objetivo en un principio era sustituir y mejorar los reguladores
analógicos, pero este objetivo se fue ampliando dada las capacidades de los
computadores en realizar un control integral de las plantas de fabricación,
englobando también la gestión de la producción.
Las principales aplicaciones industriales del computador son:

 Adquisición de datos. Consiste en la recogida, tratamiento y almacenamiento
de los datos.
 Supervisión. En esta función el computador no efectúa directamente el control
de proceso. Se conecta a los controladores del proceso (autómatas,
reguladores PID…) por medio de un sistema de comunicación serie o por una
red de comunicaciones industrial. La principal función es la ayuda al operador
de planta. El computador suministra al computador unas informaciones
elaboradas como pueden ser alarmas, tratamiento de fallos, procedimientos de
rearme.
 Control secuencial. En esta función el computador suele tomar la forma de
autómata programable, en el cual se ejecutan programas de control de
sistemas secuenciales.
 Control analógico digital. Es una forma de control que se utilizaba con los
primeros computadores en la cual el computador se encargaba de elaborar la
consigna de los bucles analógicos.
 Control digital directo. El computador ejecuta directamente el control del
proceso continuo. Toma la forma de regulador industrial o de computador
industrial con tarjetas de interface con el proceso.
 Análisis de datos. Función clásica de los computadores de gestión en el que
se analizan los datos de producción por medio de herramientas de ofimática.

Las redes de comunicaciones industriales deben su origen a la fundación FieldBus

(Redes de campo). La fundación FieldBus desarrolló un nuevo protocolo de
comunicación para la medición y el control de procesos donde todos los instrumentos
puedan comunicarse en una misma plataforma ( servidores, computadores industriales
y sensores)
Las comunicaciones entre los instrumentos de proceso y el sistema de control se

basan principalmente en señales analógicas (neumáticas de 3 a 15 psi de presión en
las válvulas de control y electrónicas de 4 a 20 mA cc). En vez de transmitir cada
variable por un par de hilos, transmiten secuencialmente las variables por medio de un
cable de comunicaciones llamado bus.
La tecnología fieldbus (bus de campo) es un protocolo de comunicaciones digital de

alta velocidad creada para remplazar la clásica señal de 4-20 mA que aún se utiliza en
muchos de los sistemas DCS (Sistema de Control Distribuido) y PLC (Controladores
Lógicos Programables), instrumentos de medida y transmisión y válvulas de control.
La arquitectura fieldbus conecta estos instrumentos con computadores que se usan en
diferentes niveles de coordinación y dirección de la fábrica. Con la mejora de los
protocolos de comunicación es ahora posible reducir el tiempo necesario para la
transferencia de datos, asegurando la misma, garantizando el tiempo de
sincronización y el tiempo real de respuesta en algunas aplicaciones
Las ventajas del uso del computador en el control de procesos son múltiples, entre
ellas se podría nombrar una mayor eficacia de las operaciones, mayor seguridad y una
reducción drástica de las operaciones manuales.

Hardware.
Hardware corresponde a todas las partes físicas de una computadora sus

componentes, electrónicos, mecánicos, cables, gabinetes, periféricos y cualquier otro
elemento físico involucrado
Computadora Personal
Una computadora es una “máquina digital, electrónica, programable para

el procesamiento de información”. El concepto “procesamiento de
información”, c u a n d o g u a r d a m o s u n d o c u m e n t o o c u a n d o g r a b a m o s
n u e s t r a v o z , los esta es introduciendo dentro del computador los llamaremos
datos que pueden usarse de forma individual o en grandes grupos, dotados de
una estructura
La unidad más elemental de información es una variable binaria, conocida como

BIT (contracción de las palabras BInary y digiT), que toma el valor 0 ó 1. El bit
representa la mínima información posible, ya que corresponde a la ocurrencia de un
suceso, de entre dos posibilidades distintas.
Arquitectura de un computador
 Arquitectura von Neumann

John von Neumann3 (1903-1957), que había colaborado en el diseño de varios
computadores durante la Segunda Guerra Mundial, publica en 1946 un artículo que

esboza los principios generales de diseño de un computador en su sentido actual:
La máquina es controlada por un conjunto de instrucciones, con un pequeño número de

elementos centrales de proceso. El programa se almacena en el computador de forma
que en su representación interna no se hacen distinciones entre datos e instrucciones,
ambos almacenados en código binario.
De esta forma el programa pasa a estar “dentro” del computador, y así el cambio de un
programa a otro sólo implica un cambio en el valor de posiciones de memoria, en
contraposición con lo hecho hasta la fecha que requería cambios manuales de clavijas.
Estos principios, enriquecidos con importantes aportaciones tecnológicas
Las unidades funcionales de una máquina de von Neumann son cinco
 Unidad de Control (UC)

 Unidad Aritmético-Lógica (ALU)
 Unidad de Entrada
 Unidad de Salida
 Memoria (principal y secundaria).
 Unidad Central de Proceso

Por su disposición y función, se llama unidad de central de proceso (CPU =
Central Process Unit) al conjunto formado por la UC y la ALU, donde reside la
‘inteligencia’ de la máquina, es decir, la capacidad de procesamiento de la
información. La memoria es el lugar donde se almacenan los datos y las
instrucciones de forma permanente o transitoria. Un vistazo al esquema,
justifica que llamemos periféricos al conjunto de unidades de E/S y de
memoria masiva ó auxiliar.

Veamos ahora con más detalle las unidades funcionales:
- UNIDAD DE ENTRADA (E). Son los dispositivos por donde se introducen

los datos e instrucciones. En estas unidades se transforman las
informaciones de entrada, en señales binarias de naturaleza eléctrica.
Son unidades de entrada: el teclado, un terminal de ventas, un
digitalizador, una lectora de tarjetas de crédito, etc.
- UNIDAD DE SALIDA (S). Son los dispositivos por donde se obtienen los
resultados de los programas ejecutados en el computador. La mayor
parte de estas unidades transforman las señales eléctricas binarias en
caracteres, escritos o visualizados, inteligibles por un humano o por otra
máquina. Son dispositivos de salida: un monitor, una impresora, un
registrador gráfico, el visor de un casco de realidad virtual, etc.
- LA UNIDAD DE PROCESAMIENTO CENTRAL (CPU). La CPU se

encarga de manipular los datos, gracias a su capacidad para ejecutar una
serie de tareas básicas que se corresponde con las operaciones incluidas
dentro de sus circuitos, contenidos, normalmente, en un solo chip
llamado microprocesador Estos están constituidos, al menos, por dos
unidades básicas, la UC y la ALU.
- LA UNIDAD DE CONTROL. Es la encargada de administrar y coordinar

los recursos y actividades del computador. Se puede pensar en la UC,
como si fuera un guardia de tráfico, dirigiendo el flujo de datos dentro de
la máquina, esto es, un coordinador que controla la ejecución “tirando de
la cuerda adecuada, en el momento adecuado”. Por ello la UC tiene
misiones relacionadas con: identificar instrucciones, supervisar su
ejecución (enviando bits a las líneas de señal adecuadas en los
momentos adecuados), y detectar señales eléctricas, procedentes del
resto de unidades.

- UNIDAD ARITMÉTICO-LÓGICA. Esta unidad contiene los circuitos

electrónicos con los que se llevan a cabo las operaciones básicas de tipo
aritmético (suma, resta, multiplicación, división, etc.), y de tipo lógico
(comparar dos números, hacer operaciones del álgebra de Boole, etc).
Este aparentemente limitado conjunto de circuitos es más que suficiente,
ya que todas las operaciones se pueden llevar a cabo en términos de un
gran número de pequeños pasos, involucrando cada uno de ellos, uno o
dos circuitos.
 Bus de Datos, Direcciones y Control

Un requisito para el buen funcionamiento de la máquina, es la conexión, para el
intercambio de información, entre unas unidades y otras. Este intercambio
entre unidades se tiene que lleva a cabo en paralelo (varios bits de información
al mismo tiempo) a través de una canal de información o bus que contiene un
determinado número de hilos conductores.
La palabra es la unidad de transferencia de información, al estar ligada a la

estructura interna de la computadora, su longitud, en bits, indica tanto el
tamaño de los datos con que opera la ALU, como la de los datos transferidos
entre la memoria y la CPU. Por tanto, esta longitud acaba determinando las
características físicas de los buses. Así, por ejemplo, se se trabaja con
palabras de memoria de 16 bits la información desde una unidad a otra debe
transmitirse por un bus de 16 hilos conductores. A través del bus, la CPU
puede extraer (leer) datos de la memoria principal, proporcionando tanto la
dirección de la posición de memoria como su contenido y viceversa en el
proceso de escritura en memoria. Al bus empleado para intercambiar
información entre los distintos subsistemas se le llama bus de datos, mientras

que si un bus es específicamente utilizado para indicar posiciones de memoria

se conoce como bus de direcciones.
Mainboard
La placa base, también conocida como placa madre o con el anglicismo board,
es un gran circuito impreso sobre el que se suelda el chipset, las ranuras de
expansión (slots), los zócalos, conectores, diversos integrados, etc. Es el soporte
fundamental que aloja y comunica a todos los demás componentes: Procesador,
módulos de memoria RAM, tarjetas gráficas, tarjetas de expansión, periféricos de
entrada y salida. Para comunicar esos componentes, la placa base posee una
serie de buses mediante los cuales se trasmiten los datos dentro y hacia afuera
del sistema.
La tendencia de integración ha hecho que la placa base se convierta en un

elemento que incluye a la mayoría de las funciones básicas (vídeo, audio, red,
puertos de varios tipos), funciones que antes se realizaban con tarjetas de
expansión. Aunque ello no excluye la capacidad de instalar otras tarjetas
adicionales específicas, tales como capturadoras de vídeo, tarjetas de
adquisición de datos, etc.
También, la tendencia en los últimos años es eliminar elementos separados en la

placa base e integrarlos al microprocesador. En ese sentido actualmente se
encuentran sistemas denominados System on a Chip que consiste en un único
circuito integrado que integra varios módulos electrónicos en su interior, tales
como un procesador, un controlador de memoria, una GPU, Wi-Fi, bluetooth, etc.
La mejora más notable en esto está en la reducción de tamaño frente a igual
funcionalidad con módulos electrónicos separados. La figura muestra una
aplicación típica, en la placa principal de un teléfono móvil.

Memoria Principal
La CPU contiene la lógica y los circuitos para que pueda funcionar la

computadora, sin embargo carece de espacio para guardar programas y datos,
esta es precisamente la misión de la unidad de MEMORIA: almacenar de forma
eficiente tanto datos como programas. Notemos que, aunque la CPU contiene
registros para datos e instrucciones, éstas son áreas de memoria muy pequeñas,
que sólo pueden guardar unos cuantos bits a la vez; cuando hay necesidad de
grandes cantidades de espacio de almacenamiento se hace necesaria la
memoria externa a la CPU. Existen dos tipos básicos de memoria, diferenciadas
tanto por sus funciones como por su velocidad: la principal y la secundaria. En
ambas, la información se codifica en un alfabeto binario formado por bits,
generalmente 8, llamado octeto o byte, que es la unidad utilizada para medir la
capacidad de almacenamiento de una memoria. Como el byte es relativamente
pequeño, es usual utilizar múltiplos:
Memoria principal (central o interna). Su función es la de almacenar los

datos y el programa que va ejecutarse en cada momento, por ello es la más
rápida y tiene optimizada sus transferencias, con la CPU Físicamente la
memoria consiste en una serie de chips conectados con el microprocesador
de la forma más integrada posible. La memoria está dividida en celdas o
posiciones denominadas también palabras de memoria, estas celdas tienen
como longitud, un número determinado de bits, normalmente coincidiendo con
un múltiplo del byte: 8, 16, 32, 64, etc.
Existen distintos tipos de memorias y más de una manera de clasificarlas.

Una manera de hacerlo es por la permanencia de la información en ellas.
Algunos chips de memoria siempre conservan los datos que tienen aun
cuando la computadora esté apagada; esta memoria se llama no volátil.
Otros chips, que forman la mayor parte de la memoria, sí pierden su
contenido cuando la computadora se apaga, la memoria de éstos es volátil.
Una segunda clasificación de la memoria es por

la manera en que puede usarse. Algunos chips
de memoria siempre guardan los mismos datos,
esto es, además de ser no volátiles sus datos no
pueden ser cambiados. De hecho, cuando los
datos se guardan en este tipo de memoria se
llama “grabación permanente de los datos”. Ya
que sólo pueden leerse y usarse, nunca

cambiarse. Este tipo de memoria se llama memoria de sólo lectura (Read

Only Memory, ROM).
Una de las razones por las que una computadora necesita ROM es para
disponer de instrucciones en el momento del encendido, ya que sin datos
grabados de forma permanente, no se podría producir todas las tareas que
constituyen el proceso de arranque. La memoria cuyo contenido puede
cambiarse se llama memoria de acceso aleatorio (Random-Access Memory,
RAM). El propósito de la memoria RAM es guardar los distintos programas y
datos, que vamos a utilizar en cada momento. Utilizamos el término acceso
aleatorio porque la CPU accede a su memoria, utilizando una dirección de
memoria, que es un número que indica un lugar en el chip de memoria, (de la
misma forma que si fuera un número de apartado postal, que indica en qué
buzón deberá ponerse el correo).
De esta manera, la computadora no

tiene que reconocer en toda la memoria
para encontrar los datos que necesita;
puede buscar la dirección e ir
directamente a ella. En ambos tipos de
memoria, la lectura es no destructiva ya
que el contenido de una posición de
memoria no se altera por muchas veces
que se lea. Sin embargo, la escritura en
una memoria RAM (recordemos que la memoria ROM no permite la escritura)
es destructiva, es decir, cuando se escribe algo en una posición de memoria
automáticamente se destruye el contenido anterior.
Memoria auxiliar
La memoria principal, aunque es muy rápida, no tiene gran capacidad de
almacenamiento. Para guardar grandes cantidades de información, se utilizan
otros tipos de memoria, tales como discos y cintas magnéticas, que siendo más
lentas en la transferencia de datos, tienen mucha más capacidad que la
memoria principal (del orden de mil veces más lentas pero más capaces).
Frecuentemente los datos y programas se graban (introduciéndolos por las
unidades de entrada) en la memoria masiva, de forma que si se ejecuta varias
veces el programa o se utilizan repetidamente los datos, no es necesario
introducirlos de nuevo por el dispositivo de entrada, sino que basta lerlos desde
el disco o la cinta.
Las memorias masivas han heredado el concepto de fichero de los sistemas
manuales de tratamiento de la información, de forma que mucha de su

terminología deriva de la tradicional. Así hablaremos de ficheros o archivos

como una colección ordenada de datos relacionados entre sí. Existen distintos
tipos de archivos, algunos de ellos tienen como unidad elemental el registro,
que se correspondería con una ficha en un fichero manual.
 Disco duro
Los discos duros tienen una gran capacidad de almacenamiento de

información, pero al estar alojados normalmente dentro del armazón de la
computadora (discos internos), no son extraíbles fácilmente. Para intercambiar
información con otros equipos necesitamos utilizar unidades de disco, como
discos duros externos, discos ópticos (CD, DVD), memorias USB, memorias
flash, etc.
El disco duro almacena casi toda la información que manejamos al trabajar con
una computadora. En él se aloja, por ejemplo, el sistema operativo que permite
arrancar la máquina, los programas, archivos de texto, imagen, vídeo, etc.
Dicha unidad puede ser interna (fija) o externa (portátil), dependiendo del lugar
que ocupe en el gabinete o caja de computadora.
Un disco duro está formado por

varios discos apilados sobre los
que se mueve una pequeña
cabeza magnética que graba y
lee la información. Este
componente, al contrario que el
microprocesador o los módulos
de memoria, no se conecta
directamente en la placa, sino
que se conecta a ella mediante
un cable. También va
conectado a la fuente de
alimentación, pues, como
cualquier otro componente,
necesita energía para funcionar.
 Disquetera
La unidad de 3,5 pulgadas permite intercambiar información utilizando

disquetes magnéticos de 1,44 MB de capacidad. Aunque la capacidad de
soporte es muy limitada si tenemos en cuenta las necesidades de las
aplicaciones actuales se siguen utilizando para intercambiar archivos
pequeños, pues pueden borrarse y reescribirse cuantas veces se desee de una

manera muy cómoda, aunque la transferencia de información es bastante lenta

si la comparamos con otros soportes, como el disco duro o un CD-ROM.
 Unidad de CD-DVD
La unidad de CD-ROM permite utilizar discos ópticos de una mayor capacidad

que los disquetes de 3,5 pulgadas, pudiendo llegar hasta 700 MB. Ésta es su
principal ventaja, pues los CD-ROM se han convertido en el estándar para
distribuir sistemas operativos, aplicaciones, etc.
Una característica básica de las

unidades de CD-ROM es la velocidad
de lectura, que normalmente se expresa
como un número seguido de una «x»
(40x, 52x,..). Este número indica la
velocidad de lectura en múltiplos de 128
kB/s. Así, una unidad de 52x lee
información de 128 kB/s × 52 = 6,656
kB/s, es decir, a 6,5 MB/s.
Las unidades de DVD-ROM son aparentemente iguales que las de CD-ROM,

pueden leer tanto discos DVD-ROM como CD-ROM. Se diferencian de las
unidades lectoras de CD-ROM en que el soporte empleado tiene hasta 17 GB
de capacidad, y en la velocidad de lectura de los datos. La velocidad se
expresa con otro número de la «x»: 12x, 16x... Pero ahora la x hace referencia
a 1,32 MB/s. Así: 16x = 21,12 MB/s.
 Lector de tarjetas de memoria
El lector de tarjetas de memoria es un periférico que lee o escribe en soportes

de memoria flash, una tarjeta de memoria es un pequeño soporte de
almacenamiento que utiliza memoria flash para guardar la información que
puede requerir o no baterías, en los
últimos modelos la batería no es
requerida, la batería era utilizada por los
primeros modelos. Estas memorias son
resistentes a los rasguños externos y al
polvo que han afectado a las formas
previas de almacenamiento portátil, como los CD y los disquetes.
 Otros dispositivos de almacenamiento
Otros dispositivos de almacenamiento son las memorias flash o los dispositivos

de almacenamiento magnéticos de gran capacidad.

Memoria flash es un tipo de memoria que se comercializa para el uso de

aparatos portátiles, como cámaras digitales o agendas electrónicas o bien un
lector de tarjetas, se conecta a la computadora a través del puerto USB o
Firewire. El Almacenamiento en línea, esta modalidad permite liberar espacio
de los equipos de escritorio y trasladar los archivos a discos rígidos remotos
provistos que garantizan normalmente la disponibilidad de la información, por
ejemplo podemos mencionar el servicio de SkyDrive que se proporciona a los
usuarios de Hotmail gratuitamente.
Periféricos
Se entiende por periférico a las dispositivos que permiten a la computadora
transmitir y recibir información, Los periféricos son los que permiten realizar las
operaciones conocidas como de entrada/salida, muchos de ellos son
fundamentales para el funcionamiento adecuado de la computadora; por
ejemplo, el teclado, el disco duro y el monitor son elementos actualmente
imprescindibles; pero no lo son un escáner o una impresora. En la década de
los años 80, las primeras computadoras personales no utilizaban disco duro ni
mouse (o ratón), tenían sólo una o dos disqueteras, el teclado y el monitor
como únicos periféricos.
 Dispositivos de entrada de información

De esta categoría son aquellos que permiten el ingreso de información, en
general desde alguna fuente externa o por parte del usuario. Los dispositivos
de entrada proveen el medio fundamental para transferir hacia la computadora
información desde alguna fuente, también permiten cumplir la tarea de leer y
cargar en memoria el sistema operativo y las aplicaciones o programas
informáticos, los que a su vez ponen operativa la computadora y hacen posible
realizar las más diversas tareas. Entre los periféricos de entrada se puede
mencionar: teclado, mouse o ratón, escáner, micrófono, cámara web , lectores
ópticos de código de barras, Joystick, lectora de CD, DVD o BluRay , placas de
adquisición/conversión de datos, etc.

 Dispositivos de salida de información
Son aquellos que permiten emitir o dar salida a la información resultante de

las operaciones realizadas por la CPU (procesamiento). Los dispositivos de
salida aportan el medio para comunicar la información y datos procesados; ya
sea al usuario o bien a otra fuente externa, local o remota. Los dispositivos
más comunes de este grupo son los monitores clásicos (no de pantalla táctil),
las impresoras, los altavoces. Proyectores, etc.
 Dispositivos Entrada, Salida
Son aquellos dispositivos que pueden operar de ambas formas: tanto de

entrada como de salida, se puede mencionar como periféricos mixtos o de
Entrada/Salida a: discos rígidos, disquetes, unidades de cinta magnética,
lecto-grabadoras de CD/DVD, discos ZIP, etc. También entran en este rango,
con algunas diferencias, otras unidades, tales como: Tarjetas de Memoria
flash o unidad de estado sólido, tarjetas de red, módems, tarjetas de
captura/salida de vídeo, etc. La pantalla táctil (no el monitor clásico) es un
dispositivo que se considera mixto, ya que además de mostrar información y
datos (salida) puede actuar como un dispositivo de entrada.
Proceso de arranque de una Computadora

La secuencia de eventos que ocurren entre el tiempo que se enciende la
computadora y el tiempo que podemos emplear el Sistema Operativo para
aceptar comandos recibe el nombre de proceso de arranque

Unos de los componentes de más importancia en una computadora es la

memoria RAM, pero esta es volátil, es decir, no almacena ninguna información
cuando la computadora pierde energía. Una computadora necesita de alguna
manera dar a la memoria RAM los archivos del Sistema Operativo para que
esta pueda iniciar. Este es uno de los principales objetivos del proceso de
arranque. En general el proceso de arranque sigue estas seis etapas:
 Encendido. , es la primera etapa en el proceso de arranque y consiste en dar

energía eléctrica a todos los circuitos de la computadora, lo primero que
sucede en esta etapa es que el fan de la fuente de poder empieza a girar y el
power LED se enciende.
 Comienzo del programa de arranque. Cuando la computadora recibe

energia, el microprocesador comienza a ejecutar el programa de arranque que
está almacenado en la memoria ROM. Si el chip de memoria ROM, los
módulos de la RAM están mal funcionando, el microprocesador estará
deshabilitado para correr el programa de arranque y la computadora
 POST. Auto prueba de encendido o power-on self-test POST (La computadora

realiza un diagnostico crucial del sistema y de cada componente de la
computadora) . La POST primero chequea la tarjeta de video que está este
correctamente conectada a su monitor y a su computadora, si la tarjeta de
video para la prueba, el próximo test en la computadora será en la memoria
RAM en este test se escribe en cada localización de la memoria RAM y luego
recuperar los datos para ver si son correctos, en este momento la computadora
despliega la cantidad de memoria RAM chequeada, si ocurre cualquier error
durante esta prueba, el POST para y despliega un mensaje indicando problema
de memoria RAM. Luego, si no hubo ningún error en la prueba de la RAM, se
prosigue con el chequeo del teclado, en la mayoría de las computadoras usted

podrá ver durante esta prueba los indicadores del teclado parpadeando
indicándole que la prueba del teclado esta en progreso, si alguna tecla esta
presionada la computadora despliega un mensaje de "error de keyboard" o
error de teclado, finalmente la POST prueba las unidades de disco, se puede
observar el disco duro y las unidades de disquete están en actividad y sus
indicadores encendido o parpadeando y también escuchara la velocidad de los
discos girando.
 Carga del sistema operativo. Después que el POST es completamente

realizado, la computadora continua siguiendo las instrucciones que están
en la memoria ROM para cargar el sistema operativo. La computadora
primero chequea el driver A: para ver si contiene un disco, si hay un
disquete aquí convierte al driver A en el driver por defecto (driver o
unidad de arranque). Si no encuentra un disco en el driver A, el driver c
será el driver por defecto, por lo que es mejor si la computadora tiene un
disco durante el proceso de arranque, luego la computadora busca los
archivos del Sistema Operativo (archivos Io.sys y Msdos.sys), si esos
archivos no existen o no están en el disco duro, el proceso de arranque
para y un mensaje de error es mostrado en la pantalla de monitor: "No
system disk" o "disk error" o "Cannot load a file", sino hay problema el
microprocesador procede a cargar otro archivo del Sistema Operativo
llamado: Command.com..
 Chequeo de la configuración. Al comenzar el proceso de arranque, la
computadora chequea los datos que están en la CMOS, para determinar
la cantidad de memoria RAM instalada y el tipo de disco duro, las
unidades de disquete entre otras cosas, estos datos de configuración son
necesarios para la computadora pueda acceder a cada dispositivo. El
próximo paso del proceso de arranque la computadora busca en el
directorio raíz del disco para ver la configuración de archivos. Algunas
computadoras tiene esos datos almacenados en un archivo llamado:
autoexec.bat.
 Lista para aceptar comando y dato. El proceso de arranque finaliza

cuando la computadora esta lista para aceptar comando y datos.
Usualmente la computadora muestra un Prompt o la pantalla principal de
su sistema operativo, si está usando Windows será el escritorio de
Windows si está usando el DOS será el Prompt

Sistema operativo
Es el programa o conjunto de programas que efectúan la gestión de los
procesos básicos de una computadora. Uno de los propósitos del sistema
operativo consiste en gestionar los recursos de localización y protección de
acceso del hardware, hecho que alivia a los programadores de aplicaciones de
tener que tratar con estos detalles. La mayoría de aparatos electrónicos que
utilizan microprocesadores para funcionar, llevan incorporado un sistema
operativo. (Teléfonos móviles, reproductores de DVD, computadoras, radios,
enrutadores, etc.), tipos de Sistemas Operativos
 Windows
 Mac OS
 Linux
 AmigaOS
Actualmente también podemos contar con Sistemas Operativos para

dispositivos mobiles, entre ellos podemos mencionar:
 Symbian
 Android
 iOS
 Windows Mobile
Microsoft Windows
Es el nombre para una serie de sistemas operativos desarrollados por
Microsoft desde 1981, en 1983, Microsoft comercializó por primera vez el
entorno operativo denominado Windows en noviembre de 1985 como
complemento para MS-DOS, en respuesta al creciente interés del mercado en
una interfaz gráfica de usuario (GUI). Microsoft Windows llegó a dominar el
mercado de ordenadores personales del mundo, superando a Mac OS, el cual
había sido introducido previamente a Windows. Las versiones más recientes de
Windows son Windows 7 para equipos de escritorio, Windows Server 2008 R2
para servidores y Windows Phone 7 para dispositivos móviles

 Windows 1.0 y 2.0. Windows 1.0 se publicó en noviembre de 1985. El shell

de Windows 1.0 es un programa conocido como MS-DOS, incluye programas
como la Calculadora, Calendario, Visor del portapapeles, Reloj, Panel de
control, el Bloc de notas, Paint, , Terminal y Write. Windows 1.0 no permite la
superposición de ventanas, debido a que Apple Computer ya contaba con
esta característica.
Windows 2.0 fue lanzado en octubre de 1987 y presentó varias mejoras en la

interfaz de usuario y en la gestión de memoria e introdujo nuevos métodos
abreviados de teclado. Windows 2.1 con u versión Windows/386 empleando
Modo 8086 virtual para realizar varias tareas de varios programas de DOS.
Las primeras versiones de Windows se suele considerar como interfaz gráfica
de usuario simple. A diferencia de MS-DOS, Windows permite a los usuarios
ejecutar las aplicaciones gráficas de múltiples al mismo tiempo, a través de la
multitarea. Windows implementa un esquema de software elaborada, basado
en el segmento, memoria virtual, lo que le permitió ejecutar aplicaciones más
grandes que la memoria disponible
 Windows 3.0 y 3.1. Windows 3.0 (1990) y Windows 3.1 (1992) mejoraron el
diseño, principalmente debido a la memoria virtual y los controladores de
dispositivo virtual, que permitió compartir dispositivos arbitrarios entre DOS y
Windows. Además, las aplicaciones de Windows ahora podrían ejecutar en
modo protegido (cuando se ejecuta Windows en el modo estándar o 386
mejorado), que les da acceso a varios megabytes de memoria y se elimina la
obligación de participar en el esquema de la memoria virtual de software.
Para Windows 3.0, Microsoft también reescribió las operaciones críticas de C
en ensamblador, haciendo esta versión más rápido y menos consumo de
memoria que sus predecesores.
 Windows 95, 98, y Me. Windows 95 fue lanzado en 1995, con una nueva
interfaz de usuario, compatibilidad con nombres de archivo largos de hasta
250 caracteres, y la capacidad de detectar automáticamente y configurar el
hardware instalado (plug and play), se podían ejecutar aplicaciones de 32-
bits y presentó varias mejoras tecnológicas que aumentaron su estabilidad

respecto a Windows 3.1. El siguiente lanzamiento de Microsoft fue Windows

98 en 1998. Microsoft lanzó una segunda versión de Windows 98 en 1999,
llamado Windows 98 Second Edition (a menudo acortado a Windows 98 SE).
En el 2000, Microsoft lanza Windows Millennium Edition (comúnmente

llamado Windows Me), que actualiza el núcleo de Windows 98 pero que
adopta algunos aspectos de Windows 2000 y elimina (más bien, oculta) la
opción de arranque r en modo DOS.
 Familia NT. La familia de sistemas Windows NT fue hecha y comercializada

por un mayor uso de fiabilidad de negocios. El primer lanzamiento fue de MS
Windows NT 3.1 (1993), fue seguido por NT 3.5 (1994), NT 3.51 (1995), NT
4.0 (1996), Windows 2000 esta es la última versión de Windows NT.
Microsoft combina los negocios de consumo y sistemas operativos con
Windows XP, viene tanto en las versiones Home y professional (y las
versiones posteriores de mercado para tablet PC y centros multimedia).
Windows Server 2003, lanzado un año y medio después de Windows XP
después de un proceso de desarrollo largo, Windows Vista fue lanzado hacia
el final de 2006, su homólogo de servidor, Windows Server 2008 fue lanzado
a principios de 2008. El 22 de julio de 2009, Windows 7 y Windows Server
2008 R2 se publicaron como RTM (versión de disponibilidad general).
Windows 7 fue lanzado el 22 de octubre de 2009.
Windows CE, la oferta de Microsoft en los mercados móviles e integrados, es

también un verdadero sistema operativo 32 bits que ofrece diversos servicios
para todas las subestaciones de trabajo de explotación.
 Windows CE. (oficialmente conocido como Windows Embedded), es una

edición de Windows que se ejecuta en equipos portátiles como teléfonos
móviles. Windows. Windows CE que se utilizó en la Dreamcast junto con
sistema operativo propietario de Sega para la consola. Windows CE es el
núcleo del que deriva Windows Mobile.

Aplicaciones de Windows
 Internet Explorer. Windows Internet Explorer es un navegador web de
Internet producido por Microsoft para su plataforma Windows. Fue creado en
1995 tras la adquisición por parte de Microsoft del código fuente de Mosaic,
un navegador desarrollado por Spyglass, siendo rebautizado entonces como
Internet Explorer. Las primeras versiones, basadas en Mosaic, no supusieron
ninguna amenaza para el entonces dominante Netscape Navigator, ya que
eran bastante simples y no eran compatibles con algunas de las extensiones
más populares de Netscape que dominaban la web de la época (como los
marcos o JavaScript). Reproductor de Windows Media
 Windows Media Player, Reproductor de Windows Media es un reproductor

multimedia creado por Microsoft. Se han lanzado varias versiones del
reproductor, siendo la versión 12 la última existente, que se incluye con
Windows 7. Permite la reproducción de varios formatos como Audio CD,
DVD-Video, DVD-Audio, WMA, WMV, MP3, MPG, AVI, entre otros, siempre y
cuando se dispongan de los códecs correspondientes. También da la
posibilidad de pasar canciones de un CD al disco duro de la computadora, y
al contrario, de la computadora a un CD de música o de datos.
 Windows Defender. Windows Defender es un programa de seguridad cuyo

propósito es prevenir, quitar y poner en cuarentena software espía en
Microsoft Windows. Es incluido y activado por defecto en Windows Vista y
Windows 7 y está disponible como descarga gratuita para Windows XP y
Windows Server 2003.
 Windows Media Center. Es una aplicación con una interfaz de usuario,

diseñado para servir como equipo personal de cine en casa. Está incluido en
Windows XP Media Center Edition como parte de dicha versión especial del
sistema operativo, también se incluye en las ediciones superiores de
Windows Vista (Vista Home Premium y Vista Ultimate) y Windows 7 (todas las
ediciones exceptuando Starter y Home Basic).
 WordPad. Es un procesador de textos básico que se incluye con casi todas

las versiones de Microsoft Windows desde Windows 95, es más avanzado
que el Bloc de notas pero más sencillo que el procesador de textos de
Microsoft Works y Microsoft Word.
 Paint. Microsoft Paint (cuyo nombre original era Paintbrush) fue desarrollado
en el año 1982 por Microsoft, Paint ha acompañado al sistema operativo
Microsoft Windows desde la versión 1.0. Siendo un programa básico, es
incluido en las nuevas versiones de este sistema.

Núcleo del Sistema

En informática, un núcleo o kernel es un software que constituye la parte más
importante del sistema operativo. Es el responsable de facilitar a los distintos
programas acceso seguro al hardware de la computadora, es decir gestiona
recursos, a través de servicios de llamada al sistema. Acceder al hardware
directamente puede ser realmente complejo, por lo que los núcleos suelen
implementar una serie de abstracciones del hardware permitiendo esconder la
complejidad, y proporciona una interfaz limpia y uniforme al hardware
subyacente, lo que facilita su uso al programador, tine como funciones las
siguientes:
 La comunicación entre los programas que solicitan recursos y el

hardware.
 Gestión de los distintos programas informáticos (tareas) de una
máquina.
 Gestión del hardware (memoria, procesador, periférico, forma de
almacenamiento, etc.)
.El núcleo tiene grandes facultades sobre la utilización de los recursos

materiales (hardware), en particular, de la memoria.
Lenguaje de programación
Es un diseñado para expresar instrucciones que pueden ser llevadas a cabo
por una computadora. Está formado por un conjunto de símbolos y reglas
sintácticas y semánticas que definen su estructura y el significado de sus
elementos y expresiones, al proceso por el cual se escribe, prueba, depura,
se compila el código fuente de un programa se llama programación.
Programación se define como el proceso de creación de un programa de

computadora, mediante la aplicación de procedimientos lógicos, a través de

los siguientes pasos:
 El desarrollo lógico del programa para resolver un problema en particular.

 Escritura de la lógica del programa empleando un lenguaje de programación
específico (codificación del programa).
 Ensamblaje o compilación del programa hasta convertirlo en lenguaje de
máquina.
 Prueba y depuración del programa.
 Desarrollo de la documentación.
Un Lenguaje de programación permite especificar de manera precisa qué

datos debe operar una computadora, cómo deben ser almacenados o
transmitidos y qué acciones debe tomar bajo una variada gama de
circunstancias. Todo esto, a través de un lenguaje que intenta estar
relativamente próximo al lenguaje humano o natural. Una característica
relevante de los lenguajes de programación es precisamente que más de un
programador pueda usar un conjunto común de instrucciones que sean
comprendidas entre ellos para realizar la construcción de un programa de
forma colaborativa.
Proceso de compilación
Es el proceso por el cual se traducen las instrucciones escritas en un

determinado lenguaje de programación a lenguaje máquina. Un programa
fuente se puede dividir en módulos almacenados en archivos distintos.
Normalmente la creación de un programa ejecutable (un típico.exe para
Microsoft Windows o DOS) conlleva dos pasos. El primer paso se llama
compilación (propiamente dicho) y traduce el código fuente escrito en un
lenguaje de programación almacenado en un archivo a código en bajo nivel
(normalmente en código objeto, no directamente a lenguaje máquina). El
segundo paso se llama enlazado en el cual se enlaza el código de bajo nivel
generado de todos los ficheros y subprogramas que se han mandado
compilar y se añade el código de las funciones que hay en las bibliotecas del
compilador para que el ejecutable pueda comunicarse directamente con el
sistema operativo, traduciendo así finalmente el código objeto a código
máquina, y generando un módulo ejecutable.
Estos dos pasos se pueden hacer por separado, almacenando el resultado de

la fase de compilación en archivos objetos (un típico.obj para Microsoft
Windows, DOS o para Unix); para enlazarlos en fases posteriores, o crear
directamente el ejecutable; con lo que la fase de compilación se almacena
sólo temporalmente. Un programa podría tener partes escritas en varios
lenguajes (por ejemplo Basic, C, C++ y Asm), que se podrían compilar de

forma independiente y luego enlazar juntas para formar un único módulo

ejecutable.
Programa
Un programa es un conjunto de instrucciones que una vez ejecutadas
realizarán una o varias tareas en una computadora. Al conjunto general de
programas, se le denomina software, que más genéricamente se refiere al
equipamiento lógico o soporte lógico de una computadora digital. De acuerdo
a sus funciones, se clasifican en software de sistema y aplicación, en los
computadores actuales, al hecho de ejecutar varios programas de forma
simultánea y eficiente, se le conoce como multitarea.
Se presentan como ficheros ejecutables, con extensión “.exe”, en los

sistemas operativos de la familia Windows) debido a que una vez que han
pasado por el proceso de compilación y han sido creados, las instrucciones
que se escribieron en un lenguaje de programación que los humanos usan
para escribirlos con mayor facilidad, se han traducido al único idioma que la
máquina comprende, combinaciones de ceros y unos llamada código
máquina.
Ejecución y almacenamiento de los programas
los programas se almacenan en una memoria no volátil, para que luego el

usuario de la computadora, directa o indirectamente, solicite su ejecución. Al
momento de dicha solicitud, el programa es cargado en la memoria de acceso
aleatorio o RAM del equipo, bajo el control del software llamado sistema
operativo, el cual puede acceder directamente al procesador. El procesador
ejecuta el programa, instrucción por instrucción hasta que termina.
Algunos programas están empotrados en el hardware. Una computadora con

arquitectura de programas almacenados requiere un programa inicial
almacenado en su ROM para arrancar. El proceso de arranque es para
identificar e inicializar todos los aspectos del sistema, desde los registros del
procesador, controladores de dispositivos hasta el contenido de la memoria
RAM seguido del proceso de inicialización, este programa inicial carga al
sistema operativo e inicializa al contador de programa para empezar las
operaciones normales, un dispositivo de hardware podría tener firmware
empotrado para el control de sus operaciones. El firmware se utiliza cuando
se espera que el programa cambie en raras ocasiones o nunca, o cuando el
programa no debe perderse cuando haya ausencia de energía.
En los primeros computadores los programas se cargaron manualmente al

procesador central mediante interruptores, una instrucción era representada

por una configuración de estado abierto o cerrado de los interruptores,

después de establecer la configuración, se ejecutaba un botón de ejecución,
este proceso se repetía constantemente. También, históricamente los
programas se cargaban manualmente mediante una cinta de papel o tarjetas
perforadas. Después de que el programa se cargaba, la dirección de inicio se
establecía mediante interruptores y el botón de ejecución se presionaba.

2
TAREA
2. Manejo de las TIC

En esta tarea el participante conocerá los elementos que componen
una red de computadoras, podrá configurar una red, compartir
recursos y realizar el diagnostico de la conexión de los diferentes
elemento que la componen. Además comprenderá la importancia de
las TIC empleando herramientas para publicar información en el
Internet
Hoy en día las redes de computadoras son de suma

importancia en nuestra vida, una red de computadoras es un
conjunto de equipos ya sea computadoras y/o dispositivos
conectados por medio de cables, señales, ondas o cualquier
otro método de transporte de datos, que comparten
información, recursos, servicios, etc. Las redes de
computadoras sirven para compartir cualquier tipo de
información, y de una manera muy rápida y eficaz. Esto es
importante hoy en día ya que vivimos en la época de la
globalización, esta se lleva a cabo principalmente gracias a las
redes de computadoras, ya que con ellas es posible
comunicarse en cuestión de segundos con cualquier país del
mundo, También son muy importantes, porque ahora con la
tecnología que cada vez avanza con más rapidez, te puedes
informar de todo lo que está pasando en el mundo.
Las tecnologías de la información y la comunicación TIC o

IT para Information Technology agrupan los elementos y las
técnicas utilizadas en el tratamiento y la transmisión de las
informaciones, principalmente de informática, internet y
telecomunicaciones

 Concentrador de red, cables de red y herramientas para instalación de red.
 Instalación de los diferentes equipos a nivel físico

 Configuración de equipos y creación de grupos de trabajo
Determina los Elementos, tipos, topología y

configuración de una Red de Computadoras
2.1. Configurar nombre del Equipo y Grupo de

Trabajo
En esta actividad vamos a configurar nuestro equipo para poder administra un

grupo de trabajo en donde se podrá conectar otras computadoras en la red,
seguiremos los siguientes pasos:
Seleccionar Propiedades del equipo en el menú de inicio de Windows
En la ventana de Propiedades del equipo veremos la configuración del

sistema, Configuración de Nombre, Dominio y Grupo de trabajo y actualización
del equipo, seleccionaremos “Cambiar configuración”

En la ventana de Propiedades del Sistema veremos la descripción del equipo,

la cual se puede modificar para cambiar el nombre del Equipo y Grupo de
trabajo presionando el botón “Cambiar…”
Después de insertar los datos del equipo y del grupo de trabajo presionar el
botón aceptar

Finalmente se reiniciara el equipo para hacer efectivos los cambios,

presionamos el botón para reiniciar.
2.2. Configurar la Conexión del Área Local

En esta actividad vamos a configurar la conexión de Área local, en el protocolo
de red TCP / IP V.4 insertaremos loas datos de: dirección IP, Mascara de
Subred, Puerta de Enlace Predeterminada y Servidos DNS preferido y
alternativo, detallaremos los pasos a continuación:
Abriremos la ventana del Panel de Control, presionando el botón de inicio de

Windows.
Abriremos la ventana del Panel de Control, presionando el botón de inicio de

Windows, seleccionamos la opción de “ Ver el estado y las tareas de red”

Se abrirá luego la ventana de las tareas de red, aquí podemos ingresar los
datos de dos maneras, la primera es seleccionando la configuración del
adaptador y la segunda es mediante “ Conexión de Área Local”
En la ventana de estado de conexión de área local se muestra la actividad de

la conexión, presionamos el botón de propiedades.

La ventana de propiedades presenta una serie de protocolos entre ellos el

TCP / IPv4 en la que accederemos a sus propiedades.
La ventana de propiedades presenta una serie de protocolos entre ellos el

TCP / IPv4 en la que accederemos a sus propiedades, insertaremos los datos
de: dirección IP, Mascara de Subred, Puerta de Enlace Predeterminada y
Servidos DNS preferido y alternativo

En la ventana de conexión de área local, hay una opción para configurar el

adaptador de red inalámbrica, si lo presionamos aparecerán las conexiones
inalámbricas disponibles (esta ventana mostrara conexiones si tenemos una
tarjeta de red instalada en la computadora)
Para comprobar el estado de conexión entre computadoras debemos emplear

algunos de los comandos de diagnostico, ejecutar el comando CMD y abrir la
ventana de DOS

Ejecutamos el comando IPCONFIG, para averiguar nuestra dirección IP (se

puede usar adicionalmente el comando IPCONFIG / ALL que nos muestra
todas las características del adaptador)
Ejecutamos el comando PING, con otro equipo para verificar la conexión de

red
Ejecutamos el comando HOSTNAME que nos muestra el nombre del equipo

Ejecutamos el comando NSlOOKUP para saber si el DNS está resolviendo

correctamente los nombres y las IP
Administra información y servicios de Internet
2.3.Comparte Información en una red de área

local
Windows 7 permite compartir directorios con los equipos que se encuentran
en la misma red de área local, este sistema operativo de Microsoft permite
compartir distintos tipos de archivos de una forma más que fácil, vamos a
explicar cómo compartir una carpeta para que puedan ingresar algunos
usuarios de la red con ciertos privilegios.
Primero debes elegir una carpeta en nuestro caso creamos una carpeta con
el nombre “Fotos Familiares” debemos hacer clic derecho sobre ella y
seleccionar la opción propiedades.
En la ventana propiedades elegimos Uso compartido avanzado para

seleccionar a los usuarios que compartirán este recurso en la red

Activamos la opción “compartir esta Carpeta”, luego presionamos el botón

permisos
Vamos a compartir el directorio algunos los usuarios, no se recomienda

otorgar acceso total a todos los usuarios.
Lo ideal sería solo lectura, así que se debe elegir el nivel de “seguridad” de los
archivos en la carpeta, luego aplicar y aceptar

Finalmente para acceder a este recurso desde cualquier computadora en la

red, en la utilidad de ejecutar escribir la dirección IP de la computadora que
esta compartiendo este recurso
Publica artículos en el Internet y emplea

programas de gestión de archivos.
2.4. Cómo crear un blog en WordPress.com

Lo primero que hay que hacer es ir a la web de WordPress.com, presionamos el
botón de Regístrate
Después de elegir el idioma español en el menú desplegable situado en la

parte superior. Aparecerá a continuación el formulario para registrarse como
usuario de WordPress.com:

Aquí rellenamos los campos de texto que se nos pide, pero hay que tener en
cuenta que nuestros datos tengan una buena “fuerza de la contraseña”
(password strength. Al final del formulario podemos elegir entre crear un blog
o sólo un nombre de usuario,.
Cuando apretamos el botón Siguiente, es posible que veamos que el nombre de

usuario ya existe.
A continuación, aparecen los datos del registro, que incluye la dirección o

dominio de mi blog y el título, que se verá en la cabecera del blog

Tanto la URL como el título los podemos cambiar ahora, pero la dirección (URL)
ya no la podremos cambiar. Dejar el nombre de usuario como dominio si no
estamos seguros de cuál va a ser el título.
La aplicación nos avisa que ya se ha creado el blog.
Al final del párrafo de ese documento, nos invitan a ver la portada del blog.

Podemos cambiar la plantilla y personalizar el blog. En la parte superior del blog

hay una barra de menús para administrar el blog
En ella podemos ver las siguientes opciones:
1. My Account (mi cuenta) - Aquí se despliega un menú de accesos directos a

distintas partes de la administración.
2. My Dashboards (paneles) – Aquí se despliegan los paneles de administración
de los blogs que tengamos o en los que participemos. Ésta es la mejor forma de
acceder a nuestro blog.
3. New Post (nueva entrada) – Nos permite acceder directamente al editor de
entradas para escribir un nuevo artículo.
Configurar el blog
La configuración se realiza en el Panel de la administración del blog, llamado

Escritorio. En él aparecen accesos directos a varias de las opciones más
usadas, y también hay información sobre comentarios recientes, enlaces
entrantes y estadísticas de las lecturas del blog, entre otros aspectos. Además,
con Publicación rápida, podemos escribir una entrada breve del blog, y Lo
último son noticias publicadas en el blog de WordPress.com.
Y en la columna de la izquierda tenemos las opciones del blog, de las que

comentaremos las más importantes:
1. Escritorio:

 Las Estadísticas del blog recogen con mucho detalle las lecturas de cada
artículo del blog.
 Estadísticas Akismet es una tecnología que permite separar los comentarios
spam.
2. Mejoras:
Sección donde se pueden contratar ampliaciones o mejoras del servicio.
3. Entradas:
 Las entradas o posts son la publicación característica de los blogs. Aparecen en

la portada del blog en orden cronológico inverso, es decir, el primero es el
último que se ha publicado. Incluyen la posibilidad de que los lectores escriban
comentarios.
 Con Añadir se nos abre un espacio con un editor y sus opciones, donde
escribimos las entradas.
 En Categorías añadimos o editamos categorías para clasificar las entradas y las
páginas del blog.
 En Post Tags añadimos etiquetas o tags para clasificar las entradas y las
páginas del blog.
4. Multimedia:
1. La Librería multimedia es una de las secciones más logradas del blog, donde
podemos cargar archivos variados desde nuestro disco duro.
2. En Añadir nuevo cargamos o subimos los nuevos archivos, que pueden ser
imágenes o archivos de texto.
5. Enlaces:
1. Agregar nuevo nos permite crear enlaces a webs que nos interesen.
2. Con Categorías de los enlaces podemos crear categorías que nos permitan
clasificarlos y mostrarlos por separado en el lateral del blog utilizando los
widgets.
6. Páginas:
1. En Añadir incluimos en el blog páginas estáticas, que no se incorporan en el

flujo normal de la portada, y se suelen utilizar como páginas informativas o de
apoyo. Van enlazadas en el lateral o en la cabecera del blog, según el diseño
que hayamos escogido.
7. Calificaciones:

Aquí podemos habilitar la opción de permitir que los lectores califiquen las
entradas, las páginas o los comentarios del blog con varias estrellas que
aparecen encima o debajo de ellas.
8. Encuestas:
En esta sección creamos encuestas que aparecerán en el lateral del blog, las
personalizamos y configuramos sus opciones.
9. Apariencia:
1. En Temas buscamos y elegimos nuevos diseños generales o temas para

nuestro blog.
2. Widgets es una parte fundamental de la administración del blog, porque nos
permite añadir a la barra o barras laterales de nuestro blog un conjunto de
elementos propios de los blogs, generalmente de carácter informativo e
interactivo.
3. Menús nos permite crear nuevos menús para el blog si hemos elegido un tema o
diseño que los incluya.
4. Añadidos son unas opciones especiales que podemos activar para nuestro blog.
5. Con Cabecera podemos personalizar la imagen y el texto de la cabecera del
blog.
6. En Editar CSS, es decir, las hojas de estilo del blog, hay que pagar una cantidad
pequeña de dinero, pues esta posibilidad permite cambiar todo el diseño del
blog.
10. Usuarios:
1. En Usuarios se incluyen todos los usuarios del blog, y los administradores del
blog pueden cambiar el perfil de los usuarios según las acciones que se les
permitan.
2. Con Invita podemos enviar por e-mail invitaciones a personas que queramos
que participen en el blog.
3. En Mi perfil cada usuario puede incluir o modificar información sobre su
persona.
4. En Configuración personal se permite a cada usuario personalizar el blog.
11. Herramientas:
1. En Herramientas tenemos una serie de recursos para el blog.

2. Con Importar podemos importar todos los datos de un blog creado en otra
plataforma para incorporarlo a un nuevo blog de WordPress.com.
3. Con Exportar podemos crear una copia de los datos de nuestro blog como copia
de seguridad o para incluirlos en otro blog de WordPress.com.

FUNDAMENTO TEÓRICO
Redes de Computadoras
Una red de computadoras, es un conjunto de equipos informáticos conectados

entre sí por medio de dispositivos físicos que envían y reciben impulsos
eléctricos, ondas electromagnéticas o cualquier otro medio para el transporte de
datos con la finalidad de compartir información y recursos.
Tipos de redes
las clases de red según su tamaño o ámbito que abarquen, se pueden clasificar dela
siguiente manera:
 LAN: (Local Área Network) Es una red que se limita a un área geográfica
relativamente pequeña
 WAN: Redes de área muy extensa (Wide Área Network) Los Ordenadores están
ubicados en distintos puntos geográficos, unirlos mediante los servicios
prestados por una Compañía Telefónica.
 MAN: (Metropolitan Área Network) Es una red de tamaño intermedio, en este
caso el tamaño de la red se limita a un área geográfica más grande, por ejemplo
una ciudad.
Componentes básicos de una Red

Una red de computadoras consta tanto de hardware como de software. En el
hardware se incluyen: estaciones de trabajo, servidores, tarjeta de interfaz de
red, cableado y equipo de conectividad. En el software se encuentra el sistema
operativo de red (Network Operating System, NOS).
Estaciones de trabajo
Cada computadora conectada a la red conserva la capacidad de funcionar de
manera independiente, realizando sus propios procesos. Asimismo, las

computadoras se convierten en estaciones de trabajo en red, con acceso a la

información y recursos contenidos en el servidor de archivos de la misma.
Servidores
Son aquellas computadoras capaces de compartir sus recursos con otras. Los
recursos compartidos pueden incluir impresoras, unidades de disco, CD-ROM,
directorios en disco duro e incluso archivos individuales. Los tipos de servidores
obtienen el nombre dependiendo del recurso que comparten. Algunos de ellos
son: servidor de discos, servidor de archivos, servidor de archivos distribuido,
servidores de archivos dedicados y no dedicados, servidor de terminales,
servidor de impresoras, servidor de discos compactos, servidor web y servidor
de correo.
Tarjeta de Interfaz de Red

Para comunicarse con el resto de la red, cada computadora debe tener instalada
una tarjeta de interfaz de red (Network Interface Card, NIC). Se les llama
también adaptadores de red o sólo tarjetas de red. En la mayoría de los casos, la
tarjeta se adapta en la ranura de expansión de la computadora. La tarjeta de
interfaz obtiene la información de la PC, la convierte al formato adecuado y la
envía a través del cable a otra tarjeta de interfaz de la red local. Esta tarjeta
recibe la información, la traduce para que la PC pueda entender y la envía a la
PC.
Cableado
La LAN debe tener un sistema de cableado que conecte las estaciones de
trabajo individuales con los servidores de archivos y otros periféricos. Si sólo
hubiera un tipo de cableado disponible, la decisión sería sencilla. Lo cierto es
que hay muchos tipos de cableado.
 Cable de par trenzado: Es con mucho, el tipo menos caro y más común de
medio de red.
 Cable coaxial: Es tan fácil de instalar y mantener como el cable de par trenzado,
y es el medio que se prefiere para las LAN grandes.
 Cable de fibra óptica: Tiene mayor velocidad de transmisión que los anteriores,
es inmune a la interferencia de frecuencias de radio y capaz de enviar señales a
distancias considerables sin perder su fuerza. Tiene un costo mayor.
Equipo de conectividad
Existen varios dispositivos que permiten conectar y extienden la longitud de la
red, donde cada uno tiene un propósito específico. Sin embargo, muchos
dispositivos incorporan las características de otro tipo de dispositivo para
aumentar la flexibilidad y el valor: Entre ellos tenemos a los Hub, Switch, Router,
etc-

Sistema Operativo de Red

Después de cumplir todos los requerimientos de hardware para instalar una LAN,
se necesita instalar un sistema operativo de red (Network Operating System,
NOS), que administre y coordine todas las operaciones de dicha red. Los
sistemas operativos de red tienen una gran variedad de formas y tamaños,
debido a que cada organización que los emplea tiene diferentes necesidades.
Algunos sistemas operativos se comportan excelentemente en redes pequeñas,
así como otros se especializan en conectar muchas redes pequeñas en áreas
bastante amplias.
Modelo se Referencia OSI

La Organización Internacional para la Normalización (ISO) Crea un modelo de
red para que fuera asumido por los fabricante de redes e implementaran ese
modelo en sus redes, esto sucede hacia el año 1984.
Estamos entonces ante las redes OSI y ante un estándar que como vamos a
analizar divide la red en siete capas.
Se establece que la información que viaja por la red se denomina paquete, datos
o paquete de datos, tenemos ya una unidad de información, pero esta unidad o
paquete de datos, que fluye por la red de un elemento (origen) a otro (destino)
necesita de otros
elementos que aseguren su correcto envío y recibimiento por el destinatario, algo
que a su vez tendrá que saber el emisor del paquete para ser este reenviado
caso de no ser recibido por su destinatario, o haber sido recibido erróneamente.

Al conjunto de todas las capa se le denomina Pila, si imaginamos un usuario que

envía un mensaje por ejemplo con Outlook, como herramienta de interfaz esta
actividad se produce en la capa siete, capa de aplicación, pero este mensaje
habrá de pasar por toda la pila. Cada capa va a efectuar su cometido y
proporcionar los servicios específicos relacionados con el tipo de comunicación a
establecer o le dará una determinada forma a los datos. Cada capa va
añadiendo al dato una señal o etiqueta para confirmar que por allí paso y fue
correcta, la única capa que no puede añadir o alterar nada es la capa física,
pues bien el dato más esta señal, añadida por las distintas capas es lo que se
llama trama.

Modelo se Referencia TCP-IP

El TCP/IP podemos considerarlo como la base de Internet puesto que enlaza
computadoras centrales sobre grandes redes de área local y de áreas extensas,
este protocolo PCP/IP fue demostrado por primera vez en el año 1972, por el
Departamento de la Defensa de Estados Unidos que fue quien lo desarrollo. Al
igual que el protocolo OSI que vimos anteriormente TCP/IP está formado
también por capas.
 Capa de aplicación. La unidad de dato manejada por esta capa se denomina

mensaje, la integran las aplicaciones o Programas, procesos, protocolos y
servicios tales como: FTP (Transferencias de fichero), SMTP (Correo
electrónico), HTTP (Navegación Web), TELNET (Comunicación con otro Host)
 Transporte. Es la responsable del transporte de los mensajes creados en el

nivel de aplicación, está compuesto por los protocolos : TCP (Transmisión
Control Protocol) , UDP (Users Datagram Protocol) . Tanto TCP como UDP
pueden aceptar los mensajes que le llegan e la capa de aplicación y estos son
segmentados en unidades más pequeñas a las que se les añade una cabecera
de información en la que se incluyen códigos capaces de identificar los procesos
de aplicación de extremo a extremo. En el transporte realizado por TCP existe
un control de errores físico, detecta y repara si un segmento ha cambiado
físicamente algún bit y a nivel lógico detecta y corrige segmentos perdidos o
desordenados.
 Internet. Esta capa denominada también de Red es la encargada del

encaminamiento de los segmentos TCP y de los datagramas UDP que fueron
generados como vimos en la capa de transporte. Es en esta capa donde se
ejecuta el protocolo denominado IP (Internet Protocol). IP admite los segmentos
TCP o los datagramas UDP y les añade una cabecera, al unir esta cabecera la
unidad resultante se le denomina datagrama IP o para mejor identificarlos se les
llama paquetes IP.
 Interface de Red. Esta capa es la responsable de intercambiar datagramas IP

de dos unidades contiguas, este es el nivel de Software más bajo de la
arquitectura del Protocolo TCP/IP, al igual que otras capas a los datagramas IP
les añade una cabecera de información de control para su transmisión en una
determinada red, una vez añadida esta cabecera el datagrama IP, pasa a
llamarse trama, encapsulando una trama por cada datagrama IP.

Topología de redes
Definimos Topología de red, como la forma en la que están distribuido los

distintos nodos o PC y la cadena que usan para comunicarse entre ellos.los
distintos tipos de topología son los siguientes:
Red Bus. En este tipo de red cada PC está conectado a un segmento común del
cable de red. Una linea va desde un extremo a otro de la red y a el van
conectados los distintos nodos (PC) que integran dicha red.
Red Estrella. Tal vez la topología más antigua la forma de envío y recepción de
mensajes puede asemejarse a la de un sistema telefónico, ya que en la
topología de este tipo de red todos los mensajes han de pasar por un dispositivo
central, donde confluyen todas las conexiones y que se denomina concentrador.
Red Anillo. En este tipo de Red los nodos o PC se colocan formando un círculo
lógico. Hay que tener en cuenta que en este tipo de red los mensajes circulan
solo en una dirección. En algunos casos pueden hacerlo en ambas direcciones
pero nunca simultáneamente.
Una red esta compuestas por muchos componentes todos ellos diferentes,
recordemos tarjetas, cables conectores, concentrador y PC. Los tres estándares
más generalizados de arquitectura de red son ARCnet, Ethernet y Token Ring,
estos estándares están respaldados por el organismo IEEE (Instituto de
Ingenieros Eléctricos y Electrónicos) ARCnet es un estándar del ANSI (Instituto
Nacional de Estándares Americanos). Los mencionaremos a continuación:
REDES ARCnet. Nace sobre los años setenta elaborada por Datapoint
Corporation, es un estándar aceptado por la industria, aun cuando no lleva
número de estándar de IEEE. Si fue reconocido por ANSI. Soporta una velocidad
de 2,5 Mbps. ARCnet usa una topología lógica de bus y física parecida a la de
estrella. Cada nodo está conectado a un concentrador, en este tipo de estándar
no se dan colisiones por lo que es más difícil que se dé la saturación de red.
Estas dos características la hicieron ser durante un tiempo el estándar para
Redes Lan, pero fue desplazada por Ethernet dado que esta última daba los 10
Mbps. Frente a los 2,5 Mbps que ofrecía ARCnet.

REDES Ethernet . Esta arquitectura es el estándar IEEE 802.3 es el estándar

mas popular de Lan se conoce como 802.3 Emplea una topología lógica de de
bus y una topología física de estrella o de bus, como hemos dicho en el punto
anterior que su velocidad es de 10 Mbps, utiliza el método de transmisión
(CSMA/CD) Acceso Múltiple con Detección de Portadora y Detección de
Colisiones.
REDES Token Ring. Es el estándar IEEE 802.5 creado por la firma IBM, este
estándar acepta velocidades de 4 Mbps, o 16 Mbps. Aquí se emplea una
topología lógica de anillo y una topología física de estrella, cada PC se conecta
mediante u cable a un HUB central llamado unidad de acceso multiestaciones
(MAU). Dato que cada nodo Token Ring examina y luego retransmite cada token
(señal), esto hace que si hay en la red un nodo con mal funcionamiento puede
hacer que la red no funcione. Este tipo de arquitectura de red es aconsejable en
aquellas redes con un tráfico muy intenso.
Direccionamiento IP
La IP es un número que identificará cada interfaz de un dispositivo, como
computadoras, impresoras, cámaras, reveladoras de imágenes, que posen
también, un interfaz que puede identificarse por una IP, La IP establece
igualmente una jerarquía dentro de la red, nunca podrá existir dentro de una
misma red dos dispositivos con un mismo número de IP. Ya que una de la
finalidad de dicha IP es identificar de forma univoca cada interfaz de la red .
Lógicamente este tipo de identificación lo usaran las redes basadas en el
protocolo IP (Internet Protocol) que corresponde, como hemos estudiado a la
capa tres llamada Internet o de red del protocolo TCP/IP.
Las direcciones IP pueden clasificarse en dos tipos Dinámicas y Fijas.
 IP Dinamica. Es utilizada generalmente en los Hogares, existe un router que

mediante un servidor de DHCP (Dinamic Host Configurations Protocol) que se
encarga entre otras cosas, de en ir asignando una IP a cada elemento que se va
conectando, que al ser apagado y s. er vuelto a conectar la asignará la que le
corresponda en ese momento, es decir la IP es cambiante o Dinámica.
Otro ejemplo es para conectarnos a Internet necesitamos de una IP, cada vez
que entramos y esto no lo nota el usuario se asigna una IP al desconectarnos la
perderíamos, y al entrar nuevamente nos asignaría otra luego la IP es también
cambiante o Dinámica.
 IP Fija. Es usada en un servidor instalado en una empresa o por usuarios que
deberá contratar con la empresa que le suministra el servicio de ADSL una IP
Fija, este tipo de IP tiene un valor adicional. Al contratar este Servicio nuestra IP
ya no cambiaria cada vez que entremos en Internet.

No debe confundirse la IP Dinámica y la IP Fija los términos privado y público.

En un entorno de red, cuatro computadoras en red con salida a Internet, cada
configuración IP podríamos asignarla nosotros y esas IP a nivel privado no
cambiarán, pero al salir a Internet se le asignaría en cada momento una IP
publica y variable con cada entrada, si queremos evitar este cambio y salir
siempre con la misma IP tendremos que tener una IP Fija.
Representación de una IP.

Una IP. Se representa por ejemplo así: 192.168.1.1 cada grupo de puede tener
un máximo de tres dígitos, formando una cifra que pueden ir del rango
comprendido entre 0 y 255 va separado por un “.” , recibe el nombre de octeto,
cada dirección IP la componen cuatro Octetos.
La Internet Corporation for Assigned Names and Numbers (ICANN): es la
organización u organismo que se encarga de regular y proporcionar los rangos
de IP para que de esa forma se respeten dichas numeraciones a nivel mundial,
de lo contrario entraríamos en un caos total.
Pues bien este organismo estable tres clases de red según su rango de IP y son:
 Clase A. el primer octeto identifica a la red los tres octetos restantes, 24 bit se
asignan l los distintos hosts.
 Clase B. en este caso la red se identifica mediante los dos primeros octetos
dejando los otros dos octetos 16 bit para asignar a los hosts.
 Clase C. son los tres primeros octetos los que identifican a la red, dejando un
único octeto 8 bit para asignar a los hosts
Dirección MAC
En las redes la dirección MAC (Media Access Control address o dirección de
control de acceso medio) es un identificador de 48 bits (6 bytes) que
corresponde de forma única a una tarjeta o interfaz de red. Es individual, cada
dispositivo tiene su propia dirección MAC determinada. No todos los protocolos
de comunicación usan direcciones MAC, y no todos los protocolos requieren
identificadores globalmente únicos.
Las direcciones MAC son únicas a nivel mundial, puesto que son escritas
directamente, en forma binaria, en el hardware en su momento de fabricación. La

dirección. Se conoce también como la dirección física en cuanto identificar

dispositivos de red.
El Internet Protocol version 4 (IPv4)
Es la cuarta versión del protocolo Internet Protocol (IP), y la primera en ser

implementada a gran escala. IPv4 usa direcciones de 32 bits, muchas de las
cuales están dedicadas a redes locales LAN, por el crecimiento enorme que ha
tenido Internet (mucho más de lo que esperaba, cuando se diseñó IPv4,
Esta limitación ayudó a estimular el impulso hacia IPv6, que está actualmente en
las primeras fases de implantación, y se espera que termine reemplazando a
IPv4. Actualmente no quedan direcciones IPv4 disponibles para compra, por
ende se está en la forzosa y prioritaria obligacion de migrar a IPv6, Los sistemas
operativos Windows Vista, 7, Unix/like (Gnu/linux, Unix, Mac OSX), BSD entre
otros, tienen soporte para IPv6,
Buscar mi IP Publica
Para buscar la dirección IP que proporciona nuestro proveedor de servicios de

Internet debemos entrar a la siguiente dirección http://whatismyipaddress.com,
aparecerá la siguiente información
La búsqueda la realizamos desde una computadora con servicio de internet

Claro Móvil, serán otros los datos si estamos conectados con otra empresa de
servicios.

Asignación de direcciones IP
La dirección IP puede ser asignada de tres maneras
 Manualmente, en este caso al servidor de DHCP se le pone a su disposición

una tabla que relaciona cada Mac con una dirección IP , lógicamente tabla que
ha sido creada por el administrador o persona que ha configurado la red, en este
caso solo dispositivos que su MAC se encuentra en la tabla recibiera del DHCP
la IP correspondiente.
 Automáticamente. En este caso el DHCP va tomando la primera IP libre del
rango previamente establecido y se la asigna permanentemente la que en cada
momento corresponde.
 Dinámicamente este es el único método que posibilita la opción de reutilizar una
IP, el administrador de la red, o en su defecto quien la ha diseñado asigna un
rango de IP para el DHCP y cada PC tiene un software TCP/IP configurado para
solicitar al servidor de DHCP una IP.
Mascara de RED
Es la combinación de bits que se usa para identificar qué parte de una dirección
se refiere a la red o subred y qué parte se refiere al host. Esto permite que el
protocolo de comunicaciones conocido como TCP/IP, pueda saber si una
dirección IP asociada a una computadora pertenece a una red u a otra.
Mediante la máscara de red un PC un Router podrá saber si debe enviar los
datos dentro o fuera de la red. Por ejemplo, si el Router tiene la IP 192.168.1.1 y
máscara de red 255.255.255.0, entiende que todo lo que se envía a una IP que

empiece por 192.168.1 va para la red local y todo lo que va a otras IP, para fuera
(Internet o otra red local mayor)
Domain Name System DNS

Es una base de datos distribuida y jerárquica que almacena información
asociada a nombres de dominio en redes como Internet. Como base de datos el
DNS es capaz de asociar diferentes tipos de información a cada nombre, los
usos más comunes son la asignación de nombres de dominio a direcciones IP y
la localización de los servidores de correo electrónico de cada dominio.
La asignación de nombres a direcciones IP es ciertamente la función más
conocida de los protocolos DNS. Por ejemplo, si la dirección IP del sitio
www.senati.edu.pe tiene la IP. 200.48.85.196 la mayoría de la gente para hacer
un ping, o entrar en Senati, pondrá mejor el nombre y no la IP del sitio, será más
fácil de recordar y con menos posibilidad de equivocación, independientemente
que esa IP puede cambiar por alguna razón no así el nombre.
Puerta de Enlace Gateway

Una puerta de enlace o Gateway es un equipo o elemento que perteneciendo a
la red está configurado para dotar a los PC que integran dicha red puedan salir al
exterior, generalmente realizando para ello operaciones de traducción de
direcciones IP (NAT: Network Address Translation). A esta capacidad de
traducción de direcciones permite aplicar una técnica llamada Enmascaramiento
de IP, usada muy a menudo para dar acceso a Internet a los equipos de una red
de área local compartiendo una única conexión a Internet, y por tanto, una única
dirección IP externa o podría decirse una dirección pública. Generalmente un
Gateway o puerta de enlace es un Router (Esa función la podría hacer
igualmente un PC) . A la dirección IP de ese Router o PC es a lo que se le
denomina puerta de enlace.
Igualmente veremos que tendremos que indicar las DNS de nuestro ISP, para tal
fin cada compañía que presta Servicio ADSL nos facilita la configuración de DNS
(una primaria y otra secundaria o alternativa)
HERRAMIENTAS DE DIAGNÓSTICO.
Existe un proceso ordenado para intentar solucionar los problemas en TCP/IP.

Vamos a ver el proceso y a recordar las utilidades de Windows para los
problemas en TCP/IP.
Solucionar un problema es fácil cuando podemos identificar su origen. Los

problemas basados en TCP/IP pueden ser agrupados en las categorías que
vamos a listar en la siguiente tabla:

 Configuración. El host no quiere inicializarse o uno de los servicios no quiere

arrancar.
 Direccionamiento IP. No se es capaz de comunicar con otros hosts.
 Subnetting. Podemos hacer un ping a las estaciones de trabajo, pero no

somos capaces de acceder a hosts remotos ni locales.
 Resolución de direcciones. Podemos hacer ping a nuestro PC. Pero no a otros

hosts.
 Resolución NetBIOS. Podemos acceder al host por dirección IP, pero no

podemos establecer una conexión con el comando net.
 Resolución Host name. Podemos acceder a un host por su dirección IP, pero
no por su nombre de host.
Windows incluye varias utilidades que nos pueden ayudar para la solución de
problemas TCP/IP veremos algunas:
 PING Verificar que el TCP/IP está correctamente configurado y que los otros
hosts están disponibles.
 ARP. Ver la caché ARP para detectar entradas inválidas.
 NETSTAT. Nos muestra estadísticas de los protocolos y el estado actual de las

conexiones TCP/IP.
 NBTSTAT. Ver en estado de la conexiones actuales NetBIOS sobre TCP/IP,

actualizar el caché LMHOSTS, o determinar nuestro nombre registrado y ‘scope’.
(alcance).
 IPCONFIG. Verificar la confioguración TCP/IP, incluyendo las direcciones de los

servidores DHCP y WINS.
 TRACERT. Verificar el camino a un host remoto.
 ROUTE . Ver o modificar la actual tabla de rutas.
 NSLOOKUP. Ver información desde los servidores de nombres DNS.
 HOSTNAME: Muestra el nombre del equipo

 NSlOOKUP: utilizado para saber si el DNS está resolviendo correctamente los
nombres y las IP
Editor de Registro Ver y editar los parámetros de configuración.

Servicios en Internet
Dominio de Internet
Un dominio de Internet es una red de identificación asociada a un grupo de
dispositivos o equipos conectados a la red Internet. El propósito principal de los
nombres de dominio en Internet y del sistema de nombres de dominio (DNS), es
traducir las direcciones IP de cada nodo activo en la red, a términos
memorizables y fáciles de encontrar. Sin la ayuda del sistema de nombres de
dominio, los usuarios de Internet tendrían que acceder a cada servicio web
utilizando la dirección IP del nodo (por ejemplo, sería necesario utilizar
http://192.0.32.10 en vez de http://example.com).
Dominios de nivel superior

Cuando se creó el Sistema de Nombres de Dominio en los años 80, el espacio de
nombres se dividió en dos grandes grupos. El primero incluye los dominios,
basados en los dos caracteres de identificación de cada territorio de acuerdo a
las abreviaciones del ISO-3166. (Ej. *.do, *.mx) y se denomina ccTLD (Dominio
de nivel superior de código de país ó Country Code Top level Domain), los
segundos, incluyen un grupo de siete dominios de primer nivel genéricos,
(gTLD), que representan una serie de nombres y multi-organizaciones: GOV,
EDU, COM, MIL, ORG, NET e INT.
Buscar un dominio
Existen muchos lugares en el internet donde podemos buscar si un dominio
existe, el nombre del titular y el tiempo de vigencia que tendrá, podemos entrar
al sitio: http://who.is y colocar el nombre de dominio que queremos buscar, por
ejemplo vamos a buscar el sitio web: www.technobot,org

Después de presionar el botón Who.is Search aparecerá una ventana con los
datos del dominio que estamos buscando.
Los dominios basados en ccTLD son administrados por organizaciones sin fines
de lucro en cada país, delegada por la IANA y o ICANN para la administración de
los dominios territoriales
Ejemplos de nombres de dominio
 .es, para servicios de España

 .gt, para servicios de Guatemala
 .eu, la región de Europa
 .cr, para servicios de Costa Rica
 .ru, para servicios de Rusia
 .fr, para servicios de Francia
 .do, para servicios de República Dominicana

 .hn, para servicios de Honduras

 .mx, para servicios de México
 .sv, para servicios de El Salvador
 .cl, para servicios de Chile
 .co, para servicios de Colombia
 .cn, para servicios de China
 .ar, para servicios de Argentina
 .bo, para servicios de Bolivia
 .ec, para servicios de Ecuador
 .py, para servicios de Paraguay
 .pe, para páginas de Perú
 .uy, para servicios de Uruguay
 .ve, para servicios de Venezuela
 .asia, la región de Asia
 .lat, la región de Latinoamérica
 .edu, para servicios de Educación
 .gov y .gob, para Gobierno y Entidades Públicas
 .info, para Información
 .xxx, para industria pornográfica
 .int, para Entidades Internacionales, organizaciones como la ONU

 .jobs, para Departamentos de empleo y recursos humanos en empresas
 .mil, para el Departamento de Defensa de los Estados Unidos (Único país con
dominio de primer nivel para el ejército)
 .mobi, para empresas de telefonía móvil o servicios para móvil.
 .museum, para los Museos
 .name, para Nombres de personas
 .net, para Infraestructura de red
 .org, para organizaciones
 .pro, para profesionales con una titulación universitaria.
 .tel, para servicios de comunicación por Internet
 .travel, para páginas de la industria de viajes y turismo.
 .fm, para páginas del país Estados Federados de Micronesia, pero usado
también para estaciones de radio de frecuencia modulada
 .tv, para páginas del país Tuvalu, pero usado también para estaciones de
televisión
 .tk, para páginas del país Tokelau; sin embargo se usan también como dominio y
servidor propio ( "Autónomas" ). Actualmente pueden obtenerse de forma
gratuita.
 .com, son los dominios más extendidos en el mundo. Sirven para cualquier tipo
de página web, temática, persona o entidad.
 .biz prevista para ser usado por negocios.

 .web es un dominio de internet de nivel superior, no oficial, que lleva propuesto

desde 1995.
Organizaciones relacionadas con los dominios de Internet
IANA
IANA es la Autoridad para la Asignación de Números de Internet (del Inglés:
Internet Assigned Numbers Authority), responsable de la coordinación global de
los protocolos de Raíz DNS, direccionamiento IP y otros recursos del Protocolo
de Internet
ICANN y la asignación oficial

La Corporación de Internet para la Asignación de
nombres y números de Dominios (del Inglés:
Internet Corporation for Assigned Names and
Numbers) es una organización sin fines de lucro
que opera a nivel de asignar espacio de
direcciones numéricas de protocolo de Internet
(IP), identificadores de protocolo y de las
administración del sistema de servidores raíz.
Aunque en un principio estos servicios los desempeñaba Internet Assigned
Numbers Authority (IANA) y otras entidades bajo contrato con el gobierno de
EE.UU., actualmente son responsabilidad de ICANN.
LATINOAMERICANN
LatinoamerICANN es una organización para la difusión de información y diálogo
en temas de Nombres de Dominio, Números IP y Gobierno o Gobernanza de
Internet en América Latina y el Caribe. Su misión asimismo es la de colocar
información en español, portugués y francés de acceso para todos, considerando
que la información en los idiomas de la región resulta siendo un elemento para
poder comprender los fenómenos propios del Internet, desde una perspectiva
regional en el contexto global
LACLTD
LACTLD es una organización sin fines de lucro que busca agrupar a los
administradores de los ccTLDs de América Latina y el Caribe, con el objeto de
Coordinar políticas en conjunto, así como estrategias de desarrollo de los
nombres de dominio a nivel regional; representar los intereses conjuntos de sus
miembros ante organismos pertinentes; promover el desarrollo de los ccTLDs de
la región; fomentar la cooperación y el intercambio de experiencia entre sus

miembros, en todos los aspectos necesarios para el adecuado funcionamiento

de los ccTLDs y establecer lazos de colaboración con las organizaciones
análogas de otras regiones del mundo.
INTERNIC
InterNIC es un servicio y marca registrada del Ministerio de Comercio de los
Estados Unidos de América y licenciado a IANA para la gestión de disputas
públicas relacionadas con el registro de nombres de dominios.
LACNIC
LACNIC es la organización para el Registro de Direcciones de Internet para
América Latina y el Caribe. Su objetivo es la construcción y articulación de
esfuerzos colaborativos para el desarrollo y estabilidad de Internet en América
Latina y el Caribe. [4]. Si bien no tiene relación directa con los dominios, sí es la
organización regional a cargo de los recursos de Internet como Direcciones IP y
ASNs.
Alojamiento web
El alojamiento web (en inglés web hosting) es el servicio que provee a los
usuarios de Internet un sistema para poder almacenar información, imágenes,
vídeo, o cualquier contenido accesible vía web. Es una analogía de "hospedaje o
alojamiento en hoteles o habitaciones" donde uno ocupa un lugar específico, en
este caso la analogía alojamiento web o alojamiento de páginas web, se refiere
al lugar que ocupa una página web, sitio web, sistema, correo electrónico,
archivos etc. en internet o más específicamente en un servidor que por lo
general hospeda varias aplicaciones o páginas web. Las compañías que
proporcionan espacio de un servidor a sus clientes se suelen denominar con el
término en inglés web host.
El hospedaje web aunque no es necesariamente un servicio, se ha convertido en

un lucrativo negocio para las compañías de internet alrededor del mundo

Tipos de alojamiento web en Internet
Alojamiento gratuito
El alojamiento gratuito es extremadamente limitado cuando se lo compara con el
alojamiento de pago. Estos servicios generalmente agregan publicidad en los
sitios y tienen un espacio y tráfico limitado.
Alojamiento compartido
En este tipo de servicio se alojan clientes de varios sitios en un mismo servidor,
gracias a la configuración del programa servidor web. Resulta una alternativa
muy buena para pequeños y medianos clientes, es un servicio económico debido
a la reducción de costos ya que al compartir un servidor con cientos miles o
millones de personas o usuarios el costo se reduce dramáticamente para cada
uno, y tiene buen rendimiento.
Entre las desventajas de este tipo de hospedaje web hay que mencionar sobre
todo el hecho de que compartir los recursos de hardware de un servidor entre
cientos o miles de usuarios disminuye notablemente el desempeño del mismo.
Es muy usual también que las fallas ocasionadas por un usuario repercutan en
los demás por lo que el administrador del servidor debe tener suma cautela al
asignar permisos de ejecución y escritura a los usuarios. En resumen las
desventajas son: disminución de los recursos del servidor, de velocidad, de
desempeño, de seguridad y de estabilidad.
Alojamiento de imágenes
Este tipo de hospedaje se ofrece para guardar imágenes en internet, la mayoría
de estos servicios son gratuitos y las páginas se valen de la publicidad colocadas
en su página al subir la imagen, entre ellos se puede mencionar: Picasa, Flikr,
etc
Alojamiento revendedor (reseller)

Este servicio de alojamiento está diseñado para grandes usuarios o personas
que venden el servicio de hospedaje a otras personas. Estos paquetes cuentan
con gran cantidad de espacio y de dominios disponibles para cada cuenta.
Servidores virtuales (VPS, Virtual Private Server)

La empresa ofrece el control de una computadora aparentemente no compartida,
que se realiza mediante una máquina virtual. Así se pueden administrar varios
dominios de forma fácil y económica, además de elegir los programas que se
ejecutan en el servidor. Por ello, es el tipo de producto recomendado para
empresas de diseño y programación web.

Servidores dedicados
Un servidor dedicado es una computadora comprada o arrendada que se utiliza
para prestar servicios dedicados, generalmente relacionados con el alojamiento
web y otros servicios en red. A diferencia de lo que ocurre con el alojamiento
compartido, en donde los recursos de la máquina son compartidos entre un
número indeterminado de clientes, en el caso de los servidores dedicados,
generalmente es un sólo cliente el que dispone de todos los recursos de la
máquina para los fines por los cuales haya contratado el servicio.
La principal desventaja de un servidor dedicado es el costo del servicio, el cual
es muy superior al del alojamiento compartido. Esto debido principalmente al
costo mensual de la máquina y la necesidad de contratar los servicios para la
administración y configuración del servidor.
Formas de obtener
Por lo general, se distingue entre servicios de pago y servicios gratuitos.
Servicios de pago
Este tipo de obtención, por lo general viene dado por el contrato de un proveedor
de internet, el cual junto con dar conexión, entre la posibilidad de
almacenamiento mediante disco virtual o espacio web o combinación de ambos.
Normalmente las transacciones son electrónicas, por tarjeta de crédito o por
sistemas de pagos como PayPal.
Servicios gratuitos
Este tipo de servicio viene dado por la base de ser gratuito, y sin costo alguno al
suscriptor. Sin embargo, quienes usan este servicio, por lo general son páginas
de bajos recursos de mantención o aquellas que los dueños no poseen suficiente
dinero para ser mantenida. Como medio de financiamiento, el servidor coloca
avisos de publicidad de Adsense u otras empresas, haciendo que la página se
llene de publicidad en algún punto.
Otra limitación de estas ofertas es que tiene un espacio limitado y no se puede
usar como almacén de datos, ni pueden alojar páginas subversivas o de
contenido adulto o no permitido.
Buscar Un Proveedor de Servicios Web
Comprar un domino u buscar alojamiento web se puede hacer en empresa

nacionales o extranjeras, pero muy pocas están aprobadas por organizaciones
de Internet para la Asignación de nombres y números de Dominios, en el sitio
http://www.godaddy.com/ podernos adquirir nombre de dominios y Hosting.


3
TAREA
3. Representación de un
problema empleando
algoritmos
En esta tarea realizaremos una introducción a la
metodología de la programación, con el objetivo de
proporcionar al aprendiz los procedimientos y técnicas para
el desarrollo de programas. Los programas se escriben con
la finalidad de resolver problemas, con ayuda de las
computadoras, analizaremos el problema en cuestión y la
obtendremos, su algoritmo. Comenzaremos con ejemplos
básicos hasta llegar a los métodos y etapas a seguir para
obtener una aplicación informática. Los conceptos que
veremos son fundamentales para realizar un programa y una
fundamentación de la programación estructurada, más allá
de la sintaxis de un lenguaje de programación
especifico.

 Software libre para representación de algoritmos DFD
 Instalación del programa DFD para diagramas de Flujo
 Programación y análisis de problemas representando su solución mediante
diagramas de Flujo
Representación de problemas con

Algoritmos.
3.1 Obtener el promedio de dos
números enteros
Realizar el algoritmo para un programa que nos permita
ingresar dos números enteros y obtener el promedio de
los mismos, el resultado deberá ser mostrado en una
función de salida
Solución
Para resolver este programa primero debemos hacer el

pseudocódigo, luego el diagrama de flujo:
Pseudocódigo
1. INICIO
2. Solicitar el ingreso de datos
3. Ingresar DATO1
4. Ingresar DATO2
5. Efectuar la operación de SUMA y luego PROMEDIO, luego guardar el valor
obtenido en la variable RESULTADO
6. Mostrar el resultado en una venta de SALIDA
7. FIN.

Programa
Solicitar el ingreso de datos empleando la función SALIDA y escribir el texto

‘ingresar números’
Ingresar las variables DATO1, DATO2 con la función de LECTURA
Efectuar la operación de promedio con la función ASIGNACION, luego guardar el

resultado en la variable RESULTADO (recordar que se puede ingresar hasta 3
operaciones en la función)
Mostrar el resultado con la función SALIDA, en esta función de puede mostrar

caracteres junto a la variable RESULTADO separado por una ‘,’

Seleccionar el comando ejecutar o presionar la tecla F9 para iniciar el programa
3.2 Mostrar el resultado de un examen

Realizar el algoritmo que nos muestre el resultado de un examen, para ello
debemos ingresar la cantidad de respuestas correctas y las
incorrectas, el programa deberá disminuir un punto por
cada respuesta incorrecta al terminar se mostrara el
resultado
Solución

Pseudocódigo
1. INICIO
3. Ingresar RESPUESTAS CORRECTAS, RESPUESTAS
INCORRECTAS
4. Efectuar la operación de SUMA y luego RESTA por
cada respuesta incorrecta, luego guardar el resultado
en una variable
5. Mostrar el resultado en una ventana de SALIDA
6. FIN.
Programa


‘ingresar la cantidad de respuestas correctas e incorrectas’
Ingresar las variables RCOR, RINC con la función de LECTURA
Efectuar la operación de RESTA con la función ASIGNACION, luego guardar el

resultado en la variable RESULTADO

caracteres junto a la variable RESULTADO separado por una ‘,

3.3. Calcular la capacidad de un documento

Realizar el algoritmo que nos muestre la capacidad de un
documento en Mbytes, teniendo en cuenta que debemos dividir el
valor ingresado por 1024, luego el programa deberá mostrara el
resultado en una ventana de SALIDA
Solución

Pseudocódigo
1. INICIO
3. Ingresar de la capacidad del documento y guardarlo en la
variable TAMAÑO
4. Efectuar dividir la variable Tamaño entre 1024, luego guardar
el resultado en una DATO
5. Mostrar el resultado en una ventana de SALIDA
6. FIN.
Programa
‘ingresar el tamaño de un documento en Mbytes’
Ingresar las variables TAMAÑO con la función de LECTURA

Efectuar la división con la función ASIGNACION, luego guardar el resultado en la

variable DATO, estamos asumiendo que la cantidad ingresada esta en Kb

caracteres junto a la variable DATO separado por una ‘,’

Solución de problemas con Algoritmos.
3.4. Calcular la cantidad de discos necesarios para

guardar un documento
Realizar un algoritmo que nos permita calcular
la cantidad de discos necesarios para guardar
un documento, el resultado deberá ser mostrado
en una función de salida
Solución
Para resolver este programa primero debemos

hacer el pseudocódigo, luego el diagrama de
flujo:
Pseudocódigo
1. INICIO
3. Ingresar el dato de la capacidad del documento en la variable TAMAÑO
4. Efectuar la división y determinar la cantidad de discos para guardar el
documento
5. Mostrar el resultado en una venta de SALIDA, si el documento necesita varios
discos indicar la cantidad, en caso contrario indicar que solo necesita un disco
6. FIN.
Programa Solicitar el ingreso de datos empleando la función SALIDA y escribir

el texto ‘Calcular la cantidad de CD’s para guardar un documento para ello ingresar el
tamaño del documento en Bytes’

Ingresar el tamaño del documento en la variable TAMAÑO con la función de

LECTURA
Efectuar la división con la función DECISION, que se determinará si el documento

necesita un disco dividiéndolo por el numero 734003200 que es la capacidad de
un CD
Mostrar el resultado con la función SALIDA, si la función anterior es VERDADERA

la función de salida indicará cuantos discos necesitaremos, pero si la condición es
FALSA la segunda función de salida nos indicara que solo usaremos un disco

3.5. Averiguar si el usuario del programa es mayor

de edad
Realizar el algoritmo para un programa que nos permita ingresar dos números
enteros y obtener el promedio de los mismos, el resultado deberá ser mostrado en
una función de salida
Solución
Para resolver este programa primero debemos hacer el pseudocódigo, luego el

diagrama de flujo:
Pseudocódigo
1. INICIO
3. Ingresar Año actual
4. Ingresar Año de Nacimiento
5. Efectuar la operación de Resta y
determinar si el usuario del
programa es mayor de edad
6. Msotrar en una ventana de
SALIDA si el usuario del
programa es menor o mayor de
edad.
7. FIN

Programa

‘Ingresa el año actual, luego su fecha de nacimiento’
Ingresar el tamaño del documento en las variables AÑO, FNAC con la función de
LECTURA
Efectuar la sustracción con la función DECISION, que se determinará si el usuario

del programa es mayor o menor de edad
Mostrar el resultado con la función SALIDA, si la función anterior es VERDADERA

la función de salida indicará que el usuario es mayor de edad, pero si la condición
es FALSA el usuario es menor de edad

3.6. Determinar la edad del mayor

Realizar el algoritmo que nos permita determinar la edad del mayor de dos
hermanos, este programa también puede determinar si ambos tienen la misma
edad, el resultado será mostrado en una ventana de SALIDA.
Solución

diagrama de flujo:
Pseudocódigo
1. INICIO
2. Solicitar el ingreso de datos:
(Primer hermano, Segundo
hermano)
3. Ingresar la edad del PRIMER
hermano, luego la del
SEGUNDO,
4. Efectuar la operación de
sustracción, si el residuo de esta
división es mayor que cero, el
primer hermano es mayor, luego
mostrar la diferencia en una
ventana de SALIDA
5. Si la condición anterior es
FALSA ( el resultado de la
sustracción en menor que cero) se debe pasar a otro bloque del programa en
la que se evalúa si ambos hermanos tienen la misma edad, si esta condición

es VERDADERA mostrar en una ventana de SALIDA que ambos hermanos

tienen la misma edad, si la condición es FALSA mostrar en una ventana de
SALIDA que el segundo hermano es menor que el primero
6. FIN
Programa
Solicitar el ingreso de datos empleando la función SALIDA y escribir el texto ‘Ingresar

las edades de dos hermanos y determinar cuál es el mayor’
Ingresar las variables en la que se guardaran los datos de las edades de los
hermanos. PHERMANO, SHERMANO
Efectuar la primera DECISION en la efectuamos la primera sustracción, si esta

es mayor que cero el primer hermano es mayor que el segundo

Mostrar en una ventana de SALIDA ‘primer hermano es mayor por:’ acompañado

de la diferencia de edades
Efectuar la segunda DECISION en la efectuamos la segunda sustracción, para

determinar si el segundo hermano tiene la misma edad que el mayor o es menor
Si la anterior condición es VERDADERA (igual a cero), visualizar en una ventana

de SALIDA ‘ ambos hermanos tienen la misma edad’

Si la anterior condición es FLASA (diferente de a cero), visualizar en una ventana

de SALIDA ‘el segundo hermano es mayor’
No debemos olvidar que para ejecutar nuestro algoritmo, seleccionar en la barra

de menú el comando EJECUTAR, o presionar la tecla F9
3.7. Determinar las horas extras trabajadas por una

persona
Realizar el algoritmo que nos permita calcular las horas trabajadas por una
persona de lunes a viernes, se debe considerar que semanalmente el trabajador
debe cumplir con 48 horas de servicio en la empresa, si al finalizar la semana el
trabajador supera estas 48 horas se le deberá pagar un adicional, en caso
contrario se le aplicara un descuento, todos los resultados serán visualizados en
una ventana de SALIDA.
Solución

diagrama de flujo:

Pseudocódigo
1. INICIO
2. Solicitar el ingreso de datos: (horas
trabajadas de lunes a viernes)
3. Ingresar horas trabajadas en la
variables LUN, MAR, MIE, JUE, VIE
4. Efectuar la operación de adición y
guardar el resultado en la variable
HTRABAJADAS
5. Efectuar la de comparación con la
constante 48 para saber si la
persona trabajo horas extras.
6. Si la anterior condición es
VERDADERA indicar que el
trabajador tendrá un pago por horas
extras, acompañado de la cantidad
de horas
7. Si la condición es FALSA indicar que
el trabajados no recibirá ningún pago
por horas extras, acompañado de la
cantidad de horas que serán
descontadas de su sueldo
8. FIN
Programa

las horas trabajadas de lunes a viernes’

Ingresar las variables en la que se guardaran los datos de las horas trabajadas
desde el lunes hasta el viernes en: LUN, MAR, MIE, JUE, VIE.
Efectuar la ASIGNACION guardando la suma de las variables LUN, MAR, MIE,

JUE, VIE en otra nueva variable que denominaremos HTRABAJADAS
Efectuar la primera DECISION comparando la variable HTRABAJADAS con la

constante 48 que la cantidad de horas que debe cumplir en una semana

Si el resultado de la DECISION es VERDADERO, mostrar en una ventana de

SALIDA ‘se debe pagar al trabajador’, acompañado de la sustracción entre
(HTRABAJADAS-48), indicándonos la cantidad de horas que se deberá pagar al
trabajador.
Si el resultado de la DECISION es FALSO, mostrar en una ventana de SALIDA

no se debe pagar al trabajador horas extras, hay que aplicar un descuento por : ’,
acompañado de la sustracción entre (HTRABAJADAS-48), como el resultado es
un valor negativo debemos obtener el valor absoluto agregándole la función ABS

Resuelve problemas empleando lógica

secuencial.
3.8. Mostrar el resultado del incremento de
los N primeros números
Realizar un algoritmo que nos permita mostrar el resultado de los
N primeros números asignados en la variable C que tendrá la
función de CONTADOR
Solución

Pseudocódigo
1. INICIO
3. Ingresar el dato de la variable C en la que guardaremos la
cantidad de veces que se repite el programa (contador)
4. Crear la variable DATO en la que guardaremos el resultado de
las sumas sucesivas.
5. Iniciar el ciclo repetitivo que estará determinado por la variable
contador.
7. Incrementar +1 la variable DATO, el resultado guardarlo en la misma
variable.
8. Mostrar el valor de la variable DATO
9. Registrar el incremento del contador y terminar cuando termine el ciclo
repetitivo, en caso contrario ejecutar el programa nuevamente
10. FIN
Programa
las cantidad de veces que se repetirá la operación’

Ingresar la variable que se empleara como contador del ciclo repetitivo
Efectuar la ASIGNACION guardando en DATO el valor cero que inicializara esta

variable que registrara la suma sucesiva de las operaciones
Inicial el ciclo repetitivo FOR, declarando el inicio del ciclo, final e incremento para
cada repetición

Efectuar la operación de ASIGNACION en la que incrementaremos +1 la variable

DATO, por cada repetición del ciclo la variable incrementara
Visualizar en una ventana de SALIDA el valor de la variable DATO

3.9. Escoger una opción y ejecutar una parte del

programa
Realizar un algoritmo que nos permita ingresar datos para seleccionar una
opción dentro del programa 1- SUMA, 2- RESTA, 3- PRODUCTO, luego
visualizar el resultado en una ventana de SALIDA.
Solución

diagrama de flujo:
Pseudocódigo
1. INICIO
3. Ingresar el dato de las variables A, B
que guardaran los valores de los
números que se manejaran
4. Ingresar el dato de la variable OPCION
para escoger una parte del programa a
efectuar
5. Insertar tres funciones de decisión
para las 3 opciones
1- SUMA, 2- RESTA, 3- PRODUCTO,
si las condiciones son FALSAS,
mostrar en una ventana de salida que
no se escogió una opción apropiada
6. Si las condiciones anteriores son
VERDADERAS derivar cada selección
al procesamiento respectivo 1- SUMA,
2- RESTA, 3- PRODUCTO
7. FIN

Programa
dos números’
Ingresar las variables A, B que almacenará los números que se van a manipular
Ingresar las variables OPCION que almacenará el número para tomar la decisión
referente a la operación a realizar (1- SUMA, 2- RESTA, 3- PRODUCTO)
Efectuar el procedimiento de DECISION en el que preguntaremos si el usuario

escogió la OPCION=1, si es VERDAD se efectuara el procedimiento de suma, si
es FALSO se realizara un nuevo procedimiento.

Insertar los procedimientos para tomar las decisiones referentes a las OPCIONES
2 ,3 como se muestra en el grafico (cascada). En caso que no se cumpla con
ninguna de las opciones, mostrar en una ventana de SALIDA el mensaje: ‘Usted
no ingreso ninguna opción, GRACIAS’
Efectuar la PRIMERRA operación de ASIGNACION (OPCION=1) en la que

efectuaremos la SUMA de las variables A, B y el resultado será depositado en
una nueva variable que llamaremos RESULTADO.
Efectuar la SEGUNDA operación de ASIGNACION (OPCION=2) en la que

efectuaremos la SUSTRACCION de las variables A, B y el resultado será
depositado en una nueva variable que llamaremos RESULTADO.

Efectuar la TERCERA operación de ASIGNACION (OPCION=3) en la que

efectuaremos el PRODUCTO de las variables A, B y el resultado será depositado
en una nueva variable que llamaremos RESULTADO.
Presionar la opción EJECUTAR o la tecla F9 para inicial el programa
FUNDAMENTO TEÓRICO
Concepto de algoritmo
Para que un ordenador pueda llevar adelante una tarea tiene que contar con
un algoritmo que le indique, a través de un programa, que es lo que debe
hacer de manera precisa. Un algoritmo es “una sucesión finita de pasos que se
pueden ejecutar en un tiempo finito”, cuya razón de
ser es la de resolver problemas; por tanto “problema” para nosotros, serán

aquellas cuestiones, conceptuales o prácticas , cuya solución es expresable
mediante un algoritmo.

Resolución de problemas y uso de algoritmos
Antes de entrar en la resolución de un problema, veremos cómo podemos llegar a esta

solución. La experiencia personal de todos nosotros nos dice que la
sistematización para la resolución de problemas no es fácil
Resolución de un problema
Análisis del problema Diseño del algoritmo Programación del algoritmo
A finales de 1940, el matemático G. Poyla propuso una metodología para la resolución

de problemas matemáticos que puede aplicarse a la resolución de problemas usando
algoritmos y se puede dividir en tres fases
1. Análisis del problema

2. Diseño del algoritmo
3. Programación del algoritmo
Análisis del problema

El objetivo del análisis del problema, es ayudar al programador a llegar a
una cierta comprensión de la naturaleza del mismo. Este análisis
supone, en particular, la superación de una serie de pasos
 Definir el problema con total precisión.

 Especificar los datos de partida necesarios para la resolución del mismo
(especificaciones de entrada).
 Especificar la información que debe proporcionarse al resolverse
(especificaciones de salida).

Análisis del problema
Especificaciones de Especificaciones de
Definicion del problema
Entrada Salida
Elaborar el análisis para obtener el área y la longitud de una circunferencia.
 Utilizar las fórmulas del área y la circunferencia en función del radio.

 Las entradas de datos se reducen al dato correspondiente al radio del círculo
y el procesamiento al cual lo someteremos, el tipo de dato debe ser un
número real.
 Las salidas serán dos variables también reales: área y circunferencia.
La finalización de la fase de análisis del problema nos llevaría al siguiente

resultado:
 Entradas: Radio del círculo (variable Radio)

 Salidas: superficie del círculo (variable Área), circunferencia del círculo
(variable circunferencia)
 Variables: Radio, Área, circunferencia
Diseño del algoritmo
Diseñar un algoritmo no es una tarea sencilla y tomara un tiempo el aprender a

diseñar uno. El periodo que existe entre el análisis de un problema y el diseño de su
solución recibe el nombre de periodo de incubación. Para diseñar un algoritmo
debemos tener la de tener ideas, propias o adquiridas, para desarrollar
algoritmos que nos permitan actuar ante los problemas que se nos planteen.
Para diseñar algoritmos debemos indicar de manera precisa el orden de realización de

cada paso, considerando que el problema en cuestión es un proceso finito.

Diseñar un algoritmo que responda a la pregunta: ¿Qué debo hacer para

escoger un determinado producto A,B,C?.
Un primer análisis nos conduce a un esbozo de solución, descomponiéndolo en

cuatro módulos sucesivos
 Ir a la tienta donde se venden los productos A,B,C

 Escoger el producto
 Pagar por el producto
 Regresar a casa
Estos cuatro pasos se pueden refinar un poco más y así este problema lo podríamos
descomponer de la siguiente forma:
 Inicio {algoritmo comprar el producto A,B,C }

 Consultar la catalogo de productos A, B, C, escoger la tienda más cercana.
 Salir de nuestra casa
 Desplazarse hasta la tienda en ingresar
 Preguntar a el vendedor si cuentan con el producto solicitado
 Si el producto existe adquirir la cantidad necesaria
 Si el producto no existe declarar como fracaso esa compra y buscar una nueva
tienda
 Retirarse de la tienda
 Regresar a nuestra casa
 Fin
Programación del algoritmo
Una vez que el algoritmo está diseñado y representado, se debe pasar a la fase
de resolución práctica del problema, Esta fase se descompone a su vez en las
siguientes fase:
1. Codificación en un programa
2. Ejecución en un programa
3. Comprobación del programa

Programación
del algoritmo
Codificación en un Comprobación del

Ejecución en un programa
programa programa
La fase de conversión de un algoritmo en instrucciones de un lenguaje de

programación se denomina codificación. El código deberá estar escrito de acuerdo
con la sintaxis del lenguaje de programación ya que solamente las instrucciones
correctas pueden ser interpretadas por el computador.
Durante el proceso de programación, se debe separar el diseño del algoritmo

de su posterior implementación en un lenguaje de programación específico.
Al llegar a este punto, se supone que el lector conoce al menos un lenguaje de
programación y éste es el momento en el que tiene que mostrar sus habilidades para
efectuar una codificación lo más correcta y eficiente posible.
Tras la codificación del programa, éste deberá ejecutarse en un computador, el

resultado de esta primera ejecución es incierto, ya que existe una alta posibilidad de
que aparezcan errores, bien en la codificación o bien en el propio algoritmo, por
tanto, el paso siguiente consiste en comprobar el correcto funcionamiento del
programa
Representación de algoritmos
Un algoritmo es abstracto y necesita una forma de representación, bien para

comunicarlo a otra persona bien para ayudar a convertirlo en un programa. De hecho,
la codificación en un lenguaje de programación, es una representación muy utilizada
de un algoritmo, sin embargo tiene el inconveniente de que no todas las personas
conocen el lenguaje que se haya elegido. Por ello, existen diferentes métodos
que permiten que se pueda independizar el algoritmo de su correspondiente
codificación. Veamos dos de ellos

Pseudocódigo
El pseudocódigo es un lenguaje de especificación de algoritmos (no de
programación) , con estructuras sintácticas y semánticas, por lo que no puede
ser ejecutado directamente por un computador. El pseudocódigo utiliza para
representar las sucesivas acciones, palabras reservadas en los lenguajes de
programación, tales como start, end, stop, if-then-else, while-do, repeat-until,
(inicio, fin, parar, si-entonces- sino, mientras-hacer, repetir-hasta), etc. Las
ventajas del uso del pseudocódigo son:
 Planificación de un programa; permitiendo que el programador se pueda

concentrar en la lógica y en las estructuras de control y no tenga que
preocuparse, por ahora de detalles acerca de las reglas sintácticas y
semánticas de un lenguaje específico.
 El pseudocódigo es independiente del lenguaje de alto nivel que vaya a
utilizarse, un algoritmo expresado en pseudocódigo puede ser traducido
más fácilmente a muchos lenguajes.
Realizaremos un algoritmo para averiguar si un número es par, será descrito

narrativamente de la siguiente forma: “si dividimos un número entre dos y obtenemos
un residuo igual a 0, entonces el numero es par, si se obtiene otro numero entonces
es impar”, este algoritmo escrito en pseudocódigo sería:
1. Leer N
2. Mientras N>0
3. Hacer N/2
4. Si Q=0 entonces
5. N es par
6. Si no
7. N es impar
8. Fin
Organigramas
Para ganar claridad expositiva se han desarrollado una serie de símbolos
gráficos que permiten representar los algoritmos y que son universalmente
reconocidos. Veamos algunos ejemplos

no
N=0
Leer Dato C= A-10
si
Los organigramas o diagramas de flujo son herramientas gráficas utilizadas tanto para
representar algoritmos, como en la ayuda en el diseño de programas. Están
compuestos por una serie de símbolos, unidos con flechas, donde cada símbolo
representa una acción distinta y las flechas el orden de realización de las acciones.
Cada símbolo, por tanto, tendrá al menos una flecha que conduzca a él y una flecha
que parta de él, exceptuando el comienzo y final del algoritmo. Representación
simbólica de los algoritmos
Terminal: inicio-fin del Condición

algoritmo Lectura: ingreso de
simple. If
datos
Escritura: muestra los

Asignación: procesos
resultados o un mensaje Repeticiones
o instrucciones que
del programador finitas: For-While
realiza el algoritmo
Veremos ahora el ejemplo anterior representado con organigramas:
Inicio
Numero = N
no
N/2=0 N= Impar
si
N= Par
Fin

Estructuras de control
Definiremos como estructuras a las acciones que tienen por objeto marcar el orden de
realización de los distintos pasos de un programa ó algoritmo. Cada estructura
tiene un punto de entrada y uno de salida, lo que facilita la depuración de posibles
errores. Estas son de tres tipos:
 Estructuras secuenciales
 Estructuras selectivas
 Estructuras repetitivas
Estructuras Secuenciales
Son aquéllas en las que una acción (instrucción) sigue a otra de acuerdo con
su orden de escritura. Las tareas se suceden de tal modo que tras la salida (final) de
una se efectúa la entrada (principio) en la siguiente y así sucesivamente hasta el fin
del proceso.
Acción 1
Acción 2
Las estructuras secuenciales se codifican de forma directa en cualquier lenguaje de

programación, pues como sabemos el orden de ejecución de todo programa es
precisamente, salvo orden en sentido contrario, de arriba abajo. A pesar de su
simplicidad, ya sabemos, que algunos problemas se pueden resolver con la
sola utilización de esta estructura.

Estructuras Selectivas
Las estructuras selectivas se utilizan para tomar seleccionar una opción, mejor dicho
para tomar decisiones, de ahí que se suelan denominar también estructuras
alternativas. En estas estructuras se evalúa una condición, especificada mediante
expresiones lógicas, en función de cuyo resultado, se realiza una opción u otra.
Podemos tomar por ejemplo un interruptor o conmutador (switch), que representa un

estado lógico y por tanto puede cambiar de valor a lo largo de la ejecución regulando
el paso a una parte del programa, dependiendo del valor que tome el conmutador.
Estos valores son 1 y 0, de ahí su nombre de interruptor(“encendido”/“apagado”,
“abierto”/“cerrado”).
encendido apagado
Interruptor ?
Acción 1 Acción 2
La estructura alternativa más sencilla, es la llamada simple y se representa por si-

entonces, ejecuta una determinada acción cuando se cumple una cierta condición
y en caso contrario seguir el orden secuencial. La selección si-entonces evalúa la
condición y de acuerdo con su resultado:
 Si es verdadera, entonces ejecuta una o varias acciones .

 Si es falsa, entonces no hace nada y sigue la ejecución normal del
programa, pasando a la instrucción siguiente a la finalización de la
estructura selectiva. Para ello es necesario que ésta venga claramente
delimitada, cosa que se hace en pseudocódigo con fin_si.
Su expresión en Pseudocódigo (para S1 compuesta de varias acciones) es:
1. si <condición> entonces
2. <acciones a realizar>

3. fin_si
Estructuras Repetitivas
Una estructura repetitiva es aquella que realiza las repeticiones de una serie de
acciones basándose en un bucle. De acuerdo con lo anterior, esta estructura debe
constar de tres partes básicas:
 Decisión (para finalizar la repetición)

 Bucle (conjunto de instrucciones que se repiten)
 Salida del bucle (instrucción a la que se accede una vez se decide finalizar)
Los procesos que se repiten varias veces en un programa necesitan contar el

número veces que re repite una operación. Una forma de hacerlo es utilizar una
variable llamada contador, cuyo valor se incrementa o decrementa en una cantidad
constante por cada repetición que se produzca.
En el grafico se presenta un diagrama de flujo para un algoritmo en el que se desea

repetir 100 veces un grupo de instrucciones, que llamaremos cuerpo del bucle, donde
el contador se representa con la variable CONT. La instrucción que actualiza al
contador es la asignación:
CONT ¬ CONT+1.
El contador puede ser positivo (para incrementos de uno en uno) o negativo

(para decrementos de uno en uno),para el ejemplo el contador cuenta desde 1 a 100 y
deja de repetirse cuando la variable CONT toma el valor 101 y termina el bucle.
Otro tipo de variable, normalmente asociada al funcionamiento de un bucle es un

acumulador o totalizador, cuya misión es almacenar una cantidad variable, resultante
de operaciones sucesivas y repetidas. Un acumulador realiza una función parecida a
la de un contador, con la diferencia de que el incremento o decremento, es variable
en lugar de constante.
Representando un problema con Algoritmos

Representar un problema que nos permita realizar la suma de dos números, para ello
utilizaremos un software de distribución libre denominado DFD Software que nos
permitirá diseñar y simular el algoritmo, es decir podremos insertar datos y el
programa nos mostrara el resultado si es correcto, seguiremos los siguientes pasos:
1. Escribir el pseudocódigo. La lista de acciones serán las siguientes:

 Ingresar numero 1
 Ingresar numero 2
 Realizar la operación numero 1 + numero 2
 Mostrar el resultado
 Fin.
2. Diseñar el diagrama de flujo. Iniciamos el programa y seleccionamos en la
barra de menú la opción Archivo/ nuevo, aparecer la ventana que se muestra la
ventana a continuación.
Insertaremos el bloque SALIDA para visualizar un mensaje en el que

solicitaremos los dos números a sumar, después de ingresar el bloque hacer
doble clic sobre el icono en la que aparecerá una ventana para llenar esta
información.

Insertaremos el bloque LECTURA para insertar datos que se van a sumar,

después de ingresar el bloque , haciendo doble clic sobre el mismo aparecerá
una ventana en la que escribiremos el nombre de las variables en la que
escribirán los datos, si queremos ingresar dos datos, estos deberán estar
separados por una coma “,”
Insertaremos el bloque ASIGNACION, que nos permitirá efectuar la operación de

suma, en la ventana de configuración del bloque podemos ingresar hasta 3
asignaciones, el resultado de esta asignación se guardara en una variable, en nuestro
ejemplo se llamara resultado, luego presionar el botón de aceptar.
Insertaremos el bloque DECISIÓN para determinar si el número es mayor que 100,

insertaremos el operador lógico de MAYOR QUE y escogeremos la condición de
VERDAD a la derecha.

Insertaremos el bloques de SALIDA para mostrar el resultado de las operaciones, en

nuestro caso para decir si el número es mayor o menor que 100

4
TAREA
4. Soluciona problemas
empleando lenguajes de
programación
En este capítulo aprenderemos a solucionar la mayoría de
problemas plateados el capitulo anterior empleando un
lenguaje de programación en nuestro caso el Visual Basic,
primero veremos los aspectos de lenguaje y para ellos no
necesitaremos obligatoriamente el uso de formularios, o
controles visuales, solo utilizaremos aplicaciones de consola.
Una aplicación de consola es aquella que se ejecuta dentro de
una ventana de línea de comandos, este tipo de ventana recibe
diferentes denominaciones: Símbolo del sistema, Sesión MS-
DOS, Ventana de línea de comandos, etc. Las aplicaciones de
consola son muy útiles cuando necesitamos realizar pruebas
que no usen el modo gráfico del sistema operativo: formularios,
controles, imágenes, etc., estos consumen pocos recursos.
 Software Microsoft Visual Studio .Net 2008 o superior.
 Instalación del programa Visual Studio .Net 2008
 Programación y solución de problemas empleando VB.NET

Resuelve problemas empleando operadores

matemáticos.
4.1 Obtener el promedio de dos números enteros

Realizar un programa que nos permita ingresar dos números enteros y obtener el
promedio de los mismos, el resultado deberá ser mostrado en la consola del
sistema
Solución
Para resolver este programa primero debemos abrir el programa VB.NET que viene
incluido en la plataforma Visual Studio.Net y al finalizar veremos el resultado en la
aplicación de consola
En el menú Proyecto, hacer clic en agregar nuevo Proyecto, luego escoger la

opción de aplicación de consola.
Iniciaremos el programa creando el procedimiento declarando Sub Main(),
luego las variables de tipo entero dato1, dato2 como tipo entero , resultado
como tipo Double
Mostrar un mensaje en consola mediante Console y el método publico

Writeline() , luego guardar en dato1 un numero escrito por el usuario desde el
teclado

Repetir el mismo procedimiento para la variable Dato2
Guardar en la variable resultado las operaciones asignadas
Mostrar un mensaje en consola mediante Console y el método publico

Writeline() , luego mostrar el contenido de la variable resultado una línea
después del mensaje anterior.
Después de mostrar el resultado, debemos colocar la instrucción

Console.readLine () para que la ejecución de programa se detenga hasta que
el usuario presione Enter.
Finalizar el procedimiento con End Sub, el resultado en consola es es

siguiente

4.2 Calcular el área de un triangulo

Realizar un programa que nos permita Calcular el area de un triangulo
ingresando su Base y altura, el resultado deberá ser mostrado en la consola del
sistema
Solución
Para resolver este programa primero debemos abrir el programa VB.NET que
viene incluido en la plataforma Visual Studio.Net y al finalizar veremos el resultado
en la aplicación de consola


luego las variables de tipo entero AR, BA, AL como tipo entero
Solicitar al usuario del programa que ingrese los datos de Base y Altura
empleando el método publico Console .Writeline() , luego guardar los datos
escrito por el usuario desde el teclado
Realizar las operaciones (BA x AL) / 2 depositando el resultado en la variable

AR, en la siguiente línea mostrar el resultado de la variable AR en la consola

Colocar la instrucción Console.readLine () para que la ejecución de programa

se detenga hasta que el usuario presione Enter.

siguiente
4.3. Calcular el resultado de un examen

Realizar un programa que nos permita Calcular el resultado de una examen,
ingresando la cantidad de respuestas correctas e incorrectas, el resultado deberá
ser mostrado en la consola del sistema, considerando que por cada respuesta
correcta se duplicara el puntaje y por cada respuesta incorrecta se quitara un
punto
Solución



luego las variables de tipo entero rCor, rInc y resultado como tipo Double
Solicitar al usuario del programa que ingrese los datos de Base y Altura
empleando el método publico Console.Write() , luego guardar los datos escrito
por el usuario desde el teclado
El Método Write escribe una cadena de caracteres y a diferencia de WriteLine

no avanza hasta la siguiente línea, es decir podemos mostrar en la misma
línea los números escritos desde el teclado.
Realizar las operaciones multiplicando por 2 cada respuesta correcta y por -1

cada incorrecta, guardar el resultado en la variable resultado

se detenga hasta que el usuario presione Enter


siguiente
Resuelve problemas empleando instrucciones

condicionales
4.4. Calcular la mayoría de edad del usuario

Realizar un programa que nos permita Calcular el resultado de una examen,
ingresando la cantidad de respuestas correctas e incorrectas, el resultado deberá
ser mostrado en la consola del sistema, considerando que por cada respuesta
correcta se duplicara el puntaje y por cada respuesta incorrecta se quitara un
punto
Solución


luego las variables de tipo Integer aact, anac, edad y dato, nombre como
tipo String

Solicitar al usuario del programa que ingrese su nombre y año de nacimiento

empleando el método publico Console.Write() , luego guardar los datos
escritos por el usuario desde el teclado en las variables nombre, anac.
Extraer el año actual del sistema mediante la función Year de la clase

Microsoft.VisualBasic y guardarlo en la variable aact (año Actual), luego
efectuar la operación se sustracción entre el año actual y el ingresado por el
usuario, el resultado guardarlo en edad
Comparar la variable edad que guarda la diferencia entre el año actual y la

edad del usuario con el número 18 , si es mayor muestra en consola que el
usuario es mayor, en caso contrario mostrar en consola que el usuario es
menor de edad y la diferencia,



siguiente
4.5. Calcular las horas extras acumuladas por un

trabajador
Realizar un programa que nos permita Calcular las horas acumuladas por un
trabajador, ingresando las horas trabajadas de lunes a viernes, el resultado
deberá ser mostrado en la consola del sistema, se debe tener en cuenta que si el
usuario del programa ingresa una cantidad mayor a 14 horas por día, el sistema
indicara que hay un error
Solución


luego las variables de tipo Integer lun, mar, mie, jue, vie, dato y htraba
como tipo Double

Solicitar al usuario del programa que ingrese las horas trabajadas de lunes a
viernes, empleando el método publico Console.Write() , luego guardar los
datos en sus respectivas variables.
Agregar el siguiente código:
En el código anterior la primera consulta que se realiza es para saber si alguno

de los datos en mayor que 14, si la afirmación es correcta el programa espera
hasta que el usuario termine de insertar datos para indicarnos que hemos
cometido un error, por otra parte si la afirmación es falsa se procede a realizar
las operaciones y comparaciones.

En la variable htraba se guardan las horas acumuladas por el trabajador, si

esta en mayor que 48 se deberá indicar que se debe pagar por horas extras,
en caso contrario se indicará el descuento respectivo (como es una cantidad
negativa usar la función de valor absoluto). Para mostrar los mensajes en una
línea debemos concatenar empleando el operador &


siguiente
Resuelve problemas empleando condiciones

múltiples
4.6. Determinar al mayor de dos números

Realizar un programa que nos permita determinar al mayor de dos hermanos, el
resultado deberá ser mostrado en la consola del sistema.
Solución



luego las variables de tipo Integer pher, sher, diferencia.
Solicitar al usuario del programa que ingrese las edades de los hermanos,
empleando el método publico Console.Write() , luego guardar los datos en sus
respectivas variables. Se puede observar que el segundo ingreso de número
tiene la función de conversión de tipo de dato entero CInt
Realizar las operaciones de comparación, si las edades de los hermanos son

iguales la variable diferencia es igual a 0 , si el primer hermano es mayor
diferencia es mayor que 0, en caso contrario el primer hermano será menor
(usar la función de valor absoluto) . Para estas instrucciones hemos utilizado la
estructura de selección múltiple IF

Para mostrar los mensajes en una línea debemos concatenar empleando el

operador &


siguiente
4.7. Seleccionando opciones

Realizar un programa que nos permita escoger una opción (1, 2, 3), luego
efectuar de manera selectiva 3 operaciones: Suma, Resta, Producto, el resultado
de cada función deberá ser mostrado por separado en la consola del sistema.
Solución


luego las variables de tipo Integer a, b, opc

Insertar el siguiente codigo
Solicitar al usuario del programa que ingrese primero la opción y luego los
números con los que el programa trabajará, luego guardar estos números a las
variables respectivas.
Realizar la operación de selección con el operador Select Case, siendo el

número uno para la suma, dos resta y tres para el producto. Para mostrar los
mensajes en una línea debemos concatenar empleando el operador &



siguiente
FUNDAMENTO TEÓRICO
Microsoft. Net Framework

Microsoft .NET es un entorno integrado de ejecución, compilación, depuración, y
desarrollo de aplicaciones. Los diferentes lenguajes de programación de la plataforma,
comparten el mismo entorno (Visual Basic, Visual C., C#, etc.) compartimento las
normas, reglas, y librerías de Microsoft .NET Framework. Tenemos que resaltar que
entre estos lenguajes de programación existen algunas diferencias, pero la cantidad
de cosas que comparten en común es una de las partes que ha hecho a
Microsoft.NET, un entorno moderno, robusto y eficiente.

Software Development Kit

El SDK es un paquete que nos permite, podemos compilar, ejecutar, y depurar
nuestras aplicaciones, utilizar las bibliotecas de clases de .NET que nos facilita
nuestro trabajo.
Con el SDK, desarrollaremos cualquier tipo de aplicación, empleando un
entorno de programación rápido para poder potenciar la programación y sacar
un mayor aprovechamiento y rendimiento a nuestro trabajo, el SDK incluye
documentación, ayuda, y ejemplos, y viene preparado con varios compiladores,
entre los que está Visual Basic.
Todo código escrito en .NET es ejecutado bajo el control del CLR como código
administrado. Es
Common Language Runtime

Common Language Runtime, que no es otra cosa que el entorno o motor de ejecución
de lenguaje común, el código escrito en .NET es ejecutado bajo el control del CLR
como código administrado, esta es una de las diferencias más notables entre las
versiones de Visual Basic anteriores a .NET ( Antes de .NET, las aplicaciones
desarrolladas con Visual Basic se ejecutaban como código no administrado) mientras
que las aplicaciones desarrolladas con Visual Basic bajo el entorno .NET, se ejecutan
como código administrado por el CLR.
Dentro del CLR, encontraremos diferentes partes, por ejemplo el CTS o Common
Type Specification (Especificación de Tipos de Datos Común). El CTS está formado
por tipos y definiciones, cada tipo de dato es utilizable en una aplicación y hereda su
tipo del objeto System.Object. El CTS está relacionado con el CLS o Common
Language Specification (Especificación Común de Lenguajes), estas son las reglas
que hay que seguir a la hora de trabajar con los tipos de datos. El Garbage Collector o
GC será definido como Recolector de basura, y que tiene la función de gestionar de
limpieza de .NET eliminando de la memoria, todos aquellos objetos que no sean útiles
en un momento dado, liberando al sistema de recursos no utilizables
Microsoft Intermediate Language

MSIL o IL es conocido como Microsoft Intermediate Language o lo que es lo mismo,
lenguaje intermedio, el IL es un lenguaje muy similar al conocido ensamblador, y

contiene instrucciones de bajo nivel. La particularidad del IL es que no está compilado

teniendo en cuenta ningún tipo de sistema operativo ni ningún dispositivo hardware en
particular, por lo que al final de este proceso, es necesario realizar un último ajuste, el
correspondiente a la ejecución de la aplicación del código intermedio en la máquina
final dónde se ejecuta, todos los lenguajes administrados de la plataforma .NET,
deben cumplir el conjunto de reglas y normas del IL.
El resultado de esta compilación a código intermedio es procesado por el JIT (Just In

Time), es un procedimiento de .NET mediante el cual, una aplicación compilada en
código intermedio, es compilado en instrucciones de ensamblador (instrucciones de
máquina) específicas para el sistema operativo en el cuál se está ejecutando.
Lenguaje de programación Visual Basic.Net
Con la llegada de interfaces visuales, los productos para el desarrollo de aplicaciones,

incorporan gran cantidad de ayudas y asistentes que hacen olvidar el uno de los
aspectos importantes al momento de programar y es el lenguaje de programación en
si. Productos como Visual Basic 6 hicieron posible que cualquier usuario con un nivel
intermedio puede desarrollar aplicaciones con el apoyo de librerías y utilidades
proporcionada por el entorno de programación, desaprovechando todo el potencial al
desconocer su elemento más importante, el lenguaje, del cual parten el resto de
aspectos del producto.
En el caso de VB.NET este aspecto se acentúa, debido al gran trabajo realizado en

dotar al lenguaje de un elevado número de características que estaban siendo
reclamadas desde hace ya tiempo por la comunidad de programadores. Microsoft
Framework es una una especificación y Visual Basic como lenguaje, ha necesitado
ser adaptado para cumplir con dicha normativa, beneficiándose así de la potencia
incluida en todas las características de la plataforma .NET.
En este capítulo realizaremos una introducción al lenguaje, repasando sus aspectos

principales: ficheros de código y su organización, módulos, procedimientos,
identificadores, operadores, estructuras de control, etc. Dado el gran número de
características disponibles, realizaremos una definición elemental de cada una.

Estructura de un programa VB.NET
Vamos a crear desde el IDE un nuevo proyecto, en esta ocasión de tipo consola. Los
componentes de un programa de estas características serán los mismos, salvando
claro está, las diferencias de interfaz de usuario entre ambas clases tipos de aplicación
Una aplicación está formada por uno o más ficheros de código, que a su vez contienen
módulos de código o clases, dentro de los que se escriben procedimientos que son los
elementos que contienen el código base.
Cuando creamos una aplicación usando VStudio.NET, es el propio IDE quién se
encarga de crear por nosotros la estructura básica del programa: crea un fichero de
código conteniendo un módulo que tiene el procedimiento de entrada, sólo falta el
código del programador. Todos los elementos que componen una aplicación VB.NET,
son organizados por VStudio.NET bajo el concepto de proyecto. Un proyecto integra
los ficheros de código de la aplicación, recursos, referencias a clases globales de la
plataforma .NET., cada vez que creamos un nuevo proyecto utilizando el IDE, dicho
proyecto es al mismo tiempo un ensamblado, por lo que también podemos referirnos a
una aplicación utilizando ambos términos: proyecto o ensamblado.
Main( ) procedimiento de entrada al programa
Todo programa necesita una rutina o procedimiento de entrada, que sea el primero
que se ejecute. EnVB.NET ese procedimiento recibe el nombre especial Main( ), y
debe estar contenido dentro de un modulo de codigo

Variables
Una variable es un identificador del programa que guarda un valor que puede ser
modificando durante el transcurso de dicha aplicación, en la tabla siguiente veremos
los tipos
Declaración
La declaración de una variable es el proceso por el cual comunicamos al compilador
que vamos a crear una nueva variable en el programa. Para declarar una variable
utilizaremos la palabra clave Dim, seguida del identificador o nombre que daremos a
dicha variable.
Podemos declarar variables en muy diversos lugares del código, el lugar que
declaremos la variable será determinante a la hora del ámbito o accesibilidad a esa
variable desde otros puntos del programa. Se recomienda declarar todas las variables
en la cabecera o comienzo del procedimiento, para dar mayor claridad al mismo. En
VB.NET utilizamos la palabra clave As seguida del nombre del tipo de datos, para
establecer el tipo de una variable, a continuación una tabla con los tipos de datos
usados en VB:NET

Denominación
El nombre de las variables, debe empezar por letra, y no puede ser ninguna de las
palabras reservadas del lenguaje, ni contener caracteres como operadores u otros
símbolos especiales. Si queremos agregar comentarios en el código podemos usar
una comilla simple ( ' ) seguida del comentario correspondiente.

Al declarar una variable con un nombre incorrecto, o si se produce otro tipo de error en
la escritura del código, el propio IDE se encarga de avisarnos que existe un problema
subrayando el fragmento de código conflictivo y mostrando una viñeta informativa al
situar sobre dicho código el cursor., como se muestra en la figura siguiente
VS.NET dispone de una ayuda al asignar el tipo a una variable, que nos muestra la
lista de tipos disponibles para poder seleccionar uno sin tener que escribir nosotros el
nombre. Al terminar de escribir la palabra As, aparecerá dicha lista, en la que pulsando
las primeras letras del tipo a buscar, se irá situando en los más parecidos. Una vez
encontrado, pulsaremos la tecla Enter o Tab para tomarlo.
En el caso de que tengamos que declarar más de una variable del mismo tipo,
podemos declararlas todas en la misma línea, separando cada una con una coma e
indicando al final de la lista el tipo de dato que van a tener,

Asignación de valor
Para asignar un valor a una variable utilizaremos el operador de asignación, el signo

igual ( = ), situando a su izquierda la variable a asignar, y a su derecha el valor. Según
el tipo de dato de la variable, puede ser necesario el uso de delimitadores para
encerrar el valor que vamos a asignar.
 Tipos numéricos. Las variables de tipos de datos numéricos no necesitan

delimitadores, se asigna directamente el número correspondiente. Si
necesitamos especificar decimales, utilizaremos el punto ( . ) como carácter
separador para los decimales
 Cadenas de caracteres. En este caso es preciso encerrar la cadena entre
comillas dobles ( " ).
 Fechas. Al asignar una fecha a una variable de este tipo, podemos encerrar
dicho valor entre el signo de almohadilla ( # ) o comillas dobles ( " ). El
formato de fecha a utilizar depende del delimitador. Cuando usemos
almohadilla la fecha tendrá el formato Mes/Día/Año; mientras que cuando
usemos comillas dobles el formato será Día/Mes/Año.
 Las fechas pueden contener además información horario que especificaremos
en el formato Hora: Minutos: Segundos Franja Horaria. En el caso de que no
indiquemos la franja horaria (AM/PM) y si estamos utilizando el signo
almohadilla como separador, el entorno insertará automáticamente los
caracteres de franja horaria correspondientes.
 Tipos lógicos. Las variables de este tipo sólo pueden tener el valor True
(Verdadero) o False(Falso). Además de asignar valores como acabamos de
explicar, podemos asignar el contenido de una variable a otra o el resultado
de una expresión, como veremos más adelante en el apartado dedicado a

operadores. El Código fuente 54 muestra unos ejemplos de asignación a

variables, que después visualizamos en la consola.
Otra cualidad destacable en este apartado de asignación de valores, reside en que

podemos declarar una variable y asignarle valor en la misma línea de código.
Si no realizamos la asignación de valor para un dato al momento de la declaración,

esta tiene un valor inicial, los valores de inicio en función del tipo de dato que tenga la
variable:
 Numérico. Cero ( 0 ).
 Cadena de caracteres. Cadena vacía ( "" ).
 Fecha. 01/01/0001 0:00:00.
 Lógico. Falso (False).
 Objeto. Valor nulo (Nothing).
Debemos declarar todas las variables que vayamos a utilizar en el código. En el caso
de que intentemos utilizar una variable no declarada, se producirá un error. La
declaración de variables proporciona una mayor claridad al código, ya que sabremos
en todo momento si un determinado identificador corresponde a una variable de
nuestro procedimiento, de un parámetro, etc.
Mediante la instrucción Option Explicit, y sus modificadores On/Off, podemos requerir
o no la declaración de variables dentro del programa.

 Option Explicit On. Hace obligatoria la declaración de variables. Opción por

defecto.
 Option Explicit Off. Hace que no sea obligatoria la declaración de variables.
Podemos aplicar esta instrucción para que tenga efecto a nivel de proyecto y a
nivel de fichero de código.
Para establecer Option Explicit a nivel de proyecto, debemos abrir la ventana

Explorador de soluciones, hacer clic en el nombre del proyecto, luego pulsar el botón
de propiedades en esa misma ventana. Esto mostrará la ventana de propiedades del
proyecto, hacer clic sobre el elemento Compilar. Finalmente abriremos la lista
desplegable del elemento Option Explicit, seleccionaremos un valor (On, Off)
Un depurador permite introducirnos dentro del código de nuestro programa mientras

se está ejecutando, el depurador ejecutar línea a línea el programa, observar el valor
de las variables, etc., en otras palabras permite hacer el seguimiento de errores y
fallos en la lógica de la aplicación.

Para ejecutar el programa en modo de depuración pulsaremos [F10], esto iniciará el

programa dentro del contexto del depurador, deteniendo la ejecución en la primera
línea de código, resaltada en color amarillo. La línea marcada en amarillo indica que
está a punto de ejecutarse, para ejecutarla y pasar a la siguiente línea pulsaremos de
nuevo [F10], y así sucesivamente hasta llegar a la última línea del programa,
cerrándose al depurador al finalizar el programa. Si queremos ejecutar el depurador a nivel
de procedimiento podemos pulsar la tecla F11
Creación de un proyecto de Consola de aplicación
Una aplicación de consola es aquella que se ejecuta dentro de una ventana de línea
de comandos, también conocida como Símbolo del sistema, Sesión MS-DOS, etc. Las
aplicaciones de consola son muy útiles cuando necesitamos realizar pruebas que no
impliquen el uso de formularios, controles, imágenes, etc. Una aplicación de consola
se ejecuta en menos tiempo debido a que no requiere muchos recursos del sistema.
Para crear una aplicación de consola básica, seleccionar el menú para crear un nuevo
proyecto, elegiremos Aplicación de consola en el panel derecho de la ventana y
presionamos aceptar

Después de pulsar Aceptar se creará el proyecto que contendrá un fichero de código

con el nombre MODULE1.VB, donde encontraremos un módulo de código
conteniendo un procedimiento Main( ) vacío.
La clase Console
Esta clase se encuentra dentro del espacio de nombres System, y nos proporciona a
través de sus métodos, acceso a la consola para mostrar u obtener información del
usuario, los miembros de esta clase se encuentran compartidos (shared), no es
necesario crear una instancia previa de la misma en una variable, pudiendo ejecutar
directamente sus métodos sobre el objeto Console.
Para mostrar texto utilizaremos el método WriteLine( ) del objeto Console. Este
método escribe en la línea actual de la consola el valor que le pasemos como
parámetro, añadiendo automáticamente las marcas de retorno de carro y nueva línea,

asumiendo que el próximo carácter mostrado en pantalla aparecerá en la siguiente

línea. Veremos ahora un ejemplo.
El código mostrado anteriormente abre una aplicación que se cierra inmediatamente,

debido a que no utilizamos ninguna instrucción para detener en la ejecución, que nos
permita observar el resultado de lo que hemos escrito en la consola.
Para remediar este problema, utilizaremos el método ReadLine( ), que realiza una
lectura de los caracteres que vayamos introduciendo en la línea actual de la consola, e
impedirá continuar la ejecución hasta que no pulsemos el botón ENTER, insertamos
una nueva línea con esta instrucción como se muestra a continuación
El resultado de lo visualizaremos en una pantalla de DOS
Al utilizar WriteLine( ) o Write( ) ocurrirá con frecuencia que en el texto a mostrar

debamos incluir valores que se encuentran en variables o expresiones, para los que
debemos realizar una combinación de la cadena de texto principal con los demás
elementos para obtener la cadena final que mostraremos al usuario. Esto lo podemos
hacer empleando dos técnicas:

Concatenación.
Concatenando a la cadena principal las variables que contienen los valores a mostrar
Parámetros sustituibles.
Pasando como primer parámetro la cadena a mostrar, y añadiendo tantos parámetros
adicionales como valores debamos mostrar en la cadena principal. En la cadena
principal indicaremos el lugar en donde visualizaremos los parámetros poniendo su
número entre los símbolos de llave “{ }”. Los parámetros sustituibles comienzan a
numerarse por cero, no estando obligados a mostrarlos en el mismo orden en el que los
hemos situado en la llamada al método.
Lectura de información
Para obtener datos escritos por el usuario en la línea actual de la consola, hasta que
presionemos ENTER podemos utilizar el método ReadLine( ) del objeto Console.

Operadores del lenguaje

Los operadores son elementos del lenguaje que tienen la finalidad de operar
variables, constantes, valores literales, instrucciones, etc., para obtener un valor
numérico, lógico, de cadena, etc., como resultado. La combinación de operadores con
variables, instrucciones, los denominaremos expresiones, a los elementos integrantes
de una expresión, que no son operadores se les denomina operandos.
.Los operadores se clasifican según el tipo de expresión a construir tenemos:
Operadores Aritméticos
 Suma: +
Este operador realiza una suma de números o una concatenación de cadenas
de caracteres, Si no configuramos adecuadamente Option Strict puede
producirse un error dependiendo del tipo de dato
 Resta: -
Efectúa una resta entre dos números, o cambia el signo de un número
 Multiplicación: *
Este operador multiplica dos números. En el caso de que alguno de los
operandos sea un valor nulo, el resultado será CERO
 División entera: \
Este operador divide dos números, devolviendo como resultado un valor
numérico entero.
 Resto: Mod
Este operador divide dos números y devuelve el módulo o resto de la división.

 División real: /
Este operador divide dos números, devolviendo un resultado con precisión
decimal ( el valor devuelto será de tipo Double). Si uno de los operandos es de
tipo Single, el resultado será de tipo Single, sucede lo mismo si los dos
operandos son del tipo de dato Decimal.
 Potenciación: ^
Este operador eleva un número a determinada potencia. Debemos situar el
número base a la izquierda de este operador, mientras que el exponente lo
situaremos a la derecha.
 Concatenación: &, +
Estos operadores permiten unir dos o más cadenas de caracteres para formar
una única cadena (Se recomienda el uso de & para facilitar la legibilidad del
código y evitar errores) El uso de + puede generar conflictos, ya que en
muchas situaciones no sabremos a primera vista si se está realizando una
suma o concatenación.
Operadores abreviados de asignación

Estos operadores simplifican la escritura de expresiones, facilitando la creación de
nuestro código. El resultado empleado operadores abreviados en una expresión, es el

mismo que utilizando la sintaxis normal, pero con un pequeño ahorro en la escritura de
código.
Suma: +=
Este operador permite sumar números, o concatenar cadenas utilizando la sintaxis
normal o abreviada.
Resta: -=
Este operador permite restar números utilizando la sintaxis normal o abreviada.
Multiplicación: *=
Este operador permite multiplicar dos números podemos utilizar la sintaxis normal o
abreviada.
División entera: \=
Este operador permite dividir dos números, con un resultado entero, podemos utilizar
la sintaxis normal o abreviada.
División real: /=
Este operador permite dividir dos números, y obtener un resultado con precisión
decimal, podemos utilizar la sintaxis normal o abreviada.
Potencia: ^=
Este operador permite elevar un número a una potencia podemos utilizar la sintaxis
normal o abreviada

Concatenación: &=
Este operador permite concatenar dos cadenas, podemos emplear la sintaxis normal
o abreviada
Operadores de Comparación
Estos operadores permiten comprobar el nivel de igualdad o diferencia existente entre
los operandos de una expresión. El resultado obtenido será un valor lógico, True
(Verdadero) o False (Falso).
La función Asc( )
Para averiguar cuál es el código correspondiente a un determinado carácter, el
lenguaje nos proporciona la función Asc( ). Esta función recibe como parámetro una
cadena, y devuelve un valor numérico de tipo Integer, con el código correspondiente al
primer carácter de la cadena.
La función Chr( )
La función Chr( ) recibe un número como parámetro y devuelve el carácter al que
pertenece como un dato de tipo Char, aunque también podemos asignar el resultado a
una variable String.

Operadores Lógicos y a nivel de bit

Los operadores lógicos devuelven un valor de tipo Boolean (True o False), en base a
una condición establecida entre los operandos de la expresión. En expresiones que
impliquen el uso de operadores lógicos, es habitual que los operandos sean a su vez
expresiones, como veremos en los próximos ejemplos con este tipo de operadores.
 Not
A nivel lógico, este operador realiza una negación entre dos expresiones. Su
formato es ligeramente distinto del resto de operadores lógicos
 Or
A nivel lógico, este operador realiza una disyunción entre dos expresiones. La
Tabla 12 muestra los diferentes resultados obtenidos con el uso de este
operador en función de los valores que tengan sus expresiones.

 Xor
A nivel lógico, este operador realiza una exclusión entre dos expresiones. La
Tabla 14 muestra los diferentes resultados obtenidos con el uso de este
operador en función de los valores que tengan sus expresiones.
 AndAlso
Este operador realiza una conjunción lógica de tipo cortocircuito entre dos
expresiones. En este tipo de operación, en cuanto la primera expresión
devuelva falso como resultado, el resto no será evaluado devolviendo falso
como resultado final.
 And
A nivel lógico, este operador realiza una conjunción entre dos expresiones.

 OrElse
Este operador realiza una disyunción lógica de tipo cortocircuito entre dos
expresiones. En este tipo de operación, en cuanto la primera expresión
devuelva verdadero como resultado, el resto no será evaluado devolviendo
verdadero como resultado final.
Los ejemplos a nivel lógico del apartado anterior, si bien se ejecutan correctamente,
pueden ser un tanto confusos a la hora de leer, ya que al tratarse de una operación
lógica, cada operando es a su vez una expresión. Para facilitar la lectura y compresión
en expresiones sobre todo lógicas, podemos encerrar cada operando-expresión entre
paréntesis
Las estructuras de control contienen bloques de instrucciones que se ejecutaran en
función del resultado obtenido al evaluarse una condición asociada a la estructura. A
este proceso de redirección del flujo del programa hacia un determinado bloque de
instrucciones se le denomina bifurcación. Las estructuras de control se dividen en los
siguientes tipos: selección y repetición.

Estructuras de Selección
Las estructuras de selección o decisión permiten ejecutar un bloque de código entre

varios disponibles, según el resultado de la evaluación de una expresión situada en la
cabecera de la estructura.
Estructura de control IF
La sintaxis de esta estructura puede aplicarse de diferentes formas en función del tipo
de decisión a resolver. Si al evaluar expresión es Verdadera, se ejecutarán las líneas o
bloque de código comprendido entre If y End If. Si Expresión es Falso, se desviará la
ejecución a la primera línea de código que haya después de la instrucción End If
Decisión simple en una línea.

Si solo se debe ejecutar una instrucción sencilla cuando se cumple la expresión de la
estructura, podemos omitir la palabra clave End If, escribiendo la sentencia a ejecutar
en la misma línea de la declaración de la estructura If, justo a continuación de la
palabra Then. La sintaxis en este caso será:
If <expresión a evaluar> Then <Instrucción (si la expresión es Verdadera)>
Decisión doble.
Además de ejecutar un bloque de código cuando la expresión sea Verdadera,
podemos ejecutar código cuando la expresión tenga el valor de Falso. En este caso
añadiremos a la estructura la palabra clave Else.
If <expresión a evaluar> Then

<Instrucción (si la expresión evaluada es Verdadera)>
Else
<Instrucción (si la expresión evaluada es Falsa)>
End If

Si bien la ejecución de la estructura If en una línea puede ser útil en ocasiones, tiene
como desventaja que nuestro código se vuelva difícil de leer. Por ello es más
recomendable el uso de esta estructura de control en su formato If...End If.
Decisión múltiple.
Cuando la expresión principal a evaluar es Falsa, podemos agregar expresiones
adicionales utilizando la palabra clave ElseIf, con su bloque de código respectivo. En el
caso de que ninguna de ellas se cumpla, se puede incluir un Else, para ejecutar un
bloque de código por defecto
If <expresión a evaluar> Then

Else IF <expresión a evaluar> Then
Else
<Instrucción (si la expresión evaluada es Falsa)>
End If
En esta situación, si la primera expresión es Verdadero, se ejecutará el código situado

a partir de If. Sin embargo, si If devuelve Falso, se comprobarán sucesivamente las
expresiones de cada uno de los ElseIf existentes. En el caso de algún ElseIf sea
Verdadero, se ejecutará el código que haya a partir del mismo, si ninguna de las
anteriores situaciones se cumple, se ejecutará el código que haya a partir de Else.

Estructura de control Case

Se trata de una mejora en la estructura If de decisión múltiple, y su trabajo consiste en
evaluar una expresión y comparar el resultado con la lista de expresiones de cada uno
de los casos proporcionados
Select Case <expresión a evaluar>

Case <Lista de expresiones>
Instrucciones
Case <otra lista de expresiones>
Instrucciones
Case Else
Instrucciones (si no se cumple ninguna de las expresiones)
End Select
Después de evaluar la expresión de la estructura, si se encuentra una coincidencia

con alguno de los Case, se ejecuta el bloque de código situado entre dicho Case y el
siguiente, si no hay ninguna coincidencia, podemos opcionalmente, ejecutar un
bloque por defecto, utilizando la palabra clave Case Else, al final de esta estructura,
la ejecución continuará a partir de la línea situada después de End Select, a
continuación un ejemplo del uso de esta estructura:

En el caso de que tras evaluar la expresión, haya más de un Case cuya lista de
expresiones se cumpla, se ejecutará el que esté situado en primer lugar. En el ejemplo
anterior, cuando la variable Valor contiene 5, se cumplen dos casos

5
TAREA
5. Realiza Programación
Estructurada
En esta actividad el participante programara estructuras de
control, estas estructuras serán ejecutadas en función del
resultado obtenido al evaluar una expresión asociada a
dicha estructura A este proceso de redirección del flujo del
programa hacia un determinado bloque de código se le
denomina bifurcación Según el modo de ejecución del
código que contienen, las estructuras de control se dividen
en dos tipos: selección y repetición.

 Software Microsoft Visual Studio .Net 2008 o superior.
 Instalación del programa Visual Studio .Net 2008
 Programación y solución de problemas empleando VB.NET
Resuelve problemas empleando Condiciones

Repetitivas.
5.1. Mostrar la sumatoria de los primeros números

Realizar un programa que nos permita ingresar un número al que llamaremos
contador, el programa deberá incrementar sucesivamente desde cero hasta
igualar el número ingresado y detenerse cuando esto suceda.
Solución
Agregar nuevo Proyecto, luego escoger la opción de aplicación de consola,

luego escoger la opción de aplicación de consola.
luego las variables de tipo entero n, c como tipo entero
Mostrar un mensaje, mediante el método publico Console.Write(), luego

guardar en la variable “c” un numero escrito por el usuario desde el teclado

Insertar la estructura repetitiva For para la variable “n”, esta variable tendrá un
incremento de 1, hasta que sea igual a la variable que ingreso el usuario.
Cada vez que se repita el ciclo se mostrara en consola el nuevo valor de la
variable “n”


siguiente, en este ejemplo ingresamos el número 20

5.2. Ingresando varios registros simultáneamente

Realizar un programa que nos permita ingresar varios números simultáneamente,
luego el programa deberá promediar el total acumulado entre la cantidad de
registros ingresados y mostrará el resultado en la consola de aplicación
Solución
Agregar nuevo Proyecto, luego escoger la opción de aplicación de consola.

luego las variables de tipo entero cprod, nprod, cont, acum como tipo
entero y prom como Single.
Mostrar un mensaje, mediante el método publico Console. Write(), luego

guardar en la variable “nprod” un numero escrito por el usuario desde el
teclado
Insertar la estructura repetitiva For para la variable “cont”, esta variable tendrá
un incremento de 1 hasta que sea igual a la variable que ingreso el usuario.
Cada vez que se repita el ciclo se guardará en la variable “cprod” un numero
ingresado por el usuario y la variable “acum” incrementará con cada nuevo
dato

Mostrar el resultado en la aplicación de consola, el cual se obtiene de dividir el

total acumulado entre la cantidad de registros ingresados.

Finalizar el procedimiento con End Sub, el resultado en consola es el

siguiente, en este ejemplo ingresamos el numero 7 para la cantidad de
registros y los números fueron 50, 30, 80, 40, 60, 20, 10.

Resuelve problemas empleando estructuras

repetitivas.
5.3. Trabajando con registros

Solución


luego las variables de tipo entero p1, p2, p3, dato, acum, nprod como tipo
Integer y G como String.

guardar en la variable “nprod” un numero escrito por el usuario desde el
teclado

Insertar la estructura repetitiva For para la variable “acum”, esta variable

tendrá un incremento de 1 hasta que sea igual a la variable que ingreso el
usuario. Cada vez que se repita el ciclo se guardará en la variable “dato” un
registro que acumulará en P1, P2, P3 cada selección que realice en el
momento de la consulta.
Estructura de selección para determinar cuando los valores seleccionados son

iguales.
Estructura de selección para determinar cual de las selecciones es mayor

Mostrar el resultado de las operaciones en la aplicación de consola y

concatenando con la variable “G”


siguiente, en este ejemplo ingresamos el numero 3 para la cantidad de
registros y los números fueron 1, 2, 2,1,1

Desarrolla Programas con Arreglos
5.4. Arreglo Unidimensional

Solución


luego las variables de tipo Integer index, num

guardar en la variable “x” un numero escrito por el usuario desde el teclado,
luego declarar el arreglo como tipo Integer , el tamaño del arreglo será
determinado por la variable ingresada por el usuario.

Insertar la estructura repetitiva For que nos permita escribir datos en el arreglo
unidimensional, la variable “index” incrementará en 1 hasta que sea igual a
la variable que ingreso el usuario
Mostrar un mensaje en la consola, luego insertar la estructura repetitiva For

que nos permita visualizar el contenido del arreglo, la variable “index”,
incrementara hasta mostrar el último registro. Para visualizar el contenido del
arreglo empleamos el comando Console.Writeline() concatenando el mensaje
con el índice del arreglo.
Finalmente debemos colocar la instrucción Console.readLine () para que la

ejecución de programa se detenga hasta que el usuario presione Enter.

siguiente, en este ejemplo ingresamos el numero 10

5.5. Trabajando con Arreglos

Realizar un programa que solicite guardar una cantidad de datos ingresada por el
usuario para ser almacenado en un arreglo, al finalizar el programa el programa
solicitar al usuario consultar sobre cualquiera de estos datos
Solución

luego las variables de tipo Integer num, indice, reg

guardar en la variable “num” un numero escrito por el usuario desde el
teclado

Declarar el arreglo “dato” como tipo Integer, el tamaño de este arreglo será
determinado por la variable “num”
La siguiente es una estructura repetitiva de tipo For para grabar los datos en el
arreglo, este ciclo repetitivo tendrá como final el dato introducido en “num”,
por cada repetición grabara en el arreglo dato un valor introducido desde el
teclado
Mostrar mensaje al usuario y solicitar ver un determinado registro del arreglo,

mediante la estructura condicional IF se consulta si el dato ingresado por el
usuario es menor o igual que la variable “num”, en caso contrario indicara que
hemos ingresado una opción incorrecta
Colocar la instrucción Console.readLine () para que la ejecución del programa

se detenga hasta que el usuario presione Enter.


siguiente, en este ejemplo ingresamos el número 10
5.6. Trabajando con Procedimientos
Realizar un programa que realice la llamada a dos procedimiento, cada

procedimiento mostrara un mensaje en la aplicación de consola
Solución
Agregar nuevo Proyecto, luego escoger la opción de aplicación de consola

luego realizaremos las llamdas a los procedimientos escribiendo su nombre
seguido de dos parentesis, el uso del parentesis no es obligatorio pero ayuda
a identificar las llamadas a procedimientos cuando nuestro codigo aumenta.

1. Después de ejecutar las llamadas a los procedimientos respectivos el

programa la ejecución del programa se detenga hasta que el usuario presione
Enter.
Para declarar el inicio de un procedimiento escribimos primero la función Sub

seguido del nombre del procedimiento, el procedimiento finaliza escribiendo al
final la función End Sub. en nuestro caso escribiremos “procedimiento_texto1(
)” , este procedimiento se encarga de escribir en la aplicación de consola un
mensaje.
Declarar el segundo “procedimiento_texto2( ), para mostrar un segundo

mensaje luego dejar la siguiente línea en blanco

siguiente,

5.7. Paso de parámetros a procedimientos
Realizar un programa que realice la llamada a dos procedimiento, cada

procedimiento mostrara un mensaje en la aplicación de consola
Solución
1. Agregar nuevo Proyecto, luego escoger la opción de aplicación de consola

luego realizaremos las llamdas a los procedimientos escribiendo su nombre
seguido de dos parentesis, el uso del parentesis no es obligatorio pero ayuda
a identificar las llamadas a procedimientos cuando nuestro codigo aumenta.
Después de ejecutar las llamadas a los procedimientos respectivos el

programa la ejecución del programa se detenga hasta que el usuario presione
Enter.
Para declarar el inicio de un procedimiento escribimos primero la función Sub

seguido del nombre del procedimiento, el procedimiento finaliza escribiendo al
final la función End Sub. en nuestro caso escribiremos “procedimiento_texto1(
)” , este procedimiento se encarga de escribir en la aplicación de consola un
mensaje.

Declarar el segundo “procedimiento_texto2( ), para mostrar un segundo

mensaje luego dejar la siguiente línea en blanco
2. Finalizar el procedimiento con End Sub, el resultado en consola es el

siguiente,
FUNDAMENTO TEÓRICO
Estructuras de repetición
Estructura de control While

Esta condición es el tipo más sencillo, ejecuta las líneas de código que contiene,
mientras que la expresión situada junto a While sea Verdadera.
While <expresión>
Instrucciones (contenido del bucle que se va a repetir)
End While

En la siguiente figura un ejemplo del uso de la estructura While:
Estructura de control Do
Esta estructura ejecuta un conjunto de líneas de código, en función del valor devuelto
por una expresión, que a modo de condición, podemos situar al comienzo o final de la
estructura.
Además se puede introducir alguna condición en el interior del código de la estructura,
para forzar la salida del bucle y evitar caer en un bucle infinito, la instrucción Exit Do
nos permite forzar la salida del bucle, pudiendo emplearla tantas veces como sea
necesario.
Do While <expresión>
Loop
Condición al principio.

La diferencia entre usar While o Until reside en que empleando While, el código del
bucle se ejecutará mientras la expresión sea Verdadera. En el caso de Until, el código
se ejecutará mientras que la expresión sea Falsa..
Condición al final.
La diferencia en este caso, consiste en que el contenido de la estructura se ejecuta al
menos una vez
Do
Loop While <expresión>
En la siguiente figura un ejemplo del uso de la estructura While:

Estructura de control For

Esta estructura ejecuta un bloque de código un número determinado de veces,
establecido por un rango de valores y controlado por un contador, el contador se
inicializa con un valor y el código existente entre For y Next es ejecutado una serie de
veces, hasta que el valor de Contador se iguala a Fin.
El Contador incrementa su valor por defecto en una unidad, pero podemos cambiar
este aspecto utilizando el modificador Step, mediante el que podemos establecer el
número en el que se van a realizar los incrementos (Step también nos permite realizar
decremento utilizando un número negativo)
For <variable > = <valor inicial> To <valor final> Step <incremento>
Next
Si queremos salir de esta estructura antes de haber completado el número de

iteraciones establecidas, podemos utilizar la instrucción Exit For, que provocará dicha
salida. Podemos usar como contador una variable de tipo Integer, en lugar de una de
tipo Short, Long, Decimal, etc; debido a que los tipos Integer se actualizan más
rápidamente,

Arrays
También conocido como matriz o vector, un array es aquel elemento del lenguaje que
nos permite agrupar un conjunto de valores del mismo tipo, y acceder a ellos a través
de una misma variable o identificador, especificando la posición o índice en donde se
encuentra el dato a recuperar.
La clase Array
Esta clase proporciona a través de sus miembros, acceso orientado a objeto para los
arrays que manipulemos en nuestras aplicaciones. Esto quiere decir que los arrays
son también objetos. Al igual que el resto de elementos del entorno, los arrays se
encuentran clasificados como tipos por referencia; esto quiere decir, que durante la
ejecución.

Al declarar una variable como array, implícitamente se crea un objeto de la clase.
Algunas de estas características se describen a continuación
 El primer índice de un array debe ser siempre cero

 No es posible crear arrays con rangos de índices
 Todos los arrays son dinámicos
Rutinas de código
Procedimientos
Un procedimiento es un elemento del lenguaje compuesto por un conjunto de líneas
de código, a las que se denomina cuerpo del procedimiento. Su comienzo y fin lo
establecemos mediante ciertas palabras reservadas del lenguaje, asociándole un
identificador, que nos servirá para reconocerlo entre el resto de procedimientos
creados en el programa.
Podemos enviarle también información adicional en forma de parámetros, con lo que

el resultado de la ejecución de un procedimiento variará según los valores que
pasemos en cada llamada, en VB.NET disponemos de los siguientes tipos de
procedimientos:
 Sub. Procedimiento que realiza un conjunto de operaciones pero no devuelve

valor al punto de llamada. A lo largo del texto también nos referiremos a las
rutinas de tipo Sub con el nombre genérico de procedimiento.
 Function. Procedimiento que realiza un conjunto de operaciones y devuelve un
valor denominado valor de retorno al punto de código que realizó la llamada
nos referiremos a las rutinas de tipo Function con el nombre genérico de
función
 Property. Procedimiento que se utiliza para labores de acceso y asignación de
valores a las propiedades de un objeto.

Procedimiento Sub
[Ámbito] Sub NombreProcedimiento [(ListaParámetros)]

[CódigoEjecutable]
[Exit Sub | Return]
[CódigoEjecutable]
End Sub
Los elementos que forman parte de este tipo de rutina son los siguientes:
 Ámbito. Define el modo en que vamos a poder acceder o llamar al

procedimiento desde otro punto de la aplicación.
 Sub...End Sub. Palabras clave que indican el comienzo y final del
procedimiento
respectivamente. Cuando hagamos una llamada al procedimiento, el
compilador ejecutará el código comprendido entre estas dos palabras clave.
 Nombre Procedimiento. Identificador que utilizamos para reconocer y llamar
al
procedimiento.
 Lista Parámetros. Lista de variables separadas por comas, encerradas entre
paréntesis, que representan la información que recibe el procedimiento..
 Return. Esta palabra clave permite salir de la ejecución del procedimiento sin
haber llegado a su fin. Podemos utilizarla en tantos lugares dentro de un
procedimiento como sea necesario. Se recomienda su uso en lugar de Exit
Sub, ya que podemos emplear Return para salir de cualquier tipo de
procedimiento.
 Exit Sub. Esta palabra clave permite salir de la ejecución del procedimiento sin
haber llegado a su fin, pudiendo igualmente, situarla en tantos lugares dentro
del procedimiento como sea necesario.

Llamada a un procedimiento Sub

Para realizar una llamada o ejecutar un procedimiento Sub, debemos escribir su
nombre en un punto del programa, como veremos a continuación:
En la llamada a un procedimiento Sub, el uso de los paréntesis es opcional,

independientemente de si pasamos o no parámetros, es muy recomendable
especificar dichos paréntesis, ya que aportan una gran claridad a nuestro código, de
forma que al leerlo podemos ver rápidamente los puntos en los que se realiza una
llamada a una rutina de código. El entorno del programa insertara automáticamente
los paréntesis en el caso de que no los especifiquemos de forma explícita.

Procedimiento Function
[Ámbito] Function NombreFunción[(ListaParámetros)] As TipoDato

[CódigoEjecutable]
[Return Valor]
[NombreFunción = Valor]
[Exit Function]
[CódigoEjecutable]
End Function
Los elementos que forman parte de este tipo de rutina son los siguientes:
 Ámbito. Define el modo en que vamos a poder acceder o llamar al

procedimiento desde otro punto de la aplicación. l lenguaje será tratado en un
apartado posterior.
 Function...End Function. Palabras clave que indican el comienzo y final de la
función respectivamente. Cuando hagamos una llamada a la función, el
compilador ejecutará el código comprendido entre estas dos palabras clave.
 NombreFunción. Identificador que utilizamos para reconocer y llamar a la
función, en este tipo de procedimiento, también utilizamos su nombre para
asignar el valor que será devuelto al código que hace la llamada en el modo
NombreFunción = Valor,
 TipoDato. Tipo de dato del valor devuelto como resultado de la ejecución de la
función.
 ListaParámetros. Lista de variables separadas por comas, y encerradas entre
paréntesis, que representan la información que recibe la función desde el
código que hace la llamada
 Return. Esta palabra clave permite salir de la ejecución de la función
devolviendo al mismo tiempo un valor al código que hizo la llamada. Podemos
utilizarla dentro de una función, en tantos lugares como necesitemos.
 Exit Function. Esta palabra clave permite salir de la ejecución de la función sin
haber llegado a su fin. Podemos utilizarla dentro de una función, en tantos
lugares como necesitemos

En el caso de devolver el valor de retorno de una función utilizando el propio nombre

de la función, nos encontramos con el problema de que si en un momento
determinado tenemos que cambiar el nombre de la función, también deberemos
cambiar todos aquellos puntos de la rutina en donde devolvemos el valor. Por este
motivo es recomendable el uso de Return para el devolver el valor de la función, ya
que si tenemos que cambiar el nombre de la función, no será necesario modificar los
puntos en los que se devuelve el valor de este tipo de procedimiento
Llamada a un procedimiento Function

Para realizar una llamada o ejecutar un procedimiento Function debemos escribir su
nombre en un punto del programa, de igual manera que los procedimientos. Por otro
lado, los puntos que marcan las diferencias entre un Function y un Sub son los
siguientes:
Un procedimiento Function devuelve un valor, de modo que si queremos obtenerlo,
debemos asignar la llamada a la función mediante una variable. Los procedimientos
Sub no pueden devolver valores.

Paso de parámetros a procedimientos
Un parámetro consiste en un valor que es pasado a un procedimiento. Dicho valor

puede ser una variable, constante o expresión, los procedimientos pueden recibir
parámetros en forma de lista de variables separada por comas.
A la lista de parámetros de un procedimiento se le denomina protocolo de llamada o
firma del procedimiento.
Al igual que hacemos cuando declaramos una variable, al declarar un parámetro
debemos especificar el tipo de dato que el parámetro va a contener. Esto será o no
obligatorio, en función del modificador establecido en la instrucción Option Strict.
Existen dos modos en el lenguaje de pasar parámetros a un procedimiento: por valor y

por referencia. Este aspecto del lenguaje está relacionado con el modo en que el
contenido de los parámetros son gestionados internamente en memoria. Ello nos

permitirá según el tipo de paso empleado, poder alterar el valor del parámetro en el
código que realizó la llamada.
Paso por valor (ByVal)

Cuando pasamos un parámetro por valor a un procedimiento, la variable que contiene
el parámetro puede ser modificada dentro del procedimiento, sin que estos cambios
afecten al valor original en el código que hizo la llamada. Debemos situar en este caso
en el procedimiento, la palabra clave ByVal antes del nombre del parámetro
En el entorno de .NET Framework, por defecto, todos los parámetros son pasados por
valor. Esto lo puede comprobar el lector de un modo muy simple: si al declarar un
parámetro no especifica el tipo de paso, el IDE automáticamente situará junto a ese
parámetro la palabra clave ByVal.
Paso por referencia (ByRef)

Cuando pasamos un parámetro por referencia a un procedimiento, si modificamos
dentro del procedimiento la variable que contiene el parámetro, dichos cambios en
este caso sí afectarán al código que hizo la llamad . Debemos situar en este caso en el
procedimiento, la palabra clave ByRef antes del nombre del parámetro.

El nivel de gestión interna en memoria de los parámetros es lo siguiente: cuando se

realiza la llamada al procedimiento y se pasa el parámetro, el entorno detecta que se
trata de un parámetro pasado por referencia, y tanto la variable del código llamador
como la del procedimiento llamado utilizan la misma dirección de memoria o referencia
hacia los datos, por lo que los cambios realizados en un procedimiento afectarán
también al otro

TAREA
6. Realiza Programas de
Aplicación
En esta tarea el participante será capaz crear interfaces
gráficas en un software de programación llamado Labview,
este es un software Industrial para el análisis y la creación de
interfaces hombre máquina, LabVIEW es una herramienta
gráfica para pruebas, control y diseño mediante la
programación. El lenguaje que usa se llama lenguaje G,
Los programas desarrollados con LabVIEW se llaman

Instrumentos Virtuales, o VIs, y su origen provenía del control
de instrumentos, aunque hoy en día se ha expandido
ampliamente no sólo al control y Automatización, sino también
a la programación embebida. Entre sus objetivos están el
reducir el tiempo de desarrollo de aplicaciones de todo tipo y
el permitir la entrada a la informática a profesionales de
cualquier otro campo. LabVIEW consigue combinarse con todo
tipo de software y hardware, tanto del propio fabricante en
tarjetas de adquisición de datos, PAC, Visión, instrumentos y
Hardware de otros fabricantes.

 Computador Pentium 4 o superior
 Sistema operativo Windows XP o superior
 Software de Programación Industrial LabVIEW (versión de evaluación)
1. Instalación y configuración del programa LabVIEW (versión de evaluación)
2. Usar el programa para diseñar instrumentos virtuales.
Desarrolla proyectos de Aplicación en Windows
6.1. Promediando números

Diseña un programa para sacar el promedio a tres números mostrando el
resultado en un indicador numérico, además el programa deberá identificar si
los números son iguales o diferentes mostrando el resultado en dos indicadores
de tipo LED (un indicador si los números son iguales y otro si son diferentes)
Creación de la interfaz gráfica:
Para el problema propuesto debemos insertar tres controles numéricos, un

indicador numérico y dos indicadores de tipo LED (de tipo booleano)
Un indicador se activará cuando los números sean iguales (LED verde) y

otro cuando son diferentes (LED amarillo). Podemos apreciar que el
control tiene una flecha para cambiar el valor del dato ingresado, además
también podemos escribir desde el teclado

Desarrollo de la programación:
Seleccionar la ventana para editar la programación CTRL + E, ingresar la

función de “promedio” seleccionándola de la paleta de funciones,
“Compound Arithmetic”, debemos mencionar que este bloque de función
puede realizar la operaciones de suma, multiplicación, AND, OR, XOR
Para nuestro problema sumaremos los números N1, N2, N3 y luego será
dividió con el número 3 (valor constante ), el resultado se mostrará en
el indicador “promedio”. Luego debemos programar la condición de
igualdad entre N1, N2, N3 con tres comparadores en los que
obtendremos como salida tres valores booleanos que serán enviados a una
función “Compound Arithmetic”, en el modo de compuerta AND.
La salida del segundo comparador se conecta directamente al indicador
LED de igualdad, la misma salida será negada
Como paso final debemos presionar el botón ejecutar y el programa

empezará a realizar las operaciones indicadas.

6.2. Concatenando caracteres
Elabore un programa en Labview que muestre una cadena de salida, con los
datos de nombre y edad, para ello deberá concatenar las entradas de dos
controles, además deberá calcular el año de nacimiento y mostrar en un
indicador si dato introducido por el usuarios mayor a 18.
Luego seleccionar nuevo VI en la barra de menú, agregar 02 indicadores de

texto para el nombre, el texto que mostrará los resultados
Agregar 01 indicador LED que mostrará cuando los datos corresponden a

una persona mayor de edad, personalizar las etiquetas de texto en la que
escribiremos lo siguiente: “NOMBRE, EDAD, MAYOR DE EDAD?, CADENA
DE SALIDA”
Luego el panel frontal de la manera siguiente:
Ya estamos en condiciones de programar, en base a los elementos

gráficos seleccionados para nuestra interfaz, implementando la lógica que
dará solución a nuestro ejercicio.
Incorporar una “función while” a nuestra aplicación seleccionamos en la paleta
de funciones el botón: opción “while loop”, luego insertar los iconos que
representan a los objetos del panel frontal
El programa deberá concatenar las cadenas, para ello utilizaremos la función

“Format Into String”, además restar el valor de la edad el año actual para
obtener el año de nacimiento y este resultado añadirlo a las cadenas.
La función retorna una cadena de caracteres con cada uno de los

elementos que se le pasan como parámetros, estos parámetros pueden ser de
cualquier tipo de dato (DBL, SGL, EXT, U8, U16, U32, I8, I16, I32). El formato

debe ser especificado de la manera siguiente: %d para enteros, %f para

números con coma, %s para cadenas. En nuestro caso el formato será:
“%s%s%s%d”, ya que son tres cadenas y un valor entero (el año).
Se observa que la función solo tiene una posible conexión de entrada, para
agregarle más entradas debemos arrastrar el icono de la parte inferior,
cuando cambie el tipo de cursor.
Para obtener el año introducir una constante numérica entera para
almacenar el valor del año 2010 y un operador de resta de la paleta de
funciones numéricas, cuando realizamos la resta del año actual menos el año
de nacimiento
Ahora agregaremos un botón para terminar la aplicación, se tiene que insertar el

control “Stop Button” representado por la variable booleana “stop” ( cu a n d o
i n s e r t a m os e l c i c l o wh i l e e l b o t o n s e ag r eg a p or d ef e c t o)
Para ejecutar el programa, presionamos el botón de menú y si se quiere

ejecutar en modo de depuración se pueden escoger las variantes ya
estudiadas.

6.3. Seleccionando Opciones

En esta actividad vamos a elaborar un programa que permita calcular la raíz
cuadrada de un número positivo cada vez que presionemos el botón “calcular”, si el
número es positivo el resultado de mostrará en un indicador numérico, de lo contrario
se activará un indicador de tipo LED y aparecerá una ventana emergente indicando
que realizamos el ingreso de un número negativo
Seleccionar nuevo VI en la barra de menú, agregar 01 control de numérico, 01

indicador numérico, insertar un indicador de tipo LED y 02 Botones.
Luego el panel frontal de la manera siguiente:
Agregar al diagrama de bloques una estructura WHILE” y un boton de

“stop” que permitirá controlar el tiempo de ejecución del programa. En el
interior de la estructura While, ingresar otra estructura del tipo CASE que
conectaremos al botón CALCULAR, como sabemos esta estructura tiene dos
valores TRUE o FALSE, estas acciones estarán asociadas a los estados del
botón.
Repetir la operación anterior, pero esta vez comparar el número ingresado con
la operación MAYOR O IGUAL A CERO para saber cuándo se ingresa un
número negativo

Ahora vamos a crear una variable local relacionada al indicador de tipo LED,
con clic derecho /create/local variable, esto permitirá encender o apagar el LED
dependiendo de la programación. De igual manera crearemos otra variable para
el control numérico NUMERO. La segunda estructura CASE recibirá el
resultado de la operaciones “SI NUMERO >= QUE CERO”
TRUE: se calcula la raíz cuadrada que se encuentra en el control numérico y el

resultado es depositado en el indicador, el indicador LED deberá estar en
estado FALSE
FALSE: mostrar una ventana de error y activar el indicador de tipo LED

Ejecutar el programa, presionando el botón y si se quiere ejecutar en

modo de depuración se pueden escoger las variantes ya estudiadas.
6.4. Trabajando con Arreglos

En esta actividad crearemos un programa en Labview que nos permita declarar un
arreglo de 10 números ingresados por el usuario luego obtener el promedio, además
extraer el valor de la posición 4 y gráficarlo en un indicador de tipo TANK
Crear nuevo VI en el panel frontal, agregando 01 arreglo, 01 indicador de tipo

TANK, 01 indicador numérico y 01 botón, personalizar las etiquetas de los
controles e indicadores. Luego el panel frontal quedara de la siguiente manera:
Al colocar el arreglo en el panel frontal, para mostrar el contenido de 10

números debemos insertar un indicador o control en el arreglo siguiendo los
siguientes pasos
Seleccionar en la paleta de funciones un control digital y arrastrarlo al interior del

arreglo, se obtendrá el resultado mostrado en la figura
Para asignar los 10 elementos que tendrá nuestro arreglo solo bastará arrastrar

el cursor hacia abajo 09 posiciones más.
Empecemos por el promedio de los 10 números, necesitamos un ciclo FOR

para recorrer el arreglo e ir sumando los elementos. Una vez que sumen los
elementos, dividimos el resultado entre 10.
Agregar la estructura de tipo FOR, luego una constante numérica haciendo clic
derecho sobre la estructura opción CREATE CONSTAN y asignamos el valor de
10
Para almacenar el resultado de la suma, vamos a utilizar los shift registers. el

valor inicial del shift register antes de la primera suma, debe ser cero, para que
no la afecte el último valor almacenado, cuando termina el ciclo FOR es
precisamente la suma, que pasamos a dividir entre 10.
Vamos a extraer elemento 5 del arreglo y lo mostraremos en el indicador tipo

tanque (tank). Al igual que en muchos otros lenguajes, LabView comienza a
indexar los arreglos con 0, o sea, que el primer elemento tiene índice 0. Esto
significa que nuestro 5 elemento tiene el índice 0.

Hay muchas funciones programadas en lenguaje G para trabajo con

arreglos, se encuentran agrupadas en la paleta Functions/Array que se
muestra a continuación
Una de las funciones presentes en esta biblioteca o librería de funciones es la

que dado un índice devuelve el valor del elemento. Dicha función es la
segunda comenzando por la esquina superior izquierda
La función INDEX ARRAY espera que se le conecte un arreglo y al menos se le

especifique un índice, entonces devolverá el valor del elemento en ese índice, si
se le especifica más de un índice devuelve un sub-arreglo con los valores
de los elementos en esos subíndices. En nuestro caso necesitamos saber el
valor del elemento 5

Finalmente ejecutar el programa, presionando el botón y si se quiere

estudiadas.
6.5. Trabajando con Clusters

En esta actividad diseñaremos un programa que nos permita crear tres
arreglos de números con las siguientes características: el primer arreglo estará
formado por 10 números generados aleatoriamente, el segundo con el
cuadrado de los números generados aleatoriamente y el tercero por la raíz
cuadrada.
Crear nuevo VI en la barra de menú, agregar 03 estructuras de tipo CLUSTER.

Debemos tener presente que los controles numéricos serán introducidos
dentro de cada estructura de tipo CLUSTER, arrastrándolos desde la paleta de
funciones.
Luego el panel frontal quedara de la siguiente manera:
Primero vamos a agregar la estructura lógica de tipo FOR y agregaremos una

constante numérica haciendo clic derecho sobre la estructura opción CREATE
CONSTAN

Generaremos los 10 números aleatorios, para ello insertaremos la función

RANDOM que será multiplicada por el número 100, para aumentar la
escala de valores debido a que la función RANDOM genera números
aleatorios entre 0-1
El siguiente paso será conectar las funciones de potencia y raíz cuadrada

teniendo como salida el límite de la estructura FOR
Las conexiones de las operaciones serán insertadas a la función Sort 1D

Array, que se encargará de ordenar cada valor generado por las
funciones y ordenarlos, luego serán enviados a cada CLUSTER
Finalmente ejecutar el programa, presionando el botón y si se quiere

estudiadas.

6.6. Gráficando un Cluster

En esta actividad vamos a crear una interfaz gráfica que nos permita crear
dos estructuras de tipo CLUSTER, la primera contendrá 10 números
generados aleatoriamente y la segunda almacenara el cuadrado de cada
número generado, luego estos valores deberán mostrarse en un indicador
grafico de tipo CHART
Crear nuevo VI en la barra de menú, agregar los siguientes elementos: 02

estructuras de tipo CLUSTER, 02 controles numéricos, 02 indicadores gráficos
de tipo CHART
Los controles numéricos serán introducidos dentro de cada estructura de tipo

CLUSTER
Desarrollo de la programación
Primero realizaremos las operaciones para generar los 10 números aleatorios,

insertaremos la función RANDOM que será multiplicada por el numero 10 (la
función RANDOM genera números aleatorios entre 0 y 1). El resultado de la
primera operación se conectará al extremo de la estructura FOR, también se
enviará a la función MULTIPLICACIÔN para generar el cuadrado del mismo
número
Conectar las salidas de cada operación a la función BUNDLE que agrupará los

valores y los enviará de manera ordenada al indicador de tipo CHART. Las

conexiones de las operaciones que se encuentran conectadas a la estructura se
enviaran a la función Sort 1D Array, que ordenará cada valor generado por las
funciones y ordenarlos, luego serán enviados a cada CLUSTER
Podemos observar cómo se generan los valores automáticamente y se gráfican

en los indicadores.
Las propiedades de la gráfica pueden cambiarse, dando clic derecho sobre el

área PLOT del indicador grafico. Ejecutar el programa, presionando el botón
y si se quiere ejecutar en modo de depuración se pueden escoger las
variantes ya estudiadas.

Creación de formularios e interfaces de usuario en

Windows
6.7. Controlando la temperatura

Diseña un programa que registre el valor de temperatura del sensor de un
horno, y active una alarma cuando la temperatura del horno esta fuera de los
rangos establecidos:
 Temperatura mínima 20
 Temperatura máxima 80

Luego seleccionar nuevo VI en la barra de menú, agregar los siguientes
elementos: 02 controles numéricos, 01 control booleano (botón), 02 indicadores
LED (booleano), 01 indicador grafico “Waveform “
Ingresar una estructura de tipo WHILE, que permitirá que la aplicación se

repita constantemente. Debemos simular la medición generada por el
sensor del horno para ello insertaremos una funciona aleatoria
multiplicada por 100 (la función aleatoria genera números al azar entre 0
y 1)

Ingresar los valores de temperatura máximo y mínimo y enlazarlo a las

funciones “mayor que” y “menor que” , que se compararan con el valor
de temperatura. El valor de la temperatura será enviado a dos funciones de
comparación, a la salida de estas funciones encontraremos valore de verdad
o falso que activarán a los indicadores LED.
Agregar una función de tiempo para poder observar los cabios de

temperatura en el horno, esta temperatura se expresa en milisegundos, por
ello insertaremos una constante numérica con un valor igual a 250
Ingresar un botón (booleano) para finalizar la aplicación

empezara a realizar las operaciones indicadas.
.

6.8. Control de nivel para un tanque

Diseña un programa que indique el nivel de llenado de un tanque, el valor de
llenado varia de 0 a 100%, este llenado e variable y en cualquier momento
puede sobre pasar el máximo nivel pudiendo desbordarse, agregarle un
sistema que nos permita regular el nivel máximo de llenado
Seleccionemos el tanque de la paleta de controles, en la opción “controls”,
dentro de la opción “numerics” que tiene el símbolo . LabVIEW agrego

un tanque con nivel de 0 a 10% para cambiar este valor máximo debemos dar
doble clic sobre el valor 10 y modificarlo, los demás valores se ajustaran a
este máximo
El siguiente elemento que debemos insertar es un control numérico para

ingresar por teclado la referencia de la alarma para el nivel máximo, repetir
los pasos para agregar el tanque, después de agregar el control numérico,
cambiar su nombre, por ejemplo podemos colocar “referencia de nivel”
Para terminar la interfaz de usuario colocar un botón para terminar su

ejecución, esto se realiza en la paleta de controles seleccionando los elemento
booleanos para luego escoger “Stop Buton”
El primer código G que debemos programar es el necesario para comenzar

y terminar la aplicación. Para ello se tiene el control “Stop Button”
representado por la variable booleana, esto quiere decir que mientras no
presionemos el botón de STOP la aplicación se ejecutar, para ello debemos

emplear un ciclo WHILE.
Para incorporar un el ciclo “WHILE” a nuestra aplicación buscar en la paleta

de funciones el botón, luego seleccionar opción “WHILE LOOP”.
Este ciclo tiene dos variables, la iteración representada por y la

condición de salida, representada por . Si negamos la variable booleana y
la conectamos a la condición de salida, se construye la lógica necesaria para la
ejecución y salida del programa.
Verificar que la variable “Tank” esté configurada como “indicador” y la variable

“referencia de nivel” esté configurada como “control”. Recordemos que según el
problema el llenado del tanque es variable, por lo que escogeremos una función
aleatoria. Esta función se encuentra entre las funciones numéricas, la función
aleatoria genera cualquier número entre los valores 0 y1, para generar
números entre 0 y 100 debemos multiplicar la salida de esta función
por el numero entero 100, la función de multiplicación se encuentra en la
misma paleta de funciones numérica y se representa por el símbolo: que
recibe dos valores y devuelve la multiplicación de ambos. Además debe
utilizarse una constante numérica entera que contenga el valor 100.
En cada iteración del ciclo el resultado de la función aleatoria se multiplica por

100 y este valor se asigna a la variable que representa al control tanque.
Como paso siguiente se debe comparar el valor del tanque con la referencia
entrada del control numérico. Si este valor es mayor que la referencia se
cambiará el color del tanque a rojo, caso contrario el tanque será de color
azul. La función comparación está ubicada en la paleta de funciones
“Comparison”:

Para modificar el color del tanque debemos utilizar la propiedad FillColor

, hacer clic derecho sobre la variable “Tank”, seleccionar la opción
Create, a continuación la opción “Property Node”
La propiedad “Fill Color” de la variable “Tank” es de lectura, sin embargo se

necesita variar la misma, para cambiar esta propiedad a escritura debemos
dar clic derecho sobre la misma y seleccionar la opción “Change To Write”.
Ahora necesitamos un bloque (if- then- else) que tome la decisión y cambie

un color u otro según el resultado de la comparación. Este bloque puede

encontrarse en la paleta de funciones, opción “Comparison”, función “Select”
esta funcion retorna el valor TRUE o FALSE. El valor que debe retornar
la función “Select” debe ser Rojo, si la condición es verdadera y Azul si es
falsa. Es necesario utilizar constantes enteras que representen los colores
deseados.
Para agregar la constante de color debemos escoger COLOR BOX

CONSTANT, por defecto la constante de color es de color negro, para
cambiar esto debemos tomar el cursor y presionar sobre la constante para
escoger el color deseado.
Para finalizar debemos ejecutarla, para ello presionamos el botón de menú

y si se quiere ejecutar en modo de depuración se pueden escoger las
variantes ya estudiadas.

Al ejecutar el programa observamos que el nivel varia rápidamente, para que

sea más efectiva la simulación se puede introducir un bloque de retardo, para
ello debemos utilizar la función “Wait Until” que tiene valor en milisegundos
ms, por ejemplo colocar 1000 ms equivalente a un segundo.
6.9. Convirtiendo temperatura

Diseña un programa que realice el llenado de un tanque de agua y que
aumente su temperatura en C° internamente el programa deberá hacer la
conversión a F°, finalmente activar una alarma luminosa cuando la temperatura
alcance 185F° que equivale a 85C°
Crear un nuevo VI en la barra de menú, agragaremos un control numerico de

tipo KNOB para regular la temperatura, 01 indicador numerico te tipo TANK,
01 indicador numerico LED y finalmente 02 botones

Ingresar la estructura de tipo WHILE, esta automáticamente insertara un botón

de STOP, esto quiere decir que todo el código que insertemos dentro de este
bloque se ejecutara hasta que presionemos ese botón. Ahora estableceremos
la primera condición que determinara el llenado del tanque con agua, si no
ejecutamos esta acción no se procederá a calentar el agua, esto lo
conseguimos insertando una estructura de tipo CASE y la conectamos al botón
BOMBA DE AGUA.
El botón BOMBA DE AGUA es un control booleano y cuando este es FALSO se

ejecuta una parte del programa que limpia todos los controles e indicadores
En el área de programación falsa de la estructura CASE, llevamos a CERO a

las propiedades de controles e indicadores, para obtener estas propiedades,
seleccionamos el control o indicador y hacemos clic derecho seleccionando la
opción CREATE/ PROPERTY NODE/ VALUE (debemos crear una propiedad
para cada control)

En el área de programación verdadera de la estructura CASE, insertaremos la

programación siguiente: primero conectaremos regulador de temperatura a una
función de comparación MAYOR O IGUAL que 85, esto nos dará un resultado
de verdad que ingresaremos a otra función denominada SELECT
La función SELECT podemos encontrarla en la paleta en la siguiente opción

FUNTIONS/ COMPARISON/ SELECT
El resultado de la función SELECT seta enviada a la propiedad FILL COLOR

que se encargará de cambiar el color del líquido del tanque cuando se cumpla
con la condición, este control escogerá entre dos constantes de color, rojo si es
verdadero y azul si es falso

El valor del tanque también será cambiado, cuando la propiedad valor del
tanque cambie a 90, indicando gráficamente que el tanque está lleno
Finalmente tenemos el código completo para nuestra aplicación

6.10. Editor de texto

Realice un programa que permita almacenar y leer los caracteres
almacenados en un control de tipo cadena, para realizar esta actividad
debemos conocer las funciones para el trabajo con ficheros que
respectivamente, leen y almacenan información en forma de caracteres ASCII
desde/hacia un fichero.
Primero debemos conocer las funciones para el manejo de ficheros, estas

funciones, se encuentran en la opción Functions/File I/O de la paleta de
funciones:

La primera de ellas se utiliza para escribir caracteres a un fichero que se

indica en file path, si no se indica ningún camino entonces aparece una caja
de diálogo de tipo Salvar Como (Save As...) que permite al usuario
especificar un nombre de fichero. En caso de que se especifique un fichero,
entonces se debe especificar si se quiere agregar los datos indicados en
la cadena de caracteres (character string) mediante una constante o
control booleano en true o reemplazar los datos del fichero existente
(constante o control booleano en false). Esta función tiene como salida el
nuevo camino donde el fichero fue escrito.
La segunda función tiene entradas similares en cuanto al camino y a la

interpretación del fin de línea, ahora en lectura presenta dos entradas que
indican la cantidad de caracteres a leer y el desplazamiento u offset dentro
del fichero a partir del cual comienza la lectura. Si no se especifica camino
también se abre una caja de diálogo del tipo Open. Esta segunda función
tiene 4 salidas, la primera igual a la de la primera función revisada, la
segunda conteniendo la cadena de caracteres leídos, la tercera (mark after
read) indica la posición del puntero del fichero después de la lectura
realizada (el puntero apuntando a la primera posición no leída) y por último,
EOF? si se produce un intento de lectura después de final del fichero.
Creación de la interfaz gráfica
En la solución incluimos dos botones booleanos que indicarán cuando

realizar la lectura o escritura de los datos contenidos en el control tipo

cadena desde o hacia el fichero, personalizaremos estos botones con las

siguientes etiquetas ABRIR, GUARDAR y STOP
Como siguiente paso seleccionar la acción mecánica para los botones: Latch
when Released (opción por defecto para los botones tipo OK) después de
agregar los botones y editar el texto de la etiqueta debemos tener en el panel
frontal lo siguiente:
Para agregar caracteres a nuestro programa insertaremos primero un control

string, después seleccionar al objeto desde la esquina inferior derecha y
redimensionar el mismo hasta el tamaño deseado, para lograr un
espacio de edición lo suficientemente grande, corresponde ahora programar
las acciones de los botones Abrir y Guardar.
Nuestro programa tiene controles de tipo booleano, por lo tanto, debemos

indicar que acciones realizar cuando esté en TRUE y que acciones realizar
cuando esté en FALSE (guardar o abrir el fichero)
Insertar una estructura de tipo WHILE, una estructura de tipo CASE para la
acción de Abrir y otro para Guardar, a continuación explicaremos cada una de
ellas:
ABRIR: conectaremos el STRING CONTROL a la función WRITE TO TEXT

FILE

Si no especificamos una ruta al programa, se abrirá una caja de diálogo para

salvar el fichero, en este caso debemos tener en cuenta que el área de
edición de texto es el mismo tipo de control string utilizado para copiar su
contenido en un fichero y por tanto, al ser un control, no acepta escritura
directa. Sin embargo hay una forma de copiar en dicho control y es creando
una variable local que lo represente al copiar en esa variable local de
hecho se escribe en el control cambiando su contenido.
Las siguientes figuras muestran los pasos para crear la variable así como el código
que se programa para el botón abrir y Guardar:
6.11. Creando un Sub VI
Vamos a modificar la actividad en la que trabajamos con Clúster y crearemos una

función que según una cantidad “N” elabore 2 arreglos el primero con N números
generados aleatoriamente y el segundo con el cuadrado de los números generados
en el primer arreglo

Realizamos las mismas operaciones que hicimos para la actividad de creación de

CLUSTERS
Desarrollo de la programación.
Nuestra Función no será un programa, por lo que no tendrá un botón para

terminar
Primero insertaremos la estructura FOR para garantizar la generación de los
números aleatorios, para ello agregaremos una función aleatoria y dos
operadores de multiplicación.
En la salida de la función FOR conectaremos dos indicadores que almacenarán

los valores generados en casa ciclo, la entrada de la estructura en lugar de
tener una constante como en otros casos tendrá un control numérico, que
permitirá insertar cualquier valor, esto permitirá generar “N” valores
La función que construiremos tendrá a los controles como parámetros de

entrada (generar N números) e indicadores como parámetros de salida (N
números y el cuadrado de N números)

LabVIEW es un lenguaje gráfico, podemos crear una representación gráfica

para nuestra función, para ello hacer clic en el icono de la parte superior
derecha del entorno del programa.
Aparecerá el editor de iconos que se presenta como una interfaz parecida a

Paint, en ella personalizaremos nuestra función.

Ahora definiremos los parámetros de entrada y salida para ello volvemos a dar
clic derecho sobre el icono y seleccionamos la opción “Show Connector”, se
muestra el siguiente icono que indica que tenemos un control y tres
indicadores en nuestro panel frontal (prototipo). Si quisiéramos adicionar
nuevos parámetros se selecciona la opción “Patterns”
Vincular cada control e indicador con su correspondiente área en el icono,

esto se realiza con el conector . Debemos marcar el área de conector que se
va a vincular, seleccionando el control que servirá como parámetro, cuando
esto suceda el área que era de color blanco tomara el color del tipo de dato de
la variable asociada (naranja, azul, rosado, verde)

6.12. Trabajando con un Sub VI
Realizar un programa que utilice la función creada en el ejemplo anterior y que

muestre en una tabla los valores generados en la función (10 números y el
cuadrado de estos) cuando activemos un control de tipo booleano
Agregar un control de tipo Booleano, luego insertaremos una tabla en la que se

mostrarán los valores generados por la función, para ello, seleccionamos en el
panel de controles la opción Controls/ Text Inds/ table
Agregaremos el encabezado a las columnas, haciendo clic derecho sobre la

tabla y seleccionamos la opción “Column headers”dentro de la opción “Visible
Items” luego se escribe dentro del encabezado con la herramienta del cursor

Desarrollo de la programación
Introducir la función creada en el ejemplo anterior en el código del programa,

para ello se debe utilizar el icono de la extrema izquierda de la paleta de
funciones , este icono abre un cuadro de dialogo para abrir un SubVI.

Colocaremos la función dentro de una estructura de tipo CASE, que
posteriormente será enlazada al control booleano, y se ejecutara el código
cada vez que presionemos el botón de generar
Colocar los parámetros de entrada, en este caso la cantidad de números

generados, esto podemos hacerlo insertando una constante de tipo numérico.
Insertaremos la función Build Array, para concatenar ambos arreglos y
enviarlos a la tabla
Insertaremos la función “Number to Fractional String” que se encargará de

convertir los números generados por la función en String, que serán
visualizados en la tabla
Ingresaremos la función “Transpose 2D Array” que convertirá el formato de
números de filas a columnas

Ejecutar el programa, presionando el botón y si se quiere ejecutar en modo

de depuración se pueden escoger las variantes ya estudiadas.

FUNDAMENTO TEÓRICO
Instrumentación virtual
Un instrumento virtual simula el panel frontal y el funcionamiento de un

instrumento real. Se basa en un ordenador, el software de instrumentación
virtual y elementos de adquisición de datos tales como tarjetas de adquisición
de datos o instrumentos externos que se comunican mediante buses de
propósito general o de instrumentación con el ordenador. El software de
instrumentación virtual permite realizar un programa que simula en la pantalla
del ordenador el panel frontal de un instrumento real así como la funcionalidad
de ese instrumento.
LabVIEW
LabVIEW es una herramienta de programación gráfica y modular utilizada para
crear instrumentación virtual. Los programas creados mediante LabVIEW son
los “instrumentos virtuales” o VI (virtual instrumento) que tienen un panel frontal
y un diagrama de bloques. La interface de usuario del instrumento se realiza en
la ventana del panel frontal y la funcionalidad del instrumento se programa en
la ventana de diagrama de bloques. A través del panel frontal el usuario
interactúa con el instrumento virtual mediante interruptores, controles
deslizantes, gráficos y otros tipos de controles e indicadores proporcionados
por LabVIEW. Utiliza un lenguaje de programación gráfico, el lenguaje G,
basado en bloques funcionales que se transfieren datos de distintos tipos. Los
bloques se seleccionan de un menú tipo paleta, con funciones que van desde
las aritméticas a funciones avanzadas de adquisición, control y rutinas de
análisis. Incluye también herramientas de depuración, de ayuda, ejecución
resaltada, paso a paso, probetas y puntos de ruptura para trazar y supervisar la
ejecución del flujo de datos. LabVIEW permite la creación de aplicaciones
profesionales con un mínimo de programación.
Las tarjetas de adquisición de datos suelen traer, además de los drivers,
instrumentos virtuales para LabVIEW que permiten hacer de interface con el
hardware.

En este capítulo estudiaremos al LabVIEW y entre sus principales

características podemos mencionar:
 Es Lenguaje de programación Simple e intuitiva, basado en un nuevo
lenguaje de programación grafica (programación G)
 Debido a que es un lenguaje de programación G cuenta con numerosas
herramientas gráficas (botones, indicadores y controles). Estas
herramientas serian muy difíciles de implementar en otro lenguaje
 Cuenta además con librerías especializadas para de DAQ, Redes,
Comunicaciones, Análisis Matemático, Comunicación con Bases de Datos
REQUERIMIENTOS
Para ejecutar LabVIEW en nuestro computador es necesario los siguientes
requerimientos como base tomados del sitio web del fabricante:
http://www.ni.com/labview/esa/requirements.htm
 Un procesador Pentium III – Celeron 866 pero se recomienda Pentium

IV
 Memoria RAM entre 256MB y 1GB
 Resolución de video: 1024X768
 Sistema operativo Windows Vista/XP/2000
 Disco duro: 1.6 GB
NI LabVIEW es un entorno intuitivo de desarrollo para crear aplicaciones
personalizadas que interactúan con datos y señales del mundo real. Diseñado
para ingenieros y científicos, LabVIEW ofrece herramientas y opciones de
programación que le ayudan a finalizar más rápido sus proyectos, se puede
descargar una versión de evaluación de la siguiente dirección:
http://www.ni.com/trylabview/esa/

Panel frontal
Los elementos del panel frontal son los controles e indicadores. Los controles
son las entradas del instrumento virtual, sobre las que actúa el usuario
mediante el ratón, y los indicadores son las salidas del instrumento que
permiten al usuario conocer los resultados en la pantalla del ordenador. Los
controles e indicadores se insertan desde la paleta de controles
Diagrama de bloques
El funcionamiento del instrumento virtual se programa en el diagrama de
bloques con el lenguaje gráfico G. En el diagrama de bloques tendremos
terminales y nodos conectados mediante cables. Los terminales son en general
puntos donde se puede conectar un cable. Dos tipos de bloques solo pueden
tener un terminal:
 Terminales correspondientes a los controles e indicadores del panel
frontal. El usuario introduce valores en los controles y tras la ejecución del
VI los resultados se muestran en los indicadores.
 Constantes. Constantes creadas por el usuario o constantes predefinidas
accesibles en la paleta de funciones.
Los nodos son los elementos que realizan la ejecución en el diagrama de

bloques, pueden tener más de un terminal:

 Funciones
 SubVIs
 Estructuras
 Nodos de Fórmula
 Nodos de Interface de Código
Estos bloques se cablean virtualmente unos con otros para transferirse los
datos. La ejecución del VI está dirigida por los datos, a medida que estos están
disponibles los bloques funcionales realizan operaciones con los datos y
proporcionan resultados para otros bloques.
Barra de herramientas
Esta tableta está disponible tanto en el panel frontal como en el diagrama de
bloques, las distintas herramientas se indican en la figura 3 son las siguientes:
 Operación: Cambia el valor de un control o selecciona el texto de un

control.
 Posicionado/tamaño/selección: Selecciona objetos y permite cambiar su
posición o tamaño. Edición de texto: Para editar texto o crear etiquetas
 Cableado: Para conectar terminales y nodos en el diagrama de bloques.
 Menú contextual: Se obtiene un menú personalizado para cada objeto.
Equivalente a botón derecho.
 Desplazamiento: Desplaza la ventana como con las barras de
desplazamiento.
 Puntos de ruptura: Pone puntos de ruptura en VIs, funciones y
estructuras.
 Probeta de datos: Puntos de prueba en cables.
 Toma de color: Toma el color de un objeto para pegarlo con la
herramienta de selección de color.
 Selección de color: Asigna el color del fondo y el primer plano de los
objetos.
Controles e indicadores del panel frontal

Los controles permiten al usuario, en tiempo de ejecución del VI, introducir
datos, parámetros, opciones, etc., son pues las entradas al VI. Los indicadores
permiten conocer resultados de la ejecución del VI ya sea de forma numérica,
gráfica, textual, etc., son las salidas del VI. Estos objetos tienen un terminal
correspondiente en el diagrama de bloques. La etiqueta propia (label ) es la
misma en el terminal que en su objeto. Nota: Si se pincha fuera de la etiqueta
antes de introducir el texto, ´esta desaparece. Se la vuelve a mostrar pulsando
el botón derecho dentro del control y seleccionando Show_Label. Se pueden

tener controles e indicadores de todos los tipos que aparecen en la paleta de

controles, entre ellos vamos a ver los siguientes:
 Numéricos
 Booleanos
 De cadena de caracteres (string)
 Enumerados
 Arrays
 Clusters
 Gráficos
Controles numéricos
Entre otros, los controles e indicadores numéricos (figura 4) pueden ser

digitales, de cursor deslizante, rotatorio y enumerado. Estos ´últimos son un
caso especial y se ven en un apartado aparte. Se puede cambiar entre otros
aspectos la representación y el formato en el menú contextual del objeto.
Representación: Los datos numéricos, en general, pueden ser enteros, de
coma flotante y complejos. Los datos enteros pueden ser con o sin signo y de
8, 16 y 32 bits (byte, word y Long). Los datos en coma flotante y los complejos
pueden ser de precisión simple, doble y extendida. Formato: Se puede elegir la
presentación numérica o temporal, el número de dígitos decimales y el tipo de
notación.
Controles booleanos
Son botones, LEDs e interruptores. El tipo de datos de estos controles es
booleano, sólo tiene dos valores: verdadero (true, on) y falso (false, off ). El
valor de los botones sin pulsar y de los interruptores abajo es falso (off ).

 Configuración de la acción mecánica de los controles booleanos Se

refiere al comportamiento del control booleano ante la acción del ratón.
El comportamiento puede ser el típico de un interruptor, o el de un
pulsador con o sin enclavamiento. La acción, además, puede ser debida
a la pulsación del botón o a su liberación. Hay 6 tipos de acciones
mecánicas posibles para los controles booleanos del panel frontal.
Estas acciones se seleccionan mediante el menú contextual. En los
esquemas de los iconos de la figura 5 la primera línea (m) expresa la
acción del botón primario del ratón según que se pulse o se libere, la
segunda línea (v) representa el cambio en el valor booleano del control,
y la tercera línea ilustra el comportamiento del control. El
comportamiento de los pulsadores con enclavamiento está relacionado
con el funcionamiento de LabVIEW, así el enclavamiento permite
asegurar que el valor del control es “leído” (RD de read) antes de que el
pulsador vuelva a su posición inicial. Leído significa que el valor pasa al
terminal o nodo que sigue.
Siguiendo el orden de los iconos, las acciones mecánicas son la

siguiente:
a) Switch When Pressed: Se trata de un interruptor cuyo valor cambia

cada vez que se pulse el botón del ratón.
b) Switch When Released: En este interruptor la acción se produce
cuando se libera el botón del ratón.
c) Switch Until Released: El comportamiento es el de un pulsador,
cambiando el valor desde que se pulsa el botón del ratón hasta que se
suelta.

d) Latch When Pressed: Es un pulsador con enclavamiento, cuando se

pulsa el botón del ratón el valor cambia pero no vuelve hasta que el
valor del control es “leído” por primera vez desde su enclavamiento.
e) Latch When Released: En este pulsador el enclavamiento se produce al
soltar el botón del ratón. También vuelve a su valor por defecto cuando
es “leído” por primera vez desde su enclavamiento.
f) Latch Until Released: El pulsador se enclava al pulsarse el botón del
ratón, pero se libera con la primera “lectura” después de soltar el botón
del ratón.
Controles de cadena de caracteres

Las cadenas de caracteres (string) son colecciones de caracteres en código
ASCII.
Controles enumerados
Se trata de listas enumeradas. Cada posición de la lista se rellena con texto y

le corresponde un número entero, empezando por 0. Este valor numérico se
puede ver mostrando el Display digital (Menú contextual Show_Digital
Display). Dentro del diagrama de bloques el terminal del control es un número
entero con el valor de la posición seleccionada desde el panel frontal.
Arrays
Un array es una colección ordenada de datos, todos ellos del mismo tipo. El
número de datos es variable. Puede tener una o más dimensiones y hasta 231
− 1 elementos por dimensión (si hay memoria). Para acceder a cada dato se
utiliza un ´índice por cada dimensión. Los ´índices empiezan en 0. En el panel
frontal se puede utilizar un array como control o como indicador. Primero se
inserta el array (ver figura 6) y, a continuación, se inserta un control o un

indicador del tipo deseado. Todos los elementos del array serán controles o
todos indicadores.
Clusters
Colección de datos heterogénea. Los elementos pueden ser de distinto tipo
pero todos deben ser controles o todos indicadores. Un clúster de control o
indicador se inserta en el panel frontal de forma similar a un array. Un tipo de
clúster predefinido se utiliza para el manejo de errores. Los clúster error in y
error out permiten transmitir los posibles errores de un subVI a otro. Estos
clúster están constituidos por tres componentes: Un valor booleano indica la
presencia o ausencia de error. Un valor numérico entero se corresponde con el
número de error. Una cadena de caracteres permite conocer el origen del error.
Indicadores gráficos
De los cinco tipos de gráficos se explican los gráficos Waveform Chart,
Waveform Graph y XY Graph.
 Waveform Chart
Permite representar gráficos de datos numéricos. El gráfico se
representa punto por punto. Los números escalares que llegan al
indicador son la coordenada Y del gráfico mientras que la coordenada X
de cada punto se calcula automáticamente desde un valor inicial X0 (por
defecto 0) y se incrementa con dX (por defecto 1). El menú contextual
del gráfico permite auto escalar las coordenadas X e Y, modificar los
valores por defecto de X0 y dX, cambiar el formato y precisión del
gráfico y las opciones de la rejilla del gráfico (figura 7).
 Waveform Graph
Se trata de un indicador gráfico de datos numéricos. A diferencia del
Waveform Chart, este no tiene memoria, no se representa punto por
punto sino como un bloque. Para representar un gráfico el dato que
llega debe ser un array. Cada elemento del array será la coordenada Y
del punto. Los puntos quedan representados en el mismo orden que
están en el array empezando por el de menor ´índice. La coordenada X
del primer punto (X0) se incrementa desde el valor del primer elemento
del array con cada punto en la cantidad dX. El menú contextual del
Waveform Graph permite las mismas opciones que el Waveform Chart.
Para representar más de un gráfico, en lugar de un array
unidimensional, se debe enviar un array bidimensional donde cada fila
es un gráfico distinto

 XY Graph
Es un indicador gráfico para datos numéricos. Igual que el Waveform
Graph representa los datos como bloques, pero a diferencia de ´este.
Se deben proporcionar las coordenadas X e Y de cada punto en forma
de dos vectores unidos en un clúster
Estructuras y elementos de programación
Para realizar un programa en cualquier lenguaje se debe conocer el manejo de

las estructuras que gobiernan un algoritmo, las estructuras en LabVIEW son:
 Los ciclos While
 Los ciclos For-Next
 Los cuadros de CASE
 Las secuencias
Otros elementos de programación son las variables, que pueden ser de tipo
global o local, y los cuadros de fórmula.
Estructura WHILE
Sirven para hacer que una secuencia de instrucciones se repita una cantidad
de veces, siempre y cuando una afirmación sea verdadera. En LabVIEW se
ejecutarán las funciones u operaciones que se encuentren dentro del cuadro
del ciclo, tomando los valores que quedaron almacenados en los registros de
entrada, y sacando los resultados a los registros de salida.
La flecha circular es el parámetro que al recibir un valor de true (verdadero),
permite repetir el ciclo, y al recibir un falso, lo detiene, al ocurrir esto el dato
que haya en el registro se mostrara en el indicador c.

Los datos a, y b solo llegan una vez al registro de entrada y quedan

almacenados en un buffer para ser usados todas las veces que el ciclo repita.
En el programa se sumará en cada ciclo el valor de ‘a’ con el contador que en
cada iteración aumenta 1, el dato se mostrará en ‘d’ y se llevará al registro de
salida, donde se almacena hasta que termine el ciclo. En la iteración siguiente
un nuevo dato llega a la frontera borrando el anterior, cuando el loop para, solo
el último valor pasa a ‘c’.
Constantemente se evalúa si el valor ‘b’ es mayor o igual al contador. Cuando
este contador alcanza a b, la comparación se vuelve falsa y el ciclo se detiene.
INDEXING. Los ciclos se pueden utilizar para crear matrices simplemente

acumulando los datos en la frontera de salida, sin permitir que el último borre el
primero, y más bien apilándolos en una matriz. Esto se logra sacando el menú
pop-up del punto negro del registro de salida, el cual es el elemento de
memoria o buffer, y seleccionar “Enable indexing”. Haciendo el alambre de
salida es grueso.
SHIFT REGISTER.-Permiten que los resultados de un ciclo sirvan como datos
para la próxima iteración, mediante memorias llamadas Shift Register, las
cuales se crean sacando el menú pop-up del ciclo en una de las fronteras.
Después del ciclo el dato resultado colocado en el registro de la frontera de
salida, se graba en el registro de entrada para participar en las funciones del
ciclo (para cualquier tipo de dato)
Debemos agregar un valor inicial a la memoria del registro de entrada. Es
posible almacenar no solo datos de la última iteración, sino de la penúltima, y
muchas anteriores, agregando shift’s a la entrada, por medio del pop-up menú
del registro, con Add Shift Register.

Estructura FOR
Se comporta similar al ciclo While este hace un número definido de iteraciones
definido por el parámetro ‘N’. Este siempre debe ser definido, pues de no
suceder así el programa no corre.
También se puede usar para crear matrices, y también puede usar valores de
ciclos anteriores con los Shift register. Tiene la desventaja respecto al ciclo
while de tener que cumplir todas las iteraciones para terminar, mientras que en
el while, se termina dependiendo de una condición, por tanto se puede crear un
algoritmo que cuando detecte un error termine el ciclo. Mientras que el for-next
es un ciclo ciego, el while siempre se está chequeando.
El ciclo For-Next- también cuenta con un elemento ‘i’ que sirve de contador
para decir en que ciclo va.
Estructura CASE
Es una estructura de comparación y ejecución condicionada donde de acuerdo
a algún parámetro se realizan las operaciones de un cuadro u otro. Si el
parámetro de condición es del tipo verdadero-falso cuando éste es verdadero
se ejecuta un contenido, y cuando es falso se ejecuta otro. De esta forma solo
son posibles dos opciones de ejecución. Si el parámetro es un número, en este
caso puede haber tantas opciones de ejecuciones como se desee.
Para obtener esta estructura, buscarla en el submenú de estructuras &
constantes, en el menú de funciones.

Indicador
de número
de caso
Para agregar un cuadro de CASE con un parámetro de selección numérico,

debemos seleccionar el menú pop-up de la estructura y seleccionar “Add Case
After” o “Add Case Before”. Para ver el contenido de cada caso, solo basta
seleccionarlo con las flechas del indicador del caso.
Secuencias
Labview es un lenguaje de tipo multiproceso, puede ejecutar varias partes del
programa simultáneamente. Además las funciones se van operando cuando
llegan todos los parámetros de entrada sin saber cual se ejecuta primero, para
ejecutar un conjunto de operaciones se puede agregar una estructura de
secuencias, de esta manera se ejecuta cuadro por cuadro
Para agregar un cuadro adicional tal como en las estructuras case, se logra por
medio del menú pop-up en el borde del marco, Add Frame. Para seleccionar el
cuadro en el que se edita se usa el indicador en el extremo superior del marco.

En el ejemplo se aprecian dos ciclos los cuales al ejecutarlos lo hacen

simultáneamente, así al presionar el botón de esto de cada uno, se detienen
independientemente. Los ciclos simplemente cuentan números.
Si se desea que primero pase el ciclo uno y al presionar de éste pase al
segundo, se puede lograr tal efecto con los cuadros de secuencia así:
Cuadros de Formula
Los bloques de formula son empleados cuando queremos empaquetar muchas
funciones y cálculos matemáticos en un solo icono y implicar todos los cables y
conexiones que dificultan en entendimiento del diagrama y aumentan el tiempo
de programación. Debemos ingresar las funciones textualmente agregándose
después conectores de entrada y salida de datos (parámetros inscritos) Para
agregar entradas o salidas debemos seleccionar en el menú pop-up Add
Input o Add Output. (El bloque de fórmula se encuentra en el menú de
funciones, estructuras y constantes)
Como regla después de cada función se debe colocar un punto y coma “;”

Creación de un programa en LabVIEW

Diseñar un programa que realice dos operaciones simultáneamente (suma,
resta) entre dos números, los resultados deben mostrarse en un indicador
para cada operación
Primero seleccionaremos un nuevo VI en la barra de menú, aparecerá un
panel frontal sin ningún elemento
Seleccionemos dos controles y dos indicadores desde paleta de controles,

en la opción “controls”, personalizamos las etiquetas de cada elemento
para poder identificar los resultados obtenidos por cada función.
Para cambiar del panel frontal para editar en el diagrama de bloques

presionar CTRL + E, ahora vamos a realizar las operaciones de SUMA y

RESTA, debemos seleccionar ambas funciones de la paleta en la opción

“Numeric”, opciones “Add” y “Subtract”
Luego de insertar las funciones realizaremos las conexiones, a los controles

numéricos que serán las entradas, los indicadores numéricos mostraran los
resultados de las operaciones al usuario del programa
 Podemos observar que mientras no estén terminadas todas las conexiones

correctamente, el botón de ejecutar mostrará una flecha rota y de color
gris, debiendo der de color blanco
 Como paso final debemos presionar el botón ejecutar y el programa

Fundamentos de Informatica

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Fundamentos de Informatica

Diunggah oleh

Hak Cipta:

Format Tersedia

Fundamentos de Informática

DETERMINAR LOS PERIFÉRICOS INTERNOS Y EXTERNOS DE UNA PC ............................................................ 6

2. MANEJO DE LAS TIC......................................................................................................... 52

Programa Nacional de Informática 1

3. REPRESENTACIÓN DE UN PROBLEMA EMPLEANDO ALGORITMOS ..................................... 88

REPRESENTACIÓN DE PROBLEMAS CON ALGORITMOS. ........................................................................ 89

4. SOLUCIONA PROBLEMAS EMPLEANDO LENGUAJES DE PROGRAMACIÓN ....................... 125

RESUELVE PROBLEMAS EMPLEANDO OPERADORES MATEMÁTICOS. ........................................................ 126

Programa Nacional de Informática 2

OPERADORES ARITMÉTICOS ................................................................................................................... 153

5. REALIZA PROGRAMACIÓN ESTRUCTURADA .................................................................... 164

RESUELVE PROBLEMAS EMPLEANDO CONDICIONES REPETITIVAS. .......................................................... 165

6. REALIZA PROGRAMAS DE APLICACIÓN............................................................................ 192

DESARROLLA PROYECTOS DE APLICACIÓN EN WINDOWS .................................................................... 193

Programa Nacional de Informática 3

6.11. CREANDO UN SUB VI................................................................................................................ 218

Programa Nacional de Informática 4

El mundo de hoy, está inmerso en una nueva revolución

Esta última década ha sido extraordinariamente rica en

Programa Nacional de Informática 5

 Instalación de los diferentes equipos a nivel físico

Determinar los periféricos internos y externos de una

1.1. Instalación de software de diagnóstico.

Luego se nos presenta la ventana de descripción del programa indicando la

Programa Nacional de Informática 6

En la siguiente ventana el fabricante del software presenta los términos y

A continuación el asistente de instalación nos muestra la ruta en la que se

Como paso siguiente seleccionar si queremos que el programa tenga un

Programa Nacional de Informática 7

Finalmente se producirá el proceso de descarga de archivos al computador y

1.2. Determinando las características del Hardware

Programa Nacional de Informática 8

A continuación veremos otras opciones del programa:

Motherboard muestra las características del fabricante, Propiedades de

Programa Nacional de Informática 9

Chipset las características del Puente Porte, controlador de Memoria, etc.

Monitor detalla la información del adaptador de video, drivers de video,

La opción almacenamiento, muestra la información de los discos duros

Programa Nacional de Informática 10

información de las particiones: Monitor/ Video de Windows, podemos

Red, Multimedia, dispositivos de Hardware muestra la información de

Monitoreo de Hardware Muestra la información acerca de los sensores

Programa Nacional de Informática 11

1.3. Generando Reportes del Equipo

Existen tres tipos de archivos de reporte: texto plano, HTML personalizable y

Programa Nacional de Informática 12

Luego escogeremos la opción: Solamente resumen del sistema luego

Ahora seleccionaremos uno de los tipos de informe disponible

1.4. Determinando las características del

Programa Nacional de Informática 13

Escribimos el comando DXDIAG en la ventana de ejecutar programas

Con los datos del fabricante y modelo de Mainboard, buscaremos en

En la Página Web del fabricante podemos encontrar las características

Programa Nacional de Informática 14

Ingresaremos al link con las especificaciones del chipset.

En la ventana del Chipset, seleccionar la opción de Diagramas del Sistema,

Programa Nacional de Informática 15

Administra el Hardware de una computadora

1.5. Administra las particiones y discos duros del

En esta actividad el participante aprenderá a usar la herramienta Administrador

Seleccionamos el botón de inicio, seleccionamos de las propiedades del equipo

Se abrirá el programa de administración de equipos, para ver el estado del los

Podemos observar la relación de discos y unidades instaladas