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

Anuncios

Tutorial Netduino Parte 3


 Netduino es una plataforma de desarrollo de código abierto integrado similar al Arduino, excepto que utiliza .NET Micro Framework para la programación.  La placa de desarrollo Netduino tiene el mismo factor que Arduino Uno, y por lo tanto la mayoría de los escudos de Arduino son también compatibles con Netduino.  Las placas de desarrollo Arduino se basan en 8 bits microcontroladores Atmel que corren a una velocidad máxima de reloj de 16 MHz en su versión primera. Por otra parte, el hardware Netduino usa potentes procesadores de 32 bits (en el caso de la primera versión un  Atmel SAM7x en Netduino, y STMicro STM32F4 en versiones Netduino Plus) y funciona a una velocidad mucho más rápida (48 MHz a 168 MHz).

El  siguiente tutorial  extraidos de http://embedded-lab.com/blog    tienen como objetivo proporcionar una amplia introducción a la plataforma Netduino  y asegurar que cualquier principiante, estudiante o aficionado, será rápidamente capaz de empezar a usarlo para sus propios proyectos y diseños embebidos. En todos los ejemplos se usa una placa  Netduino Plus ( es la versión mas antigua con NETMF 4,1) se utiliza para ilustrar la salida en estos experimentos.

Como continuación del curso básico de Netduino  donde se trataba la gestión  de un display  LCD     en esta   ocasión vamos   a tratar la  gestion de un display  de 7 segmentos de  led   con nuestro Netduino

 

Una salida visual siempre añade valor a cualquier proyecto.En esta  ocasión , vamos a mostrar un poco de información numérica, alfabética, así como dos personajes simbólicos en un módulo LED de siete segmentos de 4 dígitos. La forma en que están interrelacionadas de las siete segmentos LED se conoce como multiplexado, lo que permite ahorrar algunos pines de E / S de Netduino en comparación con la conducción de forma individual Los siete LED de segmento son los recursos y hambrientos de poder, sino que van a hacer este experimento sólo para conseguir nuestros pies mojados en el microcontrolador o incrustado mundo y entender los conceptos básicos de un niño de siete segmentos de pantallas LED.

 

En el experimento de hoy, vamos a leer una tensión analógica de un sensor LDR y mostrar la salida del ADC en cuatro de siete LEDs de segmento. Como debe saber siete segmentos LED se hace con siete más un LEDs. Cada LED tiene su propio nombre, como podemos ver en la imagen.Para mostrar dígito “1”, tenemos que enviar la señal de alto para el LED “b” y “c” solamente y tierra el cátodo. Ahora, digamos que tenemos que mostrar “12” La forma en que hacemos es, se muestra “1” en una de unidad de LED y luego apagarlo y luego vamos a mostrar “2” en la segunda unidad de LED y luego apagarlo también, pero vamos a convertir en la primera. Por lo tanto, vamos a alternar la visualización de cada letra en un bucle que resulta en todo el dígito que nos gusta mostrar. Esto básicamente es la multiplexación.

Configuración de Circuito y Teoría

En este tutorial también, podemos dividir nuestras conexiones en dos categorías, analógico y digital. En la sección analógica, hemos utilizado una LDR como nuestro dispositivo de entrada analógica. Con la iluminación, la resistencia de la LDR cambiará causar el cambio en el voltaje.> Este tipo de conexión se denomina en algún momento como divisor de tensión.La caída o subida de tensión a través de la LDR serán un insumo para nuestro pin analógico.

En la sección digital, las conexiones son sencillas. Cada pin (a hasta g) de los siete segmentos LED están conectados a la E / S digital de la Netduino través de una resistencia y de nuestro código somos control que a su vez alta o baja. Los siete segmentos LED utilizado en este tutorial es un cátodo común y hay cuatro unidades de ellos combinados en uno cuya conexión interna se parece a esto.

Para encender el LED, tenemos que ajustar los pines de ánodo a cátodo alta y seleccionado a tierra. La pregunta es, ¿cómo podemos conectar a tierra el pin seleccionado cuando necesitamos? Si somos capaces de conectar un interruptor y luego alternar el interruptor cuando necesitan a tierra va a trabajar para nosotros. Para facilitar esto, podemos utilizar transistor como interruptor. Conexión transistor como interruptor es lo que ya hemos aprendido en primer tutorial . Como se muestra en el circuito, hemos conectado la base de cada transistor a cierta E / S digital de nuestra Netduino, emisor está conectado a tierra y el colector está conectado a ánodos de siete segmentos LED. Cuando la base del transistor está ajustado a alta, el interruptor de transistor se enciende entonces el ánodo correspondiente se conecta a tierra, que completa el circuito y convierte el LED ON.

Conexión con Netduino o Netduino Plus

C Programa # .NET

Esta vez nuestro código es poco intensiva como he creado pequeña biblioteca (Clase SevenSegments) que soporta un poco más que los dígitos que muestran. Veamos paso a paso. En el código de abajo, primero creamos una instancia de la clase AnalogInput lo que nos permite obtener el valor de nuestro dispositivo analógico que es LDR en este caso. Luego creamos una instancia independiente de la clase SevenSegments. El constructor de esta clase lleva varios pines como argumentos. Una vez que tenemos SevenSetments instancia simplemente llamar al método Show y pasar el valor que se lee desde el dispositivo analógico

 

public static void Main()
{
 
    AnalogInput aInPin = new AnalogInput(Pins.GPIO_PIN_A1);  //use any analog pin
    aInPin.SetRange(0, 1234); //give a range.
 
    Debug.Print("Analog value: " + aInPin.Read());
 
    // initialize the seven segments LED and pass appropriate pins
    SevenSegments sevenSegments = new SevenSegments(
        Pins.GPIO_PIN_D0, Pins.GPIO_PIN_D1, Pins.GPIO_PIN_D2,
        Pins.GPIO_PIN_D3, Pins.GPIO_PIN_D4, Pins.GPIO_PIN_D5, Pins.GPIO_PIN_D6,
        new Cpu.Pin[] { Pins.GPIO_PIN_D8, Pins.GPIO_PIN_D9, Pins.GPIO_PIN_D10, Pins.GPIO_PIN_D11 });
 
    // Display value read by analog device
    sevenSegments.FlickerDelay = 5; // Pause between each letter during repetition in a LED unit
    sevenSegments.UnitSevenSegmentLedDelay = 1; //Duration of a LED unit being ON
    sevenSegments.UnitRepetition = 50; // Repetition of entire strip
    while (true)
    {
        sevenSegments.Show(aInPin.Read());
        Debug.Print(aInPin.Read().ToString());
    }
}

 

 

 

El   proceso  pesados ​​principal se hace en la clase SevenSegment. Por lo tanto, vamos a echar un vistazo rápido a las diferentes secciones de esta clase.

Sección constructor de la clase SevenSegment

Aquí hemos definido algunas E / S digitales para los segmentos de LED a hasta g. Para soportar cualquier número de unidades LED, los pasadores de ánodo o cátodo común son recibidos como una matriz. Ahora, para mostrar una carta o un alfabeto, he construido una serie de Boole. Todas estas matrices se almacenan en una tabla hash con una clave que corresponde a un dígito o un alfabeto o un símbolo. Finalmente algunas propiedades se inicializan con algunos valores

 

public SevenSegments(Cpu.Pin a, Cpu.Pin b, Cpu.Pin c, Cpu.Pin d, Cpu.Pin e, Cpu.Pin f,
                                 Cpu.Pin g, Cpu.Pin[] commonAnodeCathodePin)
{
    // (wire color is for personal reference)
    OutputPort PinD0Out_a = new OutputPort(a, false); //11  Black 
    OutputPort PinD1Out_b = new OutputPort(b, false); //7   Brown
    OutputPort PinD2Out_c = new OutputPort(c, false); //4   Red
    OutputPort PinD3Out_d = new OutputPort(d, false); //2   orange
    OutputPort PinD4Out_e = new OutputPort(e, false); //1   Yellow
    OutputPort PinD5Out_f = new OutputPort(f, false); //10  Green
    OutputPort PinD6Out_g = new OutputPort(g, false); //5   Blue
 
    segmentPins = new OutputPort[] { PinD0Out_a, PinD1Out_b, PinD2Out_c, PinD3Out_d,
                                                PinD4Out_e, PinD5Out_f, PinD6Out_g };
 
    // initialize commonAnodeCathodePin
    ledSegmentUnit = new OutputPort[commonAnodeCathodePin.Length];
    for (int i = 0; i < commonAnodeCathodePin.Length; i++)
    {
        ledSegmentUnit[i] = new OutputPort(commonAnodeCathodePin[i], false);
    }
 
    // create a list of supported display
    ledSegmentTable = new Hashtable();
    ledSegmentTable.Add("0", new bool[] { true, true, true, true, true, true, false });
    ledSegmentTable.Add("1", new bool[] { false, true, true, false, false, false, false });
    ledSegmentTable.Add("2", new bool[] { true, true, false, true, true, false, true });
    ledSegmentTable.Add("3", new bool[] { true, true, true, true, false, false, true });
    ledSegmentTable.Add("4", new bool[] { false, true, true, false, false, true, true });
    ledSegmentTable.Add("5", new bool[] { true, false, true, true, false, true, true });
    ledSegmentTable.Add("6", new bool[] { true, false, true, true, true, true, true });
    ledSegmentTable.Add("7", new bool[] { true, true, true, false, false, false, false });
    ledSegmentTable.Add("8", new bool[] { true, true, true, true, true, true, true });
    ledSegmentTable.Add("9", new bool[] { true, true, true, true, false, true, true });
    ledSegmentTable.Add("a", new bool[] { true, true, true, false, true, true, true });
    ledSegmentTable.Add("b", new bool[] { false, false, true, true, true, true, true });
    ledSegmentTable.Add("c", new bool[] { true, false, false, true, true, true, false });
    ledSegmentTable.Add("d", new bool[] { false, true, true, true, true, false, true });
    ledSegmentTable.Add("e", new bool[] { true, false, false, true, true, true, true });
    ledSegmentTable.Add("f", new bool[] { true, false, false, false, true, true, true });
    ledSegmentTable.Add("g", new bool[] { true, true, true, true, false, true, true }); ;
    ledSegmentTable.Add("h", new bool[] { false, false, true, false, true, true, true });
    ledSegmentTable.Add("i", new bool[] { false, true, true, false, false, false, false });
    ledSegmentTable.Add("j", new bool[] { false, true, true, true, true, false, false });
    ledSegmentTable.Add("l", new bool[] { false, false, false, true, true, true, false });
    ledSegmentTable.Add("n", new bool[] { false, false, true, false, true, false, true });
    ledSegmentTable.Add("o", new bool[] { false, false, true, true, true, false, true });
    ledSegmentTable.Add("p", new bool[] { true, true, false, false, true, true, true });
    ledSegmentTable.Add("q", new bool[] { true, true, true, false, false, true, true });
    ledSegmentTable.Add("r", new bool[] { false, false, false, false, true, false, true });
    ledSegmentTable.Add("s", new bool[] { true, false, true, true, false, true, true });
    ledSegmentTable.Add("t", new bool[] { false, false, false, true, true, true, true });
    ledSegmentTable.Add("u", new bool[] { false, false, true, true, true, false, false });
    ledSegmentTable.Add("y", new bool[] { false, true, true, false, false, true, true });
    ledSegmentTable.Add("-", new bool[] { false, false, false, false, false, false, true });
    ledSegmentTable.Add("?", new bool[] { false, true, true, false, true, true, false });
    ledSegmentTable.Add("?", new bool[] { true, false, false, true, false, false, true });
 
    // Initialize fields to its default
    FlickerDelay = 5;
    SevenSegmentsUnits = commonAnodeCathodePin.Length;
    UnitSevenSegmentLedDelay = 0;
    UnitRepetition = 50;
    RightToLeft = true;
}

Para mostrar un dígito o alfabeto, hemos expuesto un método Show de la clase. Hay tres sobrecargas de este método Show. El primero toma int como argumento y llama directamente segundo método Mostrar que tiene cadena como argumento. En este método, dependiendo de si RightToLeft se establece en verdadero o falso, código salta a la sección correspondiente. Esta sección básicamente extrae la letra correcta para mostrar y luego llama el tercer método Mostrar

 

public void Show(string stringToShow)
{
 
    // this loop will make it appear that all the LED units remained ON.
    for (int j = 0; j < UnitRepetition; j++)
    {
 
        if (RightToLeft)
        {
            int ledUnit = SevenSegmentsUnits - 1; // 0 based index
 
            for (int i = stringToShow.Length; i > 0; i--)
            {
                string eachLetter = stringToShow.Substring(i - 1, 1);
                Show(eachLetter, ledUnit);
                ledUnit -= 1;
 
                // If length of  stringToShow is greater than SevenSegmentsUnits rest it
                if (ledUnit < 0) ledUnit = SevenSegmentsUnits - 1; // - 1 as it's 0 based index
 
                Thread.Sleep(UnitSevenSegmentLedDelay);
            }
        }
        else
        {
            int ledUnit = 0; // 0 based index
            for (int i = 0; i < stringToShow.Length; i++)
            {
                string eachLetter = stringToShow.Substring(i, 1);
                Show(eachLetter, ledUnit);
                ledUnit += 1;
 
                // If length of  stringToShow is greater than SevenSegmentsUnits rest it
                ledUnit = ledUnit % SevenSegmentsUnits;
 
                Thread.Sleep(UnitSevenSegmentLedDelay);
            }
        }
 
        Thread.Sleep(FlickerDelay);
    }
 
}

 

El tercer método Mostrar toma dos argumentos, primero es la cadena que se mostrará y segundo es dónde mostrar es decir, en el que el aparato la visualización LED. Desde la HashTable definido durante la construcción, se entera de la matriz correcta de Boole entonces pin correspondiente se establece en alta o baja en base a esta matriz booleana. En el paso final, todos los pasadores de ánodo o cátodo común se establecen en baja, entonces sólo la unidad LED apropiado se establece en alto

 

public void Show(string numberString, int ledUnit)
{
    bool[] ledSegmentOnOffValues;
    numberString = numberString.ToLower();
 
    // at this level, string of unit lenght is supported so drop the rest
    if (numberString.Length > 1) numberString =
             numberString.Substring(numberString.Length - 1, 1);
 
    // Send Low to the common anode/cathode of SevelSegmentLED
    for (int i = 0; i < ledSegmentUnit.Length; i++)
    {
        ledSegmentUnit[i].Write(false);
    }
 
    if (!ledSegmentTable.Contains(numberString))
    {
        // when non supported letter is passed display "-"
        ledSegmentOnOffValues = (bool[])ledSegmentTable["-"];
    }
    else
    {
        // get the true/false array
        ledSegmentOnOffValues = (bool[])ledSegmentTable[numberString];
    }
 
    for (int i = 0; i < segmentPins.Length; i++)
    {
        //make the corresponding pin high
        segmentPins[i].Write(ledSegmentOnOffValues[i]);
    }
 
    // Only send signal to the selected Anode/Cathode
    ledSegmentUnit[ledUnit].Write(true);
}

La expansión de SevenSegments Clase con un contador

Con muy pocas líneas de código podemos ampliar o añadir funcionalidades adicionales como un contador que cuenta del mínimo al valor máximo. Este contador es un ejemplo muy simple que toma dos argumentos, el valor mínimo y el valor máximo. Un bucle for se ha configurado a partir de este minuto a valor máximo y el método Show que se ha llamado de pasar el incremento de bucle de corriente. Este método nos permite mostrar el contador en nuestros siete segmentos unidad LED

 

public void Counter(int minValue, int maxValue)
{
    for (int i = minValue; i <= maxValue; i++)
    {
        Show(i);
        Debug.Print(i.ToString());
    }
}

Salida

Con nuestra clase SevenSegments, tenemos varias salidas. En primer lugar vamos a ver la salida de nuestro circuito. Aquí podemos ver el valor más bajo en nuestra pantalla cuando LDR está cubierto sin embargo el número aumenta a medida que iluminamos nuestro LDR.

 

Ahora echemos un vistazo a nuestro método de venta libre que hemos añadido a nuestra clase SevenSegments. Con el siguiente código, vamos a ver los números de contar en SevenSegments LED 980-1020

sevenSegments.FlickerDelay = 5; // Pause between each letter during repetition in a LED unit
sevenSegments.UnitSevenSegmentLedDelay = 1; //Duration of a LED unit being ON
sevenSegments.UnitRepetition = 5; // Repetition of entire strip
sevenSegments.RightToLeft = true;
while (true)
{
    sevenSegments.Counter(980, 1020);
}

 

Vamos a darle una cadena de más de nuestros Siete unidades LED del segmento son y ver qué pasa

 

sevenSegments.FlickerDelay = 10; // Pause between each letter during repetition in a LED unit
sevenSegments.UnitSevenSegmentLedDelay = 500; //Duration of a LED unit being ON
sevenSegments.UnitRepetition = 1; // Repetition of entire strip
sevenSegments.RightToLeft = false;
while (true)
{
    sevenSegments.Show("1234567890abcdefghijklmnopqrstuvwxyz");
    sevenSegments.Show("????");
    sevenSegments.Show("Embedded-Lab");
 
}

 

Ahora, vamos a ajustar algunas de sus propiedades y ver un efecto de laminación

 

sevenSegments.FlickerDelay = 5; // Pause between each letter during repetition in a LED unit
sevenSegments.UnitSevenSegmentLedDelay = 200; //Delay Duration of a LED unit being ON
sevenSegments.UnitRepetition = 50; // Repetition of entire strip
sevenSegments.RightToLeft = false;
while (true)
{
    sevenSegments.Show("-Lab");
}

 

 

Y para terminar , es el siguinte video podermos ver el código presentado ejecutandose con al electrónica descrita

Fuente   aqui

 

 

Control de pulsadores con Netduino


 

 

 

 

 

Una de las preguntas más comúnmente hechas para comenzar Netduino 2 usuarios es cómo utilizar un botón. Para los dos ejemplos incluidos aquí vamos a usar el botón de encendido y el lede  internos de la placa .

 

Hay dos formas básicas para utilizar los puertos de entrada digital en el Netduino 2. Podemos configurarlo como un puerto de entrada, donde tendremos que comprobar continuamente el valor del puerto a continuación, realizar una acción basada en este valor o podemos utilizarlo como un puerto de interrupción donde vamos a definir un controlador de evento que se basan en una cambio de valor.

 

Para nuestro primer ejemplo este sencillo programa se iluminará el LED a bordo cuando se presiona el botón del tablero de. Esto se hace comprobando constantemente el estado del puerto de entrada en el bucle while. Cuando se pulsa el botón, el valor es alto y cuando se suelta el valor es bajo. Este valor se pasa directamente al puerto LED.

 

Observe filtro falla del InputPort se fija por falso. El filtro de interferencia se usa para prevenir el rebote del interruptor, que no es un problema en este caso. También hemos establecido el modo Resistencia interno ya que el botón a bordo Netduino 2 tiene una resistencia pulldown.

 

El MCU tiene la capacidad de fijar para pull-up o en modo descolgante ya que tiene ambas capacidades incorporadas para el pasador. Desde que usamos una resistencia pulldown para tirar de la línea de baja y el botón se conecta a la línea de 3,3 V, el botón seguirá siendo baja presionado momento en el que pasará a ALTO luego de vuelta a BAJO cuando se suelta.

?

1 /// <summary>
2 /// Button Tutorial for the Netduino 2 and Netduino Plus 2
3 /// </summary>
4 public class Program
5 {
6     /// <summary>
7     /// Main method runs on startup
8     /// </summary>
9     public static void Main()
10     {
11         // Define a new Output Pin to the Onboard LED
12         // NOTE: Setting initial state of the pin to "false"
13         OutputPort onboardLED = new OutputPort(Pins.ONBOARD_LED, false);
14
15         // Define a new Input Pin to the Onboard Switch
16         // NOTE: Set glitch filter to "false".  This is only needed to
17         //       prevent switch bounce and in this case not needed.
18         // NOTE: The pullup on the MCU is disabled and the onboard switch
19         //       has a pulldown resistor so we set this to "Disabled".
20         // NOTE: The switch has a pulldown resistor and is connected to 3.3 (logic HIGH)
21         //       so the switch will show HIGH when pressed or LOW when released.
22         InputPort button = new InputPort(Pins.ONBOARD_SW1, false, Port.ResistorMode.Disabled);
23
24         // Create a boolean member to hold the button state.
25         bool buttonState = false;
26
27         // Loop forever
28         while (true)
29         {
30             // Read the button's state
31             buttonState = button.Read();
32
33             // Illuminate the LED based on a button press
34             onboardLED.Write(buttonState);
35
36         }
37
38     }
39 }

 

 

 

 

 

 

La caída en el ejemplo de código anterior es el hecho de que tenemos que comprobar constantemente el estado del puerto de entrada y llevar a cabo sobre la base de esa condición. Un método más limpio, más eficiente es utilizar un InterruptPort. El InterruptPort nos permite crear un controlador de eventos para cuando el estado del botón cambia. Un ejemplo es el siguiente:

 

 

/// <summary>
2 /// Button Event Handler Tutorial for the Netduino 2 and Netduino Plus 2
3 /// </summary>
4 public class Program
5 {
6
7     // Define a new Output Pin to the Onboard LED
8     // NOTE: Setting initial state of the pin to "false"
9     private static OutputPort onboardLED = new OutputPort(Pins.ONBOARD_LED, false);
10
11     /// <summary>
12     /// Main method runs on startup
13     /// </summary>
14     public static void Main()
15     {
16         // Define a new Interrupt Port to the Onboard Switch
17         // NOTE: Set glitch filter to "false".  This is only needed to
18         //       prevent switch bounce and in this case not needed.
19         // NOTE: The pullup on the MCU is disabled and the onboard switch
20         //       has a pulldown resistor so we set this to "Disabled".
21         // NOTE: The switch has a pulldown resistor and is connected to 3.3 (logic HIGH)
22         //       so the switch will show HIGH when pressed or LOW when released.
23         // NOTE: Set the Interrupt to fire on both edges (HIGH and LOW). (More Info:http://msdn.microsoft.com/en-us/library/cc532332.aspx)
24         InterruptPort button = new InterruptPort(Pins.ONBOARD_SW1, false, Port.ResistorMode.Disabled, Port.InterruptMode.InterruptEdgeBoth);
25
26         // Create an event handler for the button
27         button.OnInterrupt += new NativeEventHandler(button_OnInterrupt);
28
29         // Wait forever
30         Thread.Sleep(Timeout.Infinite);
31     }
32
33     /// <summary>
34     /// Event Handler for the Button Press
35     /// </summary>
36     /// <param name="port"></param>
37     /// <param name="data"></param>
38     /// <param name="time"></param>
39     private static void button_OnInterrupt(uint port, uint data, DateTime time)
40     {
41         // Activate the LED when button is pressed (data == 1)
42         onboardLED.Write(data == 1);
43     }
44
45 }

 

En este ejemplo por encima de los ajustes son muy similares para el filtro de glitch y el Modo de Resistencia . Un ajuste adicional para el InterruptPort es el modo de interrupción de la que nos hemos fijado para InterruptEdgeBoth . En este escenario, el evento se disparará cuando el pin cambia de bajo a alto o alto a bajo. En esencia, esto nos permite manejar la prensa y la liberación del botón. Cuando esto sucede el evento OnInterrupt se dispara . El controlador de eventos que permite transformar el LED encendido o apagado en función del estado del botón.

 

La parte eficaz de este ejemplo es que el programa se va a dormir después de la inicialización de los puertos. Se despertará cuando se controla el evento , y luego irá a dormir de nuevo hasta el próximo evento .

Yo mencioné al principio me cubra el uso de componentes externos y aquí lo haré. Usted puede utilizar un botón externo o LED externo , ya sea con ejemplo . Usted sólo tendrá que conectar los componentes adecuados . Para este ejemplo vamos a necesitar nuestra Netduino 2, una placa, un botón , un LED y dos resistencias, una de 1kΩ  y una de 470Ω .

 

En ambos casos vamos a querer cambiar los pernos que estamos utilizando a los pines externos en lugar de la en los pines de mesa. Para estos ejemplos cualquiera de los pines digitales (D0-D13) se puede utilizar.

 

Vamos a utilizar D0 y D1 en nuestro ejemplo.

 

Dónde estamos utilizando el bordo LED como así:

OutputPort onboardLED = new OutputPort (Pins.ONBOARD_LED, false);

 

Vamos a querer cambiar utilizando el pin 1 para nuestro ejemplo:

OutputPort onboardLED = new OutputPort (Pins.GPIO_PIN_D1, false);

 

Dónde estamos usando el botón del tablero en que así:

Botón InputPort = new InputPort (Pins.ONBOARD_SW1, falso, Port.ResistorMode.Disabled);

 

Vamos a querer cambiar utilizando Pin 0 para nuestro ejemplo:

Botón InputPort = new InputPort (Pins.GPIO_PIN_D0, falso, Port.ResistorMode.Disabled);

 

 

Fuente aqui

Controla cualquier cosa desde Internet con Electric Imp


BlinkUp TM es una tecnología muy novedosa pendiente de patente para obtener  dispositivos habilitados en línea para el dispositivo Electric Imp. Este post le llevará a través del proceso de creación de una cuenta Electric Imp y conseguir ejecutar su primer prototipo funcional que permitirá activar o desactivar  cualquier dispositivo desde Internet.

Este es el resumen  de los pasos que vamos a seguir:

  • Crear una cuenta Electric Imp
  • Descargar y configurar la aplicación para movil
  • BlinkUp su Elctric imp

Cuenta de Electric Imp

  • Crear una cuenta en electric Imp
  • Visita la página de registro y crear una cuenta. Una vez que haya creado una cuenta, debe iniciar sesión en la eléctrica Imp IDE basado en el navegador .

Descarga de  la aplicación móvil 
La aplicación móvil le permite introducir la información de su cuenta, el SSID de la red y la contraseña, y enviarlo a la imp. La aplicación móvil no envía el SSID o la contraseña de la red a los servidores Imp eléctricos.Esta disponible tanto para iOS como para Android pero sólo es necesario la aplicación móvil para configurar el Eelctric imp, así que si usted no tiene un teléfono inteligente o una tableta a mano, puede utilizar el dispositivo móvil de otra persona – sólo tiene que utilizar sus credenciales de cuenta Imp eléctricas para iniciar sesión en la aplicación.

Introduzca las credenciales en aplicaciones móviles
Abra la aplicación móvil, e introduzca su nombre de usuario + contraseña electric Imp  (si está utilizando la aplicación para Android, debe iniciar sesión con su dirección de correo electrónico + contraseña).

Una vez que ha iniciado sesión en la aplicación, seleccione la red inalámbrica a la que desea conectarse. Si no ve la red a la que desea conectar su imp a (o es una red oculta), seleccione otra red y luego introduzca el nombre de la red.

El  sw es capaz de determinar qué tipo de seguridad (WEP, WPA, WPA2, etc) utiliza la red – por lo que todo lo que tiene que hacer es introducir la contraseña wifi. Si se está conectando a una red no segura, simplemente deje en blanco el campo Contraseña.

El poder de su electric imp
Conecte el extremo pequeño del cable Mini USB en la toma USB , y el otro extremo a un puerto USB en su computadora.

Inserte su tarjeta electric imp en la ranura SD en su adaptador especial. Si todo funciona correctamente, un LED dentro de la electric imp debe comenzar naranja parpadeando (si se trata de una nueva marca imp, o, posiblemente, rojo, si no es nuevo).

Si está utilizando el Sparkfun eléctric Imp Breakout  tendrá que rellenar el jumper de 3-pin y ponerlo en modo “USB”.

BlinkUp
Si está usando la aplicación para Android, y no ha parpadeado esta electric imp antes, hay que seleccionar el modo de herencia para los mejores resultados.

Haga clic en el BlinkUp en la aplicación móvil y, a continuación, mantenga la pantalla de su teléfono al ras con el borde de la imp. Para obtener los mejores resultados, se recomienda lo siguiente:

La colocación de teléfono adecuado para BlinkUp fiable

Mantenga la pantalla del teléfono lo más cerca posible del sensor óptico (a ras si es posible)
El pulgar debe cubrir la, parte superior expuesta de la imp (donde dice “Developer Edition”).
Trate de bloquear cualquier luz / BlinkUp brillantes directos en la sombra.
Trate de mantener el dispositivo aún durante el proceso.
Usted siempre debe realizar BlinkUp con la pantalla mirando hacia adelante y hacia el dispositivo que se está configurando, especialmente si usted sufre de una condición médica que le hace susceptible a la luz estroboscópica. Puesto que hay mensajes de audio tanto en el inicio y el final, puede cerrar los ojos durante el proceso.

¡Enhorabuena!:Su imp ahora debe estar parpadeando en verde, lo que indica que está conectado a Internet (y la nube Imp).

Ahora  se  mostra cómo programar su imp utilizando el IDE en línea .

Hello World

Esta guía le llevará a través de su primer proyecto imp habilitado. .

En este proyecto, vamos a construir un circuito simple para hacer  parpadear un LED.

Circuito

  1. Conecte el cable positivo (largo) del LED para PIN9 del imp.
  2. Conecte el cable negativo (corto) del LED a un extremo de una resistencia de 330Ω.
  3. Conecte el otro extremo de la resistencia 330Ω al pin GND del imp.

Crear un Nuevo Modelo

  1. Inicie sesión en el ID
  2. Haga clic en nuevos dispositivos para expandir el menú desplegable. Usted debe ver el dispositivo que has BlinkedUp.
  3. Haga clic en el dispositivo para abrir la ventana de configuración del dispositivo.
  4. Si lo desea, puede darle a su equipo un nombre (* nota – este nombre se asocia con el consejo abril conectó su imp en, no la propia imp *). Vamos a llamar a nuestra de 01 de abril.
  5. Haga clic en el menú desplegable a continuación modelo asociado y escriba el nombre para el nuevo modelo que desea crear. Vamos a llamar a nuestro “Hello World”.
  6. Haga clic en Guardar cambios.
  7. Usted debe ver el modelo que acaba de crear aparecerán en la barra de navegación izquierda. Si hace clic en él, y luego en el dispositivo, se abrirá el editor de código.

El Editor de código

El editor de código consta de tres ventanas (agente, dispositivo y troncos):

Agente

La ventana agente es donde usted escribe su código de agente. Los agentes son trozos de código de ardilla que se ejecutan en la nube Imp, y le permiten hacer cosas como procesamiento pesado de descarga, la marca y el procesamiento de las peticiones HTTP, y pequeñas cantidades de datos de la tienda.

Dispositivo

La ventana del dispositivo es donde se escribe el código que se ejecutará en el propio dispositivo. Dado que este ejemplo no se va a utilizar agentes, aquí es donde todo nuestro código irá.

Registros

La ventana de registros (en la parte inferior de la pantalla) muestra varios trozos de información desde el dispositivo seleccionado. Esto incluye la información del sistema (dispositivo en línea, fuera de línea, actualizaciones de firmware, nuevo código, etc), información sobre los errores en tiempo de ejecución, y cualquier cosa que se registra conserver.log .

Código

// configure the imp (best practice)
imp.configure(“Hello World”, [], []);

// create a global variabled called led,
// and assign pin9 to it
led <- hardware.pin9;

// configure led to be a digital output
led.configure(DIGITAL_OUT);

// create a global variable to store current
// state of the LED
state <- 0;

function blink() {
// invert the value of state:
// when state = 1, 1-1 = 0
// when state = 0, 1-0 = 1
state = 1-state;

// write current state to led pin
led.write(state);

// schedule imp to wakeup in .5 seconds and do it again.
imp.wakeup(0.5, blink);
}

// start the loop
blink();
view rawblink.device.nut hosted with ❤ by GitHub

Copia y pega el código en la ventana del dispositivo, haga clic en el botón Generar y ejecutar.

Usted debe ver los siguientes mensajes en la ventana de los registros:

 [Status] Downloading new code [Status]
 Device configured to be "Hello World"

Usted acaba de escribir su primer programa de imp,ahora ya puede controlar un Led por internet mediante https

Visión de conjunto

Esta guía le llevará a través de su primer proyecto conectado a Internet imp habilitado! Vamos a construir una API simple para un LED. Se supone que ya ha creado el ejemplo anterior , y vamos  a utilizar el mismo circuito.

Código de dispositivo

// configure the imp (best practice)
imp.configure(“LED Api”, [], []);

// create a global variabled called led,
// and assign pin9 to it
led <- hardware.pin9;

// configure led to be a digital output
led.configure(DIGITAL_OUT);

// function to turn LED on or off
function setLed(ledState) {
server.log(“Set LED: ” + ledState);
led.write(ledState);
}

// register a handler for “led” messages from the agent
agent.on(“led”, setLed);

Si llegamos a generar y ejecutar en este punto, nuestro equipo no va a hacer nada interesante. La parte realmente importante e interesante de este código es la siguiente línea:

 agent.on("led", setLed);

Esta función registra un listeer de mensajes enviados por el agente. Cada vez que el agente envía un mensaje al dispositivo llamado “llevó”, se ejecutará la función setled.

Código de Agente

// Log the URLs we need
server.log(“Turn LED On: ” + http.agenturl() + “?led=1”);
server.log(“Turn LED Off: ” + http.agenturl() + “?led=0”);
 
function requestHandler(request, response) {
try {
// check if the user sent led as a query parameter
if (“led” in request.query) {
 
// if they did, and led=1.. set our variable to 1
if (request.query.led == “1” || request.query.led == “0”) {
// convert the led query parameter to an integer
local ledState = request.query.led.tointeger();
 
// send “led” message to device, and send ledState as the data
device.send(“led”, ledState);
}
}
// send a response back saying everything was OK.
response.send(200, “OK”);
} catch (ex) {
response.send(500, “Internal Server Error: ” + ex);
}
}
 
// register the HTTP handler
http.onrequest(requestHandler);

En el código de agente, registramos y controladores HTTP. El controlador de HTTP se ejecuta cada vez que una petición HTTP se hace a la dirección URL agente (que se muestra en la parte superior de la ventana de código de agente).

En nuestro controlador HTTP, comprobamos para ver si se suministra un parámetro de consulta denominado led lo fuera, le enviamos un mensaje al dispositivo, junto con el valor del parámetro de consulta led.Enviamos el mensaje al dispositivo mediante la siguiente línea:

 device.send("led", ledState);

Cuando esta línea se ejecuta, envía un mensaje al dispositivo que se traduce en setled (ledState) se está ejecutando.

Pruebas

Copia y pega el agentURL en una nueva ventana y agregar? Led = 1 (para encender la lámpara encendida)o? Led = 0 (para apagar el dado). Debe ser algo como esto:

 https://agent.electricimp.com/a1b2bc3d4?led=1
 https://agent.electricimp.com/a1b2bc3d4?led=0

¡Enhorabuena!

Usted acaba de conectar un LED a Internet. Si lo desea, envíe la URL a tus amigos y haga que traten de controlar el LED desde cualquier lugar del mundo: siempre que tengan una conexión a Internet,deberán  ser capaz de controlar su LED.

Por supuesto este ejemplo es extropolable  a los 6 salidas más y obviamente en lugar de hacer lucir un led puede mediante el circuito adecuado puede  activar un relé para comandar cargas mayores.

Fuente aqui

Iluminación con leds


LED  proviene de Light Emiter Diode ( diodo emisor de luz ) y fue desarrollado  por Oleg Vladimírovich Lósev en 1927 y para posteriormente Nick Holonyak inventar el primer led comercial en 1962 mientras trabajaba como científico asesor en un laboratorio de General Electric en Syracuse (Nueva York)

En los años sesenta el led se comenzó a producir industrialmente. Solo se podían construir de color rojo, verde y amarillo, con poca intensidad de luz y se limitaba su utilización a mandos a distancia (controles remotos) y electrodomésticos, como indicadores para señalar el encendido y apagado.

A finales de los años noventa se inventaron los leds ultravioletas y azules(estos últimos en tela de juico pues pueden ser dañinos para la vista y provocar contaminación lumínica)

Gracias a la invención de los leds azules en los 90’s   se dio el paso al desarrollo del led blanco, que es un led de luz azul con recubrimiento de fósforo que produce una luz amarilla. La mezcla del azul y el amarillo (colores complementarios en el espectro RGB) produce una luz blanquecina denominada «luz de luna» que consigue alta luminosidad (7 lúmenes unidad), con lo cual se ha logrado ampliar su utilización en otros sistemas de iluminación.

Finalmente a comienzos del Siglo XXI surgen los diodos OLED (organic light-emitting diode:), fabricados con materiales >polímero orgánicos semiconductores. Aunque la eficiencia lograda con estos dispositivos está lejos de la de los diodos inorgánicos, y son biodegradables, su fabricación promete ser considerablemente más barata que la de aquellos, siendo además posible depositar gran cantidad de diodos sobre cualquier superficie empleando técnicas de pintado para crear pantallas en color.

Una solución tecnológica que pretende aprovechar las ventajas de la eficiencia alta de los leds típicos (hechos con materiales inorgánicos principalmente) y los costes menores de los OLED (derivados del uso de materiales orgánicos) son los Sistemas de Iluminación Híbridos (Orgánicos/Inorgánicos) basados en diodos emisores de luz. Dos ejemplos de este tipo de solución tecnológica los está intentado comercializar la empresa Cyberlux con los nombres de Hybrid White Light: ‘luz blanca híbrida’ y HML Hybrid Multicolor Light:‘luz multicolor híbrida’), cuyo resultado puede producir sistemas de iluminación mucho más eficientes y con un coste menor que los actuales

Los leds   en definitiva  presentan innumerables  ventajas  sobre cualquier  fuente de luz generada artificialmente como son las fuentes de luz incandescente y fluorescente , tantas que poco  a poco se perfila  como el sistema  de iluminación artificial  definitivo que terminara implantándose en todo el Globo

A continuación algunas de las ventajas que poseen los leds :

  • Muy bajo consumo de energía  hasta tal punto qeu son ideales para utilizarse con sistemas fotovoltaicos (paneles solares) en comparación con cualquier otra tecnología actual;
  • Mayor tiempo de vida :en la mayoría de los colores (a excepción de los ledes azules),
  • Tamaño reducido que aún ha disminuido mucho más conla tecnología SMD
  • Durabilidad cuentan con un alto nivel de fiabilidad y duración y ademas no les afecta el encendido intermitente (es decir pueden funcionar como luces estroboscópicas) y esto no reduce su vida promedio,
  • Resistencia a las vibraciones al no llevar elementos mecánicos y ninguna electrónica asociada
  • Reducen la emisión de calor
  • Reducen ruidos en las líneas eléctricas,
  • No contienen mercurio  como el caso de FLuorescentes  ,el cual al exponerse en el medio ambiente es altamente venenoso
  • No crean campos magnéticos altos como es el caso de los fLuorescentes   que necesitan un balast que origina una inducción magnética alta , con los cuales se crea mayor radiación residual hacia el ser humano;
  • Cuentan con mejor índice de producción cromática que otros tipos de luminarias
  • Tiempo de encendido muy corto (aproximadamente en un cuarto de segundo) en comparación con las luminarias de alta potencia como lo son las luminarias de alta intensidad de vapor de sodio, aditivos metálicos, halogenuro o halogenadas y demás sistemas con tecnología incandescente.
  • Son especiales para sistemas antiexplosión ya que cuentan con un material resistente y no desprenden calor

Viendo las múltiples ventajas que conllevan los leds   es mas que razonable ir poco a poco descartando la compra de lamparas compactas o fluorescentes  sustituyéndolas  por lamparas Leds  pues en el mercado  existen un abanico tan inmenso  que en el momento actual es posible sustituir  cualquier sistema basado en iluminación tradicional por uno con el mismo casquillo y tensión de alimentación que utilice Leds.

Algo relativamente  novedoso diferente a los formatos conocidos son las llamadas tiras de LEDS, las cuales han experimentado una bajada de precios asombrosa  respecto  a los precios   de otros años  .

tira led

En estas tiras flexibles autoadhesivas  se utiliza  un plástico como sustrato para ofrecer la  flexibilidad necesarias para pegarla  cualquier superfice.Sobre el soprte   van montados los leds smd  y la correspondiente resistencia limitadora  de forma que se repite el mismo modulo hasta terminar la tira.

Gracias a la flexibilidad del sustrato y a la modularidad del diseño  podemos cortar en la longitud que necesitemos siempre que cortemos  entre un módulo y otro .

En el caso de que necesitemos mas longitud  soldaremos  dos hilos   en los dos pads dorados de fin de cada módulo  respetando escrupulosamente la polaridad entre tiras.

Por ultimo estas tiras se suelen alimentar con 12 voltios continuos  por lo que deberemos adquirir una fuente conmutada de 12v DC de la potencia adecuada a  los metros  de leds que vayamos a alimentar , pero  también nos puede  servir  cualquier cargador conmutado  que nos de esa tensión de servicio por ejemplo de un cargador de portátil ,alimetador de una vieja consola ,etc

Como detalle curioso existen controladores que se intercalan entre la  fuente y la primera tira de leds que permiten encender o apagar o ajustar el brillo de los leds

Para terminar  :también existen tiras  autoadhesivas de Leds RGB que junto al controlador adecuado nos hara las delicias a  los amantes de las luces de colores

SOLO UNA ADVERTENCIA: mucho  cuidado con la polaridad  con que alimentamos nuestra tira de leds pues los módulos no llevan diodo de protección  y por tanto podriamos estropear nuestro montaje

Fuente aqui