Embed Size (px)
Citation preview
INSTITUTO POLITÉCNICO NACIONAL
ESCUELA SUPERIOR DE INGENIERÍA MECÁNICA Y
ELÉCTRICA
UNIDAD PROFESIONAL ZACATENCO
Diseño e implementación de herramientas básicas de
Ingeniería en Comunicaciones y Electrónica para Pocket PC
T E S I S
Que para obtener el Título de:
Ingeniero en Comunicaciones y Electrónica
Presentan:
Gómez Muñoz Jessica Lissete
Herrera Cárdenas Christian
Santiago Álvarez Jorge Luis
Asesores:
Ing. Armando Mancilla León
M. en C. Roberto Galicia Galicia
Mayo 2009
DISEÑO E IMPLEMENTACIÓN
DE HERRAMIENTAS BÁSICAS
DE INGENIERÍA EN
COMUNICACIONES Y
ELECTRÓNICA PARA POCKET
PC
Página i
ÍNDICE
Contenido
Agradecimientos ............................................................................................................................ iii
Dedicatorias .................................................................................................................................. iv
Objetivo General ............................................................................................................................. v
Objetivos Particulares: ..................................................................................................................... v
Justificación ................................................................................................................................... vi
INTRODUCCIÓN .......................................................................................................................... vii
CAPÍTULO I ................................................................................................................................... 1
Marco Histórico y Estado del Arte ..................................................................................................... 1
1.1 Marco Histórico ............................................................................................................... 1
1.1.1 ¿Qué es un dispositivo móvil?.......................................................................................... 2
1.1.2 Breve historia de los celulares.......................................................................................... 3
1.1.3 Celulares como herramientas de trabajo ........................................................................... 6
1.2 Estado del Arte ...................................................................................................................... 6
1.2.1 Sistemas Operativos para móviles.................................................................................... 6
1.2.2 Características de un Dispositivo móvil actual ................................................................ 12
1.2.3 Aplicaciones de un dispositivo móvil ............................................................................... 13
1.2.4 Aplicaciones Windows Mobile con tecnología .NET ......................................................... 16
1.3 Pocket PC........................................................................................................................... 18
1.3.1 Características de PocketPC ......................................................................................... 19
1.3.3 Funciones básicas ........................................................................................................ 20
CAPÍTULO II ................................................................................................................................ 23
Planteamiento del Problema y Herramientas de Software ................................................................. 23
2.1 Planteamiento del problema ................................................................................................. 23
2.2 Tecnología .NET.................................................................................................................. 24
2.2.1 Versiones de multiplataforma de .NET Framework........................................................... 25
2.2.2 Características de Visual C# .NET.................................................................................. 27
2.3 Windows Mobile .................................................................................................................. 28
2.3.1 Características de Windows Mobile y algunas aplicaciones incluidas................................. 28
Página ii
2.4 Visual Studio ....................................................................................................................... 32
2.4.1 Versiones ..................................................................................................................... 33
2.4.2 Funciones de Visual Studio ............................................................................................ 34
CAPÍTULO III ............................................................................................................................... 35
Diseño y Desarrollo de la Aplicación ............................................................................................... 35
3.1 Descripción general de la aplicación...................................................................................... 35
3.2 Desarrollo y creación de la aplicación .................................................................................... 37
3.2.1 Herramientas del software ............................................................................................. 41
3.2.1.1 Controles usados para el diseño de la aplicación ...................................................... 43
3.2.2 Desarrollo de herramientas de apoyo para las aplicaciones de ICE para Pocket PC ........... 49
3.2.3 Diseño de la interfaz ..................................................................................................... 81
3.3 Programación y codificación ................................................................................................. 90
3.3.1 Diagramas de clase ...................................................................................................... 92
3.4 Conversión de formularios a bibliotecas de clases. ................................................................. 97
CAPÍTULO IV ............................................................................................................................. 103
Implementación y Pruebas ........................................................................................................... 103
4.1 Conexión con el dispositivo ............................................................................................... 103
4.1.1 Emulador Smart Device de Visual Studio ...................................................................... 104
4.2 Implementación ................................................................................................................ 106
4.2.1 Transferencia de la aplicación al dispositivo móvil.......................................................... 106
4.3 Análisis de pruebas........................................................................................................... 110
4.3.1 Resultados en el dispositivo móvil y el emulador ........................................................... 115
4.4 Análisis de costos .................................................................................................................. 118
Conclusiones .............................................................................................................................. 121
Anexos ....................................................................................................................................... 124
Herramientas útiles de .NET Framework ................................................................................... 124
Especificaciones técnicas de instalación y compatibilidad con el sistema operativo del Pocket. ..... 125
Compatibilidad del Active Sync con diferentes sistemas operativos y dispositivos ......................... 127
Requerimientos de instalación Visual Studio 2008 ..................................................................... 128
Referencia de la biblioteca de clases de .NET Framework .......................................................... 129
Apéndice “Códigos de las herramientas de apoyo de la aplicación de ICE” .................................. 158
Referencias ................................................................................................................................ 221
Glosario ..................................................................................................................................... 225
Índice Alfabético......................................................................................................................... 229
Página iii
Agradecimientos
Algunas veces el camino se puede tornar difícil, algunas veces puede estar inclinado y muy pesado de subir, otras
veces plano y sin chiste. Y así, durante el trayecto, sea cual sea el que se recorra para llegar a nuestro destino, se
puede encontrar de todo tipo de obstáculos grandes o pequeños, son esos obstáculos los que hacen que uno
aprenda a sobrevivir y a ser mejor día a día. Sin embargo esto no sería posible sin la ayuda y el apoyo de las
personas que nos acompañan a nuestro alrededor a recorrer con nosotros ese camino.
Es por eso que al día de hoy en que he llegado a una de las primeras paradas, que haré durante mi trayecto,
quiero agradecer a mis padres, por todo su amor, su comprensión, su cariño, por estar conmigo desde niña, por
impulsarme a ser mejor día con día, por nunca dejar que me cayera, y ayudarme a levantarme si así fuera. Papás,
se que el camino ha sido difícil y que nos hemos topado con tristezas alegrías, pero también disfrutamos de los
éxitos que todo esto conlleva.
A mi hermana Miriam, porque sin su fortaleza como hermana, no hubiera podido reponerme de tantas cosas, por
sus consejos de hermana adulta, aun cuando es más pequeña que yo, Miriam ¡¡eres súper!!, te amo y te
agradezco todas las alegrías que me das y las ocurrencias que hicieron nivelar mi nivel de estrés, jejeje… ^_^‟
A mi hermano Ricardo, siempre tan intelectual, excelentes consejos, valiosos para poder seguir mi camino,
gracias por algunos conceptos que me diste para escribir parte de la tesis, ahora se lo importante que es tener un
diccionario a la mano. Para tu corta edad me apoyaste en mis locuras y arrebatos y me dijiste “cálmate y sigue
adelante…”, gracias por eso y mucho más, te amo Ricardo, sígueme poniendo música mientras trabajo para evitar
que me duerma, aunque luego eso no se pueda lograr jejeje… ^_^‟
A mis amigos, por su apoyo y comprensión, su cariño, su amistad desinteresada, por enseñarme que hay más
cosas en la vida que solo estudiar; por decirme que la diversión se puede combinar con el estudio y el trabajo, por
comprender mi falta de tiempo y por entender que aunque no conviviéramos mucho tiempo juntos, ellos y yo
siempre estaríamos para apoyarnos, aún en los momentos de tristeza y enojo.
Sobre todo quiero darle las gracias a Dios, por colmarme de tantas bendiciones, por nunca dejarme desamparada
y por brindarme siempre un rayito de luz y esperanza. Dios gracias por ese poder infinito y por poner en mi camino
a todas y cada una de las personas que me ayudaron a crecer como persona y me llevaron a lograr lo que ahora
soy.
MIL GRACIAS!!!
Página iv
Dedicatorias
Página v
OBJETIVOS
Objetivo General
Diseñar e implementar una aplicación para dispositivos móviles, Pocket PC, con sistemas Windows
Mobile con ayuda de la herramienta de programación Visual Studio y .NET Framework.
Objetivos Particulares:
Brindar una aplicación de apoyo, al estudiante de Ingeniería en Comunicaciones y Electrónica, una
interfaz que le permita realizar soluciones operativas básicas, con fines prácticos en esta rama; la
aplicación pretende que el usuario tenga un apoyo sustentable, la cual le ofrecerá herramientas de
diseño, de cálculo, de visualización, tales como una calculadora, formularios e información que le sirva
de apoyo a algunos temas, referentes a las materias de tronco común.
Página vi
Justificación
Que el estudiante de ingeniería tenga las herramientas necesarias, para realizar sus tareas afines con
sus materias de Ingeniería en Comunicaciones y Electrónica, por lo que esta herramienta le será de
apoyo para resolver sus problemas de ingeniería básica y con mejores resultados.
De manera más práctica, se integran, en un solo dispositivo, las herramientas necesarias básicas,
siendo innecesario el transporte de otros aditamentos como calculadora, equipo portátil (laptop), hojas
de especificación o un gran volumen de libros, desde luego, en caso de requerir tareas más específicas,
sí se tendrá que recurrir al uso de otros medios.
La aplicación está elaborada en un entorno totalmente orientado a objetos, para la facilidad de uso del
usuario en una plataforma realizada basándose en la tecnología .NET y con un software especializado
en la creación de soluciones de software, como lo es Visual Studio 2008 Professional Edition, que nos
brindan una mejor opción de diseño e implementación del software, y se adaptan a las aplicaciones
utilizadas en los dispositivos orientados a Windows Mobile (Pocket‟s PC y Smartphone). De esta
manera, el usuario podrá implementar esta aplicación de manera fácil a su dispositivo móvil, y podrá
interactuar de manera amigable con la aplicación.
Página vii
INTRODUCCIÓN
Cuando se habla de desarrollar software para dispositivos móviles, lo primero que se viene a la mente es
el desarrollo para teléfonos celulares, pero, en muchas ocasiones, no se tiene claro que se debe hacer;
¿Un sitio Web? ¿Una aplicación para el celular?
Lo cierto es que, un dispositivo móvil no es solo un celular, y que además, el software a desarrollar,
puede ser, tanto un sitio Web, como una aplicación para el dispositivo.
Los celulares no son los únicos dispositivos móviles para los cuales se puede desarrollar software,
existen otros dispositivos como Palm o Pocket PC. Dispositivos de mano, pequeños con, ciertamente,
una gran potencia.
Para poder tomar la decisión correcta, tanto para elegir el dispositivo correcto, como la tecnología a usar,
es necesario conocer cuáles son nuestras necesidades, tanto presentes como futuras, las capacidades
del dispositivo que se elija, el conocimiento actual o la facilidad de adquirir este conocimiento sobre el
software de desarrollo, entre otras.
Por un lado, Palm, nos brinda una plataforma de desarrollo basada en su propio lenguaje, el cual tiene
fundamentos en C y C++. En la actualidad, el software para desarrollar aplicaciones para estos
dispositivos es totalmente gratis, pero, para poder compilar una aplicación desarrollada para este, es
necesario desembolsar una gran suma, ya que, los compiladores se venden por separado y son
vendidos por terceros, y por último, si uno no posee un equipo Palm, es necesario obtener el BIOS del
equipo para el cual se quiera desarrollar, pero para ello, se deben llevar a cabo una serie de trámites
entre Palm y la empresa a desarrollar, para poder obtener una copia de dicho BIOS.
En contraste con Pocket PC y con Windows CE incluido, se puede programar con dos plataformas de
desarrollo, .Net, y Microsoft Embedded Visual Tools, estas últimas, herramientas totalmente gratuitas,
que nos permiten programar en lenguajes como Visual Basic o Visual C o C#.
En el caso de que se quieran utilizar tecnologías de vanguardia, también se puede desarrollar con .Net,
el cual acepta, no sólo los lenguajes tradicionales de Microsoft, si no, lenguajes alternativos como Java,
Página viii
Borland C, entre otros, y por supuesto, se puede acceder a toda la potencia de .Net, pero desde la
Pocket PC.
Se debe aclarar, que .Net, por parte de terceros, también puede desarrollar para Palm, lo que, en este
punto, ya hace la diferencia.
En el caso de teléfonos celulares, se tienen dos alternativas, crear un sitio Web o desarrollar
aplicaciones para el mismo celular. Y una vez más, se pueden plantear las dificultades de aprender un
nuevo lenguaje.
Si se pone en contraste, .Net contra otras tecnologías, se ve que, dependiendo de la marca del celular,
éste posee, para el desarrollo de aplicaciones, un lenguaje específico, aunque basados en C y C++,
cambian de celular a celular. Y en el caso del desarrollo de sitios web para celulares, es necesario
aprender otro lenguaje, comúnmente llamado WML, el cual es una mezcla de XML, con etiquetas “tags”
específicas, y el lenguaje de servidor que se quiera imbuir con nuestro código.
Por el contrario, .Net, tiene la facilidad de que, utilizando la misma forma de trabajo, que el desarrollo de
una página web normal, se pueden crear sitios web, para teléfonos celulares, dejando el código simple y
sin mezclas extrañas de otros lenguajes y tomando en sus manos el trabajo “sucio” de transformación de
datos y lenguajes.
Por último, para el desarrollo de aplicaciones para dispositivos móviles, .Net nos entrega el mismo
entorno de desarrollo, para una aplicación de escritorio. Indudablemente, que este desarrollo, es para
teléfonos celulares o Pocket PC que poseen Windows CE.
En definitiva, .Net lleva ventaja, integrando el desarrollo para dispositivos móviles, con tres alternativas
(Aplicaciones Web para móviles, aplicaciones para celulares, y aplicaciones para dispositivos Pocket),
prácticamente con el mismo código, y con lenguajes de programación que se adaptan a lo que se puede
saber u obtener información en corto plazo.
A lo largo de éste documento se abordarán diversos temas que ayudarán a un mejor entendimiento de
cómo diseñar y desarrollar aplicaciones a dispositivos móviles.
Página ix
Así, en el capítulo I, se hablará del estado del arte, la historia y evolución de los dispositivos móviles; así
como los diferentes sistemas operativos que están instalados en cada uno de ellos y las diferentes
aplicaciones desarrolladas para el dispositivo móvil, Pocket PC sus principales características y
funciones básicas.
En el capítulo II, se plantea el problema, el cual es, el desarrollo de la aplicación que será implementada
a la Pocket PC, el estudio de las herramientas de desarrollo y las características de Tecnología .NET,
Windows Mobile y una introducción las principales funciones de Visual Studio 2008.
En el capítulo III, se trata más ampliamente del diseño y desarrollo de la aplicación. Las funciones y
herramientas del Visual Studio utilizadas para el diseño de las diferentes interfaces, descripción de los
controles y el desarrollo paso a paso de las herramientas de apoyo para las aplicaciones de ICE para
Pocket PC. Se muestra la manera de programar los controles para que realicen diversas funciones de
acuerdo al tipo de herramienta que se esté desarrollando. Por último se muestra la conversión de los
diversos formularios a bibliotecas de clases, para después conjuntarlas en un solo proyecto.
En el capítulo IV, se explica la manera de sincronizar la Pocket PC por medio del Active Sync, y de esta
manera poder implementar la aplicación; o bien si no se cuenta con el dispositivo, se muestra la manera
de probar la aplicación por medio del emulador con el que cuenta el Visual Studio. Se realizan las
pruebas necesarias con la aplicación, para verificar que se implementó satisfactoriamente.
También se presenta un análisis de costos de la implementación de la aplicación.
Página x
Capítulo I Marco Histórico y Estado del arte
Aplicación de software a dispositivos móviles Página 1
CAPÍTULO I
Marco Histórico y Estado del Arte
1.1 Marco Histórico
Las tecnologías inalámbricas han tenido mucho auge y desarrollo en estos últimos años.
Una de las que ha tenido un gran desarrollo ha sido la telefonía móvil.
Desde sus inicios a finales de los años 70 han revolucionado enormemente las actividades
que se realizan diariamente. Los dispositivos móviles últimamente se han convertido en una
herramienta primordial para la gente de negocios; las hace sentir más seguras y las hace,
hasta cierto punto, más productivas.
A pesar de que la telefonía celular fue concebida estrictamente para la voz, la tecnología
celular de hoy es capaz de brindar otro tipo de servicios, como datos, audio y video con
algunas limitaciones. Sin embargo, la telefonía inalámbrica del mañana hará posible
aplicaciones que requieran un mayor consumo de ancho de banda.
La evolución del teléfono móvil ha permitido disminuir su tamaño y peso, desde ese primer
teléfono móvil en 1983 que pesaba 780 gramos, a los actuales más compactos y con
mayores prestaciones de servicio. El desarrollo de baterías más pequeñas y de mayor
duración, pantallas más nítidas y de colores, la incorporación de software más amigable, hoy
en día, hacen del teléfono móvil un elemento muy apreciado en la vida moderna.
El avance de la tecnología ha hecho que estos aparatos incorporen funciones que no hace
mucho parecían futuristas, como juegos, reproducción de música MP3 y otros formatos,
correo electrónico, SMS, agenda electrónica PDA, fotografía digital y video digital, video
llamada, navegación por Internet y hasta Televisión digital. Con el desarrollo de la Pocket
Capítulo I Marco Histórico y Estado del arte
Página 2 Aplicación de software a dispositivos móviles
PC, se incorporó la función de block de notas, agenda y otras funciones fáciles de
sincronizar con una PC; la primer compañía que hizo esto posible fue US Robotics, y el
dispositivo lo llamó Pilot 1000, en aquella entonces, aproximadamente 1996, éste dispositivo
contaba con un poderoso procesador Motorola de 16 MHz y 128 KB de RAM. Un poco más
tarde el nombre fue modificado a Palm Pilot, desembarcando en el mercado en 1997 con
dos versiones Palm Pilot personal y Palm Pilot profesional, éste último con memoria en RAM
de 1 MB, conectividad TCP/IP, reconocimiento de escritura y base de sincronización;
abriéndose paso a una multitud de aplicaciones. Las compañías de telefonía móvil y otros
dispositivos móviles, ya están pensando nuevas aplicaciones para este pequeño aparato
que acompaña a todas partes. Algunas de esas ideas son: medio de pago, localizador e
identificador de personas. Siempre hay que tener en cuenta los grandes avances sufridos
desde el primer dispositivo móvil hasta el actual.
1.1.1 ¿Qué es un dispositivo móvil?
Un dispositivo móvil no es sólo un celular. Los dispositivos móviles (también conocidos
como computadora de mano, "Palmtop" o simplemente handheld) son aparatos de pequeño
tamaño, con algunas capacidades de procesamiento, con conexión permanente o
intermitente a una red, con memoria limitada, diseñados específicamente para una función,
pero que pueden llevar a cabo otras funciones más generales.
Estos dispositivos describen a un ordenador portátil para diversas aplicaciones, que puede
ser llevado a cualquier parte mientras se utiliza.
Los computadores Hand held, o también llamados PDAs (Personal Digital Assistants) son los
llamados ordenadores de la palma de la mano, y fueron diseñados originalmente como
organizadores personales, y ellos hacen esto realmente bien. Las características básicas de
cualquier PDA son una agenda, libreta de direcciones, lista de tareas, y block de notas,
aunque con el auge de los nuevos procesadores y disponibilidad de software, ya se han
potenciado las aplicaciones web, juegos y casi cualquier otra aplicación que se pueda
pensar. Aunque estas primeras características son muy provechosas para mantener a
cualquier persona ordenada, la característica que elevó su uso, para cualquier persona
Capítulo I Marco Histórico y Estado del arte
Aplicación de software a dispositivos móviles Página 3
ocupada, que utilice una computadora de escritorio, es la de la sincronización fácil de la
información con el ordenador del escritorio, dentro de esta categoría, se ha fusionado un
teléfono celular con características similares a las de un computador personal, el cual da
como resultado un Teléfono Inteligente o Smartphone, que es un dispositivo electrónico.
Casi todos los teléfonos inteligentes son celulares que soportan completamente un cliente de
correo electrónico, con la funcionalidad completa de un organizador personal. Una
característica importante de casi todos los teléfonos inteligentes, es que permiten la
instalación de programas para incrementar el procesamiento de datos y la conectividad.
Estas aplicaciones pueden ser desarrolladas por el fabricante del dispositivo, por el operador
o por un tercero. El término "Inteligente" hace referencia a cualquier interfaz, como un
teclado QWERTY en miniatura, una pantalla táctil, o simplemente el acceso seguro al correo
electrónico de una compañía, como el provisto por un BlackBerry.
Los teléfonos inteligentes se distinguen por muchas características que incluyen, pero estas
características no se limitan a, pantallas táctiles ni a un sistema operativo así como la
conectividad a Internet. El completo soporte al correo electrónico parece ser una
característica definitiva, encontrada en todos los modelos existentes y anunciados en el
2007. Casi todos los teléfonos inteligentes también permiten al usuario instalar programas
adicionales, normalmente desde terceros, pero algunos vendedores gustan de presumir a
sus teléfonos como inteligentes, aun cuando no tienen esa característica.
Entre las características más importantes está el acceso a Internet y al correo electrónico, a
los programas de agenda, las cámaras integradas, administración de contactos,
acelerómetros y algunos programas de navegación, así como ocasionalmente la habilidad de
leer documentos de negocios en variedad de formatos como: PDF y Microsoft Office.
1.1.2 Breve historia de los celulares
Martin Cooper fue el pionero en esta tecnología, a él se le considera como "el padre de la
telefonía celular" al introducir el primer radioteléfono, en 1973, en Estados Unidos, mientras
Capítulo I Marco Histórico y Estado del arte
Página 4 Aplicación de software a dispositivos móviles
trabajaba para Motorola; pero no fue hasta 1979 cuando aparecieron los primeros sistemas
comerciales en Tokio, Japón, por la compañía NTT.
En 1981, los países nórdicos introdujeron un sistema celular similar a AMPS (Advanced
Mobile Phone System). Por otro lado, en Estados Unidos, gracias a que la entidad
reguladora de ese país adoptó reglas para la creación de un servicio comercial de telefonía
celular, en 1983 se puso en operación el primer sistema comercial en la ciudad de Chicago.
Con ese punto de partida, en varios países se diseminó la telefonía celular como una
alternativa a la telefonía convencional inalámbrica. La tecnología tuvo gran aceptación, por lo
que a los pocos años de implantarse se empezó a saturar el servicio. En ese sentido, hubo
la necesidad de desarrollar e implantar otras formas de acceso múltiple al canal, y
transformar los sistemas analógicos a digitales, con el objeto de darles cabida a más
usuarios. Para separar una etapa de la otra, la telefonía celular se ha caracterizado por
contar con diferentes generaciones. A continuación, se describe cada una de ellas.
LAS GENERACIONES DE LA TELEFONIA INALAMBRICA
--Primera generación (1G)
La 1G de la telefonía móvil, hizo su aparición en 1979 y se caracterizó por ser analógica y
estrictamente para voz. La calidad de los enlaces era muy baja, tenían baja velocidad (2400
bauds). En cuanto a la transferencia entre celdas, era muy imprecisa ya que contaban con
una baja capacidad (Basadas en FDMA, Frequency Division Multiple Access) y, además, la
seguridad no existía. La tecnología predominante de esta generación es AMPS (Advanced
Mobile Phone System).
--Segunda generación (2G)
La 2G arribó hasta 1990, y a diferencia de la primera se caracterizó por ser digital.
EL sistema 2G utiliza protocolos de codificación más sofisticados, y se emplea en los
Capítulo I Marco Histórico y Estado del arte
Aplicación de software a dispositivos móviles Página 5
sistemas de telefonía celular actuales. Las tecnologías predominantes son: GSM (Global
System por Mobile Communications); IS-136 (conocido también como TIA/EIA136 o ANSI-
136) y CDMA (Code Division Multiple Access) y PDC (Personal Digital Communications),
éste último utilizado en Japón.
Los protocolos empleados en los sistemas 2G soportan velocidades de información más
altas por voz, pero limitados en comunicación de datos. Se pueden ofrecer servicios
auxiliares, como datos, fax y SMS (Short Message Service). La mayoría de los protocolos de
2G ofrecen diferentes niveles de encriptación. En Estados Unidos y otros países se le
conoce a 2G como PCS (Personal Communication Services).
--Generación 2.5 G
Muchos de los proveedores de servicios de telecomunicaciones, se moverán a las redes
2.5G antes de entrar masivamente a la 3. La tecnología 2.5G es más rápida, y más
económica para actualizar a 3G.
La generación 2.5G ofrece características extendidas, ya que cuenta con más capacidades
adicionales que los sistemas 2G, como: GPRS (General Packet Radio System), HSCSD
(High Speed Circuit Switched), EDGE (Enhanced Data Rates for Global Evolution), IS-136B
e IS-95Bm entre otros. Los
--Tercera generación 3G.
La 3G se caracteriza por contener a la convergencia de voz y datos con acceso inalámbrico
a Internet; en otras palabras, es apta para aplicaciones multimedia y altas transmisiones de
datos.
Los protocolos empleados en los sistemas 3G, soportan altas velocidades de información y
están enfocados para aplicaciones más allá de la voz como audio (mp3), video en
movimiento, videoconferencia y acceso rápido a Internet, sólo por nombrar algunos.
Capítulo I Marco Histórico y Estado del arte
Página 6 Aplicación de software a dispositivos móviles
3G es la tecnología actual y cumplió con las predicciones que en el 2000, The Yanlee Group
anticipó para el 2004 habría más de 1,150 millones en el mundo, comparados con los 700
millones que hubo en el 2000. Dichas cifras anticiparon un gran número de capital
involucrado en la telefonía inalámbrica, lo que con mayor razón las compañías fabricantes de
tecnología, así como los proveedores de servicios de telecomunicaciones, estarían
dispuestos a invertir su capital en esta aventura llamada 3G.
1.1.3 Celulares como herramientas de trabajo
Los Handheld se han convertido en equipos robustos para su utilización en la gestión de
situaciones empresariales, como por ejemplo, para la grabación de información estando en
la calle. Actualmente son usados para archivar una variedad de tareas y para incrementar la
eficiencia, como ser, la digitalización de notas, gestión de archivos, capturas de firmas,
gestión y escaneo de partes de código de barras, entre otras tareas. Las computadoras
Handheld usadas en el trabajo, han moldeado a través del tiempo una variedad de factores y
de formas, incluyendo teléfonos inteligentes, Handheld, PDAs, PCs Ultra Móviles, Tablet
PCs, Pocket PC, e incluso computadoras portátiles.
1.2 Estado del Arte 1.2.1 Sistemas Operativos para móviles
Probablemente, cualquier usuario de informática tenga en el bolsillo un segundo ordenador
más potente después de su PC: el teléfono móvil o una Pocket PC. Muchos móviles actuales
incluyen, además de la agenda, calendario de citas, videojuegos, reproductor y grabador de
vídeo, correo electrónico e incluso navegación por la Red. Debajo de todos esos programas,
hay un sistema operativo.
Los sistemas operativos están en primera instancia, sobre todo los de PC. Microsoft, la
mayor de las empresas de software, aparece con frecuencia en los medios de comunicación,
sea por sus litigios ante la justicia o por sus problemas con la seguridad de sus programas.
Capítulo I Marco Histórico y Estado del arte
Aplicación de software a dispositivos móviles Página 7
Linux, en cambio, el sistema operativo abierto más popular, suele ser noticia cada vez que
una administración pública decide utilizarlo.
Los dispositivos móviles también tienen sus propios sistemas operativos, aunque son menos
famosos que los de PC. Sin embargo, así como el mercado de los sistemas operativos para
PC está dominado por Windows, en el caso de los móviles hay más competencia. La mayor
parte se lo reparten entre tres sistemas: Windows, Symbian y Linux.
Por norma general, antes de la compra de un dispositivo móvil, son pocos los usuarios, los
que atienden al sistema operativo que se instala en el dispositivo. Y son muchos menos los
que lo hacen cuando el dispositivo no es un teléfono inteligente. Pero la guerra en busca de
un sistema operativo estándar es larga y, pese a que últimamente se ha especulado con una
posible fusión entre plataformas o de un predominio claro de un sistema sobre los demás, lo
cierto es que pocas posiciones han variado desde hace más de diez años.
Nokia y Sony Ericsson, por citar algunos ejemplos, han hecho de la plataforma Symbian, su
bandera estratégica en el terreno de los sistemas operativos para sus teléfonos inteligentes.
De hecho, el sistema S60 (la plataforma Symbian utilizada actualmente por Nokia en su
exitosa Serie N), es en este momento el sistema operativo más utilizado a nivel mundial en
el mercado de smartphones. Otros fabricantes, como es el caso de HP, HTC, Toshiba, Acer,
Asus y recientemente Palm, se han decantado por Windows Mobile como plataforma de
desarrollo. Los argumentos son los que clásicamente se atribuyen a cualquier producto
Microsoft: compatibilidad, facilidad de uso, integración con los sistemas Windows para PC,
gracias a una interfaz similar y la garantía de marca que supone Microsoft.
Windows Mobile
Windows Mobile, antes conocido como Windows CE o Pocket PC, tiene una larga historia
como segundo en el campo de los PDA u ordenadores de bolsillo, sin embargo, hace poco
tiempo superó por primera vez al hasta entonces líder, Palm OS.
El mismo sistema operativo que se emplea en una PDA se aplica a los teléfonos móviles, y
la nueva versión 5 está muy orientada a los teléfonos inteligentes de tercera generación
Capítulo I Marco Histórico y Estado del arte
Página 8 Aplicación de software a dispositivos móviles
(3G). Tras unos años de escasa implantación, Windows Mobile 5 ha logrado atraer a
fabricantes como Qtek, Samsung, Nec o la propia Palm, que lo incorpora en sus teléfonos
Treo.
Una de las ventajas de Windows Mobile sobre sus competidores, es que los programadores
pueden desarrollar aplicaciones para móviles, utilizando los mismos lenguajes y entornos
que emplean con Windows para PC. En comparación con las aplicaciones para Symbian,
que necesitan más esfuerzo de desarrollo, aunque también están más optimizadas para
cada modelo de teléfono.
Lentamente, la compañía ha tenido que ir “convenciendo” a los fabricantes sobre las virtudes
de su sistema operativo sobre los ya estandarizados Symbian o Palm OS, y así ha
conseguido una importante cuota de mercado hoy en día. De este modo, Windows Mobile
está integrado hoy en más de 150 dispositivos de comunicación móvil y su plataforma es la
segunda más extendida en Europa.
Lo que Microsoft desarrolla con Windows Mobile 6, la última versión de su sistema operativo
móvil, son nuevas características y herramientas en una plataforma que asegura flexibilidad,
productividad y usabilidad. Esto se materializa en dispositivos que utilizan una interfaz que
es similar al Windows de una PC convencional, pero todo diseñado a medida de los
terminales. Las piezas fundamentales del sistema, son su compatibilidad con los estándares
en cuanto a correos electrónicos, HTML, la suite Office y la gestión de la seguridad. Integra
una interfaz del programa Outlook, que ahora soporta formato HTML y que permite a los
usuarios disfrutar de la administración de los mensajes. En este sentido, además, el
desarrollo de la plataforma Windows Live se ha enriquecido y optimizado, combinando
servicios on-line como Messenger Live y Search. Además, en el campo de la informática
administrativa, la total compatibilidad de esta plataforma móvil con la suite Office, es un valor
que muchos usuarios hacen prevalecer sobre otras características. Acceder al visualizado o
a la edición de archivos de Word, Excel y PowerPoint, que se han elaborado en el ordenador
es una característica necesaria y muy valorada, al permitir la continuidad del trabajo fuera de
la oficina.
Capítulo I Marco Histórico y Estado del arte
Aplicación de software a dispositivos móviles Página 9
Palm OS
Palm OS nació en 1996 de la mano de la primera máquina Palm Pilot. La versión del sistema
operativo de Palm que más se está empleando hoy día es Palm OS 5, cuya versión más
actualizada es conocida como Garnet y, entre otras mejoras, soporta un mayor rango de
resoluciones de pantalla y bluetooth.
En el 2004 se presentó Palm OS 6.1, también denominada Cobalt, un sistema operativo de
32 bits completamente nativo ARM.
El interfaz no cambia mucho, pero Cobalt, entre otras cosas, saca mayor partido a los
procesadores portátiles ARM (más rápidos y eficientes), integra mayores prestaciones
multimedia, es más multitarea, incluye un nuevo sistema de protección que impide que un
único programa pueda cargar toda la información, permite pasar sin problemas de Wi-Fi a
GPRS, ver archivos en su formato nativo (por ejemplo de Microsoft Office). No obstante, su
principal novedad es que el sistema funciona sobre Linux, el sistema operativo de software
libre.
¿Qué fue de PALM OS?
El futuro del sistema operativo que incluyen la mayor parte de las PDA de Palm, actualmente
en el mercado, es hoy en día incierto. Convertido en el auténtico líder del mercado desde su
aparición en 1996, su supremacía comenzó a ceder con la llegada del nuevo siglo, hasta que
en 2003 el fabricante se vio en la necesidad de dividirse, y la plataforma pasó a formar parte
de una nueva empresa denominada PalmSource que, en 2005, fue adquirida por la
compañía japonesa Access.
Los motivos de este retroceso en cuanto a ingresos de la compañía (que no en presencia, ya
que la plataforma sigue siendo una de las que mayor cuota de mercado tiene) son fáciles de
imaginar. La lenta, pero imparable penetración de Windows Mobile, la evolución de decenas
de modelos de teléfonos móviles inteligentes (la mayoría con Symbian), y la aparición de la
plataforma y los dispositivos BlackBerry, comenzaron a dejar en un segundo plano a las PDA
Capítulo I Marco Histórico y Estado del arte
Página 10 Aplicación de software a dispositivos móviles
que no incorporaban telefonía móvil. La reacción de Palm con los modelos Treo, convertidos
hoy en los principales dispositivos de la compañía, ha sido fundamental para que la empresa
haya continuado compitiendo, entre los grandes fabricantes de dispositivos portátiles.
Esta plataforma, lógicamente, ha evolucionado desde la clásica interfaz de un asistente de
mano, a incorporar todo tipo de programas y funcionalidades, como teléfono, correo
electrónico, mensajería y navegación en internet, además de compatibilidad con los archivos
de Office, música, vídeo y fotografías. En la actualidad existen dispositivos Palm Treo, que
incorporan el sistema operativo Windows Mobile.
El sistema operativo Palm OS, hoy propiedad de Access, parece que se encamina a su
plena operatividad en Linux, lo que le augura un futuro prometedor.
Según PalmOne, hay más de 13.000 programas disponibles para su sistema operativo,
muchos más que para Windows Mobile. Es posible que el dato sea cierto, teniendo en
cuenta la antigüedad de Palm OS, pero a la hora de la verdad, no suele haber problema
alguno para encontrar programas que hagan lo mismo en ambas plataformas. Las dos son lo
bastante importantes y llevan el suficiente tiempo en el mercado, como para contar con una
nutrida variedad de programas de todo tipo.
Sin duda, cuando se trata de interactuar con computadoras de sobremesa con alguna
versión de Windows instalado, y con programas de esta compañía como la suite de Office,
Windows Mobile tiene ventaja. No obstante, esto no quiere decir que Palm OS no sea
perfectamente compatible con Windows. Por otro lado, únicamente Palm OS es compatible
de entrada con sistemas Macintosh.
Tanto Palm OS como Windows Mobile, traen incluidas las aplicaciones habituales: libreta de
direcciones, agenda, notas, tareas, opciones de seguridad, posibilidad de ajustar
preferencia, entre otras, Palm emplea el cliente de sincronización HotSync y Microsoft
ActiveSync.
Capítulo I Marco Histórico y Estado del arte
Aplicación de software a dispositivos móviles Página 11
Linux
En los círculos del software libre, se toma en cuenta la idea de implantar Linux en el teléfono
móvil desde hace años, pero ha tardado en llegar. Aún así, en los últimos tiempos se ha
avanzado mucho, y ya hay varios modelos de móvil en el mercado que utilizan una versión
de Linux como su sistema operativo.
Con Linux no hay que pagar licencias, y esto ha atraído a fabricantes de China, Taiwán o
Singapur; aunque no son los únicos. Motorola presentó su primer teléfono basado en Linux
2003, y desde entonces no ha dejado de ofrecer nuevos modelos con este sistema operativo
incorporado. Otros fabricantes conocidos, como NEC, Panasonic o Samsung, disponen de
numerosos teléfonos Linux.
Además, el fabricante de PDA Palm se ha separado de la división encargada del sistema
operativo Palm OS. La nueva versión está a cargo de la empresa japonesa Access y estará
basada en Linux.
Java
Con las siglas J2ME se conoce a Java Micro Edition, como la versión del lenguaje de
programación Java para dispositivos móviles. Aunque es un lenguaje, y no un sistema
operativo, la mayoría de los nuevos móviles pueden ejecutar aplicaciones escritas en Java, y
muchos videojuegos se crean de este modo.
También hay sistemas operativos escritos en Java, como el sistema de RIM, que funciona en
los teléfonos inteligentes Blackberry. La ventaja de Java es que la programación es similar al
famoso lenguaje C, pero más sencilla, con lo que los programadores se pueden familiarizar
rápidamente.
Las aplicaciones desarrolladas en Java se pueden ejecutar en cualquier tipo de dispositivo y
sistema operativo, siempre que se disponga de una 'máquina virtual', el programa encargado
Capítulo I Marco Histórico y Estado del arte
Página 12 Aplicación de software a dispositivos móviles
de interpretar las instrucciones. Existen chips que puede ejecutar Java directamente, sin
necesidad de un sistema operativo, y no se descarta su uso en teléfonos móviles.
1.2.2 Características de un Dispositivo móvil
actual
Categorías de dispositivos móviles
Dado el variado número de niveles de funcionalidad asociado con dispositivos móviles, en el
2005, T38 y DuPont Global Mobility Innovation Team, propusieron los siguientes estándares
para la definición de dispositivos móviles:
Dispositivo Móvil de Datos Limitados (Limited Data Mobile Device): dispositivos
que tienen una pantalla pequeña, principalmente basada en pantalla de tipo texto
con servicios de datos generalmente limitados a SMS y acceso WAP. Un típico
ejemplo de este tipo de dispositivos son los teléfonos móviles.
Dispositivo Móvil de Datos Básicos (Basic Data Mobile Device): dispositivos que
tienen una pantalla de mediano tamaño, (entre 120 x 120 y 240 x 240 pixeles), menú
o navegación basada en íconos por medio de una "rueda" o cursor, y que ofrecen
acceso a e-mails, lista de direcciones, SMS, y un navegador web básico. Un típico
ejemplo de este tipo de dispositivos son las BlackBerry y los Teléfonos Inteligentes.
Dispositivo Móvil de Datos Mejorados (Enhanced Data Mobile Device):
dispositivos que tienen pantallas de medianas a grandes (por encima de los 240 x
120 píxeles), navegación de tipo stylus, y que ofrecen las mismas características
que el "Dispositivo Móvil de Datos Básicos" (Basic Data Mobile Devices), más
aplicaciones nativas como aplicaciones de Microsoft Office Mobile (Word, Excel,
PowerPoint), y aplicaciones corporativas usuales, en versión móvil, como Sap,
Capítulo I Marco Histórico y Estado del arte
Aplicación de software a dispositivos móviles Página 13
portales intranet, etc. Este tipo de dispositivos incluyen los Sistemas Operativos
como Windows Mobile 2006, como en las Pocket PCs.
1.2.3 Aplicaciones de un dispositivo móvil
Una aplicación, es un tipo de programa informático diseñado para facilitar al usuario la
realización de un determinado tipo de trabajo. Esto lo diferencia principalmente de otros tipos
de programas como los sistemas operativos (que hacen funcionar al ordenador), las
utilidades (que realiza tareas de mantenimiento o de uso general), y los lenguajes de
programación (con el cual se crean los programas informáticos), que realizan tareas más
avanzadas y no pertinentes al usuario común.
Suele resultar una solución informática para la automatización de ciertas tareas complicadas,
como pueden ser la contabilidad, la redacción de documentos, o la gestión de un almacén.
Algunos ejemplos de programas de aplicación, son los procesadores de textos, hojas de
cálculo, y base de datos.
Ciertas aplicaciones desarrolladas 'a medida' suelen ofrecer una gran potencia, ya que están
exclusivamente diseñadas para resolver un problema específico. Otros, llamados paquetes
integrados de software, ofrecen menos potencia pero a cambio incluyen varias aplicaciones,
como un programa procesador de textos, de hoja de cálculo y de base de datos.
Capítulo I Marco Histórico y Estado del arte
Página 14 Aplicación de software a dispositivos móviles
Figura 1 Figuraa que muestra la ubicación y la relación de las aplicaciones con el usuario final.
La figura 1, muestra la ubicación y relación que tienen estas aplicaciones para con el usuario
final, y con otros programas informáticos existentes.
Otros ejemplos de programas de aplicación pueden ser: programas de comunicación de
datos, Multimedia, presentaciones, diseño gráfico, cálculo, finanzas, correo electrónico,
compresión de archivos, presupuestario de obras, gestión de empresas, entre otros.
Libreta de Direcciones
El programa Libreta de Direcciones del Palm almacena información personal, en cualquiera
de las categorías definidas por el usuario. Se muestran las entradas y salidas se ordenan por
los apellidos, y nombre (esto sólo se puede cambiar a Compañía, Apellidos). Hay cinco
campos para el teléfono o correo electrónico, cada uno de los que se puede designar a
Trabajo, a Casa, Fax u Otras, Correo Electrónico, Principal, Buscapersonas o Móvil (los
nombres de los campos no se pueden cambiar).
Calculadora
La Calculadora convierte el ordenador de bolsillo en una calculadora estándar de 4
funciones, con botones de tres tonos morados y azules, que contrastan con los dos botones
rojos para borrar. Incluye teclas de raíz cuadrada y, de porcentaje y tiene memoria.
Capítulo I Marco Histórico y Estado del arte
Aplicación de software a dispositivos móviles Página 15
También tiene una opción para mostrar un historial de los cálculos realizados, como muchas
calculadoras que se usaban antes.
Calendario
El Calendario muestra un horario diario o semanal, o una vista mensual simple(los nuevos
tiene una vista mensual más elegante). El horario diario tiene una línea cada hora, entre dos
horas del día que el usuario puede elegir. Al hacer clic en una línea vacía, se crea una cita
nueva. Las líneas vacías se llenan con las citas correspondientes, y la hora en que
empiezan, y su duración se muestra en el margen de la izquierda.
El sistema operativo puede anunciar una cita con una alarma, en el momento indicado,
minutos, horas o días antes. Estas alarmas suenan incluso cuando la unidad está apagada.
Las citas se pueden repetir en un número especificado de días, semanas, meses o años y
pueden contener notas.
Gastos
La aplicación Gastos permite a un usuario seguir los gastos comerciales habituales. El
ordenador de bolsillo no realiza ningún cálculo para obtener el total. El usuario tiene que
sincronizar con un ordenador de escritorio, y ver los datos de los gastos en una hoja de
cálculo, en las que se incluyen las plantillas para Microsoft Excel. Debido a esta desventaja,
muchos usuarios consideran esta aplicación poco útil.
Libreta de Notas
Las Notas de Texto permiten escribir notas de hasta 4000 caracteres, clasificadas en
categorías configurables por el usuario. Las notas se pueden ordenar alfabéticamente o
manualmente (que permiten al usuario escoger el orden de las notas). Las Notas de Texto
sólo pueden incluir texto, no dibujos. Por esto, el texto en las Notas se ha de introducir
utilizando el alfabeto Grafiti, que es un alfabeto con diferentes estilos de letra.
Capítulo I Marco Histórico y Estado del arte
Página 16 Aplicación de software a dispositivos móviles
Notas
En las Notas se pueden hacer dibujos y notas manuscritas. Se pueden ingresar hasta 10
palabras por página, y limitan el escrito a ciertos bytes, si la escritura es pulcra. De lo
contrario, es mejor poner texto en la Libreta de Notas. Hay tres medidas de lápices de dibujo,
más una goma de borrar. Es posible dibujar un mapa muy simple.
Tareas
También denominada lista de tareas. Es el lugar adecuado por crear recordatorios
personales y priorizar las cosas que tienes que hacer. Cada elemento de la lista de tareas
también puede tener: una prioridad, categorías (por organizar y agrupar las tareas en grupos
lógicos), adjuntar una Nota (por añadir una descripción o una aclaración de la tarea). Las
tareas se pueden ordenar por: fecha, prioridad o categoría.
1.2.4 Aplicaciones Windows Mobile con
tecnología .NET
La plataforma .NET Framework, proporciona la infraestructura básica que necesitan las
aplicaciones Windows, para hacer realidad la visión de Microsoft que conecta información,
personas, sistemas y dispositivos.
El Framework .NET consta de:
El Common Language Runtime (CLR). Es un lenguaje neutral de desarrollo y
ejecución que proporciona servicios para ayudar a "gestionar" la ejecución de la
aplicación.
Las Framework Class Libraries (FCL). Un conjunto integral de bibliotecas
orientadas a objetos con funcionalidad pre desarrolladas.
Capítulo I Marco Histórico y Estado del arte
Aplicación de software a dispositivos móviles Página 17
Para hacer realidad la visión de Microsoft, .NET Framework proporciona una estructura
integral:
Soporta los protocolos y especificaciones de comunicación Standard. Usa los
protocolos y especificaciones estándar de Internet, como TCP/IP, SOAP, XML y
HTTP, para permitir la conexión a un amplio número de información, personas,
sistemas y dispositivos (ver figura 2).
Figura 2 Esquema de red que muestra la conexión con un amplio número de personas
Soporta diferentes lenguajes de programación. Soporta una variedad de
diferentes lenguajes de programación, de manera que los desarrolladores pueden
programar en el lenguaje que prefieran.
Soporta la programación con librerías desarrolladas en diferentes lenguajes.
La plataforma .NET proporciona un modelo consistente de programación, para
utilizar piezas de funcionalidad ya desarrolladas o bibliotecas (para mayor
información de estas bibliotecas ver anexos), que hacen que el desarrollo de
aplicaciones sea más rápido, más fácil y menos costoso.
Soporte para diferentes plataformas. El Framework .NET está disponible para
toda la variedad de las plataformas Windows, lo que permite a las personas, los
sistemas y los dispositivos, conectarse utilizando diferentes soportes. Así, una
persona utilizando entornos de escritorio como Windows XP o una plataforma de
Capítulo I Marco Histórico y Estado del arte
Página 18 Aplicación de software a dispositivos móviles
dispositivo, como una PDA o un Smartphone con Windows Mobile, puede
conectarse a servidores que utilicen Windows Server 2003, o incluso Linux.
1.3 Pocket PC
Pocket PC es un ordenador de bolsillo, también llamado PDA (Personal Digital Assistant). Se
trata de un pequeño ordenador, diseñado para ocupar el mínimo espacio y ser fácilmente
transportable, ejecuta el sistema operativo que es Windows CE de Microsoft, el cual le
proporciona capacidades similares a los PCs de sobremesa.
De acuerdo con Microsoft, el Pocket PC es "un dispositivo de mano que permite grabar,
enviar y recibir e-mail, contactos, citas, mostrar archivos multimedia, juegos, intercambiar
mensajes de texto con MSN Messenger, navegar por la web y más".
Desde un punto de vista técnico, Pocket PC es un estándar de Microsoft que impone varios
requisitos al hardware y al software de dispositivos móviles, para tener la etiqueta de Pocket
PC.
Actualmente hay muy pocos fabricantes, y se concentran la gran mayoría en el continente
asiático. Entre ellos, el más importante y que recientemente se convirtió en distribuidor, es
HTC, antiguo proveedor de HP, Acer o Fujitsu entre otros. Otros fabricantes de dispositivos
Pocket PC son Quanta, Foxcon, Inventec, Asus o Compal, concentrados todos ellos en
Taiwan y dedicados también a la fabricación de otros equipos electrónicos, como portátiles o
dispositivos GPS.
Sin embrago, hay bastantes distribuidores, entre las que se encuentran a HP, Fujitsu
Siemens, Garmin, Acer, Casio y un largo etcétera, que encargan a los fabricantes antes
mencionados, el diseño de sus equipos, y a los que sólo les ponen su marca y se encargan
de distribuirlos y dar soporte técnico.
Capítulo I Marco Histórico y Estado del arte
Aplicación de software a dispositivos móviles Página 19
1.3.1 Características de PocketPC
Los PDAs ofrecen, casi las mismas prestaciones que los PCs de sobremesa, con un
aliciente añadido: su total movilidad. Los últimos avances tecnológicos y las posibilidades de
desarrollo de soluciones a medida que ofrece Microsoft Pocket PC avalan sus ventajas.
Gran Capacidad de Procesamiento y Memoria
Enorme Integración Multimedia
Gran Compatibilidad con Ordenadores de Mesa (Word, Excel, MSN Messenger,
Windows Media Player)
Facilidad de Sincronización con PC (ActiveSync)
Mayor potencia y prestaciones
Dos factores han sido decisivos para el auge de estas soluciones: su abaratamiento y la
mayor calidad tecnológica de la última generación de PDAs. Muy lejos quedan los tiempos,
en los que consistían en meras agendas electrónicas. Los modelos actuales se han
convertido en verdaderos ordenadores de bolsillo: su velocidad de proceso es considerable,
están provistos de una amplia memoria, cómodas pantallas en color y versiones en miniatura
de los programas para PC de Microsoft (Pocket Outlook, Pocket Word, Pocket Excel,
Explorer, entre otros). Proporciona al usuario un soporte integral, ofreciéndole una extensión
de su ordenador, permitiéndole realizar numerosas tareas en tiempo real. Permite realizar
llamadas de voz y navegar por Internet a través de GSM o GPRS.
Una plataforma muy flexible
El otro movilizador de esta revolución móvil es Microsoft Pocket PC, un sistema operativo
que posibilita el desarrollo de soluciones a medida para los PDAs. “Microsoft ha creado una
plataforma fácilmente maleable y dotada de grandes herramientas para los desarrolladores,
lo que le ha permitido hacerse ya con un gran porcentaje de este mercado, y crear
numerosas aplicaciones empresariales”, dice Carlos Polo, director de Operaciones de NTS
Mobile, firma especializada en el desarrollo de productos basados en este sistema.
Capítulo I Marco Histórico y Estado del arte
Página 20 Aplicación de software a dispositivos móviles
Pero, sobre todo, los nuevos dispositivos reportan importantes ventajas empresariales. “Por
su propia movilidad, permiten aprovechar el tiempo al máximo”. Por ejemplo, la premura con
que en el almacén reciben la notificación de un pedido se traduce en una respuesta más
rápida y, por lo tanto, en una mejora del servicio.
Otro gran beneficio es la reducción de costos, en comparación con los que implicaría
ejecutar las mismas tareas en un entorno estático.
1.3.3 Funciones básicas
Hay diferencias entre los equipos que se pueden denominar Pocket PC, dependiendo de las
utilidades que tienen, se pueden englobar en tres grupos:
1º- Las Pocket PCs (comúnmente conocidos como PDA sin teléfono) incluyen versiones
móviles de las aplicaciones de Office, además de Microsoft Outlook Mobile. Con el Pocket
PC, podrá utilizar Word Mobile, Excel Mobile y PowerPoint Mobile y navegar por Internet, si
tiene un dispositivo con Wi-Fi y se encuentra en un punto de conexión inalámbrica. Puede
escribir correos electrónicos y enviarlos con tan solo sincronizar su ordenador, o mediante
conexión inalámbrica cuando se encuentra en un punto de conexión.
2º- Los Pocket PC Phone (comúnmente conocidos como Pocket PC o PPC) puede
hacer todo lo que hace con un Pocket PC, pero además dispone de teléfono móvil. Si tiene
un Pocket PC Phone, puede acceder a Internet, a través de una conexión inalámbrica
(GPRS, UMTS, etc...); no tendrá que buscar un punto en el que la haya. Tenga en cuenta
que al acceder a Internet, los proveedores de tecnología inalámbrica le impondrán cargos
económicos.
3º- Los Smartphone ofrece lo mismo que un teléfono y además, incluye una serie de
aplicaciones más pequeñas. Además de agregar software de terceros a su Smartphone, su
teclado y pantalla pequeños, se han creado, pensados para darle acceso rápido de primera
mano a la información importante. Un Smartphone es la decisión idónea para usuarios
Capítulo I Marco Histórico y Estado del arte
Aplicación de software a dispositivos móviles Página 21
avanzados, que tienen que consultar el correo electrónico, hacer un seguimiento de su
calendario y tomar notas de voz, pero que no necesitan las funciones de Word Mobile, Excel
Mobile y PowerPoint Mobile. Si después de haber adquirido el dispositivo, descubre que
quiere más funciones, hay una serie de nombres de software de terceros, pensados para
ampliar las capacidades de Smartphone equipados con Windows Mobile.
Capítulo I Marco Histórico y Estado del arte
Página 22 Aplicación de software a dispositivos móviles
Capítulo II Planteamiento del Problema y Herramientas de Software
Aplicación de software a dispositivos móviles Página 23
CAPÍTULO II
Planteamiento del Problema y
Herramientas de Software
2.1 Planteamiento del problema
Regularmente cuando se piensa en el desarrollo y creación de software, se pueden
presentar varias preguntas, ¿Qué software existe actualmente? ¿Qué se necesita ahora?
O también puede existir la posibilidad de basarse en un software o aplicación ya
elaborada, pensando en las mejoras que se podrían hacer y que se puedan agregar. Es
importante pensar en las aplicaciones o compiladores que, como programadores,
convenga utilizar, así como verificar la compatibilidad con el dispositivo en el cual se
desarrollará el software.
De esta manera, se enfocará este estudio, a la realización de una aplicación de diseño y
desarrollo de herramientas básicas de ingeniería en comunicaciones y electrónica para
Pocket PC. Por lo que se estudiarán las herramientas que se utilizarán para la realización
de ésta aplicación. Las materias de tronco común a tomar en cuenta, así como las
herramientas básicas a desarrollar, para la resolución de problemas sencillos enfocados
a cada una de las materias propuestas. Tomar en cuenta el software y la plataforma de
desarrollo.
Capítulo II Planteamiento del Problema y Herramientas de Software
Página 24 Aplicación de software a dispositivos móviles
2.2 Tecnología .NET.
La Tecnología .NET es un proyecto de Microsoft para crear una nueva plataforma de
desarrollo de software, con énfasis en transparencia de redes, con independencia de la
plataforma de hardware y que permita un rápido desarrollo de aplicaciones. Basado en
ella, la empresa intenta desarrollar una estrategia horizontal que integre todos sus
productos, desde el sistema operativo hasta las herramientas de mercado.
La Tecnología .NET podría considerarse una respuesta de Microsoft al creciente
mercado de los negocios en entornos Web, como competencia a la plataforma Java de
Sun Microsystems, y a los diversos Framework de desarrollo Web, basados en PHP. Su
propuesta es ofrecer una manera rápida y económica, a la vez que es segura y robusta,
para el desarrollo de aplicaciones –o como la misma plataforma las denomina,
soluciones– permitiendo una integración más rápida y ágil entre empresas, y un acceso
más simple y universal, a todo tipo de información desde cualquier tipo de dispositivo.
La Plataforma .NET de Microsoft es un componente de software, que puede ser añadido
al sistema operativo Windows. Provee un extenso conjunto de soluciones predefinidas,
para necesidades generales de la programación de aplicaciones, y administra la
ejecución de los programas escritos, específicamente con la plataforma. Esta solución es
el producto principal en la oferta de Microsoft, y pretende ser utilizada por la mayoría de
las aplicaciones creadas para la plataforma Windows.
La Tecnología .NET Framework se incluye en Windows Server 2008 y Windows Vista.
De igual manera, la versión actual de dicho componente, puede ser instalada en
Windows XP, y en la familia de sistemas operativos Windows Server 2003. Una versión
"reducida" de .NET Framework, está disponible para la plataforma Windows Mobile,
incluyendo teléfonos inteligentes.
Microsoft proporciona, una versión limitada del .NET Framework para utilizarla en
dispositivos móviles, llamada Compact Framework de .NET.
Capítulo II Planteamiento del Problema y Herramientas de Software
Aplicación de software a dispositivos móviles Página 25
El Compact Framework 3.5 de .NET o .NETCF 3.5 es una versión actualizada que puede
ser instalada en los diferentes dispositivos móviles que cuenten con una versión anterior
soportada por Compact Framework de (ver figura 3).
Figura 3 comparación de las plataformas soportadas por el .NET Compact Framework 3.5 Por Eduardo
Ortega de Movilidad en Microsoft
2.2.1 Versiones de multiplataforma de .NET Framework
La compatibilidad multilenguaje y la integración son objetivos de diseño básicos del CLR
(Common Languaje Runtime) y son críticos para promocionar la adopción de la
plataforma .NET en todas las áreas de la comunidad de desarrollo. La fortaleza del
soporte de lenguaje .NET, es que los componentes desarrollados en cualquier lenguaje,
se pueden utilizar en otro; por ejemplo, una aplicación C++ gestionada puede utilizar una
biblioteca C#. El requisito es que los componentes se ajusten al CLS (Common languaje
Specification); por lo tanto, también es posible desarrollar componentes en un lenguaje
.NET que no se puedan utilizar en otro.
Cuando un archivo de código fuente C# (o un archivo de de código fuente de cualquier
otro lenguaje compatible con .NET) se compila, la salida se compone de instrucciones
Capítulo II Planteamiento del Problema y Herramientas de Software
Página 26 Aplicación de software a dispositivos móviles
MSIL (Microsoft intermédiate Languaje). MSIL es una representación intermedia y se ha
de compilar a instrucciones nativas para poder ejecutarlo; esta tarea se delega al entorno
de ejecución del lenguaje común, que se trata a continuación.
Entorno de ejecución del lenguaje común
El entorno de ejecución del lenguaje común CLR (Common Languaje Runtime) es
responsable de la ejecución del código y de proporcionar servicios básicos como la
gestión de memoria automática, subprocesos, seguridad e integración con el sistema
operativo subyacente.
Antes de que se pueda ejecutar el MSIL, se ha de traducir a código nativo, el cual es
específico para una CPU concreta. Este proceso se llama compilación inmediata (Just-In-
Time, JIT) y es una característica básica del CLR.
La fuerte integración entre el sistema operativo Windows y el formato de la aplicación
.NET significa que el CLR se invoca automáticamente cuando se arranca una aplicación
.NET.
El sistema de tipos común
El CTS (Common Type System) define como se declaran los tipos, cómo se utilizan y
cómo se gestionan en tiempo de ejecución. El CTS es una parte importante del soporte
multilenguaje de .NET y proporciona la base para que los tipos escritos en un lenguaje se
puedan utilizar en otros.
Las bibliotecas de clases básicas
El .NET Framework incluye un conjunto de bibliotecas que puede utilizar y extender un
programador durante el proceso de desarrollo. Todos los tipos contenidos en las
bibliotecas de clases cumplen el CLS y se pueden utilizar desde cualquier lenguaje que
se ajuste al CLS, incluyendo el compilador de C#.
Capítulo II Planteamiento del Problema y Herramientas de Software
Aplicación de software a dispositivos móviles Página 27
Lenguajes
La compatibilidad multilenguaje y la integración son objetivos de diseño básicos del CLR
y son críticos para promocionar la adopción de la plataforma .NET en todas las áreas de
la comunidad de desarrollo. La fortaleza del soporte de lenguaje .NET es que los
componentes desarrollados en cualquier lenguaje se pueden utilizar en otro; por ejemplo,
una aplicación C++ gestionada puede utilizar una biblioteca C#.
Microsoft proporciona tres lenguajes como parte de .NET: Visual Basic .NET, Microsoft
Visual C++ .NET y Microsoft Visual C#.
2.2.2 Características de Visual C# .NET
Al combinar Visual Studio y .NET Framework, se reduce la necesidad de código de
programación común irrelevante, lo que acorta el tiempo de desarrollo y permite que los
desarrolladores, se concentren en la solución de los problemas.
Los diseñadores del lenguaje C# y el .NET Framework han estado claramente influidos
por java, C y C++ pero han tomado una aproximación fundamentalmente distinta para
resolver los conflictos del diseño seguro. Se ha llevado a cabo un gran esfuerzo para
garantizar que el desarrollador puede escribir código seguro y robusto fácilmente, pero
las características que se consideran peligrosas todavía están disponibles para el
programador avanzado o el programador de sistemas heredados que puede indicar de
forma explícita la necesidad de salirse de las limitaciones del código seguro.
Aunque la plataforma .NET acaba de ser presentada, las comparaciones entre Java y C#
son naturales ya que tienen muchas similitudes. Generalmente las comparaciones
tienden a enfocarse únicamente en las similitudes estructurales y sintácticas obvias,
mientras que una exploración a un nivel más profundo revela diferencias fundamentales y
una cantidad importante de características nuevas que están disponibles para el
programador de C#.
Capítulo II Planteamiento del Problema y Herramientas de Software
Página 28 Aplicación de software a dispositivos móviles
2.3 Windows Mobile
Windows Mobile es un sistema operativo compacto, con una suite de aplicaciones
básicas para dispositivos móviles basados en la API Win32 de Microsoft. Los dispositivos
que llevan Windows Mobile, son Pocket PC's, Smartphones y Media Center portátil. Ha
sido diseñado para ser similar a las versiones de escritorio de Windows (ver figura 4).
Figura 4 vista de sistema Windows Mobile 6.0 en Smartphone
Básicamente se originó en una versión del Kernel de Windows para sistemas embebidos,
que fue creciendo hasta ser un sistema operativo.
2.3.1 Características de Windows Mobile y algunas aplicaciones incluidas
Tanto Windows Mobile para Pocket PC, como Windows Mobile para Smartphone, poseen
bastantes aspectos parecidos, pero en cuanto a aplicaciones desarrolladas, una
aplicación no servirá para ambas versiones Windows Mobile PPC (Pocket PC) y Windows
Mobile SP (Smartphone) (ver figura 5).
Capítulo II Planteamiento del Problema y Herramientas de Software
Aplicación de software a dispositivos móviles Página 29
Figura 5 Fotografía de un Smartphone, marca Nokia. En el se muestra la interfaz en su pantalla
En el caso de Windows Mobile para Pocket PC se muestran las siguientes
características:
En la barra de tareas muestra: la hora actual, el volumen y el estado de la
conectividad. Cuando un programa o un mensaje están abiertos, el espacio en
blanco, en el que estaba el reloj, se convierte en una "OK" o un icono de cerrar (x).
La característica principal de la barra de tareas, es el botón de Inicio, que está
diseñado para que sea parecido al botón de Inicio de las versiones de escritorio de
Windows. El menú de Inicio ofrece programas abiertos recientemente, nueve
entradas del menú personalizadas, y accesos directos a programas, ajustes,
búsquedas, y ayuda.
Las versiones Pocket PC incluyen en Windows Mobile aplicaciones de Microsoft
Office. Éstos incluyen Pocket Word y Pocket Excel. En Windows Mobile 5.0 se
incluye Pocket PowerPoint. Estas versiones incluyen muchas de las características
que se utilizan en versiones de escritorio, pero algunas otras características, como la
inserción de las tablas e imágenes, no se han incluido versiones anteriores a
Windows 5.0. ActiveSync tiene la capacidad de convertir archivos de versiones de
escritorio a archivos compatibles con Pocket PC (ver figura 6).
Capítulo II Planteamiento del Problema y Herramientas de Software
Página 30 Aplicación de software a dispositivos móviles
Figura 6 Muestra de un Pocket PC, IPACmarca HP
Outlook Mobile es también un programa que viene con Windows Mobile. Esto incluye
tareas, calendario, contactos, y la bandeja de entrada. Microsoft Outlook para las
versiones de escritorio, se incluye a veces en los CD-ROM's del fabricante del Pocket
PC.
Windows Media Player para Windows Mobile, se añade con el software. Actualmente,
todas las Pocket PC incluyen la versión 9 del reproductor, pero la versión 10 se ha
incluido con un hardware más nuevo, y con las nuevas versiones de Windows
Mobile. Para algunos dispositivos, la versión 10 está disponible para su descarga,
sólo para determinados dispositivos éstos incluyen los dispositivos de la gama de
Dell Axim. Windows Media Player reproduce: WMA, WMV , MP3, y AVI. Los archivos
MPEG actualmente no están soportados, y se debe descargar un programa de
terceros para reproducirlos, y los archivos de WAV se reproducen en un reproductor
por separado. Algunas versiones son también capaces de reproducir M4A.
Windows Mobile Device Center trabaja con dispositivos Windows Mobile 2003 o
superiores, y permite gestionar las aplicaciones, opciones de calendario, correos, citas,
tareas y archivos de nuestra PDA, a través del PC.
Entre las novedades que se añaden al nuevo Windows Mobile Device Center, se muestra
una nueva interfaz de usuario, ostensiblemente mejorada con respecto a ActiveSync,
mucho más intuitiva y cómoda de utilizar (ver figura 7).
Capítulo II Planteamiento del Problema y Herramientas de Software
Aplicación de software a dispositivos móviles Página 31
Figura 7 Interfaz de Windows Mobile Device Center
Chess Mobile es un juego de ajedrez de cuidadoso diseño para Windows Mobile, que
lleva impreso el sello de calidad de los productos de Orneta, y que puede servir de
entretenimiento en esos ratos muertos, en el que no se tiene más compañía que una
PDA.
Figura 8 Interfaz del la aplicación Chess Mobile por Microsoft corporativo
DivX Mobile Player es el reproductor oficial de DivX, para teléfonos y dispositivos
Windows Mobile.
Capítulo II Planteamiento del Problema y Herramientas de Software
Página 32 Aplicación de software a dispositivos móviles
Para cargar cualquier video que se tenga almacenado en la memoria de la PDA o en la
tarjeta de memoria, sólo se tiene que actualizar el listado de la pantalla principal del
programa. Una vez que se haya copiado el video en el dispositivo, DivX Mobile Player lo
reconocerá automáticamente y se puede comenzar su reproducción (ver figura 9).
Figura 9 Pantalla de la aplicación DIVX
2.4 Visual Studio
Microsoft Visual Studio es un entorno de desarrollo integrado (IDE, por sus siglas en
inglés) para sistemas Windows. Soporta varios lenguajes de programación, tales como
Visual C++, Visual C#, Visual J#, ASP.NET y Visual Basic .NET, aunque actualmente se
han desarrollado las extensiones necesarias para muchos otros.
Visual Studio permite a los desarrolladores crear aplicaciones, sitios y aplicaciones web,
en cualquier entorno que soporte la plataforma .NET (a partir de la versión net 2002). Así
se pueden crear aplicaciones que se intercomuniquen entre estaciones de trabajo,
páginas web y dispositivos móviles.
A las mejoras de desempeño, escalabilidad y seguridad con respecto a la versión
anterior, se agregan entre otras, las siguientes novedades.
• Visual Studio 2008 ahora permite la creación de soluciones multiplataforma,
adaptadas para funcionar con las diferentes versiones de .Net Framework: 2.0.
Capítulo II Planteamiento del Problema y Herramientas de Software
Aplicación de software a dispositivos móviles Página 33
(Incluido con Visual Studio 2005), 3.0 (incluido en Windows Vista) y 3.5 (incluido
con Visual Studio 2008).
• .NET 3.5 incluye biblioteca ASP.NET AJAX para desarrollar aplicaciones web
más eficientes, interactivas y altamente personalizadas, que funcionen para
todos los navegadores más populares, y utilicen las últimas tecnologías y
herramientas Web, incluyendo Silverlight y Popfly
A partir de la versión 2005 Microsoft ofrece gratuitamente las Express Editions. Estas son
varias ediciones básicas separadas por lenguajes de programación o plataforma,
enfocadas para novatos y entusiastas. Estas ediciones son iguales al entorno de
desarrollo comercial, pero sin características avanzadas. Las ediciones que hay son:
Visual Basic Express Edition
Visual C# Express Edition
Visual C++ Express Edition
Visual J# Express Edition (Desapareció en Visual Studio 2008)
Visual Web Developer Express Edition (para programar en ASP.NET)
2.4.1 Versiones
Microsoft Visual Studio 5
Microsoft Visual Studio 6
Microsoft Visual Studio .NET (2002)
Microsoft Visual Studio .NET 2003
Microsoft Visual Studio 2005
Microsoft Visual Studio 2008
Estas son varias ediciones básicas separadas por lenguajes de programación o
plataforma. Estas ediciones son iguales al entorno de desarrollo comercial, pero sin
características avanzadas. Las ediciones que hay son:
Visual Basic Express Edition
Visual C# Express Edition
Capítulo II Planteamiento del Problema y Herramientas de Software
Página 34 Aplicación de software a dispositivos móviles
Visual C++ Express Edition
Visual J# Express Edition (Desapareció en Visual Studio 2008)
Visual Web Developer Express Edition (para programar en ASP.NET)
Adicionalmente, Microsoft ha puesto gratuitamente a disposición de todo el mundo, una
versión reducida de MS SQL Server llamada SQL Server Express Edition, cuyas
principales limitaciones son: que no soporta bases de datos superiores a 4 GB de
tamaño, únicamente utiliza un procesador y 1Gb de memoria RAM;, y no cuenta con el
Agente de SQL Server.
2.4.2 Funciones de Visual Studio
Visual Studio 2008 ofrece herramientas de desarrollo avanzadas, características de
depuración, funcionalidad de base de datos y características innovadoras, para crear
rápidamente las aplicaciones de vanguardia del futuro en una gran variedad de
plataformas.
Visual Studio 2008 incluye mejoras, como los diseñadores visuales, para el desarrollo
más rápido con .NET Framework 3.5, mejoras sustanciales de las herramientas de
desarrollo web y mejoras del lenguaje que aceleran el desarrollo con todo tipo de datos.
Visual Studio 2008 ofrece a los desarrolladores toda la compatibilidad con herramientas,
y marcos necesarios para crear aplicaciones web atractivas, expresivas y compatibles
con AJAX.
Los desarrolladores podrán beneficiarse de estos marcos de cliente y de servidor
enriquecidos para crear fácilmente aplicaciones web, centradas en el cliente que se
integren con cualquier proveedor de datos back-end, se ejecuten en cualquier explorador
moderno, y tengan acceso completo a los servicios de la aplicación ASP.NET y la
plataforma de Microsoft.
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 35
CAPÍTULO III
Diseño y Desarrollo de la
Aplicación
En este capítulo se pretende explicar de manera simple y entendible, la forma en que se
construye el proyecto de desarrollo de una aplicación, con herramientas básicas de
ingeniería, y la manera en que se utilizan las herramientas de desarrollo de Visual Studio.
Así como explicar la forma en que se recopilan las aplicaciones elaboradas de manera
individual, para su conjunción en una sola aplicación de proyecto Visual Studio 2008.
Éste capítulo también pretende aportar al lector una manera alternativa de desarrollo de
un proyecto, aplicado a dispositivos móviles, utilizando la herramienta de diseño Visual
Studio 2008, bajo el esquema de programación C#.
Para un mejor entendimiento del desarrollo de la aplicación, es necesario, tener un
conocimiento básico en programación C o C#, con el fin de que el lector tenga una
manera más sencilla de entender los procesos de programación para cada aplicación.
3.1 Descripción general de la aplicación
Para el desarrollo de la aplicación se utilizó una metodología orientada a objetos la cual
permite poder reconocer de la aplicación los objetos a diseñar, de estos objetos sus
propiedades, su valor y sus operaciones a realizar, para poder diseñar y desarrollar las
distintas tareas a desempeñar por la aplicación; esta metodología reduce la complejidad
de los problemas ya que divide la aplicación en problemas pequeños y permite obtener
soluciones con mejor rendimiento (ver figura 10).
Capítulo III Diseño y Desarrollo de la Aplicación
Página 36 Aplicación de software a dispositivos móviles
Figura 10 Metodología orientada a objetos para el diseño y desarrollo de una aplicación.
La aplicación consta de varios formularios de contenido diverso, enfocados a las materias
básicas de Ingeniería en Comunicaciones y Electrónica, que se conjuntan y se muestran
de manera atractiva, permitiendo que el estudiante de Ingeniería en Comunicaciones y
Electrónica entienda y comprenda de manera interactiva y clara los temas de algunas de
sus materias básicas.
La aplicación comprende información de materias de tronco común de la carrera de ICE
(Ingeniería en Comunicaciones y Electrónica), tales como electrónica digital, circuitos
digitales, circuitos de CA y CD, comunicaciones digitales y analógicas y procesamiento
digital de señales. Se explica el desarrollo de los formularios de cada materia, así como el
código planteado para cada una de las herramientas de apoyo. Entre las herramientas,
adicionales a los formularios, se encuentran: un convertidor de unidades, calculadora,
resolución de ejemplos que ayuden a la mejor comprensión de los temas, tales como
diseño de circuitos electrónicos, filtros pasa altas y pasa bajas. Es importante resaltar que
los formularios se muestran como herramientas de consulta, no de aplicación; y la
información mostrada en ellos, se basa en los temas abordados durante la carrera de
ICE, extraída de apuntes, libros y otros materiales de consulta, tales como internet u
hojas de especificación.
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 37
3.2 Desarrollo y creación de la aplicación
Para comenzar el desarrollo de la aplicación se hace uso de las herramientas contenidas
en Visual Studio 2008. Se mencionarán las más importantes y la manera de programarlas
para que realicen diversas acciones.
Es importante mencionar que la programación en C# sobre la plataforma del Framework
en comparación con el compact Framework difiere en las propiedades de cada
herramienta y las acciones que realiza.
Diferencias entre .NET Compact Framework y .NET Framework
.NET Compact Framework es un subconjunto del entorno completo de .NET Framework.
Implementa un 30% aproximadamente de la biblioteca de clases completa del entorno
íntegro de .NET Framework y contiene además las características y clases específicas
del desarrollo móvil e incrustado.
.NET Compact Framework admite un subconjunto de la biblioteca de clases de .NET
Framework. Dicho subconjunto es apropiado para las aplicaciones diseñadas para
ejecutarse en dispositivos con limitaciones de recursos y es semánticamente compatible
con las clases del mismo nombre de .NET Framework.
.NET Compact Framework admite la mayor parte de los controles de formularios
Windows Forms que se incluyen la versión completa de .NET Framework y contiene
controles que son específicos de .NET Compact Framework.
Implementar aplicaciones
No todos los métodos matemáticos se admiten en todas las plataformas de dispositivos,
pero se incluyen en la API por motivos de compatibilidad. (Corporations, 2009)
Para comenzar con la creación de una aplicación Visual Studio 2008, previamente se
debió de haber instalado en la PC, este software, una vez que se haya instalado se
Capítulo III Diseño y Desarrollo de la Aplicación
Página 38 Aplicación de software a dispositivos móviles
comenzarán a desarrollar las aplicaciones. Se ejecuta el programa desde Inicio/Todos los
programas/Microsoft Visual Studio 2008/ Microsoft Visual Studio 2008 (ver figura 11).
Figura 11 Pantalla para demostrar la ruta de ubicación del software Microsoft Visual Studio 2008 después de
haberse instalado
Una vez inicializada la plataforma de Visual Studio 2008, a continuación se muestra el
espacio de trabajo y se deberá de elegir Crear Nuevo Proyecto, esto es para establecer
las condiciones del proyecto necesarias para realizar la programación del dispositivo (ver
figura 12).
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 39
Figura 12 Señalización del menú para crear nuevo proyecto
Una vez elegido crear el proyecto se elige la plataforma de desarrollo la cual será Visual
C#, se selecciona Smart Device para especificar que el entorno de programación será
orientado a un dispositivo móvil (ver figura 13).
Figura 13 Ventana de creación del nuevo proyecto.
Capítulo III Diseño y Desarrollo de la Aplicación
Página 40 Aplicación de software a dispositivos móviles
El nombre del proyecto se escribirá en el campo nombre de esta misma ventana, y este
se guardará en una dirección especificada por el usuario, la cual se marca en la ventana
con el nombre de Ubicación.
El siguiente paso es elegir el tipo de plantilla para crear la base de la aplicación, en este
paso también se da la versión de la plataforma Compact Framework y el tipo de
Dispositivo físico en la opción plataforma destino. En este caso se especifica que se
trabajará un proyecto para crear una aplicación de formularios de .NET Compact
Framework 3.5 para la plataforma Windows Mobile 5.0 Pocket PC SDK (figura 14).
Figura 14 Agregar nuevo proyecto y señalización de Aplicación a dispositivo. Para especificar que el proyecto
será para un dispositivo móvil.
Una vez especificado el tipo de proyecto se realiza la elaboración de las aplicaciones con
ayuda de las herramientas y los accesorios que nos brinda la plataforma de visual studio.
En esta se encuentran la ventana de Propiedades y dos pestañas, caja de herramientas y
el Explorador de servidores (estas pestañas son verticales a lo largo de la parte superior
derecha). La ventana de propiedades muestra los tamaños, dimensiones y otras
"propiedades" de los objetos. La caja de herramientas apoya a la selección de los
componentes y añadir a su forma.
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 41
El espacio de trabajo es tal como el que se muestra en la figura (ver figura 15) en
conjunto con las ventanas y herramientas anteriormente descritas, en la parte de en
medio se puede visualizar el formulario.
Ésta será la base para realizar todas las aplicaciones o proyectos en Visual Studio.
3.2.1 Herramientas del software
En la elaboración de las aplicaciones se hace uso de las herramientas otorgadas por
Visual Studio para realizar todas y cada una de las aplicaciones. Aunque cuenta con gran
diversidad de herramientas, para la aplicación sólo algunas son las más utilizadas, cómo
las que se describen a continuación.
Figura 15 Señalización del cuadro de herramientas y de la ventana de propiedades, dentro de la interfaz
gráfica del Visual Studio 2008
Ventana de propiedades
Cuadro de herramientas
Capítulo III Diseño y Desarrollo de la Aplicación
Página 42 Aplicación de software a dispositivos móviles
El cuadro de herramientas brinda al usuario los elementos de control del dispositivo,
estos elementos son programables en el código fuente de la aplicación para ejecutar
alguna acción que el programador indique basándose en las instrucciones permitidas por
los mismos controles.
Como se menciono anteriormente, cada herramienta de control del dispositivo puede ser
programable, esta acción se realiza desde el archivo “Program.cs” que se puede
visualizar en la ventana de “Explorador de Soluciones” (ver figura 16).
Figura 16 Ventana del explorador de soluciones, tomada de la interfaz de Visual Studio 2008
Este archivo contiene todo el código fuente correspondiente a la programación de los
recursos o herramientas de todo el “Form1”; el Form1 es el nombre del formulario o
ventana principal de una aplicación, este nombre puede ser modificado dependiendo del
nombre de la clase principal del programa en el código fuente.
También se pueden agregar más de un Form a un mismo proyecto, cada uno con su
propio código de programación y variables locales, esto con la finalidad de realizar un
programa completo con diferentes ventanas o vistas.
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 43
El archivo Form1.Designer.cs contiene el código del diseño del formulario y se
autogenera cuando el programador arrastra los controles a los formularios del programa
automáticamente.
3.2.1.1 Controles usados para el diseño de la aplicación
TextBox (Caja de Texto)
Figura 17 Señalización dentro del cuadro de herramientas y elección del control
Figura 18 Ejemplo tomado de la aplicación operaciones con matrices para que se pueda observar el uso del
control
Mediante éste control se puede realizar, tanto la entrada como salida de datos en cada
aplicación.
No hace falta indicar coordenadas de posición, dentro del formulario, donde se desarrolla
la aplicación; basta con arrastrar el control y darle las dimensiones deseadas, adecuarlo a
nuestro propio diseño (ver figuras 17 y 18).
Label (Etiqueta)
Figura 19 Señalización dentro del cuadro de herramientas y elección del control Label
Figura 20 Ejemplo de un control Label dentro de un formulario, en este caso la etiqueta corresponde a la
herramienta de amplificadores
Capítulo III Diseño y Desarrollo de la Aplicación
Página 44 Aplicación de software a dispositivos móviles
Este control es de los más utilizados, dado que permite la visualización de texto; y es
precisamente ésta su restricción, pues no permite la introducción de datos por parte del
usuario (ver figuras 19 y 20).
Button (Botón)
Figura 21 Señalización dentro del cuadro de herramientas y elección del control Button
Figura 22 Ejemplo del botón dentro de un formulario.
Típico botón que aparece en la mayoría de las aplicaciones. Tiene establecido un método
el cual determina que al hacer „clic‟ sobre él, permite realizar una función concreta,
normalmente permite la realización de las operaciones en las diversas aplicaciones,
aunque sus funciones podrán variar, de acuerdo al código que se le asocie, incluso
podrían ser sólo para aceptar o cancelar un proceso (ver figuras 21 y 22).
RadioButton (Opción botón)
Figura 23 Señalización dentro del cuadro de herramientas y elección del control RadioButton
Figura 24 Ejemplo de uso de RadioButton dentro de la herramienta matrices
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 45
Éste control permite elegir una opción entre varias que se plantean. Cada opción será un
control Radiobutton diferente. Se utilizará en los formularios de la aplicación de Ice para
especificar entre un grupo de diferentes opciones, que realizan diversas operaciones.
Un control RadioButton muestra una opción que se puede activar o desactivar, pero con
dependencia del estado de los otros controles existentes en el formulario (ver figura 23).
Generalmente, los controles RadioButton se utilizan para dar a escoger un grupo de
opciones, de las cuales el usuario sólo podrá seleccionar una. Estos controles se pueden
dibujar en el formulario o se pueden agrupar en un panel; aunque para esto en primer
lugar se deberá de dibujar el panel y después se deberán dibujar los RadioButton
deseados, así todos los RadioButton contenidos actuarán como un solo grupo, e
independientes de otros grupos distintos (ver figura 24).
Aunque éste control tiene una similitud con el CheckBox, su diferencia es importante, ya
que como se explicó al principio, al seleccionar una opción RadioButton, las otras
opciones quedaran desactivadas, y con el CheckBox se pueden seleccionar más de una
opción.
ListBox y ComboBox
Figura 25 Señalización dentro del cuadro de herramientas y elección de los controles ComboBox y ListBox; y
su uso dentro de la herramienta Conversor de unidades
Capítulo III Diseño y Desarrollo de la Aplicación
Página 46 Aplicación de software a dispositivos móviles
Se trata de manera conjunta, estos dos controles, dado que tienen grandes similitudes.
Un control ListBox muestra una lista de elementos en los cuales el usuario puede
seleccionar uno o más. Si el número de elementos supera al número que puede
mostrarse, se agrega automáticamente una barra de desplazamiento al control ListBox.
Un control combo box combina las características de un control TextBox y un control
ListBox Los usuarios pueden introducir información en la parte del cuadro de texto y
seleccionar un elemento en la parte de cuadro de lista del control. En resumen, un
ComboBox es la combinación de un ListBox, que se comporta como un ListBox, y de un
TextBox, con comportamiento análogo a un TextBox sencillo, con la particularidad aquí
de que el texto se le puede introducir por teclado, o elegir uno de los que figuran en la
parte ListBox del Combo (ver figura 25).
Panel
Figura 26 Señalización dentro del cuadro de herramientas y elección del control Panel
Figura 27 Uso del Panel dentro de un formulario, en este ejemplo, se tomó el formulario de circuitos
Habilita la opción de agrupar colecciones de controles, es decir, es posible agrupar varios
controles dentro de un mismo panel lo que hace más fácil la organización de algunos
temas dentro de un solo formulario de Smart Device (ver figura 26 y 27).
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 47
MainMenu
Figura 28 Señalización dentro del cuadro de herramientas y elección del control MainMenu
Figura 29 Control MainMenu dentro de una aplicación
Muestra un menú en tiempo de ejecución. Es posible ligar por medio de éste menú hacia
otros formularios (ver figura 28 y 29).
TabControl
Figura 30 Señalización dentro del cuadro de herramientas y elección del control TabControl
Figura 31 TabControl usado para separar los temas en un formulario
Muestra al usuario el contenido mediante una colección de fichas, que pueden contener
diversos controles (ver figuras 30 y 31).
Capítulo III Diseño y Desarrollo de la Aplicación
Página 48 Aplicación de software a dispositivos móviles
PictureBox
Figura 32 Señalización dentro del cuadro de herramientas y elección del control PictureBox
Figura 33 Uso de PictureBox dentro de un formulario
Permite mostrar las imágenes dentro de un formulario (ver figuras 32 y 33).
ProgressBar
Figura 34 Señalización dentro del cuadro de herramientas y elección del control ProgressBar
Figura 35 Funcionamiento del ProgresBar en espera de ejecutar la tarea elegida
El control ProgressBar muestra una barra que marca el progreso de una operación. Es
posible determinar, por parte del programador, el tiempo de ejecución de una operación
(Ver figura 34).
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 49
En los formularios cada uno de estos controles se utilizan para diversas funciones y son
llamados de diversas maneras y programados de acuerdo a la función que desempeñan
dentro de la aplicación (ver figura 35).
3.2.2 Desarrollo de herramientas de apoyo para las aplicaciones de ICE para
Pocket PC
A continuación se describen las distintas herramientas que puede utilizar el usuario al
abrir la aplicación de ICE para Pocket PC y tenga una idea de las herramientas que tiene
como apoyo a sus materias.
Herramienta Amplificadores Operacionales
La elaboración de esta herramienta realiza el cálculo de los elementos pasivos que
describen un amplificador operacional en sus configuraciones básicas. A partir de las
condiciones anteriores de creación de proyectos Smart Device en Visual Estudio se
especifican los pasos para esta aplicación con su correspondiente uso de herramientas.
Las herramientas se desarrollan por separado, cada una es un nuevo proyecto.
Seleccionar proyecto de Smart Device, ya que se va a realizar una aplicación para la
Pocket PC y se le asigna un nombre (en este caso Amplificadores).(ver el ejemplo de la
figura 36)
Seleccionar la Plataforma a utilizar en la Pocket (depende de la versión de Windows
Mobile instalada en la ella) y la versión de .NET Compact Framework (en este caso
versión 3.5, la más actual) (ver figura 37).
Capítulo III Diseño y Desarrollo de la Aplicación
Página 50 Aplicación de software a dispositivos móviles
Figura 36 Creación del nuevo proyecto y las opciones importantes a tomar en cuenta para elegir que la
plataforma de desarrollo será para dispositivo móvil, o bien, Smart Device
Figura 37 Elección de la plataforma destino y versión del Compact Framework Versión 3.5, en éste caso la
versión más actual de Windows Mobile
Una vez creado el proyecto se abre un formulario nuevo, en el cual se muestra en la
parte inferior la herramienta MainMenu, el cual es un menú desplegable. En él se crean
distintas opciones de menú (MenuItem) en la pantalla del emulador. Esta herramienta
siempre está disponible al crear un nuevo formulario, es decir, aparece por default.
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 51
Para etiquetar una opción del menú, éste se selecciona dando clic izquierdo
sobre el MenuItem, y se escribe el nombre deseado, en este caso se etiqueta
“Cerrar” (ver figura 38).
También se puede hacer uso de la ventana de propiedades que está al lado
derecho de la ventana donde se muestra el formulario, ahí aparecen diversas
propiedades en la propiedad Text, se le da el nombre “Cerrar” (ver figura 39).
Figura 38 Figura del Emulador, donde se muestra que el formulario incluye un MainMenu
Figura 39 Ventana de propiedades dentro de Visual Studio 2008
Para programar una acción al menuItem (Cerrar), se da doble clic sobre éste.
Capítulo III Diseño y Desarrollo de la Aplicación
Página 52 Aplicación de software a dispositivos móviles
Se genera un código para el cual se agrega la instrucción this.Close(), tal como se
muestra en el siguiente ejemplo, ésta instrucción permite cerrar el formulario.
private void menuItem1_Click(object sender, EventArgs e)
{
this.Close();
}
Se procede a utilizar otras herramientas para complementar el formulario.
Nota: la elección de herramientas de diseño, depende de la creatividad del programador
y de las funciones específicas que requiera.
Para esta aplicación se usa la herramienta ControlTab y se generan dos fichas
de separación, una se llama Inversor y otra No Inversor, para los dos casos de
amplificadores que se elaboran.
Para agregar fichas se selecciona el ControlTab y en la ventana de Propiedades
TabPage Agregar, se agregan dos fichas.
En las propiedades de cada tabPage se introduce el texto que mostrará cada
ficha (ver el ejemplo de la figura 40).
Figura 40 Ventana que muestra las propiedades de edición al utilizar el control TabControl
Las siguientes herramientas o controles (labels, textbox, picturebox, button) se introducen
en cada ficha.
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 53
Los Label‟s se usan para escribir la información en pantalla de los textbox que se
van a utilizar, y de alguna manera le dan información al usuario y le indican que
introducir en cada TextBox.
Los TextBox se utilizan para introducir los valores que se calcularán en el evento
de un botón que se llamará “Calcula” y para los valores que nos resultan de las
acciones realizadas.
Los nombres de los TextBox (propiedadesname) serán vi, vo, rf1, av, ri.
La herramienta PictureBox será para mostrar la imagen del circuito que se
calcula.
Para agregar la imagen desde la ventana de Propiedades se da clic en la
propiedad image y se selecciona la ubicación de la imagen que se desea mostrar
(ver figura 41).
Figura 41 Elección de la imagen a insertar en un control PictureBox
En esta ventana se selecciona la imagen y se cargará en la ubicación del
PictureBox como se muestra en la ventana del formulario (figura 42).
Capítulo III Diseño y Desarrollo de la Aplicación
Página 54 Aplicación de software a dispositivos móviles
Figura 42 PictureBox dentro de una herramienta de apoyo de la aplicación de ICE
Una vez diseñada la interfaz de la herramienta se procede a programar el botón “Calcula”
haciendo doble clic sobre el botón para generar el evento y se introducen las siguientes
instrucciones, al programar este botón se le indicarán las operaciones que deberá realizar
para mostrar los resultados deseados.
private void button1_Click(object sender, EventArgs e)
{
double v1, v2, RF, a, b;
try //se usa para atrapar errores de
implementacion
{
v1 = double.Parse(vi.Text);
v2 = double.Parse(vo.Text);
RF = double.Parse(rf1.Text);
a = v2 / v1;
av.Text = a.ToString();
b = RF / a;
ri.Text = b.ToString();
}
// catch se utiliza para mostrar un mensaje de error en
pantalla
catch {
MessageBox.Show("Introduce valores
válidos");
}
}
Después de haber hecho esto en la ficha “Inversor”, se da clic en la siguiente ficha “No
inversor” y se realizan los mismos pasos pero ahora para el no inversor.
PictureBox
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 55
La diferencia es, en el evento del botón, cambiará el código por lo siguiente:
private void calc_Click(object sender, EventArgs e)
{
double v1, v2, RF, a, b;
try
{
v1 = double.Parse(vi2.Text);
v2 = double.Parse(vo2.Text);
RF = double.Parse(rf2.Text);
a = (v1 * RF) / (v2 - v1);
ri2.Text = a.ToString();
b = (1 + RF) / a;
av2.Text = b.ToString();
}
catch
{
MessageBox.Show("Introduce valores
válidos");
}
}
Conversión de Complejos
Esta herramienta realiza la conversión de un número complejo en su forma polar a
cartesiana y viceversa.
Se crea un proyecto nuevo de Smart Device Visual Studio de nombre complex, cabe
mencionar que el programador puede asignar nombres diferentes a los proyectos
creados, y a continuacion se comienza a crear la interfaz de la pequeña aplicación.
Con ayuda de la herramienta ControlTab en el cual se generan dos fichas, las cuales, se
etiquetan como “Forma Cartesiana a Polar” y “Forma Polar a Cartesiana” tal como se
muestra en la figura 43, para hacer referencia al usuario del tipo de conversion que hace
cada seccion del programa.
Se hace uso de las herramientas label para cada uno de los textos que se muestran al
usuario en la aplicación, TextBox para la entrada de datos dados por el usuario, Button
para ejecutar la accion correspondiente al realizar la conversion y PictureBox para
establecer la imagen de fondo de la aplicación.
Capítulo III Diseño y Desarrollo de la Aplicación
Página 56 Aplicación de software a dispositivos móviles
Figura 43 Interfaz de la herramienta de Conversión de complejos y el uso de etiquetas para nombrar a los
TextBox utilizados
Se etiquetan los textbox y se programan los eventos de cada botón.
En el primer botón llamado “Limpiar” se escribe el siguiente codigo para borrar el
contenido de los textbox.
private void button3_Click(object sender, EventArgs e)
{
mag2.Text = "";
ang2.Text = "";
real2.Text = "";
imag2.Text = "";
}
En el segundo botón llamado “convertir” se escribe el siguiente codigo para realizar las
operaciones de números complejos y se mostrarán en los textbox restantes.
private void button1_Click(object sender, EventArgs e)
{
try
{
a = double.Parse(Real.Text);
b = double.Parse(Imag.Text);
d = Math.Pow(a, 2) + Math.Pow(b, 2);
r = Math.Sqrt(d);
c = Math.Atan(b / a);
f = ((c * 180) / Math.PI);
Mag.Text = r.ToString();
Ang.Text = f.ToString();
}
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 57
catch { MessageBox.Show("introduce un
numero imaginario valido a+bi"); }
}
Para la ficha “Forma Polar a Cartesiana” se aplica el mismo diseño y aplicación de
herramientas que en la ficha anterior.
En el botón convertir se utilizará ahora el código correspondiente a la conversión de un
número expresado en su forma polar a cartesiana.
private void button4_Click(object sender, EventArgs e)
{
try
{
a2 = double.Parse(mag2.Text);
b = double.Parse(ang2.Text);
c = ((b * Math.PI) / 180);
d = a2*Math.Cos(c);
r = a2*Math.Sin(c);
real2.Text = d.ToString();
imag2.Text = r.ToString();
}
catch { MessageBox.Show("introduce un
numero o angulo validos"); }
}
Operaciones básicas de matrices
Esta herramienta sirve para poder realizar operaciones de matrices. El usuario introduce
2 matrices (A y B) y en la tercera (C) se muestra el resultado de la operación que se le
aplicó a las matrices A y B.
Crear un nuevo proyecto.
Seleccionar herramientas a utilizar. Radiobutton, label, panel, picturebox, textbox, button.
Los radiobutton permiten seleccionar distintas operaciones a realizar.
El panel sirve para agrupar una serie de elementos o funciones.
El área del picturebox puede ser usada como área de dibujo y/o para mostrar un
resultado.
Diseñar interfaz (ver figura 44)
Establecer nombres de las herramientas con la propiedad Name.
Capítulo III Diseño y Desarrollo de la Aplicación
Página 58 Aplicación de software a dispositivos móviles
Figura 44 Interfaz de la herramienta Matrices y señalización de los diferentes controles que utiliza
Una vez terminado el diseño de la interfaz y de etiquetar los objetos, se programan los
botones.
Antes de programar los botones se inicializan variables.
private double[,] a;
private double[,] b;
private double[,] c;
private double[,] d;
private int m, n, fi, co;
public matriz()
{
InitializeComponent();
}
Para el botón “Tamaño” se le agrega el còdigo que determina el tamaño de las matrices
a introducir.
private void tamaño_Click(object sender, EventArgs e)
{
try
{
m = Int32.Parse(cm.Text);
n = Int32.Parse(cn.Text);
a = new double[m, n];
Especificación del tamaño de la
matriz a insertar
Inserción de los elementos de
la matriz
Elección de la matriz a insertar
Espacio para mostrar las
matrices insertadas y el
resultado de las operaciones
realizadas
Elección de las operaciones a
realizar
Botón para leer los elementos
insertados
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 59
b = new double[m, n];
c = new double[m, n];
d = new double[m, n];
}
catch { MessageBox.Show("losvalores deben
ser numericos o validos"); }
}
Para el botón “Leer” se debe agregar el siguiente código que permite leer los elementos
de la matriz en los textbox correspondientes.
private void button1_Click(object sender, EventArgs e)
{
if (matA.Checked)
{
fi = Int32.Parse(fila.Text);
co = Int32.Parse(col.Text);
a[fi, co] = Double.Parse(elemento.Text);
}
if (matB.Checked)
{
fi = Int32.Parse(fila.Text);
co = Int32.Parse(col.Text);
b[fi, co] = Double.Parse(elemento.Text);
}
}
En el botón “Operación” se deberán obtener todas las operaciones báscias de las
matrices introducidas en los radiobutton (tal como se muestra en el siguiente código).
private void
button3_Click(object sender,
EventArgs e)
{
try
{
if (suma.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[i, j] + b[i, j];
}
}
}
if (resta.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[i, j] - b[i, j];
}
}
}
if (producto.Checked)
{
int l = m;
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = 0;
for (int k = 0; k < l; k++)
{
c[i, j] += a[i, k] * b[k, j];
}
}
}
}
if
(transpuesta.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[j, i];
}
}
Capítulo III Diseño y Desarrollo de la Aplicación
Página 60 Aplicación de software a dispositivos móviles
}
if
(transpuestaB.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = b[j, i];
}
}
}
if (suma1.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
d[i, j] = b[j, i];
}
}
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[i, j] + d[i, j];
}
}
}
if (suma2.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
d[i, j] = a[j, i];
}
}
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[i, j] + d[i, j];
}
}
}
if (resta1.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
d[i, j] = b[j, i];
}
}
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i,
j] = a[i, j] - d[i, j];
}
}
}
if
(resta2.Checked)
{
for (int i =
0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
d[i, j] = a[j, i];
}
}
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[i, j] - d[i, j];
}
}
}
if (multiplica1.Checked)
{
int l = m;
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
d[i, j] = b[j, i];
}
}
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = 0;
for (int k = 0; k < l; k++)
{
c[i, j] += a[i, k] * d[k, j];
}
}
}
}
if (multiplica2.Checked)
{
int l = m;
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
d[i, j] = a[j, i];
}
}
for (int i = 0; i < m; i++)
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 61
{
for (int j = 0; j < n; j++)
{
c[i, j] = 0;
for (int k = 0; k < l; k++)
{
c[i, j] += d[i, k] * b[k, j];
}
}
}
}
if (opuesta1.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[i, j] * -1;
}
}
}
if
(opuesta2.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = b[i, j] * -1;
}
}
}
if (nula.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[i, j] * 0;
}
}
}
if (a2.Checked)
{
for (int i =
0; i < m; i++)
{
for (int
j = 0; j < n; j++)
{
c[i,
j] = a[i, j] * a[i, j];
}
}
}
if (b2.Checked)
{
for (int i = 0; i < m; i++)
{
for (int
j = 0; j < n; j++)
{
c[i,
j] = b[i, j] * b[i, j];
}
}
}
if (d1.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if (i == j)
{
c[i, j] = a[i, j];
}
else
{
c[i, j] = 0;
}
}
}
}
if (d2.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if (i == j)
{
c[i, j] = b[i, j];
}
else
{
c[i, j] = 0;
}
}
}
}
}
catch {
MessageBox.Show("elige una
operacion para aplicar el
resultado en C");
}
}
Capítulo III Diseño y Desarrollo de la Aplicación
Página 62 Aplicación de software a dispositivos móviles
Posteriormente visualizar los resultados de las operaciones con el botón “Poner” y al mismo tiempo se visualiza la matriz resultante en el área del picturebox. Este botón se programa de la siguiente manera:
private void button2_Click(object sender, EventArgs e)
{
try
{
string tam = "";
if (matA.Checked)
{
fi = Int32.Parse(cm.Text);
co = Int32.Parse(cn.Text);
mat.Items.Add("Mat A");
for (int i = 0; i < fi; i++)
{
for (int j = 0; j < co; j++)
{
tam += a[i, j].ToString() + "";
}
mat.Items.Add(tam);
tam = "";
}
}
if (matB.Checked)
{
fi = Int32.Parse(cm.Text);
co = Int32.Parse(cn.Text);
mat.Items.Add("Mat B");
for (int i = 0; i < fi; i++)
{
for (int j = 0; j < co; j++)
{
tam += b[i, j].ToString() + "";
}
mat.Items.Add(tam);
tam = "";
}
}
if (matC.Checked)
{
mat.Items.Add("Mat C");
for (int i = 0; i < fi; i++)
{
for (int j = 0; j < co; j++)
{
tam += c[i, j].ToString() + "";
}
mat.Items.Add(tam);
tam = "";
}
}
}
catch { MessageBox.Show("selecciona alguna matriz para leer
los valores"); }
}
Por último generar la aplicación y comprobar el funcionamiento.
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 63
Herramienta de código de colores y tabla de resistencias
Esta herramienta le permite al usuario saber el color perteneciente a la resistencia que
necesite, el usuario encontrará el código de color de cualquier resistencia en su valor
comercial.
En un proyecto nuevo de Smart Device Visual Studio de nombre “resistencias”, cabe
mencionar que el programador puede asignar nombres diferentes a los proyectos
creados, el nombre que coloque el programador será el nombre de la clase, y a
continuación se comienza a crear la interfaz de la pequeña aplicación.
Se hace uso de los controles Panel para guardar los controles, TextBox para visualizar el
valor de la resistencia, ComboBox y RadioButton para visualizar los valores comerciales
así como el valor de la tolerancia y el valor multiplicativo de cada resistencia a elegir por
el usuario; además se hará uso de los controles Label para que el usuario tenga
información de la aplicación y le oriente sobre su uso, aunque el texto y diseño queda a
criterio del programador, de cómo desee mostrar la interfaz de lo que desea mostrar.
Como se observa en la figura 45 se utilizan los labels, dos controles ComboBox para
resistencia y tolerancia; ocho RadioButton para que el usuario tenga opción de
seleccionar los multiplicativos de las resistencias, y un TextBox para visualizar el valor
comercial, además del control MenuMain que se encuentra en el formulario.
Figura 45 Interfaz de la herramienta Resistencias
Capítulo III Diseño y Desarrollo de la Aplicación
Página 64 Aplicación de software a dispositivos móviles
Ahora se inserta un objeto donde se visualizará el código de color del valor de la
resistencia comercial por lo que se utilizará un PictureBox.
Y una vez agregado el PictureBox se arrastran dos botones al formulario que tienen como
eventos visualizar el valor en el Textbox y el código de colores; mientras que en el otro se
hace un vínculo hacia otro panel que tendrá en un PictureBox una tabla de resistencias.
Quedando como se muestra en la figura 46:
Figura 46 Inserción de PictureBox dentro de la herramienta Resistencias, lo cual ayuda a la mejor
comprensión del tema
Con haber creado esta interfaz, se introducen los valores de las resistencias y los valores
de las tolerancias dentro de los ComboBox.
Se selecciona el primer ComboBox que se ha nombrado como “valores” y en la
parte superior de este control se muestra una flechita; hacemos clic sobre ella y
se ven las opciones: Utilizar elementos enlazados a datos y Editar elementos (ver
figura 47).
Seleccionar Editar elementos y se escriben los valores comerciales sin su
multiplicativo (ver figura 48).
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 65
Figura 47 Edición y configuración de elementos del control ComboBox
Figura 48 Inserción de los elementos del ComboBox
Ya introducidos los elementos, se da clic en Aceptar
Para el segundo ComboBox que se nombra como “tolerancia” se realizan los
pasos anteriores para insertar los elementos con los valores 1, 2, 5 y 10% y
Aceptar.
Una vez insertados los elementos y haber nombrado cada control, a usar, se
procede a hacer el contenido del PictureBox, es decir, el dibujo de la resistencia.
En el menú Propiedades se hace clic sobre el icono en forma de rayo (ver figura 49), que indica los eventos disponibles, y se configura el evento que indique que, al iniciar la aplicación muestre en pantalla de inicio el dibujo, sin necesidad de algún evento de invocación para generarlo en el área del PictureBox.
Capítulo III Diseño y Desarrollo de la Aplicación
Página 66 Aplicación de software a dispositivos móviles
Figura 49 Ventana de propiedades para la configuración de los controles
Se busca el evento Paint y se da doble clic sobre este, ahí se introducirá el siguiente código que será el dibujo de la resistencia:
private void res_Paint(object sender, PaintEventArgs e)
{
Graphics gr = res.CreateGraphics();
Pen negro = new Pen(Color.Black);
Pen azul = new Pen(Color.CadetBlue);
negro.Width = 4.0F;
azul.Width = 3.0F;
gr.DrawRectangle(negro,new Rectangle(50,15,120,60));
gr.DrawLine(negro, 5, 50, 50, 50);
gr.DrawLine(negro, 170, 50, 210, 50);
gr.DrawRectangle(azul, new Rectangle(55, 18,20,53));
gr.DrawRectangle(azul, new Rectangle(85, 18, 20, 53));
gr.DrawRectangle(azul, new Rectangle(115, 18, 20, 53));
gr.DrawRectangle(azul, new Rectangle(145, 18, 20, 53));
}
A continuación se programan los eventos del primer botón llamado “visualizar”.
Se da doble clic sobre este botón y se definen las variables a usar así como se
define al PictureBox como objeto para que sea editable en cada evento del
botón.
private void visualiza_Click(object sender, EventArgs e)
{
double r;
Graphics gr = res.CreateGraphics();
}
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 67
Ahora es necesario definir los colores que se desean visualizar en cada línea de color de
la resistencia; para lo que se codifica de la siguiente manera:
SolidBrush beige = new SolidBrush(Color.Beige);
SolidBrush negro1=new SolidBrush(Color.Black);
SolidBrush cafe = new SolidBrush(Color.Brown);
SolidBrush rojo = new SolidBrush(Color.Red);
SolidBrush naranja = new SolidBrush(Color.Orange);
SolidBrush amarillo = new SolidBrush(Color.Yellow);
SolidBrush verde = new SolidBrush(Color.Green);
SolidBrush azul1 = new SolidBrush(Color.Blue);
SolidBrush morado = new SolidBrush(Color.Purple);
SolidBrush gris = new SolidBrush(Color.Gray);
SolidBrush blanco = new SolidBrush(Color.White);
SolidBrush dorado = new SolidBrush(Color.Gold);
SolidBrush plata = new SolidBrush(Color.Silver);
Pen negro2 = new Pen(Color.Black);
Pen azul2 = new Pen(Color.CadetBlue);
negro2.Width = 4.0F;
azul2.Width = 3.0F;
Continuando con la creación de las resistencias se hace uso de los ya nombrados
ComboBox y los RadioButton para lo que se escribe el código que permite la
visualización de la resistencia seleccionada en el dibujo del PictureBox.
try
{
switch (valores.SelectedItem.ToString())
{
case "1":
if (rd1.Checked)
{
// 1 ohm
r = 1;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(negro1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
}
if (rd2.Checked)
{
// 10 ohm
r = 10;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(negro1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(negro1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd3.Checked)
{
Capítulo III Diseño y Desarrollo de la Aplicación
Página 68 Aplicación de software a dispositivos móviles
// 100 ohm
r = 100;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(negro1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(cafe, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd4.Checked)
{
//1 kohm
r = 1000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(negro1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(rojo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd5.Checked)
{
//10 kohm
r = 10000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(negro1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(naranja, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd6.Checked)
{
//100 kohm
r = 100000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(negro1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(amarillo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd7.Checked)
{
//1 Mohm
r = 1000000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(negro1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(verde, 115, 18, 20, 53);
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 69
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd8.Checked)
{
//10 Mohm
r = 10000000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(negro1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(azul1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
break;
Este código es solo para el primer valor del ComboBox “valores”. Consulte el apéndice de
la herramienta Resistencias para ver la otra parte del código.
Después de crear los eventos del botón “Visualizar”, se crea otro panel en el cual se
introduce un PictureBox en el cual se ve una tabla de resistencias en caso de ser
necesaria.
Este panel irá por detrás del primer panel en donde se encuentra lo antes elaborado. Ahí
se da clic derecho sobre el panel Enviar al fondo (ver figura 50).
Figura 50 Organización de los paneles dentro de un formulario, envío hacia el frente o hacia atrás según
convenga, al momento de mostrar la información
Capítulo III Diseño y Desarrollo de la Aplicación
Página 70 Aplicación de software a dispositivos móviles
El botón Cerrar tabla es sólo para cerrar el panel y volver al primer panel, aunque el
código en este botón es diferente porque no se pretende cerrar el formulario sino mandar
al frente el primer panel. Este código es:
private void cetabla_Click(object sender, EventArgs e) { t1.BringToFront(); }
Por último sólo falta programar el segundo botón del primer panel (t1) llamado “tabla” en
el sólo se da el evento que mande al frente el segundo panel (t2) con el siguiente código:
private void button2_Click(object sender, EventArgs e) { t2.BringToFront(); }
Diseño de una compuerta RTL
Esta herramienta le permite al usuario estudiante de ICE poder diseñar una compuerta
RTL que es aplicada dentro de la electrónica y que le da al usuario en sencillos pasos la
facilidad de saber que resistencias utilizar para el buen funcionamiento de esta
compuerta.
En nuevo proyecto de Smart Device Visual Studio de nombre compuerta_RTL. A
continuacion se hace uso de los controles Textbox, button y label.
Primero se hace configuración del MainMenu que sale de inicio abajo del formulario y se
le crea el evento cerrar.
Para la creación de la interfaz se necesita saber que valores serán pedidos al usuario
para lo que se tienen las variables Iihmax, Iilmax, hFE, F.O., F.S. (éstas son introducidas
por el usuario); cabe recalcar que el usuario debe tener conocimientos de electrónica
para entender estos términos que son esenciales para el diseño de esta compuerta.
Una vez definidos los valores que serán pedidos al usuario se añaden los textbox
convenientes para estos cálculos. Se arrastran de la barra de herramientas, cinco
controles TextBox asi como la inserción de labels para mostrar la información de
lo que se introducirá en estos TextBox (ver figura 51).
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 71
También se introduce un botón, al cual se le nombra “Diseñar”, en el que se
hacen los cálculos que se muestran en otros TextBox.
Figura 51 Diseño de interfaz de la herramienta de diseño de compuerta RTL
La compuerta RTL necesita el cálculo de Rb, Rc, Rioh y Riol para lo cual se
necesitan otros textbox (ver figura 52) donde se arrojan dichos resultados de los
cálculos efectuados en el botón “Diseñar”.
Capítulo III Diseño y Desarrollo de la Aplicación
Página 72 Aplicación de software a dispositivos móviles
Figura 52 Inserción de TextBox para mostrar los resultados una vez ejecutadas las operaciones al pulsar el
botón Diseñar
Una vez teniendo donde poner los resultados se hace el cálculo con los valores
pedidos al usuario.
Para esto se da doble clic sobre el botón “Diseñar” y se programa el siguiente
código:
private void diseñar_Click(object sender, EventArgs e)
{
double Iihmax, Iilmax, fo, fs, hfe, iohmax,
iolmax, Rioh, Riol, rc, rb, Irc, Ics, Ibts, Ibs, Irioh,
Iriol;
try
{
Iihmax = double.Parse(v1.Text);
Iilmax = double.Parse(v2.Text);
hfe = double.Parse(v3.Text);
fo = double.Parse(v4.Text);
fs = double.Parse(v5.Text);
iohmax = fo * Iihmax;
iolmax = fo * Iilmax;
//voh=4.4v
rc = (5 - 4.4) / iohmax;
Irc = (5 - .1) / rc;
Rioh = 4.4 / iohmax;
Ics = Irc - iolmax;
Ibts = Ics / hfe;
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 73
Ibs = fs * Ibts;
rb = (3.4 - 0.7) / Ibs;
Irioh = 0.1 / Rioh;
Iriol = iolmax + Irioh;
Riol = Math.Abs((5 - .8) / Iriol);
v6.Text = rb.ToString();
v7.Text = Rioh.ToString();
v8.Text = rc.ToString();
v9.Text = Riol.ToString();
}
catch
{
MessageBox.Show("Valores no validos");
v1.Text = "";
v2.Text = "";
v3.Text = "";
v4.Text = "";
v5.Text = "";
}
}
Con esto se obtienen los valores necesarios para hace una compuerta RTL.
Ahora lo que se agregan los controles, botones; uno para ver el circuito y otro
para limpiar los valores de todos los TextBox (ver figura 53).
Figura 53 Inserción de los botones que muestran el circuito y otro que borra los valores insertados en los
TextBox
Primero se programa el botón “limpiar” con el código para borrar el contenido de
los TextBox.
Capítulo III Diseño y Desarrollo de la Aplicación
Página 74 Aplicación de software a dispositivos móviles
private void limpiar_Click(object sender, EventArgs e)
{
v1.Text = "";
v2.Text = "";
v3.Text = "";
v4.Text = "";
v5.Text = "";
v6.Text = "";
v7.Text = "";
v8.Text = "";
v9.Text = "";
}
Y para el segundo botón, primero se debe hacer un panel en el que se tendrá la
figura del circuito y un botón para regresar a la vista anterior. Se Introduce la
imagen dentro del PictureBox y en el botón se escribe el codigo:
private void regresa_Click(object sender, EventArgs e)
{
p1.BringToFront();
}
Con este código se manda a llamar al panel principal que tiene los valores de la
compuerta. Antes de hacer esto cabe recordar que el panel que se muestra en la
imagen deberá mandarse al fondo con clic derecho sobre el PictureBox y clic en
enviar al fondo (ver figura 54).
Figura 54 Manejo de lo paneles para organizar la información mostrada dentro de la herramienta
Ahora en la vista del panel principal se escribe el código para mandar a llamar el
segundo panel en el botón “Ver Circuito” el cual será:
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 75
private void visualiza_Click(object sender, EventArgs e) { p2.BringToFront(); }
Convertidor de unidades
Esta herramienta le permite al usuario hacer la conversión de un número a otro en base
al sistema numérico que elija.
En un proyecto nuevo de Smart Device, el cual se titula convertidor, a continuación se
crea la interfaz de usuario.
Se crea la interfaz utilizando los controles Button, Textbox, ComboBox y labels
estos contienen la información que se le muestra al usuario.
Se programa el MainMenu que automáticamente se genera al crear el formulario,
aparece al principio para cerrar el formulario.
Se introducen los controles en el formulario, la elección de éstos, depende de
cada programador, para este caso se colocó un ComboBox llamado “nunidades”
que será el que tendrá como elementos los nombres de las unidades de medida:
Longitud, Peso, Presión, Temperatura, Potencia.
Se agrega otro ComboBox al cual se le llama “Longitud” y que tiene como
elementos las unidades del ComboBox “nunidades”, otro textbox para visualizar
el valor convertido y un botón que se programa de manera que haga las
conversiones necesarias y muestre el resultado en el TextBox de conversión.
(ver figura 55).
Capítulo III Diseño y Desarrollo de la Aplicación
Página 76 Aplicación de software a dispositivos móviles
Figura 55 Diseño de la herramienta conversor de unidades y la inserción de los controles ComboBox para
elección de las unidades a convertir
La interfaz queda ya terminada, se le coloca una decoración de un fondo
que se introduce mediante un PictureBox. Esto es opcional ya que cada
programador tiene su estilo y le puede dar la forma y colores que desee.
La vista de cómo queda se muestra en la figura 56.
Figura 56 Inserción del botón Convertir, dentro de la interfaz del formulario
Ya teniendo la interfaz terminada se procede a programar el botón; el
código que se plantea a continuación es solo una parte, el código
completo se encuentra dentro de los apéndices:
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 77
private void conv_Click(object sender, EventArgs e)
{
try
{
if (longitud.SelectedIndex == 0)//km-m
{
a = double.Parse(valor.Text);
r = a * 1000;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 1)//km-cm
{
a = double.Parse(valor.Text);
r = a * 100000;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 2)//km-dm
{
a = double.Parse(valor.Text);
r = a * 10000;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 3)//km-mm
{
a = double.Parse(valor.Text);
r = a * 1000000;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 4)//km-pulg
{
a = double.Parse(valor.Text);
r = a * 39370.07874;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 5)//km-yarda
{
a = double.Parse(valor.Text);
r = a * 1093.613298;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 6)//m-km
{
a = double.Parse(valor.Text);
r = a * .001;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 7)//m-cm
{
a = double.Parse(valor.Text);
r = a * 100;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 8)//m-dm
{
a = double.Parse(valor.Text);
r = a * 10;
res.Text = r.ToString();
Capítulo III Diseño y Desarrollo de la Aplicación
Página 78 Aplicación de software a dispositivos móviles
}
if (longitud.SelectedIndex == 9)//m-mm
{
a = double.Parse(valor.Text);
r = a * 1000;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 10)//m-pulg
{
a = double.Parse(valor.Text);
r = a * 39.370079;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 11)//m-yarda
{
a = double.Parse(valor.Text);
r = a * 1.093613;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 12)//cm-km
{
a = double.Parse(valor.Text);
r = a * .000001;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 13)//cm-m
{
a = double.Parse(valor.Text);
r = a * .01;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 14)//cm-dm
{
a = double.Parse(valor.Text);
r = a * .1;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 15)//cm-mm
{
a = double.Parse(valor.Text);
r = a * 10;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 16)//dm-km
{
a = double.Parse(valor.Text);
r = a * 0.0001;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 17)//dm-m
{
a = double.Parse(valor.Text);
r = a * 0.1;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 18)//dm-cm
{
a = double.Parse(valor.Text);
r = a * 10;
res.Text = r.ToString();
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 79
}
if (longitud.SelectedIndex == 19)//dm-mm
{
a = double.Parse(valor.Text);
r = a * 100;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 20)//mm-km
{
a = double.Parse(valor.Text);
r = a * .0000001;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 21)//mm-m
{
a = double.Parse(valor.Text);
r = a * .001;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 22)//mm-cm
{
a = double.Parse(valor.Text);
r = a * .1;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 23)//mm-dm
{
a = double.Parse(valor.Text);
r = a * .01;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 24)//pulg-km
{
a = double.Parse(valor.Text);
r = a * .0000254;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 25)//pulg-m
{
a = double.Parse(valor.Text);
r = a * 0.0254;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 26)//pulg-cm
{
a = double.Parse(valor.Text);
r = a * 2.54;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 27)//pulg-dm
{
a = double.Parse(valor.Text);
r = a * 0.254;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 28)//pulg-mm
{
a = double.Parse(valor.Text);
r = a * 25.4;
res.Text = r.ToString();
Capítulo III Diseño y Desarrollo de la Aplicación
Página 80 Aplicación de software a dispositivos móviles
}
Como se observa en el código solo se hace la conversión de las unidades
de longitud que tiene el ComboBox “nunidades”.
Ahora se utiliza otro ComboBox de la barra de herramientas y se le da
otro nombre en el que se ingresarán las unidades de otro elemento del
ComboBox “nunidades”; cabe mencionar que estos se deben poner
encima del segundo ComboBox ”Longitud” para que no se observen
desordenados. Esto se hace para cada elemento que tiene el primer
ComboBox.
En la figura 57 se observan los cinco ComboBox a utilizar, desordenados;
se deben poner uno encima del otro para tener mejor estética y evitar
confusión en el usuario. Y en la figura 57.1 se observa un solo ComboBox
aunque todos están encimados sin que se note.
Figura 57 ComboBox Desordenados Figura 57.1 ComboBox ordenados
Como cada ComboBox es nombrado diferente y con diferentes elementos el código solo
se anexa al botón.
Ahora bien para que la aplicación funcione bien y se muestre sólo el ComboBox con las
unidades del elemento seleccionado en el ComboBox “nunidades”:
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 81
Primero se da clic derecho en el ComboBox que quedo por encima de los demás y se
manda hacia el fondo, se mostrará otro ComboBox y hacemos lo mismo, hasta llegar al
ComboBox “Longitud” que se hizo y ese se deja en frente.
Este ComboBox será el que tenga los elementos de las unidades de longitud.
Ahora para que se muestre el ComboBox con los elementos que le corresponden a cada
elemento del ComboBox “nunidades” se deberá poner el código siguiente dando doble
clic sobre el ComboBox “nunidades”.
private void nunidades_SelectedIndexChanged(object
sender, EventArgs e)
{
longitud.Visible = false;
peso.Visible = false;
presion.Visible = false;
temperatura.Visible = false;
potencia.Visible = false;
if (n_unidades.SelectedIndex == 0)
longitud.Visible = true;
if (n_unidades.SelectedIndex == 1)
peso.Visible = true;
if (n_unidades.SelectedIndex == 2)
presion.Visible = true;
if (n_unidades.SelectedIndex == 3)
temperatura.Visible = true;
if (n_unidades.SelectedIndex == 4)
potencia.Visible = true;
}
Con este código se pone cada Combobox que contiene las unidades en modo invisible y
solo se muestran cuando el usuario selecciona un elemento del ComboBox “nunidades”.
Ahora verá en la implementación como sólo se mostrará el ComboBox del elemento
seleccionado del primer ComboBox “nunidades”.
3.2.3 Diseño de la interfaz
Visual Studio 2008, permite la creación de ambientes gráficos de manera fácil y sencilla,
permitiendo el uso de herramientas propias de la aplicación, más adelante se explica
cómo estas herramientas son adaptadas al Pocket PC.
Capítulo III Diseño y Desarrollo de la Aplicación
Página 82 Aplicación de software a dispositivos móviles
Se agregaron herramientas de diseño tales como Labels, main menu, progress bar, entre
otras que ayudan a tener un mejor entendimiento y facilidad en la navegación de los
temas.
Diseño general de la aplicación
En primera instancia se observa el diseño de la portada de la aplicación y el título (ver
figura 58). Se hace clic en entrar para hacer uso de los diferentes formularios.
Figura 58 Diseño principal de la interfaz de la aplicación de ICE
Se muestra el menú de materias (las cuales corresponden a materias básicas de tronco
común) (ver figura 59).
Figura 59 Interfaz y organización de los formularios realizados
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 83
Se puede dar clic en cualquiera de las materias citadas, en el ejemplo de la figura 60, se
navegará sobre el formulario de circuitos digitales, a fin de conocer la interfaz grafica y los
menús con los que cuenta la aplicación. Se muestra la portada principal del formulario y
dos opciones, si se pulsa salir nos salimos del formulario y regresamos al menú principal
de materias. Si se pulsa entrar tenemos acceso a los temas desarrollados.
Figura 60 Interfaz del formulario de Circuitos digitales
Al entrar al formulario, el sistema es tan amigable que siempre guía al usuario sobre qué
hacer para ver los temas, tiene indicaciones especificadas en color azul.
Los temas son mostrados a manera de árbol y se debe de hacer clic sobre el tema
principal para tener acceso a la información (ver figura 61).
Capítulo III Diseño y Desarrollo de la Aplicación
Página 84 Aplicación de software a dispositivos móviles
Figura 61 Inserción del control TreeView y organización de los temas pertenecientes a la materia de circuitos
digitales
Se muestra la información en diferente ventanas (se divide en paneles, cada uno de los
subtemas) (ver figura 62).
Figura 62 Organización y navegación en la información mostrada, referente a la materia
Cada tema tiene sencillos ejemplos, para el mejor entendimiento de los temas. Como en
éste caso (ver figura 63), se muestran ejemplos definidos de la representación de
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 85
números en diferentes bases. Se pueden consultar las herramientas y se puede
encontrar una aplicación que hace conversiones a diferentes bases y unidades a partir de
los datos dados por el usuario.
Figura 63 Ejemplos de apoyo a los temas mostrados en los diferentes formularios, este ejemplo corresponde al
formulario de Circuitos digitales
Se pueden encontrar también en los formularios la explicación de diversos dispositivos
electrónicos. Por ejemplo, en el formulario se puede visualizar la explicación de las
compuertas lógicas y se puede tener acceso, a lo que se pudiera llamar una parte de la
hoja de especificación, en donde se puede ver la forma de conexión de los dispositivos,
tal como se muestra (ver figura 64).
Capítulo III Diseño y Desarrollo de la Aplicación
Página 86 Aplicación de software a dispositivos móviles
Figura 64 Tablas de verdad y hojas de especificación de algunos dispositivos de circuitos digitales.
Se puede observar en la parte inferior de la pantalla dos botones: opciones y cerrar. Si se
pulsa cerrar se sale automáticamente de la aplicación; si se pulsa opciones, se tiene un
menú, cuyas opciones son:
Salir de la aplicación, se sale en automático de la aplicación y se regresa a la ventana
principal de la aplicación.
Ir al temario, regresa al temario principal del formulario (ver figura 65).
Figura 65 Demostración del apoyo de los Controles para salir o regresar a los temarios principales
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 87
Regresando al menú principal de la aplicación, se cuenta con diversas herramientas
básicas de apoyo al estudiante de ingeniería en comunicaciones y electrónica, cuya
interfaz está desarrollada igual que las interfaces, de las cuales se habló anteriormente.
A continuación se muestra el diseño de algunas de éstas herramientas y la manera de
interactuar con las mismas, dentro de la aplicación.
Figura 66 interfaz y organización de la herramientas de apoyo para la aplicación de ICE
Las herramientas constan de una interfaz sencilla (ver figura 66), pero cada herramienta
tiene funciones diferentes, así bien, se tiene la herramienta Amplificadores (ver figura
67), la cual resuelve y diseña amplificadores inversores y no inversores; herramienta
calculadora, es una calculadora científica; matrices (ver figura 68), resuelve operaciones
con matrices, conversión de complejos, conversión de unidades, conversión de bases
(ver figura 69), diseño de compuerta RTL, Resistencias comerciales y diseño de redes
RC (Pasa Altas y Pasa Bajas).
Básicamente las herramientas cuentan con las funciones que realizan cada una,
contienen imágenes que ilustran el diseño de los circuitos que se están diseñando; esto
para complementar el conocimiento respecto a los temas y problemas planteados.
Las interfaces contienen, en lo que es su diseño, TextBox (cajas de texto), Labels
(etiquetas), PictureBox (Cajas con imágenes); la información se divide algunas veces en
paneles, que permiten navegar de manera sencilla por la herramienta. También cuenta
Capítulo III Diseño y Desarrollo de la Aplicación
Página 88 Aplicación de software a dispositivos móviles
con botones que toman los datos insertados por el usuario, estos botones contienen
métodos que realizan las operaciones necesarias y adecuadas a cada aplicación. Estas
operaciones son basadas en las fórmulas estudiadas durante la carrera.
Anteriormente se habló del diseño de estas herramientas en la herramienta de
programación Visual Studio 2008 con aplicación a Smart Device.
Vista general de Herramienta Amplificadores
Figura 67 Interfaz final de la herramienta amplificadores y los controles utilizados para su diseño
Cajas de inserción de datos Botón que contiene el método
para realizar las operaciones
Cajas de texto, para mostrar
resultados Cajas de inserción de datos
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 89
Vista general de Herramienta Matrices
Figura 68 Interfaz final de la herramienta Matrices y los controles utilizados para su diseño
Vista general de Herramienta conversión de bases
Figura 69 Interfaz final de la herramienta conversión de bases y los controles utilizados para su diseño
Espacio para mostrar las
matrices insertadas y el
resultado de las operaciones
realizadas
Elección de las operaciones a
realizar
Elección de la matriz a insertar
Especificación del tamaño de la
matriz a insertar
Inserción de los elementos de
la matriz
Botón para leer los elementos
insertados
Botón para realizar la operación
señalada
Caja para insertar los valores a convertir
Elección de una base a otra, a la cual se
desea convertir
Muestra el resultado de la
conversión
Capítulo III Diseño y Desarrollo de la Aplicación
Página 90 Aplicación de software a dispositivos móviles
3.3 Programación y codificación
Como se sabe, el desarrollo de la aplicación se realiza dentro del marco de Visual Studio
2008, en un entorno de C# (en ingles C Sharp, en español se interpretaría C afilado o
experto), es un lenguaje de programación que permite el desarrollo de aplicaciones para
Internet, para móviles y aplicaciones de propósito general. Inicialmente se desarrolló para
programar en la plataforma .NET, pero dadas las características de esta y la
estandarización que se ha hecho de su estructura por parte de Microsoft ante las
principales entidades de estándares internacionales, se han desarrollado otras
plataformas que cumplen con dicha estructura, y por lo tanto C# puede ser utilizado como
lenguaje de programación en ellas.
La sintaxis de C# es muy parecida a la de C++ o Java, puesto que la intención de
Microsoft es facilitar la migración de códigos escritos en estos lenguajes a C# y facilitar su
aprendizaje a los desarrolladores habituados a ellos. Sin embargo, su sencillez y el alto
nivel de productividad son comparables con los de Visual Basic.
Cada control en base a sus funciones propias, es posible programarlas para que cumplan
en tiempo y ejecución ciertos eventos.
A continuación se mostrarán ejemplos de programación y codificación de algunos
controles.
En la aplicación que convierte de una base a otra, el botón convertir, se programa de la
siguiente manera para que haga las diferentes conversiones.
private void button1_Click(object sender, EventArgs e)
{
long a, b,i;
string n = "";
string x = "";
if (sistemas.SelectedIndex == 0)//dec-bin
{
a = Int64.Parse(valor.Text);
b = 0;
for (i = 1; a > 0; i++)
{
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 91
b = a % 2;
a = a / 2;
n = b + n;
}
res.Text = n;
}
Se puede observar que en el objeto:
private void button1_Click(object sender, EventArgs e)
El evento predeterminado del botón se estipula, al hacer clic, pero está previamente
establecido este evento, pues ya es una propiedad definida del control. Lo que se tiene
que estipular por parte del programador son las variables. Para esto debemos de
entender algunos conceptos.
Una variable puede ser definida dentro de una definición de clase, en cuyo caso se
correspondería con el tipo de miembro que hasta ahora hemos denominado campo.
También puede definirse como un variable local a un método, que es una variable
definida dentro del código del método a la que sólo puede accederse desde dentro de
dicho código. Otra posibilidad es definirla como parámetro de un método, que son
variables que almacenan los valores de llamada al método y que, al igual que las
variables locales, sólo pueden ser accedidas desde código ubicado dentro del método.
En la aplicación y en el código que se especifico al iniciar éste tema:
private void button1_Click(object sender, EventArgs e)
{
long a, b,i;
string n = "";
string x = "";
if (sistemas.SelectedIndex == 0)//dec-bin
{
a = Int64.Parse(valor.Text);
b = 0;
for (i = 1; a > 0; i++)
{
b = a % 2;
a = a / 2;
n = b + n;
}
res.Text = n;
}
Capítulo III Diseño y Desarrollo de la Aplicación
Página 92 Aplicación de software a dispositivos móviles
3.3.1 Diagramas de clase
Un diagrama de clases es un tipo de diagrama estático que describe la estructura de un
sistema mostrando sus clases, atributos y las relaciones entre ellos. Los diagramas de
clases son utilizados durante el proceso de análisis y diseño de los sistemas, donde se
crea el diseño conceptual de la información que se manejará en el sistema, y los
componentes que se encargarán del funcionamiento y la relación entre uno y otro.
El diagrama de clases incluye mucha más información como la relación entre un objeto y
otro, la herencia de propiedades de otro objeto, conjuntos de operaciones/propiedades
que son implementadas para una interfaz.
El Diseñador de clases de Visual Studio utiliza un diagrama para mostrar los detalles de
los tipos, sus miembros constituyentes y las relaciones que éstos comparten. Al visualizar
estas entidades, en realidad se obtiene una vista del código. Esto significa que es posible
editar los tipos que son de lectura y escritura y, a continuación, ver los cambios en el
código fuente de la entidad. Análogamente, un diagrama de clase se mantiene
sincronizado con los cambios realizados en el código de las entidades.
En el diagrama 1 general de clases perteneciente a la aplicación de Formulario de Circuitos
digitales.
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 93
Diagrama 1 Diagrama de clases del formulario de circuitos digitales
Capítulo III Diseño y Desarrollo de la Aplicación
Página 94 Aplicación de software a dispositivos móviles
Se puede observar en cada uno de los diagramas las relaciones de cada una de las
clases y de los objetos que tiene cada una de éstas. El diagrama se compone de clases
base y clases derivadas, la base es la raíz y las clases derivadas son relaciones de otras.
No hay que omitir que cada clase tiene métodos y atributos y las relaciones con otras
clases conocidas entre ellas, sin mostrar los métodos mediante los cuales se invocan
entre ellas.
También tienen clases base similar entre ellas tales como Container control, Component,
Control, Scrollable y Object; ésta última admite todas las clases de la jerarquía de clases
de .NET Framework y proporciona servicios de bajo nivel a las clases derivadas. Se trata
de la clase base fundamental de todas las clases de .NET Framework; es la raíz de la
jerarquía de tipos.
Es importante resaltar que en el diagrama general de la aplicación no se muestran las
clases de los demás formularios, ni sus atributos ni propiedades; esto es porque están
contenidos como referencias a bibliotecas de clases.
Clase
Una clase define los atributos y los métodos de una serie de objetos. Todos los objetos
de esta clase (instancias de esa clase) tienen el mismo comportamiento y el mismo
conjunto de atributos (cada objetos tiene el suyo propio). En ocasiones se utiliza el
término “tipo” en lugar de clase, pero recuerde que no son lo mismo, y que el término tipo
tiene un significado más general (ver diagrama 2).
Las clases están representadas por rectángulos, con el nombre de la clase, y también
pueden mostrar atributos y operaciones de la clase en otros dos “compartimentos” dentro
del rectángulo.
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 95
Diagrama 2 Forma y Contenido del campo clase Form2 y sus Métodos
Asociaciones de clases
Las clases se pueden relacionar (estar asociadas) con otras de diferentes maneras.
Generalización
La herencia es uno de los conceptos fundamentales de la programación orientada a
objetos, en la que una clase “recoge” todos los atributos y operaciones de la clase de la
que es heredera, y puede alterar/modificar algunos de ellos, así como añadir más
atributos y operaciones propias.
En el Diseñador de clases, puede ver la relación de herencia, si existe, entre un tipo base
y sus tipos derivados en el diagrama de clase. Las relaciones de herencia se pueden dar
entre dos clases, entre dos interfaces, o entre una clase y una interfaz.
Asociaciones
Una asociación representa una relación entre clases, y aporta la semántica común y la
estructura de muchos tipos de “conexiones” entre objetos.
Capítulo III Diseño y Desarrollo de la Aplicación
Página 96 Aplicación de software a dispositivos móviles
Las asociaciones son los mecanismos que permite a los objetos comunicarse entre sí.
Describe la conexión entre diferentes clases (la conexión entre los objetos reales se
denomina conexión de objetos o enlace).
Las asociaciones pueden tener un papel que especifica el propósito de la asociación y
pueden ser unidireccionales o bidireccionales (indicando si los dos objetos participantes
en la relación pueden intercambiar mensajes entre sí, o es únicamente uno de ellos el
que recibe información del otro). Cada extremo de la asociación también tiene un valor de
multiplicidad, que indica cuántos objetos de ese lado de la asociación están relacionados
con un objeto del extremo contrario.
Las asociaciones se representan por medio de líneas que conectan las clases
participantes en la relación, y también pueden mostrar el papel y la multiplicidad de cada
una de ellas (ver diagrama 3).
En el Diseñador de clases, las líneas de asociación muestran la forma en que se
relacionan las clases en un diagrama. Una línea de asociación representa una clase que
es el tipo de una propiedad o un campo de otra clase del proyecto. Las líneas de
asociación se utilizan generalmente para ilustrar las relaciones más importantes entre las
clases del proyecto.
A pesar de que todos los campos y propiedades se pueden mostrar como asociaciones,
tiene más sentido mostrar sólo los miembros importantes como asociaciones,
dependiendo de lo que se desee resaltar en el diagrama. Se pueden mostrar los
miembros menos importantes como miembros normales u ocultarlos totalmente.
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 97
Diagrama 3 Diagrama de clases “Asociaciones entre las clases”
3.4 Conversión de formularios a bibliotecas de clases.
. NET Framework se compone de bibliotecas de clases de nombres. Cada una contiene
los tipos de instrucciones que pueden utilizar en un programa: clases, estructuras,
enumeraciones, delegados e interfaces.
Al crear una aplicación Visual C # en Visual Studio con Compact Framework 3.5 para
Smart Device, se pueden hacer bibliotecas de clases, es decir, se puede crear un
proyecto base con controles y métodos que previamente puede convertirse a una
biblioteca de clases o archivo DLL con la finalidad de ocultar el código de la aplicación o
ahorrar el hacer referencia a recursos externos de programación o herramientas, para
este proyecto en particular una biblioteca de clases es usada para la conjunción de
Asociación
Asociación
Capítulo III Diseño y Desarrollo de la Aplicación
Página 98 Aplicación de software a dispositivos móviles
proyectos en un solo menú, con las ventajas de ahorro de espacio en disco y ocultar
métodos de código y procesos de fabricación del mismo.
Al crear un proyecto en Visual Studio 2008, se crean bibliotecas de clase previamente
definidas a continuación se mencionan las más importantes. Si se desea conocer las
demás bibliotecas con las que cuenta Visual Studio al crear un proyecto, se pueden ver
los anexos cuyo título Referencia a las bibliotecas de clase de .NET Framework.
Pasos para convertir un proyecto a biblioteca de clases:
1. Visual Studio tiene una opción dentro del menú Herramientas, para generar
bibliotecas de clase, una vez abierta la ventana del proyecto actual, se deberá de ir a
las opciones dentro del nombre del proyecto con clic derecho, en la ventana de
explorador de soluciones(ver figura 70) y en el campo propiedades.
Figura 70 Ventana de explorador de soluciones
El campo propiedades nos brinda un panorama general de la aplicación y sus
contenidos, dentro de esta opción podemos modificar ciertas condiciones propias del
proyecto como son el tipo de recursos, rutas de acceso de referencia, el modo de
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 99
depuración del proyecto, firmas de ensamblado para personalizar el proyecto, así
como las propiedades de los dispositivos a los cuales estará orientado el proyecto.
Para este caso únicamente se hará uso de la pestaña aplicación en donde
especificaremos el tipo de resultado (ver figura 71).
Figura 71 Elección de la opción Biblioteca de clases para convertir el proyecto a biblioteca
2. En la opción tipo de resultado se elige la opción biblioteca de clases para que se
genere el archivo correspondiente a una biblioteca de clases tipo DLL, cabe
mencionar que la opción aplicación a Windows solo genera, al momento de depurar
el proyecto, un archivo ejecutable cuyo contenido es ejecutable en cualquier
plataforma soportada por Compact Framework 3.5. Después de elegir esta opción
únicamente se tendrá que depurar el proyecto en la opción depurar (ver figura 72).
Capítulo III Diseño y Desarrollo de la Aplicación
Página 100 Aplicación de software a dispositivos móviles
Figura 72 Se inicia el Debug para comenzar con la creación a biblioteca
Al depurar el proyecto el programa generalmente marca una excepción la cual indica que
no se puede iniciar directamente un tipo de resultado de Bibliteca de clase, lo cual es
correcto ya que el proyecto no cuenta con un recurso que ejeute directamente la
biblioteca de clases para este caso únicamente se acepta la excepción (ver figura 73).
Figura 73 Excepción que marca la imposibilidad de ejecutar el proyecto como biblioteca de clases.
3. Al aceptar la excepción anteriormente mencionada se genera un archivo con el
nombre del proyecto o de la clase principal del proyecto según el usuario haya
indicado previamente, este archivo es la biblioteca de clase con extensión DLL, ésta
se encuentra dentro de la carpeta donde está guardado el proyecto, dentro de la
subcarpeta bin\debug (ver figura 74), esta biblioteca de clase contiene de forma
compacta los métodos, recursos, propiedades e instrucciones de programación que
se realizaron en el proyecto.
Capítulo III Diseño y Desarrollo de la Aplicación
Aplicación de software a dispositivos móviles Página 101
Figura 74 Ubicación de la biblioteca creada
4. Para ejecutar el contenido de esta biblioteca de clases se crea un proyecto nuevo y
se manda a llamar la biblioteca copiando el archivo en la carpeta debug del proyecto
de Visual Studio creado, posteriormente dentro de las referencias del proyecto se
agrega la biblioteca de clases y se manda a llamar con una línea de código dentro del
programa, estos pasos se indicaran con mayor detalle en el capítulo 4 que explica la
forma en que se implementa la aplicación.
Capítulo III Diseño y Desarrollo de la Aplicación
Página 102 Aplicación de software a dispositivos móviles
Capítulo IV Implementación y Pruebas
Aplicación de software a dispositivos móviles Página 103
CAPÍTULO IV
Implementación y Pruebas
4.1 Conexión con el dispositivo
Para tener conexión y sincronización con el dispositivo Pocket PC se requiere la
instalación en la PC del Software de sincronización de archivos Active Sync que
normalmente se encuentra en el disco de drivers de la Pocket PC o en la página oficial de
Microsoft.
ActiveSync de Microsoft, es el centro de control para el intercambio de datos entre el PC
y Windows Mobile / Pocket PC. Apoya la sincronización de Contactos, Calendario,
Correo electrónico, tareas y notas con MS Outlook.
ActiveSync también se ocupa de realizar algunas tareas como son:
Conversión de documentos de Pocket Excel, Pocket Word y Pocket Acceso
Sincronización de correo electrónico Outlook y carpetas entre la bandeja de
entrada
Sincronización de archivos de audio / vídeo
Intercambio de favoritos de Internet (más contenido de cache)
Cómo copiar archivos a una PC:
Ciertamente, la forma más sencilla de copiar archivos entre la PC y dispositivo Windows
Mobile, es hacer uso del software ActiveSync. Cuando el Windows Mobile está acoplado
con el escritorio, se encuentra que se puede utilizar la conexión para la copia de archivos
con tan solo arrastrar y soltar.
1. Conectar el dispositivo Windows Mobile con la PC mediante ActiveSync
2. Ir a Windows "Mi PC"
Capítulo IV Implementación y Pruebas
Página 104 Aplicación de software a dispositivos móviles
3. Se debe ver a un "dispositivo móvil" que figuran en el icono "Mi PC" – hacer
doble clic sobre este icono , y abrir los archivos y carpetas en el
dispositivo.
4. Se deja abierta esta carpeta y se abren mis documentos
5. Ahora se debe tener dos carpetas abiertas, y se puede arrastrar archivos entre
PC y dispositivos Windows Mobile como se requiera.
4.1.1 Emulador Smart Device de Visual Studio
En caso de no contar con un dispositivo conectado a la PC para realizar las pruebas
correspondientes, se puede trabajar con el emulador incluido en la plataforma de
desarrollo Visual Studio. Los emuladores son máquinas virtuales que corren en la PC
como si fuera el dispositivo mismo.
Existen diversos emuladores que dependen de la plataforma de desarrollo y el tipo de
Framework que se utiliza al programar (Windows CE 2002, Windows Mobile 2003,
Smartphone, etc.).
Cargar aplicación desde el emulador
Una vez que el proyecto o programa en Smart Device de se ha concluido y se desean ver
los resultados únicamente se depura el proyecto en la opción depurar de la ventana barra
de herramientas del programa Visual Studio. A continuación se pedirá, donde se desea
implementar la aplicación y se elige la opción emulador que simula un dispositivo móvil
con características similares a la realidad (ver figura 75).
Capítulo IV Implementación y Pruebas
Aplicación de software a dispositivos móviles Página 105
Figura 75 Implementación del formulario desde el emulador de Visual Studio
La opción Square Emulador únicamente emula los resultados del programa sin las
características de un dispositivo real.
Al ejecutar el emulador la aplicación se carga en una ventana que simula un dispositivo
móvil Pocket PC en donde se ejecuta la aplicación deseada y se pueden verificar si los
resultados obtenidos son los deseados (ver figura 76).
Figura 76 Ventana del emulador de Visual Studio
Capítulo IV Implementación y Pruebas
Página 106 Aplicación de software a dispositivos móviles
El emulador que utiliza la plataforma de desarrollo es el Device Emulator 3.0, cuyas
características principales se enumeran de la siguiente manera.
Viene con Visual Studio 2008.
o La plataforma de diseño de software Visual Studio contiene este
emulador que facilita la tarea de revisar el comportamiento de un
programa elaborado para Smart Device.
Actualiza las versiones anteriores.
o En caso de contar con un programa desarrollado en un Compact
Framework de versión anterior el emulador tiene la capacidad de
actualizar los recursos para que este sea ejecutable en esta nueva
versión.
4.2 Implementación
Anteriormente se trató la forma en que se emula un dispositivo y como es que se emula
una aplicación de Smart Device en el programa de desarrollo Visual Studio, en esta
parte del capítulo se explicará de manera breve y significativa la manera en que una
aplicación puede ser ejecutada desde el dispositivo móvil o Pocket PC, hay que tomar en
cuenta que en este proyecto para ahorrar espacio de memoria en el dispositivo físico fue
necesario convertir las aplicaciones que conforman el menú general de Herramientas de
ICE en bibliotecas de clase (.DLL) las cuales serán llamadas por otra aplicación
complementaria que se explicará en el siguiente tema, y la forma en que la aplicación
final es transportada al dispositivo físico Pocket PC.
4.2.1 Transferencia de la aplicación al dispositivo móvil
Como requisito indispensable para realizar la prueba física se deberá contar con una
Pocket PC y con el simulador de Pocket PC de Visual Studio para realizar la transferencia
de la aplicación
Capítulo IV Implementación y Pruebas
Aplicación de software a dispositivos móviles Página 107
.
De acuerdo a lo anterior cualquier dispositivo que sea clasificado como un PocketPC
debe:
Ejecutar el sistema operativo Microsoft Windows CE o Windows Mobile (versión
PocketPC)
Tener un conjunto de aplicaciones en ROM
Incluir una pantalla sensible al tacto
Incluir un dispositivo apuntador, llamado stylus o estilete
Incluir un conjunto de botones de hardware para activar aplicaciones
Estar basado en un procesador compatible con el StrongARM
Contar con una versión Compact Framework 3.5
Diseño del menú principal de herramientas y formularios
Antes de realizar la transferencia de la aplicación al dispositivo móvil, y tomando en
cuenta que las aplicaciones fueron convertidas en bibliotecas de clases (.DLL) como se
explicó en el capitulo anterior se deberá realizar un menú o aplicación que administre
estas bibliotecas y las ejecute como parte del programa principal. Para ello se muestra a
continuación el diseño de la aplicación menú.
Retomando las instrucciones de cómo crear una aplicación Smart Device en Visual
Studio se crea de igual forma el menú herramientas llamado en esta ocasión
“menu_gen” y cuyo diseño con ayuda de las herramientas y recursos usados y
anteriormente explicados se crea una interfaz como se observa en la figura 77.
Capítulo IV Implementación y Pruebas
Página 108 Aplicación de software a dispositivos móviles
Figura 77 Creación y diseño de la interfaz del conjunto de la herramientas de apoyo para el formulario de ICE
Una vez terminado el diseño del menú principal, se pasan todas y cada una de las
librerías de clases a la carpeta del proyecto llamada “debug” y se agregan las
referencias correspondientes a estas bibliotecas desde el “explorador de soluciones”
para agregar a estas librerías como recursos locales de la aplicación.
En la figura 78 se puede observar que además de las bibliotecas propias del sistema
también se encuentran las agregadas en la carpeta debug.
Capítulo IV Implementación y Pruebas
Aplicación de software a dispositivos móviles Página 109
Figura 78 Explorador de soluciones que muestra las bibliotecas creadas por el programador
Por último se mandan a llamar las librerías de clases para que éstas se ejecuten en el
programa, esto se hace con una línea de código bastante sencilla que se explica a
continuación.
Tomar en cuenta que las referencias están hechas y los botones dentro de la aplicación
requieren llamar a una aplicación para que esta se ejecute como parte del programa,
entonces realizando doble clic sobre el botón y en modo de programación de la
herramienta se introducen las siguientes líneas:
private void linkLabel6_Click(object sender, EventArgs e)
{
convertidor.cbase bas = new convertidor.cbase();
bas.Show();
}
En donde linkLabel6_Click pertenece al botón que mandará a llamar a la
aplicación de conversor de unidades, convertidor.cbase bas = new
convertidor.cbase(); pertenece al contructor que manda a llamar al evento o
subclase de la biblioteca de clases para ejecutar una acción con el seudónimo
Capítulo IV Implementación y Pruebas
Página 110 Aplicación de software a dispositivos móviles
convertidor, bas.Show(); que contiene el seudónimo de la instrucción y el evento a
realizar, el comando Show(); muestra el contenido de la biblioteca de clases.
4.3 Análisis de pruebas
Las pruebas se realizan directamente en el dispositivo Pocket PC, para corroborar que
las aplicaciones funcionen correctamente.
Se tiene que tomar en cuenta el tamaño de la aplicación implementada; ésta no deberá
de sobrepasar el límite de memoria permitido por la Pocket PC, de lo contario será un
primer problema al momento de transferir la aplicación al Pocket PC, y se deberá de
depurar información del mismo.
El dispositivo móvil Pocket PC deberá de tener instalado el compact framework 3.5, ya
que de no tenerlo instalado la aplicación no podrá ser visualizada. Conecte el dispositivo
a su PC. Si el dispositivo no está conectado, ActiveSync almacenará el archivo CAB y no
instalará el paquete hasta que lo conecte. Si no usa ActiveSync, ejecute los archivos CAB
del dispositivo correspondiente a archivos CAB específicos de dicho dispositivo que
encontrará en la carpeta de instalación. De no tener instalada ésta versión de software,
se puede descargar de forma gratuita desde la siguiente página (ver figura 79):
http://www.microsoft.com/Downloads/details.aspx?familyid=E3821449-3C6B-42F1-9FD9-
0041345B3385&displaylang=es
Capítulo IV Implementación y Pruebas
Aplicación de software a dispositivos móviles Página 111
Figura 79 Página en Microsoft para demostrar la posibilidad de bajar el compact framework
Se deberá de realizar la descarga. Como se indica a continuación.
1. Haga clic en el botón Descargar de esta página para iniciar la descarga o elija un
idioma diferente en la lista desplegable y haga clic en Cambiar. Para copiar la
descarga en el equipo para instalarla posteriormente, haga clic en Guardar o en
Guardar este programa en disco (ver figura 80).
Figura 80 Pantalla de descarga del compact Framework
Capítulo IV Implementación y Pruebas
Página 112 Aplicación de software a dispositivos móviles
2. Comenzará la descarga en la ubicación que se haya especificado:
Figura 81 Comienzo de la instalación del software Compact framework
3. Para iniciar la instalación inmediatamente, haga clic en Abrir o en Ejecutar este
programa desde Internet.
4. Si no se ejecuta desde internet, el programa se guardará en la ubicación que
anteriormente le indique el usuario. Para instalarlo se deberá de hacer doble clic
sobre el icono del ejecutable NetCFSetupv35:
5. Al ejecutar el instalador, aparecerá el asistente para la instalación, se deberá dar
clic en siguiente y seguir los pasos siguientes para la correcta instalación (ver
figuras de la 81 a la 85).
Capítulo IV Implementación y Pruebas
Aplicación de software a dispositivos móviles Página 113
Figura 82 Asistente de la instalación del compact Framework
Figura 83 Instalación personalizada del compact Framework 3.5.
Capítulo IV Implementación y Pruebas
Página 114 Aplicación de software a dispositivos móviles
Figura 84 Pantallas para la instalación del software compact framework
Figura 85 finalización del asistente de instalación de ,NET Compact Framevork
Capítulo IV Implementación y Pruebas
Aplicación de software a dispositivos móviles Página 115
Otra prueba será, verificar el debido funcionamiento de todas y cada una de las
aplicaciones, herramientas y menús implementados en la aplicación, para esto, se
debieron de haber realizado correctamente las bibliotecas de clases y se debieron de
haber referenciado debidamente en el proyecto, donde se realizó el menú general. Si al
analizar las pruebas se encuentra error al abrir alguna aplicación o herramienta se deberá
de estudiar cual es el error marcado, el más común es la referencia a un formulario que
no existe, para éste caso se deberá de volver a colocar la referencia del formulario que se
está mandando llamar. Si no fuera éste el inconveniente se deberá de borrar y volver a
cargar la aplicación del dispositivo, con las correcciones realizadas desde la plataforma
sobre la cual se desarrolló el proyecto.
4.3.1 Resultados en el dispositivo móvil y el emulador
Una vez creada la interfaz que verá el usuario en la Pocket PC se prosigue con la prueba
de la aplicación. Para iniciar la prueba se da clic en la flecha verde que aparece en el
menú de la parte superior de Visual Studio. Como se observa con este botón se inicia la
generación de la aplicación (ver figura 86).
Figura 86 Depuración y generación de la aplicación
Una vez iniciado el proceso de depuración se muestra una ventana como la que se
observa en la cual se tienen las opciones para probar la aplicación ya sea emulándola en
la computadora con el aspecto de la Pocket PC o cargándola directamente a la Pocket
PC la cual es la tercera opción.
Para este primer caso se prueba la aplicación con el emulador, para lo que se selecciona
la primera opción (ver figura 87).
Capítulo IV Implementación y Pruebas
Página 116 Aplicación de software a dispositivos móviles
Figura 87 Pantalla del emulador
Después el emulador se empieza a cargar para dar como resultado la interfaz de una
Pocket PC (ver figura 88).
Figura 88 Interfaz de la herramienta de la aplicación
Y como se observa se habrá cargado la interfaz de la aplicación que se hizo.
Ahora se prueba la aplicación mediante un ejemplo sencillo.
Capítulo IV Implementación y Pruebas
Aplicación de software a dispositivos móviles Página 117
En el siguiente ejemplo retomado de apuntes de la carrera de ICE en la materia de
Dispositivos Electrónicos se calcula primero la ganancia en base a un voltaje inicial, un
voltaje final y una resistencia Rf.
Estos fueron los resultados obtenidos experimentalmente. Ahora se introducen los
mismos datos a la aplicación y se da clic en el botón “Calcula”.
Como se observa obtenemos los mismos resultados que en la parte experimental (ver
figura 89).
Figura 89 Emulación de los datos y obtención de resultados, de acuerdo a lo programado en el botón.
Ahora se probarán los elementos de error para el código try-catch, haciendo referencia a
que la sentencia de control try-catch es una sentencia de control de errores, es decir ésta
secuencia de código captura algún error y permite manipularlo para que el programa no
se salga del proceso o se interunpa de manera abrupta.
De tal forma que si se llegaran a escribir valores no válidos en algún cuadro de texto y se
intenta ejecutar una acción el programa manda el mensaje de error y permite que el
usuario corrija este error de acuerdo a la instrucción o tipo de error que se marca.
Capítulo IV Implementación y Pruebas
Página 118 Aplicación de software a dispositivos móviles
4.4 Análisis de costos
Los costos del proyecto incluyen la adquisición de software y herramientas de hardware
para poder implementar la aplicación.
La mayor ventaja de Windows CE 5.0, es la calidad de producción de varios de sus
componentes. Quizás para el usuario de una Pocket PC esto no signifique nada, pero
para los OEMs que manufacturan los aparatos resulta un gran avance, pues el tiempo de
desarrollo es más breve y, sobre todo, más confiable; esto reducirá los tiempos de
producción y sus costos asociados.
Windows CE 5.0 incluye la funcionalidad del .NET Compact Framework Service Pack 2.
(Windows CE 5.0 es un software que ya viene incluido en la compra de la Pocket PC).
Para determinar el valor de la aplicación en el mercado, se necesita hacer una valoración
del software en base a criterios establecidos, estos criterios pueden ser:
-Número de entradas.
-Número de salidas.
-Número de peticiones.
Desde luego estos criterios, deben tomarse en cuenta para un proyecto en etapa de
experimentación, y en base a la evaluación de estos criterios se propondrá un valor de
acuerdo a la versión del software y evaluación del mismo.
El costo de la aplicación, en base a argumentos establecidos en la vida cotidiana se
maneja con objetos tangibles, los cuales son necesarios para la realización de la
aplicación; estos argumentos se anexan en una tabla, con los precios que actualmente se
manejan si se iniciara la creación de este software.
Capítulo IV Implementación y Pruebas
Aplicación de software a dispositivos móviles Página 119
Ing. de Desarrollo (Programador) $15,000 Al mes
Ing. de Diseño $10,000 Al mes
Licencia de Software (Visual Studio) $5,300
Equipo de Cómputo $7,000
HP iPAQ 214 Enterprise Handheld $4,500
Versión Compact Framework Gratis (Descargable desde la Página de Microsoft)
Tabla 1 Análisis de costos actuales.
Página 120 Aplicación de software a dispositivos móviles
Aplicación de software a dispositivos móviles Página 121
Conclusiones
Como se mencionó, el objetivo de esta aplicación fue desarrollar una herramienta de apoyo al
estudiante de ICE, por lo que fueron realizados formularios de apoyo a algunas materias de
tronco común, tales como: circuitos digitales, circuitos de CA y CD, comunicaciones analógicas,
comunicaciones digitales y procesamiento digital de señales; las cuales son de las materias que
se tenía más información, sin embargo, es necesario considerar que se puede complementar
con recursos de otras materias y/o carreras, con la única finalidad de enriquecer la aplicación.
Las pruebas fueron realizadas e implementadas de manera satisfactoria, de forma que se
probaron en el dispositivo móvil Pocket PC. Con esto, no se quiere decir, que la aplicación se
reduzca a los formularios informativos realizados en esta tesis, sino que es posible ampliar las
aplicaciones y herramientas contenidas, incluso crear nuevos formularios y nuevas aplicaciones
de apoyo, con ayuda de las herramientas de diseño de Visual Studio.
Esta tesis no pretende imponer una manera específica de diseñar y programar una aplicación, ya
sea para PC o dispositivo móvil, sino que trata de introducir y brindar, al programador o
diseñador de software básico, las herramientas y opciones de diseño para que el mismo cree y
programe aplicaciones como así lo desee.
Se deja abierta la invitación, para una mejora en la presentación de interfaces gráficas,
introducción de datos, solicitar la participación de alumnos y docentes, e incluso expertos en el
diseño y desarrollo de herramientas de software, así como en el aspecto pedagógico.
Probablemente, para un mayor enriquecimiento, sería posible contar con un departamento
especializado en herramientas de desarrollo de aprendizaje, para reforzar la aplicación y que se
verifique la adecuación y que cumpla con los estándares de aprendizaje necesarios para el
alumno y que sea una herramienta mucho más útil. Se podría llegar a afirmar que es de gran
utilidad entre el alumnado, dado que se realizaron encuestas entre los compañeros del mismo
semestre y de un semestre anterior al noveno, quienes comprobaron su funcionalidad.
También, no se descarta la idea de colocar en una página de internet la prueba de este software
mediante el archivo ejecutable de la aplicación, y de ésta manera obtener comentarios, con la
finalidad de tener una retroalimentación y contar con sugerencias de mejora del sistema.
Página 122 Aplicación de software a dispositivos móviles
Por último es importante mencionar y hablar sobre la utilidad de la herramienta de desarrollo de
la aplicación, ya que como se pudo observar, Visual Studio es un software bastante útil para el
desarrollo de aplicaciones, el cual brinda las facilidades necesarias, proporcionando
herramientas de diseño y creación de aplicaciones, no sólo para PCs sino también para
dispositivos móviles. Es por eso que se optó por usar este software para desarrollar la aplicación
en la Pocket PC, debido a la ventaja que ofrece, en cuanto a que cada proyecto cuenta con un
archivo ejecutable que es capaz de ejecutarse en cualquier equipo, con cualquiera que sea su
sistema operativo, sin necesidad de tener instalado el Visual Studio, con la única condición de
tener instalada la versión más actual del framework, la cual es posible bajar de internet, tal como
se mencionó en el capítulo IV tema 4.3, éste no genera ningún costo extra y su instalación es
fácil y muy sencilla.
Con la creación de bibliotecas de clases fue posible la protección de la aplicación, por lo que se
protege tanto al código de las aplicaciones o herramientas, además de tener una mayor
flexibilidad de conjuntar, todas las herramientas en un solo proyecto, tal como se hizo con la
creación del menú principal, en donde se insertaron todas las aplicaciones y formularios de las
materias antes descritas, y las herramientas de apoyo, tales como: amplificadores, diseño de
compuerta RTL, convertidor de unidades, convertidor de bases, resolución de matrices,
calculadora, cálculo de resistencias, Diseño de redes RC pasa bajas y pasa altas.
Aplicación de software a dispositivos móviles Página 123
Bibliografía
http://foro.todopocketpc.com/
http://msdn.microsoft.com/es-es/library/aa291596(VS.71).aspx
http://www.devjoker.com/contenidos/Tutorial-C/125/Introduccion-a-C.aspx
http://www.devjoker.com/asp/ver_contenidos.aspx?co_contenido=142
"http://es.wikipedia.org/wiki/Diagrama_de_clases"
http://docs.kde.org/kde3/es/kdesdk/umbrello/uml-elements.html
C# para desarrolladores de JAVA
Allen Jones
Adam Freeman
Editorial Mc Graw Hill (pags. 3 -20)
Corporations, M. (2009). MSDN. Recuperado el 06 de Enero de 2009, de
http://msdn.microsoft.com/es-es/default.aspx
Página 124 Aplicación de software a dispositivos móviles
Anexos
Herramientas útiles de .NET Framework
Herramienta Descripción
Enlazador de ensamblaje (Assembly Linker,
al .exe)
Genera metadatos para uno o más archivos
que se combinan en un ensamblaje.
Utilidad para la cache de ensamblajes de
Microsoft .NET (Microsoft .NET Global
Assembly Cache Utility, gacutil.exe)
Lista y manipula la cache global de
ensamblajes (global assembly cache, GAC) y
la caché de descarga de archivos.
Herramienta de configuración del .NET
Framework (.net Framework Configuration Tool, mscorcfg.msc)
Herramienta de interfaz gráfica de usuario
para la gestión y configuración del .NET Framework, utilizando la interfaz de gestión
de Windows (Windows Management
Interface, WMI).
Depurador para CLR de Microsoft (Microsoft
CLR Debugger dbgclr.exe)
Herramienta de depuración gráfica.
Entorno de depuración para pruebas del
entorno de ejecución del CLR de Microsoft
(Microsoft CLR Runtime Test DebuggerShell, cordbg.exe)
Herramienta de depuración de línea de
comandos.
Utilidad para nombres fuertes del Framework de Microsoft .NET (Microsoft .NET Framework
Strong Name Utility, sn.exe)
Ayuda en la creación de ensamblajes con nombres fuertes.
Herramienta de políticas de seguridad para
acceso al código (Code Access Security Policy
Tool, caspol.exe)
Gestor de políticas de seguridad para las
políticas de seguridad de máquina, usuario y
corporativa.
Generador de archivos de recursos
(Resources Files Generato, resgen.exe)
Crea archivos de recursos binarios para CLR
a partir de formatos existentes.
Desensamblador de IL para Microsoft .NET
(Microsoft .NET IL Dissambler, ildasm.exe)
Herramienta gráfica para desensamblar
archivos MSIL.
Aplicación de software a dispositivos móviles Página 125
Especificaciones técnicas de instalación y compatibilidad con el sistema
operativo del Pocket.
Requisitos del sistema
Sistemas operativos compatibles: Windows 2000 Service Pack 4; Windows CE
.NET; Windows Mobile 2003 SE software for Pocket PC; Windows Mobile 5.0;
Windows Mobile 6; Windows Vista; Windows XP
Sistemas operativos del dispositivo admitidos: Windows Mobile para Pocket PC
2003, Windows Mobile 5.0 para PocketPC y Smartphone, Windows CE .NET 5.0 y
superior.
.NET Compact Framework está disponible como componente del sistema operativo en todos los
dispositivos inteligentes de Microsoft, incluidos los dispositivos Pocket PC, Pocket PC Phone
Edition y Smartphone, así como otros dispositivos que se ejecutan bajo Windows CE.
Lista de compatibilidades
La tabla siguiente muestra las plataformas y los dispositivos admitidos por .NET Compact
Framework.
Versión de .NET Compact
Framework Dispositivo Plataforma
1.0 Pocket PC Pocket PC 2000
Pocket PC 2002
Windows Mobile 2003 para
Pocket PC
Windows Mobile 2003 para
Pocket PC SE
Windows Mobile 5,0 para
Pocket PC
1.0 Smartphone Windows Mobile 2003 para
Smartphone
Windows Mobile 5,0 para
Smartphone
1.0 Otros dispositivos para
Windows Embedded CE
Windows CE 4,1
Windows CE 4,2
Windows CE 5.0
Página 126 Aplicación de software a dispositivos móviles
2.0 Pocket PC Windows Mobile 2003 para
Pocket PC
Windows Mobile 2003 para
Pocket PC SE
Windows Mobile 5,0 para
Pocket PC
Windows Mobile 6 Professional
2.0 Smartphone Software Windows Mobile 5.0
para Smartphone
Windows Mobile 6 Standard
2.0 Otros dispositivos para
Windows Embedded CE
Windows CE 4.2
Windows CE 5.0
Windows Embedded CE 6.0
3.5 Pocket PC Windows Mobile 2003 para
Pocket PC
Windows Mobile 2003 para
Pocket PC SE
Software Windows Mobile 5.0
para Pocket PC
Windows Mobile 6 Professional
3.5 Smartphone Software Windows Mobile 5.0
para Smartphone
Windows Mobile 6 Standard
3.5 Otros dispositivos para
Windows Embedded CE
Windows Embedded CE 6.0
Nota:
Para Smartphone, .NET Compact Framework versión 2.0 requiere que se ejecute Windows
Mobile versión 5.0 en el dispositivo. Para obtener información acerca de cómo se instalan los
SDK de Windows Mobile 5.0 para Pocket PC y Smartphone en Visual Studio, vea Visual Studio
y .NET Compact Framework.
Aplicación de software a dispositivos móviles Página 127
Compatibilidad del Active Sync con diferentes sistemas operativos y
dispositivos
Operative System Use ActiveSync
version
Windows 9x, NT 4 3.8 [4]
Windows 2000, Windows XP (SP2 and earlier only), Windows
Server 2003 3.8/4.5
Windows Vista, Windows Server 2008 WMDC 6.1
Device's OS Use ActiveSync version
Windows CE 1 1.1 (Handheld PC Explorer)
Windows CE 2-5/Windows Mobile 2000-2003 3.8
Windows CE 3-6/Windows Mobile 2002-5.0 4.2
Windows CE 3-6/Windows Mobile 2002-6.1 4.5
Página 128 Aplicación de software a dispositivos móviles
Requerimientos de instalación Visual Studio 2008
Los requerimientos para instalar Visual Studio 2008 son:
Sistemas Operativos Soportados:
Windows Server 2003, Windows Server 2008, Windows Vista, Windows XP.
Requerimientos mínimos:
1.6 GHz CPU, 384 MB RAM, 1024×768 display, 5400 RPM hard disk.
Requerimientos Recomendados:
2.2 GHz o mayor CPU, 1024 MB en RAM, 1280×1024 en resolución de gráficos, 7200 RPM en
velocidad de disco Windows Vista: 2.4 GHz.
Aplicación de software a dispositivos móviles Página 129
Referencia de la biblioteca de clases de .NET Framework
La biblioteca de clases de .NET Framework es una biblioteca de clases, interfaces y tipos de
valor que se incluye en Microsoft .NET Framework. Esta biblioteca brinda acceso a la
funcionalidad del sistema y es la base sobre la que se crean las aplicaciones, los componentes y
los controles de .NET Framework.
Espacios de nombres
La biblioteca de clases de .NET Framework proporciona los siguientes espacios de nombres.
Microsoft.Aspnet.Snapin
Contiene las clases necesarias para que la aplicación de consola de administración de
ASP.NET interactúe con Microsoft Management Console (MMC).
Microsoft.Build.BuildEngine
Contiene las clases que representan el motor de MSBuild.
Microsoft.Build.Framework
Contiene clases que constituyen las tareas, los registradores y los eventos de MSBuild.
Microsoft.Build.Tasks
Contiene la implementación de todas las tareas que se suministran con MSBuild.
Microsoft.Build.Tasks.Deployment.Bootstrapper
Contiene clases utilizadas internamente por MSBuild.
Microsoft.Build.Tasks.Deployment.ManifestUtilities
Contiene clases utilizadas internamente por MSBuild.
Microsoft.Build.Utilities
Página 130 Aplicación de software a dispositivos móviles
Proporciona clases auxiliares que puede utilizar para crear sus propios registradores y
tareas de MSBuild.
Microsoft.CSharp
Contiene clases para compilar y generar código mediante el lenguaje C#.
Microsoft.JScript
Contiene clases que admiten la compilación y generación de código mediante el
lenguaje JScript.
Microsoft.SqlServer.Server
Contiene clases que son específicas de la integración del componente Common
Language Runtime (CLR) de Microsoft .NET Framework en Microsoft SQL Server y en el
entorno de ejecución de procesos del motor de bases de datos de SQL Server.
Microsoft.VisualBasic
Contiene clases que admiten la compilación y generación de código mediante el
lenguaje Visual Basic.
Microsoft.VisualBasic.ApplicationServices
Contiene tipos que admiten el modelo de aplicaciones de Visual Basic y proporcionan
acceso a la información de la aplicación.
Microsoft.VisualBasic.CompilerServices
Contiene sólo los tipos de uso interno que admiten el compilador de Visual Basic.
Microsoft.VisualBasic.Devices
Contiene los tipos que admiten los objetos My relacionados con los dispositivos de
Visual Basic.
Microsoft.VisualBasic.FileIO
Contiene los tipos que admiten el objeto del sistema de archivos My de Visual Basic.
Aplicación de software a dispositivos móviles Página 131
Microsoft.VisualBasic.Logging
Contiene los tipos que admiten los objetos de registro My de Visual Basic y proporciona
un agente de escucha de registro simple que dirige los datos de registro generados a un
archivo.
Microsoft.VisualBasic.MyServices
Contiene tipos que admiten My en Visual Basic.
Microsoft.VisualBasic.MyServices.Internal
Contiene los tipos de sólo uso interno que admiten My en Visual Basic.
Microsoft.VisualBasic.Vsa
Microsoft.VisualC
Microsoft.Vsa
Contiene interfaces que permiten integrar secuencias de comandos para los motores de
secuencias de comandos de .NET Framework en las aplicaciones, y compilar y ejecutar
código en tiempo de ejecución.
Microsoft.Vsa.Vb.CodeDOM
Microsoft.Win32
Proporciona dos tipos de clases: las que controlan los eventos desencadenados por el
sistema operativo y las que manipulan el Registro del sistema.
Microsoft.Win32.SafeHandles
Contiene clases que son derivaciones abstractas de las clases de identificador seguras y
que proporcionan funcionalidad común y admiten los identificadores de archivos y del
sistema operativo.
Microsoft.WindowsCE.Forms
Contiene clases para el desarrollo de aplicaciones de Windows Forms para Pocket PC y
Smartphone utilizando .NET Compact Framework.
Página 132 Aplicación de software a dispositivos móviles
Microsoft.WindowsMobile.DirectX
Contiene clases para el desarrollo de aplicaciones DirectX en dispositivos con .NET
Compact Framework. Requiere una versión futura de Windows Mobile que ejecute las
aplicaciones.
Microsoft.WindowsMobile.DirectX.Direct3D
Contiene clases para el desarrollo de las aplicaciones Direct3D en dispositivos con .NET
Compact Framework. Requiere una versión futura de Windows Mobile que ejecute las
aplicaciones.
Microsoft_VsaVb
System
Contiene clases fundamentales y clases base que definen los valores y tipos de datos de
referencia, eventos y controladores de eventos, interfaces, atributos y excepciones de
procesamiento comúnmente utilizados. Otras clases proporcionan servicios para
convertir tipos de datos, manipular parámetros de métodos, realizar cálculos
matemáticos, invocar programas remotos y locales, administrar el entorno de
aplicaciones y supervisar aplicaciones administradas y no administradas.
System.CodeDom
Contiene clases que se pueden utilizar para representar los elementos y la estructura de
un documento de código fuente. Estos elementos pueden usarse para modelar la
estructura de un documento de código fuente que se puede utilizar como código fuente
en un lenguaje compatible mediante la funcionalidad que proporciona el espacio de
nombres System.CodeDom.Compiler.
System.CodeDom.Compiler
Contiene tipos para administrar la generación y compilación de código fuente en los
lenguajes de programación compatibles. Los generadores de código pueden producir
código fuente en un lenguaje de programación específico basado en la estructura de los
modelos de código fuente CodeDOM (Code Document Object Model) que están
formados por elementos proporcionados por el espacio de nombres System.CodeDom.
Aplicación de software a dispositivos móviles Página 133
System.Collections
Contiene interfaces y clases que definen diversas colecciones de objetos, tales como
listas, colas, matrices de bits, tablas hash y diccionarios.
System.Collections.Generic
Contiene interfaces y clases que definen colecciones genéricas, que permitirán a los
usuarios crear colecciones con establecimiento inflexible de tipos que proporcionan
mejor seguridad y rendimiento de tipos que las colecciones con establecimiento inflexible
de tipos no genéricas.
System.Collections.ObjectModel
Contiene clases que se pueden utilizar como colecciones en el modelo de objetos de
una biblioteca reutilizable. Utilice estas clases cuando las propiedades o métodos
devuelven colecciones.
System.Collections.Specialized
Contiene colecciones especializadas y con establecimiento inflexible de tipos; por
ejemplo, un diccionario de listas vinculadas, un vector de bits o colecciones que sólo
contienen cadenas.
System.ComponentModel
Proporciona clases que se utilizan para implementar el comportamiento de los
componentes y controles en tiempo de diseño y en tiempo de ejecución. Este espacio de
nombres incluye las clases e interfaces necesarias para implementar atributos,
convertidores de tipos, enlaces a orígenes de datos y componentes de licencia.
System.ComponentModel.Design
Contiene clases que los desarrolladores pueden utilizar para generar un comportamiento
personalizado de los componentes en tiempo de diseño e interfaces de usuario para
configurar los componentes en tiempo de diseño. El entorno en tiempo de diseño
proporciona sistemas que permiten a los desarrolladores organizar los componentes y
configurar sus propiedades.
Página 134 Aplicación de software a dispositivos móviles
System.ComponentModel.Design.Data
Contiene clases para implementar el comportamiento en tiempo de diseño de los
componentes relacionados con datos.
System.ComponentModel.Design.Serialization
Proporciona tipos que admiten la personalización y el control de la serialización en
tiempo de diseño.
System.Configuration
Contiene los tipos que proporcionan el modelo de programación para controlar los datos
de configuración.
System.Configuration.Assemblies
Contiene clases que se utilizan para configurar un ensamblado.
System.Configuration.Install
Proporciona clases que permiten escribir instaladores personalizados para los
componentes propios. La clase Installer es la clase base para todos los instaladores
personalizados de .NET Framework.
System.Configuration.Provider
Contiene las clases base compartidas por aplicaciones de servidor y aplicaciones cliente
para admitir un modelo conectable y agregar o quitar funcionalidad con facilidad.
System.Data
Contiene clases que constituyen la mayoría de la arquitectura ADO.NET. La arquitectura
ADO.NET permite crear componentes que administran eficazmente los datos
procedentes de múltiples orígenes. En un escenario desconectado (como Internet),
ADO.NET proporciona las herramientas necesarias para solicitar, actualizar y reconciliar
los datos de sistemas de varios niveles. La arquitectura ADO.NET también se
Aplicación de software a dispositivos móviles Página 135
implementa en aplicaciones cliente, como Windows Forms, o en las páginas HTML
creadas por ASP.NET.
System.Data.Common
Contiene clases compartidas por los proveedores de datos de .NET Framework. Un
proveedor de datos de .NET Framework describe una colección de clases que se utiliza
para tener acceso a un origen de datos, como una base de datos, en el espacio
administrado.
System.Data.Design
Contiene clases que se pueden utilizar para generar un conjunto de datos con tipo
personalizado.
System.Data.Linq
Contiene clases para obtener acceso a datos relacionales como objetos. DataContext y
las clases relacionadas se pueden utilizar para leer, crear, actualizar y eliminar los
objetos asignados a una base de datos utilizando la asignación especificada como
atributos en el modelo de objetos o en un archivo XML externo independiente.
System.Data.Linq.Mapping
Proporciona acceso mediante programación a la información de asignación que se utiliza
en LINQ to SQL.
System.Data.Odbc
Contiene clases que encapsulan el proveedor de datos de .NET Framework para ODBC.
El proveedor de datos de .NET Framework para ODBC describe una colección de clases
que se utiliza para obtener acceso a un origen de datos ODBC en el espacio
administrado.
System.Data.OleDb
Contiene clases que encapsulan el proveedor de datos de .NET Framework para OLE
DB. El proveedor de datos de .NET Framework para OLE DB describe una colección de
clases que se utiliza para obtener acceso a un origen de datos OLE DB en el espacio
administrado.
Página 136 Aplicación de software a dispositivos móviles
System.Data.OracleClient
Contiene clases que encapsulan el proveedor de datos de .NET Framework para Oracle.
El proveedor de datos de .NET Framework para Oracle describe una colección de clases
que se utiliza para obtener acceso a un origen de datos de Oracle en el espacio
administrado.
System.Data.Sql
Contiene clases que admiten funcionalidad específica de SQL Server. Las extensiones
API de esta clase se agregan al Proveedor de datos de .NET Framework para SQL
Server (System.Data.SqlClient).
System.Data.SqlClient
Contiene clases que encapsulan el Proveedor de datos de .NET Framework para SQL
Server. El proveedor de datos de .NET Framework para SQL Server describe una
colección de clases que se utiliza para obtener acceso a una base de datos de SQL
Server en el espacio administrado.
System.Data.SqlServerCE
Describe una colección de clases que se puede utilizar para obtener acceso a una base
de datos de SQL Server CE de dispositivos basados en Windows CE en el entorno
administrado. Mediante este espacio de nombres se pueden crear bases de datos de
SQL Server CE en un dispositivo así como establecer conexiones a bases de datos de
SQL Server que se encuentran en un dispositivo o un servidor remoto.
System.Data.SqlTypes
Contiene clases para los tipos de datos nativos de SQL Server. Estas clases ofrecen una
alternativa más rápida a otros tipos de datos. El uso de estas clases en este espacio de
nombres ayuda a evitar errores de conversión de tipos causados en situaciones en las
que podría producirse una pérdida de precisión. Dado que otros tipos de datos se
convierten en segundo plano a SqlTypes y viceversa, la creación y el uso explícitos de
objetos en este espacio de nombres conllevan también un código más rápido.
System.Diagnostics
Aplicación de software a dispositivos móviles Página 137
Proporciona clases que permiten interactuar con procesos del sistema, registros de
eventos y contadores de rendimiento. Este espacio de nombres también proporciona
clases que permiten depurar la aplicación y realizar un seguimiento de la ejecución del
código. Para obtener más información, vea las clases Trace y Debug.
System.Diagnostics.CodeAnalysis
Contiene clases para la interacción con herramientas de análisis de código. Las
herramientas de análisis de código se utilizan para comprobar si el código se ajusta a las
convenciones de codificación, como son las reglas de nomenclatura o las de seguridad.
System.Diagnostics.Design
Contiene clases que se pueden utilizar para ampliar la compatibilidad en tiempo de
diseño de la supervisión y la instrumentación de las aplicaciones.
System.Diagnostics.SymbolStore
Proporciona clases que permiten leer y escribir información de símbolos de depuración,
como una línea de código fuente de las asignaciones del lenguaje intermedio de
Microsoft (MSIL). Los compiladores para .NET Framework pueden almacenar la
información de símbolos de depuración en los archivos de base de datos del
programador (PDB). Los depuradores y las herramientas del analizador de código
pueden leer la información de símbolos de depuración en tiempo de ejecución.
System.DirectoryServices
Proporciona fácil acceso a Active Directory desde código administrado. El espacio de
nombres contiene dos clases de componentes, DirectoryEntry y DirectorySearcher, que
utilizan la tecnología de interfaces de servicios de Active Directory (Active Directory
Services Interfaces, ADSI). ADSI es el conjunto de interfaces que Microsoft proporciona
como una herramienta flexible que permite trabajar con un gran número de proveedores
de red. ADSI permite al administrador localizar y administrar con relativa facilidad los
recursos de una red, independientemente del tamaño de esta última.
System.DirectoryServices.ActiveDirectory
Página 138 Aplicación de software a dispositivos móviles
Proporciona un modelo de objetos de abstracción de alto nivel que genera tareas de
servicio de directorio de Microsoft® Active Directory®. Los conceptos de servicio de
directorio de Active Directory® como bosque, dominio, sitio, subred, partición y esquema
forman parte del modelo de objetos.
System.DirectoryServices.Protocols
Proporciona los métodos definidos en los estándares LDAP (Protocolo ligero de acceso
a directorios) versión 3 (V3) y DSML (Directory Services Markup Language) versión 2
(V2).
System.Drawing
Proporciona acceso a la funcionalidad básica de gráficos de GDI+. En los espacios de
nombres System.Drawing.Drawing2D, System.Drawing.Imaging y System.Drawing.Text
se proporciona funcionalidad más avanzada.
System.Drawing.Design
Contiene clases que amplían la lógica y el dibujo de las interfaces de usuario (UI) en
tiempo de diseño. Se puede ampliar aún más esta funcionalidad en tiempo de diseño
para crear elementos de cuadro de herramientas personalizados, editores de valores
específicos de tipos que pueden editar y representar gráficamente valores de los tipos
admitidos, o convertidores de tipos que pueden realizar conversiones de valores entre
determinados tipos. Este espacio de nombres proporciona el marco de trabajo básico
para desarrollar extensiones a la interfaz de usuario en tiempo de diseño.
System.Drawing.Drawing2D
Proporciona funcionalidad bidimensional y de gráficos vectoriales avanzada. Este
espacio de nombres incluye los pinceles de degradado, la clase Matrix (que se utiliza
para definir transformaciones geométricas) y la clase GraphicsPath.
System.Drawing.Imaging
Proporciona funcionalidad avanzada de procesamiento de imágenes de GDI+. Las
funciones básicas de gráficos las proporciona el espacio de nombres System.Drawing.
System.Drawing.Printing
Aplicación de software a dispositivos móviles Página 139
Proporciona servicios relacionados con la impresión. Normalmente, se crea una nueva
instancia de la clase PrintDocument, se establecen las propiedades que describen lo que
se va a imprimir y se llama al método Print para imprimir el documento.
System.Drawing.Text
Proporciona funcionalidad tipográfica avanzada de GDI+. Las funciones básicas de
gráficos las proporciona el espacio de nombres System.Drawing. Las clases incluidas en
este espacio de nombres permiten a los usuarios crear y utilizar colecciones de fuentes.
System.EnterpriseServices
Proporciona una infraestructura importante para aplicaciones empresariales. COM+
proporciona una arquitectura de servicios para los modelos de programación de
componentes implementados en un entorno empresarial. Este espacio de nombres
proporciona objetos de .NET Framework con acceso a servicios COM+, por lo que los
objetos de .NET Framework son más prácticos para las aplicaciones empresariales.
System.EnterpriseServices.CompensatingResourceManager
Proporciona clases que permiten utilizar un Administrador de compensación de recursos
(CRM) en código administrado. Un CRM es un servicio proporcionado por COM+ que
permite incluir objetos no transaccionales en las transacciones del Coordinador de
transacciones distribuidas de Microsoft (DTC). Aunque los CRM no ofrecen las
funcionalidades de un administrador de recursos completo, proporcionan la atomicidad
transaccional (comportamiento todo o nada) y la durabilidad por medio del registro de
recuperación.
System.EnterpriseServices.Internal
Proporciona compatibilidad de infraestructura para los servicios COM+. Las clases e
interfaces incluidas en este espacio de nombres están diseñadas específicamente para
admitir llamadas en System.EnterpriseServices de las clases COM+ no administradas.
System.Globalization
Contiene clases que definen datos relativos a la referencia cultural, tales como idioma,
país o región, calendario, formatos de fecha, moneda y números, así como el criterio de
Página 140 Aplicación de software a dispositivos móviles
ordenación para cadenas. Estas clases resultan útiles para escribir aplicaciones
globalizadas (de uso internacional).
System.IO
Contiene tipos que permiten la lectura y escritura sincrónicas y asincrónicas en archivos
y secuencias de datos.
System.IO.Compression
Contiene clases que proporcionan compresión y descompresión básicas para las
secuencias.
System.IO.IsolatedStorage
Contiene tipos que permiten crear y utilizar almacenes aislados. Estos almacenes
permiten leer y escribir datos a los que los fragmentos de código de menos confianza no
pueden tener acceso y permiten evitar la exposición de información confidencial que se
pueda guardar en cualquier otro lugar del sistema de archivos. Los datos se almacenan
en compartimientos aislados por el usuario actual y por el ensamblado en el que existe
el código.
System.IO.Ports
Contiene clases que controlan los puertos serie, proporcionando un marco de trabajo
para E/S sincrónica y controlada por eventos, acceso para fijar e interrumpir los estados,
acceso a las propiedades del controlador serie y enumeraciones para especificar las
características de los puertos.
System.Linq
Proporciona clases e interfaces que admiten consultas que utilizan Language-Integrated
Query (LINQ).
System.Linq.Expressions
Contiene las clases, interfaces y enumeraciones que permiten representar expresiones
de código del nivel de lenguaje como objetos en forma de árboles de expresión.
System.Management
Aplicación de software a dispositivos móviles Página 141
Proporciona acceso a un variado conjunto de datos y eventos de administración relativos
al sistema, dispositivos y aplicaciones instrumentados para Windows Management
Infrastructure (WMI).
System.Management.Instrumentation
Proporciona las clases necesarias para instrumentar aplicaciones de administración y
exponer sus datos y eventos de administración a posibles consumidores a través de
WMI. De este modo, los consumidores como Microsoft Application Center o Microsoft
Operations Manager podrán administrar fácilmente la aplicación, que se podrá
supervisar y configurar mediante secuencias de comandos de administrador u otras
aplicaciones, tanto administradas como no administradas.
System.Messaging
Proporciona clases que permiten conectar con colas de mensajes de la red,
supervisarlas, administrarlas y enviar, recibir o leer mensajes.
System.Messaging.Design
Contiene clases que se pueden utilizar para ampliar la compatibilidad en tiempo de
diseño de las clases System.Messaging.
System.Net
Proporciona una interfaz de programación sencilla para muchos de los protocolos que se
utilizan en las redes actuales. Las clases WebRequest y WebResponse forman la base
de lo que se denomina protocolos conectables, una implementación de servicios de red
que permite desarrollar aplicaciones que utilizan recursos de Internet sin preocuparse de
los detalles específicos de cada uno de los protocolos.
System.Net.Cache
Define los tipos y las enumeraciones utilizadas para definir las directivas de la caché
para los recursos obtenidos utilizando las clases WebRequest y HttpWebRequest.
System.Net.Configuration
Página 142 Aplicación de software a dispositivos móviles
Contiene clases que utilizan las aplicaciones para obtener acceso mediante
programación y actualizar las opciones de configuración para los espacios de nombres
System.Net.
System.Net.Mail
Contiene clases utilizadas para enviar correo electrónico a un servidor SMTP (Protocolo
simple de transferencia de correo) para su entrega.
System.Net.Mime
Contiene tipos utilizados para representar los encabezados MIME (Multipurpose Internet
Mail Exchange). Estos tipos se utilizan con los tipos del espacio de nombres
System.Net.Mail para especificar los encabezados Content-Type, Content-Disposition y
Content-transfer-Encoding al enviar un correo electrónico mediante la clase SmtpClient.
System.Net.NetworkInformation
Proporciona acceso a los datos de tráfico de la red, información de direcciones de red y
notificación de cambios de dirección para el equipo local. El espacio de nombres
también contiene las clases que implementan la utilidad Ping. Puede utilizar Ping y las
clases relacionadas para comprobar si se puede conectar con un equipo a través de la
red.
System.Net.Sockets
Proporciona una implementación administrada de la interfaz de Windows Sockets
(Winsock) para desarrolladores que necesitan controlar el acceso a la red.
System.Reflection
Contiene clases e interfaces que proporcionan una vista administrada de los tipos
cargados, métodos y campos, con la capacidad de crear e invocar dinámicamente los
tipos.
System.Reflection.Emit
Contiene clases que permiten a un compilador o una herramienta emitir metadatos así
como lenguaje intermedio de Microsoft (MSIL) y, opcionalmente, generar un archivo PE
Aplicación de software a dispositivos móviles Página 143
en el disco. Los principales clientes de estas clases son los motores de secuencias de
comandos y los compiladores.
System.Resources
Proporciona clases e interfaces que permiten a los desarrolladores crear, almacenar y
administrar varios recursos específicos de la referencia cultural utilizados en una
aplicación.
System.Resources.Tools
Contiene la clase StronglyTypedResourceBuilder, que proporciona compatibilidad para
recursos con establecimiento inflexible de tipos. A partir de .NET Framework versión 2.0,
esta característica en tiempo de compilación encapsula el acceso a los recursos creando
clases que contienen un conjunto de propiedades de sólo lectura (get) estáticas, lo que
facilita el consumo de recursos.
System.Runtime
Contiene tipos avanzados que admiten diversos espacios de nombres tales como
System, los espacios de nombres Runtime y los espacios de nombres Security.
System.Runtime.ConstrainedExecution
Define un conjunto de tipos que enumeran y definen un contrato para la confiabilidad
entre el autor de algún código y los desarrolladores que toman una dependencia de ese
código.
System.Runtime.Hosting
Contiene tipos avanzados que se utilizan en la activación de aplicaciones dentro de los
dominios de aplicación.
System.Runtime.CompilerServices
Proporciona funcionalidad a los programadores de compiladores que utilicen código
administrado para especificar atributos en los metadatos que afectan al comportamiento
de Common Language Runtime en tiempo de ejecución. Las clases en este espacio de
nombres son sólo para los programadores de compiladores.
Página 144 Aplicación de software a dispositivos móviles
System.Runtime.InteropServices
Proporciona una amplia variedad de miembros compatibles con la interoperabilidad
COM y los servicios de invocación de plataforma. Si no conoce estos servicios.
System.Runtime.InteropServices.ComTypes
Contiene métodos que son definiciones de funciones COM para código administrado.
Estas funciones reemplazan a los métodos UCOM*, ahora obsoletos, en el espacio de
nombres System.Runtime.InteropServices.
System.Runtime.InteropServices.CustomMarshalers
Es compatible con la infraestructura de .NET y no está diseñado para que se utilice
directamente desde el código.
System.Runtime.InteropServices.Expando
Contiene la interfaz IExpando, que permite modificar un objeto agregando o quitando sus
miembros.
System.Runtime.Remoting
Proporciona clases e interfaces que permiten a los desarrolladores crear y configurar
aplicaciones distribuidas.
System.Runtime.Remoting.Activation
Proporciona clases y objetos que admiten la activación de objetos remotos en el servidor
o el cliente.
System.Runtime.Remoting.Channels
Contiene clases que admiten y controlan canales y receptores de canales, que se
utilizan como medio de transporte cuando un cliente llama a un método de un objeto
remoto.
System.Runtime.Remoting.Channels.Http
Aplicación de software a dispositivos móviles Página 145
Contiene canales que utilizan el protocolo HTTP para llevar mensajes y objetos a
ubicaciones remotas o viceversa. De forma predeterminada, los canales HTTP codifican
las llamadas a objetos y métodos en formato SOAP para la transmisión, pero se pueden
especificar otros receptores de formateadores de codificación y descodificación en las
propiedades de configuración de un canal.
System.Runtime.Remoting.Channels.Ipc
Define un canal de comunicación para la interacción remota que utiliza el sistema de
comunicaciones entre procesos (IPC) del sistema operativo Windows. Dado que no
utiliza la comunicación por red, el canal IPC es mucho más rápido que los canales HTTP
y TCP, pero sólo se puede utilizar para la comunicación entre los dominios de aplicación
del mismo equipo físico.
System.Runtime.Remoting.Channels.Tcp
Contiene canales que utilizan el protocolo TCP para llevar mensajes y objetos a
ubicaciones remotas o viceversa. De forma predeterminada, los canales TCP codifican
las llamadas a objetos y métodos en formato binario para la transmisión, pero se pueden
especificar otros receptores de formateadores de codificación y descodificación en las
propiedades de configuración de un canal.
System.Runtime.Remoting.Contexts
Contiene objetos que definen los contextos en los que residen todos los objetos. Un
contexto es una serie ordenada de propiedades que define un entorno para los objetos
que contiene. Los contextos se crean durante el proceso de activación de los objetos
configurados para requerir determinados servicios automáticos, como la sincronización,
las transacciones, la activación just-in-time (JIT), la seguridad, etc. En un contexto
pueden residir varios objetos.
System.Runtime.Remoting.Lifetime
Contiene clases que administran la duración de los objetos remotos. Tradicionalmente,
la recolección distribuida de elementos no utilizados recurre a los recuentos de
referencias y comandos ping para controlar la duración de los objetos. Esto funciona
bien cuando hay pocos clientes por servicio, pero no se ajusta adecuadamente cuando
hay miles de clientes por cada servicio. El servicio de duración remoto asocia una
concesión a cada servicio y, cuando ésta vence, elimina el servicio. El servicio de
Página 146 Aplicación de software a dispositivos móviles
duración puede desempeñar la función de un colector distribuido de elementos no
utilizados tradicional y se adapta bien al aumentar el número de clientes por servidor.
System.Runtime.Remoting.Messaging
Contiene clases que se utilizan para crear mensajes y procesarlos de forma remota. La
infraestructura de interacción remota utiliza mensajes para comunicarse con objetos
remotos. Los mensajes se utilizan para transmitir llamadas a métodos remotos, activar
objetos remotos y comunicar información. Un objeto de mensaje lleva una serie de
propiedades con nombre, entre las que se incluyen identificadores de acción,
información de envío y parámetros.
System.Runtime.Remoting.Metadata
Contiene clases y atributos que se pueden utilizar para personalizar la generación y el
procesamiento de SOAP para objetos y campos. Las clases en este espacio de nombres
se pueden utilizar para indicar el encabezado SOAPAction, el tipo de resultado, el
nombre de elemento XML y el identificador URI del espacio de nombres XML del
método.
System.Runtime.Remoting.Metadata.W3cXsd2001
Contiene la definición de esquema XML (XSD) establecida por el Consorcio World Wide
Web (W3C) en 2001. La especificación de W3C titulada "XML Schema Part2: Data
types" identifica el formato y el comportamiento de varios tipos de datos. Este espacio de
nombres contiene clases contenedoras para los tipos de datos que se ajustan a la
especificación de W3C. Todos los tipos de fecha y hora se ajustan a la especificación de
estándares ISO.
System.Runtime.Remoting.MetadataServices
Contiene las clases utilizadas por la herramienta de línea de comandos Soapsuds.exe y
el código de usuario para convertir metadatos a esquemas XML, o viceversa, para la
infraestructura de interacción remota.
System.Runtime.Remoting.Proxies
Aplicación de software a dispositivos móviles Página 147
Contiene clases que controlan y proporcionan funcionalidad a los servidores proxy. Un
servidor proxy es un objeto local que constituye una imagen de un objeto remoto. Los
servidores proxy permiten a los clientes tener acceso a objetos más allá de los límites
remotos.
System.Runtime.Remoting.Services
Contiene clases de servicios que proporcionan funcionalidad a .NET Framework.
System.Runtime.Serialization
Contiene clases que se pueden utilizar para serializar y deserializar objetos. La
serialización es el proceso de convertir un objeto o un gráfico de objetos en una
secuencia lineal de bytes para su almacenamiento o transmisión a otra ubicación. La
deserialización es el proceso de volver a generar los objetos a partir de la información
almacenada.
System.Runtime.Serialization.Formatters
Proporciona enumeraciones, interfaces y clases comunes que utilizan los formateadores
de serialización.
System.Runtime.Serialization.Formatters.Binary
Contiene la clase BinaryFormatter, que se puede utilizar para serializar y deserializar los
objetos en formato binario.
System.Runtime.Serialization.Formatters.Soap
Contiene la clase SoapFormatter, que se puede utilizar para serializar y deserializar los
objetos en formato SOAP.
System.Security
Proporciona la estructura subyacente del sistema de seguridad de .NET Framework,
incluidas clases base relativa a permisos.
Página 148 Aplicación de software a dispositivos móviles
System.Security.AccessControl
System.Security.Cryptography
Proporciona servicios criptográficos, incluidas la codificación y descodificación seguras
de datos, así como muchas otras operaciones, como los cálculos hash, la generación de
números aleatorios y la autenticación de mensajes.
System.Security.Cryptography.Pkcs
Proporciona elementos de programación para Estándares de criptografía de clave
pública (PKCS, Public Key Cryptography Standards), incluidos los métodos para firmar
datos, intercambio de claves, solicitud de certificados, cifrado y descifrado de claves
públicas, así como otras funciones de seguridad.
System.Security.Cryptography.X509Certificates
Contiene la implementación de Common Language Runtime del certificado Authenticode
X.509 v.3. Este certificado se firma con una clave privada que identifica de forma única y
segura al propietario del certificado.
System.Security.Cryptography.Xml
Contiene clases que admiten la creación y validación de firmas digitales XML. Las clases
en este espacio de nombres implementan la recomendación del Consorcio World Wide
Web, "XML-Signature Syntax and Processing", descrita en:
http://www.w3.org/TR/xmldsig-core/.
System.Security.Permissions
Define clases que controlan el acceso a operaciones y recursos a partir de una directiva.
System.Security.Policy
Contiene grupos de código, condiciones de pertenencia y evidencia. Estos tres tipos de
clase se utilizan para crear las reglas que aplica el sistema de directivas de seguridad de
.NET Framework. Las clases de evidencia son la entrada de la directiva de seguridad y
las condiciones de pertenencia son los modificadores; juntas, crean instrucciones de
directiva y determinan el conjunto de permisos concedido. Los niveles de directivas y los
grupos de código constituyen la estructura de la jerarquía de directivas. Los grupos de
Aplicación de software a dispositivos móviles Página 149
código son la encapsulación de una regla y se organizan jerárquicamente en un nivel de
directiva.
System.Security.Principal
Define un objeto principal que representa el contexto de seguridad en el cual se ejecuta
código.
System.ServiceProcess
Proporciona clases que permiten implementar, instalar y controlar las aplicaciones de
servicios para Windows. Los servicios son ejecutables de ejecución prolongada que no
utilizan ninguna interfaz de usuario. La implementación de un servicio implica la herencia
de la clase ServiceBase y la definición de un comportamiento específico que se debe
procesar al pasar comandos de inicio, detención, pausa y continuación, así como el
comportamiento personalizado y las acciones que se deben adoptar cuando se cierra el
sistema.
System.Text
Contiene clases que representan codificaciones de caracteres ASCII, Unicode, UTF-7 y
UTF-8, clases base abstractas para realizar conversiones entre bloques de caracteres y
bloques de bytes, así como una clase auxiliar que manipula objetos String y les aplica
formato sin crear instancias intermedias de String.
System.Text.RegularExpressions
Contiene clases que proporcionan acceso al motor de expresiones regulares de .NET
Framework. El espacio de nombres proporciona funcionalidad de expresiones regulares
que se puede utilizar desde cualquier plataforma o lenguaje que se ejecute con Microsoft
.NET Framework.
System.Threading
Proporciona clases e interfaces que habilitan la programación multiproceso. Además de
clases para la sincronización de actividades de subprocesos y el acceso a datos (Mutex,
Monitor, Interlocked, AutoResetEvent, etc), este espacio de nombres incluye una clase
ThreadPool que permite utilizar un grupo de subprocesos suministrados por el sistema y
Página 150 Aplicación de software a dispositivos móviles
una clase Timer que ejecuta métodos de devolución de llamada en subprocesos del
grupo de subprocesos.
System.Timers
Proporciona el componente Timer, que permite provocar un evento en un intervalo
especificado.
System.Transactions
Contiene clases que permiten al código participar en transacciones. Las clases admiten
transacciones con varios participantes distribuidos, varias notificaciones de fase e
inscripciones duraderas.
System.Transactions.Configuration
Contiene clases que describen las opciones de configuración utilizadas por las clases
System.Transactions.
System.Web
Proporciona clases e interfaces que permiten la comunicación entre explorador y
servidor. Este espacio de nombres incluye la clase HttpRequest, que proporciona
información abundante sobre la solicitud HTTP actual, la clase HttpResponse, que
administra la salida HTTP al cliente, y el objeto HttpServerUtility, que proporciona acceso
a las utilidades y los procesos del servidor. System.Web también incluye clases para la
manipulación de las cookies, la transferencia de archivos, la información sobre las
excepciones y el control de la caché de resultados.
System.Web.Caching
Proporciona clases para almacenar en caché los datos que se utilizan con frecuencia en
el servidor. Incluye la clase Cache, un diccionario que permite almacenar objetos de
datos arbitrarios, como tablas hash y conjuntos de datos. Proporciona asimismo la
funcionalidad de caducidad para dichos objetos así como métodos que permiten agregar
y quitar los objetos. Se pueden agregar también los objetos con dependencia de otros
archivos o entradas de la caché, además de realizar devoluciones de llamada para
notificar a la aplicación cuando se quita un objeto de la memoria caché.
System.Web.Compilation
Aplicación de software a dispositivos móviles Página 151
Contiene clases que permiten generar y compilar los tipos de archivo personalizados
dentro del entorno de generación ASP.NET.
System.Web.Configuration
Contiene clases que se utilizan para configurar ASP.NET.
System.Web.Handlers
Contiene clases del controlador HTTP que procesan las solicitudes HTTP a un servidor
Web.
System.Web.Hosting
Proporciona la funcionalidad necesaria para alojar aplicaciones ASP.NET de
aplicaciones administradas fuera de los servicios de Microsoft Internet Information
Services (IIS).
System.Web.Mail
Las clases de este espacio de nombres están obsoletas; utilice en su lugar las clases
incluidas en el espacio de nombres System.Net.Mail. Contiene clases que permiten crear
y enviar mensajes mediante el componente de mensajería CDOSYS. El mensaje de
correo se entrega a través del servicio de correo SMTP integrado en Microsoft Windows
2000 o a través de un servidor SMTP arbitrario. Las clases en este espacio de nombres
se pueden utilizar desde ASP.NET o cualquier aplicación administrada.
System.Web.Management
Contiene clases e interfaces que permiten administrar y supervisar el estado de las
aplicaciones Web.
System.Web.Mobile
Contiene las principales funciones, incluidos la autenticación y el control de errores,
necesarias para generar las aplicaciones Web ASP.NET Mobile.
System.Web.Profile
Contiene clases que se utilizan para implementar el perfil de usuario de ASP.NET en
aplicaciones de servidor Web.
Página 152 Aplicación de software a dispositivos móviles
System.Web.RegularExpressions
Proporciona las expresiones regulares que se utilizan para analizar los archivos de
ASP.NET. Todos los miembros del espacio de nombres
System.Web.RegularExpressions son descendientes de la clase Regex.
System.Web.Security
Contiene clases que se utilizan para implementar la seguridad de ASP.NET en
aplicaciones de servidor Web.
System.Web.Services
Se compone de las clases que permiten crear servicios Web XML mediante clientes de
servicios Web XML y ASP.NET. Los servicios Web XML son aplicaciones que permiten
intercambiar mensajes en un entorno de correspondencia imprecisa mediante protocolos
estándar como HTTP, XML, XSD, SOAP y WSDL. Los servicios Web XML permiten
generar aplicaciones modulares ubicadas dentro y fuera de empresas de entornos
heterogéneos, por lo que pueden interoperar con una amplia variedad de
implementaciones, plataformas y dispositivos. Los mensajes XML basados en SOAP de
estas aplicaciones pueden tener partes debidamente definidas (estructuradas y con
establecimiento de tipos) o pueden tener partes definidas de manera imprecisa
(mediante XML arbitrario). La capacidad de los mensajes de evolucionar con el tiempo
sin romper el protocolo es fundamental para la flexibilidad y la solidez de los servicios
Web XML como componente básico para el futuro del Web.
System.Web.Services.Configuration
Consta de las clases que configuran la forma en que se ejecutan los servicios Web XML
creados con ASP.NET.
System.Web.Services.Description
Consta de las clases que permiten describir públicamente un servicio Web XML
mediante el Lenguaje de descripción de servicios Web (WSDL). Cada clase en este
espacio de nombres se corresponde con un elemento específico de la especificación
WSDL, y la jerarquía de clases se corresponde con la estructura XML de un documento
WSDL válido.
Aplicación de software a dispositivos móviles Página 153
System.Web.Services.Discovery
Consta de las clases que permiten a los clientes de servicios Web XML encontrar los
servicios Web XML disponibles en un servidor Web mediante un proceso denominado
Descubrimiento de servicios Web XML.
System.Web.Services.Protocols
Consta de las clases que definen los protocolos utilizados para transmitir datos a través
de la red durante la comunicación entre los clientes del servicio Web XML y los servicios
Web XML creados con ASP.NET.
System.Web.SessionState
Proporciona las clases e interfaces que habilitan el almacenamiento de los datos
específicos de un cliente individual en una aplicación Web del servidor. Los datos
relativos al estado de la sesión se utilizan para ofrecer al cliente la apariencia de una
conexión permanente con la aplicación. La información de estado se puede almacenar
en la memoria del proceso local o, en el caso de las configuraciones de baterías de
servidores Web, fuera de proceso mediante el servicio de estado de ASP.NET o una
base de datos de SQL Server.
System.Web.UI
Proporciona las clases e interfaces que permiten crear los controles y páginas que
aparecerán en las aplicaciones Web como interfaz de usuario de una página Web. Este
espacio de nombres incluye la clase Control, que proporciona a todos los controles, ya
sean controles HTML, controles Web o controles de usuario, un conjunto común de
funcionalidades. También incluye el control Page, que se genera automáticamente
siempre que se realiza una solicitud de una página en la aplicación Web. También se
proporcionan clases que ofrecen la funcionalidad de enlace de datos a los controles de
servidor de formularios Web Forms, la capacidad de guardar el estado de la vista de un
control o una página determinada, así como la funcionalidad de análisis para los
controles programables y literales.
System.Web.UI.Adapters
Página 154 Aplicación de software a dispositivos móviles
Contiene las clases base para los adaptadores de control y los adaptadores de página,
que permiten reemplazar estados del ciclo de vida de las páginas y los controles para
modificar su marcado o comportamiento predeterminado para los nuevos estándares de
marcado o para exploradores concretos.
System.Web.UI.Design
Contiene clases que se pueden utilizar para ampliar la compatibilidad en tiempo de
diseño de los controles de servidor Web y de formularios Web Forms.
System.Web.UI.Design.MobileControls
Obsoleta. Contiene clases que proporcionan la compatibilidad en tiempo de diseño para
las clases del espacio de nombres System.Web.UI.MobileControls. Las clases de este
espacio de nombres están obsoletas; utilice las clases de
System.Web.UI.Design.WebControls en su lugar.
System.Web.UI.Design.MobileControls.Converters
Contiene clases que proporcionan la compatibilidad en tiempo de diseño para los
convertidores de tipos de datos en controles móviles.
System.Web.UI.Design.WebControls
Contiene clases que se pueden utilizar para ampliar la compatibilidad en tiempo de
diseño de los controles de servidor Web.
System.Web.UI.Design.WebControls.WebParts
Contiene clases que proporcionan la compatibilidad en tiempo de diseño para los
controles derivados de las clases del espacio de nombres
System.Web.UI.WebControls.WebParts.
System.Web.UI.HtmlControls
Se compone de una colección de clases que permiten crear controles de servidor HTML
en una página de formularios Web Forms. Los controles de servidor HTML se ejecutan
en el servidor y se asignan directamente a las etiquetas HTML estándar compatibles con
Aplicación de software a dispositivos móviles Página 155
la mayoría de los exploradores. Esto permite controlar mediante programación los
elementos HTML de una página de formularios Web Forms.
System.Web.UI.MobileControls
Obsoleta. Contiene un conjunto de controles de servidor ASP.NET que pueden procesar
de manera inteligente la aplicación para diferentes dispositivos móviles. Las clases de
este espacio de nombres están obsoletas; utilice los controles de
System.Web.UI.WebControls en su lugar.
System.Web.UI.MobileControls.Adapters
Contiene clases que permiten reemplazar las fases del ciclo de vida de un control móvil
para modificar su marcado o comportamiento HTML, CHTML o WML predeterminado
para los nuevos estándares de marcado o para exploradores y dispositivos móviles
concretos.
System.Web.UI.MobileControls.Adapters.XhtmlAdapters
Contiene clases que permiten reemplazar las fases del ciclo de vida de un control móvil
para modificar su marcado o comportamiento XHTML predeterminado para los nuevos
estándares de marcado o para exploradores y dispositivos móviles concretos.
System.Web.UI.WebControls
Contiene clases que permiten crear controles de servidor Web en una página Web. Los
controles de servidor Web se ejecutan en el servidor e incluyen controles de formulario
como botones y cuadros de texto. También incluyen controles para fines especiales
como un calendario. Dado que los controles de servidor Web se ejecutan en el servidor,
se pueden controlar estos elementos mediante programación. Los controles de servidor
Web son más abstractos que los controles de servidor HTML. Su modelo de objetos no
refleja necesariamente la sintaxis HTML.
System.Web.UI.WebControls.Adapters
Contiene clases que permiten reemplazar las fases del ciclo de vida de un control Web
para modificar el marcado o el comportamiento predeterminado de un control para los
nuevos estándares de marcado o para exploradores concretos.
System.Web.UI.WebControls.WebParts
Página 156 Aplicación de software a dispositivos móviles
Contiene un conjunto integrado de clases e interfaces para crear páginas Web cuyo
aspecto y comportamiento podrán modificar (personalizar) los usuarios finales. La
configuración definida por el usuario para cada página se guarda para las sesiones
futuras del explorador.
System.Web.Util
Contiene clases que permiten a los métodos de devolución de llamada ejecutarse bajo el
ámbito de una transacción y el envío del trabajo a subprocesos separados.
System.Windows.Forms
Contiene clases para crear aplicaciones basadas en Windows y que aprovechan
plenamente las características avanzadas de interfaz de usuario disponibles en este
sistema operativo.
System.Windows.Forms.ComponentModel.Com2Interop
Contiene clases auxiliares que Visual Studio utiliza para mostrar páginas de propiedades
mientras se está en el modo diseño.
System.Windows.Forms.Design
Contiene clases que son compatibles con la configuración y el comportamiento en
tiempo de diseño de los componentes de Windows Forms. Estas clases se componen
de: clases de diseñador que proporcionan compatibilidad con los componentes de
Windows Forms, un conjunto de servicios en tiempo de diseño, clases UITypeEditor para
configurar determinados tipos de propiedades, así como clases para importar controles
ActiveX.
System.Windows.Forms.Design.Behavior
Contiene clases que permiten crear comportamiento personalizado de la interfaz de
usuario para los componentes en tiempo de diseño.
System.Windows.Forms.Layout
Contiene clases que admiten los comportamientos del diseño tanto en tiempo de diseño
como en tiempo de ejecución.
Aplicación de software a dispositivos móviles Página 157
System.Windows.Forms.PropertyGridInternal
Proporciona la compatibilidad interna para el control PropertyGrid. Las clases de este
espacio de nombres admiten la infraestructura de .NET Framework y no están diseñadas
para ser utilizadas directamente en el código.
System.Xml
Proporciona compatibilidad basada en estándares para procesar XML.
System.Xml.Schema
Contiene las clases XML que proporcionan compatibilidad basada en estándares para
los esquemas XSD.
System.Xml.Serialization
Contiene clases que se utilizan para serializar objetos en documentos o secuencias de
formato XML.
System.Xml.XPath
Contiene el analizador y el motor de evaluación de XPath. Es compatible con la
recomendación de W3C titulada "XML Path Language (XPath) Version 1.0"
(www.w3.org/TR/xpath).
System.Xml.Xsl
Proporciona compatibilidad con las transformaciones XSLT (Extensible Stylesheet
Transformation). Es compatible con la recomendación de W3C titulada "XSL
Transformations (XSLT) Version 1.0" (www.w3.org/TR/xslt).
System.Xml.Xsl.Runtime
Proporciona compatibilidad interna para las clases del espacio de nombres
System.Xml.Xsl. Las clases de este espacio de nombres admiten la infraestructura de
.NET Framework y no están diseñadas para ser utilizadas directamente en el código.
Página 158 Aplicación de software a dispositivos móviles
Apéndice “Códigos de las herramientas de apoyo de la aplicación de ICE”
CALCULADORA
using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace calculadora
{
public partial class calculador : Form
{
private enum Entrada
{
NINGUNA,
DIGITO,
OPERADOR,
CE,
MEMMAS
}
private Entrada ultimaEntrada;
private bool comaDecimal;
private char operador;
private byte numOperandos;
private double operando1;
private double operando2;
private double memoria;
private double carry;
public calculador()
{
InitializeComponent();
ultimaEntrada = Entrada.NINGUNA;
comaDecimal = false;
operador = '\0';
numOperandos = 0;
operando1 = 0;
operando2 = 0;
memoria = 0;
}
private void btDigito_Click(object sender, EventArgs e)
{
Button objButton = (Button)sender;
if (ultimaEntrada != Entrada.DIGITO)
{
if (objButton.Text == "0")
{
return;
}
etPantalla.Text = "";
ultimaEntrada = Entrada.DIGITO;
comaDecimal = false;
}
etPantalla.Text += objButton.Text;
}
private void btComaDec_Click(object sender, EventArgs e)
Aplicación de software a dispositivos móviles Página 159
{
if (ultimaEntrada != Entrada.DIGITO)
{
etPantalla.Text = "0.";
ultimaEntrada = Entrada.DIGITO;
}
else if (comaDecimal == false)
etPantalla.Text = etPantalla.Text + ".";
comaDecimal = true;
}
private void btOperacion_Click(object sender, EventArgs e)
{
// Obtener el id del botón que generó el evento
Button objButton = (Button)sender;
// Obtener el texto del botón pulsado
string textoBoton = objButton.Text;
if ((numOperandos == 0) && (textoBoton[0] == '-'))
ultimaEntrada = Entrada.DIGITO;
if (ultimaEntrada == Entrada.DIGITO)
numOperandos += 1;
if (numOperandos == 1)
operando1 = double.Parse(etPantalla.Text);
else if (numOperandos == 2)
{
operando2 = double.Parse(etPantalla.Text);
switch (operador)
{
case '+':
operando1 += operando2;
break;
case '-':
operando1 -= operando2;
break;
case 'x':
operando1 *= operando2;
break;
case '/':
operando1 /= operando2;
break;
case '=':
operando1 = operando2;
break;
}
// Visualizar el resultado
amlResultado.Text = operando1.ToString();
numOperandos = 1;
}
operador = textoBoton[0]; // carácter de la posición 0
ultimaEntrada = Entrada.OPERADOR;
}
private void btTantoPorCiento_Click(object sender, EventArgs
e)
{
double resultado;
if (ultimaEntrada == Entrada.DIGITO)
{
resultado = operando1 * double.Parse(etPantalla.Text)
/ 100;
// Visualizar el resultado
amlResultado.Text = resultado.ToString();
Página 160 Aplicación de software a dispositivos móviles
// Simular que se ha hecho clic en "="
// btIgual.PerformClick();
btIgual.Capture = true;
// Enfocar la tecla %
btTantoPorCiento.Focus();
}
}
private void btIniciar_Click(object sender, EventArgs e)
{
etPantalla.Text = "0,";
ultimaEntrada = Entrada.NINGUNA;
comaDecimal = false;
operador = '\0';
numOperandos = 0;
operando1 = 0;
operando2 = 0;
}
private void btBorrarEntrada_Click(object sender, EventArgs e)
{
etPantalla.Text = "0.";
ultimaEntrada = Entrada.CE;
comaDecimal = false;
}
private void btCambiarSigno_Click(object sender, EventArgs e)
{
// Cambiar el signo del dato mostrado en la pantalla
double resultado;
resultado = -double.Parse(etPantalla.Text);
etPantalla.Text = resultado.ToString();
}
private void btRaizCuadrada_Click(object sender, EventArgs e)
{
double resultado;
resultado = Math.Sqrt(double.Parse(etPantalla.Text));
amlResultado.Text = resultado.ToString();
}
private void button15_Click(object sender, EventArgs e)
{
// Exponenciación
double resultado;
resultado = Math.Exp(double.Parse(etPantalla.Text));
amlResultado.Text = resultado.ToString();
}
private void button13_Click(object sender, EventArgs e)
{
// Logaritmo
double resultado;
resultado = Math.Log10(double.Parse(etPantalla.Text));
amlResultado.Text = resultado.ToString();
}
private void button14_Click(object sender, EventArgs e)
{
// Logaritmo neperiano
double resultado;
resultado = Math.Log(double.Parse(etPantalla.Text));
amlResultado.Text = resultado.ToString();
}
Aplicación de software a dispositivos móviles Página 161
private void button22_Click(object sender, EventArgs e)
{
// x al cuadrado
double resultado;
resultado = Math.Pow(double.Parse(etPantalla.Text), 2.0);
amlResultado.Text = resultado.ToString();
}
private void button19_Click(object sender, EventArgs e)
{
// x^y pendiente
double resultado;
if (numOperandos == 1)
operando1 = double.Parse(etPantalla.Text);
else if (numOperandos == 2)
{
operando2 = double.Parse(etPantalla.Text);
switch (operador)
{
case '^':
operando1 = Math.Pow(operando1, operando2);
break;
case '=':
operando1 = operando2;
break;
}
// Visualizar el resultado
}
numOperandos = 1;
amlResultado.Text = operando1.ToString();
}
private void button20_Click(object sender, EventArgs e)
{
// x al inverso
double resultado;
resultado = 1.0 / Math.Pow(double.Parse(etPantalla.Text),
2.0);
amlResultado.Text = resultado.ToString();
}
private void button18_Click(object sender, EventArgs e)
{
// Seno
double resultado;
resultado = Math.Sin(double.Parse(etPantalla.Text));
amlResultado.Text = resultado.ToString();
}
private void button16_Click(object sender, EventArgs e)
{
// Coseno
double resultado;
resultado = Math.Cos(double.Parse(etPantalla.Text));
amlResultado.Text = resultado.ToString();
}
private void button17_Click(object sender, EventArgs e)
{
// Tangente
double resultado;
resultado = Math.Tan(double.Parse(etPantalla.Text));
amlResultado.Text = resultado.ToString();
Página 162 Aplicación de software a dispositivos móviles
}
}
Conversor de números complejos a polares
using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace complex
{
public partial class Rectpolar : Form
{
// variables de tipo publico utilizadas en el programa
double d, a, b, r, c, f,a2;
public Rectpolar()
{
InitializeComponent();
}
private void menuItem3_Click_1(object sender, EventArgs e)
{
//sentencia del boton del menu opciones para salir de la
aplicacion completa
Application.Exit();
}
private void button3_Click(object sender, EventArgs e)
//boton salir
{
//introduce cadenas vacias para limpiar el texto existente
mag2.Text = "";
ang2.Text = "";
real2.Text = "";
imag2.Text = "";
}
private void button4_Click(object sender, EventArgs e)
//Boton convertir en la ficha forma polar a cartesiana
{
try
{ //se aplica el algoritmo correspondiente`para la
conversion
a2 = double.Parse(mag2.Text);
b = double.Parse(ang2.Text);
c = ((b * Math.PI) / 180);
d = a2*Math.Cos(c);
r = a2*Math.Sin(c);
/*r = Math.Sqrt(d);
c = Math.Atan(b / a);
f = ((c * 180) / Math.PI);*/
real2.Text = d.ToString();
imag2.Text = r.ToString();
}
catch { MessageBox.Show("introduce un numero o angulo
validos"); }
}
private void button1_Click(object sender, EventArgs e)
//Boton convertir en la ficha forma cartesiana a polar
Aplicación de software a dispositivos móviles Página 163
{
try
{ //se aplica el algoritmo correspondiente para la
conversion
a = double.Parse(Real.Text);
b = double.Parse(Imag.Text);
d = Math.Pow(a, 2) + Math.Pow(b, 2);
r = Math.Sqrt(d);
c = Math.Atan(b / a);
f = ((c * 180) / Math.PI);
Mag.Text = r.ToString();
Ang.Text = f.ToString();
}
catch { MessageBox.Show("introduce un numero imaginario
valido a+bi"); }
}
private void button2_Click_1(object sender, EventArgs e)
//boton limpiar
{
//introduce cadenas vacias para limpiar el texto
existente
Mag.Text = "";
Ang.Text = "";
Real.Text = "";
Imag.Text = "";
}
}
}
Compuertas RTL
using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace compuerta_RTL
{
public partial class comprtl : Form
{
public comprtl()
{
InitializeComponent();
}
private void menuItem2_Click(object sender, EventArgs e)
//opcion menu salir de la aplicacion
{
// instruccion para salir de la aplicacion completa
Application.Exit();
}
private void diseñar_Click(object sender, EventArgs e) //
boton diseñar
{
double Iihmax,Iilmax,fo,fs,hfe,iohmax, iolmax,
Rioh,Riol,rc,rb,Irc,Ics,Ibts,Ibs,Irioh,Iriol;
Página 164 Aplicación de software a dispositivos móviles
//asignacion de variables locales
Iihmax= double.Parse(v1.Text);// pasa los valores de una
caja de texto de a un valor de tipo doble en una variable local
Iilmax = double.Parse(v2.Text);
hfe = double.Parse(v3.Text);
fo = double.Parse(v4.Text);
fs = double.Parse(v5.Text);
iohmax = fo * Iihmax; //algoritmo segun las formulas de
diseño de compuertas RTL
iolmax = fo * Iilmax;
//voh=4.4v
rc = (5 - 4.4) / iohmax;
v8.Text = rc.ToString();
Irc = (5 - .1) / rc;
Rioh = 4.4 / iohmax;
v7.Text = Rioh.ToString();
Ics = Irc - iolmax;
Ibts = Ics / hfe;
Ibs = fs * Ibts;
rb = (3.4 - 0.7)/Ibs;
v6.Text = rb.ToString();
Irioh = 0.1 / Rioh;
Iriol = iolmax + Irioh;
Riol = Math.Abs((5 - .8)/Iriol); // llamada a la libreria
. math que contiene los controles de operaciones matematicas
v9.Text = Riol.ToString();
}
private void limpiar_Click(object sender, EventArgs e) //boton
limpiar
{
// limpia todos los valores escritos en las cajas de texto
o Text Box
v1.Text = "";
v2.Text = "";
v3.Text = "";
v4.Text = "";
v5.Text = "";
v6.Text = "";
v7.Text = "";
v8.Text = "";
v9.Text = "";
}
}
}
Conversor de unidades. using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace convertidor
{
public partial class Form1 : Form
{
private double a;
private double r;
Aplicación de software a dispositivos móviles Página 165
public Form1()
{
InitializeComponent();
}
private void longitud_SelectedIndexChanged(object sender,
EventArgs e) //programacion de la herramienta combo box
{//algoritmos de conversion de unidades de medida
if (longitud.SelectedIndex == 0)//km-m
{
a = double.Parse(valor.Text);
r = a * 1000;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 1)//km-cm
{
a = double.Parse(valor.Text);
r = a * 100000;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 2)//km-dm
{
a = double.Parse(valor.Text);
r = a * 10000;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 3)//km-mm
{
a = double.Parse(valor.Text);
r = a * 1000000;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 4)//km-pulg
{
a = double.Parse(valor.Text);
r = a * 39370.07874;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 5)//km-yarda
{
a = double.Parse(valor.Text);
r = a * 1093.613298;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 6)//m-km
{
a = double.Parse(valor.Text);
r = a * .001;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 7)//m-cm
{
a = double.Parse(valor.Text);
r = a * 100;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 8)//m-dm
{
a = double.Parse(valor.Text);
r = a * 10;
Página 166 Aplicación de software a dispositivos móviles
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 9)//m-mm
{
a = double.Parse(valor.Text);
r = a * 1000;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 10)//m-pulg
{
a = double.Parse(valor.Text);
r = a * 39.370079;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 11)//m-yarda
{
a = double.Parse(valor.Text);
r = a * 1.093613;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 12)//cm-km
{
a = double.Parse(valor.Text);
r = a * .000001;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 13)//cm-m
{
a = double.Parse(valor.Text);
r = a * .01;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 14)//cm-dm
{
a = double.Parse(valor.Text);
r = a * .1;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 15)//cm-mm
{
a = double.Parse(valor.Text);
r = a * 10;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 16)//dm-km
{
a = double.Parse(valor.Text);
r = a * 0.0001;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 17)//dm-m
{
a = double.Parse(valor.Text);
r = a * 0.1;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 18)//dm-cm
{
a = double.Parse(valor.Text);
r = a * 10;
res.Text = r.ToString();
}
Aplicación de software a dispositivos móviles Página 167
if (longitud.SelectedIndex == 19)//dm-mm
{
a = double.Parse(valor.Text);
r = a * 100;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 20)//mm-km
{
a = double.Parse(valor.Text);
r = a * .0000001;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 21)//mm-m
{
a = double.Parse(valor.Text);
r = a * .001;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 22)//mm-cm
{
a = double.Parse(valor.Text);
r = a * .1;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 23)//mm-dm
{
a = double.Parse(valor.Text);
r = a * .01;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 24)//pulg-km
{
a = double.Parse(valor.Text);
r = a * .0000254;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 25)//pulg-m
{
a = double.Parse(valor.Text);
r = a * 0.0254;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 26)//pulg-cm
{
a = double.Parse(valor.Text);
r = a * 2.54;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 27)//pulg-dm
{
a = double.Parse(valor.Text);
r = a * 0.254;
res.Text = r.ToString();
}
if (longitud.SelectedIndex == 28)//pulg-mm
{
a = double.Parse(valor.Text);
r = a * 25.4;
res.Text = r.ToString();
}
}
Página 168 Aplicación de software a dispositivos móviles
private void comboBox2_SelectedIndexChanged(object sender,
EventArgs e) //programacion del menu desplegable
{// el algoritmo asigna valores enteros a cada opcion para que
el usuario vea en pantalla el tipo de conversion seleccionado
longitud.Visible = false;
peso.Visible = false;
presion.Visible = false;
temperatura.Visible = false;
potencia.Visible = false;
if (comboBox2.SelectedIndex == 0)
longitud.Visible = true;
if (comboBox2.SelectedIndex == 1)
peso.Visible = true;
if (comboBox2.SelectedIndex == 2)
presion.Visible = true;
if (comboBox2.SelectedIndex == 3)
temperatura.Visible = true;
if (comboBox2.SelectedIndex == 4)
potencia.Visible = true;
}
private void peso_SelectedIndexChanged(object sender,
EventArgs e) //programacion del menu desplegable para seleccionar las
unidades de peso
{//conversion de unidades de peso
if (peso.SelectedIndex == 0)//ton/kg
{
a = double.Parse(valor.Text);
r = a * 1000;
res.Text = r.ToString();
}
if (peso.SelectedIndex == 1)//ton/g
{
a = double.Parse(valor.Text);
r = a * 1000000;
res.Text = r.ToString();
} if (peso.SelectedIndex == 2)//ton/mg
{
a = double.Parse(valor.Text);
r = a * 1000000000;
res.Text = r.ToString();
}
if (peso.SelectedIndex == 3)//kg/ton
{
a = double.Parse(valor.Text);
r = a * 0.01;
res.Text = r.ToString();
}
if (peso.SelectedIndex == 4)//kg/g
{
a = double.Parse(valor.Text);
r = a * 1000;
res.Text = r.ToString();
}
if (peso.SelectedIndex == 5)//kg/mg
{
a = double.Parse(valor.Text);
r = a * 1000000;
res.Text = r.ToString();
}
if (peso.SelectedIndex == 6)//g/ton
{
Aplicación de software a dispositivos móviles Página 169
a = double.Parse(valor.Text);
r = a * 0.000001;
res.Text = r.ToString();
}
if (peso.SelectedIndex == 7)//g/kg
{
a = double.Parse(valor.Text);
r = a * 0.001;
res.Text = r.ToString();
}
if (peso.SelectedIndex == 8)//g/mg
{
a = double.Parse(valor.Text);
r = a * 1000;
res.Text = r.ToString();
}
if (peso.SelectedIndex == 9)//mg/ton
{
a = double.Parse(valor.Text);
r = a * 0.000000001;
res.Text = r.ToString();
}
if (peso.SelectedIndex == 10)//mg/kg
{
a = double.Parse(valor.Text);
r = a * 0.000001;
res.Text = r.ToString();
}
if (peso.SelectedIndex == 11)//mg/g
{
a = double.Parse(valor.Text);
r = a * 0.001;
res.Text = r.ToString();
}
}
private void presion_SelectedIndexChanged(object sender,
EventArgs e) //opcion del menu para unidades de presion
{//algoritmos para la conversion de unidades de presion
if (presion.SelectedIndex == 0)//atm-pascal
{
a = double.Parse(valor.Text);
r = a * 101325;
res.Text = r.ToString();
}
if (presion.SelectedIndex == 1)//atm-bar
{
a = double.Parse(valor.Text);
r = a * 1.01325;
res.Text = r.ToString();
}
if (presion.SelectedIndex == 2)//atm-mbar
{
a = double.Parse(valor.Text);
r = a * 1013.25;
res.Text = r.ToString();
}
if (presion.SelectedIndex == 3)//atm-mmHg
{
a = double.Parse(valor.Text);
r = a * 760;
res.Text = r.ToString();
Página 170 Aplicación de software a dispositivos móviles
} if (presion.SelectedIndex == 4)//pascal-atm
{
a = double.Parse(valor.Text);
r = a * 0.00001;
res.Text = r.ToString();
} if (presion.SelectedIndex == 5)//pascal-bar
{
a = double.Parse(valor.Text);
r = a * 0.00001;
res.Text = r.ToString();
} if (presion.SelectedIndex == 6)//pascal-mbar
{
a = double.Parse(valor.Text);
r = a * 0.01;
res.Text = r.ToString();
} if (presion.SelectedIndex == 7)//pascal-mmHg
{
a = double.Parse(valor.Text);
r = a * 0.0075;
res.Text = r.ToString();
}
}
private void temperatura_SelectedIndexChanged(object sender,
EventArgs e) //opciones del menu desplegable para unidades de
temperatura
{// algoritmo correspondiente al cambio de unidades de
temperatura
if (temperatura.SelectedIndex == 0)//c-f
{
a = double.Parse(valor.Text);
r = ((9 * a) / 5) + 32;
res.Text = r.ToString();
}
if (temperatura.SelectedIndex == 1)//c-k
{
a = double.Parse(valor.Text);
r = a + 273.15;
res.Text = r.ToString();
}
if (temperatura.SelectedIndex == 2)//k-c
{
a = double.Parse(valor.Text);
r = a + 273.15;
res.Text = r.ToString();
}
if (temperatura.SelectedIndex == 3)//k-f
{
a = double.Parse(valor.Text);
r = ((9 * a) / 5) - 459.67;
res.Text = r.ToString();
}
if (temperatura.SelectedIndex == 4)//f-c
{
a = double.Parse(valor.Text);
r = ((a - 32) * 5 )/ 9;
res.Text = r.ToString();
}
if (temperatura.SelectedIndex == 5)//f-k
{
a = double.Parse(valor.Text);
r = ((a+459.67)*5)/9;
Aplicación de software a dispositivos móviles Página 171
res.Text = r.ToString();
}
}
private void potencia_SelectedIndexChanged(object sender,
EventArgs e) //opcion del menu desplegable para aplicar cambios de
unidades de energia
{//algoritmos para cambios de unidades de energia
if (potencia.SelectedIndex == 0)//watt/HP
{
a = double.Parse(valor.Text);
r = a*0.001341;
res.Text = r.ToString();
}
if (potencia.SelectedIndex == 1)//watt/BTU
{
a = double.Parse(valor.Text);
r = a * 3.414;
res.Text = r.ToString();
}
if (potencia.SelectedIndex == 2)//watt/(cal/s)
{
a = double.Parse(valor.Text);
r = a *0.239;
res.Text = r.ToString();
}
if (potencia.SelectedIndex == 3)//HP/watt
{
a = double.Parse(valor.Text);
r = a * 745.7 ;
res.Text = r.ToString();
}
if (potencia.SelectedIndex == 4)//HP/BTU
{
a = double.Parse(valor.Text);
r = a * 2546;
res.Text = r.ToString();
}
if (potencia.SelectedIndex == 5)//HP/(cal/s)
{
a = double.Parse(valor.Text);
r = a * 178.2;
res.Text = r.ToString();
}
if (potencia.SelectedIndex == 6)//BTU/watt
{
a = double.Parse(valor.Text);
r = a * 0.293;
res.Text = r.ToString();
}
if (potencia.SelectedIndex == 7)//BTU/HP
{
a = double.Parse(valor.Text);
r = a * 0.0003930;
res.Text = r.ToString();
}
if (potencia.SelectedIndex == 8)//BTU/(cal/s)
{
a = double.Parse(valor.Text);
r = a * .07;
res.Text = r.ToString();
}
Página 172 Aplicación de software a dispositivos móviles
}
private void menuItem2_Click(object sender, EventArgs e)
//cierra la aplicacion actual
{
Close();
}
private void menuItem1_Click(object sender, EventArgs e)
//redirecciona al Form2 que contiene sistemas de numeracion
{
Form2 f2 = new Form2();
f2.Show();
}
Conversor de unidades Form2
using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace convertidor
{
public partial class Form2 : Form //programacion para el Form2
perteneciente al mismo proyecto "convertidor"
{
public Form2()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e) //boton
convertir convierte las unidades dependiendo del valor seleccionado
{
long a, b,i;
string n = "";
string x = "";
if (sistemas.SelectedIndex == 0)//dec-bin
{
a = Int64.Parse(valor.Text);
b = 0;
for (i = 1; a > 0; i++)
{
b = a % 2;
a = a / 2;
n = b + n;
}
res.Text = n;
}
if (sistemas.SelectedIndex == 1)//dec-octal
{
a = Int64.Parse(valor.Text);
b=0;
for (i = 1; a > 0; i++)
Aplicación de software a dispositivos móviles Página 173
{
b = a % 8;
a = a / 8;
n = b + n;
}
res.Text = n;
}
if (sistemas.SelectedIndex == 2)//dec-hex
{
a = Int64.Parse(valor.Text);
b = 0;
for (i = 1; a > 0; i++)
{
b = a % 16;
a = a / 16;
if (b > 9)
{
switch (b)
{
case 10:
x = "A";
n = x + n;
break;
case 11:
x = "B";
n = x + n;
break;
case 12:
x = "C";
n = x + n;
break;
case 13:
x = "D";
n = x + n;
break;
case 14:
x = "E";
n = x + n;
break;
case 15:
x = "F";
n = x + n;
break;
}
}
else
{
n = b + n;
}
}
res.Text = n;
}
if (sistemas.SelectedIndex == 3)//bin-dec
{
string c;
c = Convert.ToString(valor.Text);
int d,j;
int dec = 0;
for (d = c.Length-1,j=0; d >=0; d--)
{
Página 174 Aplicación de software a dispositivos móviles
dec += Convert.ToInt32(c.Substring(d, 1)) *
Convert.ToInt32(Math.Pow(2, j));
j++;
}
res.Text = dec.ToString(); ;
}
if (sistemas.SelectedIndex == 4)//bin-oct
{
string c;
c = Convert.ToString(valor.Text);
int d, j;
int dec = 0;
for (d = c.Length - 1, j = 0; d >= 0; d--)
{
dec += Convert.ToInt32(c.Substring(d, 1)) *
Convert.ToInt32(Math.Pow(2, j));
j++;
}
b = 0;
for (i = 1; dec > 0; i++)
{
b = dec % 8;
dec = dec / 8;
n = b + n;
}
res.Text = n.ToString(); ;
}
if (sistemas.SelectedIndex == 5)//bin-hex
{
string c;
c = Convert.ToString(valor.Text);
int d, j;
int dec = 0;
for (d = c.Length - 1, j = 0; d >= 0; d--)
{
dec += Convert.ToInt32(c.Substring(d, 1)) *
Convert.ToInt32(Math.Pow(2, j));
j++;
}
b = 0;
for (i = 1; dec > 0; i++)
{
b = dec % 16;
dec = dec / 16;
if (b > 9)
{
switch (b)
{
case 10:
x = "A";
n = x + n;
break;
case 11:
x = "B";
n = x + n;
break;
case 12:
Aplicación de software a dispositivos móviles Página 175
x = "C";
n = x + n;
break;
case 13:
x = "D";
n = x + n;
break;
case 14:
x = "E";
n = x + n;
break;
case 15:
x = "F";
n = x + n;
break;
}
}
else
{
n = b + n;
}
}
res.Text = n.ToString(); ;
}
if (sistemas.SelectedIndex == 6)//oct-dec
{
string c;
c = Convert.ToString(valor.Text);
int d, j;
int dec = 0;
for (d = c.Length - 1, j = 0; d >= 0; d--)
{
dec += Convert.ToInt32(c.Substring(d, 1)) *
Convert.ToInt32(Math.Pow(8, j));
j++;
}
res.Text = dec.ToString(); ;
}
if (sistemas.SelectedIndex == 7)//oct-bin
{
string c;
c = Convert.ToString(valor.Text);
int d, j;
int dec = 0;
for (d = c.Length - 1, j = 0; d >= 0; d--)
{
dec += Convert.ToInt32(c.Substring(d, 1)) *
Convert.ToInt32(Math.Pow(8, j));
j++;
}
b = 0;
for (i = 1; dec > 0; i++)
{
b = dec % 2;
dec = dec / 2;
n = b + n;
}
Página 176 Aplicación de software a dispositivos móviles
res.Text = n.ToString(); ;
}
if (sistemas.SelectedIndex == 8)//oct-hex
{
string c;
c = Convert.ToString(valor.Text);
int d, j;
int dec = 0;
for (d = c.Length - 1, j = 0; d >= 0; d--)
{
dec += Convert.ToInt32(c.Substring(d, 1)) *
Convert.ToInt32(Math.Pow(8, j));
j++;
}
b = 0;
for (i = 1; dec > 0; i++)
{
b = dec % 16;
dec = dec / 16;
if (b > 9)
{
switch (b)
{
case 10:
x = "A";
n = x + n;
break;
case 11:
x = "B";
n = x + n;
break;
case 12:
x = "C";
n = x + n;
break;
case 13:
x = "D";
n = x + n;
break;
case 14:
x = "E";
n = x + n;
break;
case 15:
x = "F";
n = x + n;
break;
}
}
else
{
n = b + n;
}
}
res.Text = n.ToString(); ;
}
if (sistemas.SelectedIndex == 9)//hex-dec
{
Aplicación de software a dispositivos móviles Página 177
string c;
c = Convert.ToString(valor.Text);
int d, j;
int dec = 0;
for (d = c.Length - 1, j = 0; d >= 0; d--)
{
dec += Convert.ToInt32(c.Substring(d, 1)) *
Convert.ToInt32(Math.Pow(16, j));
j++;
}
res.Text = dec.ToString();
}
}
private void menuItem2_Click(object sender, EventArgs e)
//cierra la aplicacion completa
{
Application.Exit();
}
}
}
OPERACIONES CON MATRICES
using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace Matrixx
{
public partial class matriz : Form
{
private double[,] a;
private double[,] b;
private double[,] c;
private double[,] d;
private int m, n, fi, co;
public matriz()
{
InitializeComponent();
}
private void button2_Click(object sender, EventArgs e) //boton
poner
//lee los valores introducidos en cada campo de la matriz
{
string tam = "";
if (matA.Checked) //algoritmo para leer los datos en la
matriz A y guardarlos en el arreglo correspondiente
{
fi = Int32.Parse(cm.Text);
co = Int32.Parse(cn.Text);
mat.Items.Add("Mat A");
for (int i = 0; i < fi; i++)
{
for (int j = 0; j < co; j++)
Página 178 Aplicación de software a dispositivos móviles
{
tam += a[i, j].ToString() + "";
}
mat.Items.Add(tam);
tam = "";
}
}
if (matB.Checked) //algoritmo para leer los datos en la
matriz B y guardarlos en el arreglo correspondiente
{
fi = Int32.Parse(cm.Text);
co = Int32.Parse(cn.Text);
mat.Items.Add("Mat B");
for (int i = 0; i < fi; i++)
{
for (int j = 0; j < co; j++)
{
tam += b[i, j].ToString() + "";
}
mat.Items.Add(tam);
tam = "";
}
}
if (matC.Checked) //algoritmo para leer los datos en la
matriz C y guardarlos en el arreglo correspondiente
{
mat.Items.Add("Mat C");
for (int i = 0; i < fi; i++)
{
for (int j = 0; j < co; j++)
{
tam += c[i, j].ToString() + "";
}
mat.Items.Add(tam);
tam = "";
}
}
}
private void tamaño_Click(object sender, EventArgs e) //lee el
tamaño de la matriz y pasa los valores a variables globales
{
m = Int32.Parse(cm.Text);
n = Int32.Parse(cn.Text);
a = new double[m, n];
b = new double[m, n];
c = new double[m, n];
d = new double[m, n];
}
private void button1_Click(object sender, EventArgs e) //boton
leer
{
// lee los numeros almacenados en las matrices A y B
if (matA.Checked)
{
fi = Int32.Parse(fila.Text);
co = Int32.Parse(col.Text);
a[fi, co] = Double.Parse(elemento.Text);
}
if (matB.Checked)
{
fi = Int32.Parse(fila.Text);
Aplicación de software a dispositivos móviles Página 179
co = Int32.Parse(col.Text);
b[fi, co] = Double.Parse(elemento.Text);
}
}
private void button3_Click(object sender, EventArgs e) //boton
calcula
{
//algoritmos correspondientes a las operaciones de las
matrices
if (suma.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[i, j] + b[i, j];
}
}
}
if (resta.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[i, j] - b[i, j];
}
}
}
if (producto.Checked)
{
int l = m;
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = 0;
for (int k = 0; k < l; k++)
{
c[i, j] += a[i, k] * b[k, j];
}
}
}
}
if (transpuesta.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[j, i];
}
}
}
if (transpuestaB.Checked)
{
for (int i = 0; i < m; i++)
{
Página 180 Aplicación de software a dispositivos móviles
for (int j = 0; j < n; j++)
{
c[i, j] = b[j, i];
}
}
}
if (suma1.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
d[i, j] = b[j, i];
}
}
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[i, j] + d[i, j];
}
}
}
if (suma2.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
d[i, j] = a[j, i];
}
}
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[i, j] + d[i, j];
}
}
}
if (resta1.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
d[i, j] = b[j, i];
}
}
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[i, j] - d[i, j];
}
}
}
if (resta2.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
Aplicación de software a dispositivos móviles Página 181
{
d[i, j] = a[j, i];
}
}
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[i, j] - d[i, j];
}
}
}
if (multiplica1.Checked)
{
int l = m;
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
d[i, j] = b[j, i];
}
}
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = 0;
for (int k = 0; k < l; k++)
{
c[i, j] += a[i, k] * d[k, j];
}
}
}
}
if (multiplica2.Checked)
{
int l = m;
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
d[i, j] = a[j, i];
}
}
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = 0;
for (int k = 0; k < l; k++)
{
c[i, j] += d[i, k] * b[k, j];
}
}
}
}
if (opuesta1.Checked)
Página 182 Aplicación de software a dispositivos móviles
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[i, j] * -1;
}
}
}
if (opuesta2.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = b[i, j] * -1;
}
}
}
if (nula.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[i, j] * 0;
}
}
}
if (a2.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = a[i, j] * a[i, j];
}
}
}
if (b2.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
c[i, j] = b[i, j] * b[i, j];
}
}
}
if (d1.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if (i == j)
{
c[i, j] = a[i, j];
}
else
{
c[i, j] = 0;
Aplicación de software a dispositivos móviles Página 183
}
}
}
}
if (d2.Checked)
{
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if (i == j)
{
c[i, j] = b[i, j];
}
else
{
c[i, j] = 0;
}
}
}
} // los resultados calculados son puestos como resultados
en la matriz C
}
private void menuItem3_Click(object sender, EventArgs e) //
opcion del menu salir de la aplicacion
{
Application.Exit();
}
private void menuItem1_Click(object sender, EventArgs e)
//opcion para cerrar el formulario actual Forn 2
{
Close();
}
}
}
Redes RC Pasa altas y Pasa bajas using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace PasaAB
{
public partial class Pasaalta : Form
{
double a, rc, a1, res, aten, capa, requiv, r1, r2, atenr;
public Pasaalta()
{
InitializeComponent();
}
private void calc_Click(object sender, EventArgs e) //boton
calcula
{
Página 184 Aplicación de software a dispositivos móviles
//calcula los elementos de el circuito RC
rc = double.Parse(FC1.Text);
a = 1 / (2 * 3.1416 * rc);
RC1.Text = a.ToString();
// float.MaxValue = .2F;
}
private void button3_Click(object sender, EventArgs e) //elige
el valor comercial de un capacitor
{
if (micro.SelectedIndex == 0) //elige valores de un
microcapacitor en microfaradios
{
a1 = (0.10 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 1)
{
a1 = (0.12 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 2)
{
a1 = (0.15 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 3)
{
a1 = (0.18 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 4)
{
a1 = (0.22 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 5)
{
a1 = (0.27 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 6)
{
a1 = (0.33 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 7)
{
a1 = (0.39 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 8)
{
a1 = (0.47 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 9)
{
a1 = (0.56 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 10)
{
a1 = (0.68 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 11)
{
a1 = (0.82 * 0.000001);
Aplicación de software a dispositivos móviles Página 185
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 12)
{
a1 = (1.0 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 13)
{
a1 = (1.2 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 14)
{
a1 = (1.5 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 15)
{
a1 = (1.8 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 16)
{
a1 = (2.2 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 17)
{
a1 = (2.7 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 18)
{
a1 = (3.3 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 19)
{
a1 = (3.9 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 20)
{
a1 = (4.7 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 21)
{
a1 = (5.6 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 22)
{
a1 = (6.8 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 23)
{
a1 = (8.2 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 24)
{
a1 = (10 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 25)
{
a1 = (12 * 0.000001);
ccap.Text = a1.ToString();
Página 186 Aplicación de software a dispositivos móviles
} if (micro.SelectedIndex == 26)
{
a1 = (15 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 27)
{
a1 = (18 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 28)
{
a1 = (22 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 29)
{
a1 = (27 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 30)
{
a1 = (33 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 31)
{
a1 = (39 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 32)
{
a1 = (47 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 33)
{
a1 = (56 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 34)
{
a1 = (68 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 35)
{
a1 = (82 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 36)
{
a1 = (100 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 37)
{
a1 = (120 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 38)
{
a1 = (150 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 39)
{
a1 = (180 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 40)
Aplicación de software a dispositivos móviles Página 187
{
a1 = (220 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 41)
{
a1 = (270 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 42)
{
a1 = (330 * 0.000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 43)
{
a1 = (390 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 44)
{
a1 = (470 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 45)
{
a1 = (560 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 46)
{
a1 = (680 * 0.000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 47)
{
a1 = (820 * 0.000001);
ccap.Text = a1.ToString();
}
}
private void button1_Click(object sender, EventArgs e) //boton
nf //elige valores de un microcapacitor en nano faradios
{
if (micro.SelectedIndex == 0)
{
a1 = (0.10 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 1)
{
a1 = (0.12 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 2)
{
a1 = (0.15 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 3)
{
a1 = (0.18 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 4)
Página 188 Aplicación de software a dispositivos móviles
{
a1 = (0.22 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 5)
{
a1 = (0.27 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 6)
{
a1 = (0.33 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 7)
{
a1 = (0.39 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 8)
{
a1 = (0.47 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 9)
{
a1 = (0.56 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 10)
{
a1 = (0.68 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 11)
{
a1 = (0.82 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 12)
{
a1 = (1.0 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 13)
{
a1 = (1.2 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 14)
{
a1 = (1.5 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 15)
{
a1 = (1.8 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 16)
{
a1 = (2.2 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 17)
{
a1 = (2.7 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 18)
{
a1 = (3.3 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 19)
{
Aplicación de software a dispositivos móviles Página 189
a1 = (3.9 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 20)
{
a1 = (4.7 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 21)
{
a1 = (5.6 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 22)
{
a1 = (6.8 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 23)
{
a1 = (8.2 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 24)
{
a1 = (10 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 25)
{
a1 = (12 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 26)
{
a1 = (15 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 27)
{
a1 = (18 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 28)
{
a1 = (22 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 29)
{
a1 = (27 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 30)
{
a1 = (33 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 31)
{
a1 = (39 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 32)
{
a1 = (47 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 33)
Página 190 Aplicación de software a dispositivos móviles
{
a1 = (56 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 34)
{
a1 = (68 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 35)
{
a1 = (82 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 36)
{
a1 = (100 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 37)
{
a1 = (120 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 38)
{
a1 = (150 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 39)
{
a1 = (180 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 40)
{
a1 = (220 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 41)
{
a1 = (270 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 42)
{
a1 = (330 * 0.000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 43)
{
a1 = (390 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 44)
{
a1 = (470 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 45)
{
a1 = (560 * 0.000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 46)
{
a1 = (680 * 0.000000001);
ccap.Text = a1.ToString();
}
Aplicación de software a dispositivos móviles Página 191
if (micro.SelectedIndex == 47)
{
a1 = (820 * 0.000000001);
ccap.Text = a1.ToString();
}
}
private void button2_Click(object sender, EventArgs e) //boton
pf //elige valores de un microcapacitor en pico faradios
{
if (micro.SelectedIndex == 0)
{
a1 = (0.10 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 1)
{
a1 = (0.12 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 2)
{
a1 = (0.15 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 3)
{
a1 = (0.18 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 4)
{
a1 = (0.22 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 5)
{
a1 = (0.27 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 6)
{
a1 = (0.33 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 7)
{
a1 = (0.39 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 8)
{
a1 = (0.47 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 9)
{
a1 = (0.56 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 10)
{
a1 = (0.68 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 11)
{
a1 = (0.82 * 0.000000000001);
Página 192 Aplicación de software a dispositivos móviles
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 12)
{
a1 = (1.0 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 13)
{
a1 = (1.2 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 14)
{
a1 = (1.5 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 15)
{
a1 = (1.8 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 16)
{
a1 = (2.2 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 17)
{
a1 = (2.7 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 18)
{
a1 = (3.3 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 19)
{
a1 = (3.9 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 20)
{
a1 = (4.7 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 21)
{
a1 = (5.6 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 22)
{
a1 = (6.8 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 23)
{
a1 = (8.2 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 24)
{
a1 = (10 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 25)
{
a1 = (12 * 0.000000000001);
ccap.Text = a1.ToString();
Aplicación de software a dispositivos móviles Página 193
} if (micro.SelectedIndex == 26)
{
a1 = (15 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 27)
{
a1 = (18 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 28)
{
a1 = (22 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 29)
{
a1 = (27 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 30)
{
a1 = (33 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 31)
{
a1 = (39 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 32)
{
a1 = (47 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 33)
{
a1 = (56 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 34)
{
a1 = (68 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 35)
{
a1 = (82 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 36)
{
a1 = (100 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 37)
{
a1 = (120 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 38)
{
a1 = (150 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 39)
{
a1 = (180 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 40)
Página 194 Aplicación de software a dispositivos móviles
{
a1 = (220 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 41)
{
a1 = (270 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 42)
{
a1 = (330 * 0.000000000001);
ccap.Text = a1.ToString();
} if (micro.SelectedIndex == 43)
{
a1 = (390 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 44)
{
a1 = (470 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 45)
{
a1 = (560 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 46)
{
a1 = (680 * 0.000000000001);
ccap.Text = a1.ToString();
}
if (micro.SelectedIndex == 47)
{
a1 = (820 * 0.000000000001);
ccap.Text = a1.ToString();
}
}
private void button4_Click(object sender, EventArgs e) //boton
calcula la resisrencia del circuito
{
res = a / a1;
resis.Text = res.ToString();
}
private void button8_Click(object sender, EventArgs e) //boton
calcula, calcula todos los valores de una red pasabajas
{
rc = double.Parse(TBfq.Text);
aten = double.Parse(TBdB.Text);
capa = double.Parse(cap.Text);
requiv = 1 / (2 * 3.1416 * rc* capa);
aten = Math.Pow(10, aten / 20);
atenr = (1 - aten) / aten;
r2 = (requiv * atenr) / (atenr + 1);
r1 = r2 * atenr;
ATL.Text = aten.ToString();
TBrequiv.Text = requiv.ToString();
TBr1.Text = r1.ToString();
TBr2.Text = r2.ToString();
//RC1.Text = a.ToString();
}
Aplicación de software a dispositivos móviles Página 195
private void button10_Click(object sender, EventArgs e)
//boton calcula, calcula todos los valores de una red pasa altas
{
rc = double.Parse(TBfq2.Text);
aten = double.Parse(TBatenfij2.Text);
capa = double.Parse(TBcap2.Text);
requiv = 1 / (2 * 3.1416 * rc * capa);
aten = Math.Pow(10, aten / 20);
atenr = (1 - aten) / aten;
r2 = requiv / (atenr + 1);
r1 = r2 * atenr;
TBatlin2.Text = aten.ToString();
TBreqv2.Text = requiv.ToString();
TBr12.Text = r1.ToString();
TBr22.Text = r2.ToString();
}
private void button5_Click(object sender, EventArgs e) //boton
ver red pasabajas
{ //muestra el diseño de la red pasabajas en un picture box
panel1.Visible = true;
panel2.Visible = false;
}
private void button6_Click(object sender, EventArgs e)//boton
pasa altas
{//muestra el diseño de la red pasaaltas en un picture box
panel2.Visible = true;
panel1.Visible = false;
}
// los demas botones obedecen a instrucciones similares
private void button12_Click(object sender, EventArgs e)
{
panel2.Visible = false;
}
private void button11_Click(object sender, EventArgs e)
{
panel1.Visible = false;
}
private void button7_Click(object sender, EventArgs e)
{
panel3.Visible = true;
}
private void button13_Click(object sender, EventArgs e)
{
panel3.Visible = false;
}
private void button9_Click(object sender, EventArgs e)
{
panel4.Visible = true;
}
private void button15_Click(object sender, EventArgs e)
{
panel4.Visible = false;
}
Página 196 Aplicación de software a dispositivos móviles
private void menuItem1_Click(object sender, EventArgs e)
{
Close();
}
private void menuItem3_Click(object sender, EventArgs e)
{
Application.Exit();
}
}
}
Menú general
Presentación using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace menu_gen
{
public partial class presentacion : Form
{
public presentacion()
{
InitializeComponent();
}
private void menuItem1_Click(object sender, EventArgs e)
{
menmat men = new menmat();
men.Show();
}
private void menuItem2_Click(object sender, EventArgs e)
{
Application.Exit();
}
}
}
Menú Herramientas using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace menu_gen
{
public partial class herramientas : Form
{
public herramientas()
{
InitializeComponent();
}
private void menuItem1_Click(object sender, EventArgs e)
{
Aplicación de software a dispositivos móviles Página 197
menmat mens = new menmat();
mens.Show();
}
private void linkLabel1_Click(object sender, EventArgs e)
{
Amplificadores.opam am = new Amplificadores.opam();
am.Show();
}
private void linkLabel2_Click(object sender, EventArgs e)
{
calculadora.calculador ca = new calculadora.calculador();
ca.Show();
}
private void linkLabel3_Click(object sender, EventArgs e)
{
Matrixx.matriz mat = new Matrixx.matriz();
mat.Show();
}
private void linkLabel4_Click(object sender, EventArgs e)
{
complex.Rectpolar com = new complex.Rectpolar();
com.Show();
}
private void linkLabel5_Click(object sender, EventArgs e)
{
convertidor.cunid cun = new convertidor.cunid();
cun.Show();
}
private void linkLabel6_Click(object sender, EventArgs e)
{
convertidor.cbase bas = new convertidor.cbase();
bas.Show();
}
private void linkLabel7_Click(object sender, EventArgs e)
{
compuerta_RTL.comprtl rtl = new compuerta_RTL.comprtl();
rtl.Show();
}
private void linkLabel8_Click(object sender, EventArgs e)
{
resistencias.resistencias resi = new
resistencias.resistencias();
resi.Show();
}
private void linkLabel9_Click(object sender, EventArgs e)
{
PasaAB.Pasaalta pas = new PasaAB.Pasaalta();
pas.Show();
}
}
}
Menú materias using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
Página 198 Aplicación de software a dispositivos móviles
using System.Windows.Forms;
namespace menu_gen
{
public partial class menmat : Form
{
public menmat()
{
InitializeComponent();
}
private void menuItem1_Click(object sender, EventArgs e)
{
herramientas her = new herramientas();
her.Show();
}
private void menuItem2_Click(object sender, EventArgs e)
{
Application.Exit();
}
private void button1_Click(object sender, EventArgs e)
{
circacd.cacd ca = new circacd.cacd();
ca.Show();
}
private void cir_digital_Click(object sender, EventArgs e)
{
circdigi.digitales dig = new circdigi.digitales();
dig.Show();
}
private void comunicacion_Click(object sender, EventArgs e)
{
comunicaciones.comu1 c1 = new comunicaciones.comu1();
c1.Show();
}
}
}
Cálculo de Resistencias Comerciales
using System;
using System.Linq;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace resistencias
{
public partial class resistencias : Form
{
public resistencias()
{
InitializeComponent();
}
Aplicación de software a dispositivos móviles Página 199
private void button2_Click(object sender, EventArgs e)
{
t2.BringToFront();
}
private void menuItem2_Click(object sender, EventArgs e)
{
this.Close();
}
private void res_Paint(object sender, PaintEventArgs e)
{
//int xi, xf, y1, yf;
//xi = 10; xf = 210; y1 = 10; yf = 80;
Graphics gr = res.CreateGraphics();
Pen negro = new Pen(Color.Black);
Pen azul = new Pen(Color.CadetBlue);
negro.Width = 4.0F;
azul.Width = 3.0F;
//negro.DashStyle =
System.Drawing.Drawing2D.DashStyle.Solid;
gr.DrawRectangle(negro,new Rectangle(50,15,120,60));
gr.DrawLine(negro, 5, 50, 50, 50);
gr.DrawLine(negro, 170, 50, 210, 50);
gr.DrawRectangle(azul, new Rectangle(55, 18,20,53));
gr.DrawRectangle(azul, new Rectangle(85, 18, 20, 53));
gr.DrawRectangle(azul, new Rectangle(115, 18, 20, 53));
gr.DrawRectangle(azul, new Rectangle(145, 18, 20, 53));
}
private void menuItem1_Click(object sender, EventArgs e)
{
t1.BringToFront();
}
private void menuItem5_Click(object sender, EventArgs e)
{
Application.Exit();
}
private void visualiza_Click(object sender, EventArgs e)
{
double r;
Graphics gr = res.CreateGraphics();
SolidBrush beige = new SolidBrush(Color.Beige);
SolidBrush negro1=new SolidBrush(Color.Black);
SolidBrush cafe = new SolidBrush(Color.Brown);
SolidBrush rojo = new SolidBrush(Color.Red);
SolidBrush naranja = new SolidBrush(Color.Orange);
SolidBrush amarillo = new SolidBrush(Color.Yellow);
SolidBrush verde = new SolidBrush(Color.Green);
SolidBrush azul1 = new SolidBrush(Color.Blue);
SolidBrush morado = new SolidBrush(Color.Purple);
SolidBrush gris = new SolidBrush(Color.Gray);
SolidBrush blanco = new SolidBrush(Color.White);
SolidBrush dorado = new SolidBrush(Color.Gold);
SolidBrush plata = new SolidBrush(Color.Silver);
Pen negro2 = new Pen(Color.Black);
Pen azul2 = new Pen(Color.CadetBlue);
negro2.Width = 4.0F;
azul2.Width = 3.0F;
try
{
switch (valores.SelectedItem.ToString())
{
case "1":
if (rd1.Checked)
Página 200 Aplicación de software a dispositivos móviles
{
// 1 ohm
r = 1;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(negro1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
}
if (rd2.Checked)
{
// 10 ohm
r = 10;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(negro1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(negro1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd3.Checked)
{
// 100 ohm
r = 100;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(negro1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(cafe, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd4.Checked)
{
//1 kohm
r = 1000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(negro1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(rojo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd5.Checked)
{
//10 kohm
r = 10000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(negro1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(naranja, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd6.Checked)
{
//100 kohm
r = 100000;
Resultado.Text = r.ToString();
Aplicación de software a dispositivos móviles Página 201
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(negro1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(amarillo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd7.Checked)
{
//1 Mohm
r = 1000000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(negro1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(verde, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd8.Checked)
{
//10 Mohm
r = 10000000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(negro1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(azul1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
break;
case "1.2":
if (rd1.Checked)
{
//1.2 ohm
r = 1.2;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(beige, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd2.Checked)
{
// 12 ohm
r = 12;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(negro1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd3.Checked)
{
// 120 ohm
r = 120;
Resultado.Text = r.ToString();
Página 202 Aplicación de software a dispositivos móviles
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(cafe, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd4.Checked)
{
//1.2 kohm
r = 1200;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(rojo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd5.Checked)
{
//12 kohm
r = 12000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(naranja, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd6.Checked)
{
//120 kohm
r = 120000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(amarillo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd7.Checked)
{
//1.2 Mohm
r = 1200000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(verde, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd8.Checked)
{
//12 Mohm
r = 12000000;
Resultado.Text = r.ToString();
Aplicación de software a dispositivos móviles Página 203
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(azul1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
break;
case "1.5":
if (rd1.Checked)
{
//1.5 ohm
r = 1.5;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(verde, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(beige, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd2.Checked)
{
// 15 ohm
r = 15;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(verde, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(negro1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd3.Checked)
{
// 150 ohm
r = 150;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(verde, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(cafe, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd4.Checked)
{
//1.5 kohm
r = 1500;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(verde, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(rojo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd5.Checked)
{
//15 kohm
r = 15000;
Resultado.Text = r.ToString();
Página 204 Aplicación de software a dispositivos móviles
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(verde, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(naranja, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd6.Checked)
{
//150 kohm
r = 150000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(verde, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(amarillo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd7.Checked)
{
//1.5 Mohm
r = 1500000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(verde, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(verde, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd8.Checked)
{
//15 Mohm
r = 15000000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(verde, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(azul1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
break;
case "1.8":
if (rd1.Checked)
{
//1.8 ohm
r = 1.8;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(gris, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(beige, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd2.Checked)
{
// 18 ohm
Aplicación de software a dispositivos móviles Página 205
r = 18;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(gris, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(negro1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd3.Checked)
{
// 180 ohm
r = 180;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(gris, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(cafe, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd4.Checked)
{
//1.8 kohm
r = 1800;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(gris, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(rojo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd5.Checked)
{
//18 kohm
r = 18000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(gris, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(naranja, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd6.Checked)
{
//180 kohm
r = 180000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(gris, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(amarillo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd7.Checked)
{
//1.8 Mohm
r = 1800000;
Resultado.Text = r.ToString();
Página 206 Aplicación de software a dispositivos móviles
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(gris, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(verde, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd8.Checked)
{
//18 Mohm
r = 18000000;
Resultado.Text = r.ToString();
gr.FillRectangle(cafe, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(gris, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(azul1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
break;
case "2.2":
if (rd1.Checked)
{
//2.2 ohm
r = 2.2;
Resultado.Text = r.ToString();
gr.FillRectangle(rojo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(beige, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd2.Checked)
{
// 22 ohm
r = 22;
Resultado.Text = r.ToString();
gr.FillRectangle(rojo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(negro1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd3.Checked)
{
// 220 ohm
r = 220;
Resultado.Text = r.ToString();
gr.FillRectangle(rojo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(cafe, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd4.Checked)
{
//2.2 kohm
r = 2200;
Aplicación de software a dispositivos móviles Página 207
Resultado.Text = r.ToString();
gr.FillRectangle(rojo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(rojo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd5.Checked)
{
//22 kohm
r = 22000;
Resultado.Text = r.ToString();
gr.FillRectangle(rojo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(naranja, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd6.Checked)
{
//220 kohm
r = 220000;
Resultado.Text = r.ToString();
gr.FillRectangle(rojo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(amarillo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd7.Checked)
{
//2.2 Mohm
r = 2200000;
Resultado.Text = r.ToString();
gr.FillRectangle(rojo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(verde, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd8.Checked)
{
//22 Mohm
r = 22000000;
Resultado.Text = r.ToString();
gr.FillRectangle(rojo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(azul1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
break;
case "2.7":
if (rd1.Checked)
{
//2.7 ohm
r = 2.7;
Página 208 Aplicación de software a dispositivos móviles
Resultado.Text = r.ToString();
gr.FillRectangle(rojo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(morado, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(beige, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd2.Checked)
{
// 27 ohm
r = 27;
Resultado.Text = r.ToString();
gr.FillRectangle(rojo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(morado, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(negro1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd3.Checked)
{
// 270 ohm
r = 270;
Resultado.Text = r.ToString();
gr.FillRectangle(rojo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(morado, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(cafe, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd4.Checked)
{
//2.7 kohm
r = 2700;
Resultado.Text = r.ToString();
gr.FillRectangle(rojo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(morado, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(rojo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd5.Checked)
{
//27 kohm
r = 27000;
Resultado.Text = r.ToString();
gr.FillRectangle(rojo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(morado, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(naranja, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd6.Checked)
{
//270 kohm
r = 270000;
Resultado.Text = r.ToString();
gr.FillRectangle(rojo, new Rectangle(55, 18, 20, 53));
Aplicación de software a dispositivos móviles Página 209
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(morado, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(amarillo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd7.Checked)
{
//2.7 Mohm
r = 2700000;
Resultado.Text = r.ToString();
gr.FillRectangle(rojo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(morado, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(verde, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd8.Checked)
{
//27 Mohm
r = 27000000;
Resultado.Text = r.ToString();
gr.FillRectangle(rojo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(morado, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(azul1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
break;
case "3.3":
if (rd1.Checked)
{
//3.3 ohm
r = 3.3;
Resultado.Text = r.ToString();
gr.FillRectangle(naranja, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(naranja, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(beige, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd2.Checked)
{
// 33 ohm
r = 33;
Resultado.Text = r.ToString();
gr.FillRectangle(naranja, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(naranja, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(negro1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd3.Checked)
{
// 330 ohm
r = 330;
Resultado.Text = r.ToString();
gr.FillRectangle(naranja, new Rectangle(55, 18, 20, 53));
Página 210 Aplicación de software a dispositivos móviles
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(naranja, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(cafe, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd4.Checked)
{
//3.3 kohm
r = 3300;
Resultado.Text = r.ToString();
gr.FillRectangle(naranja, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(naranja, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(rojo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd5.Checked)
{
//33 kohm
r = 33000;
Resultado.Text = r.ToString();
gr.FillRectangle(naranja, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(naranja, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(naranja, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd6.Checked)
{
//330 kohm
r = 330000;
Resultado.Text = r.ToString();
gr.FillRectangle(naranja, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(naranja, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(amarillo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd7.Checked)
{
//3.3 Mohm
r = 3300000;
Resultado.Text = r.ToString();
gr.FillRectangle(naranja, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(naranja, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(verde, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd8.Checked)
{
//33 Mohm
r = 33000000;
Resultado.Text = r.ToString();
gr.FillRectangle(naranja, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(naranja, 85, 18, 20, 53);
Aplicación de software a dispositivos móviles Página 211
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(azul1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
break;
case "3.9":
if (rd1.Checked)
{
//3.9 ohm
r = 3.9;
Resultado.Text = r.ToString();
gr.FillRectangle(naranja, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(blanco, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(beige, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd2.Checked)
{
// 39 ohm
r = 39;
Resultado.Text = r.ToString();
gr.FillRectangle(naranja, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(blanco, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(negro1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd3.Checked)
{
// 390 ohm
r = 390;
Resultado.Text = r.ToString();
gr.FillRectangle(naranja, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(blanco, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(cafe, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd4.Checked)
{
//3.9 kohm
r = 3900;
Resultado.Text = r.ToString();
gr.FillRectangle(naranja, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(blanco, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(rojo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd5.Checked)
{
//39 kohm
r = 39000;
Resultado.Text = r.ToString();
gr.FillRectangle(naranja, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(blanco, 85, 18, 20, 53);
Página 212 Aplicación de software a dispositivos móviles
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(naranja, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd6.Checked)
{
//390 kohm
r = 390000;
Resultado.Text = r.ToString();
gr.FillRectangle(naranja, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(blanco, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(amarillo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd7.Checked)
{
//3.9 Mohm
r = 3900000;
Resultado.Text = r.ToString();
gr.FillRectangle(naranja, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(blanco, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(verde, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd8.Checked)
{
//39 Mohm
r = 39000000;
Resultado.Text = r.ToString();
gr.FillRectangle(naranja, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(blanco, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(azul1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
break;
case "4.7":
if (rd1.Checked)
{
r = 4.7;
Resultado.Text = r.ToString();
gr.FillRectangle(amarillo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(morado, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(beige, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd2.Checked)
{
r = 47;
Resultado.Text = r.ToString();
gr.FillRectangle(amarillo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(morado, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
Aplicación de software a dispositivos móviles Página 213
gr.FillRectangle(negro1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd3.Checked)
{
r = 470;
Resultado.Text = r.ToString();
gr.FillRectangle(amarillo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(morado, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(cafe, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd4.Checked)
{
r = 4700;
Resultado.Text = r.ToString();
gr.FillRectangle(amarillo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(morado, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(rojo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd5.Checked)
{
r = 47000;
Resultado.Text = r.ToString();
gr.FillRectangle(amarillo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(morado, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(naranja, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd6.Checked)
{
r = 470000;
Resultado.Text = r.ToString();
gr.FillRectangle(amarillo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(morado, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(amarillo, 115, 18, 20, 53);
gr.DrawRecangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd7.Checked)
{
r = 4700000;
Resultado.Text = r.ToString();
gr.FillRectangle(amarillo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(morado, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(verde, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd8.Checked)
{
r = 47000000;
Resultado.Text = r.ToString();
Página 214 Aplicación de software a dispositivos móviles
gr.FillRectangle(amarillo, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(morado, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(azul1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
break;
case "5.6":
if (rd1.Checked)
{
r = 5.6;
Resultado.Text = r.ToString();
gr.FillRectangle(verde, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(azul1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(beige, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd2.Checked)
{
r = 56;
Resultado.Text = r.ToString();
gr.FillRectangle(verde, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(azul1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(negro1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd3.Checked)
{
r = 560;
Resultado.Text = r.ToString();
gr.FillRectangle(verde, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(azul1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(cafe, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd4.Checked)
{
r = 5600;
Resultado.Text = r.ToString();
gr.FillRectangle(verde, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(azul1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(rojo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd5.Checked)
{
r = 56000;
Resultado.Text = r.ToString();
gr.FillRectangle(verde, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(azul1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
Aplicación de software a dispositivos móviles Página 215
gr.FillRectangle(naranja, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd6.Checked)
{
r = 560000;
Resultado.Text = r.ToString();
gr.FillRectangle(verde, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(azul1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(amarillo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd7.Checked)
{
r = 5600000;
Resultado.Text = r.ToString();
gr.FillRectangle(verde, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(azul1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(verde, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd8.Checked)
{
r = 56000000;
Resultado.Text = r.ToString();
gr.FillRectangle(verde, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(azul1, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(azul1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
break;
case "6.8":
if (rd1.Checked)
{
r = 6.8;
Resultado.Text = r.ToString();
gr.FillRectangle(azul1, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(gris, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(beige, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd2.Checked)
{
r = 68;
Resultado.Text = r.ToString();
gr.FillRectangle(azul1, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(gris, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(negro1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
Página 216 Aplicación de software a dispositivos móviles
if (rd3.Checked)
{
r = 680;
Resultado.Text = r.ToString();
gr.FillRectangle(azul1, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(gris, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(cafe, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd4.Checked)
{
r = 6800;
Resultado.Text = r.ToString();
gr.FillRectangle(azul1, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(gris, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(rojo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd5.Checked)
{
r = 68000;
Resultado.Text = r.ToString();
gr.FillRectangle(azul1, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(gris, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(naranja, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd6.Checked)
{
r = 680000;
Resultado.Text = r.ToString();
gr.FillRectangle(azul1, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(gris, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(amarillo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd7.Checked)
{
r = 6800000;
Resultado.Text = r.ToString();
gr.FillRectangle(azul1, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(gris, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(verde, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd8.Checked)
{
r = 68000000;
Aplicación de software a dispositivos móviles Página 217
Resultado.Text = r.ToString();
gr.FillRectangle(azul1, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(gris, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(azul1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
break;
case "8.2":
if (rd1.Checked)
{
r = 8.2;
Resultado.Text = r.ToString();
gr.FillRectangle(gris, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(beige, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd2.Checked)
{
r = 82;
Resultado.Text = r.ToString();
gr.FillRectangle(gris, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(negro1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd3.Checked)
{
r = 820;
Resultado.Text = r.ToString();
gr.FillRectangle(gris, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(cafe, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd4.Checked)
{
r = 8200;
Resultado.Text = r.ToString();
gr.FillRectangle(gris, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(rojo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
Página 218 Aplicación de software a dispositivos móviles
if (rd5.Checked)
{
r = 82000;
Resultado.Text = r.ToString();
gr.FillRectangle(gris, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(naranja, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd6.Checked)
{
r = 820000;
Resultado.Text = r.ToString();
gr.FillRectangle(gris, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(amarillo, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd7.Checked)
{
r = 8200000;
Resultado.Text = r.ToString();
gr.FillRectangle(gris, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(verde, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
if (rd8.Checked)
{
r = 82000000;
Resultado.Text = r.ToString();
gr.FillRectangle(gris, new Rectangle(55, 18, 20, 53));
gr.DrawRectangle(azul2, new Rectangle(55, 18, 20, 53));
gr.FillRectangle(rojo, 85, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(85, 18, 20, 53));
gr.FillRectangle(azul1, 115, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(115, 18, 20, 53));
}
break;
}
if (tolerancia.Text == "1%")
{
gr.FillRectangle(cafe, 145, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(145, 18, 20, 53));
}
if (tolerancia.Text == "2%")
{
gr.FillRectangle(rojo, 145, 18, 20, 53);
Aplicación de software a dispositivos móviles Página 219
gr.DrawRectangle(azul2, new Rectangle(145, 18, 20, 53));
}
if (tolerancia.Text == "5%")
{
gr.FillRectangle(dorado, 145, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(145, 18, 20, 53));
}
if (tolerancia.Text == "10%")
{
gr.FillRectangle(plata, 145, 18, 20, 53);
gr.DrawRectangle(azul2, new Rectangle(145, 18, 20, 53));
}
}
catch
{
MessageBox.Show("Falta algun valor");
}
}
private void cetabla_Click(object sender, EventArgs e)
{
t1.BringToFront();
}
}
}
Página 220 Aplicación de software a dispositivos móviles
Aplicación de software a dispositivos móviles Página 221
Referencias
Índice de Diagramas
DIAGRAMA 1 DIAGRAMA DE CLASES DEL FORMULARIO DE CIRCUITOS DIGITALES ......................................................... 93
DIAGRAMA 2 FORMA Y CONTENIDO DEL CAMPO CLASE FORM2 Y SUS METODOS ....................................................... 95
DIAGRAMA 3 DIAGRAMA DE CLASES “ASOCIACIONES ENTRE LAS CLASES” ................................................................. 97
Índice de figuras
FIGURA 1 FIGURAA QUE MUESTRA LA UBICACIÓN Y LA RELACIÓN DE LAS APLICACIONES CON EL USUARIO FINAL. ................... 1
FIGURA 2 ESQUEMA DE RED QUE MUESTRA LA CONEXIÓN CON UN AMPLIO NÚMERO DE PERSONAS................................. 17
FIGURA 3 COMPARACIÓN DE LAS PLATAFORMAS SOPORTADAS POR EL .NET COMPACT FRAMEWORK 3.5 POR EDUARDO
ORTEGA DE MOVILIDAD EN MICROSOFT .................................................................................................. 25
FIGURA 4 VISTA DE SISTEMA WINDOWS MOBILE 6.0 EN SMARTPHONE ..................................................................... 28
FIGURA 5 FOTOGRAFÍA DE UN SMARTPHONE, MARCA NOKIA. EN EL SE MUESTRA LA INTERFAZ EN SU PANTALLA ................ 29
FIGURA 6 MUESTRA DE UN POCKET PC, IPACMARCA HP..................................................................................... 30
FIGURA 7 INTERFAZ DE WINDOWS MOBILE DEVICE CENTER .................................................................................. 31
FIGURA 8 INTERFAZ DEL LA APLICACIÓN CHESS MOBILE POR MICROSOFT CORPORATIVO .............................................. 31
FIGURA 9 PANTALLA DE LA APLICACIÓN DIVX ................................................................................................... 32
FIGURA 10 METODOLOGÍA ORIENTA A OBJETOS PARA EL DISEÑO Y DESARROLLO DE UNA APLICACIÓN. ............................. 36
FIGURA 11 PANTALLA PARA DEMOSTRAR LA RUTA DE UBICACIÓN DEL SOFTWARE MICROSOFT VISUAL STUDIO 2008 DESPUÉS
DE HABERSE INSTALADO ....................................................................................................................... 38
FIGURA 12 SEÑALIZACIÓN DEL MENÚ PARA CREAR NUEVO PROYECTO ...................................................................... 39
FIGURA 13 VENTANA DE CREACIÓN DEL NUEVO PROYECTO. ................................................................................... 39
FIGURA 14 AGREGAR NUEVO PROYECTO Y SEÑALIZACIÓN DE APLICACIÓN A DISPOSITIVO. PARA ESPECIFICAR QUE EL PROYECTO
SERÁ PARA UN DISPOSITIVO MÓVIL. ........................................................................................................ 40
FIGURA 15 SEÑALIZACIÓN DEL CUADRO DE HERRAMIENTAS Y DE LA VENTANA DE PROPIEDADES, DENTRO DE LA INTERFAZ
GRÁFICA DEL VISUAL STUDIO 2008 ........................................................................................................ 41
FIGURA 16 VENTANA DEL EXPLORADOR DE SOLUCIONES, TOMADA DE LA INTERFAZ DE VISUAL STUDIO 2008 .................... 42
FIGURA 17 SEÑALIZACIÓN DENTRO DEL CUADRO DE HERRAMIENTAS Y ELECCIÓN DEL CONTROL ...................................... 43
FIGURA 18 EJEMPLO TOMADO DE LA APLICACIÓN OPERACIONES CON MATRICES PARA QUE SE PUEDA OBSERVAR EL USO DEL
CONTROL ......................................................................................................................................... 43
FIGURA 19 SEÑALIZACIÓN DENTRO DEL CUADRO DE HERRAMIENTAS Y ELECCIÓN DEL CONTROL LABEL.............................. 43
FIGURA 20 EJEMPLO DE UN CONTROL LABEL DENTRO DE UN FORMULARIO, EN ESTE CASO LA ETIQUETA CORRESPONDE A LA
HERRAMIENTA DE AMPLIFICADORES ........................................................................................................ 43
FIGURA 21 SEÑALIZACIÓN DENTRO DEL CUADRO DE HERRAMIENTAS Y ELECCIÓN DEL CONTROL BUTTON .......................... 44
FIGURA 22 EJEMPLO DEL BOTÓN DENTRO DE UN FORMULARIO. ............................................................................. 44
FIGURA 23 SEÑALIZACIÓN DENTRO DEL CUADRO DE HERRAMIENTAS Y ELECCIÓN DEL CONTROL RADIOBUTTON .................. 44
FIGURA 24 EJEMPLO DE USO DE RADIOBUTTON DENTRO DE LA HERRAMIENTA MATRICES ............................................. 44
Página 222 Aplicación de software a dispositivos móviles
FIGURA 25 SEÑALIZACIÓN DENTRO DEL CUADRO DE HERRAMIENTAS Y ELECCIÓN DE LOS CONTROLES COMBOBOX Y LISTBOX; Y
SU USO DENTRO DE LA HERRAMIENTA CONVERSOR DE UNIDADES ................................................................... 45
FIGURA 26 SEÑALIZACIÓN DENTRO DEL CUADRO DE HERRAMIENTAS Y ELECCIÓN DEL CONTROL PANEL ............................. 46
FIGURA 27 USO DEL PANEL DENTRO DE UN FORMULARIO, EN ESTE EJEMPLO, SE TOMÓ EL FORMULARIO DE CIRCUITOS ........ 46
FIGURA 28 SEÑALIZACIÓN DENTRO DEL CUADRO DE HERRAMIENTAS Y ELECCIÓN DEL CONTROL MAINMENU ..................... 47
FIGURA 29 CONTROL MAINMENU DENTRO DE UNA APLICACIÓN ............................................................................ 47
FIGURA 30 SEÑALIZACIÓN DENTRO DEL CUADRO DE HERRAMIENTAS Y ELECCIÓN DEL CONTROL TABCONTROL ................... 47
FIGURA 31 TABCONTROL USADO PARA SEPARAR LOS TEMAS EN UN FORMULARIO....................................................... 47
FIGURA 32 SEÑALIZACIÓN DENTRO DEL CUADRO DE HERRAMIENTAS Y ELECCIÓN DEL CONTROL PICTUREBOX ..................... 48
FIGURA 33 USO DE PICTUREBOX DENTRO DE UN FORMULARIO .............................................................................. 48
FIGURA 34 SEÑALIZACIÓN DENTRO DEL CUADRO DE HERRAMIENTAS Y ELECCIÓN DEL CONTROL PROGRESSBAR .................. 48
FIGURA 35 FUNCIONAMIENTO DEL PROGRESBAR EN ESPERA DE EJECUTAR LA TAREA ELEGIDA ........................................ 48
FIGURA 36 CREACIÓN DEL NUEVO PROYECTO Y LAS OPCIONES IMPORTANTES A TOMAR EN CUENTA PARA ELEGIR QUE LA
PLATAFORMA DE DESARROLLO SERÁ PARA DISPOSITIVO MÓVIL, O BIEN, SMART DEVICE ....................................... 50
FIGURA 37 ELECCIÓN DE LA PLATAFORMA DESTINO Y VERSIÓN DEL COMPACT FRAMEWORK VERSIÓN 3.5, EN ÉSTE CASO LA
VERSIÓN MÁS ACTUAL DE WINDOWS MOBILE ........................................................................................... 50
FIGURA 38 FIGURA DEL EMULADOR, DONDE SE MUESTRA QUE EL FORMULARIO INCLUYE UN MAINMENU ........................ 51
FIGURA 39 VENTANA DE PROPIEDADES DENTRO DE VISUAL STUDIO 2008 ................................................................ 51
FIGURA 40 VENTANA QUE MUESTRA LAS PROPIEDADES DE EDICIÓN AL UTILIZAR EL CONTROL TABCONTROL ...................... 52
FIGURA 41 ELECCIÓN DE LA IMAGEN A INSERTAR EN UN CONTROL PICTUREBOX ......................................................... 53
FIGURA 42 PICTUREBOX DENTRO DE UNA HERRAMIENTA DE APOYO DE LA APLICACIÓN DE ICE ...................................... 54
FIGURA 43 INTERFAZ DE LA HERRAMIENTA DE CONVERSIÓN DE COMPLEJOS Y EL USO DE ETIQUETAS PARA NOMBRAR A LOS
TEXTBOX UTILIZADOS .......................................................................................................................... 56
FIGURA 44 INTERFAZ DE LA HERRAMIENTA MATRICES Y SEÑALIZACIÓN DE LOS DIFERENTES CONTROLES QUE UTILIZA ........... 58
FIGURA 45 INTERFAZ DE LA HERRAMIENTA RESISTENCIAS ...................................................................................... 63
FIGURA 46 INSERCIÓN DE PICTUREBOX DENTRO DE LA HERRAMIENTA RESISTENCIAS, LO CUAL AYUDA A LA MEJOR
COMPRENSIÓN DEL TEMA ..................................................................................................................... 64
FIGURA 47 EDICIÓN Y CONFIGURACIÓN DE ELEMENTOS DEL CONTROL COMBOBOX ..................................................... 65
FIGURA 48 INSERCIÓN DE LOS ELEMENTOS DEL COMBOBOX .................................................................................. 65
FIGURA 49 VENTANA DE PROPIEDADES PARA LA CONFIGURACIÓN DE LOS CONTROLES.................................................. 66
FIGURA 50 ORGANIZACIÓN DE LOS PANELES DENTRO DE UN FORMULARIO, ENVÍO HACIA EL FRENTE O HACIA ATRÁS SEGÚN
CONVENGA, AL MOMENTO DE MOSTRAR LA INFORMACIÓN........................................................................... 69
FIGURA 51 DISEÑO DE INTERFAZ DE LA HERRAMIENTA DE DISEÑO DE COMPUERTA RTL ................................................ 71
FIGURA 52 INSERCIÓN DE TEXTBOX PARA MOSTRAR LOS RESULTADOS UNA VEZ EJECUTADAS LAS OPERACIONES AL PULSAR EL
BOTÓN DISEÑAR ................................................................................................................................ 72
FIGURA 53 INSERCIÓN DE LOS BOTONES QUE MUESTRAN EL CIRCUITO Y OTRO QUE BORRA LOS VALORES INSERTADOS EN LOS
TEXTBOX ......................................................................................................................................... 73
FIGURA 54 MANEJO DE LO PANELES PARA ORGANIZAR LA INFORMACIÓN MOSTRADA DENTRO DE LA HERRAMIENTA ............ 74
Aplicación de software a dispositivos móviles Página 223
FIGURA 55 DISEÑO DE LA HERRAMIENTA CONVERSOR DE UNIDADES Y LA INSERCIÓN DE LOS CONTROLES COMBOBOX PARA
ELECCIÓN DE LAS UNIDADES A CONVERTIR ................................................................................................ 76
FIGURA 56 INSERCIÓN DEL BOTÓN CONVERTIR, DENTRO DE LA INTERFAZ DEL FORMULARIO .......................................... 76
FIGURA 57 COMBOBOX DESORDENADOS FIGURA 57.1 COMBOBOX ORDENADOS ....................................... 80
FIGURA 58 DISEÑO PRINCIPAL DE LA INTERFAZ DE LA APLICACIÓN DE ICE.................................................................. 82
FIGURA 59 INTERFAZ Y ORGANIZACIÓN DE LOS FORMULARIOS REALIZADOS ............................................................... 82
FIGURA 60 INTERFAZ DEL FORMULARIO DE CIRCUITOS DIGITALES ............................................................................ 83
FIGURA 61 INSERCIÓN DEL CONTROL TREEVIEW Y ORGANIZACIÓN DE LOS TEMAS PERTENECIENTES A LA MATERIA DE CIRCUITOS
DIGITALES ......................................................................................................................................... 84
FIGURA 62 ORGANIZACIÓN Y NAVEGACIÓN EN LA INFORMACIÓN MOSTRADA, REFERENTE A LA MATERIA ......................... 84
FIGURA 63 EJEMPLOS DE APOYO A LOS TEMAS MOSTRADOS EN LOS DIFERENTES FORMULARIOS, ESTE EJEMPLO CORRESPONDE
AL FORMULARIO DE CIRCUITOS DIGITALES ................................................................................................ 85
FIGURA 64 TABLAS DE VERDAD Y HOJAS DE ESPECIFICACIÓN DE ALGUNOS DISPOSITIVOS DE CIRCUITOS DIGITALES ............... 86
FIGURA 65 DEMOSTRACIÓN DEL APOYO DE LOS CONTROLES PARA SALIR O REGRESAR A LOS TEMARIOS PRINCIPALES ........... 86
FIGURA 66 INTERFAZ Y ORGANIZACIÓN DE LA HERRAMIENTAS DE APOYO PARA LA APLICACIÓN DE ICE ............................. 87
FIGURA 67 INTERFAZ FINAL DE LA HERRAMIENTA AMPLIFICADORES Y LOS CONTROLES UTILIZADOS PARA SU DISEÑO ............ 88
FIGURA 68 INTERFAZ FINAL DE LA HERRAMIENTA MATRICES Y LOS CONTROLES UTILIZADOS PARA SU DISEÑO ..................... 89
FIGURA 69 INTERFAZ FINAL DE LA HERRAMIENTA CONVERSIÓN DE BASES Y LOS CONTROLES UTILIZADOS PARA SU DISEÑO ..... 89
FIGURA 70 VENTANA DE EXPLORADOR DE SOLUCIONES ........................................................................................ 98
FIGURA 71 ELECCIÓN DE LA OPCIÓN BIBLIOTECA DE CLASES PARA CONVERTIR EL PROYECTO A BIBLIOTECA ........................ 99
FIGURA 72 SE INICIA EL DEBUG PARA COMENZAR CON LA CREACIÓN A BIBLIOTECA .................................................... 100
FIGURA 73 EXCEPCIÓN QUE MARCA LA IMPOSIBILIDAD DE EJECUTAR EL PROYECTO COMO BIBLIOTECA DE CLASES. ............. 100
FIGURA 74 UBICACIÓN DE LA BIBLIOTECA CREADA ............................................................................................. 101
FIGURA 75 IMPLEMENTACIÓN DEL FORMULARIO DESDE EL EMULADOR DE VISUAL STUDIO .......................................... 105
FIGURA 76 VENTANA DEL EMULADOR DE VISUAL STUDIO ................................................................................... 105
FIGURA 77 CREACIÓN Y DISEÑO DE LA INTERFAZ DEL CONJUNTO DE LA HERRAMIENTAS DE APOYO ................................ 108
FIGURA 78 EXPLORADOR DE SOLUCIONES QUE MUESTRA LAS BIBLIOTECAS CREADAS POR EL PROGRAMADOR ................... 109
FIGURA 79 PÁGINA EN MICROSOFT PARA DEMOSTRAR LA POSIBILIDAD DE BAJAR EL COMPACT FRAMEWORK ................... 111
FIGURA 80 PANTALLA DE DESCARGA DEL COMPACT FRAMEWORK ......................................................................... 111
FIGURA 81 COMIENZO DE LA INSTALACIÓN DEL SOFTWARE COMPACT FRAMEWORK .................................................. 112
FIGURA 82 ASISTENTE DE LA INSTALACIÓN DEL COMPACT FRAMEWORK ................................................................. 113
FIGURA 83 INSTALACIÓN PERSONALIZADA DEL COMPACT FRAMEWORK 3.5. ........................................................... 113
FIGURA 84 PANTALLAS PARA LA INSTALACIÓN DEL SOFTWARE COMPACT FRAMEWORK .............................................. 114
FIGURA 85 FINALIZACIÓN DEL ASISTENTE DE INSTALACIÓN DE ,NET COMPACT FRAMEVORK ........................................ 114
FIGURA 86 DEPURACIÓN Y GENERACIÓN DE LA APLICACIÓN ................................................................................. 115
FIGURA 87 PANTALLA DEL EMULADOR ........................................................................................................... 116
FIGURA 88 INTERFAZ DE LA HERRAMIENTA DE LA APLICACIÓN.............................................................................. 116
FIGURA 89 EMULACIÓN DE LOS DATOS Y OBTENCIÓN DE RESULTADOS, DE ACUERDO A LO PROGRAMADO EN EL BOTÓN. .... 117
Página 224 Aplicación de software a dispositivos móviles
Índice de Tablas
TABLA 1 ANÁLISIS DE COSTOS ACTUALES. ........................................................................................................ 119
Aplicación de software a dispositivos móviles Página 225
Glosario
Algoritmo
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 ejecución) la que debe ser finita, no el número de pasos realizados.
API
Una API (del inglés Application Programming Interface - Interfaz de Programación de
Aplicaciones) es el conjunto de funciones y procedimientos (o métodos si se refiere a
programación orientada a objetos) que ofrece cierta biblioteca para ser utilizado por otro software
como una capa de abstracción.
CDMA
La multiplexación por división de código, acceso múltiple por división de código o CDMA (del
inglés Code Division Multiple Access) es un término genérico para varios métodos de
multiplexación o control de acceso al medio basados en la tecnología de espectro expandido.
La traducción del inglés spread spectrum se hace con distintos adjetivos según las fuentes;
pueden emplearse indistintamente espectro ensanchado, expandido, difuso o disperso para
referirse en todos los casos al mismo concepto.
Habitualmente se emplea en comunicaciones inalámbricas (por radiofrecuencia), aunque
también puede usarse en sistemas de fibra óptica o de cable.
Código nativo
Es un seudónimo del lenguaje máquina, que es el lenguaje creado por código fuente compilado y
que puede ser interpretado por la máquina.
Controles
Página 226 Aplicación de software a dispositivos móviles
Son los objetos que conforman la interfaz grafica de un programa; a través de ellos, un usuario
interactúa con la aplicación. Sus características pueden cambiarse por medio de la ventana
propiedades
Eventos
Un evento es una acción como hacer clic, doble clic, presionar una tecla, mover el puntero del
mouse, etc. Que el usuario debe realizar para que un objeto ejecute una acción determinada
cada control responde a diferentes eventos, algunos de ellos tienen características comunes. Los
eventos pueden Visualizarse en la ventana de código.
Framework
Conjunto de APIS y herramientas destinadas a la construcción de un determinado tipo de
aplicaciones de manera generalista.
GPRS
General Packet Radio Service (GPRS) o servicio general de paquetes vía radio es una extensión
del Sistema Global para Comunicaciones Móviles (Global System for Mobile Communications o
GSM) para la transmisión de datos no conmutada (o por paquetes). Existe un servicio similar
para los teléfonos móviles que del sistema IS-136. Permite velocidades de transferencia de 56 a
114 kbps.
GSM
El Sistema Global para las Comunicaciones Móviles (GSM, proviene de "Groupe Spécial
Mobile") es un sistema estándar, completamente definido, para la comunicación mediante
teléfonos móviles que incorporan tecnología digital. Por ser digital cualquier cliente de GSM
puede conectarse a través de su teléfono con su ordenador y puede hacer, enviar y recibir
mensajes por e-mail, faxes, navegar por Internet, acceso seguro a la red informática de una
compañía (LAN/Intranet), así como utilizar otras funciones digitales de transmisión de datos,
incluyendo el Servicio de Mensajes Cortos (SMS) o mensajes de texto.
Aplicación de software a dispositivos móviles Página 227
Métodos
Son procedimientos definidos para realizar operaciones específicas sobre los objetos (Controles
o Formularios)
Módulo
Un proyecto Visual Studio no sólo está compuesto de Formularios, sino también de lo que se
denominan módulos. Un módulo es un fichero Visual Studio donde escribimos parte del código
de nuestro programa.
Kernel
Es el núcleo de todo sistema operativo, que contiene la parte central del funcionamiento y
arranque del sistema.
Objetos
Un objeto es una entidad que tiene asociado un conjunto de métodos, eventos y propiedades.
Hay muchas clases de objetos, y por tanto, puede llegar a haber tantos métodos, eventos y
propiedades distintas como objetos diferentes. Ejemplo: Una caja de texto (TextBox) en la cual
podemos escribir cualquier línea, es un objeto.
Propiedades
Son los datos que hacen referencia a un objeto o formulario. Ejemplo: Color de fondo del
formulario, Fuente de texto de un TextBox.
SDK
Conjunto de programas que usa un programador para crear una aplicación. Consta de un editor,
un constructor gráfico, un compilador y un enlazador.
WIFI
Es un sistema de envío de datos sobre redes computacionales que utiliza ondas de radio en
lugar de cables. WIFI no es una abreviatura de Wireless Fidelity, simplemente es un nombre
comercial.
Página 228 Aplicación de software a dispositivos móviles
WML
El Wireless Markup Language es un lenguaje cuyo origen es el XML (eXtensible Markup
Language). Este lenguaje se utiliza para construir las páginas que aparecen en las pantallas de
los teléfonos móviles y los asistentes personales digitales (PDA) dotados de tecnología WAP. Es
una versión reducida del lenguaje HTML que facilita la conexión a Internet de dichos dispositivos
y que además permite la visualización de páginas web en dispositivos inalámbricos que incluyan
la tecnología WAP. La visualización de la página dependerá del dispositivo que se use y de la
forma en que este interprete el código, ya que varían entre sí. WML es un metalenguaje, lo que
implica que además de usar etiquetas predefinidas se pueden crear componentes propios y tiene
ciertas similitudes con otro lenguaje de etiquetas bastante conocido, el HTML (Hypertext Markup
Language), utilizado para la creación de páginas web convencionales.
Aplicación de software a dispositivos móviles Página 229
Índice Alfabético
.NET, vi, vii, 16, 17, 24, 34
.NET Framework, 24, 25, 26, 27, 34, 37,
94, 98, 124, 129, 130, 131, 134, 135,
136, 137, 139, 143, 147, 148, 149,
157
Active Sync, x, 103, 127
Algoritmo, 225
API, 28, 225
CLR, 16, 25, 26, 27, 124, 130
CTS, 26
dispositivos móviles, vi, viii, ix, 1, 2, 11,
12, 18, 24, 25, 28, 32, 35, 155
Framework, vi, 16, 17, 24, 25, 32, 37, 40,
49, 50, 94, 97, 99, 104, 106, 107,
111, 113, 118, 124, 125, 126, 129,
131, 132, 135, 136, 139, 149, 226
Java, viii, 11, 24, 27, 90
Linux, 7, 9, 10, 11, 18
MSIL, 26, 124, 137, 142
Palm OS, 7, 8, 9, 10, 11
PDA, 1, 2, 7, 9, 11, 18, 20, 30, 31, 32,
228
Pocket PC, I, vi, viii, ix, x, 2, 6, 7, 18,
19, 20, 23, 28, 29, 30, 40, 49, 81,
103, 105, 106, 110, 115, 116, 118,
121, 122, 125, 126, 131
Smartphone, vii, 3, 18, 20, 28, 29, 104,
125, 126, 131
telefonía celular, 1, 3, 4, 5
Visual Studio, vi, vii, 27, 32, 33, 34, 49,
81
Windows CE, viii, ix, 7, 18, 107, 118,
125, 126, 127, 136
Windows Mobile, vi, vii, 7, 8, 9, 10, 13,
16, 18, 21, 24, 28, 29, 30, 31, 40, 49,
50, 103, 104, 107, 125, 126, 127, 132
Página 230 Aplicación de software a dispositivos móviles
