Apunte Herramientas Informaticas

80
UNIVERSIDAD TECNOLÓGICA NACIONAL FACULTAD REGIONAL CÓRDOBA TECNICATURA DE MECATRÓNICA HERRAMIENTAS INFORMÁTICAS Ing. Centeno, Carlos Ing. Avramovich, Javier A.

Transcript of Apunte Herramientas Informaticas

Page 1: Apunte Herramientas Informaticas

UNIVERSIDAD TECNOLÓGICA NACIONAL

FACULTAD REGIONAL CÓRDOBA

TECNICATURA DE MECATRÓNICA

HERRAMIENTAS INFORMÁTICAS

Ing. Centeno, Carlos

Ing. Avramovich, Javier A.

Page 2: Apunte Herramientas Informaticas

A la memoria de mi padre; Boris Avramovich, quien fuera mi primer maestro en el mundo de la electrónica.

+

Page 3: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 3

TABLA DE CONTENIDO Tabla de Contenido ...................................................................................................................... 3 Informática. ................................................................................................................................... 7 Computadora................................................................................................................................ 7

Arquitectura de una computadora............................................................................................. 7 Funcionamiento......................................................................................................................... 8 Flujo de datos............................................................................................................................ 9

Hardware. ................................................................................................................................... 10 Componentes básicos del Hardware.......................................................................................... 10

Placa principal......................................................................................................................... 10 Microprocesador. .................................................................................................................... 11 El coprocesador aritmético...................................................................................................... 11 La memoria. ............................................................................................................................ 11 Memoria ROM......................................................................................................................... 11 Memoria RAM. ........................................................................................................................ 11 Fuente de alimentación........................................................................................................... 12 Dispositivos de crecimiento (Slots). ........................................................................................ 12

Periféricos................................................................................................................................... 12 Tipos de periféricos................................................................................................................. 13 Otros conceptos y curiosidades .............................................................................................. 14

Software...................................................................................................................................... 14 Tipología del software................................................................................................................. 15 Los sistemas operativos. ............................................................................................................ 15 Lenguajes de Programación....................................................................................................... 16

Lenguaje de maquina:............................................................................................................. 16 Lenguaje de bajo nivel (ensambladores) ................................................................................ 16 Lenguaje de alto nivel. ............................................................................................................ 17 Características de los lenguajes de programación: ................................................................ 17

Formas del software ................................................................................................................... 17 El proceso de creación de software............................................................................................ 18 Programación. ............................................................................................................................ 18

Programas y algoritmos. ......................................................................................................... 18 Compilación. ........................................................................................................................... 18 Programación e ingeniería del software.................................................................................. 19 Objetivos de la programación ................................................................................................. 19

Concepto de "programa" ............................................................................................................ 20 Concepto de “función” ................................................................................................................ 21

Nombre, valor de retorno y argumentos de una función......................................................... 21 La función principal o función main() ...................................................................................... 23 Palabras claves del C ............................................................................................................. 23

Elementos................................................................................................................................... 24 Comentarios............................................................................................................................ 24 Identificadores......................................................................................................................... 24 Variables ................................................................................................................................. 24 Constantes.............................................................................................................................. 24 Operadores ............................................................................................................................. 24 Sentencias .............................................................................................................................. 25

Tipos........................................................................................................................................... 26 Unidades de medida empleadas en informática......................................................................... 27

Los bytes, Kilobytes, Megabytes............................................................................................. 27 Los bits.................................................................................................................................... 27

Sistemas de numeración ............................................................................................................ 28

Page 4: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

4 Ing. Prof. Avramovich, Javier A.

Sistema binario ....................................................................................................................... 28 Sistema Hexadecimal ............................................................................................................. 29

Diagramas de Flujo .................................................................................................................... 31 Programación Estructurada .................................................................................................... 31

Comando #include...................................................................................................................... 32 Estructuras Secuenciales ........................................................................................................... 33 Función printf() .......................................................................................................................... 33 Función scanf().......................................................................................................................... 36 Estructuras Selectiva.................................................................................................................. 38 Función if ................................................................................................................................... 38 funcion if-else ............................................................................................................................ 39 funcion if-else-if .......................................................................................................................... 41 El operador condicional ? ........................................................................................................... 42 Función switch............................................................................................................................ 43 Estructuras repetitivas ................................................................................................................ 46 Sentencia While.......................................................................................................................... 46 Sentencia Do-While.................................................................................................................... 49 Sentencia for .............................................................................................................................. 52

El operador coma (,) .............................................................................................................. 53 Sentencia Break y continue........................................................................................................ 55

Break....................................................................................................................................... 55 Continue.................................................................................................................................. 55

Sentencia goto............................................................................................................................ 57 Tipos de datos estructurados ..................................................................................................... 58 Vector o array ............................................................................................................................. 58

Consulta de un array............................................................................................................... 58 Asignación de datos a un array .............................................................................................. 59

Matriz o array bidimensional....................................................................................................... 61 Consulta.................................................................................................................................. 62 Asignación .............................................................................................................................. 62

Arreglos multidimencionales....................................................................................................... 63 Funciones ................................................................................................................................... 63

Definición de una función........................................................................................................ 64 Prototipos de una función. ...................................................................................................... 65 Llamada a una función............................................................................................................ 65 Ejemplo: .................................................................................................................................. 65

Conexión y programación del puerto paralelo. ........................................................................... 67 El puerto paralelo en un PC.................................................................................................... 67 El Registro de Datos. .............................................................................................................. 68 El Registro de Estado. ............................................................................................................ 68 El Registro de Control............................................................................................................. 69 Asignación de pines en el conector DB25 Hembra del puerto paralelo.................................. 70 Entradas y salidas por el puerto paralelo................................................................................ 71 Características E/S. ................................................................................................................ 71

Apéndice A - Tabla de Caracteres ASCII ................................................................................... 74 Apéndice B – Métodos de ordenamiento y búsqueda................................................................ 75

Ordenamiento. ........................................................................................................................ 75 Método de la burbuja .............................................................................................................. 75

Apéndice C – Interfase para puerto paralelo.............................................................................. 78 Introducción. ........................................................................................................................... 78 Descripción. ............................................................................................................................ 78 Lista de materiales:................................................................................................................. 78

Page 5: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 5

Diagrama electrónico: ............................................................................................................. 79 Placa PCB:.............................................................................................................................. 79

Page 6: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

6 Ing. Prof. Avramovich, Javier A.

Page 7: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 7

INFORMÁTICA. La informática es la disciplina que estudia el tratamiento automático de la información utilizando dispositivos electrónicos y sistemas computacionales. También es definida como el procesamiento de información en forma automática. Para ello los sistemas informáticos deben realizar las siguientes tareas básicas:

Entrada: Captación de información.

Procesamiento o tratamiento de dicha información.

Salida: Transmisión de resultados.

El vocablo Informática proveniente del francés ‘informatique’, acuñado por el ingeniero Philippe Dreyfus en 1962, acrónimo de las palabras ‘information’ y ‘automatique’. En lo que hoy conocemos como informática confluyen muchas de las técnicas y de las máquinas que el hombre ha desarrollado a lo largo de la historia para apoyar y potenciar sus capacidades de memoria, de pensamiento y de comunicación.

La informática se utiliza en diversidad de tareas, por ejemplo: elaboración de documentos, monitorización y control de procesos, robots industriales, telecomunicaciones, desarrollo de juegos, aplicaciones/herramientas multimedia, etc.

En la informática convergen los fundamentos de las ciencias de la computación (hardware), la programación y las metodologías para el desarrollo de software, la arquitectura de computadores, las redes de datos como Internet, la inteligencia artificial, así como determinados temas de electrónica. Se puede entender por informática a la unión sinérgica de todo este conjunto de disciplinas.

COMPUTADORA Una computadora (del latín ‘computare’ -calcular-), también denominada como ordenador o computador es un sistema digital con tecnología microelectrónica, capaz de recibir y procesar datos a partir de un grupo de instrucciones denominadas programas, y finalmente transferir la información procesada o guardarla en algún tipo de dispositivo o unidad de almacenamiento.

La característica principal que la distingue de otros dispositivos similares, como una calculadora no programable, es que puede realizar tareas muy diversas cargando distintos programas en la memoria para que el procesador los ejecute.

Arquitectura de una computadora

Dispositivos de Entrada/Salida

Registros

ALU Unidad deControl

Memoria

ProgramaArea de datos

Area de codigos

Bus del sistema

001101001110011100001011111100001010101010011010001100111101110001110010101100101011

100110110110011100001111100001010101010101111000011001111011100000111010110010101110101001011111111110

Aunque las tecnologías empleadas en las computadoras digitales han cambiado mucho desde que aparecieron los primeros modelos en los años 40, la mayoría todavía utiliza la arquitectura

Page 8: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

8 Ing. Prof. Avramovich, Javier A.

Eckert-Mauchly, publicada a principios de los años 1940 por John von Neumann pero que fue creada por John Presper Eckert y John William Mauchly.

La arquitectura Eckert-Mauchly describe una computadora con 4 secciones principales: la unidad lógica y aritmética (ALU), la unidad de control, la memoria, y los dispositivos de entrada y salida (E/S). Estas partes están interconectadas por un conjunto de cables denominados buses:

La memoria es una secuencia de celdas de almacenamiento numeradas, donde cada una es un bit o unidad de información. La instrucción es la información necesaria para realizar lo que se desea con el computador. Las «celdas» contienen datos que se necesitan para llevar a cabo las instrucciones, con el computador. El número de celdas varían mucho de computador a computador, y las tecnologías empleadas para la memoria han cambiado bastante; van desde los relés electromecánicos, tubos llenos de mercurio en los que se formaban los pulsos acústicos, matrices de imanes permanentes, transistores individuales a circuitos integrados con millones de celdas en un solo chip. En general, la memoria puede ser reescrita varios millones de veces (memoria RAM); se parece más a una pizarra que a una lápida (memoria ROM) que sólo puede ser escrita una vez.

El procesador (también llamado Unidad central de procesamiento o CPU) consta de un típico símbolo esquemático para una ALU: A y B son operandos; R es la salida; F es la entrada de la unidad de control; D es un estado de la salida.

La unidad lógica y aritmética o ALU es el dispositivo diseñado y construido para llevar a cabo las operaciones elementales como las operaciones aritméticas (suma, resta), operaciones lógicas (Y, O, NOR), y operaciones de comparación o relacionales. En esta unidad es en donde se hace todo el trabajo computacional.

La unidad de control sigue la dirección de las posiciones en memoria que contiene la instrucción que el computador va a realizar en ese momento; recupera la información poniéndola en la ALU para la operación que debe desarrollar. Transfiere luego el resultado a ubicaciones apropiadas en la memoria. Una vez que ocurre lo anterior, la unidad de control va a la siguiente instrucción (normalmente situada en la siguiente posición, a menos que la instrucción sea una instrucción de salto, informando a la computadora de que la próxima instrucción estará ubicada en otra posición de la memoria).

Los dispositivos E/S sirven a la computadora para obtener información del mundo exterior y/o comunicar los resultados generados por el computador al exterior. Hay una gama muy extensa de dispositivos E/S como teclados, monitores, y unidades de disco flexible o cámaras web.

Funcionamiento. Las instrucciones que se ejecutan en un computador, no son las ricas instrucciones del ser humano. Una computadora sólo se diseña con un número limitado de instrucciones bien definidas. Los tipos de instrucciones típicas realizadas por la mayoría de las computadoras son como estos ejemplos:

Page 9: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 9

- Copia los contenidos de la posición de memoria 123. - Coloca la copia en la posición 456. - Añade los contenidos de la posición 666 a la 042. - Coloca el resultado en la posición 013. - Si los contenidos de la posición 999 son 0. - Tu próxima instrucción está en la posición 345.

Las instrucciones dentro del computador se representan mediante números. Por ejemplo, el código para copiar puede ser 001. El conjunto de instrucciones que puede realizar un computador se conoce como lenguaje de máquina o código máquina. En la práctica, no se escriben las instrucciones para los computadores directamente en lenguaje de máquina, sino que se usa un lenguaje de programación de alto nivel que se traduce después al lenguaje de la máquina automáticamente, a través de programas especiales de traducción (intérpretes y compiladores). Algunos lenguajes de programación representan de manera muy directa el lenguaje de máquina, como el lenguaje ensamblador (lenguajes de bajo nivel) y, por otra parte, los lenguajes como Java, se basan en principios abstractos muy alejados de los que hace la máquina en concreto (lenguajes de alto nivel).

Por lo tanto, el funcionamiento de un computador es en principio bastante sencillo. El computador trae las instrucciones y los datos de la memoria. Se ejecutan las instrucciones, se almacenan los datos y se va a por la siguiente instrucción. Este procedimiento se repite continuamente, hasta que se apaga el computador. Los Programas de ordenador (software) son simplemente largas listas de instrucciones que debe ejecutar el computador, a veces con tablas de datos. Muchos programas de computador contienen millones de instrucciones que se ejecutan a gran velocidad; un computador personal moderno puede ejecutar de 2000 a 3000 millones de instrucciones por segundo. Las capacidades extraordinarias que tienen los computadores no se deben a su habilidad para ejecutar instrucciones complejas. Los computadores ejecutan millones de instrucciones simples diseñadas por programadores. Hay programadores que desarrollan grupos de instrucciones para hacer tareas comunes (por ejemplo, dibujar un punto en la pantalla) y luego ponen dichos grupos de instrucciones a disposición de otros programadores para que estos elaboren funciones o tareas más complejas.

Flujo de datos. El mapa conceptual muestra, en forma básica, como funciona el flujo de los datos en una computadora, para luego convertirse en información útil para el usuario. Podemos notar que los datos comúnmente fluyen según esta secuencia:

DMA(Acceso Directo a Memoria)Entrada de datos o información

Microprocesador Memoria RAM

Salida directade información

Almacenamientode la información

Page 10: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

10 Ing. Prof. Avramovich, Javier A.

Ejemplos:

Entrada de datos o información: Teclado, Mouse, micrófono, escáner.

Almacenamiento de información: Disco rígido, CD, DVD, USB Drive.

Salida directa de información: Monitor, parlantes, impresora.

Existe también la entrada de datos directamente a la RAM, sin la intervención previa del microprocesador; este modo de acceso se denomina Acceso Directo a Memoria. La memoria RAM está en constante comunicación con el microprocesador (en el diagrama, procesamiento), de forma mucho más rápida que cualquier otro dispositivo de almacenamiento. Finalmente la información (los datos procesados) es almacenada en algún disco, o bien, sale directamente de forma analógica o digital de la computadora, ya sea hacia el monitor, los altavoces la impresora o cualquier otro dispositivo que reciba y proyecte la información.

HARDWARE. Hardware es un neologismo proveniente del inglés definido como el conjunto de elementos materiales que conforman una computadora, sin embargo, es usual que sea utilizado en una forma más amplia, generalmente para describir componentes físicos de una tecnología, así el hardware puede ser de un equipo militar importante, un equipo electrónico, un equipo informático o un robot. En informática también se aplica a los periféricos de una computadora tales como el disco duro, CD-ROM, disquetera (floppy), etc... En dicho conjunto se incluyen los dispositivos electrónicos y electromecánicos, circuitos, cables, armarios o cajas, periféricos de todo tipo y cualquier otro elemento físico involucrado.

El hardware se refiere a todos los componentes físicos (que se pueden tocar), en el caso de una computadora personal serían los discos, unidades de disco, monitor, teclado, la placa base, el microprocesador, etc. En cambio, el software es intangible, existe como información, ideas, conceptos, símbolos, pero no ocupa un espacio físico, se podría decir que no tiene sustancia. Una buena metáfora sería un libro: las páginas y la tinta son el hardware, mientras que las palabras, oraciones, párrafos y el significado del texto (información) son el software. Una computadora sin software sería tan inútil como un libro con páginas en blanco.

COMPONENTES BÁSICOS DEL HARDWARE.

Placa principal. También llamada Tarjeta Madre o Motherboard es donde se encuentran las conexiones básicas para todos los componentes de la computadora, los cuales giran en torno al microprocesador. Es básicamente la que permite o no el futuro crecimiento de las habilidades de cualquier computadora, una tarjeta con una arquitectura muy cerrada terminará con la vida de todo el equipo en el momento que ésta requiera una reparación o mejora, éste fue el caso de la mayoría de las computadoras que existieron en el pasado, como por mencionar algunas, podemos citar a la Comodore 64, Tandy 1000 e incluso todas las XT´s y algunas 286 de IBM.

Estas se pueden clasificar en la actualidad en:

Arquitectura de 8 bits: Primeras XT.

Arquitectura ISA 8 -16 bits. La mayoría de las actuales clones.

Arquitectura EISA o MCA de 32 bits. La mayoría de las de IBM o compatibles de marca de calidad que se venden actualmente.

En ella podemos encontrar los siguientes componentes:

Page 11: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 11

Microprocesador. Es en sí el cerebro, el cual se compone a su vez de Unidad Aritmética, lógica y de control. Esta unidad trabaja en base a un reloj (clock) maestro que coordina la ejecución de todas las operaciones que realiza el microprocesador.

La unidad fundamental de trabajo de este reloj es la cantidad de instrucciones que el microprocesador puede ejecutar en un segundo. Así, un clock de 12 MHz limita al microprocesador a realizar 12 millones de instrucciones por segundo.

La rapidez y poder de ejecución de tareas esta determinado completamente por el microprocesador el cual subdivide a las computadoras en diferentes tipos, entre ellos algunas ya obsoletas como son : las llamadas 8086 XT (80286, 80386, 80486) y Pentium (80586), bautizadas así por la compañía fabricante INTEL la cual ha proveído desde las primeras PC’s y hasta hoy a la mayoría de las computadoras con sus modelos de cerebro.

Sin embargo Intel no es ya el único fabricante de microprocesadores para las computadoras personales, compiten también en el mercado compañías como Cyrix, AMD, Power Pc, Digital Equipment, etc. Sin embargo, aunque en competencia, la mayoría de esas compañías ofrecen microprocesadores equivalentes a los estándares ofrecidos serie a serie por Intel Corporation.

El modelo de un microprocesador nos indica sobre todo el poder o sea el potencial de tareas que un microprocesador puede ejecutar a la vez y su reloj nos indica su velocidad de sincronización con la cual éstas son realizadas. Así entre una computadora 286 y una 486 hay una notable diferencia de poder y velocidad incomparables ya que a la primera no podremos agregarle u ordenarle tantas cosas como a la segunda; y por otro lado entre una 486 de 25 Mhz y una 486 de 50 Mhz estamos hablando que las dos tienen el mismo poder, pero la segunda dobla la velocidad a la primera.

El coprocesador aritmético. Es un microprocesador de instalación opcional, también denominado unidad de punto flotante que auxilia al microprocesador en el uso eficiente de programas de graficación, cálculos matemáticos complejos y diseño entre tantos, lo cual al especializarse en dichas funciones acelera la velocidad con que una computadora puede responder a necesidades tan sofisticadas.

En la actualidad ya vienen incluidos en todas las computadoras nuevas, ya que el poder que exigen no puede descartar la falta de éste coprocesador.

La memoria. Es la capacidad de almacenar información, su unidad de almacenamiento es el BYTE que es la capacidad de almacenar un carácter, una letra, número o cualquier símbolo como #,$,&, etc. Se clasifican en memoria ROM y RAM.

Memoria ROM. Esta memoria es sólo de lectura (Read Only Memory), y sirve para almacenar el programa básico de iniciación, instalado desde fábrica. Este programa entra en función en cuanto es encendida la computadora y su primer función es la de reconocer los dispositivos.

Memoria RAM. Esta es la denominada memoria de acceso aleatorio (Random Access Memory) o sea, como puede leerse también puede escribirse en ella, tiene la característica de ser volátil, esto es, que sólo opera mientras esté encendida la computadora. En ella son almacenadas tanto las

Page 12: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

12 Ing. Prof. Avramovich, Javier A.

instrucciones que necesita ejecutar el microprocesador como los datos que introducimos y deseamos procesar, y los resultados obtenidos de esto.

Como puede usted ver, si al momento de apagar nuestra computadora se volatilizan nuestro datos almacenados en la memoria RAM, requerimos por lo tanto, de medios que almacenamiento por tiempo indefinido que nos garanticen la seguridad y confiabilidad de nuestros datos, o sea, otro tipo de memorias, que definiremos como memorias auxiliares, entre ella ubicamos al disco duro, los disquete, los CD/DVD, los pen drive, etc.

Fuente de alimentación. Tanto el microprocesador como todos los circuitos que forman los dispositivos se alimentan de cantidades de energía bien definidas y precisas, o sea necesitan de una fuente que les suministre y regule la cantidad necesaria ya que cualquier variación en el voltaje podría ser suficiente para quemar dichos circuitos.

Dispositivos de crecimiento (Slots). Son las puertas que están listas para recibir la conexión de cualquier otro aparato o tarjeta que permita ampliar las capacidades de trabajo de una computadora, y son el punto más importante para asegurarnos haber hecho una buena inversión. Estos son las ranuras de expansión y los puertos.

Los puertos son los puntos de conexión que ya vienen con la computadora y que permiten la instalación rápida de los dispositivos más comunes, como lo son el teclado, la impresora, el monitor, etc.

PERIFÉRICOS. Se denominan periféricos tanto a las unidades o dispositivos a través de los cuales la computadora se comunica con el mundo exterior, como a los sistemas que almacenan o archivan la información, sirviendo de memoria auxiliar de la memoria principal.

Se entenderá por periférico a todo conjunto de dispositivos que, sin pertenecer al núcleo fundamental de la computadora, formado por la CPU y la memoria central, permitan realizar operaciones de entrada/salida (E/S) complementarias al proceso de datos que realiza la CPU.

Estas tres unidades básicas en un computador, CPU, memoria central y el subsistema de E/S, están comunicadas entre sí por tres buses o canales de comunicación: el bus de direcciones, para seleccionar la dirección del dato o del periférico al que se quiere acceder, el bus de control, básicamente para seleccionar la operación a realizar sobre el dato (principalmente lectura, escritura o modificación) y el bus de datos, por donde circulan los datos.

A pesar de que el término periférico implica a menudo el concepto de “adicional pero no esencial”, muchos de ellos son elementos fundamentales para un sistema informático. El teclado y el monitor, imprescindibles en cualquier computadora personal de hoy en día (no lo fueron en los primeros computadores), son posiblemente los periféricos más comunes, y es posible que mucha gente no los considere como tal debido a que generalmente se toman como parte necesaria de una computadora. El mouse es posiblemente el ejemplo más claro de este aspecto. Hace menos de 20 años no todos las computadora personales incluían este dispositivo. El sistema operativo MS-DOS, el más común en esa época, tenía una interfaz de línea de comandos para la que no era necesario el empleo de un mouse, todo se hacía mediante comandos de texto. Fue con la popularización de Finder, sistema operativo de la Macintosh de Apple y la posterior aparición de Windows cuando el mouse comenzó a ser un elemento imprescindible en cualquier hogar dotado de una computadora personal. Actualmente existen sistemas operativos con interfaz de texto que tampoco hacen uso del mouse como, por ejemplo, algunos sistemas básicos de UNIX y Linux.

Page 13: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 13

Tipos de periféricos Los periféricos pueden clasificarse en 4 categorías principales:

Periféricos de entrada: Captan y envían los datos al dispositivo que los procesará. Son los que introducen datos externos a la computadora para su posterior tratamiento por parte de la CPU. Estos datos pueden provenir de distintas fuentes, siendo la principal un ser humano.

Los periféricos de entrada más habituales son:

Teclado Mouse Cámara web Escáner Micrófono Conversor Analógico digital Escáner de código de barras Joystick Tableta digitalizadora Pantalla táctil

Periféricos de salida: Son dispositivos que muestran o proyectan información hacia el exterior del ordenador. La mayoría son para informar, alertar, comunicar, proyectar o dar al usuario cierta información, de la misma forma se encargan de convertir los impulsos eléctricos en información legible para el usuario. Sin embargo, no todos este tipo de periféricos es información para el usuario. Cabe aclarar también que ciertos periféricos de salida pueden ser duales, o sea, de entrada y salida.

Los periféricos de salida más habituales son:

Monitor Impresoras Altavoces Auriculares Fax

Periféricos de almacenamiento: Son los dispositivos que almacenan datos e información por bastante tiempo. La memoria RAM no puede ser considerada un periférico de almacenamiento, ya que su memoria es volátil y temporal.

En otras palabras, se encargan de guardar o salvar datos para que la CPU pueda hacer uso de ellos una vez que han sido eliminados de la memoria principal, ya que ésta se borra cada vez que se apaga la computadora. Pueden ser internos, como un disco duro, o extraíbles, como un CD.

Los periféricos de almacenamiento más habituales son:

Disco duro Grabadora y/o lector de CD Grabadora y/o lector de DVD Memoria Flash (usualmente las de las cámaras fotográficas). Cintas magnéticas Memoria portátil (pendrive) Disquete

Periféricos de comunicación: Son los periféricos que se encargan de comunicarse con otras máquinas o computadoras, ya sea para trabajar en conjunto, o para enviar y recibir información. Su función es permitir o facilitar la interacción entre dos o más computadoras, o entre una computadora y otro periférico externo a la computadora.

Page 14: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

14 Ing. Prof. Avramovich, Javier A.

Los periféricos de comunicación más habituales son:

Fax-Módem. Tarjeta de red. Tarjeta Wireless tipo infrarrojo. Tarjeta Bluetooth. Controladores de puertos (serie, paralelo, infrarrojo, etc.) USB

Otros conceptos y curiosidades Algunos computadores más grandes se diferencian del modelo anterior, en un aspecto importante, porque tienen varias CPU y unidades de control que trabajan al mismo tiempo. Además, algunos computadores, usados principalmente para investigación, son muy diferentes del modelo anterior, pero no tienen muchas aplicaciones comerciales.

En la actualidad, podemos tener la impresión de que los computadores están ejecutando varios programas al mismo tiempo. Esto se conoce como multitarea, siendo más usado el segundo término. En realidad, la CPU ejecuta instrucciones de un programa y después tras un breve periodo de tiempo, cambian a un segundo programa y ejecuta algunas de sus instrucciones. Esto crea la ilusión de que se están ejecutando varios programas simultáneamente, repartiendo el tiempo de la CPU entre los programas. Esto es similar a la película que está formada por una sucesión rápida de fotogramas. El sistema operativo es el programa que generalmente controla el reparto del tiempo.

El sistema operativo sirve para decidir, por ejemplo, qué programas se ejecutan, y cuándo, y qué fuentes (memoria o dispositivos E/S) se utilizan. El sistema operativo tiene otras funciones que ofrecer a otros programas, como los códigos que sirven a los programadores, escribir programas para una máquina sin necesidad de conocer los detalles internos de todos los dispositivos electrónicos conectados.

En la actualidad se están empezando a incluir dentro del sistema operativo algunos programas muy usados debido a que es una manera económica de distribuirlos. No es extraño que un sistema operativo incluya navegadores de Internet, procesadores de texto, programas de correo electrónico, interfaces de red, reproductores de películas y otros programas que antes se tenían que conseguir e instalar separadamente.

SOFTWARE Se denomina software (palabra de origen anglosajón, pronunciada "sóft-uer"), programa, equipamiento lógico o soporte lógico a todos los componentes intangibles de una computadora, es decir, al conjunto de programas y procedimientos necesarios para hacer posible la realización de una tarea específica, en contraposición a los componentes físicos del sistema (hardware). Esto incluye aplicaciones informáticas tales como un procesador de textos, que permite al usuario realizar una tarea, y software de sistema como un sistema operativo, que permite al resto de programas funcionar adecuadamente, facilitando la interacción con los componentes físicos y el resto de aplicaciones.

Probablemente la definición más formal de software es la atribuida a la IEEE en su estándar 729: «la suma total de los programas de cómputo, procedimientos, reglas documentación y datos asociados que forman parte de las operaciones de un sistema de cómputo». Bajo esta definición, el concepto de software va más allá de los programas de cómputo en sus distintas formas: código fuente, binario o ejecutable, además de su documentación: es decir, todo lo intangible.

El término «software» fue usado por primera vez en este sentido por John W. Tukey en 1957. En las ciencias de la computación y la ingeniería de software, el software es toda la información

Page 15: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 15

procesada por los sistemas informáticos: programas y datos. El concepto de leer diferentes secuencias de instrucciones de la memoria de un dispositivo para controlar cálculos fue inventado por Charles Babbage como parte de su máquina diferencial. La teoría que forma la base de la mayor parte del software moderno fue propuesta por vez primera por Alan Turing en su ensayo de 1936, Los números computables, con una aplicación al problema de decisión.

TIPOLOGÍA DEL SOFTWARE Si bien esta distinción es, en cierto modo, arbitraria, y, a veces, difusa y confusa, se puede distinguir al software de la siguiente forma:

Software de sistema. Es la parte que permite funcionar al hardware. Su objetivo es aislar tanto como sea posible al programador de aplicaciones de los detalles del computador particular que se use, especialmente de las características físicas de la memoria, dispositivos de comunicaciones, impresoras, pantallas, teclados, etcétera. Incluye entre otros:

Sistemas operativos Controladores de dispositivo Herramientas de diagnóstico Servidores Sistemas de ventanas Utilidades

Software de programación. Que proporciona herramientas para ayudar al programador a escribir programas informáticos y a usar diferentes lenguajes de programación de forma práctica. Incluye entre otros:

Editores de texto Compiladores Intérpretes Enlazadores Depuradores

Software de aplicación. Que permite a los usuarios llevar a cabo una o varias tareas más específicas, en cualquier campo de actividad susceptible de ser automatizado o asistido, con especial énfasis en los negocios. Incluye entre otros:

Aplicaciones de automatización industrial Software educativo Software médico Bases de datos Videojuegos Archivos de datos

LOS SISTEMAS OPERATIVOS. Para que una maquina basada completamente en electrónica y un ser humano con miles de años de evolución se entiendan no ha sido fácil la comunicación entre ambos. Desde sus orígenes los primeros diseñadores y creadores de éstas se dieron cuenta que necesitaban algo más que permitiera la fácil interpretación de las instrucciones así como de los resultados obtenidos, para lo cuál crearon un programa básico que toda computadora debe cargar primero en su memoria para poderse comunicar y comprender con un ser humano.

Así nació el Sistema Operativo, programa básico que se carga al momento de encender la máquina y sirve de intérprete entre el frío lenguaje de la maquina electrónica y el complejo idioma humano, el Sistema operativo es pues, el gobierno interno de la máquina.

Page 16: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

16 Ing. Prof. Avramovich, Javier A.

LENGUAJES DE PROGRAMACIÓN Los lenguajes utilizados para escribir programas de computadoras que puedan ser entendidos por ellas se denominan lenguajes de programación. Los lenguajes de programación se clasifican en tres grandes categorías: de maquinas, de bajo nivel y de alto nivel.

Lenguaje de maquina: El lenguaje de maquina es aquel cuyas instrucciones son directamente entendibles por la computadora y no necesitan traducción posterior para que el µP pueda comprender y ejecutar el programa.

Las instrucciones en lenguaje maquina se expresan en términos de la unidad de memoria más pequeña (bit) = digito binario 0 ó 1, en esencia una secuencia de bits que especifican la operación y las celdas de memoria implicadas en una operación

Ejemplo de instrucciones en lenguaje de maquina: 0010, 0000, 1001, 1001, 10001, 1110.

Como se observa estas instrucciones son fáciles de leer por una computadora y difíciles para un programador. Por esta razón se hace difícil escribir programas en código o lenguaje de maquina. Y se requiere otro lenguaje para comunicarse con la computadora que se hace más fácil de escribir y de leer por el programador. Para evitar la tediosa tarea de escribir programas en este lenguaje se han diseñado otros programas de programación que facilitan la escritura y posterior ejecución de los programas, estos son lenguajes de bajo y alto nivel.

Lenguaje de bajo nivel (ensambladores) La programación en lenguaje de maquina es difícil, por ello se necesitan lenguajes que permitan simplificar este proceso los lenguajes de bajo nivel han sido diseñados para ese fin.

Estos lenguajes dependen de la maquina o sea del conjunto de instrucciones especificas de la computadora, por ejemplo el lenguaje ensamblador, en el cual las instrucciones se escriben en códigos alfabéticos conocidos como nemotécnicos (abreviaturas de palabras inglesas o españolas, ejemplo sumar en ingles

ADD = suma SUB= resta MPY = multiplicar DIV=dividir LDA= cargar acumulador STO= almacenar

Las palabras nemotécnicas son mas fáciles de recordar que las secuencias de dígitos de 0 a 1. Una instrucción típica en ensamblador puede ser

ADD X, Y, Z.

Esta instrucción significa que se deben sumar los números almacenados en las direcciones X,Y y luego almacenar el resultado en la dirección Z, el lenguaje ensamblador traducirá la instrucción a código de maquina, por ejemplo.

ADD = 1110 X=1001 Y=1010 Z=1011

La instrucción traducida será 1110 1001 1000 1011

Después que un programa ha sido escrito en lenguaje ensamblador se necesita un programa llamado ensamblador, que lo traduzca a código de maquina.

Page 17: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 17

Programa fuenteen lenguajeEnsamblador

Ensamblador(Assembler)

Programa enlenguanje demaquina

Lenguaje de alto nivel. Los lenguajes de programación de alto nivel (BASIC, PASCAL, FORTRAN, C, C++, COBOL) son aquellos en los cuales las instrucciones o sentencias a la computadora se escriben con palabras similares a los lenguajes humanos.

En general en lenguaje ingles como es el caso de C o C++, lo cual facilita la escritura y la comprensión por parte del programador.

Características de los lenguajes de programación: Transportabilidad: un programa escrito en un lenguaje de alto nivel se puede escribir con poca o ninguna modificación en distintos tipos de computadora.

Independencia: Los lenguajes deben ser independientes de la máquina o sea una sentencia no depende del diseño de hardware de una computadora en particular.

Los programas escritos en lenguaje de alto nivel no son entendibles directamente por la maquina.

Necesitan ser traducidos a instrucciones en lenguaje de maquina que lo entienda la computadora.

Los programas que realizan esta traducción se llaman programas compiladores.

Los programas escritos en lenguaje de alto nivel se llaman programas fuentes

El compilador traduce el programa fuente en un programa objeto, el cual se utiliza en la fase de ejecución del programa.

Algunas computadoras o microcomputadoras utilizan unos programas similares llamados programas interpretes que traducen los programas.

El proceso de traducción de un programa fuente se denomina interpretación o compilación, según sea el programa.

Un intérprete traduce y ejecuta una traducción (sentencia) en código fuente cada vez. Los programas interpretados generalmente se ejecutan mucho más lentamente que los programas compilados; sin embargo los intérpretes son más fáciles de utilizar y la depuración (corrección) de errores es mucho más cómoda.

Basic, Basica (Basic Avanced), GW-Basic, son interpretes y Quick Basic es un compilador.

Fortran, Pascal , C, son programas compiladores.

Los lenguajes de programación C, Turbo C, C++ , son programas orientados a objeto. Windows fue desarrollado en C.

Visual Basic es un lenguaje orientado a eventos.

FORMAS DEL SOFTWARE El software adopta varias formas en distintos momentos de su ciclo de vida:

Código fuente: escrito por programadores. Contiene el conjunto de instrucciones destinadas a la computadora.

Page 18: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

18 Ing. Prof. Avramovich, Javier A.

Código objeto: resultado del uso de un compilador sobre el código fuente. Consiste en una traducción de éste último. El código objeto no es directamente inteligible por el ser humano, pero tampoco es directamente entendible por la computadora. Se trata de una representación intermedia del código fuente.

Código ejecutable: resultado de enlazar uno o varios fragmentos de código objeto. Constituye un archivo binario con un formato tal que el sistema operativo es capaz de cargarlo en la memoria de una computadora, y proceder a su ejecución.

Código o Programafuente en lenguajede alto nivel

Código o Programaobjeto en lenguajede bajo nivel

Código o Programaejecutable en lenguajede maquina

Compilado Linkeado

EL PROCESO DE CREACIÓN DE SOFTWARE El proceso de creación de software es materia de la ingeniería del software, una de las ramas propias de la Ingeniería Informática. Es un proceso complejo que involucra diversas tareas de gestión y desarrollo. Como resumen de las etapas para la creación de un software, se pueden mencionar:

Análisis Desarrollo Construcción Pruebas (unitarias e integradas) Producción

PROGRAMACIÓN. Se conoce como programación de computadoras a la implementación de un algoritmo en un determinado lenguaje de programación, conformando un programa. Mientras que un algoritmo se ejecuta en una máquina abstracta que no tiene limitaciones de memoria o tiempo, un programa se ejecuta en una máquina real, que sí tiene esas limitaciones. El lenguaje de programación puede ser de alto nivel o bajo nivel, en función del grado de abstracción.

Programas y algoritmos. Un algoritmo es una secuencia no ambigua, finita y ordenada de instrucciones que han de seguirse para resolver un problema. Un programa normalmente implementa (traduce a un lenguaje de programación concreto) un algoritmo. Nótese que es la secuencia de instrucciones en sí la que debe ser finita, no el número de pasos realizados como la ejecución de ellas.

Los programas suelen subdividirse en partes menores (módulos), de modo que la complejidad algorítmica de cada una de las partes sea menor que la del programa completo, lo cual ayuda al desarrollo del programa.

Según Niklaus Wirth un programa está formado por algoritmos y estructura de datos.

Se han propuesto diversas técnicas de programación, cuyo objetivo es mejorar tanto el proceso de creación de software como su mantenimiento. Entre ellas se pueden mencionar las programaciones lineal, estructurada, modular y orientada a objetos.

Compilación. El programa escrito en un lenguaje de programación (comprensible por el ser humano, aunque se suelen corresponder con lenguajes formales descritos por gramáticas independientes del

Page 19: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 19

contexto) no es inmediatamente ejecutado en una computadora. La opción más común es compilar el programa, aunque también puede ser ejecutado mediante un intérprete informático.

El código fuente del programa se debe someter a un proceso de transformación para convertirse en lenguaje máquina, interpretable por el procesador. A este proceso se le llama compilación.

Normalmente la creación de un programa ejecutable (un típico .exe para Microsoft Windows) 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 al lenguaje máquina). El segundo paso se llama enlazado (del inglés link o linker) se junta el código de bajo nivel generado de todos los ficheros que se han mandado compilar y se añade el código de las funciones que hay el las bibliotecas del compilador para que el ejecutable pueda comunicarse con el sistemas operativo y traduce el código objeto a código máquina.

Estos dos pasos se pueden mandar hacer por separado, almacenando el resultado de la fase de compilación en archivos objetos (un típico .obj para Microsoft Windows, .o para Unix), para enlazarlos posteriormente, 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 (generalmente C, C++ y Asm), que se podrían compilar de forma independiente y enlazar juntas para formar un único ejecutable.

Programación e ingeniería del software Existe una tendencia a identificar el proceso de creación de un programa informático con la programación, que es cierta cuando se trata de programas pequeños para uso personal, y que dista de la realidad cuando se trata de grandes proyectos.

El proceso de creación de software desde el punto de vista de la Ingeniería tiene los siguientes pasos:

Reconocer la necesidad de un programa para solucionar un problema ó identificar la posibilidad de automatización de una tarea.

Recoger los requisitos del programa. Debe quedar claro qué es lo que debe hacer el programa y para qué se necesita.

Realizar el análisis de los requisitos del programa. Debe quedar claro cómo debe realizar el programa las cosas que debe hacer. Las pruebas que comprueben la validez del programa se pueden especificar en esta fase.

Diseñar la arquitectura del programa. Se debe descomponer el programa en partes de complejidad abordable.

Implementar el programa. Consiste en realizar un diseño detallado, especificando completamente todo el funcionamiento del programa, tras lo cual la codificación debería resultar inmediata.

Implantar (instalar) el programa. Consiste en poner el programa en funcionamiento junto con los componentes que pueda necesitar (bases de datos, redes de comunicaciones, etc.)

La Ingeniería del Software se centra en los pasos de planificación y diseño del programa, mientras que antiguamente (programación artesanal) la realización de un programa consistía únicamente en escribir el código.

Objetivos de la programación La programación de ordenadores debe perseguir tres objetivos fundamentales:

Page 20: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

20 Ing. Prof. Avramovich, Javier A.

Corrección: un programa es correcto si hace lo que debe hacer. Para determinar si un programa hace lo que debe es muy importante especificar claramente qué debe hacer el programa antes de desarrollarlo y una vez acabado compararlo con lo que realmente hace.

Claridad: es muy importante que el programa sea lo más claro y legible posible para mejorar el mantenimiento del software. Cuando se acaba de escribir el código del programa, se deben buscar errores y corregirlos. Más concretamente, cuando el programa está concluido, es necesario hacerle ampliaciones o modificaciones, según la demanda de los usuarios, esta labor puede ser llevada acabo por el mismo programador que implementó el programa o por otros.

Eficiencia: debe consumir la menor cantidad de recursos posible. Normalmente al hablar de eficiencia se suele hacer referencia al consumo de tiempo y/o memoria.

La eficiencia y la claridad de un programa pueden ser objetivos contrapuestos: se puede conseguir mayor claridad sacrificando parte de la eficiencia o viceversa. Pero hay que tener en cuenta que el tiempo del programador es caro, y que hoy en día el precio de los ordenadores es razonable y cada vez son más baratos.

CONCEPTO DE "PROGRAMA" Un programa –en sentido informático– está constituido por un conjunto de instrucciones que se ejecutan –ordinariamente– de modo secuencial, es decir, cada una a continuación de la anterior. Recientemente, con objeto de disminuir los tiempos de ejecución de programas críticos por su tamaño o complejidad, se está haciendo un gran esfuerzo en desarrollar programas paralelos, esto es, programas que se pueden ejecutar simultáneamente en varios procesadores. La programación paralela es mucho más complicada que la secuencial y no se hará referencia a ella en este curso. Análogamente a los datos que maneja, las instrucciones que un procesador digital es capaz de entender están constituidas por conjuntos de unos y ceros. A esto se llama lenguaje de máquina o binario, y es muy difícil de manejar. Por ello, desde casi los primeros años de los ordenadores, se comenzaron a desarrollar los llamados lenguajes de alto nivel (tales como el Fortran, el Cobol, etc.), que están mucho más cerca del lenguaje natural. Estos lenguajes están basados en el uso de identificadores, tanto para los datos como para las componentes elementales del programa, que en algunos lenguajes se llaman rutinas o procedimientos, y que en C se denominan funciones. Además, cada lenguaje dispone de una sintaxis o conjunto de reglas con las que se indica de modo inequívoco las operaciones que se quiere realizar. Los lenguajes de alto nivel son más o menos comprensibles para el usuario, pero no para el procesador. Para que éste pueda ejecutarlos es necesario traducirlos a su propio lenguaje de máquina. Esta es una tarea que realiza un programa especial llamado compilador, que traduce el programa a lenguaje de máquina. Esta tarea se suele descomponer en dos etapas, que se pueden realizar juntas o por separado. El programa de alto nivel se suele almacenar en uno o más ficheros llamados ficheros fuente, que en casi todos los sistemas operativos se caracterizan por una terminación –también llamada extensión– especial. Así, todos los ficheros fuente de C deben terminar por (.c o .cpp); ejemplos de nombres de estos ficheros son calculos.c, derivada.c, etc. La primera tarea del compilador es realizar una traducción directa del programa a un lenguaje más próximo al del computador (llamado ensamblador), produciendo un fichero objeto con el mismo nombre que el fichero original, pero con la extensión (.obj u simplemente .o). En una segunda etapa se realiza el proceso de montaje (linkage) del programa, consistente en producir un programa ejecutable en lenguaje de máquina, en el que están ya incorporados todos los otros módulos que aporta el sistema sin intervención explícita del programador (funciones de librería, recursos del sistema operativo, etc.). En un PC con sistema operativo Windows el programa ejecutable se guarda en un fichero con extensión (*.exe). Este fichero es cargado por el sistema operativo en la memoria RAM cuando el programa va a ser ejecutado.

Page 21: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 21

Una de las ventajas más importantes de los lenguajes de alto nivel es la portabilidad de los ficheros fuente resultantes. Quiere esto decir que un programa desarrollado en un PC podrá ser ejecutado en un Macintosh o en una máquina UNIX, con mínimas modificaciones y una simple recopilación. El lenguaje C, originalmente desarrollado por D. Ritchie en los laboratorios Bell de la AT&T, fue posteriormente estandarizado por un comité del ANSI (American National Standard Institute) con objeto de garantizar su portabilidad entre distintos computadores, dando lugar al ANSI C, que es la variante que actualmente se utiliza casi universalmente.

CONCEPTO DE “FUNCIÓN” Las aplicaciones informáticas que habitualmente se utilizan, incluso a nivel de informática personal, suelen contener decenas y aún cientos de miles de líneas de código fuente. A medida que los programas se van desarrollando y aumentan de tamaño, se convertirían rápidamente en sistemas poco manejables si no fuera por la modularización, que es el proceso consistente en dividir un programa muy grande en una serie de módulos mucho más pequeños y manejables. A estos módulos se les suele denominar de distintas formas (subprogramas, subrutinas, procedimientos, funciones, etc.) según los distintos lenguajes. El lenguaje C hace uso del concepto de función (function). Sea cual sea la nomenclatura, la idea es sin embargo siempre la misma: dividir un programa grande en un conjunto de subprogramas o funciones más pequeñas que son llamadas por el programa principal; éstas a su vez llaman a otras funciones más específicas y así sucesivamente.

La división de un programa en unidades más pequeñas o funciones presenta –entre otras– las ventajas siguientes:

Modularización. Cada función tiene una misión muy concreta, de modo que nunca tiene un número de líneas excesivo y siempre se mantiene dentro de un tamaño manejable. Además, una misma función (por ejemplo, un producto de matrices, una resolución de un sistema de ecuaciones lineales) puede ser llamada muchas veces en un mismo programa, e incluso puede ser reutilizada por otros programas. Cada función puede ser desarrollada y comprobada por separado.

Ahorro de memoria y tiempo de desarrollo. En la medida en que una misma función es utilizada muchas veces, el número total de líneas de código del programa disminuye, y también lo hace la probabilidad de introducir errores en el programa.

Independencia de datos y ocultamiento de información. Una de las fuentes más comunes de errores en los programas de computador son los efectos colaterales o perturbaciones que se pueden producir entre distintas partes del programa. Es muy frecuente que al hacer una modificación para añadir una funcionalidad o corregir un error, se introduzcan nuevos errores en partes del programa que antes funcionaban correctamente. Una función es capaz de mantener una gran independencia con el resto del programa, manteniendo sus propios datos y definiendo muy claramente la interfaz o comunicación con la función que la ha llamado y con las funciones a las que llama, y no teniendo ninguna posibilidad de acceso a la información que no le compete. Las funciones de C están implementadas con un particular cuidado y riqueza, constituyendo uno de los aspectos más potentes del lenguaje. Es muy importante entender bien su funcionamiento y sus posibilidades.

Nombre, valor de retorno y argumentos de una función Una función de C es una porción de código o programa que realiza una determinada tarea. Una función está asociada con un identificador o nombre, que se utiliza para referirse a ella desde el resto del programa. En toda función utilizada en C hay que distinguir entre su definición, su declaración y su llamada. Para explicar estos conceptos hay que introducir los conceptos de valor de retorno y de argumentos.

Page 22: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

22 Ing. Prof. Avramovich, Javier A.

Quizás lo mejor sea empezar por el concepto más próximo al usuario, que es el concepto de llamada. Las funciones en C se llaman incluyendo su nombre, seguido de los argumentos, en una sentencia del programa principal o de otra función de rango superior. Los argumentos son datos que se envían a la función incluyéndolos entre paréntesis a continuación del nombre, separados por comas. Por ejemplo, supóngase una función llamada power que calcula x elevado a y. Una forma de llamar a esta función es escribir la siguiente sentencia (las sentencias de C terminan con punto y coma):

power(x,y);

En este ejemplo power es el nombre de la función, y x e y son los argumentos, que en este caso constituyen los datos necesarios para calcular el resultado deseado. ¿Qué pasa con el resultado? ¿Dónde aparece? Pues en el ejemplo anterior el resultado es el valor de retorno de la función, que está disponible pero no se utiliza. En efecto, el resultado de la llamada a power está disponible, pues aparece sustituyendo al nombre de la función en el mismo lugar donde se ha hecho la llamada; en el ejemplo anterior, el resultado aparece, pero no se hace nada con él. A este mecanismo de sustitución de la llamada por el resultado es a lo que se llama valor de retorno. Otra forma de llamar a esta función utilizando el resultado podría ser la siguiente:

distancia = power(x+3, y)*escala;

En este caso el primer argumento (x+3) es elevado al segundo argumento y, el resultado de la potencia –el valor de retorno– es multiplicado por escala, y este nuevo resultado se almacena en la posición de memoria asociada con el identificador distancia. Este ejemplo resulta típico de lo que es una instrucción o sentencia que incluye una llamada a una función en el lenguaje C.

Para poder llamar a una función es necesario que en algún otro lado, en el mismo o en algún otro fichero fuente, aparezca la definición de dicha función, que en el ejemplo anterior es la función power. La definición de una función es ni más ni menos que el conjunto de sentencias o instrucciones necesarias para que la función pueda realizar su tarea cuando sea llamada. En otras palabras, la definición es el código correspondiente a la función. Además del código, la definición de la función incluye la definición del tipo del valor de retorno y de cada uno de los argumentos. A continuación se presenta un ejemplo –incompleto– de cómo podría ser la definición de la función power utilizada en el ejemplo anterior.

double power(double base, double exponente) { double resultado; ... resultado = ... ; return resultado; }

La primera línea de la definición es particularmente importante. La primera palabra double indica el tipo del valor de retorno. Esto quiere decir que el resultado de la función será un número de punto flotante con unas 16 cifras de precisión (así es el tipo double, como se verá más adelante). Después viene el nombre de la función seguido de –entre paréntesis– la definición de los argumentos y de sus tipos respectivos. En este caso hay dos argumentos, base y exponente, que son ambos de tipo double. A continuación se abren las llaves que contienen el código de la función. La primera sentencia declara la variable resultado, que es también de tipo double. Después vendrían las sentencias necesarias para calcular resultado como base elevado a exponente. Finalmente, con la sentencia return se devuelve resultado al programa o función que ha llamado a power.

Conviene notar que las variables base y exponente han sido declaradas en la cabecera – primera línea– de la definición, y por tanto ya no hace falta declararlas después, como se ha

Page 23: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 23

hecho con resultado. Cuando la función es llamada, las variables base y exponente reciben sendas copias de los valores del primer y segundo argumento que siguen al nombre de la función en la llamada.

Una función debe ser también declarada antes de ser llamada. Además de la llamada y la definición, está también la declaración de la función. Ya se verá más adelante dónde se puede realizar esta declaración. La declaración de una función se puede realizar por medio de la primera línea de la definición, de la que pueden suprimirse los nombres de los argumentos, pero no sus tipos; al final debe incluirse el punto y coma (;). Por ejemplo, la función power se puede declarar en otra función que la va a llamar incluyendo la línea siguiente:

double power(double, double);

La declaración de una función permite que el compilador chequee el número y tipo de los argumentos, así como el tipo del valor de retorno. La declaración de la función se conoce también con el nombre de prototipo de la función.

La función principal o función main() Todo programa C, desde el más pequeño hasta el más complejo, tiene un programa principal que es con el que se comienza la ejecución del programa. Este programa principal es también una función, pero una función que está por encima de todas las demás. Esta función se llama main() y tiene la forma siguiente (la palabra void es opcional en este caso):

void main(void) { sentencia_1 sentencia_2 ... }

Las llaves {...} constituyen el modo utilizado por el lenguaje C para agrupar varias sentencias de modo que se comporten como una sentencia única (sentencia compuesta o bloque). Todo el cuerpo de la función debe ir comprendido entre las llaves de apertura y cierre.

Palabras claves del C En C, como en cualquier otro lenguaje, existen una serie de palabras clave (keywords) que el usuario no puede utilizar como identificadores (nombres de variables y/o de funciones). Estas palabras sirven para indicar al computador que realice una tarea muy determinada (desde evaluar una comparación, hasta definir el tipo de una variable) y tienen un especial significado para el compilador. El C es un lenguaje muy conciso, con muchas menos palabras clave que otros lenguajes. A continuación se presenta la lista de las 32 palabras clave del ANSI C, para las que más adelante se dará detalle de su significado (algunos compiladores añaden otras palabras clave, propias de cada uno de ellos. Es importante evitarlas como identificadores):

Auto double int struct Break else long switch Case enum register typedef Char extern return union Const float short unsigned Continue for signed void Default goto sizeof volatile Do if static while

Page 24: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

24 Ing. Prof. Avramovich, Javier A.

ELEMENTOS

Comentarios Los comentarios son textos que no son procesados por el compilador. Sirven como información al programador. Para que un texto sea comentario debe estar entre los símbolos /* (marca el comienzo) y */ (marca el final de comentario).

Identificadores Se usan para referenciar las variables, las funciones, las etiquetas y otros objetos definidos por el usuario. La longitud del identificador puede variar entre uno o varios caracteres (se recomienda no más de 31.

El primer carácter debe ser una letra o un símbolo subrayado y los caracteres siguientes pueden ser letras, números o símbolos de subrayado. Las minúsculas y las mayúsculas se tratan como distintas.

Un identificador no puede ser igual a una palabra clave de C y no debe tener el mismo nombre que una función ya escrita o que se encuentre en la biblioteca de C.

Variables Una variable es una posición de memoria con nombre que se usa para mantener un valor que puede ser modificado en el programa. Todas las variables deben ser declaradas antes de poder usarlas.

Constantes Las variables pueden cambiar de valor a lo largo de la ejecución de un programa, o bien en ejecuciones distintas de un mismo programa. Además de variables, un programa utiliza también constantes, es decir, valores que siempre son los mismos. Un ejemplo típico es el número pi que vale 3.141592654. Este valor, con más o menos cifras significativas, puede aparecer muchas veces en las sentencias de un programa. En C existen distintos tipos de constantes:

Constantes numéricas. Son valores numéricos, enteros o de punto flotante. Se permiten también constantes octales (números enteros en base 8) y hexadecimales (base 16).

Constantes carácter. Cualquier carácter individual encerrado entre apóstrofos (tal como 'a', 'Y', ')', '+', etc.) es considerado por C como una constante carácter.

Cadenas de caracteres. Un conjunto de caracteres alfanuméricos encerrados entre comillas es también un tipo de constante del lenguaje C, como por ejemplo: "espacio", "Esto es una cadena de caracteres", etc.

Una variable puede ser fijada a una constante con la sintaxis const tipo identificador = valor (por ejemplo const int a=10).

Operadores Los operadores son palabras o símbolos que hacen que un programa actúe sobre las variables. En C existen cinco tipos de operadores:

Page 25: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 25

Aritméticos:

+ Suma

- Resta

* Producto

/ Cociente de una división

% Resto de una división

Lógico:

! Not (inversor lógico)

&& And (Y lógico)

|| Or (O lógico)

Relacionales:

= = Igual a

!= No igual a

> Mayor que

< Menor que

>= Mayor o igual que

<= Menor o igual que

De asignación:

Operador

= ++ -- += - = *= /=

%=

Sentencia abreviada

=

m++

m--

m+=n

m-=n

m*=n

m/=n

m%=n

Sentencia completa

=

m=m+1

m=m-1

m=m+n

m=m-n

m=m*n

m=m/n

m=m%n

De dirección:

* Operador de contenido de apuntado u operador de in dirección

& Operador de dirección

Sentencias Una sentencia es una expresión en C donde se esperan unas consecuencias, normalmente son asignaciones, operaciones, llamadas a funciones, etc.

Page 26: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

26 Ing. Prof. Avramovich, Javier A.

TIPOS Cuando en C se dice que un objeto es de un tipo, se quiere decir que ese objeto pertenece a un conjunto específico de valores con los cuales se pueden realizar un conjunto de operaciones también determinadas.

Existen cinco tipos básicos: carácter, entero, coma flotante, coma flotante de doble precisión y void.

Los demás tipos se basan en alguno de estos tipos básicos.

La siguiente tabla muestra todas las combinaciones que se ajustan al estándar ANSI junto con sus rangos mínimos y longitudes aproximadas en bits.

Tipo Char Unsigned char Signed char Int Unsigned int Signed int Short int Unsigned short int Signed short int Long int Signed long int Unsigned long int Float Double Long double

Tamaño en bits 8 8 8 16 16 16 16 16 16 32 32 32 32 64 64

Rango -127 a 127 0 a 255 -127 a 127 -32767 a 32767 0 a 65535 -32767 a 32767 -32767 a 32767 0 a 65535 -32767 a 32767 -2147483647 a 2147483647 -2147483647 a 2147483647 0 a 4294967295 Seis dígitos de precisión Diez dígitos de precisión Diez dígitos de precisión

Page 27: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 27

UNIDADES DE MEDIDA EMPLEADAS EN INFORMÁTICA

Los bytes, Kilobytes, Megabytes En informática, la unidad básica de información es el byte. En la práctica, podemos pensar que un byte es el equivalente a una letra. Si un cierto texto está formado por 2000 letras, podemos esperar que ocupe unos 2000 bytes de espacio en nuestro disco. Eso sí, suele ocurrir que realmente un texto de 2000 letras que se guarde en el ordenador ocupe más de 2000 bytes, porque se suele incluir información adicional sobre los tipos de letra que se han utilizado, cursivas, negritas, márgenes y formato de página, etc. Un byte se queda corto a la hora de manejar textos o datos algo más largos, con lo que se recurre a un múltiplo suyo, el kilobyte, que se suele abreviar Kb o K. En teoría, el prefijo kilo querría decir “mil”, luego un kilobyte debería ser 1000 bytes, pero en los ordenadores conviene buscar por comodidad una potencia de 2 (pronto veremos por qué), por lo que se usa 210 =1024. Así, la equivalencia exacta es 1 K = 1024 bytes. Los K eran unidades típicas para medir la memoria de ordenadores: 640 K ha sido mucho tiempo la memoria habitual en los IBM PC y similares. Por otra parte, una página mecanografiada suele ocupar entre 2 K (cerca de 2000 letras) y 4 K. Cuando se manejan datos realmente extensos, se pasa a otro múltiplo, el megabyte o Mb, que es 1000 K (en realidad 1024 K) o algo más de un millón de bytes. Por ejemplo, en un diskette “normal” caben 1.44 Mb, y en un Compact Disc para ordenador (CD-Rom) se pueden almacenar hasta 700 Mb. La memoria principal (RAM) de un ordenador actual suele andar por encima de los 512 Mb, y un disco duro actual puede tener una capacidad superior a los 80.000 Mb. Para estas unidades de gran capacidad, su tamaño no se suele medir en megabytes, sino en el múltiplo siguiente: en gigabytes, con la correspondencia 1 Gb = 1024 Mb. Así, son cada vez más frecuentes los discos duros con una capacidad de 120, 200 o más gigabytes. Y todavía hay unidades mayores, pero que aún se utilizan muy poco. Por ejemplo, un terabyte son 1024 gigabytes.

Todo esto se puede resumir así:

Byte desde 0 a 255 (para guardar 1 letra) Kilobyte (K o Kb) 1024 bytes Megabyte (Mb) 1024 Kb Gigabyte (Gb) 1024 Mb Terabyte (Tb) 1024 Gb

Pero por debajo de los bytes también hay unidades más pequeñas...

Los bits Dentro del ordenador, la información se debe almacenar realmente de alguna forma que a él le resulte "cómoda" de manejar. Como la memoria del ordenador se basa en componentes electrónicos, la unidad básica de información será que una posición de memoria esté usada o no (totalmente llena o totalmente vacía), lo que se representa como un 1 o un 0. Esta unidad recibe el nombre de bit. Un bit es demasiado pequeño para un uso normal (recordemos: sólo puede tener dos valores: 0 ó 1), por lo que se usa un conjunto de ellos, 8 bits, que forman un byte. Las matemáticas elementales (combinatoria) nos dicen que si agrupamos los bits de 8 en 8, tenemos 256 posibilidades distintas. 00000000 00000001 00000010 00000011 00000100 ......... …….. 11111110 11111111

Page 28: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

28 Ing. Prof. Avramovich, Javier A.

Por tanto, si en vez de tomar los bits de 1 en 1 (que resulta cómodo para el ordenador, pero no para nosotros) los utilizamos en grupos de 8 (lo que se conoce como un byte), nos encontramos con 256 posibilidades distintas, que ya son más que suficientes para almacenar una letra, o un signo de puntuación, o una cifra numérica o algún otro símbolo. Por ejemplo, se podría decir que cada vez que encontremos la secuencia 00000010 la interpretaremos como una letra A, y la combinación 00000011 como una letra B, y así sucesivamente. También existe una correspondencia entre cada grupo de bits y un número del 0 al 255: si usamos el sistema binario de numeración (que aprenderemos dentro de muy poco), en vez del sistema decimal, tenemos que: 0000 0000 (binario) = 0 (decimal) 0000 0001 (binario) = 1 (decimal) 0000 0010 (binario) = 2 (decimal) 0000 0011 (binario) = 3 (decimal) ... 1111 1110 (binario) = 254 (decimal) 1111 1111 (binario) = 255 (decimal)

En la práctica, existe un código estándar, el código ASCII (American Standard Code for Information Interchange, código estándar americano para intercambio de información), que relaciona cada letra, número o símbolo con una cifra del 0 al 255 (realmente, con una secuencia de 8 bits): la "a" es el número 97, la "b" el 98, la "A" el 65, la "B", el 32, el "0" el 48, el "1" el 49, etc. Así se tiene una forma muy cómoda de almacenar la información en ordenadores, ya que cada letra ocupará exactamente un byte (8 bits: 8 posiciones elementales de memoria). Aun así, hay un inconveniente con el código ASCII: sólo los primeros 127 números son estándar. Eso quiere decir que si escribimos un texto en un ordenador y lo llevamos a otro, las letras básicas (A a la Z, 0 al 9 y algunos símbolos) no cambiarán, pero las letras internacionales (como la Ñ o las vocales con acentos) puede que no aparezcan correctamente, porque se les asignan números que no son estándar para todos los ordenadores.

Nota: Eso de que realmente el ordenador trabaja con ceros y unos, por lo que le resulta más fácil manejar los números que son potencia de 2 que los números que no lo son, es lo que explica que el prefijo kilo no quiera decir “exactamente mil”, sino que se usa la potencia de 2 más cercana: 210 =1024. Por eso, la equivalencia exacta es 1 K = 1024 bytes.

SISTEMAS DE NUMERACIÓN

Sistema binario Nosotros normalmente utilizamos el sistema decimal de numeración: todos los números se expresan a partir de potencias de 10, pero normalmente lo hacemos sin pensar. Por ejemplo, el número 3254 se podría desglosar como:

3254 = 3x1000 + 2x100 + 5x10 + 4x1

Aunque realmente nosotros lo hacemos automáticamente: no nos paramos a pensar este tipo de cosas cuando sumamos o multiplicamos dos números.

Para los ordenadores no es cómodo contar hasta 10. Como partimos de “casillas de memoria” que están completamente vacías (0) o completamente llenas (1), sólo les es realmente cómodo contar con 2 cifras: 0 y 1. Por eso, dentro del ordenador cualquier número se deberá almacenar como ceros y unos, y entonces los números se deberán desglosar en potencias de 2 (el llamado “sistema binario”):

13 = 1x8 + 1x4 + 0x2 + 1x1

De modo que el número decimal 13 se escribirá en binario como 1101.

Page 29: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 29

En general, convertir un número binario al sistema decimal es fácil: lo expresamos como suma de potencias de 2 y sumamos:

0110 1101 (binario) = 0x27 + 1x26 + 1x25 + 0x24 + 1x23 + 1x22 + 0x21 + 1x20 0110 1101 (binario) = 0x128 + 1x64 + 1x32 + 0x16 + 1x8 + 1x4 + 0x2 + 1x1 0110 1101 (binario) = 109 (decimal)

Convertir un número de decimal a binario resulta algo menos intuitivo. Una forma sencilla es ir dividiendo entre las potencias de 2, y tomar todos los cocientes de las divisiones:

109 / 128 = 0 (resto: 109) 109 / 64 = 1 (resto: 45) 45 / 32 = 1 (resto: 13) 13 / 16 = 0 (resto: 13) 13 / 8 = 1 (resto: 5) 5 / 4 = 1 (resto: 1) 1 / 2 = 0 (resto: 1) 1 / 1 = 1 (se terminó).

Si “juntamos” los cocientes que hemos obtenido, aparece el número binario que buscábamos:

109 decimal = 0110 1101 binario

Otra forma sencilla de convertir de decimal a binario es dividir consecutivamente entre 2 y tomar los restos que hemos obtenido, pero en orden inverso:

109 / 2 = 54, resto 1 54 / 2 = 27, resto 0 27 / 2 = 13, resto 1 13 /2 = 6, resto 1 6 / 2 = 3, resto 0 3 / 2 = 1, resto 1 1 / 2 = 0, resto 1

Si leemos esos restos de abajo hacia arriba, obtenemos el número binario: 1101101 (7 cifras, si queremos completarlo a 8 cifras rellenamos con ceros por la izquierda: 01101101).

¿Y se pueden hacer operaciones con números binarios? Sí, casi igual que en decimal:

0·0 = 0 0·1 = 0 1·0 = 0 1·1 = 1

0 + 0 = 0 0 + 1 = 1 1 + 0 = 1 1+1 = 10 (en decimal: 2)

Sistema Hexadecimal Una forma más cómoda de trabajar es agrupando de 4 en 4 los bits. Este sistema de numeración trabajará en base 16 (24 =16), y es lo que se conoce como sistema hexadecimal.

Pero hay una dificultad: estamos acostumbrados al sistema decimal, con números del 0 al 9, de modo que no tenemos cifras de un solo dígito para los números 10, 11, 12, 13, 14 y 15, que utilizaremos en el sistema hexadecimal. Para representar estas cifras usaremos las letras de la A a la F, así:

0 (decimal) = 0 (hexadecimal) 1 (decimal) = 1 (hexadecimal) 2 (decimal) = 2 (hexadecimal) 3 (decimal) = 3 (hexadecimal) 4 (decimal) = 4 (hexadecimal) 5 (decimal) = 5 (hexadecimal)

6 (decimal) = 6 (hexadecimal) 7 (decimal) = 7 (hexadecimal) 8 (decimal) = 8 (hexadecimal) 9 (decimal) = 9 (hexadecimal) 10 (decimal) = A (hexadecimal) 11 (decimal) = B (hexadecimal)

Page 30: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

30 Ing. Prof. Avramovich, Javier A.

12 (decimal) = C (hexadecimal) 13 (decimal) = D (hexadecimal)

14 (decimal) = E (hexadecimal) 15 (decimal) = F (hexadecimal)

Con estas consideraciones, expresar números en el sistema hexadecimal ya no es difícil:

254 (decimal) a hexadecimal, seria: 254 / 16 = 15 (resto: 14) 14 / 1 = 14

De modo que

254(decimal) = 15x16 + 14x1 254(decimal) = 15x161 + 14x160 254 (decimal) = FE (hexadecimal)

Vamos a repetirlo para un convertir de decimal a hexadecimal un número más grande:

54331 (decimal) a hexadecimal, seria: 54331 / 4096 = 13 (resto: 1083) 1083 / 256 = 4 (resto: 59) 59 / 16 = 3 (resto: 11) 11 / 1 = 11

De modo que

54331 = 13x4096 + 4x256 + 3x16 + 11x1 54331 = 13x163 + 4x162 + 3x161 + 11x160 54331 (decimal) = D43B (hexadecimal)

Ahora vamos a dar el paso inverso: convertir de hexadecimal a decimal, por ejemplo el número A2B5

A2B5 (hexadecimal) = 10x163 + 2x162 + 11x161 + 5x160 A2B5 (hexadecimal) = 41653

El paso de hexadecimal a binario también es (relativamente) rápido, porque cada dígito hexadecimal equivale a una secuencia de 4 bits:

0 (hexadecimal) = 0 (decimal) = 0000 (binario) 1 (hexadecimal) = 1 (decimal) = 0001 (binario) 2 (hexadecimal) = 2 (decimal) = 0010 (binario) 3 (hexadecimal) = 3 (decimal) = 0011 (binario) 4 (hexadecimal) = 4 (decimal) = 0100 (binario) 5 (hexadecimal) = 5 (decimal) = 0101 (binario) 6 (hexadecimal) = 6 (decimal) = 0110 (binario) 7 (hexadecimal) = 7 (decimal) = 0111 (binario) 8 (hexadecimal) = 8 (decimal) = 1000 (binario) 9 (hexadecimal) = 9 (decimal) = 1001 (binario) A (hexadecimal) = 10 (decimal) = 1010 (binario) B (hexadecimal) = 11 (decimal) = 1011 (binario) C (hexadecimal) = 12 (decimal) = 1100 (binario) D (hexadecimal) = 13 (decimal) = 1101 (binario) E (hexadecimal) = 14 (decimal) = 1110 (binario) F (hexadecimal) = 15 (decimal) = 1111 (binario)

De modo que A2B5 (hexadecimal) = 1010 0010 1011 0101 (binario) y de igual modo, de binario a hexadecimal es dividir en grupos de 4 bits y hallar el valor de cada uno de ellos:

0110 0101 0010 0100 1010 1010 0111 = 6524AA7

Page 31: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 31

DIAGRAMAS DE FLUJO Un algoritmo es un conjunto ordenado y finito de operaciones que permite hallar la solución de un problema. Es evidente, a partir de la definición, que un algoritmo es independiente del lenguaje de programación que se utilice para realizar la solución.

Por eso es muy conveniente separar la realización de un programa en dos fases: elaboración del algoritmo que soluciona el problema, y traducción del algoritmo al lenguaje de programación deseado (en nuestro caso el C).

De las diferentes técnicas que existen para la representación de un algoritmo, la más utilizada es la de los diagramas de flujo. En ellos se utilizan símbolos (cajas) unidos por flechas (líneas de flujo) que indican las operaciones a realizar y el orden o dirección de flujo del programa respectivamente. Como se puede comprobar es una forma gráfica e intuitiva de ver la estructura global de un algoritmo.

Algunos de los símbolos utilizados en los diagramas de flujo son los siguientes:

I

O

Inicio

Fin

Programación Estructurada La programación estructurada se basa en la utilización de un reducido número de estructuras que permitan hacer que un programa sea suficientemente legible, reduciendo considerablemente el número de errores, y facilitando enormemente la detección y solución de éstos.

La característica fundamental de la programación estructurada consiste en que todas las estructuras tienen un único punto de entrada y un único punto de salida. Esto permite descomponer fácilmente un problema en subproblemas, reduciendo la complejidad y facilitando la programación.

Page 32: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

32 Ing. Prof. Avramovich, Javier A.

Las estructuras que incorpora el C basadas en la programación estructurada son:

Secuenciales Selectivas Repetitivas

Se debe evitar el uso de cualquier otra estructura que no sea una de las anteriores, ya que conduce a código no estructurado. Contrariamente a lo que pudiera parecer en un primer momento, esto no supone ninguna limitación a la hora de realizar un programa, ya que se puede demostrar que cualquier programa se puede realizar utilizando únicamente estas estructuras. En concreto, no es recomendado la utilización de las sentencias goto (que realiza un salto incondicional) y continue (que fuerza una nueva iteración dentro de una estructura repetitiva), y sólo se permite la utilización de la sentencia break (que fuerza la salida de una estructura selectiva o repetitiva) en el ámbito de la sentencia selectiva múltiple. Estas sentencias de explicaran con más detalles luego de comprender las estructuras selectivas repetitivas.

A partir de ahora se explicara la simbología en el diagrama de flujo, la instrucción en C y un ejemplo práctico de cada una de las sentencias básicas que conforman el lenguaje de programación C.

COMANDO #INCLUDE Cuando en un archivo .c se encuentra una línea con un #include seguido de un nombre de archivo, el preprocesador la sustituye por el contenido de ese archivo. La sintaxis de este comando es la siguiente:

#include "nombre_del_archivo" #include <nombre_del_archivo>

La diferencia entre la primera forma (con comillas "...") y la segunda forma (con los símbolos <...>) estriba en el directorio de búsqueda de dichos archivos. En la forma con comillas se busca el archivo en el directorio actual y posteriormente en el directorio estándar de librerías (definido normalmente con una variable de entorno del MS-DOS llamada INCLUDE, en el caso de los compiladores de Microsoft). En la forma que utiliza los símbolos <...> se busca directamente en el directorio estándar de librerías. En la práctica, los archivos del sistema (stdio.h, math.h, etc.) se incluyen con la segunda forma, mientras que los archivos hechos por el propio programador se incluyen con la primera.

Este comando del preprocesador se utiliza normalmente para incluir archivos con los prototipos (declaraciones) de las funciones de librería, o con módulos de programación y prototipos de las funciones del propio usuario. Estos archivos suelen tener la extensión *.h, aunque puede incluirse cualquier tipo de archivo de texto.

Page 33: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 33

ESTRUCTURAS SECUENCIALES

FUNCIÓN PRINTF()

“Aquí se escribe el texto que saldrá por pantalla”O

La función printf() imprime en la unidad de salida (el monitor, por defecto), el texto, y las constantes y variables que se indiquen. La forma general de esta función se puede estudiar viendo su prototipo:

int printf("cadena_de_caracteres", tipo arg1, tipo arg2, ...)

Explicación: La función printf() imprime el texto contenido escrito en cadena_de_caracteres junto con el valor de los otros argumentos, de acuerdo con los formatos incluidos en cadena_de_caracteres. Los puntos suspensivos (...) indican que puede haber un número variable de argumentos entre un printf() y otro del mismo programa. Cada formato comienza con el carácter (%) y termina con un carácter de conversión.

Considérese el siguiente ejemplo:

Programa: int i=5; double tiempo=48; float masa=3.78; printf("Resultado numero %d. En el instante %lf la masa vale %f\n", i, tiempo, masa);

Resultado: Resultado numero 5. En el instante 48.000000 la masa vale 3.780000

En el que se imprimen 3 variables (i, tiempo y masa) con los formatos (%d, %lf y %f), correspondientes a los tipos (int, double y float), respectivamente. La cadena_de_caracteres se imprime con el valor de cada variable intercalado en el lugar del formato correspondiente.

Los caracteres de conversión utilizados en la función printf() son:

Carácter de conversión Tipo de argumento

d, i int decimal u int unsigned c char f float notación decimal p puntero (void *) o octal unsigned

x , X hexadecimal unsigned s cadena de char

e , g float notación científica Lo importante es considerar que debe haber correspondencia uno a uno (el 1º con el 1º, el 2º con el 2º, etc.) entre los formatos que aparecen en la cadena_de_caracteres y los otros argumentos (constantes, variables o expresiones).

Page 34: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

34 Ing. Prof. Avramovich, Javier A.

Entre el carácter % y el carácter de conversión puede haber uno o varios de los elementos que a continuación se indican:

• Un número entero positivo, que indica la anchura mínima del campo en caracteres.

Programa: int entero1=1523; int entero2=78; printf("%5i\n",entero1); /*reserva cinco lugares mínimos para la impresión en pantalla de la variable i*/ printf("%2i\n",entero1); /*reserva dos lugares mínimos para la impresión en pantalla de la variable i*/ printf("\n\n"); printf("%5i\n%5i\n",entero1,entero2); printf("\n\n"); printf("%i\n%i\n",entero1,entero2);

Resultado: 1523 1523 1523 78 1523 78

• Un signo (-), que indica alineamiento por la izquierda (el defecto es por la derecha).

Programa: int entero1=1523; int entero2=78; printf("%5i\n%5i\n",entero1,entero2); printf("\n\n"); printf("%-5i\n%-5i\n",entero1,entero2);

Resultado: 1523 78 1523 78

• Un punto (.), que separa la anchura de la precisión, el cual será un número entero positivo indicando el número máximo de caracteres a imprimir en un string, el número de decimales de un float o double, o las cifras mínimas de un int o long.

Programa: float entero1=1523.2345; printf("%5.2f\n%5.4f\n\n",entero1,entero1);

Resultado: 1523.23 1523.2345

• Un cualificador: una (h) para short o una (l) para long y double.

A continuación se incluyen algunos ejemplos de uso de la función printf().

Page 35: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 35

El primer ejemplo contiene sólo texto, por lo que basta con considerar la cadena_de_caracteres:

Programa: printf("Con cien cañones por banda,\nviento en popa a toda vela,\n");

Resultado: Con cien cañones por banda, viento en popa a toda vela,

No es posible partir cadena_de_caracteres en varias líneas con caracteres intro (\n), por lo que en este ejemplo podría haber problemas para añadir más estrofas. Una forma alternativa, muy sencilla, clara y ordenada, de escribir la poesía sería la siguiente:

Programa: printf("%s\n%s\n%s\n%s\n", "Con cien cañones por banda,", "viento en popa a toda vela,", "no cruza el mar sino vuela,", "un velero bergantín.");

Resultado: Con cien cañones por banda, viento en popa a toda vela, no cruza el mar sino vuela, un velero bergantín.

En este caso se están escribiendo 4 cadenas constantes de caracteres que se introducen como argumentos, con formato %s y con los correspondientes saltos de línea.

Un ejemplo que contiene una constante y una variable como argumentos es el siguiente:

Programa: float beneficios=1523.2345; printf("En el año %s ganó %5.2f dólares.\n", "1993", beneficios);

Resultado: En el año 1993 ganó 1523.23 dólares.

Donde el texto 1993 se imprime como cadena de caracteres (%s), mientras que beneficios se imprime con formato de variable float (%f) con dos dígitos de precisión.

Es importante hacer corresponder bien los formatos con el tipo de los argumentos, pues si no los resultados pueden ser muy diferentes de lo esperado.

La función printf() tiene un valor de retorno de tipo int, que representa el número de caracteres escritos en esa llamada.

Page 36: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

36 Ing. Prof. Avramovich, Javier A.

Las secuencias de escape más utilizadas en C son:

Nombre completo Secuencia de escape

sonido de alerta \a

nueva línea \n

tabulador horizontal \t

retroceso \b

retorno de carro \r

salto de página \f

barra invertida \\

apóstrofo \’

comillas \”

carácter nulo \0

FUNCIÓN SCANF()

Aca se escribe el nombre de la variableen donde se guardara el dato ingresadopor tecladoI

La función scanf() es análoga en muchos aspectos a printf(), y se utiliza para leer datos de la entrada estándar (que por defecto es el teclado). La forma general de esta función es la siguiente:

int scanf("%x1%x2...", &arg1, &arg2, ...);

Donde x1, x2, ... son los caracteres de conversión, mostrados en la tabla, que representan los formatos con los que se espera encontrar los datos. La función scanf() devuelve como valor de retorno el número de conversiones de formato realizadas con éxito. La cadena de control de scanf() puede contener caracteres además de formatos. Dichos caracteres se utilizan para tratar de detectar la presencia de caracteres idénticos en la entrada por teclado. Si lo que se desea es leer variables numéricas, esta posibilidad tiene escaso interés. A veces hay que comenzar la cadena de control con un espacio en blanco para que la conversión de formatos se realice correctamente.

En la función scanf() los argumentos que siguen a la cadena_de_control deben ser pasados por referencia, ya que la función los lee y tiene que trasmitirlos al programa que la ha llamado. Para ello, dichos argumentos deben estar constituidos por las direcciones de las variables en las que hay que depositar los datos, y no por las propias variables. Una excepción son las cadenas de caracteres, cuyo nombre es ya de por sí una dirección (un puntero), y por tanto no debe ir precedido por el operador (&) en la llamada.

Page 37: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 37

Carácter Caracteres leído

c cualquier carácter d , i entero decimal con signo

u entero decimal sin signo o entero octal

x , X entero hexadecimal e, E, f, g, G número de punto flotante

s cadena de caracteres sin ' ' h, l para short, long y double L modificador para long double

Por ejemplo, para leer los valores de dos variables int y double y de una cadena de caracteres, se utilizarían la sentencia:

int n; double distancia; char nombre[20]; scanf("%d%lf%s", &n, &distancia, nombre);

En la que se establece una correspondencia entre n y %d, entre distancia y %lf, y entre nombre y %s. Obsérvese que nombre no va precedido por el operador (&). La lectura de cadenas de caracteres se detiene en cuanto se encuentra un espacio en blanco, por lo que para leer una línea completa con varias palabras hay que utilizar otras técnicas diferentes.

En los formatos de la cadena de control de scanf() pueden introducirse corchetes [...], que se utilizan como sigue:

scanf("%[AB \n\t]s", nombre); // se leen solo los caracteres indicados

Lee caracteres hasta que encuentra uno diferente de (’A’,’B’,’ ’,’\n’,’\t’). En otras palabras, se leen sólo los caracteres que aparecen en el corchete. Cuando se encuentra un carácter distinto de éstos se detiene la lectura y se devuelve el control al programa que llamó a scanf(). Si los corchetes contienen un carácter (^), se leen todos los caracteres distintos de los caracteres que se encuentran dentro de los corchetes a continuación del (^). Por ejemplo, la sentencia,

scanf(" %[^\n]s", nombre);

Lee todos los caracteres que encuentra hasta que llega al carácter nueva línea ’\n’. Esta sentencia puede utilizarse por tanto para leer líneas completas, con blancos incluidos. Recuérdese que con el formato %s la lectura se detiene al llegar al primer delimitador (carácter blanco, tabulador o nueva línea).

Page 38: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

38 Ing. Prof. Avramovich, Javier A.

ESTRUCTURAS SELECTIVA Una de las estructuras importantes que pueden utilizarse en un programa son las selectivas y radican en el hecho de realizar diferentes tareas en función de ciertas condiciones. Esto es, ejecutar una parte del código u otra, condicionalmente. Para ello será necesario especificar dichas condiciones y disponer de un mecanismo para indicar qué acciones tomar dependiendo de cómo se evalúe una determinada condición en un momento dado de la ejecución del programa.

FUNCIÓN IF

Verdadero FalsoIF (Condición)

Procedimiento

El formato general de esta estructura IF() para decidir si una determinada sentencia debe ejecutarse o no (alternativa simple) es el siguiente:

if (condicion) sentencia; /*Se ejecuta si la condición es verdadera*/

La construcción if puede escribirse también de forma más general para controlar la ejecución de un grupo de sentencias, de la siguiente manera:

if (condicion) {

sentencia 1; /*Se ejecutan si la condición es verdadera*/ sentencia 2; . . . sentencia n;

}

El funcionamiento de la construcción if es muy simple. En primer lugar se evalúa la condición, que no es otra cosa que una expresión de tipo entero. A continuación, si la expresión se ha evaluado como verdadera, se ejecuta la sentencia o grupo de sentencias. En caso contrario la ejecución del programa continúa por la siguiente sentencia en orden secuencial.

Page 39: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 39

El siguiente ejemplo muestra el uso de la función if. El programa lee un número entero y lo transforma en el impar inmediatamente mayor, si es que no era ya impar.

Programa: int main(int argc, char *argv[]) { int a; scanf("%d", &a); if (a % 2 == 0) /* Corroboro si a es par. */ a = a + 1; /*Si a es par le sumo 1*/ printf( "Ahora es impar: %d\n", a ); system("PAUSE"); return 0; }

Resultado: 2 Ahora es impar: 3 Presione una tecla para continuar . . .

Nótese que después de la función if (condición) no se escribe ‘;’ (punto y coma).

FUNCION IF-ELSE

Verdadero Falso (Else)IF (Condición)

Procedimiento Procedimiento

Existe otra forma más general, denominada alternativa doble, que ofrece dos alternativas de ejecución, en función de si la condición se evalúa verdadera o falsa.

if (condicion) sentencia 1; /*Se ejecuta si la condición es verdadera*/

else sentencia 2; /*Se ejecuta si la condición es falsa*/

Page 40: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

40 Ing. Prof. Avramovich, Javier A.

La construcción if-else puede escribirse también de forma más general para controlar la ejecución de un grupo de sentencias, de la siguiente manera:

if (condicion) {

grupo sentencias 1; /*Se ejecutan si la condición es verdadera*/ } else {

grupo sentencias 2; /*Se ejecutan si la condición es falsa*/ }

Así pues, si la condición es verdadera se ejecutará la primera sentencia o el primer grupo de sentencias, y si es falsa se ejecutará la segunda sentencia o el segundo grupo de sentencias.

El siguiente programa muestra el uso de la función if-else. El programa calcula el máximo de dos números enteros:

Programa: int main(int argc, char *argv[]) { int a, b, max; scanf( "%d %d", &a, &b ); if (a>b) max = a; else max = b; printf( "\nEl máximo es: %d\n", max ); system("PAUSE"); return 0; }

Resultado: 2 4 El máximo es: 4 Presione una tecla para continuar . . .

Page 41: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 41

FUNCION IF-ELSE-IF Existe finalmente otra construcción alternativa muy común, conocida como if-else-if o simplemente else-if. Su construcción se muestra a continuación:

if (condicion 1) { grupo de sentencias 1; } else if (condicion 2) { grupo de sentencias 2; }

else if (condicion 3) { grupo de sentencias 3; }

else if (condicion n) { grupo de sentencias n; }

else { grupo de sentencias por defecto; }

Las condiciones se evalúan secuencialmente de arriba hacia abajo hasta encontrar una que dé como resultado verdadero. En ese punto, se ejecuta el grupo de sentencias correspondiente a dicha condición. El resto de condiciones y sentencias asociadas se ignoran. En caso de que ninguna de las condiciones se evalúe verdadera, se ejecutaría el grupo de sentencias por defecto. Como en todos los casos anteriores, el último else es opcional.

A continuación se muestra un ejemplo del uso de esta construcción: int hora; scanf("%d", &hora ); if((hora>=0)&&(hora<12)) /*Si 0<hora<12*/

printf( "Buenos días" ); /*Imprimo Buenos días*/ else if((hora>=12)&&(hora<18)) /*Sino, Si 12<hora<18*/ printf( "Buenas tardes" ); /*Imprimo Buenas tardes*/ else if ((hora >= 18) && (hora < 24)) /*Sino, Si 18<hora<24*/ printf( "Buenas noches" ); /*Imprimo Buenas noches*/ else /*Sino,…*/ printf( "Hora no válida" ); /*Imprimo Hora no válida*/

Page 42: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

42 Ing. Prof. Avramovich, Javier A.

EL OPERADOR CONDICIONAL ?

El operador condicional ? es el único operador ternario de C. La forma general de las expresiones construidas con este operador es la siguiente:

expresion1 ? expresion2 : expresion3;

De manera que si la primera expresión se evalúa verdadera, toda la expresión toma el valor de la segunda expresión. En cambio, si la primera expresión se evalúa falsa, toda la expresión toma el valor de la tercera expresión.

Un ejemplo típico del uso de este operador es el cálculo del máximo de dos valores. En la siguiente sentencia, C toma el valor del máximo entre la variable a y b.

c = (a > b)? a : b;

Esto mismo podría haberse escrito usando la función if-else como: if (a>b)

c = a; else

c = b;

De esta manera, algunas sentencias if-else sencillas pueden escribirse de manera muy compacta mediante el operador ?.

Finalmente, el operador condicional, por ser en realidad un operador para expresiones, puede usarse en lugares donde no puede usarse un if-else, como se muestra a continuación:

printf("El mínimo es %d \n", ((x < y) ? x : y)); /*Si la expresión x<y es verdadera se imprime el valor de x, de lo contrario se imprime el valor de y.*/

Page 43: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 43

FUNCIÓN SWITCH

Switch (Condición)

123456Default

Procedimiento 1

Procedimiento 2

Procedimiento 3

Procedimiento 4

Procedimiento 5

Procedimiento 6

Procedimiento Default

Esta construcción permite especificar múltiples sentencias al estilo if-else-if, pero de manera más compacta, legible y elegante. Su forma general es la siguiente:

switch ( expresion ) {

case constante 1 : grupo de sentencias 1; break;

case constante 2 : grupo de sentencias 2; break;

case constante 3 : grupo de sentencias 3; break;

………………… case constante n :

grupo de sentencias n; break;

default : grupo de sentencias por defecto; break;

}

Donde la expresión debe ser de tipo entero o carácter, al igual que todas las constantes asociadas a cada etiqueta case. Es importante resaltar que no pueden usarse variables o expresiones en los distintos case, sino sólo constantes.

Page 44: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

44 Ing. Prof. Avramovich, Javier A.

El funcionamiento de la función switch es como sigue. En primer lugar se evalúa la expresión. Seguidamente su valor es comparado secuencialmente con el de las diferentes constantes en los case. Si el valor de la expresión coincide con alguna de ellas, se ejecuta el grupo de sentencias correspondiente y el switch concluye gracias a la sentencia break. En caso contrario, y si existe el caso default (que es opcional), se ejecutaría el grupo de sentencias por defecto.

Cabe recordar la sentencia break en general se utiliza para finalizar de forma forzada la ejecución dentro de un bloque de código, de manera que la siguiente sentencia a ejecutar será la primera sentencia justo después de dicho bloque. En la construcción switch, break es necesario para concluir la ejecución del grupo de sentencias asociado al case cuya constante coincide con el valor de la expresión. Así pues, la sentencia a ejecutar después de break en un switch, será la primera sentencia posterior a la llave g que cierra el switch.

El siguiente ejemplo muestra un programa que hace uso de switch para traducir a caracteres un dígito entre 1 y 5:

int num; scanf( "%d", &num ); switch ( num ) {

case 1 : printf( "Uno.\n" ); break;

case 2 : printf( "Dos.\n" );

break; case 3 :

printf( "Tres.\n" ); break; case 4 :

printf( "Cuatro.\n" ); break; case 5 :

printf( "Cinco.\n" ); break;

default : printf( "El dígito está fuera de rango.\n" ); break;

}

Page 45: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 45

Finalmente, cabe decir que el grupo de sentencias asociado a un case puede ser vacío. Este caso particular tiene su utilidad cuando se desea que varias etiquetas case ejecuten un mismo grupo de sentencias. Por ejemplo:

int num; scanf( "%d", &num ); switch ( num ) {

case 1 : case 3 : case 7 :

printf( "Uno, Tres o Siete.\n" ); break;

case 4 : case 8 :

printf( "Cuatro u Ocho.\n" ); break; case 9 :

printf( "Nueve.\n" ); break;

default : printf( "El dígito está fuera de rango.\n" ); break;

}

Page 46: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

46 Ing. Prof. Avramovich, Javier A.

ESTRUCTURAS REPETITIVAS Además de bifurcaciones, en el lenguaje C existen también varias sentencias que permiten repetir una serie de veces la ejecución de unas líneas de código. Esta repetición se puede realizar, o bien un número fijo determinado de veces, o bien hasta que se cumpla una determinada condición de tipo lógico o aritmético. De modo genérico, a estas sentencias se les denomina bucles. Las tres construcciones del lenguaje C para realizar bucles son el while, el for y el do...while.

SENTENCIA WHILE

Verdadero

FalsoWhile (Condición)

Procedimiento

Esta sentencia permite ejecutar repetidamente, mientras se cumpla una determinada condición, una sentencia o bloque de sentencias. La forma general es como sigue:

while (condición) sentencia;

O para la ejecución repetida de un grupo de sentencias: while (condición) {

grupo de sentencias; }

El funcionamiento de esta construcción es bastante simple. El cuerpo del bucle, es decir, la sentencia o grupo de sentencias dentro del bucle, se ejecuta mientras el valor de la expresión que actúa de condición sea verdadero. En el momento en que la condición sea falsa, la ejecución del programa continúa secuencialmente con la siguiente instrucción posterior al bucle.

Page 47: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 47

El siguiente ejemplo calcula la media de una secuencia de números enteros leídos por teclado. La secuencia finaliza en -1

Programa: #include <stdio.h> void main() {

int num, cont, suma; cont = 0; suma = 0; scanf( "%d", &num ); while (num != -1) {

cont++; suma = suma + num; scanf( "%d", &num ); }

if (cont != 0) printf( "La media es %d\n", sum/cont );

else printf( "La secuencia es vacía\nn" );

}

En la construcción while la condición se evalúa al principio del bucle. Por ello, si cuando se alcanza el bucle por primera vez, la condición es falsa, el cuerpo del bucle no se ejecuta nunca (imagínese el caso, en el ejemplo anterior, en que el primer número de la secuencia sea -1). como consecuencia, el cuerpo de un bucle while puede ejecutarse entre 0 y n veces, donde n depende de la condición. Nótese también que si la condición permanece cierta, el bucle puede no terminar nunca (imagínese qué ocurriría si se elimina la sentencia scanf del cuerpo del bucle del ejemplo anterior). Por ello, habitualmente las sentencias del cuerpo del bucle modifican las variables que aparecen en la condición, de forma que ésta sea falsa en algún momento.

Otro ejemplo podría ser un programa que nos diga si cada número que ingresamos es positivo o negativo, y que pare cuando ingresemos el número 0, esto podría ser:

Programa: #include <stdio.h> main() {

int numero; printf("Teclea un número (0 para salir): "); scanf("%d", &numero); while (numero!=0) {

if (numero > 0) printf("Es positivo\n"); else printf("Es negativo\n"); printf("Teclea otro número (0 para salir): "); scanf("%d", &numero);

} {

Page 48: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

48 Ing. Prof. Avramovich, Javier A.

Resultado: Teclea un número (0 para salir): 2 Es positivo Teclea otro número (0 para salir): 8 Es positivo Teclea otro número (0 para salir): -9 Es negativo Teclea otro número (0 para salir): -56 Es negativo Teclea otro número (0 para salir): 78 Es positivo Teclea otro número (0 para salir): -249 Es negativo Teclea otro número (0 para salir): 1597 Es positivo Teclea otro número (0 para salir): -98124 Es negativo Teclea otro número (0 para salir): 0 Presione una tecla para continuar . . .

En este ejemplo, si se introduce 0 la primera vez, la condición es falsa y ni siquiera se entra al bloque del “while”, terminando el programa inmediatamente.

Resultado: (2): Teclea un número (0 para salir): 0 Presione una tecla para continuar . . .

Page 49: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 49

SENTENCIA DO-WHILE

Verdadero

FalsoWhile (Condición)

Do-Procedimiento

Esta sentencia funciona de modo análogo a While, con la diferencia de que la evaluación de condición se realiza al final del bucle, después de haber ejecutado al menos una vez las sentencias entre llaves; éstas se volverán a ejecutar mientras la condición sea verdadera. La forma general de esta sentencia es:

Do { sentencia o grupo de sentencias; } while (condición);

Nótese que tanto para ejecutar una sola sentencia como para ejecutar un grupo de ellas, las llaves { } son igualmente necesarias. Esta construcción funciona de manera muy similar a la construcción while. Sin embargo, al contrario de ésta, Do-While ejecuta primero el cuerpo del bucle y después evalúa la condición. Por lo cual, el cuerpo del bucle se ejecuta como mínimo 1 vez.

El siguiente ejemplo cuenta el número de veces que aparece el valor 3 en una secuencia de números enteros acabada en -1

Page 50: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

50 Ing. Prof. Avramovich, Javier A.

Programa: #include <stdio.h> void main() {

int num, cont; cont = 0; do { scanf( "%d", &num ); if (num == 3)

cont++; } while (num != -1); printf( "El 3 se ha ingresado %d veces\n", cont );

}

Resultado: 2 4 6 3 8 1 2 3 5 77 569 3 21 0 78 -1 El 3 se ha ingresado 3 veces Presione una tecla para continuar . . .

Es importante destacar el uso de ‘;’ después de la condición, a diferencia de la construcción While, donde no se utiliza.

Finalmente, cabe decir que tradicionalmente, tanto la sentencia While como la sentencia Do-while se utilizan cuando se desconoce de entrada el número exacto de iteraciones repetitivas.

Page 51: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 51

Como ejemplo, vamos a ver cómo sería el típico programa que nos pide una clave de acceso y no nos deja entrar hasta que ingresemos la clave correcta. La clave será un número:

Programa: #include <stdio.h> main() {

int valida = 711; int clave; do { printf("Introduzca su clave numerica: "); scanf("%d", &clave); if (clave != valida)

printf("No valida!\n"); } while (clave != valida); printf("Aceptada.\n");

}

Resultado: Introduzca su clave numerica: 12 No valida! Introduzca su clave numerica: 25 No valida! Introduzca su clave numerica: 348 No valida! Introduzca su clave numerica: 32148 No valida! Introduzca su clave numerica: 711 Aceptada. Presione una tecla para continuar . . .

En este caso, se comprueba la condición al final, de modo que se nos preguntará la clave al menos una vez. Mientras que la respuesta que demos no sea la correcta, se nos vuelve a preguntar. Finalmente, cuando tecleamos la clave correcta, el ordenador escribe “Aceptada” y termina el programa.

Resultado: (2): Introduzca su clave numerica: 711 Aceptada. Presione una tecla para continuar . . .

Page 52: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

52 Ing. Prof. Avramovich, Javier A.

SENTENCIA FOR

For (Cond. inicial; Cond. escape; Paso)

Procedimiento

Ésta es la sentencia que usaremos habitualmente para crear partes del programa que se repitan un cierto número de veces ya conocido con anterioridad. El formato de “for” es:

for (condición inicial ; condición de escape ; paso) sentencia;

O para la ejecución repetida de un grupo de sentencias: for (condición inicial ; condición de escape ; paso) {

grupo de sentencias; }

La primera parte de la sentencia for acostumbra a ser una sentencia de asignación donde se inicializa alguna variable que controla el número de veces que debe ejecutarse el cuerpo del bucle, ósea, se establece la condición inicial. Esta sentencia se ejecuta una sola ocasión, antes de entrar por primera vez al cuerpo del bucle.

La segunda parte corresponde a la condición de escape que indica cuándo finaliza el bucle, de la misma forma que en las construcciones iterativas anteriores. En este caso, la condición se evalúa antes de ejecutar el cuerpo del bucle o grupo de sentencias, por lo que al igual que en la construcción While, el cuerpo puede ejecutarse entre 0 y n veces, donde n depende de la condición.

La tercera parte corresponde normalmente a una sentencia del paso que llevara la variable de control, generalmente un incremento o decremento. Esta sentencia se ejecuta siempre después de la ejecución del cuerpo del bucle.

El programa del siguiente ejemplo utiliza la construcción for para calcular la sumatoria de los números que van del 1 al 10, elevados al cuadrado:

Page 53: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 53

Programa: #include <stdio.h> void main() {

int i, cuadrado, suma; suma = 0; for (i = 0 ; i <= 10 ; i++) {

cuadrado = i * i; suma = suma + cuadrado; printf("La sumatoria parcial hasta” “ el numero %d es: %d\n", i,suma);

} printf("La sumatoria es %d\n", suma );

}

Resultado: La sumatoria parcial hasta el número 0 es: 0 La sumatoria parcial hasta el número 1 es: 1 La sumatoria parcial hasta el número 2 es: 5 La sumatoria parcial hasta el número 3 es: 14 La sumatoria parcial hasta el número 4 es: 30 La sumatoria parcial hasta el número 5 es: 55 La sumatoria parcial hasta el número 6 es: 91 La sumatoria parcial hasta el número 7 es: 140 La sumatoria parcial hasta el número 8 es: 204 La sumatoria parcial hasta el número 9 es: 285 La sumatoria parcial hasta el número 10 es: 385 El sumatorio es 385 Presione una tecla para continuar . . .

Finalmente, cabe decir que tradicionalmente la sentencia For se utiliza cuando se conoce de entrada el número exacto de iteraciones repetitivas a realizar.

El operador coma (,) C permite la utilización de más de una sentencia en la primera y tercera partes de la construcción for, así como de más de una condición en la segunda parte. Por ejemplo, el siguiente bucle es válido en C:

for (i = 0, j = 10 ; i < 10, j > 0 ; i++, j-=2) { /* Grupo de sentencias */ }

Así pues, las variables i y j se inicializan a 0 y 10 respectivamente, antes de comenzar la ejecución del bucle. En la segunda parte de la construcción, aparecen dos condiciones, i<10 y j>0. Si alguna de ellas es falsa, la ejecución del bucle se detiene. Finalmente, tras ejecutarse el cuerpo del bucle, i se incrementa en 1 y j se decrementa en 2 tras lo cual vuelven a comprobarse las condiciones, y así sucesivamente.

Otro ejemplo útil seria con bucles For anidados. Podríamos, por ejemplo, realizar un programa que nos muestre las tablas de multiplicar del 1 al 4:

Page 54: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

54 Ing. Prof. Avramovich, Javier A.

Programa: #include <stdio.h> main() {

int tabla, numero; for (tabla=1; tabla<=4; tabla++) {

for (numero=1; numero<=10; numero++) printf("%dx%d=%d\n", tabla, numero, tabla*numero);

printf("\n"); }

}

Resultado: 1x1=1 1x2=2 1x3=3 1x4=4 1x5=5 1x6=6 1x7=7 1x8=8 1x9=9 1x10=10 2x1=2 2x2=4 2x3=6 2x4=8 2x5=10 2x6=12 2x7=14 2x8=16 2x9=18 2x10=20 3x1=3 3x2=6 3x3=9 3x4=12 3x5=15 3x6=18 3x7=21 3x8=24 3x9=27 3x10=30 4x1=4 4x2=8 4x3=12 4x4=16 4x5=20 4x6=24 4x7=28 4x8=32 4x9=36 4x10=40 Presione una tecla para continuar . . .

Page 55: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 55

SENTENCIA BREAK Y CONTINUE C proporciona dos mecanismos para alterar la ejecución de las estructuras repetitivas, las sentencias break y continue.

Break Esta sentencia tiene una doble finalidad. Por un lado, indica el final de un Case en la construcción Switch, como ya se vio con anterioridad. Y por otro, para forzar la terminación inmediata de la ejecución de un bucle. De esta forma, se permite salir de la estructura repetitiva ignorando la evaluación de la condición. Si bien su uso está reconocido como no muy elegante, permite en ocasiones escribir programas más legibles y compactos.

Continue Esta sentencia se utiliza únicamente en las estructuras repetitivas. Su función es la de evitar que se ejecute todo el código a continuación de ella y hasta el final del cuerpo del bucle, durante una iteración determinada.

El siguiente ejemplo pretende ilustrar el uso de estas sentencias:

Programa: #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int num; do { scanf("%d",&num); if(num<0) { printf("\nEl valor es negativo, termino el bucle!\n"); break; } if(num>100) { printf("\nEl valor es muy grande, termino la iteracion\n"); continue; } printf("Este cartel se vera si no se produjo" " ni el break ni el continue\n"); } while(num!=0); return 0; }

Resultado: 6 Este cartel se vera si no se produjo ni el break ni el continue 105 El valor es muy grande, termino la iteracion 99 Este cartel se vera si no se produjo ni el break ni el continue -48 El valor es negativo, termino el bucle!

Page 56: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

56 Ing. Prof. Avramovich, Javier A.

Otro ejemplo exclusivo del break, seria:

Programa: #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int i; for (i=0; i<=10; i++) { if(i==5) break; printf("%d ", i); } system("PAUSE"); return 0; }

Resultado: 0 1 2 3 4 Presione una tecla para continuar . . .

Y, un ejemplo exclusivo del continue, seria:

Programa: #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int i; for (i=0; i<=10; i++) { if (i==5) continue; printf("%d ", i); } system("PAUSE"); return 0; }

Resultado: 0 1 2 3 4 6 7 8 9 10 Presione una tecla para continuar . . .

Page 57: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 57

SENTENCIA GOTO El lenguaje C también permite la orden “goto”, para hacer saltos incondicionales. Su uso indisciplinado está muy mal visto, porque puede ayudar a hacer programas llenos de saltos, difíciles de seguir. Pero en casos concretos puede ser muy útil, por ejemplo, para salir de un bucle muy anidado (un “for” dentro de otro “for” que a su vez está dentro de otro “for”: en este caso, “break” sólo saldría del “for” más interno).

El formato de “goto” es: goto Pepe;

y la posición de salto se indica con su nombre seguido de dos puntos (:) Pepe:

Como en el siguiente ejemplo:

Programa: #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int i, j; for (i=0; i<=5; i++) for (j=0; j<=20; j+=2) { if ((i==1) && (j>=7)) goto salida; printf("i vale %d y j vale %d.\n", i, j); } salida: printf("Fin del programa\n"); system("PAUSE"); return 0; }

Resultado: i vale 0 y j vale 0. i vale 0 y j vale 2. i vale 0 y j vale 4. i vale 0 y j vale 6. i vale 0 y j vale 8. i vale 0 y j vale 10. i vale 0 y j vale 12. i vale 0 y j vale 14. i vale 0 y j vale 16. i vale 0 y j vale 18. i vale 0 y j vale 20. i vale 1 y j vale 0. i vale 1 y j vale 2. i vale 1 y j vale 4. i vale 1 y j vale 6. Fin del programa Presione una tecla para continuar . . .

Vemos que cuando i=1 y j>=7, se sale de los dos “for” sin que ninguno de ellos haya llegado a finalizar el bucle para el cual fueron calibrados.

Page 58: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

58 Ing. Prof. Avramovich, Javier A.

TIPOS DE DATOS ESTRUCTURADOS

Comenzaremos hablando del tipo abstracto de datos estructurados, tanto de una dimensión (vector o array), dos dimensiones (matriz) o múltiples dimensiones.

VECTOR O ARRAY Los vectores, también llamados tablas unidimensionales, son estructuras de datos caracterizadas por ser:

• Una colección de datos del mismo tipo.

• Referenciados mediante un mismo nombre.

• Almacenados en posiciones de memoria físicamente contiguas, de forma que, la dirección de memoria más baja corresponde a la del primer elemento, y la dirección de memoria más alta corresponde a la del último elemento.

El formato general para la declaración de una variable de tipo vector es el siguiente: tipo de datos nombre array [tamaño];

Donde:

• tipo de datos: indica el tipo de los datos almacenados por el vector. Recordemos que todos los elementos del vector son forzosamente del mismo tipo. Debe aparecer necesariamente en la declaración, puesto que de ella depende el espacio de memoria que se reservará para almacenar el vector. Por ejemplo: Int, Float o Char.

• nombre array: es un identificador que usaremos para referiremos tanto al array como un todo, como a cada uno de sus elementos. Por ejemplo: notas, fechas, nombres.

• tamaño: es una expresión entera constante que indica el número de elementos que contendrá el vector. El espacio ocupado por un vector en memoria se obtiene como el producto del número de elementos que lo componen y el tamaño de cada uno de éstos.

Último elementodel vector

. . . .0 1 2 3 4 N-1

Primer elementodel vector

Representación grafica de un vector de N elementos.

Consulta de un array El acceso a un elemento de un array se realiza mediante el nombre de éste y un índice entre corchetes ([índice]). El índice representa la posición relativa que ocupa dicho elemento dentro del vector y se especifica mediante una expresión entera (normalmente una constante o una variable).

Page 59: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 59

A continuación se muestran algunas formas válidas de acceso a los elementos de un vector:

Programa: int contador[10]; int i, j, x; . . . x = contador[1]; /*coloco en x el segundo valor del array contador*/ x = contador[i]; /*coloco en x el valor que se encuentra en la

posición definida por ‘i’*/ x = contador[i * 2 + j]; /*coloco en x el valor que se encuentra en la

posición definida por ‘i*2+j’*/ . . .

Como muestra la figura, el primer elemento de un vector en C se sitúa en la posición 0(cero), mientras que el último lo hace en la posición N-1 (N indica el número de elementos del vector). Por esta razón, el índice para acceder a los elementos del vector debe permanecer entre estos dos valores. Es responsabilidad del programador garantizar este hecho, para no acceder a posiciones de memoria fuera del vector, lo cual produciría errores imprevisibles en el programa.

Asignación de datos a un array La asignación de valores a los elementos de un array se realiza de forma similar a como se consultan. Veámoslo en un ejemplo:

Programa: int contador[3]; . . . contador[0] = 24; /*asigno el valor 24 a la primer posición del

array*/ contador[1] = 12; /*asigno el valor 12 a la segunda posición del

array*/ contador[2] = 6; /*asigno el valor 06 a la tercera posición del

array*/

En muchas ocasiones, antes de usar un array (o cualquier tipo de dato estructurado) por primera vez, es necesario dar a sus elementos un valor inicial. La manera más habitual de inicializar un vector en tiempo de ejecución consiste en recorrer secuencialmente todos sus elementos y darles el valor inicial que les corresponda. Veámoslo en el siguiente ejemplo, donde todos los elementos de un vector de números enteros toman el valor 0 (cero):

Programa: void main() { int vector[100], i; for (i= 0; i< 100; i++) vector[i] = 0; }

Nótese que el bucle recorre los elementos del vector empezando por el elemento 0 (i=0) y hasta el elemento 100-1 (condición de salida del bucle for; i<100).

Existe también un mecanismo que permite asignar un valor a todos los elementos de un array con una sola sentencia. Concretamente en la propia declaración del array.

La forma general de inicializar un arreglo de datos array es la siguiente: tipo de datos nombre del array [tamaño] = { lista valores};

La lista de valores no deberá contener nunca más valores de los que puedan almacenarse en la tabla. Veamos algunos ejemplos:

Page 60: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

60 Ing. Prof. Avramovich, Javier A.

int contador[3] = {24, 12, 6}; /* Correcto */ char vocales[5] = {’a’, ’e’, ’i’, ’o’, ’u’}; /* Correcto */ int v[4] = {2, 6, 8, 9, 10, 38}; /* Incorrecto */

Finalmente remarcamos que los mecanismos de acceso descriptos en esta sección son idénticos para las matrices y las tablas multidimensionales. La única diferencia es que será necesario especificar tantos índices como dimensiones posea el arreglo al que se desea acceder. Esto lo veremos en las siguientes secciones.

A continuación se muestra un ejemplo de un programa que almacena 15 valores enteros y encuentra el mayor de estos.

Programa: #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int numero[15],num_mayor=0,i; for(i=0;i<15;i++) { scanf("%d", &numero[i]); if (numero[i]> num_mayor) num_mayor=numero[i]; } printf( "El mayor de los 15 números ingresados es: %d", num_mayor); system("PAUSE"); return 0; }

Resultado: 2 5 3 18 6 489 178 789 15 38 331 55 22 147 233 El mayor de los 15 números ingresados es: 789

Otro ejemplo consiste en un programa que inicializa dos array de 100 elementos en cero, luego carga en uno de ellos 100 valores ingresados por teclado, a continuación calcula y almacena en el otro array el cuadrado de los números ingresados para finalmente mostrar el resultado de la operación en pantalla.

Page 61: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 61

Programa: #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int numero_normal[100],numero_cuadrado[100],i; for(i=0;i<100;i++) { numero_normal[i]=0; numero_cuadrado[i]=0; } for(i=0;i<100;i++) scanf("%d", &numero_normal[i]); for(i=0;i<100;i++) numero_cuadrado[i]=numero_normal[i]*numero_normal[i]; for(i=0;i<100;i++) printf("%d^2=%d\n",numero_normal[i],numero_cuadrado[i]); system("PAUSE"); return 0; }

Resultado: Queda como tarea del alumno observar el comportamiento de este programa.

MATRIZ O ARRAY BIDIMENSIONAL Las matrices, también llamadas array bidimensionales, no son otra cosa que vectores con dos dimensiones.

Por lo que los conceptos de acceso, inicialización, etc. son similares.

La declaración de una variable matriz tiene la forma siguiente: Tipo_de_datos nombre_tabla [tamaño dim1][tamaño dim2];

Donde tamaño dim1 y tamaño dim2 indican, respectivamente, el número de filas y de columnas que componen la matriz. La figura muestra la representación gráfica habitual de una matriz de datos.

Otro hecho importante es que las matrices en C se almacenan “por filas”. Es decir, que los elementos de cada fila se sitúan en memoria de forma contigua. Así pues, en la matriz de la figura anterior, el primer elemento almacenado en memoria es el (0,0), el segundo el (0,1), el tercero el (0,2), . . . ,(0,M-1), después (1,0), y así sucesivamente hasta el último elemento, es decir (N-1,M-1).

Page 62: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

62 Ing. Prof. Avramovich, Javier A.

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

. . . .

0 1 2 3 4 M-1

0

0

0

0

0

N-1

Último elementode la matriz

Primer elementode la matriz

Representación grafica de una matriz de N filas y M columnas.

Consulta El acceso a un elemento de una matriz se realiza mediante el nombre de ésta y dos índices (uno para cada dimensión) entre corchetes. El primer índice representa la fila y el segundo la columna en que se encuentra dicho elemento. Tal como muestra la figura, el índice de las filas tomará valores entre 0 y el número de filas menos 1, mientras que el índice de las columnas tomará valores entre 0 y el número de columnas menos 1. Es responsabilidad del programador garantizar este hecho.

nombre matriz[índice 1][índice 2];

Asignación Comentaremos únicamente la inicialización de una matriz en la propia declaración. El siguiente ejemplo declara una matriz de tres filas y cuatro columnas y la inicializa. Por claridad, se han expresado los datos por filas, aunque se puede escribir todos en una sola línea.

int mat[3][4] = {24, 12, 6, 17, 15, 28, 78, 32, 0, 44, 3200, -34 }

La inicialización de matrices, y en general de tablas multidimensionales, puede expresarse de forma más clara agrupando los valores mediante llaves ({}g), siguiendo la estructura de la matriz. Así pues, el ejemplo anterior también podría escribirse como:

int mat[3][4] = { {24, 12, 6, 17}, {15, 28, 78, 32}, {0, 44, 3200 , -34} };

Page 63: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 63

El siguiente programa muestra como se cargan las 3 notas de herramientas informáticas de los 50 alumnos numerados según el listado de bedelia. Estos datos se cargaran en una matriz.

Programa: #include <iostream> #include <stdlib.h> using namespace std; int main(int argc, char *argv[]) { int i,j,num_alumno; int notas[50][3]; for(i=0;i<50;i++) for(j=0;j<3;j++) notas[i][j]=0; printf("\nIngrese el numero del alumno al cual quiere” “ ingresarle las notas: "); printf("\nIngrese cero (0) para terminar "); scanf("%i",&num_alumno); while(num_alumno!=0) { for(i=0;i<3;i++) { printf("Ingrese la nota numero %d: ",i+1); scanf("%i",&notas[num_alumno-1][i]); } printf("\nIngrese el numero del alumno al cual quiere” “ ingresarle las notas: "); printf("\nIngrese cero (0) para terminar "); scanf("%i",&num_alumno); } for(i=0;i<50;i++) { printf("\nLas notas del alumno %d son: ",i+1); for(j=0;j<3;j++) { printf("%i ",notas[i][j]); } } system("PAUSE"); return 0; }

Resultado: Queda como tarea del alumno observar el comportamiento de este programa.

ARREGLOS MULTIDIMENCIONALES Este tipo de arreglos se caracteriza por tener tres o más dimensiones.

Al igual que vectores y matrices, todos los elementos almacenados en ellas son del mismo tipo de datos.

La declaración de una tabla multidimensional tiene la forma siguiente: Tipo_de_datos nombre_tabla [tamaño dim1].....[tamaño dimN];

No esta en el alcance de este curso este tipo de arreglos, por lo quedará a criterio del alumno profundizar sobre este tema.

FUNCIONES Hasta ahora hemos visto como el programa principal (main()) utiliza funciones de la librería estándar de C para realizar algunas tareas comunes (printf(), scanf(), . . . ). C permite

Page 64: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

64 Ing. Prof. Avramovich, Javier A.

también la definición de funciones por parte del programador. Como veremos, al usar funciones definidas por el programador, los programas pueden estructurarse en partes más pequeñas y sencillas. Cada una de estas partes debe responder a un propósito único e identificable, pudiendo además utilizarse en distintos lugares del programa principal. La distribución del código de un programa usando funciones se conoce como modularización.

El diseño modular de programas ofrece diversas ventajas. Por ejemplo, muchos programas requieren la ejecución de un mismo grupo de instrucciones en distintas partes del programa. Este grupo de instrucciones puede incluirse dentro de una sola función, a la que se puede llamar cuando sea necesario.

Además, puede proporcionarse un conjunto de datos (parámetros) diferente a la función cada vez que se la llama.

Es importante también la claridad en la lógica del programa resultante de la descomposición del mismo en partes bien definidas. Un programa concebido de esta forma es mucho más fácil de escribir y de depurar, no sólo por el propio programador, sino también (y más importante) por otros programadores que posteriormente deban mantener el programa. Este hecho es especialmente cierto en programas grandes donde participan muchos programadores.

La utilización de funciones permite también la construcción a medida de librerías de funciones de uso frecuente. Por ejemplo, un programador especializado en el desarrollo de programas matemáticos podría crear una librería con funciones para el manejo de matrices, números complejos, etc. De esta forma se evita la reescritura del mismo código repetidas veces para distintos programas.

Una función es una porción de programa, identificable mediante un nombre, que realiza determinadas tareas bien definidas por un grupo de sentencias sobre un conjunto de datos. Las operaciones que realiza la función son siempre las mismas, pero los datos pueden variar cada vez que se llame a la función. Todo programa en C consta de una o mas funciones, una (y sólo una) de la cuales debe llamarse main.

La ejecución del programa comienza siempre en dicha función, desde donde puede llamarse a otras funciones de la librería estándar o funciones definidas por el programador. Al llamar a una función se ejecutan las sentencias que la componen y, una vez completada la ejecución de la función, la ejecución del programa continúa desde el punto en que se hizo la llamada a la función.

Generalmente, al llamar a una función se le proporciona un conjunto de datos (parámetros) que se procesan ejecutando las sentencias que la componen. La función devuelve un solo valor mediante la sentencia return. Algunas funciones reciben parámetros, pero no devuelven nada, mientras que otras no reciben parámetros pero síı devuelven un valor.

Definición de una función. La definición de una función se hace de forma similar a la de la función main(). Su forma más genérica consta básicamente de dos partes: un línea llamada cabecera donde se especifica el nombre de la función, el tipo del resultado que devuelve y los parámetros que recibe; y un conjunto de sentencias encerrado entre llaves formando el cuerpo.

Tipo_dato_a_devolver nombre función(Tipo1 param1, ..., TipoN paramN) { Cuerpo }

Tipo_dato_a_devolver: es el tipo de datos del valor que devuelve la función. Si no se especifica ninguno, C asume que la función devuelve un valor de tipo entero (int).

Page 65: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 65

Nombre función: identificador que se usará posteriormente para llamar a la función desde cualquier punto del programa.

Tipo param: tipo y nombre de cada uno de los parámetros que recibe la función. Se especifican entre paréntesis y separados por comas. Algunas funciones pueden no recibir parámetros (void).

Los parámetros de la declaración se denominan parámetros formales, ya que representan los nombres con que referirse dentro de la función a los datos que se transfieren a ésta desde la parte del programa que hace la llamada.

Cuerpo: conjunto de declaración de variables y sentencias de ejecución necesarias para la realización de la tarea especificada por la función. Debe incluir una o más sentencias return para devolver un valor al punto de llamada.

Prototipos de una función. Si en el punto del programa donde se va a realizar una llamada a una función, dicha función ya ha sido definida previamente, entonces ya se conocen sus características (tipo del resultado, número y tipo de los parámetros, etc.), por lo que la llamada puede realizarse sin problemas. Sin embargo, si la función que se va a llamar se halla definida posteriormente al punto desde donde se realiza la llamada, entonces debe crearse un prototipo de la función a la cual se desea llamar. Dicho prototipo deberá colocarse antes del punto donde se haga la primera llamada a la función, y consta únicamente de la cabecera de dicha función.

El prototipo de una función puede interpretarse como un aviso al compilador, para que cuando encuentre una llamada a dicha función pueda conocer el tipo del resultado que devuelve y la información sobre los parámetros que recibe.

A continuación se muestra el formato general de un prototipo, que corresponde a la cabecera de la función seguida de un punto y coma:

Tipo nombre_función (Tipo1 param1, ..., TipoN paramN);

La utilización de prototipos de funciones no es obligatoria en C. Sin embargo, es aconsejable, ya que facilitan la comprobación y detección de errores entre las llamadas a funciones y las definiciones correspondientes.

Llamada a una función. Finalmente, la llamada a una función se realiza con el nombre de la misma y una lista de parámetros (si es que los requiere) entre paréntesis los cuales serán los que se transferirán a la función. El número y tipo de los parámetros empleados en la llamada a la función debe coincidir con el número y tipo de los parámetros formales de la definición o prototipo.

Adicionalmente, si la función devuelve algún valor (es decir, no es de tipo void) la llamada a la función debe estar incluida en una expresión que recoja el valor devuelto.

Los datos empleados en la llamada a una función reciben el nombre de parámetros reales, ya que se refieren a la información que se transfiere a la función para que ésta se ejecute. Como veremos más adelante, los identificadores de los parámetros formales son locales a la función, en el sentido de que no son reconocidos desde fuera de ésta. Por tanto, los nombres de los parámetros formales no tienen por qué coincidir con los nombres de las variables usadas como parámetros reales en el momento de la llamada.

Ejemplo: En el siguiente programa mostraremos un aplicación sencilla de la utilidad de las funciones. En este tendremos una función llamada “superficie” a la cual se le pasan dos valores enteros y

Page 66: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

66 Ing. Prof. Avramovich, Javier A.

devuelve un valor tipo flotante que representa la superficie de un triangulo cuya base y altura fueron pasadas a la función desde el lugar en donde esta fue llamada.

Programa: #include <iostream> #include <stdlib.h> float superficie (int num1, int num2); /*Prototipo. Fuera del programa principal y con punto y coma al finalizar*/ int main() /*Inicio del programa principal*/ { int a,b; /*Variables locales del programa principal*/ float d; /*que no tienen injerencia en la función superficie*/ printf("Introduzca el valor de la base: "); scanf("%d",&a); printf("Introduzca el valor de la altura: "); scanf("%d",&b); d=superficie(a,b); /*Llamada a la función "superficie" con el paso de los valores de "a" y "b"*/ printf("\nbase = %d" "\naltura = %d" "\nsuperficie del triangulo = %f",a,b,d); d=superficie(3,5); /*Nueva llamada a la función "superficie" con el paso de los valores "3" y "5"*/ printf("\n\nLa superficie de un triangulo de 3*5 es %3.2f",d); printf("\n\n"); system("PAUSE"); return 0; } float superficie (int base, int altura)/*Definición función "superficie" */ { float x;/*Variable local de la función, no sirve en el programa principal */ x=(base*altura); x=x/2; return(x); /*Retorno al programa principal con el valor obtenido en "x" */ }

Resultado: Introduzca el valor de la base: 3 Introduzca el valor de la altura: 9 base = 3 altura = 9 superficie del triangulo = 13.500000 La superficie de un triangulo de 3*5 es 7.50 Presione una tecla para continuar . . .

Page 67: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 67

CONEXIÓN Y PROGRAMACIÓN DEL PUERTO PARALELO. Las comunicaciones en paralelo se realizan mediante la transferencia simultánea de todos los bits que constituyen el dato (byte o palabra). Presentan la ventaja de que la transmisión puede ser más rápida.

Sin embargo, las comunicaciones en paralelo no pueden ser implementadas para grandes distancias debido a que no es viable la conexión física de todas las líneas necesarias. Las comunicaciones en paralelo propiamente dichas no han sido normalizadas, lo que sí se reconoce es la norma Centronic, para la conexión del PC a la impresora, mediante el envío simultáneo de 8 bits de datos (un byte), además de un conjunto de líneas de protocolo (handshake o intercambio). La operación más frecuente en la que interviene el puerto paralelo del PC es en el envío de datos a la impresora.

Los antiguos circuitos integrados que se incluían en las tarjetas de interfase del puerto paralelo no permitían la recepción de datos, sólo estaban diseñados para el envío de información al exterior. Las versiones recientes de estas tarjetas de interfase de puertos paralelo sí permiten la recepción de datos y dan la posibilidad, por ejemplo, de intercambiar información entre la PC y un dispositivo externo a través del puerto paralelo, siempre que se utilice el software adecuado.

La norma Centronics hace referencia a las características de la conexión en la interfase de puerto paralelo y una impresora. Las líneas son latcheadas, esto es, mantienen siempre el último valor establecido en ellas mientras no se cambien expresamente y los niveles de tensión y de corriente coinciden con los niveles de la lógica TTL, cuyos valores típicos son:

• Tensión de nivel alto: 5 V.

• Tensión de nivel bajo: 0 v.

• Intensidad de salida máxima: 2.6 mA.

• Intensidad de entrada máxima: 24 mA.

La norma Centronics establece el nombre y las características de 36 líneas eléctricas para la conexión entre el PC y la impresora. En realidad, para la transferencia de las señales de datos y de control a través de la tarjeta de interfase paralelo sólo se requieren 18 líneas, las restantes son líneas de masa que se enrollan alrededor de los cables de señal para proporcionarles apantallamiento y protección contra interferencias. Por esto, las citadas tarjetas suelen incorporar un conector hembra DB-25, mientras que prácticamente todas las impresoras incorporan un conector hembra tipo Centronics macho de 36 pines.

Los cables comerciales para la conexión paralelo entre el PC y la impresora tienen una longitud de 2 metros, aunque pueden ser mayores, no es recomendable que tengan una longitud superior a 5 metros si se desea una conexión fiable y sin interferencias.

El puerto paralelo en un PC Todos los ordenadores tipo PC están equipados, al menos, con una tarjeta de interfase paralelo. La BIOS almacena el número de interfaces de puertos paralelo que se hayan instalado en el equipo. La dirección de entrada/salida de cada uno de los puertos paralelo y el número de puertos instalados en una PC se muestra en la pantalla inicial de arranque del equipo, y es frecuente, que las direcciones de los dos primeros puertos paralelo sean las siguientes:

• LPT1 = 0x378 Hexadecimal.

• LPT2 = 0x278 Hexadecimal.

Page 68: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

68 Ing. Prof. Avramovich, Javier A.

Las tarjetas del puerto paralelo tienen una estructura muy simple; consta de tres registros:

• Registro de Datos (Data).

• Registro de Control (Control).

• Registro de Estado (Status).

Todas las señales que intervienen en el puerto tienen asociado un bit en uno de esos registros, de acuerdo con las funciones asignadas a cada línea en particular.

El Registro de Datos. Es de tipo latch de 8 bits, que puede ser leído y escrito desde el procesador. Es el registro donde el procesador, en operaciones de salida (OUT), pone el dato que se quiere enviar a la impresora y su dirección coincide con la dirección base del puerto paralelo (0x378 en LPT1).

Registro de Datos (D)

D7 D6 D5 D4 D3 D2 D1 D0

Invertido por Hardware No No No No No No No No

Pines en DB 25 hembra 2 3 4 5 6 7 8 9

El Registro de Estado. El registro de estado indica la situación actual de la impresora conectada al puerto, de acuerdo con los niveles de tensión que tengan las líneas ACK, BSY, PAP y OFON, lo que permite controlar el comportamiento de la impresora.

Se trata de un registro de entrada (Lectura) de información, su dirección se obtiene sumando 1 a la dirección base del puerto (0x379 en LPT1).

Registro de Estado (S)

S7 S6 S5 S4 S3 S2 S1 S0

BSY /ACK PAP OFON /ERR X X X Invertido por Hardware Si No No No No

Pines en DB 25 hembra 11 10 12 13 15

El símbolo «/» delante del nombre del bit indica que es activo a nivel bajo.

Pero el bit S7 del registro de estado (BSY ) es invertido por el hardware y, por tanto, la línea tiene un nivel complementado al que aparece en ese bit.

El significado que tienen los bits de este registro es el siguiente:

Si el bit S7 (BSY- Busy) está a 0, significa que la impresora está ocupada (buffer de impresión lleno, procesando información, pendiente de inicializar, etc.).

El bit S6 (/ACK- Acknoledge) indica que se ha producido una transferencia correcta: cuando del puerto paralelo se transfiere un byte a la impresora, la impresora activa la línea ACK de reconocimiento del carácter y, como consecuencia, el bit ACK del registro de estado pasa a nivel bajo; cuando el bit ACK está a nivel alto, significa que la impresora está ocupada y no se pueden realizar envíos.

Page 69: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 69

El bit S5 (PAP-Paper) si está a 1, señala que la impresora no dispone de papel.

El bit S4 (OFON-Line Off) indica cuando está a 1, que la impresora no está en línea.

El bit S3 (ERR) si está a 0, indica que se ha producido un error de impresora (mal funcionamiento, falta de papel, impresora fuera de línea).

Los bits 0,1 y 2 no se utilizan.

El Registro de Control. El registro de control permite controlar las transferencias de información con la impresora, puede ser escrito y leído desde el microprocesador. Es un registro de entrada/salida cuya dirección se obtiene sumando 2 a la dirección base del puerto (0x37A en LPT1).

Registro de Control (C)

C7 C6 C5 C4 C3 C2 C1 C0

X X X IRQ DSL /INI ALF STR Invertido por Hardware Si No Si Si

Pines en DB 25 hembra 17 16 14 1

El símbolo «/» delante del nombre del bit indica que es activo a nivel bajo.

Los bits STR, ALF y DSL del registro de control son invertidos por el hardware con relación a las líneas correspondientes al cable de conexión, por lo que el nivel de los bits C0, C1 y C3 del registro de control son complementados con relación a las líneas correspondientes.

El significado que tienen los bits de este registro es el siguiente:

El bit C4 (Interrupt request-IRQ) es el que permite controlar la generación de interrupciones de tipo hardware desde el puerto paralelo. Si este bit está a 1, el interfase paralelo puede generar la petición de interrupción IRQ7 (en LPT1), que se corresponden con las interrupción 0x0Fh respectivamente del procesador 80X86. Esta petición de interrupción se produce cuando se da una transición alto a bajo en la línea ACK.

El bit C3 (DSL). La mayoría de las impresoras paralelo IBM-compatibles, no utilizan esta línea y son activadas con un pulsador de on-line.

El bit C2 (INI) produce una inicialización de la impresora (es poco utilizado).

El bit C1 (ALF). Si está a nivel alto, la impresora produce automáticamente un cambio de línea (LF) cada vez que recibe un retorno de carro (CR).

El bit C0 (STR). Controla la línea que permite validar el dato existente en el registro de datos. La puesta a 1 del bit STR genera un impulso corto que indica a la impresora que el carácter del registro de datos es válido y debe ser aceptado. Así pues, cada vez que se precise enviar un carácter, no basta con ponerlo en el registro de datos, sino que hay que hacer un reset en el bit STR del registro de control y validar el dato volviendo a poner un 1 en ese bit.

Los bits C5, C6 y C7 no se utilizan.

Page 70: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

70 Ing. Prof. Avramovich, Javier A.

Asignación de pines en el conector DB25 Hembra del puerto paralelo.

Numero de pin en el conector

DB25 Hembra

Señal Dirección IN / OUT

Registro Invertida

por Hardware

1 /STR IN / OUT Control SI

2 Data 0 OUT Datos

3 Data 1 OUT Datos

4 Data 2 OUT Datos

5 Data 3 OUT Datos

6 Data 4 OUT Datos

7 Data 5 OUT Datos

8 Data 6 OUT Datos

9 Data 7 OUT Datos

10 /ACK IN Estado

11 BSY IN Estado SI

12 PAP IN Estado

13 OFON IN Estado

14 /ALF IN / OUT Control SI

15 /ERR IN Estado

16 /INI IN / OUT Control

17 /DSL IN / OUT Control SI

18-25 GROUND GND

Page 71: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 71

Entradas y salidas por el puerto paralelo. Al hablar de operaciones de entrada y salida por el puerto paralelo no debe olvidarse que, inicialmente, este elemento se desarrolló de acuerdo con el estándar Centronics con el fin, casi exclusivo, de que el PC pudiese enviar datos en paralelo a la impresora conectada, no se pensó en la posibilidad inversa, o sea, que el PC pudiese recibir datos a través de ese puerto.

Las operaciones de entrada y salida de información a través del puerto paralelo en el PC las realizaremos gestionando el puerto paralelo en el nivel de registros, es decir, programando directamente los circuitos integrados o chips que constituyen la tarjeta de interfase, lo cual permitirá aprovechar al máximo todas las posibilidades que ofrezca realmente el hardware de la tarjeta de interfase.

Características E/S. Cuando usamos el puerto paralelo para otro cometido distinto al original, solo podemos hablar de:

12 líneas de salida de información desde el ordenador:

• pines del 2 al 9. Registro de Datos.

• pines 1,14, 16 y 17. Registro de Control.

15 líneas de entrada al mismo:

• pines 2-9. Registro de Datos.

• pines 10, 11, 12,13 y 15. Registro de Estado

Esto hace del puerto paralelo una interfase de comunicación con el exterior bastante flexible.

El Registro de Estado es de sólo lectura. Cuando se lee este registro, lo que se recibe es el estado lógico de los pines 10, 11, 12, 13 y 15 del conector DB-25 (el bit S7 contiene el complemento del estado de la línea). Los tres bits de menor peso (SO-S2) no se utilizan y, habitualmente, se encuentran a nivel alto.

El Registro de Control es parcialmente bidireccional. Cuando se escribe en los cuatro bits de menor peso (C0 - C3) lo que se hace es establecer el nivel lógico de los pines C2 de forma directa y C0, C1 y C3 de forma complementada. Los tres bits de mayor peso (C5, C6 y C7) no se utilizan.

El Registro de Datos es de tipo latch de lectura y de escritura, de modo que cuando se realiza una operación de escritura (OUT) el dato se carga en los bits correspondientes y las líneas asociadas del conector tienden a alcanzar la tensión correspondiente a ese estado.

En algunas ocasiones las líneas de datos de la tarjeta de interfase paralelo (Centronics) son bidireccionales, pero la etapa de salida se ha construido mediante buffers con transistores en colector abierto. En este caso, el hecho de que las operaciones de entrada y salida se hagan por las mismas líneas, condiciona notablemente el proceso de lectura, ya que con esa configuración electrónica de las líneas de datos (D0-D7), los valores lógicos leídos dependerán del nivel lógico presente en el registro y del valor de tensión en la línea (que no tienen por qué coincidir) de acuerdo con lo mostrado en la siguiente tabla.

Page 72: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

72 Ing. Prof. Avramovich, Javier A.

Nivel lógico de los bits en el registro de datos.

Nivel de tensión en lo pines del conector DB-25

Nivel lógico leído en una operación de lectura del

puerto paralelo.

Bajo (0) Bajo (0) Bajo (0)

Bajo (0) Alto (1) Bajo (0)

Alto (1) Bajo (0) Bajo (0)

Alto (1) Alto (1) Alto (1)

A la vista de la tabla, lo que se deduce es que, si se va a realizar una operación de lectura sobre el puerto paralelo, lo que se va a leer realmente es la operación AND lógica entre el nivel lógico del registro y el nivel lógico de la línea, lo que implica que, si se desea realizar una lectura real del estado de las líneas, deberá escribirse antes el dato 0xFF en el registro de datos del puerto paralelo.

A continuación se da un ejemplo de cómo se programa el envío de datos a trabes del puerto paralelo.

Page 73: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 73

Programa: /* El siguiente programa envía datos a trabes del puerto paralelo. En primer momento envía unos a todo el bus de datos encendiendo todos los LED por 1 seg. Luego envia ceros a todo el bus de datos apagando todos los LED por 1 seg. Luego comienza una secuencia de encendido de los LED´s uno a uno en forma secuencial y en orden ascendente y descendente, generando en los LED´s el efecto conocido como el del auto fantástico*/ #include <stdio.h> #include <stdlib.h> #include <windows.h> #include <C:\Dev-Cpp\io\io.cpp> // incluido en io.zip #define Data 0x0378 // DATA #define Status Data+1 // STATUS #define Conrol Data+2 // CONTROL int main(int argc, char *argv[]) {int i; LoadIODLL(); // inicializar io.dll <io.cpp> PortOut(Data,0xFF);// Envía UNOS (LEDS ON) Sleep(1000); // Genera un retardo de 1000 ms (1 Seg) _outp(0x378,0x00); // Envía CEROS (LEDS OFF) Sleep(1000); // Genera un retardo de 1000 ms (1 Seg) for (i=0;i<10;i++) {_outp(0x378,0x01); Sleep(100); _outp(0x378,0x02); Sleep(100); _outp(0x378,0x04); Sleep(100); _outp(0x378,0x08); Sleep(100); _outp(0x378,0x10); Sleep(100); _outp(0x378,0x20); Sleep(100); _outp(0x378,0x40); Sleep(100); _outp(0x378,0x80); Sleep(100); _outp(0x378,0x40); Sleep(100); _outp(0x378,0x20); Sleep(100); _outp(0x378,0x10); Sleep(100); _outp(0x378,0x08); Sleep(100); _outp(0x378,0x04); Sleep(100); _outp(0x378,0x02); Sleep(100); } _outp(0x378,0x00); system("PAUSE"); return 0; }

Page 74: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

74 Ing. Prof. Avramovich, Javier A.

APÉNDICE A - TABLA DE CARACTERES ASCII

Page 75: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 75

APÉNDICE B – MÉTODOS DE ORDENAMIENTO Y BÚSQUEDA.

Ordenamiento. Uno de los procedimientos más comunes y útiles en el procesamiento de datos, es la clasificación u ordenación de los mismos. Se considera ordenar al proceso de reorganizar un conjunto dado de objetos en una secuencia determinada. Cuando se analiza un método de ordenación, hay que determinar cuántas comparaciones e intercambios se realizan para el caso más favorable, para el caso medio y para el caso más desfavorable.

La colocación en orden de una lista de valores se llama ordenación. Por ejemplo, se podría disponer una lista de valores numéricos en orden ascendente o descendente, o bien una lista de nombres en orden alfabético. La localización de un elemento de una lista se llama búsqueda.

Tal operación se puede hacer de manera más eficiente después de que la lista ha sido ordenada. Existen varios métodos para ordenamiento, clasificados en tres formas:

• Intercambio.

• Selección.

• Inserción.

En cada familia se distinguen dos versiones: un método simple y directo, fácil de comprender pero de escasa eficiencia respecto al tiempo de ejecución, y un método rápido, más sofisticado en su ejecución por la complejidad de las operaciones a realizar, pero mucho más eficiente en cuanto a tiempo de ejecución. En general, para arreglos con pocos elementos, los métodos directos son más eficientes (menor tiempo de ejecución) mientras que para grandes cantidades de datos se deben emplear los llamados métodos rápidos.

Método de la burbuja.

El método de intercambio o método de la burbuja se basa en comparar los elementos del arreglo e intercambiarlos si su posición actual o inicial es contraria inversa a la deseada. Pertenece a este método el conocido método de la burbuja clasificado como intercambio directo. Aunque no es muy eficiente para ordenar listas grandes, es fácil de entender y muy adecuado para ordenar una pequeña lista de unos 100 elementos o menos.

Una pasada por la ordenación de burbujeo consiste en un recorrido completo a través del arreglo, en el que se comparan los contenidos de las casillas adyacentes, y se cambian si no están en orden. La ordenación por burbujeo completa consiste en una serie de pasadas ("burbujeo") que termina con una en la que ya no se hacen cambios porque todo está en orden.

Ejemplo: Supóngase que están almacenados cuatro números en un arreglo con casillas de memoria de x[1] a x[4]. Se desea disponer esos números en orden creciente. La primera pasada de la ordenación por burbujeo haría lo siguiente:

Comparar el contenido de x[1] con el de x[2]; si x[1] contiene el mayor de los números, se intercambian sus contenidos. Comparar el contenido de x[2] con el de x[3]; e intercambiarlos si fuera necesario. Comparar el contenido de x[3] con el de x[4]; e intercambiarlos si fuera necesario.

Al final de la primera pasada, el mayor de los números estará en x[4].

Page 76: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

76 Ing. Prof. Avramovich, Javier A.

El método de ordenamiento por el método de la burbuja se llama así porque los números pequeños ascienden como burbujas hasta la parte superior, mientras que los mayores se hunden y caen hacia el fondo. Está garantizado que cada pasada pone el siguiente número más grande en su lugar, aunque pueden colocarse más de ellos en su lugar por casualidad.

Page 77: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 77

Programa: #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { int i,j; float numero[10],auxiliar; printf("Programa ejemplo del metodo de ordenamiento de la burbuja"); printf("\n\nIngrese 10 valores que seran ordenados de menor a mayor\n"); for(i=0;i<10;i++) {printf("Numero %d: ",i+1); scanf("%f",&numero[i]); } for(j=0;j<9;j++) {for(i=0;i<9-j;i++) {if(numero[i]>numero[i+1]) {auxiliar=numero[i+1]; numero[i+1]=numero[i]; numero[i]=auxiliar; } } } printf("\n\nLos numeros ingresados y ordenados de"); printf(" menor a mayor son:\n"); for(i=0;i<10;i++) printf("%f\n",numero[i]); system("PAUSE"); return 0; }

Resultado: Programa ejemplo del metodo de ordenamiento de la burbuja Ingrese 10 valores que seran ordenados de menor a mayor Numero 1: 1.25 Numero 2: 10.25 Numero 3: 159 Numero 4: 999 Numero 5: 2145 Numero 6: 3.012 Numero 7: 3.1415 Numero 8: 1978 Numero 9: 0.017 Numero 10: 46.58 Los numeros ingresados y ordenados de menor a mayor son: 2145.000000 1978.000000 999.000000 159.000000 46.580002 10.250000 3.141500 3.012000 1.250000 0.017000 Presione una tecla para continuar . . .

Page 78: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

78 Ing. Prof. Avramovich, Javier A.

APÉNDICE C – INTERFASE PARA PUERTO PARALELO.

Introducción. El siguiente circuito es propuesto como una interfase para conectar el puerto paralelo al mundo exterior | sea para generar señales de control hacia el exterior como para introducir señales tomadas por algún transductor digital.

Descripción. Entre las señales de salida que el puerto paralelo nos proporciona, tenemos los 8 bits del registro de datos, los cuales se encuentran en los pines 2 al 9 en el conector DB25 (J2) y que en el circuito son conectados al Octal BUS Transceiver (IC1-74HC245) que se encarga de adaptar las señales mediante buffers; para que estén disponibles en nuestra placa con niveles correctos para la tecnología TTL. Las señales a la salida del IC1 se encuentran disponibles directamente en el conector J3 para su uso en aplicaciones con niveles lógicos TTL.

Además estas señales ingresan en un array de transistores Darlington (IC3-ULN2803) que se encarga de proporcionar niveles lógicos mara manejo de potencia; con salidas de 12V/500mA que tendremos disponibles en los conectores J4 y J5.

Los LED´s (D1-D8) con sus respectivas resistencias limitadoras de corriente (R1-R8) se utilizan para proporcionarle al usuario una indicación visual permanente del nivel lógico en las salidas, de este modo, cada LED permanecerá encendido mientras tengamos un nivel alto (1 con lógica positiva = 5V) y se apagará cuando tengamos un nivel bajo (0 con lógica positiva = GND).

Las señales que se ingresan a través del puerto paralelo se realizan mediante los pines 10,12,13 y 15 del conector DB25 (J2). Estas señales provenientes del mundo físico exterior deben ser previamente transformadas con un transductor de forma de proporcionarle a nuestra interfase niveles lógicos TTL compatible. Estas señales ingresan a través del conector J6 hacia el Octal BUS Transceiver (IC2-74HC245) que se encarga de adaptar los niveles logicos TTL antes de enviarlas hacia el puerto paralelo.

La fuente de alimentación esta formada por el regulador serie de voltaje (IC4-LM7805) y los capacitares de filtrado C1, C2 y C3. La entrada será a través del conector J1 con niveles de tensión continua entre los 7V – 24V capas de proporcionar un consumo de 100 mA.

Lista de materiales:

R1-R8 1KΩ - 1/4W. R9-R12 10KΩ - 1/4W C1 100 μF/35V C2, C3 100 ηF cerámico. D1-D8 Diodo LED rojo de 35mm. IC1, IC2 74HC245 IC3 ULN2803 IC4 LM7805 J1 conector dos terminales. J2 conector DB25 macho – 90° p/soldar en plaqueta. J3 Tira de pines paralelos rectos dobles - 4x2. J4 – J6 conector cuatro terminales.

Page 79: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

Ing. Prof. Avramovich, Javier A. 79

Diagrama electrónico:

A02 B0 18

A13 B1 17

A24 B2 16

A35 B3 15

A46 B4 14

A57 B5 13

A68 B6 12

A79 B7 11

CE19

AB/BA1

IC1

74HC245

VI1 VO 3

GN

D2

IC4 7805

11421531641751861972082192210231124122513

J2

DB25 Macho

1 2 3 4

8 7 6 5

J3

A02 B0 18

A13 B1 17

A24 B2 16

A35 B3 15

A46 B4 14

A57 B5 13

A68 B6 12

A79 B7 11

CE19

AB/BA1

IC2

74HC245

GND

VCC

GND

GND

12

J1

GND

C1

100uF/35V

C2

100p

VCC

C3

100p

1234

J6

R9

10k

R10

10k

R11

10k

R12

10k

VCC

GND

1234

J4

1234

J5

D6D4

D5D3

D2

D1 D7

D8

R8

1k

R7

1k

R6

1k

R5

1k

R4

1k

R3

1k

R2

1k

R1

1k

GND

Input 3Input 2Input 1Input 0

Output 7Output 6Output 5Output 4

Output 3Output 2Output 1Output 0

12 VdcGND

TTL Output

Higt Power Output12 Vdc / 500 mA

Input Signal

Power Supply

12 Vdc

12 Vdc

1B1 1C 18

2B2 2C 17

3B3 3C 16

4B4 4C 15

5B5 5C 14

6B6 6C 13

7B7 7C 12

COM 10

8B8 8C 11

IC3

ULN2803A

Placa PCB:

Vista Componentes Vista Soldadura

Page 80: Apunte Herramientas Informaticas

Universidad Tecnológica Nacional Facultad Regional Córdoba

Tecnicatura de Mecatrónica

80 Ing. Prof. Avramovich, Javier A.

Este texto no pretende “sustituir a un profesor”, sino servir de apoyo para que los alumnos no pierdan tiempo en tomar apuntes. Es trabajo del profesor aclarar las dudas que surjan y proponer muchos más ejercicios que los que figuran aquí.

Este texto ha sido escrito por el Ingeniero Avramovich, Javier Alejandro. Si quiere conseguir la última versión, o sugerir modificaciones por favor envíe un mail a:

[email protected]

Este texto es de distribución gratuita. Se puede distribuir a otras personas libremente, siempre y cuando no se modifique su contenido parcial o total.

Este texto se distribuye "tal cual", sin garantía de ningún tipo, implícita ni explícita. Aun así, mi intención es que resulte útil, así que le rogaría que me comunique cualquier error que encuentre.

Para cualquier sugerencia, no dude en contactarme.

El autor