Linux Y Electronica-v0

LINUX Y ELECTRÓNICA v0

César Eduardo Ulloa Romo [email protected] 14-05-2009

1

RESUMEN

El presente documento tiene por finalidad fomentar el uso del sistema operativo Linux y sus aplicaciones. También se pretende demostrar el potencial de este sistema operativo en el área electrónica. Se estudiaron diferentes aplicaciones centradas en el diseño y análisis de circuitos electrónicos y aplicaciones para el diseño de circuitos impresos (PCB). Si bien el análisis hecho no es de la profundidad que hubiese querido, creo que aporta algunas luces sobre este tema. Para este estudio se utilizó un computador portátil marca Sony, modelo VAIO VGNN130F con un procesador Intel Centrino de 1,8 GHz, 1,5 GB de memoria RAM. Como sistema operativo instalado se utilizó Debian Testing/Unstable con entorno gráfico GNOME 2.22.3. Todo el software utilizado es GPL a excepción de Eagle, que es la versión limitada disponible para Debian. Este trabajo está licenciado bajo una licencia Creative Commons, es decir : Esta obra está publicada bajo una Atribución-No Comercial-Licenciar Igual 2.0 Chile de Creative Commons. Para ver una copia de esta licencia, visite http://creativecommons.org/ licenses/by-nc-sa/2.0/cl/.

Si existen dudas, consultas, sugerencias, etc. enviar un mail a [email protected]

2

ÍNDICE

1.1¿QUÉ ES UN SISTEMA OPERATIVO?................................................................................9 1.2¿QUÉ ES GNU/LINUX?.........................................................................................................9 1.3¿CUÁNDO NACE GNU/LINUX?..........................................................................................10 1.4¿CÓMO FUNCIONA GNU/LINUX?.....................................................................................10 1.4.1Procesos........................................................................................................10 1.4.2Archivos..........................................................................................................11 1.4.3Directorios......................................................................................................13 1.4.4Sistemas de Archivo......................................................................................13 1.5UTILIZANDO LINUX............................................................................................................14 1.5.1Estructura del sistema operativo....................................................................14 1.5.2Instalación y configuración de aplicaciones en GNU/Linux...........................16 1.6GNUCAP..............................................................................................................................24 1.6.1Ejemplo: circuito de carga de condensador...................................................25 1.7NGSPICE.............................................................................................................................29 1.7.1Ejemplo: circuito de carga de condensador...................................................30 1.8OREGANO...........................................................................................................................35 1.8.1OREGANO CON GNUCAP...........................................................................40 1.8.2OREGANO CON NGSPICE..........................................................................42 1.9GEDA...................................................................................................................................43 1.9.1Gschem..........................................................................................................43 1.9.2Gnetlist...........................................................................................................45 1.9.3Gattrib.............................................................................................................45 1.9.4Symbols..........................................................................................................46 1.9.5Ejemplo: Circuito de carga de condensador..................................................46 1.10KLOGIC..............................................................................................................................50 1.10.1Ejemplo: Diseño de circuito con flip-flop tipo T............................................52 1.11KICAD................................................................................................................................56 1.11.1Eeschema....................................................................................................56 1.11.2Cvpcb...........................................................................................................57 1.11.3Pcbnew.........................................................................................................58 1.11.4Ejemplo: Diseño de circuito amplificador inversor con amplificador operacional..........................................................................................................................59 1.12EAGLE...............................................................................................................................67 1.12.1Libraries........................................................................................................68 1.12.2Design Rules................................................................................................69 1.12.3Scripts..........................................................................................................70 1.12.4Projects........................................................................................................70

3

1.12.5Ejemplo: Diseño de circuito amplificador inversor con amplificador operacional..........................................................................................................................70

4

SIGLAS

E EAGLE ERC F F/F G GNU GNUCAP GPL GRUB L LILO

: Easy Applicable Graphical Layout Editor : Electric Rules Check : Flip Flop : GNU is Not Unix : GNU Circuit Analysis Package : General Public License. : Grand Unified Bootloader : Linux Loader

M MBR : Master Boot Record N NGSPICE : New Generation SPICE P PCB : Printed Circuit Board S SPICE

: Simulation Program with Integrated Circuits Emphasis

5

INTRODUCCIÓN

Debido al crecimiento sostenido de la plataforma de software libre en el mercado mundial y a la poca difusión del mismo, en el área de electrónica y del país en general, se hace necesario instruir y motivar al estudiante hacia la investigación de las fortalezas y debilidades que presenta el software libre frente al software propietario, no libre, o privativo que se utiliza a diario y, en la mayoría de los casos, de forma ilegal. ¿Qué es software libre y qué es software propietario? Software libre es una aplicación que concede al usuario cuatro derechos: o Ejecutar el programa con cualquier propósito: Educacional, comercial, militar, etc. o Estudiar y modificar el programa: para esto se requiere el código fuente. o Copiar el programa: Las copias en cualquier medio y a cualquier escala están permitidas. o Mejorar el programa y publicar las mejoras: A raíz del código fuente se puede modificar el programa original para usos específicos, y luego hacer públicas las mejoras del programa. Hay que aclarar que en inglés se denomina “free software”, lo que tiende a confundir acerca de su concepto de “gratis”. Software libre no es lo mismo que software gratis, aunque pueden coincidir. El software gratis es denominado “freeware”. El software propietario, en cambio, reserva los derechos de autor a la persona o compañía que lo desarrolló; prohibiendo su copia, redistribución y su modificación, ya que no entrega el código fuente del programa. Por otro lado; ¿Quién tiene una copia legal de Windows en su hogar? A la mayoría de la gente no le interesa, esto ocurre casi siempre por desconocimiento del usuario. Cuando se adquiere un computador nuevo de marca reconocida, generalmente viene preinstalado un sistema Windows. El valor del software que viene con el computador está incluido en el precio, pero el comprador no lo sabe. Cuando instala el computador en su casa y lo enciende se da cuenta de que su nuevo computador “no trae nada”. Acto seguido comienza a instalar programas que le han prestado o ha descargado desde Internet, creyendo que esto es normal, pero en realidad está cometiendo un delito. Si no ha comprado el software, y lo está instalando, está robando. A raíz de este mismo problema, se desarrolló el concepto de que si el programa tenía un costo de adquisición, se debía tener el derecho de adaptarlo a las necesidades propias de uso. Actualmente se desarrollan aplicaciones libres que cumplen los mismos objetivos que los privativos, algunos de mejor manera incluso. Se podría decir que el valor que se paga por el software privativo es por el soporte que entregan, en caso de cualquier duda o problema. El soporte del software libre está en el Internet, en el sitio del desarrollador o en foros alrededor del mundo. El soporte es el mismo que para el software privativo.

6

Existe una ventaja notable del software privativo por sobre el libre, está masificado. Hoy en día el estándar de las aplicaciones de oficina es MS Office. Por ejemplo: si no está en .doc, no sirve. Es una mala costumbre enviar documentos (por ejemplo un currículum vitae) que no necesitan posterior revisión o modificación en formato .doc, si para eso está el estándar PDF. En el área electrónica existen aplicaciones que pueden simular circuitos, ya sean analógicos o digitales, combinaciones de ambos, etc.; que permiten análisis transiente, en el tiempo y en la frecuencia. Son compatibles con los modelos matemáticos que entregan los fabricantes de semiconductores (modelos SPICE). En este campo las aplicaciones privativas llevan un paso adelante, ya que el software libre para electrónica está aún en desarrollo, pero pueden utilizarse como medio comparativo de las aplicaciones privativas. Pueden servir como tema de investigación, desarrollo e innovación. Si el software libre está ahí, y es “gratis”, entonces, ¿por qué no utilizarlo?

7

CAPÍTULO 1: INTRODUCCIÓN A LINUX

8

1

INTRODUCCIÓN A LINUX

En este capítulo se hace una breve descripción de lo que es el sistema operativo GNU/Linux y cómo se utiliza. Comenzando desde lo más básico como ¿qué es un sistema operativo?, pasando por la historia de este sistema, una breve descripción de su arquitectura, cómo el usuario interactúa con éste, para finalizar en el manejo de aplicaciones dentro del mismo. 1.1

¿QUÉ ES UN SISTEMA OPERATIVO?

Un sistema operativo es un administrador de recursos disponibles dentro de un computador. Por ejemplo: impresora, teclado, disco duro, etc. El sistema operativo decide qué imprimir, que caracteres se ingresan, dónde se escriben o leen los datos. Hace unas cinco décadas, los computadores no podían ejecutar más de un programa a la vez, ya que no existía sistema operativo, no había un administrador de recursos que permitiera esta tarea. Al avanzar la tecnología, se comenzó a cargar diferentes programas dentro de un computador a la vez por medio de cintas, y a través de un programa monitor, éste podía ejecutar los programas precargados desde la cinta. En la década de los setenta surgió el término “multiprogramación”. Si un programa debía esperar que ocurriera un evento externo para continuar con su ejecución, la CPU, a través del programa monitor, podía comenzar la ejecución de otro programa cargado desde una cinta, para así tener un aprovechamiento superior del procesador del computador. A finales de los setenta surge el sistema operativo UNIX, de manos de Ken Thompson, de Bell Labs, que en la actualidad ocupa un amplio porcentaje en el mercado, aunque no es utilizado en su mayoría por el usuario promedio, se utiliza bastante en servidores y hardware. 1.2

¿QUÉ ES GNU/LINUX?

GNU/Linux o popularmente conocido como Linux, es un sistema operativo de tipo UNIX, de código abierto y que se encuentra bajo la licencia GPL (General Public License). Actualmente se utiliza en computadores de diferentes clases: de escritorio, portátiles, servidores, teléfonos móviles, sistemas dedicados, consolas de videojuego, dispositivos de red, etc. Es multiplataforma, puede ser instalado en computadores de diferentes arquitecturas, como Intel o IBM PowerPc.

9

Es un sistema multiusuario, que permite que más de un usuario pueda ejecutar acciones en un mismo sistema a la vez. Tiene una estructura que se denomina núcleo monolítico, lo que implica que es un núcleo grande y complejo que engloba todos los servicios del sistema. En estos tipos de núcleo todos los servicios del sistema(periféricos, sistemas de archivos, conexiones de red, etc.) se encuentran dentro de un gran programa, la extensión del programa es variable de acuerdo a la cantidad de funcionalidades que tenga el núcleo. Todo esto implica, en muchos casos, que para añadir una nueva funcionalidad al sistema, el núcleo deba ser compilado nuevamente. Una característica que ha adquirido con el tiempo es que estas nuevas funcionalidades puedan ser cargadas y descargadas sin recompilar el núcleo, a esto se le denomina módulo. 1.3

¿CUÁNDO NACE GNU/LINUX?

Richard Stallman trabajaba en los laboratorios de inteligencia artificial del MIT, pero en el año 1983, renuncia y crea el proyecto GNU con la finalidad de obtener un sistema operativo completamente libre. Su renuncia se debió a que fue obligado a firmar un acuerdo de no divulgación. Este acuerdo, no formaba parte de sus principios, por lo que decidió iniciar su propio proyecto. Con su proyecto GNU, Stallman y sus colaboradores desarrollaron una gran cantidad de aplicaciones, las que permitieron, en 1991, a Linus Torvalds, generar el núcleo de un sistema operativo que más tarde sería conocido como GNU/Linux o simplemente Linux. 1.4

¿CÓMO FUNCIONA GNU/LINUX?

1.4.1 Procesos Cada programa es un conjunto de datos que hace lo que se necesita. Un proceso es más que un programa en sí, por ejemplo, en un editor de textos se está editando un archivo cualquiera; aunque este archivo no es parte del programa, lo es del proceso en ejecución. Si dos o más usuarios estuvieran ejecutando el mismo programa, tendrían asignados procesos diferentes dentro de la memoria del computador. Como es sabido, en todos los sistemas tipo UNIX, puede haber más de un usuario conectado a la vez en un mismo sistema. Esto significa que el sistema operativo tiene más de un proceso abierto “a la vez” en dicho computador. Si un usuario abre una consola de comandos (conocida como shell), ya tiene un proceso, pero si además dentro de esta consola ejecuta, por ejemplo un editor de textos, otro proceso diferente se carga en memoria, conservando el proceso anteriormente abierto por la consola. Se dice entonces que el editor de textos es un proceso “hijo” y que la consola es un proceso “padre”. Un proceso puede tener solo un padre, pero muchos hijos, como es el caso de una consola de comandos.

10

Al mismo tiempo que un usuario ejecuta una consola y un editor de textos; otro usuario puede estar trabajando copiando archivos, editando una hoja de cálculo, etc. Por cada programa que se abre, el sistema abre un proceso diferente, y simula que cada usuario tiene todos los recursos disponibles sólo para él. Cada proceso, de cualquier usuario, tiene acceso al procesador del computador por cierto intervalo de tiempo. Si en un sistema GNU/Linux, un usuario tiene acceso al sistema por 100[ms], al término de este tiempo es el turno de otro proceso, que puede ser incluso de otro usuario del sistema. Se comparaba con un sistema Windows (inferior a la versión NT). Los programas que se ejecutaban utilizaban el procesador completamente hasta terminar. Si un programa se colgaba mientras hacía uso del procesador, ni el mismo sistema operativo podía detenerlo, ya que había entregado el control al programa que dejó de funcionar correctamente. Cuando se necesita escribir datos al disco duro, el computador pareciera escribirlos de manera instantánea, en realidad el sistema gestiona este tipo de procesos, recolecta peticiones de escritura y lectura al disco y las ejecuta en bloques, esto hace más eficiente la entrada y salida de datos desde el disco. Este sistema tiene una ventaja, ya que a menudo los datos leídos desde el disco se vuelven a utilizar más de una vez. El sistema operativo guarda estos datos en un espacio especial de la memoria, llamada caché, desde donde las llama cada vez que las necesita. Si el sistema escribiera o leyera los sistemas cada vez que se requiere, los procesos efectivamente útiles del sistema se verían drásticamente reducidos por la gran cantidad de peticiones. Además de los procesos de usuario vistos anteriormente, el sistema también tiene procesos en ejecución, que el sistema operativo ejecuta en la memoria. Estos procesos están relacionados principalmente con la administración de memoria y la calendarización de los turnos del procesador, también hay procesos que se relacionan con la entrega de correo, servicios de impresión y otros servicios que son transparentes para el usuario, como el sonido y el entorno gráfico. Aunque estructuralmente los procesos del sistema y los de usuario son idénticos, los procesos del sistema pueden ejecutarse con una prioridad más alta, es decir, tienen una mayor frecuencia en los turnos de uso del procesador. 1.4.2 Archivos Un archivo es un conjunto bytes almacenados en algún tipo de memoria. Este conjunto de bytes lleva un nombre que es el que reconoce el sistema operativo y ubica su posición exacta en la memoria. Al igual que en otros sistema operativos, existen diferentes tipos de archivos para denotar diferentes aplicaciones del mismo, por ejemplo existen archivos ejecutables (programas), archivos de audio, de video, imágenes, archivos de texto, etc. En los sistemas tipo UNIX podemos encontrar además otros tipos de archivo, como los archivos de dispositivos. En los sistemas tipo UNIX el hardware es administrado a través de un archivo específico, todos los dispositivos del computador son tratados como un archivo, desde donde se controlan todas sus operaciones.

11

También existen los archivos de canalización (pipeline), los que se utilizan para la redirección de los mismos a otro sitio. Son utilizados para que la salida de un programa sirva como la entrada de otro A diferencia de los sistemas operativos similares a DOS o Windows, no existe un patrón de ejecución de archivos. En DOS jamás se podrá ejecutar un archivo que no sea .EXE, .COM o .BAT. En UNIX esto es independiente, de acuerdo a los permisos que tenga el archivo, será la capacidad de ejecución (usuario, administrador) del archivo sin importar su extensión. El archivo programa puede ser ejecutado al igual que el archivo programa.txt Se pueden ver los permisos de un archivo ejecutando un listado de los archivos de un directorio, como se muestra en la .

Figura 1: Resultado comando ls -l A la izquierda se pueden observar, separados por un guión los permisos para root, grupo y usuario. Un programa puede tener permisos de ejecución sin ser un archivo ejecutable, esto puede tener respuestas inesperadas y aleatorias en el sistema o bien, una pantalla de error respecto de la ejecución del archivo. Los nombres de archivo en GNU/Linux pueden ser de hasta 255 caracteres de longitud y su nombre diferencia mayúsculas de minúsculas, así, el archivo lista.txt es diferente de Lista.txt, lista.TXT, LISTA.txt, etc. Basta que una letra sea diferente (esté en mayúsculas) para que el archivo también lo sea. Un alcance importante para los archivos en Linux, es el punto “.” al comienzo de un archivo; el sistema operativo asume que todos los archivos que comienzan con punto, son ocultos. Para ocultar un archivo, basta sólo con cambiar su nombre y agregarle un punto como primer carácter.

12

Además, los archivos en los sistemas tipo UNIX, cumplen una función diferente dentro del sistema operativo. Aparte de de contener datos, los archivos son la forma de acceder al hardware del sistema, cuando accede a la memoria, también lo hace como accedería a un archivo. Por ejemplo, si se está editando un archivo de texto, además del archivo abierto como tal, el sistema operativo tiene un archivo abierto que relaciona el archivo con el sistema de archivos y éste con la partición, la partición con el disco duro y el disco duro en sí, también son tratado como archivos. 1.4.3 Directorios En Linux, un directorio es un archivo con formato especial que indica dónde están los archivos realmente en el disco, contiene los nombre de los archivos que están asociados a él, pero no el archivo en sí. Esta posición física del archivo se denomina inodo y es lo que se guarda en el archivo del directorio. Al ejecutar un listado de directorio o en un navegador de archivos, éstos leen la información de este archivo de formato especial y la presenta en pantalla de una forma jerarquizada. Un directorio puede contener más directorios en su interior, llamados subdirectorios. Con esto se crea una estructura jerarquizada que se ve en el navegador de archivos al explorar el disco. Para referirse a los directorios en GNU/Linux se utiliza la barra diagonal (slash) “/”. El directorio raíz del sistema es “/”, dentro de este directorio se encuentra toda la estructura organizada del disco. A medida que se avanza en la estructura de directorios, los nombres se separan con “/”, por ejemplo “/media/RAZEK/trabajo_de_titulo/cap1/cap1.odt“, lo que se convierte en una ruta de archivo. Esta estructura permite que existan dos archivos exactamente iguales, pero con una ruta diferente, como se indica en la Figura 2: Ejemplo de estructura de directorios

Figura 2: Ejemplo de estructura de directorios

13

La ruta de un archivo debe ser única en todo el sistema. Cuando se navega por los directorios, en realidad lo que hace es leer unos archivos que contienen el nombre y la posición en el disco inodo) de los datos reales a los que se desea acceder. 1.4.4 Sistemas de Archivo En Linux los archivos y directorios están agrupados en unidades llamadas sistemas de archivo. Sistema de archivo es una parte del disco duro que es administrado como una sola unidad. Los sistemas de archivo se encuentran dentro de una unidad física denominada partición. Los discos duros pueden dividirse en múltiples particiones, cada una de las cuales contiene un sistema de archivos, el cual puede ser diferente en cada partición; es el caso de sistemas que contienen dos sistemas operativos diferentes. 1.5

UTILIZANDO LINUX

Para conocer en forma práctica la estructura de Linux, a continuación se mostrará cómo se organizan los directorios en un sistema estándar, para una familiarización con el sistema operativo. 1.5.1 Estructura del sistema operativo 1.5.1.1 Directorio raíz Uno de los archivos más importantes dentro de la estructura de directorios de GNU/Linux, es el archivo vmlinuz. Este archivo es el sistema operativo en sí, contiene todas las funciones del sistema. Cuando este archivo se encuentra en el disco duro, se encuentra en /boot/vmlinuz. Si el archivo se encuentra cargado en la memoria, se le llama kernel.

14

Figura 3: Estructura de directorios típica de un sistema Linux

En la Figura 3: Estructura de directorios típica de un sistema Linux se representa en forma esquemática la organización de directorios de un sistema GNU/Linux estándar. En el directorio /bin es donde se guardan muchos de los archivos ejecutables del sistema. Su nombre proviene de binario, que es la forma en que se llaman los archivos ejecutables (programas) en Linux. Los permisos de este directorio generalmente son de lectura y ejecución para los usuarios y sólo el administrador del sistema tiene acceso de escritura. El directorio /boot es donde se encuentran los archivos de arranque del sistema, y desde donde arranca vmlinuz, el cerebro del sistema o kernel. En /dev se contienen los archivos de dispositivo, es decir, es el directorio en donde el sistema accesa al hardware del sistema a través de los archivos. El directorio /etc contiene archivos de configuración de las aplicaciones del sistema, casi la totalidad de las aplicaciones del sistema tienen un archivo de configuración que se encuentra en este directorio. El administrador es el que tiene permisos de escritura de estos archivos, los usuarios generalmente(a menos que el administrador dé los permisos correspondientes) sólo pueden acceder como lectura dentro de este directorio. Las configuraciones que guardan estos archivos son de las aplicaciones en general, los usuarios en su directorio /home tienen acceso a los archivos de configuración de las aplicaciones, pero solo en forma local. Los archivos de configuración editados en /etc modifican las variables del programa en todo el sistema; así una modificación en /etc afectará a todos los usuarios de dicha aplicación o programa.

15

En /home se ubican los directorios de los usuarios generados en el sistema, es el espacio reservado para el uso del usuario. Acá cada usuario tiene acceso irrestricto a los archivos que él copie, edite o cree, a menos que el administrador indique lo contrario. El directorio /lost+found se usa para mantener los archivos que han perdido su inodo, es decir, no tienen asociada una posición en el disco, aunque físicamente estén en una porción del disco duro. Cuando se ejecuta una revisión del sistema de archivos, luego de un reinicio imprevisto del sistema, por ejemplo; pueden quedar archivos que no fueron asignados con inodo. Cuando la herramienta de revisión de disco (e2fsck) encuentra este tipo de archivos, les asigna el directorio /lost+found para su posterior recuperación. El directorio /proc es muy importante ya que es el reflejo del kernel, la memoria, el hardware y los procesos que se están en ejecución. La mayoría de estos archivos son sólo de lectura. El directorio /root correspondo al directorio personal del administrador del sistema, solo éste tiene acceso a él. /sbin contiene los archivos binarios del sistema en sí, las tareas de administración del sistema se ejecutan desde este directorio. Aunque los archivos generalmente son accesibles a los usuarios, su ejecución está limitada, ya que los dispositivos del sistema no son siempre accesibles a los usuarios. Dentro del directorio /usr, se encuentran la mayoría de los datos que utilizan los usuarios del sistema; los archivos binarios, archivos de documentación, bibliotecas, código fuente de aplicaciones, entorno gráfico, etc. En el directorio /var se encuentran los archivos que “varían” conforme a la ejecución del sistema o aplicaciones, guarda los registros de ejecución de programas (/var/log/), los registros de caídas de programas (/var/crash/), etc. 1.5.1.2 Arranque del sistema Al encender el computador, éste realiza una serie de procesos para inicializar el hardware propio e ejecutar pruebas sobre los mismos. Una vez que termina de hacer este procedimiento, el computador va a leer el sector 0 del disco maestro, el registro de arranque maestro (MBR) y ejecuta las instrucciones contenidas en ese sector. En un sistema GNU/Linux pueden variadas aplicaciones para el arranque, pero las más utilizadas son: lilo (Linux loader) y grub (grand unified bootloader). En la actualidad grub está reemplazando a los sistemas con lilo, ya que es mucho más versátil y eficiente en su trabajo; una de sus principales ventajas es que reconoce otros sistemas operativos instalados en la máquina. Debido a que lilo ya está quedando obsoleto, se trabajará con grub. Al iniciar el MBR del disco, se ejecuta grub, que, según como se configure a través de /boot/grub/menu.lst contiene una lista de los sistemas operativos instalados y arrancables. Grub está diseñado para ser independiente respecto del sistema operativo que arranque, En el fondo, lo que grub hace es ir al sector0 del sistema operativo seleccionado y ejecutarlo, de ahí en adelante, el sistema en sí es el que inicia su proceso de carga y grub deja de trabajar.

16

Figura 4: Pantalla típica de grub Una vez seleccionado el kernel a arrancar, mostrado en la Figura 4: Pantalla típica de grub, comienza el proceso de boot del sistema operativo. Boot viene de bootstrapping, en alusión a que un sistema “tira del cordón de sus botas para levantarse”. Dependiendo de la configuración del sistema que esté instalado, se puede o no observar el proceso de carga del sistema 1.5.2 Instalación y configuración de aplicaciones en GNU/Linux Bajo GNU/LINUX existen dos formas de instalar aplicaciones en el sistema, la más común es utilizar el administrador o gestor de paquetes de la distribución instalada, el cual automatiza el proceso de instalación del programa deseado y de todas sus dependencias. También existe una manera estándar, que es transversal a cualquier distribución de GNU/LINUX. Esto requiere la compilación del código fuente del software a instalar, además de que se cuente con todas las dependencias que éste necesita. 1.5.2.1 Distribuciones y tipos de paquetes De acuerdo a la distribución que se esté utilizando, el administrador de paquetes será diferente, por ejemplo: o Debian utiliza synaptic. o Fedora utiliza yum. o SuSe utiliza yast. o Slackware utiliza sware. Estos administradores de paquetes no son sólo para una distribución específica, así, Debian y SuSe pueden utilizar también el administrador de paquetes apt-get o aptitude. Cada administrador de paquetes tiene sus propias características, pero sus funciones principales

17

son las mismas: buscar, instalar, desinstalar aplicaciones y sus dependencias, de manera de automatizar el proceso de instalación de software. Como muchas aplicaciones de GNU/LINUX los administradores de paquetes puede ejecutarse tanto en entorno gráfico como en consola de comandos, en ambos entornos tienen la misma funcionalidad. La diferencia radica en que en la consola de comandos se utiliza sólo el teclado y los comandos se ejecutan a través del tecleo de las instrucciones. En el entorno gráfico se utiliza el ratón para seleccionar las opciones, tal como se trabaja con cualquier aplicación en entorno gráfico. Los tipos de paquetes se dividen en binarios y de código fuente. Los paquetes binarios varían de acuerdo a la distribución instalada, mientras que los paquetes de código fuente, pueden ser instalados en cualquier distribución. De acuerdo a la distribución que se utilice, el paquete binario será diferente en su extensión y en su estructura interna. Por ejemplo: o Debian utiliza la extensión .deb o Fedora y SuSe utilizan la extensión .rpm o Slackware utiliza la extensión .tgz Los paquetes de código fuente son estándar para cualquier distribución de GNU/LINUX y la forma de instalación es bastante similar en cada distribución, pasando por un proceso de configuración, compilación e instalación. Los paquetes de código fuente vienen generalmente en dos formatos diferentes, de acuerdo al formato de compresión que se utilice. Aunque ambos utilizan la aplicación tar para su compresión, para uno de ellos se requiere el adicionalmente programa bzip. Su diferencia principal es la capacidad de compresión; bzip (.tar.bz2) tiene la capacidad de generar archivos comprimidos de tamaño menor a los que genera tar(.tar.gz). 1.5.2.2 Instalación a través de un gestor de paquetes La instalación a través de un gestor de paquetes se utiliza sólo con archivos binarios, según la distribución. Para comenzar se debe abrir el gestor de paquetes con permisos de root(Administrador). Este paso está automatizado en el entorno gráfico, ya que al ejecutar el programa se le pide que ingrese la contraseña de root.

18

Figura 5: Gestor de paquetes synaptic Dentro del gestor de paquetes, mostrado en la Figura 5: Gestor de paquetes synaptic se busca y selecciona la aplicación a instalar y se selecciona el botón instalar. El instalador verifica el paquete a instalar y sus dependencias para luego mostrar los resultados y pedir aprobación del usuario para su instalación. Por ejemplo, para instalar el programa oregano, se realizan los pasos siguientes : o Abrir el gestor de paquetes. o Buscar el paquete oregano y seleccionarlo para su instalación. o Seleccionar y aplicar o instalar según la distribución, indicado en la Figura 6: Búsqueda de paquetes en synaptic. o El sistema verifica las dependencias y pide la aprobación para su instalación. o Instala si es aprobado para su instalación por el usuario. El administrador de paquetes comienza la descarga e instalación de la aplicación seleccionada

19

Figura 6: Búsqueda de paquetes en synaptic Una vez concluida la instalación muestra en pantalla un resumen general de los pasos ejecutados por el instalador y si el paquete fue instalado satisfactoriamente o tuvo errores en el proceso. También una aplicación (paquete) puede ser instalado desde un administrador de paquetes que se ejecute a través de la consola de comandos, como es el caso del gestor apt-get, que es utilizado en varias distribuciones. Instalando el paquete oregano, los pasos a realizar bajo el gestor apt-get son los siguientes : o Abrir una consola de comandos o Ejecutar el comando apt-cache search orégano o Esperar la respuesta del sistema indicando si el paquete existe y si es instalable. Si la respuesta es positiva, la consola entregará una respuesta como la de la Figura 7: Gestor de paquetes apt-get.

20

Figura 7: Gestor de paquetes apt-get Para instalar la aplicación se ejecuta el comando: apt-get install oregano o El administrador de paquetes verifica las dependencias e instala los paquetes correspondientes o Una vez terminado, el sistema entrega un resumen de las acciones ejecutadas durante la instalación, indicado en Figura 8: Búsqueda e instlación del paquete oregano bajo apt-get.

Figura 8: Búsqueda e instlación del paquete oregano bajo apt-get

21

1.5.2.3 Instalación desde código fuente La instalación de este tipo de paquetes se justifica cuando la distribución no tiene la aplicación en formato binario o, si la tiene, ésta no cuenta con todas las funcionalidades que el software puede desarrollar. Para instalar aplicaciones desde su código fuente, se debe contar con las herramientas esenciales de compilación de software como son el compilador gcc y g++, las librerías libc6 y la herramienta make. Con estas herramientas ya instaladas, se cuenta con lo mínimo para comenzar la compilación e instalación de paquetes; esto no significa que cualquier programa va a ser compilado e instalado satisfactoriamente, ya que antes de instalar cualquier software bajo este método, se deben instalar primero sus dependencias. Para compilar e instalar software desde su código fuente, se deben seguir los siguientes pasos: o Abrir una consola con permisos de root o Mover o copiar la aplicación al directorio /usr/src o Descomprimir el archivo con el código fuente, mostrado en la Figura 9: Descompresión de código fuente.

Figura 9: Descompresión de código fuente

22

o Ingresar al directorio que se generó de la descompresión o Leer el archivo README o INSTALL para verificar las dependencias y pasos de instalación de la aplicación o Ejecutar el script ./configure e ir revisando los pasos en busca de problemas, mostrado en la Figura 10: Ejecución del script configure. Generalmente, cuando falla un script configure, se debe a que una dependencia no se encuentra resuelta. El resultado del script configure es un archivo Makefile, que es utilizado por make para la compilación.

Figura 10: Ejecución del script configure o Ejecutar el comando make, para comenzar la compilación. Al igual que con configure, se debe revisar la salida del programa para comprobar la correcta compilación del paquete. o Ejecutar el comando make install para que se instalen los archivos ejecutables en los directorios correspondientes, generalmente /usr/bin/, a menos que se especifique otro directorio. Una vez completados estos pasos de manera satisfactoria, la aplicación instalada se puede ejecutar en el entorno gráfico o de consola, llamándola desde la consola o seleccionándola desde el menú.

23

CAPÍTULO 2: APLICACIONES DE DISEÑO DE CIRCUITOS Y SIMULACIÓN

24

2

APLICACIONES DE DISEÑO DE CIRCUITOS Y SIMULACIÓN

Como apoyo al estudio se pueden utilizar aplicaciones que permiten realizar una simulación virtual de los cálculos y circuitos estudiados en la literatura. Estas herramientas hacen mucho más comprensible para el estudiante los efectos que se producen en los circuitos electrónicos, ya sean análogos o digitales. Por otro lado, algunos de estos softwares se acogen a la licencia GPL (General Public License). 2.1

GNUCAP

Gnucap es el acrónimo de GNU circuit analysis package, es un analizador de circuitos eléctricos multipropósito desarrollado por el proyecto GNU. Permite realizar análisis de : corriente continua, corriente alterna, transiente y fourier. La última versión lanzada corresponde a la 0.35 y está bajo la GPL Gnucap es un software que funciona bajo la consola de comandos, no tiene entorno gráfico por sí mismo, pero es utilizado como backend para otros programas de simulación gráficos, como orégano. Gnucap puede ser ejecutado ya sea como backend, en modo por lotes, o en modo normal. Cuando se utiliza como backend, Gnucap, es transparente para el usuario, ya que programa con el que se interactúa (frontend), ejecuta los comandos en Gnucap. Al ejecutar Gnucap, en la consola se abre una nueva línea de comandos en la que ya se puede comenzar a diseñar el circuito. Al ejecutar Gnucap desde una consola se abre una interfaz como la de la Figura 11: Pantalla principal de gnucap.

25

Figura 11: Pantalla principal de gnucap 2.1.1 Ejemplo: circuito de carga de condensador Teniendo el circuito esquemático de la Figura 12: Circuito simulado en gnucap

Figura 12: Circuito simulado en gnucap

26

Se ejecuta Gnucap desde una consola y con la instrucción build, se ingresan los valores correspondientes a los componentes, como se indica en la Figura 13: Construcción de circuito de gnucap

Figura 13: Construcción de circuito de gnucap Los elementos se ingresan de acuerdo a una notación convencional dentro del ámbito eléctrico, donde V es una fuente de voltaje, C un condensador, L una inductancia, etc. Como se muestra en la Figura 13: Construcción de circuito de gnucap la fuente de tensión se indica como V1 (el uno representa su identificador, ya que en un circuito pueden encontrarse múltiples fuentes, las que serían V2, V3, V4, etc. respectivamente); luego se indica los nodos en los cuales está conectada, el nodo 0 (cero) es siempre tierra. Luego se indica que la fuente es de tensión continua, y finalmente el valor de la tensión. Con los demás componentes se utiliza la misma lógica, se les indica un identificador numérico, luego sus nodos de conexión, y finalmente el valor que se desee asignar. Importante es que no se debe indicar la unidad de medida, sólo la magnitud. Una vez ingresados los componentes, a través del comando build. Se recomienda, por seguridad, guardar el archivo, a través del comando save, como se muestra en la Figura 14: Comando save en gnucap.

27

Figura 14: Comando save en gnucap Una vez guardado, se procede a configurar y seleccionar los parámetros que se analizarán, en caso del análisis de la carga de un condensador, los parámetros importantes son: la tensión de la fuente y la tensión del condensador. Esta selección de parámetros se efectúa a través del comando print, indicado en la penúltima línea de la Figura 15: Comando de simulación de gnucap. Luego de seleccionar las variables, se ejecuta el análisis deseado, en este ejempĺo se hace uso del análisis transiente, a través del comando tran, indicado en la Figura 15: Comando de simulación de gnucap.

28

Figura 15: Comando de simulación de gnucap Una vez ejecutado el comando tran se genera una lista de valores desde t=0 a t=1.2 [s], si no se indica un archivo de destino, mostrado en la Figura 16: Resultado de la simulación en archivo de texto plano, Gnucap las muestra por pantalla.

Figura 16: Resultado de la simulación en archivo de texto plano

29

2.2

NGSPICE

Ngspice es un simulador de circuitos electrónicos basado en tres softwares de código abierto : spice3f5, Xcircuit y Cider1b1. Spice es un simulador desarrollado por la universidad de Berkeley, en el año 1975, por Donald Pederson. Su acrónico en inglés es Simulation Program with Integrated Circuits Emphasis (Programa de Simulación con Énfasis en Circuitos Integrados) y actualmente está en la versión 18, que se libera el 1 de diciembre del 2008. Es parte del proyecto Geda, que busca generar un entorno de diseño, simulación análisis y representación gráfica de circuitos electrónicos. Al igual que Gnucap se ejecuta en consola de comandos y es backend para otras aplicaciones. Para trabajar con Ngspice se debe primero editar un archivo netlist, cualquier editor de texto plano sirve para este propósito. Al editar un archivo de nodos o archivo netlist, la primera línea siempre corresponde al nombre de circuito. El carácter asterisco (*) se utiliza para realizar comentarios, cualquier carácter que se encuentre a continuación de un asterisco, no será tomado en cuenta por Ngspice al momento de la ejecución del circuito. De manera general, R corresponde a una resistencia, C a un condensador, V a fuente independiente, etc. Las líneas que comienzan con punto (.) corresponden a comandos que Ngspice ejecutará para la simulación, por ejemplo .model indica que cargará un modelo de componentes desde un archivo externo; .op indica que se ejecutará análisis del punto de operación; .tran indica análisis transiente; etc Al ejecutar Ngspice, a través de la consola, se abre otra línea de comandos, como se indica en la Figura 17: Pantalla principal de ngspice.

Figura 17: Pantalla principal de ngspice

30

Al ingresar a este intérprete de comandos se puede comenzar a trabajar con Ngspice. 2.2.1 Ejemplo: circuito de carga de condensador Tomando el circuito de la Figura 18: Circuito simulado en ngspice:

Figura 18: Circuito simulado en ngspice Al editar para Ngspice se tiene lo siguiente en el interior del archivo de nodos (archivo netlist): CIRCUITO CARGA DE CONDENSADOR * V1 1 0 dc 5 R1 1 2 1k C1 2 0 100u * .op .tran 0.01 1 uic .end Se debe observar que la forma de escritura es la misma que se utiliza con gnucap, logrando una uniformidad entre las aplicaciones para una potabilidad entre ellas.

31

Se ejecuta el comando Ngspice Ngspice_carga_condensador.net. Una vez dentro de Ngspice se ejecuta el circuito con el comando run. Luego, con el comando display, se verifican los vectores analizados, indicados en la Figura 19: Archivo cargado a ngspice.

Figura 19: Archivo cargado a ngspice Los vectores simulados en este caso son V(1) y V(2), éstos corresponden a los nodos del circuito descritos en el archivo net simulado. V(1) corresponde a la fuente de tensión continua y V(2) a la tensión en el condensador. A través del comando print, mostrado en la Figura 20: Resultado de la simulación en pantalla de ngspice, Ngspice arroja a la consola los valores de la simulación transiente. Se debe tener presente que a diferencia de Gnucap, en el archivo de nodos debe especificarse el tipo de análisis a realizar, en este caso , con el comando .tran se especifica que se desea un análisis transiente del circuito.

32

Figura 20: Resultado de la simulación en pantalla de ngspice En la primera columna de la Figura 20: Resultado de la simulación en pantalla de ngspice, se encuentra el número de muestra analizada, en la segunda tiempo, de acuerdo al intervalo establecido en el archivo net, luego sigue la tensión V(1) que corresponde a la fuente continua, y la cuarta columna corresponde a la tensión del condensador C1. También es posible realizar un gráfico de los datos simulados, a través del comando plot. Como se muestra en la Figura 21: Gráfico con los resultado de la simulación.

33

Figura 21: Gráfico con los resultado de la simulación Una herramienta bastante útil es el zoom, que permite tener una vista de alguna parte de la gráfica que interesa para el análisis. Seleccionando con clic derecho el área que se desea aumentar, como se muestra en la Figura 22: Herramienta zoom de ngspice.

Figura 22: Herramienta zoom de ngspice

34

2.3

OREGANO

Oregano fue desarrollado en un principio por Richard Hult, quien trabajó hasta el año 2002, luego fue tomado por Ricardo Markiewics y Andrés Barbará quienes lo mantienen en la actualidad. Oregano es una aplicación que permite el diseño de circuitos, para luego servir de frontend para la simulación de circuitos de corriente continua y corriente alterna. Puede realizar análisis de corriente continua, corriente alterna, de tiempo y análisis de fourier. Por el momento sólo utiliza la medida de tensión para realizar el análisis. Para la simulación de los circuitos puede utilizar Gnucap o Ngspice. Actualmente está disponible la versión beta 0.69, bajo la GPL. Debido al desarrollo beta, aún en fase experimental, por lo que no todos los componentes que se muestran dentro del software están completamente operativos. Al abrir oregano se despliega la pantalla principal; a la derecha se tiene el menú de componentes y, al centro, el plano donde se diseña el circuito, tal y como se muestra en la Figura 23: Pantalla principal de oregano.

Figura 23: Pantalla principal de oregano Para la construcción de circuitos es recomendable escoger lo componentes y ubicarlos en el plano central, para luego comenzar a unir los nodos. Dentro de la barra de herramientas, existen seis botones que son los más utilizados a la hora de la construcción y simulación del circuito, estos botones se indican en la Figura 24: Herramientas principales de oregano.

35

Figura 24: Herramientas principales de oregano El primer botón (de izquierda a derecha) de la Figura 24: Herramientas principales de oregano, sirve para activar la opción de mover componentes dentro del plano y para agregar y quitar componentes. El segundo botón agrega etiquetas de texto en el circuito, estas etiquetas se utilizan para hacer comentarios o aclaraciones dentro de los circuitos, para una mejor comprensión, este botón se indica en la Figura 25: Propiedades de texto.

Figura 25: Propiedades de texto La herramienta lápiz (tercer botón) traza las líneas de interconexión entre los componentes. La herramienta punta de prueba, es útil a la hora de simular el circuito. Con esta herramienta se inserta un punto en donde se ejecutará la medición. En la Figura 26: Edición de puntas de prueba se muestran las opciones disponibles de la herramienta puntas de prueba.

36

Figura 26: Edición de puntas de prueba Los engranajes abren la ventana de simulación, en donde se escogen las puntas de prueba que se van a graficar, los ejes se dibujan de acuerdo con los especificado en las propiedades. El botón propiedades de simulación,mostrado en la Figura 27: Opciones de simulación, permite escoger el tipo de análisis a realizar. El único análisis que está disponible en este momento es el análisis en el tiempo y transiente.

Figura 27: Opciones de simulación

37

Se deben introducir los valores de tiempo en los cuales se desea simular el circuito, es necesario ingresar el valor de tiempo inicial y final, todos estos en segundos[s]. Es posible generar un análisis transiente de los componentes, seleccionando la opción usar condiciones iniciales. También se puede escoger la cantidad de muestras que se van a tomar dentro del intervalo de tiempo seleccionado. Activando la opción paso se introduce el número de muestras que el programa debe considerar para la simulación del gráfico. Finalmente, el botón simulación, permite abrir una nueva ventana donde aparece un eje de coordenadas similar a un osciloscopio, como se ve en la Figura 28: Ventana de simulación.

Figura 28: Ventana de simulación En la pantalla mostrada en la Figura 28: Ventana de simulación se grafican tantas señales como puntas de prueba se instalen en el circuito a simular. En el panel izquierdo se selecciona tipo de análisis. En esta etapa de desarrollo del software solo se ha podido simular análisis de tiempo. También, en la sección nodos, se seleccionan las puntas de prueba a graficar en la pantalla. Con la herramienta región de la ventana de simulación es posible seleccionar una porción del gráfico y ampliarla al tamaño de la ventana, para una mejor visualización del resultado obtenido del circuito. La herramienta mover permite desplazarse a través del gráfico para observar el comportamiento de la señal graficada. Para la simulación un factor importante es escoger el backend que se utilizará. Oregano tiene la opción de trabajar con Gnucap y con Ngspice, cada cual con sus pros y contras.

38

El backend se escoge en el menú edición/preferencias, mostrada en la Figura 29: Opciones generales de oregano.

Figura 29: Opciones generales de oregano 2.3.1 OREGANO CON GNUCAP Teniendo el circuito amplificador inversor con amplificador operacional ideal de la Figura 30: Circuito de simulación en oregano.

Figura 30: Circuito de simulación en oregano

39

Luego del diseño, se ajustan las propiedades de simulación a análisis en el tiempo. Una vez ajustadas las propiedades se procede a simular el circuito en el botón simulación. Al presionar simulación oregano abre una ventana nueva con la pantalla del osciloscopio, mostrado en la . En el panel izquierdo, mostrado en la Figura 31: Resultado de la simulación de oregano con gnucap, se expande menú nodos y se seleccionan las puntas de prueba que se hayan instalado en el circuito, en este caso, dos.

Figura 31: Resultado de la simulación de oregano con gnucap Se observa claramente en la Figura 31: Resultado de la simulación de oregano con gnucap, que v2 es la entrada y v3 es la salida, tal como fue indicado en el circuito esquemático En el eje X de la misma figura anterior, se tiene el eje de tiempo, que en este caso está indicado con milisegundos [ms]. En el eje Y se encuentra el eje de tensión, en este caso se indica en volt[V]. En la ventana de simulación es posible mover y aumentar alguna sección de la pantalla para obtener una mejor aproximación de la señal, esto se observa en la Figura 32: Herramienta zoom de oregano, donde se muestra una porción ampliada del gráfico de la mitad positiva de ambas señales del circuito simulado.

40

Figura 32: Herramienta zoom de oregano 2.3.2 OREGANO CON NGSPICE Utilizando el mismo circuito de la Figura 30: Circuito de simulación en oregano, se simula con el backend de orégano, Ngspice. Se selecciona el backend Ngspice desde el menú Edición/Preferencias, luego se configuran los parámetros de la simulación y se ejecuta el análisis.

Figura 33: Resultado de la simulación en oregano en ngspice

41

En el gráfico de la Figura 33: Resultado de la simulación en oregano en ngspice se muestran los resultados de la simulación. Se observa en el eje X, el tiempo y en el eje Y, el voltaje. Donde V(2) es la entrada y V(3) es la salida. Al utilizar seleccionar cualquier backend en orégano, éste no sufre ninguna transformación cuando se diseñan circuitos o se simulan. El cambio de backend es transparente para el usuario. Una diferencia sustancial es que Ngspice muestra las magnitudes en los ejes X e Y. En este sentido Gnucap carece de dicha característica. 2.4

GEDA

GEDA es un proyecto que busca crear un entorno completo para el diseño y construcción de circuitos electrónicos. Cuenta con una interfaz para el diseño y contiene aplicaciones para el diseño de la tarjeta de circuito integrado (PCB). También cuenta con una característica especial, contiene una aplicación que exporta los diseños a diferentes backends de simulación. El proyecto Geda fue iniciado en 1998 por Ales Hvesda debido a la falta de aplicaciones de diseño electrónico bajo la GPL. Dentro de Geda se incluyen una gran variedad de aplicaciones, entre las cuales se encuentran: 2.4.1 Gschem Gschem es una herramienta que permite el diseño de circuitos eléctricos y electrónicos, ya sean análogos o digitales. Fue escrito por Ales Hvezda y actualmente se encuentra en la versión 1.0.4

Figura 34: Pantalla prinipal de gschem

42

Dentro de las características de diseño de gschem se destacan la capacidad de dibujar conectores, agregar textos personalizados a los esquemas, dibujar figuras geométricas que no necesariamente son componentes, líneas, arcos, etc. Cuenta con una biblioteca de componentes para un fácil diseño. Tiene un editor de propiedades de los componentes. Para comenzar a trabajar con gschem se utiliza una barra de herramientas que se muestra en la Figura 35: Herramientas principales de gschem bastante útil para diseñar los circuitos

Figura 35: Herramientas principales de gschem El primer botón de la Figura 35: Herramientas principales de gschem, de izquierda a derecha, se utiliza para insertar símbolos (componentes), al presionarlo se abre un cuadro de diálogo con todas las familias de símbolos instaladas en Geda, dentro del cual se escoge el elemento que se necesita. Ahí están contenidos desde conectores, fuentes de alimentación hasta circuitos integrados complejos. El segundo botón es la herramienta para interconectarlos componentes del circuito esquemático. El tercero, es una herramienta similar a la anterior, la diferencia radica en que se utiliza para crear un bus de datos, esto es útil cuando la cantidad de líneas de conexión dentro del esquemático es elevada. El siguiente botón corresponde a la herramienta de texto que proporciona gschem, permite añadir textos dentro del esquemático para una mejor compresión del mismo, explicaciones de circuito, etc. Finalmente, el último botón permite seleccionar y mover los componentes dentro del circuito. 2.4.2 Gnetlist Gnetlist es una aplicación para la generación del archivo de simulación. Estos archivos se basan en los archivo de esquemáticos .sch de gschem. Transforma este esquemático en en un archivo ejecutable por alguna aplicación de simulación. Gnetlist fue escrito por Ales Hvezda y actualmente está en la versión 1.4. Dentro de las aplicaciones de simulación que soporta gnetlist están: o UNIX PCB

43

o o o o o o o o o o o

Allegro BAE Gossip Maxascii PADS Protelll Spice Tango Verilog VDHL Vipec

Gnetlist es un programa basado en consola de comandos, es usado para generar el archivo netlist y escoge el backend de simulación que utilizará dicho archivo. Es necesario su uso ya que gschem sólo sirve para el diseño del circuito y la edición de atributos del mismo. Una vez generado el archivo se utiliza el simulador escogido para el análisis 2.4.3 Gattrib Esta aplicación permite editar los atributos de los componentes de un archivo esquemático (.sch). En su interfaz, presentada en la Figura 36: Pantalla principal de gattrib, presenta una planilla con todos los componentes ordenados en filas y columnas para una fácil edición de los atributos de cada componente, incluyendo cables, conectores, pines, etc.

Figura 36: Pantalla principal de gattrib

44

En circuitos grandes, de muchos componentes, permite una rápida adición, eliminación y edición de atributos de todos los componentes insertos dentro del circuito diseñado, todo esto ahorra tiempo el eliminar la edición individual de cada elemento. A pesar de que gattrib posee versiones oficiales, no tiene la capacidad de editar todos los atributos disponibles de spice. 2.4.4 Symbols GEDA incluye una biblioteca de símbolos de alrededor de 1400 elementos para el uso dentro del entorno Geda. Estos símbolos son las representaciones abstractas de los componentes reales, es decir, son modelos utilizados en los circuitos diseñados en Geda que simulan un componente real. 2.4.5 Ejemplo: Circuito de carga de condensador Teniendo el circuito de la Figura 37: Circuito diseñado de gschem en gschem:

Figura 37: Circuito diseñado de gschem

45

Una vez diseñado en gschem, el circuito debe ser editado, para definir los atributos que se utilizarán. Como es un circuito relativamente sencillo, basta con hacer doble clic en cada componente y editar su contenido en el cuadro de diálogo de la Figura 38: Edición de atributos en gschem.

Figura 38: Edición de atributos en gschem El atributo refdes es obligatorio debido a que gnetlist interpretará esto como el nombre del componente. Se debe procurar definir un nombre simple y claro, como en este caso, la fuente, se denominará V1. Luego, el atributo device, es el tipo de componente que se utiliza, en este caso, una fuente de tensión. Footprint es la “huella digital” del componente, se utiliza para asociar el componente con una patrón para la creación de una tarjeta de circuito impreso, en este caso no se utiliza, por esta razón se le indica none. El siguiente atributo, value, es el más importante, ya que éste contiene el valor del componente, en este caso 5 volts de tensión continua. Este procedimiento se debe realizar con cada componente del circuito, menos con la tierra, que toma sus valores por defecto. Una vez terminado el diseño se debe invocar a gnetlist para la generación del archivo de simulación. Para dar continuidad a esta investigación se utilizará el backend Ngspice, por lo tanto al ejecutar gnetlist se deberá incluir la opción de spice. Se abre una consola de comandos y se ejecuta el siguiente: gnetlist –v –g spice-sdb –o carga_condensador.net carga_condensador.sch La opción –v significa que se muestran los progresos del gnetlist en pantalla, todas las advertencias, operaciones, etc. son visualizadas en la consola de comandos.

46

La opción –g se usa para escoger el backend a utilizar para el análisis posterior, en este caso spice. La opción –o indica que se debe escribir el archivo netlist para el análisis. Finalmente se indica el archivo de entrada para la conversión, en este caso carga_condensador.sch. Una vez ejecutado gnetlist, la consola devuelve lo que se indica en la Figura 39: Creación del archivo de simulación con gnetlist.

Figura 39: Creación del archivo de simulación con gnetlist El paso siguiente es editar el archivo con un editor de texto y agregar las líneas de simulación que corresponden, dependiendo del análisis a efectuar. El archivo netlist queda como sigue: * gnetlist -v -g spice-sdb -o carga_condensador.net carga_condensador.sch ********************************************************* * Spice file generated by gnetlist * * spice-sdb version 4.28.2007 by SDB -* * provides advanced spice netlisting capability. * * Documentation at http://www.brorson.com/Geda/SPICE/ * ********************************************************* *============== Begin SPICE netlist of main design ============ V1 1 0 DC 5V R1 1 2 1k C1 2 0 1uf

47

.end En este caso lo que interesa es un análisis transiente del circuito, por lo que se agrega la línea, antes de .end, que corresponde: .tran 0.001 0.02 0 uic Luego se ejecuta Ngspice y se realizan los análisis deseados. Esta herramienta está asociada con el proyecto Geda y se define como su entorno de simulación, por lo que no necesita mayor explicación. 2.5

KLOGIC

Klogic es un programa para la simulación de circuitos digitales en de una manera didáctica y en bloques, lo que permite una comprensión rápida y proporciona un diseño efectivo, además de un análisis en pantalla con un monitor de ciclos de reloj incorporado. Klogic fue escrito por Andreas Rostin y actualmente está en la versión 1.63. Al abrir klogic se presenta una pantalla muy similar a las demás aplicaciones mostradas anteriormente, como muestra la Figura 4: Pantalla típica de grub.

Figura 40: Pantalla principal de klogic

48

La pantalla de klogic, mostrada en la Figura 40: Pantalla principal de klogic, tiene todas las herramientas para comenzar a trabajar en forma gráfica sin utilizar los menús. Dentro de los componentes que pueden ser utilizados para la simulación se encuentran las siguientes compuertas lógicas: o AND o NAND o OR o NOR o XOR o Inversor Entre los flip-flops se encuentran disponibles los siguientes: o o o o

Tipo JK Tipo RS Tipo D Tipo T

Además se incluyen herramientas de ayuda a la simulación como un oscilador de onda cuadrada, interruptores/pulsadores, leds y displays de 7 segmentos. Para comenzar a diseñar sólo se necesita seleccionar un componente en la barra de herramientas y luego hacer clic en alguna parte del área de diseño. Para comenzar una simulación se debe seleccionar la N de la barra de herramientas de la Figura 41: Botón de simulación.

Figura 41: Botón de simulación

Una vez que Klogic comienza la simulación, el estado de los componentes se verifica con el indicador de estados de la Figura 42: Botón de diagrama de tiempos que se activa desde la barra de herramienta.

49

Figura 42: Botón de diagrama de tiempos 2.5.1 Ejemplo: Diseño de circuito con flip-flop tipo T Diseñando el circuito de la Figura 43: Circuito de simulación de klogic:

Figura 43: Circuito de simulación de klogic Observando el circuito de la Figura 43: Circuito de simulación de klogic, se pueden notar : un oscilador de onda cuadrada, que genera la señal que entra al flip-flop tipo T, luego, la señal se divide en dos; una señal entra directamente al LED 1, mientras que la otra señal ingresa a un inversor y luego pasa al LED 2. Una consideración importante en el diseño es que al dibujar las conexiones entre componentes, éstas deben salir de un componente y terminar en el aire (en el área de diseño), no es posible unir dos componentes con la misma línea de conexión.

50

Para editar las propiedades de los componentes se selecciona y luego se hace clic derecho y luego propiedades. En el cuadro se pueden ajustar las propiedades de cada componente en forma individual. A pesar de que las opciones son simples, permiten una forma fácil y rápida para definir las opciones de los objetos insertados en el circuito.

Figura 44: Edición de componentes En la Figura 44: Edición de componentes se muestran las propiedades del componente FF T (flip-flop tipo T). Aquí se puede editar el nombre, el retardo de funcionamiento, si se activa con flanco de subida o bajada y si la salida es normal o invertida. Al simular el comportamiento del circuito y abrir el indicador de estados se puede ver el comportamiento del circuito en funcionamiento, tal como lo muestra la Figura 45: Simulación de circuito con F/F tipo T:

51

Figura 45: Simulación de circuito con F/F tipo T Se puede observar en la Figura 45: Simulación de circuito con F/F tipo T, que el flipflop tipo T, reacciona con el canto de bajada del oscilador, además el inversor reacciona a la señal del F/F. En la última porción del gráfico de tiempo, como se muestra en la parte inferior derecha de la Figura 45: Simulación de circuito con F/F tipo T; se observa que la salida del flip-flop es alta, por lo que el LED 1 está encendido y, por consecuencia, el LED 2 se encuentra apagado.

52

CAPÍTULO 3: APLICACIONES PARA DISEÑO DE TARJETAS DE CIRCUITO IMPRESO

53

3

APLICACIONES PARA DISEÑO DE TARJETAS DE CIRCUITO IMPRESO

Como parte de un completo aprendizaje por parte del alumno, además del diseño, análisis de circuitos electrónicos, parte importante del desarrollo consiste en la construcción de placas de circuito impreso que alojarán los diseños creados. Dentro del software que proporciona GNU/Linux también se encuentran aplicaciones que permiten la construcción de PCB’s 3.1

KICAD

Kicad es un software de código abierto, que se enmarca dentro de la GPL, que permite el diseño y creación de circuitos esquemáticos y posteriormente la construcción de la placa de circuito impreso. En sí Kicad es un entorno de gestión de proyectos electrónicos que engloba diferentes programas. Fue escrito inicialmente por Jean-Pierre Charras, y actualmente su última versión es de noviembre del 2007. En la pantalla principal de Picad se encuentra un árbol jerárquico de los proyectos en desarrollo. Dentro de cada proyecto se van creando y editando los archivos esquemáticos y los de circuito impreso.

Figura 46: Barra de herramientas de kicad Como lo muestra la Figura 46: Barra de herramientas de kicad, éstas son las cuatro herramientas principales de esta aplicación. Comenzando de izquierda a derecha: el editor esquemático (eeschema), luego el enlazador componente/módulo (cvpcb), el editor de circuito impreso (pcbnew) y finalmente, una herramienta para ver los archivos gerber (gerbview). Dentro de los programas que contiene el entorno Kicad, se encuentran: 3.1.1 Eeschema Eeschema es una aplicación que permite el diseño de circuitos electrónicos, similar a oregano o gschem.

54

Figura 47: Pantalla principal de eeschema Dentro de la pantalla principal de eeschema,indicada en la Figura 47: Pantalla principal de eeschema, se encuentran las barras de herramientas, a la izquierda de la pantalla están las barras relacionadas con la visualización del circuito esquemático, en la parte superior, indicada en la Figura 48: Barra de herramientas superior, se encuentran los botones que permiten la portabilidad del circuito esquemático al circuito impreso. Eeschema cuenta con un editor para la creación de componentes personalizados, en caso de que sea necesario utilizar o diseñar un componente que no se encuentre en su biblioteca, especialmente conectores, que luego pueden ser asociados a un conector conocido por cvpcb.

Figura 48: Barra de herramientas superior 3.1.2 Cvpcb Esta aplicación tiene como función relacionar cada componente del esquemático con una huella o “footprint” de componentes reales para su paso desde circuito esquemático a circuito impreso.

55

Figura 49: Pantalla principal de cvpcb Como se observa en la Figura 49: Pantalla principal de cvpcb, en el lado izquierdo se listan los componentes del circuito esquemático y a la derecha los “footprints” disponibles para utilizar. 3.1.3 Pcbnew Pcbnew es el editor de circuitos impresos de Picad, puede ser utilizado degenerando un circuito a través de eeschema y cvpbc o simplemente de manera directa.

Figura 50: Pantalla principal de pcbnew

56

Al igual que ocurre con eeschema, las barras de herramientas de edición de componentes se encuentran a la derecha, a la izquierda la de visualización. La barra de herramientas superior de la comprende las herramientas de ruteo y edición de capas del circuito impreso. 3.1.4 Ejemplo: Diseño de circuito amplificador inversor con amplificador operacional En el menú Projects de la pantalla principal de Kicad, se crea un archivo nuevo que servirá para ordenar la creación de los diferentes archivos de esquema y circuito impreso, luego se presiona el botón eeschema, mostrado en la , lo que abre la ventana del editor de esquemáticos se comienza con el diseño.

Figura 51: Barra de herramientas de edición de esquemáticos de eeschema Utilizando las herramientas de diseño de la Figura 51: Barra de herramientas de edición de esquemáticos de eeschema, se comienza el diseño del circuito amplificador inversor con un amplificador operacional. Dentro de esta barra de herramientas se encuentran los botones para agregar: componentes, líneas, buses, fuentes de poder, tierra, textos, eliminar elementos. Para agregar un componentes se utiliza el botón Agregar componente (tercer botón de izquierda a derecha de la Figura 51: Barra de herramientas de edición de esquemáticos de eeschema; luego se hace clic en cualquier parte del esquemático y se abre un cuadro nuevo solicitando información sobre el nuevo componente, indicado en la Figura 52: Inserción de componentes en eeschema; se hace clic en “By Lib Browser”.

Figura 52: Inserción de componentes en eeschema

57

Al presionar este botón se abre un navegador en donde se puede seleccionar el componente adecuado para el diseño que se esté implementando, en este caso se utilizará un amplificador operacional LM 741, que se encuentra dentro de la familia “linear”, como se muestra en la .

Figura 53: Selección de componentes en eeschema Una vez escogido el componente correcto se debe hacer clic en el botón “Export to schematic”, en la parte superior del navegador de componentes de la Figura 53: Selección de componentes en eeschema (enmarcado en rojo); finalmente se ubica el componentes y se inserta haciendo clic en alguna parte del esquemático. De esta manera se agregan los demás componentes hasta tener los deseados. Una vez agregados los componentes, es necesario editarlos para definir sus valores y referencia de los mismos. Para esto se debe hacer clic derecho sobre el componentes a editar y luego escoger “Edit component/Edit”. Se abre un cuadro de diálogo con las opciones para editar. Dentro de la pestaña “Fields” se modifican los valores “ref” y “value”, según corresponda. “Ref” es el nombre para que el componente pueda ser reconocido como único dentro del esquemático, y “value” el valor del mismo, como se ve en la Figura 54: Propiedades de componente, al editar una resistencia del esquemático.

58

Figura 54: Propiedades de componente Una vez terminados la edición de propiedades de los componentes, éstos pueden ser movidos a sus posiciones respectivas dentro del esquemático, esto se logra haciendo clic derecho y seleccionando “Move component” y llevándolo a la posición deseada. Un hecho importante es que se produce una distorsión visual en el esquemático a medida que se editan los componentes, esto se soluciona refrescando la pantalla de eeschema, presionando la tecla F3. Luego con el botón “Add wires” de la barra de herramientas derecha de la , se comienzan a interconectar los componentes, evitar la generación de errores durante el diseño del circuito, el botón “Add no connected flag”, de la barra de herramientas derecha, permite designar pines de componentes que no serán utilizados dentro del circuito. Una vez completado el circuito en eeschema, como se ve en la Figura 55: Circuito esquemático completado.

59

Figura 55: Circuito esquemático completado Una vez finalizado el esquemático, el siguiente paso es generar un identificador único por cada componente en el circuito, esto se logra con el botón “Schematic Annotation” de la barra de herramientas superior de la Figura 48: Barra de herramientas superior.

Figura 56: Eeschema Annotation

60

Dentro de la ventana de Eeschema Annotation, mostrada en la Figura 56: Eeschema Annotation, se debe seleccionar la opción “current sheet" y “all components” Luego se realiza la generación de nodos del circuito, para que el editor de circuitos impresos lea esta información y pueda referenciar exactamente los nodos que están conectados entre sí. A través del botón “Netlist Generator” en la barra de herramientas superior de la . En este caso el diseño sólo será utilizado para la generación del archivo de circuito impreso, por lo que se selecciona la pestaña Pcbnew de la ventana de creación de archivos netlist, mostrada en la Figura 57: Netlist generator, seleccionando la opción “Default format”.

Figura 57: Netlist generator Luego se hace clic en el botón Netlist y se guarda el archivo dentro del directorio del proyecto. Además, es necesario agregar el “footprint” de cada componente de manera que pcbnew pueda asociar los elementos del esquemático con un elemento dentro del circuito impreso. Esto se logra con la aplicación cvpcb, seleccionándola desde la pantalla principal de Kicad, indicada en la Figura 46: Barra de herramientas de kicad. Al cargar cvpcb se abre la pantalla principal con todos los elementos dentro del esquemático en la parte izquierda de la ventana, en la parte derecha de la misma aparecen todos los footprints que contiene cvpcb. Aunque pueden ser relacionados de manera manual, es recomendable utilizar el botón de asociación automática de la barra de herramientas de cvpcb de la Figura 58: Asociación automática en cvpcb.

61

Figura 58: Asociación automática en cvpcb Luego se verifica que los componentes asociados automáticamente sean los correctos al diseño que se está realizando. Para los componentes que no fueron asociados, es necesario realizar esta tarea de forma manual, seleccionando primero al lado izquierdo el elemento, y luego haciendo doble clic en el footprint correcto que se desea. Es posible verificar que el footprint utilizado a través del botón “View Selected Part” en la barra de herramientas superior, mostrada en la Figura 58: Asociación automática en cvpcb. Dentro de la ventana de visión de componentes en el circuito impreso, es posible generar una vista en tres dimensiones para una visión global del componente y cómo se inserta en la placa de circuito integrado, como se muestra en la Figura 59: Visualizador 3D de kicad.

62

Figura 59: Visualizador 3D de kicad Finalmente se debe grabar los cambios realizados en cvpcb a través del botón “save” de la barra de herramientas. Esto graba el archivo netlist con la referencia de los footprints. Finalmente, es necesario leer el archivo netlist modificado con cvpcb con pcbnew y comenzar con el ruteo de los caminos en la placa de circuito impreso. Desde la barra de herramientas de Kicad, mostrada en la , se selecciona pcbnew. Se abre la ventana de pcbnew con un archivo en blanco. Desde el botón “Read Netlist” de la barra de herramientas de pcbnew, se selecciona el archivo de nodos del proyecto. Aparecerán en la esquina superior izquierda, los componentes diseñados en su formato para circuito impreso. Se deben mover hacia una posición conveniente dentro de la ventana y rotar los componentes, para su posterior ruteo. Si los componentes no muestran sus líneas de conexiones, es necesario habilitar la visualización de estás a través del botón “Show general ratsnest”, de la barra de herramientas izquierda de newpcb, mostrado en la Figura 60: Barra de herramientas izquierda newpcb.

Figura 60: Barra de herramientas izquierda newpcb Una vez que los componentes están en la posición deseada, el circuito queda como muestra la Figura 61: Circuito impreso en pcbnew.

63

Figura 61: Circuito impreso en pcbnew En este punto el ruteo de caminos de circuito impreso puede ser ejecutado de manera manual o automática, en este caso se utilizará la manera automática de manera de posteriormente a este paso optimizar el diseño de manera manual. Para el ruteo automático se debe activar el botón “Mode track and autorouting” de la barra de herramientas superior de pcbnew, luego se hace clic derecho en alguna parte del circuito y se selecciona “Global autoroute/Autoroute All Modules”. En el circuito impreso aparecerán los caminos del circuito, ya sea en su parte superior como inferior de la placa, quedando el circuito final, como muestra la Figura 62: Autoruteo completado.

Figura 62: Autoruteo completado

64

Para delimitar la placa de circuito impreso se necesita seleccionar “Edge PCB” desde el menú desplegable que está en la barra de herramientas superior; luego seleccionar el botón “Add graphic line or polygon” de la barra de herramientas derecha y dibujar el área que se desea en la placa. Esto es necesario para generar una vista en tres dimensiones del circuito terminado, como se ve en la Vista en tres dimensiones del circuito diseñado.

Figura 63: Vista en tres dimensiones del circuito diseñado Con el circuito finalizado, éste puede ser impreso ya para la confección manual de la placa de circuito impreso o puede ser enviado a archivo gerber para la confección de manera industrial. Los esquemáticos también puede ser impresos a través del menú File/Print. 3.2

EAGLE

Eagle, aunque no está dentro del denominado software libre, posee una versión freeware que está bastante extendida; por lo que es conveniente mencionarlo en este estudio. Eagle es un software de diseño de tarjetas de circuito impresas creado por la empresa CadSoft. Es el acrónimo de Easy Aplicable Graphical Layout Editor. Actualmente está en la versión 5.3. Las limitaciones que contiene la versión freeware, son: o Tamaño de tarjeta de 100[mm]x80[mm]. o Cada proyecto puede tener sólo un circuito esquemático.

65

o Sólo dos capas para el diseño de la tarjeta. Superior e inferior. No soporta el diseño de tarjetas de circuito impresas con capas intermedias. o Su uso sólo debe ser para aplicaciones sin fines de lucro, por ejemplo fines educacionales. En Eagle se trabaja por proyectos, cada circuito impreso que se desee generar, es un proyecto, como muestra la Figura 64: Panel de control de eagle. La pantalla inicial se denomina panel de control, y es donde se administra el proyecto en su totalidad, desde donde se generan los esquemáticos, los archivos de PCB, se editan las librerías, se crean scripts y se editan las reglas de diseño.

Figura 64: Panel de control de eagle 3.2.1 Libraries En la opción libraries se incluyen todos los componentes que posee la versión freeware de eagle. Cada elemento de la librería corresponde a un componente en específico. Están clasificados por fabricante y por tipo de componente. Dentro de cada componente aparece una descripción del mismo; indica dimensiones físicas, tipo de encapsulado y dos gráficos representativos, uno para el circuito esquemático, y otro para el circuito impreso, como se muestra en la Figura 65: Diodo 1N4148 en libraries.

66

Figura 65: Diodo 1N4148 en libraries 3.2.2 Design Rules En la opción design rules se editan las reglas de diseño de los circuitos. Existe un archivo general que se aplica a todos los proyectos hechos en Eagle. Es posible crear reglas de diseño específicas para cada proyecto, y así tener un diseño apropiado para cada proyecto. En la Figura 66: Pantalla de design rules se muestra una de las opciones a configurar en las reglas de diseño.

Figura 66: Pantalla de design rules Dentro de las opciones de las reglas de diseño se encuentran: o Espesor de placa. o Separación de componentes en la placa.

67

o Espesor de líneas de conexión (caminos). o Separación de las líneas de conexión o Diámetros de perforaciones. Es recomendable generar reglas de diseño para cada proyecto y sólo si es indispensable, ya que las opciones predefinidas están pensadas para abarcar la mayor cantidad de proyectos posibles. 3.2.3 Scripts Los scripts son archivos que contienen líneas de comandos extensas, que son ejecutadas por lotes (en secuencia), para una configuración rápida del proyecto en el que se trabaja. Por ejemplo existen scripts para configurar de manera rápida los colores utilizados en los diseños, los tamaños de la tarjeta de circuitos, etc. 3.2.4 Projects En esta sección se almacenan los proyectos que se han creado en Eagle. Dentro de cada directorio creado existe un proyecto con sus respectivos archivos. Debido a que Eagle es un entorno completo para el diseño y construcción de tarjetas de circuito impreso, lo mejor para una compresión es recomendable estudiarlo a través de un ejemplo, para notar la interacción de sus diferentes programas internos. 3.2.5 Ejemplo: Diseño de circuito amplificador inversor con amplificador operacional El primer paso para el diseño de un es crear el proyecto en el panel de control de Eagle. Luego, se debe crear el esquemático, se abre una ventana para comenzar el diseño, como indica la Figura 67: Edición de circuito esquemático.

68

Figura 67: Edición de circuito esquemático En la sección biblioteca (libraries) del panel de control (control panel) de Eagle se seleccionar el encapsulado correcto en la librería DIL 8, como se muestra en la ya que corresponde al encapsulado de un amplificador operacional típico como el LM741.

Figura 68: Selección de encapsulado En la Figura 68: Selección de encapsulado se muestra la alternativa para instalar una base (socket) para alojar el integrado, en caso de que se requiera su recambio. Para añadir el elemento se hace clic en ADD, indicado en la parte inferior de la . La misma operación se repite por cada componente que se inserte en el esquemático. Luego con las herramientas

69

de la Figura 69: Herramientas del editor de esquemáticos de eagle, se dibujan los cables, nodos, buses, etc.

Figura 69: Herramientas del editor de esquemáticos de eagle Finalmente, el circuito de amplificador inversor con amplificador operacional, queda como el de la Figura 70: Circuito esquemático amplificador inversor con amplificador operacional. El siguiente paso corresponde a la transferencia del archivo esquemático al archivo de diseño de placa impresa.

Figura 70: Circuito esquemático amplificador inversor con amplificador operacional En el menú File/Switch to board se encuentra la opción para portar el archivo desde el esquemático al archivo de circuito impreso. Al exportar el proyecto desde su archivo de esquemático por primera vez al archivo de circuito impreso, Eagle pregunta si lo crea en base al esquemático, el usuario decide si así lo quiere. Al exportar el archivo, se abre una ventana con el circuito desplegado tal y como se vería en una placa de circuito impreso, como se muestra en la Figura 71: Esquemático de circuito impreso.

70

Figura 71: Esquemático de circuito impreso Una vez dentro de este diseño mostrado en la Figura 70: Circuito esquemático amplificador inversor con amplificador operacional, se debe modificar la posición de los componentes para obtener el diseño deseado en la placa impresa, las líneas de conexión se mantienen de manera automática. Se deben mover los componentes al área demarcada con borde blanco, debido a que esa ésta es la zona permitida para la versión freeware de Eagle. Una vez dentro de la zona, se pueden ordenar los componentes de la forma que el usuario desee como, hacer rutas manuales dentro de la placa, agregar textos, formas geométricas, agregar más componentes, rotar componentes, etc. Una vez ordenado el circuito de la manera apropiada, se puede comenzar a realizar el ruteo de forma manual o automática. Por de rapidez del diseño se recomienda realizar el ruteo automático primero y luego definir en forma manual algunos elementos que no se ajusten a las necesidades del diseño. Una vez definida la posición final del circuito se utiliza la herramienta autorouter, que se selecciona desde el menú.

71

Figura 72: Herramienta de autoruteo Al presionar el botón autoruteo de la Figura 72: Herramienta de autoruteo, aparece en la pantalla un cuadro de diálogo con variadas opciones para el desarrollo de la operación automática de impresión de caminos en la placa de circuito impreso. Dentro de este cuadro de diálogo encontramos primero opciones generales de configuración, tales como si la placa de circuito impreso se construirá por uno o ambos lados(se debe recordar que la versión registrada de Eagle, soporta más capas de construcción), también se define el ancho de la grilla, que viene a ser algo como la separación de los caminos entre sí; se define la dirección preferida de las líneas: vertical, horizontal, oblicua o cualquiera; y también se define el tipo de curva que se utilizará: redondeada u octagonal.

Figura 73: Opciones generales de autoruteo

72

La próxima pestaña corresponde a buses de datos, cuando en los circuitos se ha diseñado un bus de datos, aquí se configuran los parámetros de diseño. La pestaña Buses es idéntica a la pestaña Route, en este ejemplo está desactivada Luego se encuentra la pestaña ruteo. En esta pantalla se configuran los caminos del circuito, trabajando con valores entre 0 y 10 para las preferencias (llamados costos), donde 0 corresponde a una opción con la prioridad mínima y 10 a la máxima.

Figura 74: Autoruteo, pestaña ruta Como se muestra en la figura Figura 74: Autoruteo, pestaña ruta, al centro se ven los parámetros de costo para el autoruteo, y a la derecha se configuran los valores máximos (en cantidad) de otros parámetros de ruteo. Las pestañas Optimize son idénticas a la pestaña de Route, estas se utilizan para optimizar y mejorar el autoruteo realizado por la etapa anterior, se pueden agregar y sea necesario a través del botón Add, y eliminar a través de botón Active de la Figura 74: Autoruteo, pestaña ruta. Una vez que se ha configurado el ruteo y las optimizaciones, el paso siguiente es que Eagle procese las opciones configuradas, haciendo clic en el botón OK de la Figura 74: Autoruteo, pestaña ruta. Eagle comienza con el autoruteo y muestra el resultado. La velocidad del procesamiento dependerá de las características técnicas de la máquina que se esté utilizando y de las opciones configuradas en el Autorouter. Preliminarmente se obtiene un diseño como el que muestra la Figura 75: Ruteo preliminar con la herramienta autorouter.

73

Figura 75: Ruteo preliminar con la herramienta autorouter Luego de este autoruteo, es recomendable reubicar los componentes para un mejor aprovechamiento del espacio. Para eliminar el autoruteo, es necesario seleccionar todo el circuito a través de la herramienta selección de la Figura 76: Herramienta de selección.

Figura 76: Herramienta de selección

Luego para remover los ruteos se presiona la herramienta Ripup, mostrada en la Figura 77: Herramiena para eliminación de ruteo.

74

Figura 77: Herramiena para eliminación de ruteo

El circuito vuelve al estado original, como aparece luego de la exportación desde el esquemático al circuito impreso, como muestra la Figura 75: Ruteo preliminar con la herramienta autorouter. Finalmente, con los componentes definidos en su posición final, se hace un nuevo autoroute, quedando el circuito como lo muestra la .

Figura 78: Circuito impreso terminado A esta altura, el circuito ya puede ser impreso en papel para su fabricación en la PCB. A través de la edición de las capas, a la que se accede a través del botón de la Figura 79: Herramienta de edición de capas, puede definirse que no aparezcan los componentes en la placa, lo que facilita aun más la construcción práctica de la misma, como se ve en la Figura 80: PCB sin componentes.

75

Figura 79: Herramienta de edición de capas

Figura 80: PCB sin componentes Luego de este procedimiento es posible imprimir la placa para su construcción en la realidad. Desde el menú file/print setup y file/print, se configura la impresión del respectivo circuito. Es posible la impresión tanto del esquemático, como del circuito impreso.

76

CONCLUSIONES

Luego del estudio de estas aplicaciones del área electrónica en el entorno GNU/Linux se pueden obtener las siguientes conclusiones de ámbito técnico: o Existen dos líneas de desarrollo respecto de los simuladores de circuitos análogos: Gnucap y Ngspice. Están programados de forma diferente pero pretenden ser compatibles entre ellos. o Ngspice está mucho más maduro que Gnucap, debido a que ya tiene versiones oficiales y fue escrito a partir del código de spice. Por lo que se puede afirmar que es una continuación del desarrollo de éste. o Gnucap está aun en desarrollo beta ya que fue escrito desde cero, porque como se acoge bajo el proyecto GNU, no puede contener ni una sola línea de código propietario. o Gnucap tiene una interfaz de línea de comandos mucho más intuitiva que la interfaz de Ngspice. Debido a que sus comandos de trabajo son más simples y a menudo son palabras de uso común dentro del lenguaje técnico en el área electrónica. o Un circuito diseñado en oregano permite ser exportado como archivo de nodos funcional, separado del archivo de diseño gráfico, para ser analizado en forma separada con un backend (Gnucap o Ngspice) o Los archivos de nodos de Gnucap son portables a Ngspice y viceversa, con la salvedad de que algunos comandos ejecutan con diferentes parámetros. o De forma global, al comparar Gnucap con Ngspice en este estudio, se determina que Ngspice tiene mejores prestaciones que Gnucap, debido a que tiene mejor compatibilidad como backend con otras aplicaciones respecto de Gnucap. Además, las opciones de graficación en Ngspice son ampliamente superiores a las Gnucap, pudiendo incluso ejecutar funciones de zoom en los gráficos presentados por la simulación de un circuito y cálculos de pendientes y derivadas. o La interfaz de diseño de circuitos que presenta gschem es mucho más avanzada que la de orégano debido a la cantidad de elementos incluidos en el entorno Geda. o Una ventaja de oregano sobre gschem es su capacidad de generar el archivo netlist para la simulación de forma interna. Gschem depende de gnetlist para generar este archivo, esto hace que el proceso de simulación sea más lento. Orégano gestiona la interacción con el backend de manera automática. o El programa de diseño de circuitos impresos Eagle está mucho más automatizado que Kicad, en lo que se refiere al ruteo de caminos en las tarjetas de circuito impreso. o Eagle y Kicad: Al ser ambas, aplicaciones orientada en su totalidad al diseño y construcción de placas de circuito impreso (PCB), éstas se hacen independientes de la malla curricular del área electrónica; pudiéndose utilizar en cualquier instante en que se requiera la implementación real de un circuito estudiado.

77

Como conclusiones generales se puede obtener lo siguiente: o Al tener la posibilidad de incluir modelos spice de los fabricantes de semiconductores en las aplicaciones de simulación, se puede obtener una fuente de información importante acerca de la composición interna de componentes semiconductores. o Los sitios web de los creadores de las aplicaciones para electrónica aportan con valiosa información a la hora de entender el funcionamiento del programa y su uso. La gran mayoría de esta información es proporcionada por los usuarios de la aplicación, por ende la ayuda que se puede encontrar va creciendo en el tiempo.

78

BIBLIOGRAFÍA

DAVIS, Albert. Gnucap The GNU Circuit Analysis Package Users Manual. [documento pdf]. 2006. [entre agosto y noviembre de 2008]. Disponible en: . MERTENS, Sven. Klogic Documentation [en línea]. 2002. [consulta entre agosto y noviembre de 2008]. Disponible en . MOHR, James. Linux: Recursos para el usuario. México. Prentice-Hall. [s.a.]. 789 p. ISBN 9701701925 THOMAS, Kevin. SPICE3 Version 3f User’s Manual [en línea]. 1998 [consulta entre agosto y noviembre de 2008]. Disponible en . VARIOS, Autores. NGSPICE User Manual. [documento pdf]. 1996. [consulta entre agosto y noviembre de 2008]. Disponible en . HVESDA, Ales. Geda Documentation [en línea]. 2002. [consulta entre agosto y noviembre de 2008]. Disponible en . CADSOFT, Computer GmbH. Cadsoft Online: Frequently Asked Questions [en línea]. 2008. [consulta entre agosto y nomviembre de 2008]. Disponible en .

79