Metodos de retroiluminacion en un TV y pistas para su reparacion


Todos hemos oído hablar de TFT, LCD, Plasma ,OLED,LED e  incluso combinaciones de ellas, como TFT LCD, y muchas más, veamos a grandes rasgos sus diferencias:

  • TFT: TFT no es una tecnología de visualización en sí, sino que simplemente se trata de un tipo especial de transistores con el que se consigue mejorar la calidad de la imagen. Su uso más frecuente es junto con las pantallas LCD.
  • LCD y TFT LCD: La tecnología LCD utiliza moléculas de cristal líquido colocadas entre diferentes capas que las polarizan y las rotan según se quiera mostrar un color u otro. Su principal ventaja, además de su reducido tamaño, es el ahorro de energía. Cuando estas pantallas usan transistores TFT entonces estamos hablando de TFT LCDs, los cuales son los modelos más extendidos en la actualidad.Incorporan un filtro con la cual ya no te malogran ni cansan la vista a comparación de los CRT.
  • PLASMA: Al contrario que las pantallas LCD, las pantallas de plasma utilizan fósforos excitados con gases nobles para mostrar píxeles y dotarles de color. Aunque se inventó en 1964 se trata de la tecnología mas retrasada, en cuanto a nivel de implantación, debido a que su precio es mas elevado (aunque cada vez la diferencia es menor) y también  porque la tecnología   LED  ha equiparado  en calidad a estas. Las características que destacaban  son un  mayor ángulo de visión que una pantalla LCD, mejor contraste y más realismo entre los colores mostrados pero sin embargo  con un  costo mayor   y un mayor consumo  energético.
  • OLED: Por ultimo, esta tecnología que también tiene muy pocos años y que poco a poco también iremos viéndola mas constantemente. Se trata de una variante del LED clásico, pero donde la capa de emisión tiene un componente orgánico. Seguramente habrá escuchado que las pantallas OLED tienen la ventaja de no necesitar luz trasera, con lo que ahorran mucha mas energía que cualquier otra alternativa. Además, su costo también es menor. Sin embargo, su tiempo de uso no es tan bueno como el de las anteriores tecnologías que les hemos comentado.
  • LED :Las pantallas LED son pantallas LCD que emplean tecnología de retroiluminación LED, a diferencia de las pantallas LCD convencionales, que utilizan retroiluminación mediante CCFL,es decir  en vez de utilizar lámparas fluorescentes utilizan retro iluminación por LED.Al no utilizar lámparas fluorescentes eliminan el uso de Mercurio en los monitores, evitando la contaminación.  Presenta mejor contraste en las imágenes proyectadas, también controla mejor el brillo de la imagen para evitar la fatiga en la vista.La ventaja más directa en el uso de luces LEDs para retroiluminar los paneles de televisores LCD es el menor consumo de este tipo de diodos (hasta un 40%menos). Son así equipos más eficientesenergéticamente y cuya vida útil también es mayor. En la calidad de imagen  destaca el aumento del contraste dinámico en los televisoresLED frente a losLCD clásicos. La representación de color también mejora con la tecnologíaLED. Las pantallasLED son las que se han implantado    frente al resto de tecnologías  por proporcionar  imágenes de elevado brillo y contraste y bajo consumo de energía, una mayor temperatura del panel y una vida útil de los diodosLED limitada.Existen varios tipos de pantallasLED en función de la tecnología deretroiluminaciónLED empleada:
    • Edge LED: los diodos LED van colocados alrededor de la pantalla, en los bordes del televisor, utilizándose un panel especial para distribuir la luz de forma uniforme por toda la superficie de la pantalla. Esta disposición lateral de los diodos hace que el televisor sea muy delgado, pero no permite iluminar de forma precisa toda la pantalla, lo que afecta negativamente a la relación de contraste.
    • Full LED (también llamada Direct LED): los diodos LED están distribuidos por todo el panel, no sólo en los bordes de la pantalla, lo que permite mejor contraste, brillo y calidad de imagen, aunque con un mayor consumo de energía y grosor que las pantallas Edge LED.

 

 

En resumen, los monitores LED gastan menos energía, ayudan a cuidar el medio ambiente y presentan mejor imagen que un LCD

 

Retroiluminacion del los paneles LCD

 

En las pantallas LCD es necesaria la retroiluminación porque la imagen está formada por pixels pero estos no emiten luz por sí mismos, por lo que es necesaria una fuente de luz que ilumine los pixels desde la parte posterior.

Las principales diferentes de las pantallas LED frente a las pantallas LCD con retroiluminación CCFL:

  • Los LED necesitan menos espacio que las lámparas CCFL lo que permite reducir el grosor, obteniendo paneles más delgados.
  • En función del tipo de tecnología LED, las pantallas LED pueden consumir entre 20 y 40% menos que las pantallas LCD convencionales.
  • Mejor nivel de brillo, niveles de contraste y gama de colores más amplia en los paneles con LED.
  • Mayor alta tasa de refresco en los paneles LED (cansa menos la vista )
  • Menor  temperatura sobre el panel en los LCD.
  • Vida útil de los diodos LED limitada.

Los LED se diferencias de los LCD simplemente en la forma en que se ilumina la pantalla. Los LCD usan tubos fluorescentes tipo lampara de bajo consumo y los LED usan leds que también existen en forma de lamparas pero son poco conocidas y muy caras.

Veamos  ahora  la electrónica involucrada en ambos casos

 

 

 

 

 

 

 

 

 

 

RETROIMUMINACION  DE  UN TELEVISOR  LCD

 

Un   componente fundamental y exclusiva de los TV de LCD es el inverter, pieza  que no existía en los TV convencionales o de tubo de imagen.El inverter es el encargado junto a las lámparas CCFL de la retroiluminación de la pantalla.

El circuito de inverter se basa en circuitos osciladores de alta tensión similar  como el que se usa en el circuito de líneas de un TV de Tubo de imagen para obtener el MAT o alta tensión. La diferencia es que en la etapa de MAT se obtenían tensiones del orden de 20 a 25 KV y en un inverter cada circuito de MAT proporciona sobre 1KV. Otra diferencia es que hay un circuito de MAT para cada lámpara o para cada dos,con lo cuál en un inverter puede encontrar 6, 7 o 8 transformadores en los casos más normales, pudiendo haber incluso más según el tamaño de la pantalla.

 

Las conexiones externas de un inverter que necesita para funcionar son:

  1.  24V
  2.  BL_ON
  3.  BL_Current que se utiliza para dar más iluminación trasera o menos. Hay veces que no se utiliza y aunque no esté presente el inverter funciona.
  4. línea de protección que se activa cuando detecta algún fallo en elinverter. Esta línea la utiliza algún fabricante para apagar la fuente si hay fallos en elinverter, pero son pocos los que la usan, con lo cuál si no se usa elTV sigue funcionando con sonido.El orden de arranque es el siguiente:
  •  Pulsamos el interruptor general y obtenemos 5V y 3V3.
  •  Pulsamos Stand-By o Programa + y se activa POWER_ON con lo cuál se obtienen 12V de la segunda fuente y 24V de la tercera fuente.
  •  Una vez que todos los circuitos integrados de la Main Board están alimentados el micro ya se puede comunicar con ellos a través del Bus I2C y chequearlos.
  •  Si el micro detecta que está todo bien activa la línea BL_ON, que también puede llamarse Backlight_ON.
  •  Esta línea es parecida a POWER_ON pero hace funciona el inverter.
  •  Una vez con 24V y BL_ON a nivel alto en el inverter, este ya puede hacer oscilar todas las etapas de alta tensión e iluminar las lámparas.

 

Averías   en el inverter 

 

Una avería típica de los  TV LCD  es que al encender el televisor LCD, después de unos  segundos  la pantalla se apaga ,pero el sonido del TV es normal, excepto que sólo hay visualización( se puede comprobar iluminando con una linterna . La tensión de alimentación de la placa del inversor puede ser buena y el inversor en señal del mainboard puede estar presente también. Eso significa que el problema puede estar en la placa del inversor o en  las lámparas CCFL

Después de medir todos los componentes sospechosos en la placa del inversor, si no cuenta con un  probador de la lámpara CCFL en este momento, puede usar  un método especial para probar las lámparas CCFL para comprobar si están funcionando o no (tiene que ser cuidadoso con este método, ya que podría dañar los componentes de la placa del inversor) llamado  como “protección del inversor Bypass“, pues le permitirá saber si cualquiera de las lámparas CCFL esta averiada  o el problema es de la  placa del inversor que hace que  causado la TV LCD se apague después de un segundo.

En el inverter  es  fácil  utilizar el OZ9938 IC como inversor IC. Si se refiere al pin 3 en el diagrama siguiente se podía ver la marca pin  “Timer” y la descripción como “condensador de temporización para establecer sorprendente el tiempo y el tiempo de retardo de apagado”. Esto significa que el condensador externo tomará la decisión en “ON” el momento lámparas CCFL. Si el valor de la tensión llega a su entorno tensiones y las lámparas aún no esta puesta en marcha, el OZ9938 dejará de funcionar y cerrar.
OZ9938 ic
Ahora, cuando se corte el pin 3 de OZ9938 IC a tierra, se cancelará temporalmente el sistema de retroiluminación cortó función de protección y la TV LCD se puede activar . Mire la pantalla ahora para ver si hay alguna zona de barras negra / oscuras y asegúrese de que el brillo es incluso en todos los ángulos. Si en la pantalla el brillo es bueno, entonces esto significa que la luz de fondo está trabajando muy bien y el problema está en la placa del inversor. Si pudieran ver la zona oscura / negro entonces esto significa que una de la luces de fondo LCD tienen problema. No encienda el televisor LCD durante mucho tiempo por motivos de seguridad.
Despues de  comprobar   todos los componentes en la placa del inversor  si  están en buen estado puede  encender  el televisor LCD de nuevo y dejarlo encendido  durante unos 3 minutos (después de un cortocircuito en el pin 3 de OZ9938 IC a tierra). Después de 3 minutos, apagar el televisor LCVD y tocar   cuidadosamente  los componentes  ( especialmente los  7 transformadores HV) para  comprobar la temperatura . Si alguno de los  7 HV esta   mas  caliente, podria ser  el devanado obtener cortocircuito cuando está bajo carga haciendo que la protección de sobrecorriente (CCFL Lamps Circuito equilibrio actual) actué clausurando así la luz de fondo.   En este caso  la sustitución de un nuevo transformador de alto voltaje en el T914 hara que , el televisor LCD funcione perfectamente bien. Puesto a prueba la TV LCD de más de 30 minutos ya se encontró que la temperatura del T914 a ser normal otra vez.

 

 Lámparas CCFL circuito de balance actual

 

Por cierto , dado el alto coste  tanto de los inverters,así   como el de las lamparas CCFL, hay muchas personas que optan ,por reemplazar todo el conjunto (INVERTER + CCFL)   por una economica  tira de  leds SMD pegándolos a lo largo del panel LCD  , tomando   de la fuente  de alimentación los 12 V para alimentar las tiras de led .

 

Todas las tiras de LED, vienen con película adhesiva 3M estándar  , por lo que se pueden colocar de manera creativa en cualquier lugar  . Las tiras suelen ir paquete de 5 metros de tira de LED pero se pueden cortar a la medida  que nos interese segun la longitud  del panel LCD

Algunos incluyen   regulador de intensidad , lo cual  nos puede ser util  para  ajustar el brillo correcto del LCD   si vamos a sustituir todo el conjunto (INVERTER + CCFL)

 

Etas son algunas de sus características:

Tipo del LED: SMD3528

Color: LED blanco frío

Cantidad: 300leds / 5metre

Ángulo de visión: 120 °

Voltaje de entrada: 12VDC, ? 2A

Energía de trabajo: 4,8 W / M

Corriente / metro: 0 35-0 4A

Temperatura de trabajo: -20 a 50 º

Tarifa de la protección: IP65 Impermeable-

 

 

El precio de esta tiras  ronda los 15€  en Amazon :3528 SMD Blanco fresco impermeable los 5M 300Leds. Tira LED de luz de lámpara. + Dimmer LD124

Anuncios

Cómo reparar una TV LCD con leds


Pues en efecto tanto los  TV como los monitores  LCD  por diversos motivos pueden averiarse justo en el sistema de reto-iluminación, bien en los circuitos de los balast    que suelen  fallar bastante por las altas intensidades que manejan,   o  bien en los propios tubos , ambos con idénticas consecuencias: no habrá  imagen,  pero en cambio si habrá sonido.
En todos los casos, para comprobar que en efecto  falla  la reto-iluminación, la forma de proceder para comprobarlo es iluminar con una fuente de luz exterior  (  ha ser posible en  oscuridad) el propio LCD con el foco de luz : en ese caso, debería verse en la zona iluminada la imagen ( aunque difusa y con muy pobre contraste ), señal de que toda la electrónica de vídeo funciona y solo falla la iluminación posterior del panel lcd
En caso de no encontrar repuestos de balast o de lo propios tubos una solución económica puede  ser  usar tiras flexibles SMD LED No-Impermeable 5050 DC12V, veamos  los pasos  para  usar esta ingeniosa solución:

Paso 1: Desmontar TV LCD

Desmontar por completo el  TV LCD para reemplazar Backlight  usando  lógicamente  herramientas apropiadas y procurando no olvidar  o perder las conexiones entre los diferentes módulos.

 Paso 2: Antes de los  LED

Imagen Antes de LED SMD Fit

Retire el tubo de luz de fondo antiguo , asi como su electronica  asociada  antes de preparar los leds

Paso 3: Trabajo con SMD LED 5050 12v

Foto de Trabajo con SMD LED 5050 12v

!Divida y vencerás como su requisito!

En este ejemplo   se esta reparando  una Pantalla LCD  de  22 “,  que requirió una tira de 50 cm en cada lado (superior / inferior), lo cual en total suponen 1 metro  de tira de leds.

Al extremo  de la tira de leds   debemos soldar  un par de cables  respetando la polaridad.

Paso 4: Antes de poner SMD LED

Imagen Antes de colocar LED SMD

Las tiras  de led suelen ser auto-adhesivas    , así que retire el plástico protector por  la cara adhesiva, antes  de proceder  a la colocación de esta , cortando con unas tijeras normales sólo  por las lineas marcadas  a tal efecto 

Paso 5: Cómo poner SMD LED

Imagen de Cómo Coloque LED SMD

Para pegar la tira  SMD LED ,use una  herramienta para asegurarse que queda bien fijada la tira

Paso 6: Cómo encender luz de fondo?

Imagen de Cómo encender luz de fondo?

Encender  la  de luz de fondo no es gran problema con un alimentador externo de 12V  DC  , pero hay un problema cada vez que se necesita ,para activar manualmente la potencia de encendido / apagado ( eso seguro  que no se ve tan bien).

La  solución pasa  simplemente alimentarlo desde la placa  ATV donde  usted puede encontrar fácilmente la externalización de + 12v y GND que suele ir bien marcado en la placa madre.

Paso 7: Antes de volver a montar!

Imagen Antes de Ensamble!

Deba  asegurarse  de que no ha perdido conectividad y asegurarse de que funciona- En caso contrario compruebe todas  las conexiones pues podría haberse qusdado algunas conexión sin montar

Paso 8: Ultimo Paso!

Foto del último paso!

Ya sólo queda  Montar su tv lcd y disfrutar.

 

Fuente   aqui

Usando el 16×4 LCD: μLiquidCrystal


ET MF incluye soporte mejorado para interfaces gráficas. Hay algunas placas  con lcd integrado como el Tahoe II , ChipworkX o FEZ Cobra que tiene pantalla gráfica y puede ser manejado por las clases implementadas. .

Sin embargo, el más común entre los aficionados  son el display alfanumérico tradicional, especialmente de 16 caracteres por dos líneas “16×2”.

 Los LCDs de  16×2 son muy populares debido a que la forma de comunicarse es a través de un bus paralelo se puede utilizar con los viejos puertos LPT1 ( impresoras), que popularizó su uso muy bien permitir que un ‘emulación manual “del mensaje, o puede contener una gran cantidad de llaves y completamente repetir la introducción de datos para mostrar el mensaje en la pantalla LCD, hace un par de años
Una desventaja de la comunicación en paralelo es la cantidad de lineas de IO necesarias  ( ocho para ser exactos), y que es un problema cuando sólo tiene a su disposición (desafortunado Netduino usando un chip con 50 IO y sólo está disponible en el adaptador de 14 pines) de 14IO.
Otra desventaja importante es lo engorroso  que puede resultar el  quitar el panel de control LCD, por ser necesario pasar a la placa un cable de 5 pares (10 hilos) a la pantalla LCD.
Sin embargo en este artículo se he buscado una solución que satisficiera forma más general y con un menor costo en términos de aplicaciones de software. La mejor solución fue presentada por Pavel Bansky en su blog. Estos son dos artículos en los que el primer artículo se realizó señal de multiplexación análisis de la pantalla LCD para el uso en 3-hilos  y de acuerdo con un artículo asociado ha construido una aplicación que implica el hardware I ² C microcontrolador para reducir el costo del software.
Además de trabajo Pavel también tiene una excelente referencia en el Internet que es el diseño μLiquidCrystal Lo que comenzó como un proyecto de Szymon Kobalczyk de  y luego concretarse y ahora es un paquete completo de clases para los dispositivos tales como LCD y pantalla de la manipulación.

Prácticamentetodos los s LCDs populares sebasan  en elfamoso chip de Hitachi  HD44780 queademas conestecontroladorpermite lacomunicaciónparalela. El 16-pinconectorestándar en lalínea en la parte inferiorderecha de laesquinatablero LCDtambién esmuytípico ypuedeutilizar unacombinación deinformaciónparalela 8 de bits o 4 bits (pseudoserie), esdecir, el 16-pin 8 son parainformar de un feed lalógica, dos pines paraalimentar la luz defondo, elpoder y la terminal detierra de lapantalla ensí y de lacomunicación enserie de doscontactosascendió a 16 pins.

Las instrucciones para la escritura y la lectura es un estándar que Pavel Bansky demostró que es sencillo para multiplexar con registro de desplazamiento y poner el código en el Netduino.

Pavel utilizó el CMOS 4094 es el mismo que 74HC595 TTL que sólo se acepta como un archivo de valores de alto nivel por encima de 2,5 V que significa que usted puede colgar un 5V LCD directamente con Netduino de la IO y sin un circuito adicional sólo el registro de desplazamiento 74HC595.

Por otra parte, si desea utilizar una pantalla LCD de 3,3 V Restivo sólo hay que poner un separador hecho con un rango de 1.68 kOhms y 3,3 kOhm que el nivel de salida es de 3,3 V.

Pavel implementó el tratamiento en dos LCD papeles gemelos uno debajo del otro. La clase que en realidad está incluida en los códigos es LiquidCrystal y en un segundo nivel requerido ILiquidCrystalTransferProvider tratar con la interfaz de hardware para poder utilizar la misma clase de nuevo con los manipuladores de hardware diferente, ambos implementados por Pavel esGpioLiquidCrystalTransferProvider y HC4094 Szymon que en su mayor parte, procedió a llamar Shifter74Hc595LiquidCrystalTransferProvider, Szymon porque estaba usando el 74595 para conectar la pantalla LCD. tiene otras cosas implementas relacionas con algunas tarjetas de expansión para LCD equipado con un chip de comunicación, ya que estamos en Brasil, el más es la comunicación en serie se hace con una tarjeta de expansión con PIC16F628 o algo así. Las implementaciones realizadas por Pavel y por Szymon incluyen chips de soporte MCP23008 yPCF8574P una clase llamada BaseShifterLiquidCrystalTransferProvicer. ‘s Szymon en su blog mencionó la comunicación SPI a hablar como LCD, una alternativa si se carga el bus I ² C a pesar de que no he visto manera en que el tratamiento se produce la comunicación SPI.

El SPI se encuentra disponible a través de los pins Netduino 11 (MOSI), 12 (MOSO) y 13 (SPCK) y cualquier otro pasador para seleccionar el esclavo deseado. Esta implementación de Szymon parte de μLiquidCrystal, en realidad no lo probó, pero vale la pena echar  un vistazo.

 

 

Con respecto al circuito, vale la pena una cierta consideración. La Primera refiere a un transistor NPN (BC548  pero se he usado el 2N2222 es el equivalente americano) que por lo general surge para controlar la luz de fondo de la pantalla LCD a través de un registro de desplazamiento de salida para que pueda encender y apagar la pantalla LCD en el Código si desea guardar energia.

A otra es controlar la luminosidad de la pantalla LCD se puede hacer mediante la colocación de una olla de 47Kohms la 2Kohms, o no quieren simplemente configurar y listo para poner un divisor resistivo. ‘s Pavel creado una biblioteca (que como tava viejo tuvo que . recrearlo en NETMF 4.2) llamado Bansky.SPOT.LCD donde existen métodos y ITransferProvider SendByte . capa utilizada para interactuar con otros El código de prueba es la siguiente:

 

> / / Crear instancia de registro de desplazamiento
/ / (Compatible con los 74.595!)
Shifter HC4094 = nueva HC4094 (Pins.GPIO_PIN_D0,    
                                Pins.GPIO_PIN_D2,
                                Pins.GPIO_PIN_D1,
                                false );         
/ / Crear una nueva instancia LCD
LCD4Bit lcd = nueva LCD4Bit (shifter);
/ / Activar la visualización, gire de nuevo la luz en,
Gran espectáculo cursor / / Ocultar cursor pequeño, parpadeando
lcd.Display ( verdadero , verdadero , falso , verdadero );
/ / Borrar la ventana
lcd.Clear (); 
/ / Escribir el mensaje en primera línea
lcd.Write ( "Victor M. >>>>>>>>" );
/ / Mueve el cursor a 2 ª línea
lcd.SetPosition (40);         
/ / Escribir en el segundo Line
lcd.Write ( "Q2 NETMF." );
Thread.Sleep (Timeout.Infinite);

Tenga en cuenta que el flujo del proceso es muy simple:

  1. Crear la clase de la primera capa de informar a los pasadores del hardware que se utiliza para esa función;
  2. Cree el manejo de la pantalla LCD a partir del hardware de clase;
  3. Ajuste que desea mostrar en la pantalla LCD (si el parpadeo caja);
  4. Limpieza del LCD;
  5. Escriba el mensaje.

Hay mucho más que decir sobre el LCD, es muy sencillo, más que mi trabajo era para montar el circuito en el tablero para entender la operación. Y entonces la imagen que muestra el resultado final:

Fuente aqui

Proyecto alarma casera con Netduino


En este original   proyecto  se trata de proteger una habitación de la bomba de sumidero  potencialmente peligrosa para los niños  asegurándose  de que las estancias quedan las  puertas cerradas y las personas (principalmente niños) no entran  en esta.

Las soluciones “alarma de la puerta” disponibles en el mercado parecen dirigidas a congeladores y simplemente no se adaptan a  necesidades mas complejas del autor   que pensaba mas bien  en una solución  con  Netduino.

La idea  original por tanto era algo que hiciera sonar  una alarma corta cuando se abriera la puerta y luego alertara a intervalos (cada pocos minutos), similar a un detector de humo con una batería que funcionase hasta agotar la batería o  hasta que la puerta se cerrase

esquema_alarma

La unidad controla la puerta a través de un interruptor magnético. Cuando se abre la puerta varias cosas suceden:

  1.  La luz del techo se enciende con un relé que controla una carga de baja  tensión.
  2.  Un servicio web se llama el cual envía un MMS a un teléfono.
  3. Un contador de tiempo que  se activa qeu al concluir  producirá una alerta sonora y hara una  llamada webservice (MMS) si la puerta permanece abierta durante un periodo de tiempo determinado.

Cuando se cierra la puerta a la luz se apaga y el temporizador de la alarma se detiene. El proyecto también incorpora una pantalla LCD de 2 líneas para mensajes, 2 LEDs (1 para la energía, 1 para la indicación de modo de problemas / override) y algunos botones para interactuar con el sistema.

Las funcionalidades de esta alarma de puerta basada en Netduino pues son las siguientes :

  •  Apaga/enciende  la luz : la enciende automáticamente cuando se abre la puerta y la apaga cuando la puerta está cerrada
  •  Alarma del MMS al abrir la puerta (a través de llamadas de servicio web)
  •  Alerta audible y alerta MMS adicional si la puerta se deja abierta más tiempo que  el  valor del temporizador
  •  Alerta que se repiten a intervalos especificados si la puerta sigue dejándose abierta
  • 4 botones :
    •  Botón 1: Manual de luz de encendido / apagado de anulación
    • – Botón 2: Regreso al control de forma automática la luz
    • – Botón 3: mensajes de error Revisión (principalmente para conexiones de red)
    • – Botón 4: Encender / apagar el sensor de la puerta (permite prolongado puerta abierta sin alerta)

Respecto al software para Netduino  se utilizan  cuatro clases :

Una clase para  dar soporte  a la comunicación de red:

public static class Network
{
public static bool NetworkAvail = false;
public static NetworkInterface ni = NetworkInterface.GetAllNetworkInterfaces()[0];

static NoteClass[] networkUpTune = {
new NoteClass(5,NoteClass.C, NoteClass.ThirtySecond),
new NoteClass(5,NoteClass.Rest, NoteClass.ThirtySecond),
new NoteClass(5,NoteClass.C, NoteClass.ThirtySecond),
new NoteClass(5,NoteClass.Rest, NoteClass.ThirtySecond),
new NoteClass(5,NoteClass.C, NoteClass.ThirtySecond)
};

static NoteClass[] networkDownTune = {
new NoteClass(3,NoteClass.C, NoteClass.ThirtySecond),
new NoteClass(3,NoteClass.Rest, NoteClass.ThirtySecond),
new NoteClass(3,NoteClass.C, NoteClass.ThirtySecond),
new NoteClass(3,NoteClass.Rest, NoteClass.ThirtySecond),
new NoteClass(3,NoteClass.C, NoteClass.ThirtySecond)
};

static NoteClass[] alertTune = {
new NoteClass(5,NoteClass.C, NoteClass.Eighth),
new NoteClass(6,NoteClass.C, NoteClass.Eighth),
new NoteClass(5,NoteClass.C, NoteClass.Eighth),
new NoteClass(6,NoteClass.C, NoteClass.Eighth)
};

public static void InitNetwork()
{
ParallaxLCD.Print(“Network…”);
int count = 0;
//DHCP can take a few seconds to finish so wait (up to 10 seconds) for it to complete
while (true)
{
count++;
ni = NetworkInterface.GetAllNetworkInterfaces()[0];
//only try for 10 seconds
if (ni.IPAddress != “0.0.0.0” || count > 10) break;
Thread.Sleep(1000);
}
if (ni.IPAddress == “0.0.0.0”)
{
ParallaxLCD.Print(“Network…\rError: Failed”);
}
else
{
ParallaxLCD.Print(“Network… IP:\r” + ni.IPAddress);
NetworkAvail = true;
}
//wire in event handler to keep track of the current network up/down state
NetworkChange.NetworkAvailabilityChanged += new NetworkAvailabilityChangedEventHandler(NetworkChange_NetworkAvailabilityChanged);
}

static void NetworkChange_NetworkAvailabilityChanged(object sender, NetworkAvailabilityEventArgs e)
{
NetworkAvail = e.IsAvailable;
if (Program.initializing)
return;
if (NetworkAvail)
{
ParallaxLCD.Play(networkUpTune);
}
else
{
ParallaxLCD.Play(networkDownTune);
}
}

public static void SendAlert()
{
if (NetworkAvail)
{
try
{
//HttpWebRequest
HttpWebRequest alertRequest = (HttpWebRequest)WebRequest.Create(Program.AlertWebService);
alertRequest.Method = “GET”;
HttpWebResponse alertResponse = (HttpWebResponse)alertRequest.GetResponse();
if (alertResponse.StatusCode != HttpStatusCode.OK)
{
Program.LastError = “(SendAlert) ” + alertResponse.StatusCode.ToString() + “: ” + alertResponse.StatusDescription;
ParallaxLCD.Play(alertTune);
}
}
catch (Exception e)
{
Program.LastError = “(SendAlert) ” + e.Message;
ParallaxLCD.Play(alertTune);
}
}
else
{
Program.LastError = “(SendAlert) Network unavailable”;
ParallaxLCD.Play(alertTune);
}
}

}
}

La clase  para controlar el display LCD

//Non-visible characters (Decimal ASCII) used by the Parallax LCD as commands
public enum LCD_COMMAND_CHARS
{
PrintCustomChar0 = 0,
PrintCustomChar1 = 1,
PrintCustomChar2 = 2,
PrintCustomChar3 = 3,
PrintCustomChar4 = 4,
PrintCustomChar5 = 5,
PrintCustomChar6 = 6,
PrintCustomChar7 = 7,
Backspace = 8,
Right = 9,
LineFeed = 10,
FormFeed = 12, //clears display and sets cursor to row 0 column 0
CR = 13,
BacklightOn = 17,
BacklightOff = 18,
DisplayOff = 21,
DisplayOn_NoCursor_NoBlink = 22,
DisplayOn_NoCursor_CharBlink = 23,
DisplayOn_Cursor_NoBlink = 24,
DisplayOn_Cursor_CharBlink = 25,
//Sound control
NoteLength_1_64 = 208,
NoteLength_1_32 = 209,
NoteLength_1_16 = 210,
NoteLength_1_8 = 211,
NoteLength_1_4 = 212,
NoteLength_1_2 = 213,
NoteLength_Whole = 214,
NoteScale_3 = 215,
NoteScale_4 = 216,
NoteScale_5 = 217,
NoteScale_6 = 218,
NoteScale_7 = 219,
Note_A = 220,
Note_A_Sharp = 221,
Note_B = 222,
Note_C = 223,
Note_C_Sharp = 224,
Note_D = 225,
Note_D_Sharp = 226,
Note_E = 227,
Note_F = 228,
Note_F_Sharp = 229,
Note_G = 230,
Note_G_Sharp = 231,
Note_Rest = 232,
LoadCustomChar0 = 248,
LoadCustomChar1 = 249,
LoadCustomChar2 = 250,
LoadCustomChar3 = 251,
LoadCustomChar4 = 252,
LoadCustomChar5 = 253,
LoadCustomChar6 = 254,
LoadCustomChar7 = 255
}

//This class assumes the Parallax LCD/speaker combo unit is connected to Netduino Plus Digital I/O PIN 3
//which is reserved for COM2 in the Netduino framework. Also assumes the Parallax LCD has been set to
//9600 baud using it’s onboard dip switches.
public static class ParallaxLCD
{
private static SerialPort LCD_PORT;
private static string COM_PORT = “COM2”; //Netduino Plus Digital I/O PIN 3
private static int COM_BAUD = 9600;

private static bool _LCD_state = false;

public static bool LCD
{
get
{
return _LCD_state;
}
set
{
if (value == _LCD_state)
{
//LCD already in specified state, don’t do anything
return;
}
if (value)
{
LCDOn();
BacklightOn();
}
else
{
BacklightOff();
LCDOff();
}
_LCD_state = value;
}
}
public static void Print(string inputstring)
{
//if the first line is >= 16 characters then remove the line break for a more natural behavior
int cr = inputstring.IndexOf(‘\r’, 0);
if (cr >= 16)
{
inputstring = inputstring.Substring(0, cr) + inputstring.Substring(cr + 1);
}
//this routine assumes all output will be “full screen”, meaning no other data is left on the screen
ClearLCD();
byte[] bytes = UTF8Encoding.UTF8.GetBytes(inputstring);
LCD_PORT.Write(bytes, 0, bytes.Length);
}

public static void StartSerial()
{
LCD_PORT = new SerialPort(COM_PORT, COM_BAUD, Parity.None, 8, StopBits.One);
LCD_PORT.Open();
}

public static void BacklightOn()
{
LCD_PORT.Write(new byte[] { (int)LCD_COMMAND_CHARS.BacklightOn }, 0, 1);
}

public static void BacklightOff()
{
LCD_PORT.Write(new byte[] { (int)LCD_COMMAND_CHARS.BacklightOff }, 0, 1);
}

public static void ClearLCD()
{
LCD_PORT.Write(new byte[] { (int)LCD_COMMAND_CHARS.FormFeed }, 0, 1);
}

public static void LCDOff()
{
LCD_PORT.Write(new byte[] { (int)LCD_COMMAND_CHARS.DisplayOff }, 0, 1);
}

public static void LCDOn()
{
LCD_PORT.Write(new byte[] { (int)LCD_COMMAND_CHARS.DisplayOn_NoCursor_NoBlink }, 0, 1);
}

public static void LCDCR()
{
LCD_PORT.Write(new byte[] { (int)LCD_COMMAND_CHARS.CR }, 0, 1);
}

//Short, high-pitched sound to ack as notification that an action was detected (like a button press)
public static void Acknowledge()
{
Play(new NoteClass(7, NoteClass.A, NoteClass.ThirtySecond));
}

//Sound a traditional computer beep
public static void Beep()
{
Play(new NoteClass(5, NoteClass.A, NoteClass.Quarter));
}

public static void Play(NoteClass note)
{
byte[] sequence = new byte[3];
sequence[0] = (byte)note.ScaleChar;
sequence[1] = (byte)note.LengthChar;
sequence[2] = (byte)note.NoteChar;
LCD_PORT.Write(sequence, 0, 3);
}
public static void Play(NoteClass[] notes)
{
int currentScale = 0;
int currentLength = 0;
int count = 0;
if (notes != null && notes.Length > 0)
{
byte[] sequence = new byte[notes.Length * 3];
foreach (NoteClass note in notes)
{
if (note.ScaleChar != currentScale)
{
currentScale = note.ScaleChar;
sequence[count++] = (byte)currentScale;
}
if (note.LengthChar != currentLength)
{
currentLength = note.LengthChar;
sequence[count++] = (byte)currentLength;
}
sequence[count++] = (byte)note.NoteChar;
}
LCD_PORT.Write(sequence, 0, count);
}
}

public static byte[] CharsToBytes(char[] Input)
{
byte[] ReturnValue = new byte[Input.Length];

for (int Counter = 0; Counter < Input.Length; ++Counter)
{
ReturnValue[Counter] = (byte)Input[Counter];
}
return ReturnValue;
}

}
public class NoteClass
{
//Helper constants
public const int A = 0;
public const int ASharp = 1;
public const int B = 2;
public const int C = 3;
public const int CSharp = 4;
public const int D = 5;
public const int DSharp = 6;
public const int E = 7;
public const int F = 8;
public const int FSharp = 9;
public const int G = 10;
public const int GSharp = 11;
public const int Rest = 12;

public const int SixtyQuarter = (int)LCD_COMMAND_CHARS.NoteLength_1_64;
public const int ThirtySecond = (int)LCD_COMMAND_CHARS.NoteLength_1_32;
public const int Sixteenth = (int)LCD_COMMAND_CHARS.NoteLength_1_16;
public const int Eighth = (int)LCD_COMMAND_CHARS.NoteLength_1_8;
public const int Quarter = (int)LCD_COMMAND_CHARS.NoteLength_1_4;
public const int Half = (int)LCD_COMMAND_CHARS.NoteLength_1_2;
public const int Whole = (int)LCD_COMMAND_CHARS.NoteLength_Whole;

private int _scale = 5;
private int _note = A;
private int _length = Quarter;

public int Scale
{
get
{
return _scale;
}
set
{
if (value >= 3 && value <= 7)
{
_scale = value;
}
}
}
public int ScaleChar
{
get
{
return ((int)LCD_COMMAND_CHARS.NoteScale_3 – 3) + _scale;
}
}
public int Note
{
get
{
return _note;
}
set
{
if (value >= A && value <= Rest)
{
_note = value;
}
}
}
public int NoteChar
{
get
{
return (int)LCD_COMMAND_CHARS.Note_A + _note;
}
}
public int Length
{
get
{
return _length;
}
set
{
if (value >= SixtyQuarter && value <= Whole)
{
_length = value;
}
}
}
public int LengthChar
{
get
{
return _length;
}
}

public NoteClass(int scale, int note, int length)
{
Scale = scale;
Note = note;
Length = length;
}
}

Una clase para controlar los pulsadores

public static class Utility
{
public static string PadLeft(string val, int maxlen, string padchar)
{
string newval = val;
while (newval.Length < maxlen)
{
newval = padchar + newval;
}
return newval;
}
public static string PadRight(string val, int maxlen, string padchar)
{
string newval = val;
while (newval.Length < maxlen)
{
newval += padchar;
}
return newval;
}
}

Y por último la clase principal:

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using Microsoft.SPOT;
using Microsoft.SPOT.Hardware;
using SecretLabs.NETMF.Hardware;
using SecretLabs.NETMF.Hardware.NetduinoPlus;

namespace DoorManager
{
public enum LightModes { Auto, ManualOn, ManualOff }

public class Program
{
#region User Settings & Constants
public static Cpu.Pin DoorSensorPin = Pins.GPIO_PIN_D11; //Magnetic switch to monitor door open/close state
public static Cpu.Pin LEDPin = Pins.GPIO_PIN_D13; //Status indicator (blinks if error or override on)
public static Cpu.Pin LightPin = Pins.GPIO_PIN_D12; //Connection to high voltage relay to control room light
public static Cpu.Pin Button1Pin = Pins.GPIO_PIN_D7; //Manually turns light on/off
public static Cpu.Pin Button2Pin = Pins.GPIO_PIN_D6; //Returns light control to automatic
public static Cpu.Pin Button3Pin = Pins.GPIO_PIN_D5; //Display error messages
public static Cpu.Pin Button4Pin = Pins.GPIO_PIN_D4; //Toggles door sensor (when off, no alerts are created)
public const int InitialDoorOpenAlertDelay = 30; //in minutes
public const int OngoingDoorOpenSoundAlertDelay = 1; //in minutes
public const int OngoingDoorOpenMessageAlertDelay = 30; //in minutes
public const int LCDOffDelay = 10; //in seconds
public const string AlertWebService = “http://192.168.1.2/WS/SendAlert.aspx?a=Door+Manager&e=Door+Opened&#8221;;
#endregion

#region Fields
public static string LastError = “”;
public static InterruptPort DoorSensor;
public static OutputPort LED;
public static OutputPort Light;
public static InterruptPort Button1;
public static InterruptPort Button2;
public static InterruptPort Button3;
public static InterruptPort Button4;
private static bool IsDoorSensorProcessing = false;
private static bool IsDoorSensorIgnored = false;
public static bool IsDoorOpen = false;
private static bool _LightState = false;
public static bool initializing = true;
public static bool IgnoreButtons = true;
public static bool IgnoreAlerts = false;
public static bool AlertScheduled = false;
public static Timer DoorTimer = new Timer(new TimerCallback(DoorTimerHandler), null, Timeout.Infinite, Timeout.Infinite);
public static Timer LCDTimer = new Timer(new TimerCallback(LCDTimerHandler), null, Timeout.Infinite, Timeout.Infinite);
public static Timer LEDTimer = new Timer(new TimerCallback(LEDTimerHandler), null, Timeout.Infinite, Timeout.Infinite);
public static Timer ButtonTimer = new Timer(new TimerCallback(ButtonTimerHandler), null, Timeout.Infinite, Timeout.Infinite);
public static Timer SendAlertTimer = new Timer(new TimerCallback(SendAlertTimerHandler), null, Timeout.Infinite, Timeout.Infinite);
public static Timer DoorCloseTimer = new Timer(new TimerCallback(DoorCloseTimerHandler), null, Timeout.Infinite, Timeout.Infinite);
public static int CurrentMessageAlertDelayTimeout = 0;
public static int CurrentSoundAlertDelayTimeout = 0;
public static int CurrentAlertDelayTime = 0;
public static int CurrentLCDDelayTime = 0;
public static LightModes LightMode = LightModes.Auto;
private static int _LEDBlinkCount = 0;
public static bool _LEDBlink = false;

static NoteClass[] initTune = {
new NoteClass(5,NoteClass.C, NoteClass.Sixteenth),
new NoteClass(5,NoteClass.D, NoteClass.Sixteenth),
new NoteClass(5,NoteClass.E, NoteClass.Sixteenth),
new NoteClass(5,NoteClass.F, NoteClass.Sixteenth),
new NoteClass(5,NoteClass.G, NoteClass.Sixteenth),
new NoteClass(6,NoteClass.A, NoteClass.Sixteenth),
new NoteClass(6,NoteClass.B, NoteClass.Sixteenth),
new NoteClass(6,NoteClass.C, NoteClass.Sixteenth)
};
#endregion

#region Properties
public static bool LEDBlink
{
set
{
if (value)
_LEDBlinkCount++;
else
_LEDBlinkCount–;
if (_LEDBlinkCount > 0 && !_LEDBlink)
{
_LEDBlink = true;
LEDTimer.Change(250, Timeout.Infinite); //start timer
}
else if (_LEDBlinkCount == 0 && _LEDBlink)
{
LEDTimer.Change(Timeout.Infinite, Timeout.Infinite); //cancel timer
_LEDBlink = false;
LED.Write(false);
}
}
}
#endregion

#region Program Start
public static void Main()
{
Initialize();
ShowDoorSensorState();

Thread.Sleep(Timeout.Infinite); //keep running forever
}
#endregion

#region Methods
static void IgnoreButton()
{
IgnoreButtons = true;
ButtonTimer.Change(500, Timeout.Infinite); //restart timer
}

public static bool SetLightState()
{
bool expectedState = IsDoorOpen;
switch (LightMode)
{
case LightModes.ManualOn:
expectedState = true;
break;
case LightModes.ManualOff:
expectedState = false;
break;
}
if (expectedState != _LightState)
{
_LightState = expectedState;
Light.Write(expectedState);
}
return _LightState;
}

public static void SetIgnoreDoorSensor(bool ignore)
{
if (ignore != IsDoorSensorIgnored)
{
IsDoorSensorIgnored = ignore;
if (ignore)
{
LEDBlink = true;
//stop door sensor
DoorTimer.Change(Timeout.Infinite, Timeout.Infinite);
ParallaxLCD.LCD = true;
ParallaxLCD.Print(“Door Sensor\rDisabled”);
SetLCDOffTimer();
}
else
{
LEDBlink = false;
ParallaxLCD.LCD = true;
ParallaxLCD.Print(“Door Sensor\rEnabled”);
Thread.Sleep(2000);
//Check door
ShowDoorSensorState();
}
}
}

static void ShowDoorSensorState()
{
if (IsDoorSensorIgnored)
return;
ParallaxLCD.LCD = true; //ensure LCD is on
ParallaxLCD.Print(“Door ” + (IsDoorOpen ? “Open” : “Closed”));
if (IsDoorOpen)
{
//start door timer
CurrentSoundAlertDelayTimeout = InitialDoorOpenAlertDelay * 60 * 1000; //convert minutes to milliseconds
CurrentAlertDelayTime = 0;
DoorTimer.Change(0, Timeout.Infinite);
}
else
{
//clear door timer
DoorTimer.Change(Timeout.Infinite, Timeout.Infinite);
//set LCD timer
SetLCDOffTimer();
}
SetLightState();
}

static void SetLCDOffTimer()
{
CurrentLCDDelayTime = LCDOffDelay * 1000;
LCDTimer.Change(1000, Timeout.Infinite);
}

static void Initialize()
{
ParallaxLCD.StartSerial();
ParallaxLCD.LCD = true;
ParallaxLCD.ClearLCD();
Thread.Sleep(1000);
ParallaxLCD.Print(“Initializing…”);
ParallaxLCD.Beep();
Thread.Sleep(1000);

//set LED
LED = new OutputPort(LEDPin, false);
LEDBlink = true;

//setup door sensor
DoorSensor = new InterruptPort(DoorSensorPin, true, Port.ResistorMode.PullUp, Port.InterruptMode.InterruptEdgeBoth);
DoorSensor.OnInterrupt += new NativeEventHandler(DoorSensor_OnInterrupt);
IsDoorOpen = DoorSensor.Read();

//setup light control
Light = new OutputPort(LightPin, false);
Light.Write(_LightState);

//setup buttons
Button1 = new InterruptPort(Button1Pin, true, Port.ResistorMode.PullUp, Port.InterruptMode.InterruptEdgeLow);
Button1.OnInterrupt += new NativeEventHandler(Button1_OnInterrupt);
Button2 = new InterruptPort(Button2Pin, true, Port.ResistorMode.PullUp, Port.InterruptMode.InterruptEdgeLow);
Button2.OnInterrupt += new NativeEventHandler(Button2_OnInterrupt);
Button3 = new InterruptPort(Button3Pin, true, Port.ResistorMode.PullUp, Port.InterruptMode.InterruptEdgeLow);
Button3.OnInterrupt += new NativeEventHandler(Button3_OnInterrupt);
Button4 = new InterruptPort(Button4Pin, true, Port.ResistorMode.PullUp, Port.InterruptMode.InterruptEdgeLow);
Button4.OnInterrupt += new NativeEventHandler(Button4_OnInterrupt);

//setup network
Network.InitNetwork();

Thread.Sleep(5000);

ParallaxLCD.Print(“Ready”);
ParallaxLCD.Play(initTune);

Thread.Sleep(2000);

LEDBlink = false;

initializing = false;
IgnoreButtons = false;
}
#endregion

#region Timer Handlers
static void DoorCloseTimerHandler(object sender)
{
//this timer turns off sending alerts for a period of time after the door has been closed; this is another “bounce” preventative measure
DoorCloseTimer.Change(Timeout.Infinite, Timeout.Infinite); //cancel timer
IgnoreAlerts = false;
}

static void SendAlertTimerHandler(object sender)
{
//performing this in a timer ensures switch “bounce” doesn’t send multiple alerts
SendAlertTimer.Change(Timeout.Infinite, Timeout.Infinite); //cancel timer
Network.SendAlert();
AlertScheduled = false;
}

static void ButtonTimerHandler(object sender)
{
//this routine is to delay reaction to button presses to eliminate “bounce” and false presses
ButtonTimer.Change(Timeout.Infinite, Timeout.Infinite); //cancel timer
IgnoreButtons = false;
}

static void LEDTimerHandler(object sender)
{
if (_LEDBlink)
{
LED.Write(!LED.Read());
LEDTimer.Change(250, Timeout.Infinite); //restart timer
}
else
{
LED.Write(false);
}
}

static void LCDTimerHandler(object sender)
{
if (!IsDoorOpen || IsDoorSensorIgnored)
{
CurrentLCDDelayTime -= 1000;
if (CurrentLCDDelayTime <= 0)
{
CurrentLCDDelayTime = 0;
ParallaxLCD.LCD = false; //turn off LCD
//clear LCD timer
LCDTimer.Change(Timeout.Infinite, Timeout.Infinite);
}
else
{
LCDTimer.Change(1000, Timeout.Infinite);
}
}
else
{
//clear LCD timer
LCDTimer.Change(Timeout.Infinite, Timeout.Infinite);
}
}

static void DoorTimerHandler(object sender)
{
if (IsDoorOpen && !IsDoorSensorIgnored)
{
if (CurrentSoundAlertDelayTimeout > 0)
{
CurrentSoundAlertDelayTimeout -= CurrentAlertDelayTime;
}
if (CurrentMessageAlertDelayTimeout > 0)
{
CurrentMessageAlertDelayTimeout -= CurrentAlertDelayTime;
}
if (CurrentMessageAlertDelayTimeout <= 0)
{
//alert
SendAlertTimer.Change(5000, Timeout.Infinite); //send alert after 5 seconds
//restart delay
CurrentMessageAlertDelayTimeout = OngoingDoorOpenMessageAlertDelay * 60 * 1000; //convert minutes to milliseconds
}
if (CurrentSoundAlertDelayTimeout > 0)
{
int mins = CurrentSoundAlertDelayTimeout / 60000;
int secs = (CurrentSoundAlertDelayTimeout – (mins * 60000)) / 1000;
ParallaxLCD.Print(“Door Open\rAlert in ” + (mins > 1 ? mins.ToString() + ” min” : secs.ToString() + ” sec”));
if (mins > 1)
{
CurrentAlertDelayTime = 60000;
}
else
{
CurrentAlertDelayTime = 1000;
}
}
else
{
//alert
ParallaxLCD.Play(new NoteClass(7, NoteClass.A, NoteClass.Half));
//restart delay
CurrentSoundAlertDelayTimeout = OngoingDoorOpenSoundAlertDelay * 60 * 1000; //convert minutes to milliseconds
CurrentAlertDelayTime = 0;
}
DoorTimer.Change(CurrentAlertDelayTime, Timeout.Infinite);
}
}
#endregion

#region Event Handlers
static void DoorSensor_OnInterrupt(uint data1, uint data2, DateTime time)
{
if (initializing || IsDoorSensorProcessing)
return;
IsDoorSensorProcessing = true;
//magnetic switch wired to normally open / onboard switch normally high
//therefore when the door is closed (magnetic switch open) the onboard switch (normally high) is on
IsDoorOpen = (data2 == 1);
if (IsDoorOpen && !IgnoreAlerts)
{
AlertScheduled = true;
SendAlertTimer.Change(5000, Timeout.Infinite); //send alert after 5 seconds
}
else if (!IsDoorOpen && !AlertScheduled)
{
IgnoreAlerts = true;
DoorCloseTimer.Change(5000, Timeout.Infinite); //prevent alerts for 5 seconds
}
ShowDoorSensorState();
IsDoorSensorProcessing = false;
}

/// <summary>
/// Button 1 turns the light on/off manually.
/// </summary>
static void Button1_OnInterrupt(uint data1, uint data2, DateTime time)
{
if (initializing)
return;
if (!IgnoreButtons)
{
IgnoreButtons = true;
ParallaxLCD.Acknowledge();
LightModes oldMode = LightMode;
if (_LightState)
LightMode = LightModes.ManualOff;
else
LightMode = LightModes.ManualOn;
SetLightState();
//if we’re moving off auto mode start the led blinking for awareness
if (oldMode == LightModes.Auto)
LEDBlink = true;
IgnoreButton();
}
}

/// <summary>
/// Button 2 sets the light back to automatic (door sensor controlled).
/// </summary>
static void Button2_OnInterrupt(uint data1, uint data2, DateTime time)
{
if (initializing)
return;
if (!IgnoreButtons)
{
IgnoreButtons = true;
if (LightMode != LightModes.Auto)
{
ParallaxLCD.Acknowledge();
LightMode = LightModes.Auto;
SetLightState();
LEDBlink = false;
}
IgnoreButton();
}
}

static void Button3_OnInterrupt(uint data1, uint data2, DateTime time)
{
if (initializing)
return;
if (!IgnoreButtons && (!IsDoorOpen || IsDoorSensorIgnored))
{
IgnoreButtons = true;
ParallaxLCD.Acknowledge();
if (LastError != null && LastError.Length > 0)
{
string msg = LastError;
//show error in byte size pieces
ParallaxLCD.LCD = true;
while (msg.Length > 0)
{
if (msg.Length > 32)
{
ParallaxLCD.Print(msg.Substring(0,32));
msg = msg.Substring(32);
}
else
{
ParallaxLCD.Print(msg);
msg = “”;
}
Thread.Sleep(5000);
}
ParallaxLCD.Acknowledge();
SetLCDOffTimer();
}
else
{
ParallaxLCD.LCD = true;
ParallaxLCD.Print(“No Errors”);
SetLCDOffTimer();
}
IgnoreButton();
}
}

/// <summary>
/// Button 4 disables/re-enables the door sensor.
/// </summary>
static void Button4_OnInterrupt(uint data1, uint data2, DateTime time)
{
if (initializing)
return;
if (!IgnoreButtons)
{
IgnoreButtons = true;
ParallaxLCD.Acknowledge();
SetIgnoreDoorSensor(!IsDoorSensorIgnored);
IgnoreButton();
}
}
#endregion
}
}

Lista de componentes :

  • 2 LED, 4 interruptores momentáneos, tornillos diverso, caja de proyecto
  • Opcional: Kit Protoshield para Ardiono – $ 9.90  http://www.seeedstud…uino-p-318.html
  • Este kit incluye una placa de circuito de prototipos, conectores, resistencias, los LED (no caja montable en proyecto), conmutadores (no caja montable proyecto) y otras piezas misceláneas que puede ayudar a un iniciado a empezar.

Fuente  aqui

Cómo conectar un display LCD a tu Raspberry-Pi


En este post Mark Wiliams  nos muestra con  todo detalle   cómo conectar y utilizar un display de   16 x 2 LCD en modo 4 bits sobre una Raspberry Pi usando la  librería WiringPi que permite programar de forma fácil dispositivos externos.

El LCD  usando es un display  OLED azul (LCD) de 16 × 2 de adafruit basado en el clásico HD44780 de Hitachi ,el cual es un standard “de facto ” en cuanto a displays lcd alfanumericos.

image005

Esta modelo de pantalla cuenta con ultra-alto contraste  ,mayor incluso que las clásicas pantallas LCD restroliluminadas, por lo que la legibilidad es excelente desde cualquier ángulo.

El LCD ,como  adelantaba utiliza el controlador HD44780 el cual  está presente en casi todas las pantallas LCD.Como es habitual en este tipo de displays que utilizan este controlador por lo general tienen 14 ó 16 pines. En etse caso elLCD tiene 16, numerados del 0 al 16, como se muestra a continuación.
OLED.front 823back_LRG

A veces, todos estos pines están presentes, pero alguno  no se utiliza,por ejemplo, los pines 15 y 16 son para back-light que en este modelo no se utilizan

PINES DEL HD44780  EN DETALLE
Pin 1 Ground.
Pin 2 Tensión de alimentación de OLED y la lógica
Pin 3 Por lo general está conectado a un potenciómetro para controlar el contraste de la pantalla.
Pin 4 La señal de selección de registro (RS) determina si los valores de los bits de datos se interpretan como una orden (la pantalla del claro ejemplo) o los datos (aka: un personaje para mostrar).
Pin 5 ¿La lectura / escritura pin. En el modo de lectura, este pin se utiliza para obtener información de la pantalla LCD para averiguar si la pantalla LCD se puede aceptar comandos o para indicar que está demasiado ocupado.
No necesitamos esta función podemos esperar el tiempo máximo de una orden que debe ser por escrito (200us) antes de enviar el siguiente comando.
Si la lectura está activada y Pin4 en la pantalla LCD está conectado a un pin en el Raspberry Pi, hay una posibilidad de que pueda destruir su Pi. Sólo quiero volver a escribir en el LCD, nunca queremos leer de él. Así que esto siempre debe estar conectado a tierra.
Pin 6 La patilla de habilitación (E) funciona como el comando / data enclavamiento de señales para la pantalla LCD. La pantalla LCD se enganchará en lo que está en los bits de datos y procesarlos en el flanco descendente de la señal E
Es decir, cuando este pin va de baja, la pantalla LCD se llevará a la entrada de los pines de datos en este momento.
Clavijas 7 y 14 Son los pines de datos. En el modo de pin 4, sólo se usan los pines 11 a 14.
Los contactos 15 y 16 Se utilizan para la luz de fondo si está presente.

Cableado del LCD   a tu Raspberry

A continuación se muestra cómo conectar el LCD a la Raspberry Pi. Vamos a utilizar el modo de pin 4, así que no hay necesidad de conectar los pines 7 a 10. Este LCD no utiliza los pines de luz de fondo, pines 15 y 16 . Asimismo,en el ejemplo tampoco se utiliza el pin de contraste, pin 3.

OLED2

Código

En el pasado, usted habría tenido que conocer los registros utilizados por el controlador para configurar la pantalla, coloque el cursor o incluso escribir un carácter único.Hoy en día todo esto e ha simplifico muchísimo , que en el caso de la Raspberry gracias a la librería  WiringPi .

Instalación WiringPi;

@ raspberrypi pi ~ $ sudo apt-get update
@ raspberrypi pi ~ $ git clone git :/ / git.drogon.net / wiringPi
@ raspberrypi pi ~ $ cd wiringPi
@ raspberrypi pi ~ $ git pull origen
@ raspberrypi pi ~ $. / build

El código siguiente es un ejemplo muy simple de mostrar un poco de texto en la línea superior de la pantalla LCD. Hay una lista completa de todas las funciones de la biblioteca en el LCD WiringPi sitio web.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <wiringPi.h>           //WiringPi headers
#include <lcd.h>                //LCD headers from WiringPi
#include <stdio.h>              //Needed for the printf function below
//Pin numbers below are the WiringPi pin numbers
#define LCD_RS  3               //Register select pin
#define LCD_E   0               //Enable Pin
#define LCD_D4  6               //Data pin 4
#define LCD_D5  1               //Data pin 5
#define LCD_D6  5               //Data pin 6
#define LCD_D7  4               //Data pin 7
int main()
{
    int lcd;                //Handle for LCD
    wiringPiSetup();        //Initialise WiringPi
    //Initialise LCD(int rows, int cols, int bits, int rs, int enable, int d0, int d1, int d2, int d3, int d4, int d5, int d6, int d7)
    if (lcd = lcdInit (2, 16,4, LCD_RS, LCD_E ,LCD_D4 , LCD_D5, LCD_D6,LCD_D7,0,0,0,0)){
            printf ("lcdInit failed! \n");
            return -1 ;
    }
    lcdPosition(lcd,0,0);           //Position cursor on the first line in the first column
    lcdPuts(lcd, "Character LCD");  //Print the text on the LCD at the current cursor postion
    getchar();                      //Wait for key press
    lcdClear(lcd);                  //Clear the display
}
Lineas 1 y 2 se requieren ya que estos son los encabezados de la biblioteca LCD WiringPi.
Líneas 7 y 12 son las definiciones de los pines utilizados para conectar el LCD a la Raspberry Pi. Los números de pin se puede encontrar aquí.
Línea 21 sirve para  inicializar el LCD con LCDINIT ()
Los argumentos usados en la funcion lcdint() son:;
(int rows, int cols, int bits, int rs, int enable, int d0, int d1, int d2, int d3, int d4, int d5, int d6, int d7)
rows = Numero de filas del  LCD
cols = Numero de columnas del  LCD
bits = Numeros de bits usados como datos (   8 o 4).
rs = Pin de seleccion
enable =  pin activacion
d0-d7 = modo 8 o 4 bit modo. In modor 4 bit,solamente  usar  pins desde d0 a d3( como en todosl los displays HD44780). Si se utiliza el modo de 8 bits, es necesario especificar los pins del d0 a d7. En el código de ejemplo anterior, estamos utilizando el modo de 4 bits.El código siguiente es lo que se utiliza en el vídeo en la parte inferior de este post

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <wiringPi.h>
#include <lcd.h>
#include <string.h>
#include <time.h>
char level0[8] = { 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b11111};
char level1[8] = { 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b11111, 0b11111};
char level2[8] = { 0b00000, 0b00000, 0b00000, 0b00000, 0b00000, 0b11111, 0b11111, 0b11111};
char level3[8] = { 0b00000, 0b00000, 0b00000, 0b00000, 0b11111, 0b11111, 0b11111, 0b11111};
char level4[8] = { 0b00000, 0b00000, 0b00000, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
char level5[8] = { 0b00000, 0b00000, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
char level6[8] = { 0b00000, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
char level7[8] = { 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111, 0b11111};
#define COLUMNS 16
#define LCD_RS  3
#define LCD_E   0
#define LCD_D4  6
#define LCD_D5  1
#define LCD_D6  5
#define LCD_D7  4
void uptime(void);
void memory(void);
void volume(void);
void scrollText(void);
void INThandler(int sig);
int mymillis(void);
char message[] = "WWW.MARKS-SPACE.COM";
int count =0;
int j = 0;
FILE *uptime_file, *mem_file;
char *temp;
int lcd;
int main()
{
        signal(SIGINT, INThandler);
        wiringPiSetup () ;
        if (lcd = lcdInit (2, 16,4, LCD_RS, LCD_E ,LCD_D4 , LCD_D5, LCD_D6,LCD_D7,0,0,0,0)){
                printf ("lcdInit failed! \n");
                 return -1 ;
        }
        int uptimeTimer;
        while(1){
                lcdClear (lcd);
                volume();
                sleep(1);
                memory();
                sleep(4);
                lcdClear (lcd);
                uptimeTimer  = mymillis();
                while ((mymillis() - uptimeTimer) < 5000)
                        uptime();
                sleep(1);
                lcdClear (lcd);
                scrollText();
        }
}
void uptime(void)
{
  unsigned int uptime_unsorted = 0;
  unsigned char c;
  unsigned int DD;
  unsigned int HH;
  unsigned int MM;
  unsigned int SS;
  uptime_file=fopen("/proc/uptime","r");
  if(NULL != uptime_file)
  {
    while((c=fgetc(uptime_file))!= '.')
      {
        unsigned int i;
        i = atoi(&c);
        uptime_unsorted = (uptime_unsorted * 10) + i;
      }
    SS = uptime_unsorted % 60;
    MM = uptime_unsorted / 60 % 60;
    HH = uptime_unsorted / 60 / 60 % 24;
    DD = uptime_unsorted / 60 / 60 / 24;
    printf("\x1B[2J");
    printf("Uptime:D%i,%02i:%02i:%02i\n",DD,HH,MM,SS);
    lcdPosition(lcd,0,0);
    lcdPrintf(lcd,"Uptime:  Days %i", DD);
    lcdPosition(lcd,4,1);
    lcdPrintf(lcd,"%02i:%02i:%02i",HH,MM,SS);
  }
  else
  {
    printf("Open file \"proc/uptime\" failed!\n");
  }
void memory(void)
{
   char MemTotal[35];
    char MemFree[35];
    char total[35];
    char free[35];
        lcdClear (lcd);
    mem_file=fopen("/proc/meminfo","r");
    if(NULL != mem_file)
    {
    fscanf(mem_file,"%*s%s%*s", MemTotal);
    fscanf(mem_file,"%*s%s%*s", MemFree);
    printf("\x1B[2J");
    lcdPosition(lcd,0,0);
    lcdPrintf(lcd,"MemTotal-%sk",MemTotal);
    lcdPosition(lcd,0,1);
    lcdPrintf(lcd,"MemFree -%sk",MemFree);
    fclose(mem_file);
  }
  else
  {
    printf("Open file \"/proc/meminfo\" failed!\n");
  }
}
void volume(void)
{
         //Defined custom characters for volume display
        lcdCharDef  (lcd, 0, level0);
        lcdCharDef  (lcd, 1, level1);
        lcdCharDef  (lcd, 2, level2);
        lcdCharDef  (lcd, 3, level3);
        lcdCharDef  (lcd, 4, level4);
        lcdCharDef  (lcd, 5, level5);
        lcdCharDef  (lcd, 6, level6);
        lcdCharDef  (lcd, 7, level7);
        lcdClear (lcd);
        int i;
        lcdPosition (lcd, 9,1);
        lcdPuts (lcd, ":Volume");
        for (i = 0; i < 7; i++){
                lcdPosition (lcd, i, 1);
                lcdPutchar  (lcd, i);
                usleep(400000);
        }
}
void  scrollText(void)
{
        int i,n;
        int h ;
        int tempSpace = 0;
        char scrollPadding[] = "                   ";
        int messageLength = strlen (scrollPadding)+strlen(message);
        for (n=0;n<messageLength;n++){
                h = COLUMNS;
                usleep(300000);
                printf("\x1B[2J");
                if ( j > messageLength )
                        j = 0;
                for (i = 0  ; i  < j ; i ++){
                        scrollPadding[h-j] = message[i];
                        h++;
                }
                lcdPosition(lcd,0,0);
                lcdClear (lcd);
                lcdPrintf(lcd,"%s",scrollPadding);
                j++;
        }
}
void  INThandler(int sig)
{
        lcdClear (lcd);
        fclose(uptime_file);
        signal(sig, SIG_IGN);
        exit(0);
}
int mymillis(void)
{
        struct timeval tv;
        gettimeofday(&tv, NULL);
        return (tv.tv_sec) * 1000 + (tv.tv_usec)/1000;
}

Y por último en este vídeo podemos  ver el excelente rendimiento que ofrece este display con nuestro Raspberry Pi

Fuente  aquí

Modos de retroiluminar una pantalla LCD


Fluorescentes de cátodo frío (CCF) los tubos, las fuentes de luz que se utiliza para la iluminación de fondo la última pantalla de cristal líquido (LCD) de los módulos, requieren una cuidadosa ingeniería para proporcionar el rendimiento y la vida de servicio a los usuarios esperan. Los requisitos de energía del LCD sí mismos que se utilizan para televisores de pantalla plana, computadoras, equipos médicos, instrumentos de las aeronaves, e incluso las bombas de gas son relativamente sencilla, ya que el uso estándar de tensiones de alimentación DC, como 5 o 12V. Sin embargo, el LCD son transmisivo y requieren una instalación de fuente de luz transmitida desde la parte trasera de la pantalla para leerlos.

La mayoría de los LCD fluorescentes de cátodo frío (CCF) los tubos de retroiluminación de la pantalla. Estos tubos no se diferencia de los tubos fluorescentes para la iluminación de edificios de oficinas, sólo de menor tamaño. Estas luces de borde estrecho de tubos de diámetro son muy brillantes y se puede configurar como individuales, dobles, o en forma de L

DISEÑO DEL CONVERTIDOR DC-AC

El tubo del marco de cooperación en última instancia determina la legibilidad de la pantalla. Productos a la potencia del inversor en el tubo es esencial para el éxito del diseño, como la incompatibilidad de reducir la vida e incluso causar una falla catastrófica “La fiabilidad es realmente todo depende de cuánto tiempo y qué tan bien que el tubo dura”, dice John Peterson, el presidente , Endicott Research Group, un fabricante de convertidores DC-AC para alimentar retroiluminada pantallas planas.

La puesta en marcha o tensión alterna aplicada necesaria para encender el gas en el tubo es una especificación chocante. Un tubo fluorescente puede requerir 1.500 V ac para comenzar y luego 700V AC para operar. Si el voltaje mínimo de partida no está previsto, el tubo no se iniciará. El convertidor DC-AC es una fuente de corriente constante para una tensión superior que no puede ocurrir. Con la mayoría de los diseños electrónicos de hoy, los ingenieros trabajan con bajos voltajes. De envases, fuga y distancias de separación entre las consideraciones de diseño.

La tensión mínima de partida puede cambiar en diversas circunstancias con el inicio de la temperatura es uno de los factores más críticos. “Antiguo y frío” son términos críticos, de acuerdo con Byron Cole, regionales ERG gerente de ventas que ha trabajado en muchas aplicaciones de los clientes. Cuando la lámpara es nueva, puede tardar mucho menos voltaje para empezar, pero con la edad, los requisitos de tensión puede aumentar la producción de un escenario del peor caso.

El inversor debe tener un voltaje suficiente para controlar la caída de tensión que pudieran producirse entre el inversor y el tubo. Esto no es trivial, ya que la frecuencia de funcionamiento de las lámparas es de 40 a 50 kHz, y la capacitancia parásita en estas frecuencias pueden reducir significativamente la tensión del inversor.

La impedancia de un 2,5 W típico, 6-tubo del marco de cooperación pulgadas es de 50.000 a 70.000 V. Tanto voltímetros y osciloscopios puede cargar la salida si se utiliza sin tener en cuenta su efecto en la medición. Esto significa que un análisis detallado se deben realizar para evitar las caídas de tensión inesperada. Margen suficiente se tiene en cuenta el diseño del inversor en circunstancias normales, pero también requiere la consideración por el usuario para evitar casos extremos. En muchos casos, un poco de ayuda de los expertos de suministro de alta tensión es necesaria para validar el diseño de las tablas de la aplicación.

Los ingenieros de ERG tratar cualquier problema en la fase de diseño como una cuestión de aplicación. Identifican capacitancia parásita como causa de los fracasos principios de los 90 por ciento del tiempo. La capacidad puede ser de metal fuera de lugar, cables demasiado largos, y, en general, los problemas de alta tensión que no son problemas para los diseños de bajo voltaje.

LA EFICIENCIA ES LA CLAVE DE DISEÑO

La eficiencia es otra cuestión que requiere la corriente de salida a coincidan exactamente con las especificaciones de la pantalla. Forzando la pantalla puede producir muy buena imagen en el corto plazo, pero la vida en general se ve comprometida. En algunos casos esto responde a los objetivos de diseño general, pero en la mayoría de los casos reducidos de funcionamiento la vida no es aceptable.

Por ejemplo, un Sharp especificación de pantalla de 10,4 pulgadas proporciona una vida útil de 50.000 horas con 6 mA pero este se reduce a sólo 30.000 horas si la corriente es de 7 mA a sólo 1 mA superior. Para complicar el problema, las medidas actuales y las frecuencias son muy difíciles ya que la mayoría de los clientes no tienen equipo para medir 5 mArms a 40 kHz. Uso de sondas de corriente especialmente diseñado y convertidores DA, ERG valida que un inversor particular, es un buen partido para un tubo del marco de cooperación específicos

Su prueba se utiliza un tercer contacto de sonda de corriente donde el cableado se ejecuta a través de un transformador en la primaria. El transformador genera un pequeño voltaje que es leído por un osciloscopio, la señal es cortado en 512 piezas, una conversión DA se lleva a cabo, y el valor rms se calcula. Esto permite que las mediciones actuales, sin contacto con el dispositivo ya que el contacto se agrega la capacitancia parásita y distorsionar la lectura. El circuito del inversor está diseñado para producir 5 mA por lo que la medición valida que este funciona correctamente en la aplicación.

Otro factor de diseño importante es la observación de que la distorsión de la forma de onda para minimizar la interferencia electromagnética (EMI). El DC-AC inversor produce una onda sinusoidal pura, pero la distorsión se produce debido a la dinámica en el tubo del marco de cooperación. La medición de la corriente también se identifica si la distorsión inaceptable está presente. El análisis de las piezas de la forma de onda ha mejorado el rendimiento de la PC ha mejorado. Hoy ERG pueden comparar punto por punto a una onda senoidal perfecta en la frecuencia adecuada y generar un factor de distorsión para que los clientes saben de antemano que el inversor correspondiente a los requisitos del tubo del marco de cooperación en su presentación. 

OTROS  MODOS DE RETROILUMINACION

Además de la iluminación de fondo CCFL usando convertidores DC-AC, existen otras opciones populares para la retroiluminación LCD:

Retroiluminación LED es la luz de fondo más popular para los LCD pequeños y medianos. Retroiluminación LED proporciona bajo costo, larga vida, la inmunidad a las vibraciones y de bajo voltaje de funcionamiento de cd, y el control de la intensidad precisa.

Un controlador de LED de circuito integrado (IC) normalmente controla el poder de los LEDs ya sea en modo de voltaje constante o corriente constante. El simple control de corriente constante se utiliza una combinación serie de LEDs, pero el aumento de la unidad de tensión desde la caída de tensión de un LED es generalmente de 3,5 a 4V. Con la tensión de alimentación de una sola célula de Li-ion 4.2V ser, el controlador IC debe tener un convertidor DC-DC para aumentar la tensión.

Más reciente VA han incorporado a cargo de la bomba para impulsar los LEDs en las distintas formaciones y la aplicación de varias características, como una interna digital a analógica para la compatibilidad de microcontroladores y de control de brillo digital.

EL (electroluminiscente) paneles de uso de colores fosforescentes, a fin de generar luz. El consumo de energía del panel EL es bastante baja, normalmente consumen menos energía que los LED, pero requiere una tensión de 100 V ca @ 400 Hz, así que un convertidor DC-AC es necesario. Con una tensión de salida mucho más baja y la frecuencia de los tubos de CCFL, los problemas de aplicación se reducen considerablemente, pero su vida se limita normalmente a 5.000 horas o menos.

Transformadores de cerámica piezoeléctrica (PZTs), un nuevo enfoque para la alimentación de los tubos CCFL, en lugar de utilizar la tecnología piezoeléctrica magnético en un convertidor DC-AC. Transformadores de cerámica piezoeléctrica (PZTs) ofrecen ventajas potenciales para las aplicaciones de luz de fondo, incluyendo una mayor eficiencia, menor tamaño, menor ruido electromagnético, una mayor disposición de tensión de partida, y la operación sinusoidal. El material PZT es excitada por una etapa de potencia sonora y produce una tensión mayor a la unidad de la lámpara.

Cinco reglas para comprobar  un convertidor  DC-AC de un  CCFT


-La tension de arranque debe exceder de lanzar tensión de corte del tubo.
-Tensión de servicio deben cumplir con los requisitos generados por tubo.
-Tension de salida  debe coincidir con la especificación de la corriente del tubo.
-Frecuencia de operación deben ser compatibles con el tubo y los requisitos de LCD.
-Formas de onda debe tener la mínima distorsión de tubo

Display LCD de dos lineas para PC por puerto paralelo


By CRN
Poco a poco la idea de un ordenador de salón como centro lúdico de entretenimiento va haciéndose realidad día a día gracias, sobre todo a la gran flexibilidad y versatilidad que ofrece un ordenador frente a otros dispositivos electrónicos (dvd, lector de cd’s, vcr, etc.) en los que muy difícilmente podemos adaptarlos a soportar nuevos formatos, cometidos y funciones.

De hecho ya existen soluciones comerciales de ordenadores específicamente diseñados para entretenimiento: los barebones o ordenadores de salón, los cuales, aunque es cierto que cada vez alcanzan precios más competitivos respecto a los ordenadores convencionales, hoy por hoy su adquisición lleva implícito un desembolso económico mayor y un sinfín de problemas técnicos por su falta de flexibilidad (al ir integrado todo el hardware en una única placa soporte que apenas soporta modificaciones o ampliaciones en su estructura).

Nosotros intentaremos acercarnos a esta idea de Ordenador de Salón, pero proponiendo una solución más económica, flexible y mejorada frente a las soluciones actuales de barebones: con software y hardware especifico, en lugar de adquirir un nuevo ordenador especifico, intentaremos implementar en nuestro ordenador las funciones de un ordenador de salón.

Saber mas..>>