Cómo compartir un descodificador, blue-ray ,etc en toda una vivienda


En la mayoría  de las  viviendas unifamiliares  es muy sencilla la distribución de antena   a la largo de la vivienda  , sencillez   que  nos va a permitir introducir mezclada junto con la señal de antena proveniente de la antena comunitaria   una nueva señal VHF  de alta calidad modulada con  cualquier fuente de audio  y vídeo  que nos interese  transmitir como puede ser un descodificador de cable,un descodificador satélite , un reproductor de dvd , un reproductor de blue-ray,un disco  multimedia ,etc

La única dificultad para realizar el montaje estriba en localizar el cajetin principal  de distribución de antena de la vivienda (normalmente esta en el salón )    pues sera ahí precisamente donde inyectaremos la señal VHF que transmitiremos por toda la vivienda

   Paso a paso

Paso 1

Localizaremos la toma principal de  entrada de antena de la vivienda

.

Paso 2
Lo primero que debemos hacer es aflojar los tornillos que sujetan la tapa de la caja, con la ayuda de un destornillador.

Paso 3
Después, retiramos la pieza, destornillamos el mecanismo y lo sacamos: debe haber dos cables uno principal ( que marcaremos  como antena  y suele ir en lado in del mecanismo)     que procede  de la cabecera de antena y otro cable que sera el que distribuye las señal de antena por toda la vivienda ( que marcaremos como out)

En el caso de que el mecanismo tenga conectado un cable de entrada y otro de salida se tratará de una toma de paso y puede ser una caja que nos interese . En cambio, si sólo se le acopla SOLO un cable de entrada será de final de carrera y es evidente que NO nos servirá  para nuestro cometido .

Para probar que es la caja correcta, si probamos el resto de TV’s  de la vivienda una vez eliminado el mecanismo  ya no debería verse  ningún canal de TV    lo cual significa que nuestro cajetin es el punto de entrada de antena de nuestra vivienda  .

Paso 4
Una vez que hayamos hecho esta tarea, tendremos que adquirir   una nueva tapa   de salida de cable  o de dos conectores independientes para poder  inyectar una nueva señal (la modulada en VHF).

Paso 5
En el caso de que el mecanismo tenga conectado un cable de entrada y otro de salida  y esta sea la correcta conectaremos el nuevo mecanismo, mejor uno de salida de  cables  u otro  en el  que estén los dos conectores separados  y   deberían  diferenciarse claramente    la  señal de entrada y la la de salida de antena .

Paso 6

Usaremos para modular la señal VHF bien  cualquier reproductor de video VHS,Beta ,etc con esta funcionalidad que normalmente  iba incluida  en todos los vídeos “compatibles con canal-plus”   (dado qeu estan en desuso pueden  ser adquirido en cualquier establecimiento de segundamano por menos de 10€)   o bien un modulador de VHF  independiente(ver paso 8)

Conectaremos el cable procedente de la antena comunitaria a la entrada de antena   del video  VHS (o  modulador   VHF  ) y la salida de antena   del video  VHS   a la distribución de antena de la vivienda .

Por ultimo conectaremos los cables de audio y vídeo procedentes de la fuente  a compartir    en  el euro-conector  normalmente  marcado de color azul ( es decir de entrada de audio y vídeo)

Paso 7

Para probar que  el montaje es funcional asegurarse de  que les estamos  introduciendo aun señal de video y audio procedente de una fuente  externa  ,encender el video  y conmutarlo a la entrada de vídeo auxiliar ( normalmente en el display aparecerá  el mensaje AU1)  y en nuestro TV escanear la señales de VHF  ( normalmente estará por el canal 30  al 43). No confundir con buscar los canales de la TDT pues la señal de estos vídeos es analógica y solo aparecerá en esta .

Paso 8

Alternativamente  al video VHS,  se puede usar un  modulador profesional VHF  como el que se muestra a continuación

NOTA: si la señal no aparece clara o con “niebla”  en todos los TV’s  ,intercalar un amplificador de antena doméstico    entre la señal de salida de antena del video VHS  y la toma de antena de la vivienda: el resultado mejorará considerablemente la calidad de audio y vídeo  en todos los TV’s

Espero  que os  sirva esta guía  ….!Feliz navidad  y año nuevo! 

Anuncios

Sobre los smartphones del futuro


A través de los ojos de Tomás Palacios, español y profesor del Instituto Tecnológico de Massachussets (MIT, por sus siglas en inglés), el futuro esta en electrónica  flexible, transparente y ubicua  ya que   los dispositivos electrónicos actuales  bastante convencionales al basarse en  bloques sólidos que no se pueden doblar y que no dejan pasar la luz , por lo que se prevee que a electrónica del futuro va a cambiar totalmente su aspecto, va a ser ubicua y  va a estar en todas partes de modo

Si nos referimos a la fabricación de smartphones  transparentes y flexibles, sera necesario conseguir materiales que sean muy baratos y que consuman poca energía, siendo el candidato perfecto el  Grafeno el cual está compuesto por un solo átomo de espesor lo cual lo hace el material más delgado que existe, es uno de los mejores materiales para la electrónica( los transistores de grafeno funcionan hasta cien veces más rápido que los transistores de silicio) es el material más resistente que se conoce (es cinco veces más duro que el acero) ,el mejor conductor térmico y eléctrico y además tiene una propiedad muy importante: es transparente y flexible.

Si bien todo en el grafeno parecen ventajas , hay una serie duda :aunque los transistores de grafeno son más rápidos que los del silicio, no se pueden utilizar todavía en microprocesadores, pues consumirían demasiada energía.

Sin embargo la opinión tan optimista de tan insignie ingeniero  español contrasta con  la opinion de  directivos de Samsung:  “El smartphone del futuro requerirá de una revolución técnica que hoy por hoy no es posible”

Para la firma coreana, no hay personas lo suficientemente preparadas para abordar la necesaria revolución técnica que dé lugar a la siguiente generación de smartphones.

El teléfono inteligente del futuro va a requerir una “revolución” en el pensamiento sobre el diseño técnico y “no hay suficientes personas están preparadas” para estos desafíos. Así de tajante se mostró el presidente de Samsung Electronics, Namsung Woo, en una conferencia internacional.
Basada en la automatización de diseño electrónico (EDA) existente en la actualidad, la industria ha hecho hasta ahora los deberes con los teléfonos inteligentes y aún podrá presentar novedades los próximos dos o tres años.
Sin embargo, el diseño del mañana (pantalla flexible, cámaras con calidad de una réflex o aplicaciones de realidad aumentada mil veces más potentes que las actuales) necesitará de una revisión total del pensamiento y la forma de abordar su diseño.
Woo ha sugerido además que la industria de los semiconductores y la industria de automatización de diseño electrónico tienen la necesidad de hacer las cosas de manera muy diferente de la que lo hacen hoy. “Todavía tenemos que utilizar más de una docena de chips para construir un teléfono inteligente”, dijo Woo, algo inviable si finalmente se lanza un móvil con pantalla flexible

Fuente   aqui

 

Maquina expendedora de caramelos conectada a Internet


Imagen de SnackBot: Internet conectado Candy Machine!
Durante el 2013 Bay Area Maker Faire , el distribuidor   Electric  Imp repartieron  una asombrosa cantidad de caramelos  M & Ms con el prototipo “SnackBot” .Cientos de asistentes les encantó, así que decidieron compartir la forma en que lo construyeron.El  SnackBot se basa en el dispositivo Electric Imp   del que ya se  ha hablado en este blog ,  que como recodareis una plataforma de hardware, software y basada en la nube que hace que sea muy fácil de conectar casi cualquier cosa en Internet.

Este proyecto implica un poco de soldadura (y desoldar), y debe usted tomar cerca de 2-3 horas para completarlo
Para completar este proyecto, usted va a necesitar lo siguiente:

Usted también va a necesitar algunas herramientas:

Lo primero que tenemos que hacer es desmontar un  SnackMan tradicional  .

DSC_0473.JPG
DSC_0475.JPG
Se  va  a cambiar   (casi) toda la electrónica, y sustituirlos por una placa nueva  y un  FET.Desmontar el SnackMan:

  1. Retire la cúpula de plástico transparente presionando el botón en la parte frontal de la SnackMan.
  2. Retire la pieza superior de plástico para exponer la cubierta de engranajes y tapas de rosca.
  3. Quite la cubierta de engranaje, el engranaje, tapones de rosca, y tornillos.
  4. Presione sobre el botón (el mismo botón de # 1) y tire hacia arriba para retirar la cubierta de plástico.
  5. Una vez retirada la cubierta de plástico, tenemos acceso a la electrónica.
  6. Quite los tornillos que sujetan las placas de circuito a la base.
  7. Suelte todos los cables de la placa principal.

 

DSC_0483.JPG

 

El SnackMan tiene una esfera que se usa para encender la máquinay  tambien para la  desconexión, así como controlar el tamaño de la porción. Vamos a modificarlo para actuar como un interruptor de alimentación para el Electric imp.Cuando el interruptor está en el estado desactivado, el SnackBot estará apagado. En cualquier otro estado, el SnackBot estará encendido. Nosotros no tenemos que preocuparnos acerca de cómo controlar el tamaño de porción, ya que será gestionado por nuestra página web.

Esto es lo que tenemos que hacer:

  1. Cortar el conector del extremo de los cables.
  2. Tire de los cables separados (esto hará que los próximos pasos más fácil).
  3. Desoldar todos los cables excepto el tercero de la parte superior (que debe ser de color negro).
  4. Suelde el cable rojo de la fuente de alimentación de la SnackMan al segundo desde el orificio superior.
  5. El cable rojo de la fuente de alimentación, y el cable negro que dejamos debería ser uno junto al otro.

Ahora debería tener 5 piezas:

  1. La cubierta superior del motor +
  2. El codificador rotatorio (tablero de dial circular +) de la parte delantera de la SnackMan
  3. La parte inferior de la SnackMan (con el cable de alimentación que viene desde la base)
  4. La placa principal
  5. La placa  IR

Usted no tendrá que utilizar la placa principal  ni la placa  IR , por lo que se puede descartar (o guardarlo para futuros proyectos si se quiere).

Lo siguiente que tenemos que hacer es conseguir que el motor se conecte a nuestra placa :

  1. Dobla los cables del NFET para los pasadores fuera alinean con GND y Pin9
  2. Soldar Pin S (origen) a GND (a la imp).
  3. Soldar Pin G (puerta) para Pin9 (en la imp).
  4. Soldar el (negro) cable negativo desde el motor al pin D (fuga).

Conexiones de la Electric  Imp :

  1. Suelde la resistencia 10k entre Pin9 y GND.

Conexión de la Electric  imp a la alimentación:

  1. Suelde el cable negro de la fuente de alimentación (base) del SnackMan al pin GND del diablillo.
  2. Suelde el cable extra que sale de la codificación giratorio para pin VIN del imp.
  3. Soldar el (rojo) positivo desde el motor al pin VIN del imp.

Añadir el diodo:

  1. Suelde el diodo entre los terminales positivo y negativo del motor de la SnackMan(el l lado banda / rayas del diodo debe ser soldado a (rojo) del motor positivo).
    • IMG_0183.PNG

       

      Antes de cerrar el SnackBot recién imp habilitados, vamos a parpadear para arriba y ejecutar algún código de prueba para asegurarse de que todo funciona correctamente.Obtenga su imp online:

      1. Añadir baterías (o enchufe el cable de alimentación).
      2. Gire el codificador giratorio a cualquier posición que no sea la posición “Off”.
      3. Inserte la  tarjeta Eelctric Imp en en la ranura para tarjeta SD de la placa adaptadora.
      4. Un LED en el interior del imp debe comenzar a parpadear.
      5. Siga los pasos de BlinkUp  para obtener su línea.
      • Si su imp no se enciende, es probable que tenga problema de cableado.Vayan y vuelva a comprobar que sueldan todas las cosas que había que soldar.

      En este punto, el imp debe parpadear verde, para indicar que está en línea y hablar con nuestro servidor.

      Pruebe el hardware:

      1. Acceda a Electric Imp basada en web IDE .
      2. Copia y pega el código de prueba del repositorio SnackBot en la ventana de dispositivos en el IDE.
      3. Hit Run.
      • El motor debería haber encendido durante 10 segundos, y luego vuelve a apagar. Si no fuera así, usted tiene un problema y usted debe asegurarse de que el NFET está orientado en la dirección correcta.

      Ejecute el código real:

      1. Copia y pega el código de Agente SnackBot en la ventana Agente de la IDE.
      2. Copia y pega el código de dispositivo SnackBot en la ventana de dispositivos del IDE.
      3. Hit Run.

      Cuando navegas URL Agent del dispositivo, se le presentará con una página web. Si hace clic en uno de los botones, se debe encender el motor y distribuir el caramelo.

  2. DSC_0538.JPG

     

    Ahora que todo está conectado y probado, vamos a añadir los toques finales.Asegure Electrónica del SnackBot:

    1. Si lo desea, retire la pieza roja de plástico. Esto hará más fácil BlinkUp en el futuro.
    2. Vuelva a colocar el interruptor de codificación / potencia rotativa.
    3. Añadir cinta de espuma a la base del conjunto SnackBot para sostener el tablero del desbloqueo de abril en su lugar.
    4. Presione firmemente el tablero del desbloqueo de abril (con la imp) en la cinta de espuma que acaba de dejar.

    Vuelva a montar el resto de la SnackBot:

    1. Añadir la cubierta de plástico que se coloca sobre la electrónica.
    2. Añadir el botón de plástico.
    3. Tornillo de la tapa de plástico en su lugar.
    4. Cubra los tornillos con los tapones de rosca.
    5. Añadir el dispensador de engranajes / dulces.
    6. Añadir la cubierta del engranaje.
    7. Encaje la clara cúpula de plástico en su lugar.
    8. Añadir caramelos   y Disfrute! 
Fuente  aqui

 

Colorimetro basado en Netduino


En este post  vamos a tratar  de  un original  sensor de color    controlado con  Netduino,Netduino Plus o Netduino Go.

Gracias al sensor de Color de Sparkfun   ADJD-S371-q999 y un Netduino  en este proyectos    se imprimirá el nombre de color HTML (es decir DarkRed) de un objeto que se ve( de hecho esta  aplicacion podria ser particularme  interesante  para las personas  daltónicas , pues basandose en este  sensor, podrian  obtener  un rango de mejora)

He aquí un breve video para demostrar el  fuincionamiento del sensor :

El ADJD-S371 es un 4 canal de sensor RGB + Claro que utiliza el protocolo I2C 2 hilos para comunicar con el microcontrolador. Es un poco complejo  el  dispositivo   pues no se limita a dar el color correcto cuando usted la pida  y necesitaremos  usar el algoritmo de calibración de ganancia,aunque para realizar pruebas sencillas puede utilizar el código descrito en este post

El código fue creado originalmente por Nathan Seidle para el microcontrolador PIC y fue portado y modificado para el Arduino por Marcus de Matter Interactive  y despues  Paul King lo porto en  lenguaje C # para el net Framework Micro..

Haga clic para ampliar
Haga clic para ampliar

El esquema de arriba    muestra el  sencillo circuito con   Netduino,donde  hay que a tener en cuenta, que  se usa un LED externo solo como  fuente de luz  por lo que no hay necesidad de conectar el pin LED en el ADJD-S371-Q999.  En cuanto a los  piuertos  podemos  utilizar cualquiera de las IO pines digitales: sólo tiene que cambiar un poco de código al configurar los puertos de salida. Por último, el LED RGB puede ser conectado a 3.3V o 5V y es posible que tenga que ajustar el tamaño de resistencias para su RGB LED de todos modos.

A continuación   se describe el código en c#   de este demo:

C # Código

1
2
3
4
5
6
using System;
utilizando System.IO.Ports;
using System.Threading;
utilizando Microsoft.SPOT;
utilizando Microsoft.SPOT.Hardware;
utilizando SecretLabs.NETMF.Hardware.Netduino;

Las líneas 1 a 6 definen un espacio de nombres, lo cual permite utilizar las clases o tipos sin tener que escribir el espacio de nombres completo donde existen esos tipos.

Por ejemplo, en lugar de escribir:
SecretLabs . NETMF . Hardware . Netduino . Pins . ONBOARD_LED

Podemos escribir simplemente:
Pins . ONBOARD_LED

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
namespace Squintz. colorímetro
{
Programa clase pública
{
I2C_ADDRESS público static byte = 0x74; / / 7bit
byte static REG_CAP_RED = 0x06;
REG_CAP_GREEN byte static = 0x07;
REG_CAP_BLUE byte static = 0x08;
REG_CAP_CLEAR byte static = 0x09;byte static REG_INT_RED_LO = 0x0A;
REG_INT_RED_HI público static byte = 0x0B;
byte static REG_INT_GREEN_LO = 0x0C;
byte public static REG_INT_GREEN_HI = 0x0D;
byte public static REG_INT_BLUE_LO = 0x0E;
REG_INT_BLUE_HI público static byte = 0x0F;
REG_INT_CLEAR_LO byte static = 0x10;
REG_INT_CLEAR_HI byte static = 0x11;REG_DATA_RED_LO byte static = 0x40;
REG_DATA_RED_HI byte static = 0x41;
REG_DATA_GREEN_LO byte static = 0x42;
REG_DATA_GREEN_HI byte static = 0x43;
REG_DATA_BLUE_LO byte static = 0x44;
REG_DATA_BLUE_HI byte static = 0x45;
REG_DATA_CLEAR_LO byte static = 0x46;
REG_DATA_CLEAR_HI byte static = 0x47;
public static I2CDevice rtc = nueva I2CDevice ( nueva . I2CDevice configuración (I2C_ADDRESS, 100));

byte static [] = readBuffer nuevo byte [1];

Líneas 7 a 33 son constantes definidas en la documentación y sensores de color. Línea 35 crea un nuevo objeto de dispositivo C I 2 llamado rtc. Utilizamos este objeto para enviar realmente los datos de la Netduino al sensor de color. I 2 C es un protocolo de bus que significa que varios dispositivos pueden compartir los mismos cables. Así el objeto I2CDevice nos obliga a darle una dirección de esclavo  para lo cual  se ha definido  como la constante  I2C_Address en la línea 11. El objeto I2CDevice también nos requiere que se especifique un tipo en kilohercios (en este ejemplo se ja usado 100 Khz)

Línea 37 crea una variable de tipo array de bytes  que debe tener en cuenta que solamente estamos inicializando el tamaño de la matriz a 1. El sensor de color no necesita realmente una matriz de bytes, pero el metodo  I2CDevice.CreateReadTransaction requiere una matriz de bytes como uno de sus parámetros y no tiene un método sobrecargado para usar sólo un byte.

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
public static void Main ()
{
OutputPort redpin = nueva OutputPort (pines GPIO_PIN_D10, cierto.);
OutputPort greenpin = nueva OutputPort (pines GPIO_PIN_D9, cierto.);
OutputPort BluePin = nueva OutputPort (pines GPIO_PIN_D7, cierto.);int cc = 0;
int rojo = 0;
int verde = 0;
int azul = 0;int clearGain;
int colorGain;int num_samples;

int i;

while (true)
{
clearGain = getClearGain ();
set_gain (REG_INT_CLEAR_LO, clearGain);
colorGain = getColorGain ();
set_gain (REG_INT_RED_LO, colorGain);
set_gain (REG_INT_GREEN_LO, colorGain);
set_gain (REG_INT_BLUE_LO, colorGain);

num_samples = 10;

for (i = 0; i <num_samples; i + +)
{
. Programa performMeasurement ();
cc + = get_readout (REG_DATA_CLEAR_LO);
rojo + = get_readout (REG_DATA_RED_LO);
verde + = get_readout (REG_DATA_GREEN_LO);
azul + = get_readout (REG_DATA_BLUE_LO);
}
cc / = num_samples;
rojo / = num_samples;
verde / = num_samples;
azules / = num_samples;

. redpin Escriba (false);
. greenpin Escriba (false);
. BluePin Escriba (false);

if (red> verde && red> blue)
. redpin Escriba (true);
más
if (verde> rojo && verde> azul)
. greenpin Escriba (true);
más
if (azul> rojo && azul> verde)
. BluePin Escriba (true);

. Depuración de impresión (“C:” + (byte) (cc >> 2) + “” + “R:” + (byte) (rojo >> 2) + “” + “G:” + (byte) (verde >> 2) + “” + “B” + (byte) (azul >> 2));
. Thread Sleep (500);
}
}

Líneas 38 es el principal punto de entrada para nuestro programa. En las líneas 40 a 42 definen  que 3 puertos de I/O estamos utilizando para controlar un LED RGB. Al añadir el SecretLabs.NETMF.Hardware.Netduino.dll a nuestra lista de recursos y declarándola con la instrucción using de la línea 6 que no tenemos que recordar los números de pin microcontroladores reales. SecretLabs ya ha visto todo esto para nosotros y que nos permitirá usar Pins.xxxxx.(de hecho  con la función completa de código alias intellisense de Visual Studio automáticamente aparece un menú contextual que le permite seleccionar de una lista de pines disponibles).

[* ACTUALIZACIÓN:. Si utiliza el instalador del  SDK SecretLabs  puede iniciar una nueva “Aplicación Netduino”, que elimina la necesidad de añadir manualmente las dll a su lista de recursos y también elimina la necesidad de añadir manualmente los SecretLabs usando declaraciones]

En la línea 56 creamos un bucle infinito de modo que nuestro programa no se acaba nunca. Sin este nuestro programa sólo se ejecutará una vez y luego terminaria.

Líneas 58 y 64 es donde se puede ser creativo. La hoja de datos de sensores de color y nota de aplicación son un poco borroso en la explicación de la manera adecuada para calibrar y ajustar la ganancia de su sensor. Sin embargo, se debe establecer la ganancia de cada color antes de que usted solicite el color pues de NO ajustar la ganancia solo  recibiría resultados bajos.

Líneas 65 a la 78 es donde nos muestra los colores mediante el uso de unos métodos de ayuda que usted va a leer a continuación. La clave a destacar aquí es que cuantas más muestras se toma  más estable aparecerán sus números. En este caso se toman  muestras de 10 y se suman los resultados juntos y se dividen por 10 para obtener el valor medio.

Líneas 80 a 93 es donde establecemos el color de nuestra RGB LED. El algoritmo usado es  muy simple para determinar el color más dominan y encender sólo el pin  del LED RGB via experimental

En la línea 95 que llamamos Debug.Print e imprimir los valores de la ventana de resultados de Visual Studios. El valor claro indica una intensidad de luz general que los valores Azul Rojo, Verde, y son la intensidad, como se ve a través de un filtro de luz.

99
100
101
102
public static void performMeasurement ()
{
set_register (0x00, 0x01); / / inicio de detección
}

Ahora empezamos a conseguir profundamente en el protocolo de sensores de color. Para decir el sensor de color para tomar una muestra fijamos el registro 0 × 00 con el valor de 0 × 01. El sensor de color a continuación,  toma una muestra y la almacena.

103
104
105
106
static int get_readout (readRegister byte)
{
volver read_register (readRegister) + (read_register ((byte) (readRegister + 0x01)) << 8);
}

El sensor de color almacena sus valores de color en dos registros de 8 bits. Así. en las líneas 103 a 106, get_readout () toma el primer registro como parámetro y asume el siguiente registro está a sólo 1 más direcciones por encima de ese registro. Así leemos el valor del primer registro y luego leemos el valor del segundo registro y luego cambiamos el valor del segundo registro de 8 bits a la izquierda que nos deja con el pleno entero de 16 bits. Sin embargo, sólo 10 bits se ponen realmente en el entero debido a que los altos registros sólo devuelven los dos bits menos significativos y el bajo registro devuelve 7 Bits.

107
108
109
110
111
112
113
114
115
116
117
public static void set_gain (gainRegister byte, int ganancia)
{
if (ganancia <4,096)
{
byte hi = (byte) (ganancia >> 8);
lo = byte (byte) (ganancia);set_register (gainRegister, lo);
set_register ((byte) (gainRegister + 1), hi);
}
}

Cada color tiene dos de sus propios registros de ganancia. Definimos estos en nuestros constantes en las primeras líneas. Aquí  suponemos que ya que sabemos la dirección del registro del registro inferior, por lo que sólo podemos añadir 1 a la dirección para obtener la dirección del registro superior. Luego asignamos los valores de ganancia a través de la ayuda de set_register ().

118
119
120
121
122
123
124
125
126
public static void set_register (byte r, byte v)
{rtc. Ejecutar ( nueva I2CDevice. I2CTransaction []
{
I2CDevice. CreateWriteTransaction ( nuevo byte [] {r, v})}, 5000);
}

set_register es donde sucede la magia. Aquí creamos una nueva matriz de bytes que contiene dos valores. La primera es r para el registro y el segundo es v por valor. Transmitimos esta matriz de bytes a un nuevo objeto I2CDevice.CreateWriteTransaction y luego pasamos ese objeto con el método rtc.Execute. Usted debe recordar que rtc es nuestro objeto I2CDevice que sabe acerca de la dirección del esclavo de nuestro sensor de color. Así, en pocas palabras nuestra función set_register es donde empaquetamos todo y lo enviamos en su camino.

127
128
129
130
131
132
133
134
135
136
read_register público static byte (byte r)
{
rtc. Ejecutar ( nueva I2CDevice. I2CTransaction [] {
I2CDevice. CreateWriteTransaction ( nuevo byte [] {r})
,
I2CDevice. CreateReadTransaction (readBuffer)
}, 5000);volver readBuffer [0];
}

En líneas 127 a 136  estamos enviando una solicitud de nuestros valores de color. Nos pasamos ‘r’, que es el color que queremos leer. Recuerde que esto ocurre dos veces para cada color con el fin de obtener el valor total. Esperamos 5.000 milisegundos o 5 segundos para que el regreso antes de tiempo de espera.

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
public static int getClearGain ()
{
int gainFound = 0;
int upperBox = 4,096;
int lowerBox = 0;
int media = 0;
int halfValue;mientras que (gainFound == 0)
{
media = ((upperBox – lowerBox) / 2) + lowerBox;
/ / Possbile no más lejos Halfing
if (media == lowerBox)
{
gainFound = 1;
}
más
{
set_gain (REG_INT_CLEAR_LO, medio);
performMeasurement ();
halfValue = get_readout (REG_DATA_CLEAR_LO);si (halfValue> 1000)
{
upperBox = medio;
}
else if (halfValue <1,000)
{
lowerBox = medio;
}
más
{
gainFound = 1;
}
}
}
devolver la mitad;
}

Líneas 137-174 es donde usted puede volver a probar  para perfeccionar sus resultados. Usted tendrá que obtener una forma de obtener un valor de ganancia que compensa la luz ambiental y todos los demás factores ambientales que pueden cambiar la sensibilidad.

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
216
217
218
219
220
public static int getColorGain ()
{
int gainFound = 0;
int upperBox = 4,096;
int lowerBox = 0;
int media = 0;
int halfValue;mientras que (gainFound == 0)
{
media = ((upperBox – lowerBox) / 2) + lowerBox;
/ / Possbile no más lejos Halfing
if (media == lowerBox)
{
gainFound = 1;
}
más
{
set_gain (REG_INT_RED_LO, medio);
set_gain (REG_INT_GREEN_LO, medio);
set_gain (REG_INT_BLUE_LO, medio);
performMeasurement ();
halfValue = 0;halfValue = Sistema de Matemáticas Max (halfValue, get_readout (REG_DATA_RED_LO))..;
halfValue = Sistema de Matemáticas Max (halfValue, get_readout (REG_DATA_GREEN_LO))..;
halfValue = Sistema de Matemáticas Max (halfValue, get_readout (REG_DATA_BLUE_LO))..;si (halfValue> 1000)
{
upperBox = medio;
}
else if (halfValue <1,000)
{
lowerBox = medio;
}
más
{
gainFound = 1;
}
}
}
devolver la mitad;
}
}
}

Por último, las líneas 175-220 intenta establecer una ganancia adecuada para cada color. Esto será llamado 3 veces porque cada color tiene una sensibilidad diferente. Usted puede ser creativo aquí y venir con su propio algoritmo que se adapte a su aplicación específica. Si usted tuviera un ambiente controlado, en teoría, esto sería muy simple.

Fuente aqui

 

Automatizacion del hogar usando Android


Gracias a Tasker disponible en Google Play y tres componentes de automatización cuyo precio en total puede rondar los 300$ es posible construir un sistema domótico muy completo y versatil que ademas podremos controlar desde nuestro terminal Android por medio de ordenes vocales.

Si usted no termina de creérselo puede ver el video de la solución global aqui:


Tasker
Tasker podria ser la mejor aplicación que puedes instalar en tu dispositivo Android pues permite automatizar absolutamente todo lo que se te ocurra(todo que se se pueda programar), y todo sin tener que hablarle(aunque se puede tambien con ayuda de autovoice)  ,lo cual en muchos apectos se asemeja a Siri salvando las distancias.
Obviamente, una aplicación tan completa también es algo compleja de usar, pero una vez aprendamos cómo crear la primera tarea automática en Tasker, dicen que no se pude parar.

Como muestra, os dejo el vídeo de lo que se puede hacer con esta “pequeña” aplicación:

Como complemento de este fantástico sw   de este proyecto el autor    ha usado  el siguiente  software  en la solución :

  • Tasker
  • AutoVoice
  • AutoRemote
  • AuHomationHD
  • Yatse
  • XBMC
  • Netflix
  • YouTube

Y a continuaciónn  hablamos de todo el hardware que ha hecho  posible este interesantisimo proyecto:

VERALITE HOME CONTROLLER

El Veralite es actualmente una forma más fácil para hacer su casa un hogar inteligente. Esta pasarela de Z-Wave te permite controlar fácilmente las luces, cámaras, termostatos, cerraduras, sistemas de alarma, y más. El Veralite también le permite recibir al instante mensajes de texto personalizados y alertas de correo electrónico para cualquier situación. Después de tener esta puerta de enlace instalado, usted tiene acceso a comandos y puede adaptar las funciones de control de Veralite desde su PC o Mac, o con una aplicación fácil en su teléfono inteligente o una tableta, lo que permite agregar inteligencia a casi cualquier cosa electrónica en su hogar.

Hardware

  • CPU 500 MHz MIPS SoC
  • Flash Memory: NAND 32 MB
  • DDR2 Memory  64 MB
  • USB Port 1
  • WAN Port 1
  • Z-Wave: Built-in with internal antennae
  • Dimensions:116mm x 95mm x 44mm (HxWxD)
  • Power Supply Input AC 100 ~ 240v, 50~60Hz/Output DC 12V/2A/Battery Pack 4 AA batteries (included)

Intermatic HA03C 

Intermatic HA03C es un módulo inalámbrico plug-in de la lámpara que proporciona un control local y remoto de encendido / apagado y regulación de luces (lámparas incandescentes). Este módulo de lámpara Plug-In tiene la capacidad de anulación manual. La luz LED del módulo muestra la retroalimentación del controlador durante la instalación que el dispositivo está funcionando.Por ulymo la configuración de este dispositivo es sencilla.

Especificaciones técnicas

  • Controles lámparas ordinarias utilizando el mando a distancia
  • Control inalámbrico de hasta 100 pies
  • 300 vatios
  • 120V AC, 60Hz
  • Alcance de temperatura: 0 a 60 grados C

INTERMATIC HA02C HOME SETTINGS WIRELESS PLUG-IN APPLIANCE MODULE

El HA02C Intermatic es un módulo de iluminación inalámbrico plug-in de dispositivo que proporciona un control local y remoto de encendido / apagado. Su enchufe de diente de alta resistencia 3 y receptáculo controles electrodomésticos y la iluminación de hasta 15 amperios. Este módulo de aparatos plug-in tiene la capacidad de anulación manual. La luz LED de este módulo muestra la retroalimentación del controlador durante la instalación que el dispositivo está funcionando. Configuración de este dispositivo es sencillo pero más información para el HA02C se encuentra aquí en el manual del producto.

Especificaciones técnicas

  • 8,3 amperios de tungsteno
  • 1200 vatios inductivos
  • 120VAC, 60Hz
  • 1/2 caballos de fuerza
  • Alcance de temperatura: 0 a 60 grados C
  • Proporciona control inalámbrico de hasta 100 pies

 Intermatic CA600 p

El Intermatic CA600 pared Dimmer es un dispositivo compatible con Z-Wave que ofrece una capacidad local y remoto de encendido / apagado y regulación. Luces se desvanecen hacia arriba o hacia abajo cuando se ha activado o desactivado y estos niveles de luz se configuran pulsando y manteniendo pulsado el balancín hasta que se alcance el nivel de luz deseado. Este interruptor en la pared está hecha para el uso con lámparas incandescentes y halógenas y luces. Se puede utilizar en opciones de iluminación 4-forma convencional de 3 vías o, lo que le da la capacidad de controlar las luces de múltiples ubicaciones. Cada CA600 Z-Wave pared Dimmer se completa con tres carcasas intercambiables (negro, marfil y almendra claro).

 

Para mas informacion  pulse aqui