Ejemplo de manejo de un display LCD con Netduino

Si desea mostrar una mejor  presentación  superior a hacer  parpadear  LED’s, un módulo LCD es una buena opción dado que es muy fácil  de   programar, y por lo general, también  muy  asequible.

Los LCD’s vienen en diferentes tamaños siendo los mas normales son de 2 filas numéricos ( es decir sólo dígitos) , pero también son frecuentes  recientemente los módulos de  40×4  de matriz de puntos alfanuméricas.  También existen LCD gráficos, que van desde módulos con resoluciones pequeñas (por ejemplo, 122×32 o 240×128 píxeles) a más profesionales pantallas LCD (por ejemplo, 5 “o 7″)

En este post vamos  a usar simplemente LCD alfanuméricos , los  cuales en su mayoría  se construyen alrededor del  famoso  chip de Hitachi  ,  HD44780 o controlador compatible, dado    que lo habitual es que   todos ellos utilizan la misma interfaz.

LCD alfanuméricos se controlan mediante un puerto paralelo de 8 bits, y algunos hilos mas para control (que controlan la transferencia de datos a través del puerto paralelo), pines para controlar el contraste y luz de fondo (si  le quedan puertos disponibles), y  por supuesto ,  los dos hilos para alimentación y tierra.

En la siguinte tabla podemos ver un ejemplo de configuracion para controlar un display  LCD,  con los bit de  salida completos:

 

LCD Pin Number Symbol Netduino Pin Description
1 VSS GND Ground
2 VDD 5V Logic voltage
3 V0 10K Pot Leg 2 op voltage for LCD. Controls color/contrast
4 RS D12 Register selector
5 R/W GND Low means write, so you can just ground it
6 E D11 Chip enable
7 DB0 D9 Data Bit 0
8 DB1 D8 Data Bit 1
9 DB2 D7 Data Bit 2
10 DB3 D6 Data Bit 3
11 DB4 D5 Data Bit 4
12 DB5 D4 Data Bit 5
13 DB6 D3 Data Bit 6
14 DB7 D2 Data Bit 7
15 LED(+) Resistor to 5V Backlight LED Anode
16 LED(-) Ground Backlight LED Cathode

 

El puerto paralelo también se puede utilizar en el modo de 4 bits, el envío de los datos de 8 bits en dos acciones de escritura,lo cualo ahorra puertos I / O, pero toma más tiempo para actualizar la pantalla LCD.

Hay una excelente biblioteca disponible en CodePlex (con una buena introducción en el blog del autor) para controlar los módulos LCD.

Esta biblioteca hace que muestrar el texto en una pantalla sea  tan fácil como llamar a un método de escritura con la cadena deseada.  Se utiliza un proveedor de patrón para permitir diferentes escenarios de conexión, como conexion directa en los pines GPIO, utilizando un registro de desplazamiento o el uso de un expansor I2C. Además  si usted quiere usar otro escenario, puede añadir su propio proveedor.

lcd

En la imagen se ver un módulo LCD 20×2  conectado directamente a los pines GPIO de un Netduino+ utilizando el puerto paralelo en modo de 4 bits.

Las conexiones se realizan en un circuito, ya que esto hace que sea un poco más fácil de poner todos los cables juntos.

El código de ejemplo proporcionado con la biblioteca contiene un enlace a un esquema muy útil en el sitio web de Arduino.

 

Recuerde conectar la alimentación del módulo LCD al 5V del Netduino pues  la alimentación de 3.3V no es suficiente y  deja en blanco el LCD.

 

La biblioteca contiene un ejemplo sencillo de cómo utilizar la biblioteca.  Se inicializa el LCD, muestra la obligatoria “Hola mundo” y luego entra en un bucle que muestra los milisegundos desde el restablecimiento.Usa los pines GPIO directamente, por lo que hay que cambiar de proveedor como se ve en el ejemplo:

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
public class Program
{
    public static void Main()
    {
        // create the transfer provider, use direct GPIO provider
        // Initialize the library with the numbers of the interface pins
        // Use wiring shown here http://arduino.cc/en/uploads/Tutorial/lcd_schem.png
        var lcdProvider = new GpioLcdTransferProvider(Pins.GPIO_PIN_D12,    // RS
                                                        Pins.GPIO_PIN_D11,    // ENABLE
                                                        Pins.GPIO_PIN_D5,     // D4
                                                        Pins.GPIO_PIN_D4,     // D5
                                                        Pins.GPIO_PIN_D3,     // D6
                                                        Pins.GPIO_PIN_D2);    // D7
 
        // create the LCD interface
        var lcd = new Lcd(lcdProvider);
 
        // set up the LCD's number of columns and rows: 
        lcd.Begin(20, 2);
 
        // print a message to the LCD.
        lcd.Write("Hello world!");
 
        while (true)
        {
            // set the cursor to the first column on the second line
            lcd.SetCursorPosition(0, 1);
 
            // print the number of milliseconds since reset:
            lcd.Write((Utility.GetMachineTime().Ticks / 10000).ToString());
 
            Thread.Sleep(100);
        }
    }
}

Fuente   aqui

El creador de Arduino se defiende

Cuando se inició el proyecto Arduino, los cinco co-fundadores ( David Cuartielles, David Mellis, Tom Igoe, y Gianluca Martino) decidieron crear una empresa que sería  la propietaria de las marcas comerciales y gestionaría  la parte comercial de Arduino , de modo que los fabricantes construirían  y vendería placas  y  Arduino obtendrían una regalía de ellos como en muchos otros negocios, como en el mundo de la moda.

Esto ocurrió en abril de 2008 cuando Arduino LLC fue fundada y en los estatutos de la empresa se especificó que cada uno de los cinco fundadores transferiría a esta empresa cualquier propiedad de la marca Arduino. A finales de 2008, cuando Arduino estaba a punto de registrar la marca en los EE.UU. y en todo el mundo sin ningún aviso previo, la compañía de Gianluca Smart Projects – el  pricipal fabricante de placas de Arduino – se adelantó y registró el nombre Arduino en Italia y mantuvo esta noticias  oculta por casi dos años.

Después de que el proceso de registro en los EE.UU. había terminado,  el  abogado de los fundadores  trató de extender la marca para el resto del mundo, cuando se dio cuenta de que alguien había registrado ya en Italia.  Gianluca les aseguró que esto se hizo para proteger la  inversión colectiva de los fundadores ..

A medida que el proyecto tubo más éxito y las ventas aumentaron, los intentos de recuperar el control del registro de la marca italiana se hizo más y más difícil con las demandas cada vez mayores que se le  hacían a los fundadores  mientras Gianluca les  vetó efectivamente para otros fabricantes o conseguir cualquier inversión externa. Los fundadores hicieron  progresos con Arduino creando  mucha innovación, empujando los límites de hardware de código abierto, la contratación de un montón de gente con talento de todo el mundo y en última instancia la construcción de una comunidad increíble en todo el sitio web arduino.cc.

Ni que decir tiene, se hizo cada vez más difícil trabajar con un socio que era tan reacio a permitir que cualquier mejora significativa así como la  expansión de la empresa. Trataron  durante mucho tiempo  de reducir el costo de los productos a los clientes, pero las  manos de los fundadores  estaban atadas.

En julio pasado después de otra ronda de conversaciones, y otra solicitud creciente de dinero, los fundadores se vieron obligados a pedir a sus abogados  que empezaran  a enviar cartas a empresas ,  delinear las diferencias y solicitar que la marca fuese devuelta  a sus fundadores.

Hace un año y sin explicación, empresa de fabricación de Gianluca dejó de cooperar con los fundadores y se detuvo de manera unilateral las regalías que pagaban. Así que si la gente compró una placa Arduino fabricado en Italia en el último año pensando que estaban apoyando el proyecto, deben saber que los fundadores  no recibieron ningún dinero por ello a pesar de que han diseñado, documentado, mantenido y apoyado esos productos. (Los otros fabricantes todavía están a nuestro lado.)

En noviembre pasado, SmartProjects nombrado un nuevo director general, el Sr. Musto, quien cambió el nombre a la empresa a Arduino Srl y creó un sitio web llamado “Arduino” copiando los gráficos y el diseño  de los  fundadores , pues  afirma haber inventado Arduino sin mención de los 4 fundadores. Incluso comenzó la impresión de esta nueva URL en todas las nuevas placas.

El colmo llegó hace unas semanas, cuando esta persona  concedió  entrevistas a varios periódicos italianos afirmando ser el nuevo director general de “Arduino” , lo que implica que uno de los fundadores   renunciaba a dedicarme a actividades “no lucrativas”:los fundadares se  quedaron  impactados y respondieron a sus reclamos tratando de mantener el ruido al mínimo y evitar daños en la comunidad y el proyecto, de modo que ahora los asuntos están en manos de los abogados de ambos lados del Atlántico.

Por suerte, Massimo Banzi   hace tres años, empezó a ampliar las formas en que Arduino apoya en sí:  trabajando con grandes empresas para asesorarles sobre cómo construir para la comunidad c participando en proyectos de investigación internacionales, corriendo una tienda en línea muy exitosa, lo cual les  permitió crecer independientemente de venta de las placas.

Massimo Banzi   pensó  que el  hardware se vuelve más y más de un producto, de modo que los modelos de negocios deben evolucionar hacia servicios, plataformas en la nube, la educación, y todo el proceso de ayudar a los responsables políticos son profesionales.

Ahora los fundadores  estan trabajando con los fabricantes de todo el mundo, y estan  lanzando nuevos productos emocionantes en los campos de la educación y la IO. Estan muy tristes de que estas cuestiones se hayan hecho públicas para confundir a la comunidad, pero no han tirado la toalla aún y   siguen  innovando pretendiendo  eguir ampliando las fronteras de hardware abierto como lo han ido  haciendo desde hace 10 años.

Como es habitual  el único santuario de la comunidad Arduino es arduino.cc y se puede ver en day.arduino.cc que la próxima Jornada Arduino el 28 de marzo va a ser un evento mundial increíble en el que van   a desvelar mucho cosas de lo mas interesantes….

Massimo Banzi

MASSIMO BANZI

Massimo Banzi es el co-fundador del proyecto Arduino.Él es un diseñador de interacción, Educador y Open Source Hardware defensor.

 

 

 

 

Fuente  aqui

Envío de tweets con Netduino+

 Hemos hablado en muchísmas ocasiones en este blog   de Netduino Plus,  una  placa pequeña (pero poderoso) basado en un microprocesador Atmel 32 bits con el mismo factor de forma que un Arduino   que ademas  puede ejecutar programas escritos en C# para Micro de .NET Framework y la versión “Plus” añade un puerto 10/100 Mbps Ethernet, proporcionándole un dispositivo compatible con redes muy potente para alrededor de $59 USD.

¿Qué puede hacer con él? Mucho, realmente, como  puede ver  en los foros Netduino:tiene acceso a conexiones de red mediante System.Net.Sockets, puede realizar peticiones HTTP mediante System.Http, y hay incluso algunas implementaciones de servidores web ligero disponibles(Neomilka Web Server)

Lo único que no pude encontrar fácilmente  es una biblioteca para Twitter, por lo que el autor   inspirándose   en la  Biblioteca Tweet para Arduino, que envía tweets a través de un sitio web externo, presumiblemente para evitar aplicar OAuth de Arduino,  decidió  hacer que  Netduino se comunique con la API de Twitter directamente, lo que significa que no son necesarios  webs ni proxies .

Resumen de OAuth

Twitter actualmente requiere que todas las llamadas API sean autenticados con OAuth. Para comunicarse con la API de Twitter, usted debe primero registrar una aplicación para obtener los valores clave de consumo y del consumidor secreto necesarios. Llamadas a la API cuenta específicas requieren un Token de acceso y el Token de acceso secreto, que se generan después de dar un permiso de la aplicación para acceder a tu cuenta. Un Token de acceso y acceso secreto Token se proporcionan automáticamente por su cuenta cuando se registre una aplicación.

Cada solicitud de API debe tener un encabezado de autenticación con ciertos parámetros OAuth. Uno de estos parámetros es la firma OAuth, que se genera mediante la creación de un valor HMAC-SHA1 hash del método HTTP, la URL normalizada y variables POST, los otros parámetros OAuth, (o parámetros de cadena de consulta de solicitudes GET). Esta firma está codificada en una cadena Base64.

Generación de la firma OAuth es la parte más cálculo intensiva de hacer llamadas a la API. He encontrado que tarda alrededor de 500-1500ms para generar la firma en un Netduino Plus dependiendo de los parámetros de entrada.

También cabe mencionar que uno de los parámetros de OAuth es la fecha y hora actuales con formato como un timestamp de Unix. Sin una fecha y hora exacta fallarán todas las solicitudes de API, así que es importante para asegurarse de que se actualiza el reloj de la Netduino antes de hacer llamadas a la API.

Implementación

Para este proyecto, se usan  las siguientes bibliotecas de terceros:

  • SHA/HMAC Digest clase, con una modificación para manejar adecuadamente secretos valores > 84 caracteres de Elze Kool
  • La clase NearlyGenericArrayList del proyecto MicroLinq
  • El método NTPTime publicado por Chris Seto en los foros de Netduino

La clase OAuth creada para este proyecto implementa la mayor parte de la especificación OAuth, con unos accesos directos adoptadas ahorrar tiempo y programa espacio de procesamiento.Por ejemplo, asume que URLs han sido normalizadas correctamente antes de que se pasan al método OAuth.GetOAuthRequest.

La clase TweetBot se ha separado en dos archivos diferentes: TweetBot.cs para la estructura de la clase principal y TweetBot.HTTPRequests.cs para las solicitudes HTTP. Mientras que actualmente hay sólo un método de solicitud HTTP, esta estructura ayudará a asegurarse de que el código sigue siendo fácil de entender como desarrollo continúa.

TweetBot instancias tendrán un evento DebugMessage que se puede conectar a imprimir los mensajes de depuración a un puerto serie, un archivo de registro en una tarjeta SD, etc..

Actualmente, se realizan todas las operaciones HTTP sincrónicamente pero probablemente puede modificar que ejecuta asincrónicamente bastante fácilmente. Además, actualmente hay muy poca errores así que si no puede alcanzarse la API de Twitter o si entras en las teclas de acceso mal probablemente obtendrá una excepción no controlada. Tal vez sea una buena idea para envolver todo método TweetBot llamadas en un bloque try/catch.

Utilizando la clase TweetBot

Uso TweetBot es bastante sencillo. En primer lugar, especificar sus datos de cuenta y aplicación en algún lugar en su programa.

Debe primero registrar una nueva aplicación para conseguir un Consumer Key y Consumer Secret. Una vez que haya completado el procedimiento de registro, abra la página de Aplicaciones de Twitter, ver los detalles de su aplicación y haga clic en el enlace que dice “Mi Token de acceso”. Esa página mostrará de su cuenta usuario acceso Token y secreto Token de acceso de usuario.

Con el fin de crear las solicitudes válidas de OAuth, reloj de la Netduino debe establecerse con la hora correcta. Aquí hay un ejemplo de los foros Netduino para recuperar el tiempo actual de un servidor NTP. (Este código también está incluido en la aplicación de demostración).

Para enviar un tweet, crear una nueva instancia de la clase TweetBot y llamar a su método SendTweet:

Eso es todo! SendTweet devuelve true si el mensaje fue enviado con éxito.

Programa de demostración

El programa demo incluido con este proyecto crea una serie de “consola” en puerto COM1 el Plus’ Netduino funcionando a 115200bps. Este puerto utiliza pin digital 0 en el N + para Rx y pin 1 para Tx( el autor ha usando un Bus Pirate para comunicarse con el puerto serial de la Netduino, pero también puede usar un dispositivo FT232R (o similar) a 3.3V o un convertidor de nivel).

Bus Pirate

Tres conexiones son necesarias:

  • Autobús pirata Gnd a Netduino Gnd
  • Autobús pirata Tx a Netduino Rx
  • Bus Pirate Rx de Tx Netduino

Consulte el manual de Bus Pirate de números pin específico como pueden variar entre los dispositivos. Una vez que todo está conectado y encendido, configurar el Bus Pirate para 115200bps UART con “Normalidad” (3, 3V / Gnd) salida. La secuencia de comandos es m, 3, 9, 1, 1, 1, 2.

A continuación, inicie la macro “Puente transparente” escribiendo “(1)” (con el paréntesis) y luego “y” aceptar la advertencia. Esto configura el Bus Pirate para actuar como un puente UART transparente, así los caracteres de entrada se envían a la Netduino y todos los resultados de la Netduino se muestran en su terminal.

Consola demo

Cuando se ejecuta el programa de demostración, un mensaje de ayuda se escribirán en el puerto serie. Si se conecta después de que se ha enviado el mensaje inicial, sólo tienes que escribir “?” y pulse enter para verlo otra vez.
Para enviar un tweet, tipo “p < mensaje >” y pulse enter. También puede omitir el mensaje a enviar un mensaje genérico de “Hola desde un [OEMString]!”. (Tenga en cuenta que si intenta enviar el mismo mensaje varias veces probablemente obtendrá un error de “mensaje repetido”).
Si todo sale bien, se registrará su mensaje en Twitter desde tu cuenta:

Código

 Este proyecto está ahora en CodePlex: MicroTweet – Twitter OAuth biblioteca API para la Micro de .NET Framework

Como software de Netduino, este código está liberado bajo la licencia Apache 2.0.

 

 

 

Fuente   aqui

Desarrollo de aplicaciones basadas en twitter

Twitter  es un servicio de microblogging, con sede en San Francisco, California, con filiales en San Antonio (Texas) y Boston (Massachusetts) en Estados Unidos.   Desde que Jack Dorsey lo creó en marzo de 2006, y lo lanzó en julio del mismo año, la red ha ganado popularidad mundialmente y se estima que tiene más de 500 millones de usuarios, generando 65 millones de tuits al día y maneja más de 800 000 peticiones de búsqueda diarias. Ha sido apodado como el “SMS de Internet”.

La red permite enviar mensajes de texto plano de corta longitud, con un máximo de 140 caracteres, llamados tweets, que se muestran en la página principal del usuario. Los usuarios pueden suscribirse a los tuits de otros usuarios  – a esto se le llama “seguir” y a los usuarios abonados se les llama “seguidores”, “followers“. Por defecto, los mensajes son públicos, pudiendo difundirse privadamente mostrándolos únicamente a unos seguidores determinados. Los usuarios pueden tuitear desde la web del servicio, con aplicaciones oficiales externas (como para teléfonos inteligentes), o mediante el Servicio de mensajes cortos (SMS) disponible en ciertos países.

Twitter ha crecido  tanto  no solo   a nivel de nuevos   usuarios  sino  también  gracias   a las  gran cantidad  de   aplicaciones ( +50.000) que han sido desarrolladas basadas en la  plataforma.

Para    empezar  a desarrollar apps     que exploten o   usen el API  de Twitter  el sitio indiscutible de referencia es  el portal  de oficial  de desarrollo de twitter :  http://chirp.twitter.com/.

 

twiiter

 

Con  todas   estas herramientas  se busca  mejorar  el  desarrollo Móvil de  una forma más racionalizada . Sabiendo de primera mano que la construcción de grandes aplicaciones móviles es difícil pues  los desarrolladores se enfrentan con muchos de los mismos desafíos día tras día que han de afrontar como  son hacer que sus aplicaciones sean  amigable, miles de  pruebas , manejo de  descargas, abordar nuevos usuarios, feedback de los usuarios, entender el crecimiento y monetización de sus aplicaciones, donde cada desafío presenta un conjunto único de obstáculos.

La pasión del equipo  de Twitter  es la construcción de herramientas que hagan la vida de los desarrolladores más fácil  ( así como que extiendan  si cabe mas esta red social)  . Es por esto que han  construido Fabric: una  multi-plataforma de desarrollo móvil modular que le puede ayudar a resolver cualquiera – o todos – de estos desafíos y construir las mejores aplicaciones con el menor esfuerzo.

Fabric  , tiene una serie de herramientas a su disposición inmediata que han organizado en  varios  SDKs en diferentes “kits” para hacerlos modulares. Puede instalar sólo el kit que necesita en este momento y agregar más Kits más tarde, cuando usted lo necesite.

Los  SDKs móviles, estan   muy desfragmentados  pues en los últimos años, ha habido  una explosión de SDKs móviles – cada uno con el objetivo de resolver un problema específico. Si bien esto dió a los desarrolladores más soluciones y opciones para hacer frente a los retos individuales, un nuevo problema ha surgido: la instalación y la gestión de una amplia gama de SDK puede ser pesada y compleja.

Fabric  resuelve este problema mediante la combinación de  siete  SDKs bajo un mismo techo y organizándolos en tres kits:

  • El Kit Crashlytics.
  • El Kit de Twitter.
  • Y el Kit MoPub.

Fabric está profundamente integrado con su flujo de trabajo existente, por lo que puede gestionar todo su conjunto de herramientas sin tener que salir de su entorno de codificación preferido.Apoyan  Xcode y todos los principales entornos de desarrollo para Android

Y construir herramientas, también

A medida que crecen sus aplicaciones, es posible que necesite ampliar su conjunto de herramientas para satisfacer sus necesidades, ya que están mejorando la estabilidad de su aplicación, el crecimiento de su base de usuarios, o obtener beneficios de su aplicación.

Con  Fabric  puede instalar cualquiera de los kits dentro de su flujo de trabajo  .

twitter1

Para cada equipo, han  reducido la instalación por lo que es fácil  ponerse en marcha en cuestión de segundos.

 Kit Crashlytics

Con Fabric, usted tiene acceso a una colección de módulos de características individuales llamado “Kits”. El Kit Crashlytics proporciona una solución mejor en su clase de informes de bloqueo, distribución beta para sus aplicaciones móviles, y análisis de aplicaciones móviles.

Kit Crashlytics para iOS: Kit Crashlytics para iOS ofrece un servicio elegante para capturar los accidentes al tiempo que añade los datos de accidentes más importantes y relevantes de su elección. Comience con el plugin Tela para incluir el Kit Crashlytics en su aplicación;simplemente incluyendo Crashlytics permitirá accidente informar de inmediato – no hay ningún código extra para escribir.

Kit Crashlytics para Android :El Kit Crashlytics para Android proporciona APIs simples para reportar accidentes y anotar con la información del usuario y otros detalles. Comience con el plugin Tela para incluir el Kit Crashlytics en su aplicación; simplemente incluyendo el Kit Crashlytics permitirá accidente informes enseguida- hay ningún código extra para escribir.

Crash Reporting:Los informes de choques por Crashlytics están diseñados para conseguir que las respuestas que necesita rápidamente. En lugar de lo que muestra a la traza de la pila, se analizan los hilos de de-priorizar las líneas que no importan además de destacar los interesantes. Esto hace que la lectura pila traza más fácil, más rápido y más útil.

Beta por Crashlytics :Beta por Crashlytics es un conjunto de herramientas multiplataforma construido para hacer la distribución beta tan fácil e intuitivo como sea posible. Nuestro plugin se guiará a través de unos pocos pasos para obtener sus manos app testers ‘lo antes posible.

Respuestas:Habilitación respuestas le da una visión en tiempo real de la experiencia de las personas en su app- de la cantidad de tiempo que dedican a usarlo para la frecuencia con que lo experimentan bloquee.

Tweet Incrustado

La forma más fácil de llevar el contenido de Twitter en su aplicación.La creciente base de usuarios de una aplicación y retener a los usuarios finales pueden ser un reto para cualquier desarrollador. Para mantener a los usuarios que participan, necesita rico contenido, único que se siente natural a la experiencia de su aplicación.

Mantenga Usuarios Devolución

Tweet Incrustado le da acceso inmediato a contenido atractivo, en tiempo real disponible únicamente en Twitter. Ya se trate de relatos en primera persona de las últimas noticias, anuncios de productos o actualizaciones de las figuras públicas, se puede visualizar fácilmente este contenido dentro de su aplicación.

Es increíblemente simple ya que estan obsesionados con hacer la vida de los desarrolladores fácil, por lo que han hecho Tweet Incrustado simple de implementar. Puede agregar un Tweet con sólo unas pocas líneas de código.

Increíblemente simple

No hay necesidad de manejar JSON análisis, almacenamiento en caché o representación de imágenes. Han  hecho todo el trabajo  pesado para usted. Puede mostrar los tweets incluso si su usuario no está conectado en Twitter – al igual que en la web.

Combina perfectamente en su App:Entendemos que el contenido de Twitter necesita sentir nativa de su aplicación para que su experiencia de marca es consistente.

Combina perfectamente en su App

Han  hecho fondo y de texto colores de Tweets Incrustado fácilmente personalizable.

Mopub 

MoPub es servidor de publicidad má importantes del mundo para los desarrolladores móviles, diseñado para atraer más ingresos por publicidad a través de una única solución. La plataforma integral le permite obtener beneficios económicos con los anunciantes directos, sus socios de la red de anuncios y conecta a miles de anunciantes de alta calidad en nuestro intercambio de publicidad, MoPub mercado.

MoPub asegura a maximizar sus ingresosUsted tiene el poder para trabajar con las fuentes de publicidad que tengan más sentido para su negocio. Lo mejor de todo, MoPub asegura a maximizar sus ingresos al mostrar el anuncio del anunciante que paga más alta.

Potente Ad Serving para Campañas directos

MoPub ofrece ayuda poderosa que sirve para soportar todas las características principales de la gestión de campañas, elaboración de presupuestos, y de orientación que necesita para hacer crecer su negocio.

Tango
TheScore

Desde ofertas de anunciantes directos a sus propias campañas de promoción, se puede optimizar al máximo su experiencia de usuario con sofisticada segmentación geográfica, palabra clave-focalización y límites de frecuencia en Android, iOS y web móvil.

Apoyan todos los formatos, incluyendo anuncios nativos , vídeos , intersticiales, banners y formatos personalizados.

Apoyamos todos los formatos

Flexibilidad para trabajar con cualquier red de anuncios

Mediación red de anuncios de MoPub le permite servir anuncios de cualquier red a través de un único SDK.

Redes de anuncios MoPub

La mediación de MoPub cuenta con aprovechar nuestra tecnología de ad serving para que pueda asignar cada impresión de anuncio a la red ad derecha, optimizar sus ingresos. También le damos la posibilidad de trabajar con cualquier red utilizando SDK de terceros y adaptadores, muchos de los cuales son pre-construidos.

Más ingresos de miles de anunciantes del mercado

MoPub opera la mayor bolsa del mundo en tiempo real de licitación, MoPub mercado, para teléfonos anuncios in-app. Directamente integrado en la plataforma, Plataformas de la Demanda (DSP) en MoPub mercado compiten con sus socios de la red existentes para darle el mejor precio posible para su inventario.

MoPub mercado le da más control

MoPub mercado le da más control y más transparencia sobre cómo obtener beneficios económicos, para que pueda centrarse en la creación de aplicaciones muy buenas. Más información sobre cómo funciona MoPub mercado .

MoPub ya es de confianza por muchos de los mejores desarrolladores:

Clientes MoPub dejaron
Clientes MoPub derecho

 

 

Mas  información en  https://get.fabric.io/

 

Desarrollo de aplicaciones para Android completamente en Python

En la conferencia EuroPython en Florencia, Italia, dio  una jornada de formación  de medio día sobre el desarrollo de aplicaciones Python en Android. En total fue de 240 minutos de duración y se llevó a cabo el martes 03 de julio 2012 a las 09:00.


Crédito de la foto: Stefan Kögl

El objetivo de estas jornadas   era mostrar cómo empezar a desarrollar aplicaciones Android completos utilizando sólo Python. Diferentes tecnologías fueron  mostrados, incluyendo a base de PySide QML interfaces gráficas de usuario utilizando el puerto Necessitas Qt y el enfoque basado en SL4A Py4A /, que se puede combinar con WebKit y reutilizar los marcos Python web de Android.

Mientras que Android ya tiene una buena SDK fuera de la caja, poder utilizar Python en lugar de Java es una gran ventaja para algunos desarrolladores – que permite tiempos de respuesta más rápidos, y la reutilización de las bibliotecas de Python. Python en Android usa una acumulación CPython nativo, por lo que su rendimiento y compatibilidad es muy bueno. Combinado con PySide (que utiliza una compilación nativa Qt) y el apoyo de Qt para la aceleración OpenGL ES, puede crear interfaces de usuario fluida incluso con Python.

Las aplicaciones basadas en PySide resultantes se ejecutan en Android, pero también, al menos en Mac OS X, Windows, Linux y Maemo y MeeGo – básicamente todas las plataformas en las que Qt está disponible. Los / las aplicaciones basadas en Py4A SL4A se ejecutan en Android solo, pero será capaz de utilizar las API de Android-específicos. Ambos enfoques pueden combinarse también.

Descargas Código

Prepárese

Para empezar, tienes que descargar algunos paquetes a su ordenador principal, para que pueda desarrollar y desplegar sus paquetes de Python para su dispositivo Android:

Video (segunda parte solamente)

Desafortunadamente, debido a problemas técnicos, la primera parte del vídeo no está disponible en línea. La segunda parte se puede encontrar aquí:

Las preguntas de la ruptura

Cómo instalar el emulador de Android

No se olvide de instalar las “Herramientas de la plataforma Android” a través de $SDK/tools/android !

  1. http://developer.android.com/tools/devices/
  2. $ SDK / herramientas / androide avd # “dispositivos virtuales android”
  3. crear emulador
  4. iniciar emulador
  5. “Adb devices” muestra emulador también

Dónde obtener SL4A para su dispositivo Android

A continuación, para instalar a través de adb:

  adb instalar Descargas / sl4a_r5.apk
 adb instalar Descargas / PythonForAndroid_r5.apk

Cómo instalar PySide en Mac OS X

Vea las instrucciones en el Proyecto Wiki Qt: Binarios PySide para Mac OS X

Otras instrucciones útiles

Ctypes de Construcción para el PGS4A

  hg clone https://code.google.com/p/android-python27/

Mira en README, copie el entorno configuración de la variable + arreglar caminos:

  environment.sh fuente
 bootstrap.sh fiesta
 build.sh fiesta
 / / lib.linux-i686-2.7 / _ctypes.so / ruta de compilación cp Python / a / pgs4a / private /
 cp -rpv Python / lib / ctypes ~ / src / pgs4a-0.9.4 / private / lib /
 cd / ruta / a / pgs4a /
 rm -rf / ctypes / test / lib privado

Ejecución de Python desde shell ADB

  /data/data/com.googlecode.pythonforandroid/files/python/bin cd
 export LD_LIBRARY_PATH = $ LD_LIBRARY_PATH: /data/data/com.googlecode.pythonforandroid/files/python/lib

Notas PGS4A

  • Cambio “android-8″ a “android-15″ para instalar la plataforma adecuada
  • Enlace simbólico “android-15″ de SDK de Android en pgs4a / android-sdk / plataformas
  • Para inicializar: python android.py configure mygame (escribirá un archivo .android.json )
  • Para construir y desplegar: python android.py build mygame release install

Notas Py4A

  http://code.google.com/p/python-for-android/wiki/BuildingPython
 exportación ANDROID_NDK = ~ / pkg / android-ndk-r8 /
 export PATH = $ PATH: $ ANDROID_NDK: $ ANDROID_NDK / toolchains / arm-linux-androideabi-4.4.3 / prebuilt / linux-x86 /

Enlaces

 

 

Fuente  aqui

Un monitor con Netduino

Las ratas se comen cualquier cosa

Hace unos años stewlg  cometío el error de almacenar alimentos en el sótano de una manera que era inferior a salvo de roedores. Un auge de la población pequeña en ratas se produjo antes de que entendíamos lo que estaba sucediendo. Cuando quitamos todo el acceso a la comida en el final del invierno, introdujimos un hambre cuya pánico después nos leemos en los plásticos roídos sobre todo encerrando alimento.

Rat-vs

Todo esto era malo. Caca de rata y orinar son desagradables. Pero lo peor fue que las ratas desesperadas comiendo el tubo de goma y las juntas dentro de nuestra lavadora. Una helada mañana me vino a encontrar jabonosa hemorragia agua fría de la lavadora y que cubre el suelo de nuestro sótano. De repente comprendí por qué alguien querría un monitor de inundación.

Empezó con un acuerdo con pilas de nueve voltios con una alarma audible.

IMG_5217

Esto es mejor que nada, pero no iba a ser capaz de decirle acerca de los problemas cuando estaba fuera de la ciudad, o, para el caso, cuando  stewlg  estaba en el trabajo. Quería más. En concreto,  quería que se conectara a Nagios(un proveedor de Iot) , que comenzó el seguimiento de unas cuantas unidades de disco duro para mí, pero ha crecido a lo largo de los años en algo que una empresa de tamaño medio que podría estar usando para monitorear su red. Nagios se había convertido en la forma en que llevaba la cuenta de los problemas en la casa. Ya paginado y me envió por correo electrónico, y que mantendrá las métricas y datos históricos.

Lo primero que hizo   stewlg   fue buscar un producto comercial que hizo esto – seguramente alguien más necesitado la misma cosa. Y, de hecho, se ha hecho :

SensorMetrix_225Pound

Mientras escribía este post   costaba  alrededor de 425 dólares de Estados Unidos, que todavía parece ridículo, no importa lo industrial y prueba de balas el dispositivo de seguridad es. Eencontró otra empresa que realizaba este también, pero te cobran un precio similar si no mayor para la misma funcionalidad.

¿No podría hacer todo esto con un Arduino ? Y los Internets de cosas?

¿Por qué Netduino

Miró a Arduino, pero una alternativa menos popular  a  stewlg  le  atrajo: Netduino .

* Ya utilizba .NET para el trabajo.  C # es un ambiente verdaderamente excelente.
* Hilos, eventos, temporizadores
Y, probablemente, lo mejor de todo:
* En el circuito de depuración

 stewlg  hizo lo suficiente programación de objetos incrustados para es apreciado tambien  la posibilidad de desplazarse por el código en un depurador o pausando el  programa de modo que  stewlg  estaba dispuesto a pagar un poco más por esto, y de tolerar algunos compromisos en el medio ambiente para evitar ReSharper withdrawl.

También significó mucho para  stewlg   que, si bien la placa de  netduino  cuesta  $ 60 en lugar de ~ $ 30 para un Arduino, pero Netduino +  venía con Ethernet incorporado y no tendría que futz por ahí con un escudo en el primer día. Esto parecía una introducción más suave más amable con el trabajo Arduino-esque.

Portar NRPE a C # y .NET Micro

Como agradable como C # generalmente es que se necesita trabajar en una versión más pequeña de él para recordarle cuánto hay en las bibliotecas, y no en el idioma adecuado. Trabajando en el marco Micro es como trabajar en una cocina cocina en un pequeño velero cuando estás acostumbrado a una cocina de casa decente .Plantillas? Nop. El formato de cadenas? Nop. LINQ? Hah – que es rico.

Afortunadamente, NRPE es un formato muy simple:

  [2 Byte int16_t] - Número de versión
 [2 Byte int16_t] - Tipo (Consulta / Respuesta)
 [4 Byte u_int32_t] - CRC32 Checksum
 [2 int16_t Byte] - código de resultado (OK, WARNING, ERROR DESCONOCIDO)
 [1024 Char Byte] Buffer

Aun así, tubo problemas con el orden de bytes y el relleno por un poco de tiempoantes de averiguarlo. El mayor problema era conseguir un CRC compatible de trabajo, y al final me terminó portar el código a C # . Hubo otro código por ahí que podría haber funcionado, pero casi todo otro código C # hace buen uso viril, sano, de plantillas y LINQ y todo lo que no se puede tener en 192kb de memoria.

¿Cómo funciona

Usted puede tener una mirada en el código mismo, pero los que no tienen una instalación de Nagios puede gustarte una vista previa de cómo funcionan las cosas, una vez que haya instalado las cosas.

He aquí cómo llamar a los diferentes controles manualmente. Aquí nos estamos quedando check_nrpe (el cliente en nuestro servidor Netduino) de Ubuntu:

  # ./check_nrpe -n -H Noah.doodle.local -c check_temp

 OK - Temperatura = 78.1F 25.6C Humedad relativa = 33,6% | temp_celsius = 25.6000004; 35; 38; 0; 100, relative_humidity = 33,6000023%; 70; 80; 0; 100, temp_fahrenheit = 78,080000686645519; 95; 100,40000000000001; 32; 212
  # ./check_nrpe -n -H Noah.doodle.local -c check_flood

 OK - No detectado agua | water_detected = 0
  # ./check_nrpe -n -H Noah.doodle.local -c check_uptime

 OK - Uptime: 03: 42: 51.2740000 memoria libre: 101364 | uptime_in_seconds = 13371, uptime_in_hours = 3, uptime_in_minutes = 222, free_memory = 101364

Estos son los tres servicios que he escrito hasta ahora. Hay tres partes principales visible aquí:

  • OKAY

El código de resultado. En este caso, el servicio se considera estar en un buen estado.

  • Temperatura = 78.1F 25.6C Humedad relativa = 33,6%

Este es el texto de estado legible que aparecerá en Nagios.

  • temp_celsius = 25.6000004; 35; 38; 0; 100, relative_humidity = 33,6000023%; 70; 80; 0; 100, temp_fahrenheit = 78,080000686645519; 95; 100.40000000000001; 32; 212:

Los valores después de la tubería es de datos de rendimiento que es todo lo registra, y puede ser graficada retrospectiva con diversos plug-ins.

Así que aquí está cómo aparece el servicio de Nagios. Aquí al parecer las ratas están de vuelta y han encontrado su camino más allá de las placas de metal que atornilladas a la parte inferior de la lavadora, o tal vez nuestro primer inodoro piso se ha desbordado y se echan por el conducto de calefacción en el sótano de nuevo (no hay ratas la culpa de eso , a menos que mi trasero puede ser considerada como un barco que se hunde) Y algo ha ido mal con el sensor de temperatura -. tal vez los cables han sido comido por las ratas.

NagiosStatusSlice2

Esto es lo que la salida de línea de comandos sería buscar estos dos casos problemáticos:

  ADVERTENCIA - No se puede leer la temperatura.  |
  CRÍTICA - Agua detecta!  | Water_detected = 1

Aquí hay una captura de pantalla de lo que se puede hacer con los datos de rendimiento recogidos a través del tiempo, desde un tiempo sin emergencias o fallas. Podemos ver un tiempo de actividad en constante aumento, y un uso de la memoria constante (no hay fugas aparentemente):

NagiosUptimeInMinutesAndFreeMemoyDemo

Alguna variación en la temperatura y una humedad casi constante:

NagiosTempAndHumidityGraphDemo

Limitaciones

Es importante señalar que la -n aquí es esencial * *:

  ./check_nrpe -n -H noah.doodle.local -c check_uptime

Esto inhabilita SSL para NRPE. Hay al parecer hay espacio en el Netduino para una gran biblioteca tales . Si esto es esencial para que supongo que se podría envolver dentro de un túnel VPN, etc.

Esto es lo que verás si intenta llamar NRPE sin SSL:

  # ./check_nrpe -H Noah.doodle.local -c check_flood
 Check_nrpe: tiempo de espera de socket después de 10 segundos.

También hay algo de cordura comprobar en el código; Si el tipo de consulta no se reconoce TinyNrpeServer no será capaz de responder a la consulta y no intentará.Un mensaje de depuración dará una pista sobre SSL si está conectado a la consola.

Estabilidad

Si se mira a través del código, puede que le resulte bastante paranoico acerca de los errores y accidentes, con dos reinicios duros independientes en el código. Esto se debe a que he probado el código bastante duro y yo estaba esforzándome por evitar que el dispositivo nunca deje de responder y que necesitan un reinicio.

El dispositivo ahora hace un reinicio duro en dos casos:

1) Cuando se hace una excepción

Hay algunas excepciones que descubrí que se producen normalmente, tales como errores de desconexión de socket, que a menudo pueden ser reclamadas a sin recurrir a reiniciar el dispositivo. Por desgracia, no todos ellos parecían ser recuperable, o al menos no de manera consistente, y en lugar de distinguir, me eligieron para reiniciar el dispositivo. En condiciones normales de funcionamiento son bastante raros.

2) Cuando no se haya recibido una consulta para un intervalo de tiempo configurable

En las pruebas, he probado usando condiciones muy abusivos, pero estas condiciones podría conseguir fácilmente el Netduino en un estado donde no sólo mi código no escuchar las conexiones de red entrantes (que podría decirse que tal vez podría ser mi culpa), pila de red del dispositivo se estrellaría, y sería dejar de responder a un ping, que me pareció mucho menos responsables.

En mi código tengo este tiempo de espera configurado así:

  /// <Summary>
 /// Número de milisegundos antes de que la junta se reiniciará.
 /// </ Summary>
 int const público InactivityTimeout = 60 * UpTimeCheck.SecondsPerMinute * UpTimeCheck.MillisecondsPerSecond;

En otras palabras, si no ha tenido un mensaje entrante en una hora, que va a reinicie por sí mismo. Si usted necesita para poner a punto este intervalo, me ponga esto en al menos dos veces el intervalo de control mínimo. Así que si usted comprueba el dispositivo cada 5 minutos, ajusta esto a por lo menos 10 minutos.

Elegí establecer este mucho más alto que yo pueda ver a través de la gráfica el tiempo de actividad, si esto ocurre en realidad nunca – una hora de inactividad debe ser inequívocamente visible.

Para ser justos con la plataforma Netduino, tengo serias dudas de que nadie va a colgar este servidor bajo una carga de red típica. Una encuesta discreta desde un único servidor Nagios cada minuto o dos no va a gravar seriamente nada. Tal vez en un azul-moon, una excepción a la red se producirá y el dispositivo se reinicie en silencio – si lo hace, usted debe ver que se refleja en los datos de rendimiento de tiempo de actividad, pero aún así disfrutar disponibilidad esencialmente ininterrumpida. No espero a nadie a hacer realidad el dispositivo no responde, y activar el reinicio de la vigilancia. Pero por favor dígame cómo va para usted.

Si tuviera que tomar esto más lejos a  stewlg   le gustaría que un temporizador de vigilancia adecuado en hardware .

Expansión

 stewlg   realmente no necesita nada más que un monitor de inundación, pero  pensó en tirar en al menos otra métrica para obtener el código listo para manejar múltiples cheques, por lo tanto, la comprobación de la temperatura.

Aquí es lo menos que había necesidad de hacer para poner en práctica un cheque:

  /// <Summary>
  /// Un ejemplo de lo mínimo que hay que hacer para poner en práctica un cheque
  /// </ Summary>
  DemoCheck clase pública: NrpeCheck
  {
      public override NrpeMessage.NrpeResultState GetStatus (fuera cadena statusString, fuera Hashtable performanceData)
      {
         performanceData = new Hashtable (); var demoMetric = 20;
         performanceData.Add ("demo_metric", demoMetric);
         statusString = "Demo métrica:" + demoMetric.ToString ();
         // Siempre Ok.
         volver NrpeMessage.NrpeResultState.Ok;
      }
  }

Usted probablemente querrá algo de código condicional para el ResultState, y cualquier métrica que tiene probablemente variar. Pero la adición de ningún tipo de supervisión debe ser fácil, al menos desde el punto de vista TinyNrpeServer.

Si usted sube un sensor que desea añadir, envíeme un correo electrónico con un parche o una solicitud de extracción. Me encantaría este servidor NRPE tienen más supervisión que ofrecer fuera de la caja.

Costo

Así que, si no es de $ 425, ¿qué dedico? Probablemente menos de $ 120.Hubiera sido mucho más barato si supiera  lo que estaba haciendo – esto erael primer proyecto de tipo Arduino y los conceptos básicos eran un misterio para  stewlg  . Terminó probando un montón de cosas que no funcionaron antes de encontrar cosas que funcionaron bien pasablemente.

Circuito

Noé V2

Instalación

Prueba inicial de monitor de inundación

Protoshield cableada

Sensor de Inundación comprobación final

Sensor sujeta con cintas para el pelo

Entre las máquinas

Brilla muy prominente en la penumbra

Primeros DHT-22 cableado

DHT-22 en su lugar

Instalado en la caja de ProyectoIMG_5271

Bibliografía y Apreciación

Para ayuda inestimable, indirectos con el protocolo NRPE núcleo, gracias sobre todo a Andreas Marschke y Sadris . Para la clase DhtSensor, Stanislav “CW” Simicek y todo el mundo en este hilo . Para  cluing en aproximadamente perros guardianes y reinicios duras, las personas en estas discusiones . Chris Walker para la clase Cronómetro (y todo lo demás en Netduino, por supuesto).

El Código

https://github.com/StewLG/NetduinoNrpe

 

 

 

Fuente aqui

Un werable que puede detectar problemas cerebrales

El laboratorio de investigación avanzada C-Lab de Samsung, ha presentado el wearable EDSAP (Early Detection Sensor & Algorithm Package) para detectar infartos cerebrales y otras enfermedades.

El segmento de dispositivos electrónicos conectados, wearables, ha encontrado un gran campo de aplicación en el cuidado de la salud y la actividad física. No hay reloj o pulsera inteligente que se precie que no tenga algún tipo de sensor. ARM tiene diseños usables para cualquier dispositivo conectado y el Curie de Intel presentado en el CES como plataforma completa para dispositivos conectados y su propio sistema operativo de código abierto, muestra la importancia que tomará el sector los próximos semestres.

Hace dos años, un grupo de ingenieros de teléfonos inteligentes y diseñadores de  lavadoras de Samsung Electronics querían un soplo de aire fresco. Así, aplicaron para emprender un proyecto independiente en Creatividad Lab de la compañía, o C-Lab, donde se les da a los empleados la oportunidad de plasmar sus ideas creativas y peculiares en productos y soluciones comercialmente viables. Los ingenieros querían desarrollar una solución que podría detectar la aparición de un ictus mediante el control de las ondas cerebrales. Muchos médicos que consultó con sarcasmo les dijeron, “buena suerte”.

En enero de 2015, Lim y su equipo introdujeron una solución prototipo, el sensor y algoritmo paquete de Detección Temprana (EDSAP), una solución de detección  que  utiliza las  ondas cerebrales. Consistió en un conjunto de sensores y un algoritmo juiced, EDSAP permite que cualquier persona con un teléfono inteligente o una tableta para controlar los impulsos eléctricos que son las ondas cerebrales, midiendo así la probabilidad de un accidente cerebrovascular que se acerca. El objetivo es proporcionar una alerta temprana, por lo que las personas expuestas pueden visitar al médico para un diagnóstico adecuado con tiempo suficiente para evitar los potencialmente trágicas consecuencias de un accidente cerebrovascular.

Sensores de EDSAP se colocan en un auricular, recogida y transmisión de datos de forma inalámbrica de ondas cerebrales de una aplicación móvil, donde el algoritmo analiza las ondas cerebrales y en última instancia determina la probabilidad de un accidente cerebrovascular, todo dentro de un 60-segundo período de tiempo. Además, mediante el seguimiento de las ondas cerebrales durante más tiempo, EDSAP puede aprovechar sus capacidades de análisis de ondas cerebrales para proporcionar información adicional relacionada con la salud neurológica, como patrones de estrés, ansiedad y del sueño.

En comparación con otros sensores de ondas cerebrales en el mercado, que se utilizan más comúnmente para el control de dispositivos en lugar de efectos relacionados con la salud, los sensores EDSAP son únicos en un número de maneras:

 

  • Los sensores EDSAP son capaces de monitorear y analizar las ondas cerebrales mucho más rápido que los 15 minutos más o menos necesarios para equipos de monitoreo de ondas cerebrales existentes en los hospitales.
  • Los sensores son capaces de escanear las ondas cerebrales en detalle exhaustivo, en gran parte gracias al material similar al caucho de alta conductividad descubierto por Lim y su equipo
  •  En tercer lugar, los sensores son fáciles de usar. Las soluciones salinas ya no tienen que ser frotado en el pelo, la eliminación de las cosas desagradables que previamente habían sido parte de la exploración de las ondas cerebrales. Más importante aún, en parte gracias al material similar al caucho, sensores EDSAP se pueden escalar hacia abajo en una variedad de factores de forma que recuerda a los objetos cotidianos. Mientras que el prototipo actual está en la forma de un engranaje principal, sensores EDSAP también se pueden pegar en la parte posterior de las horquillas o templos gafas, lo que permite a los usuarios monitorear sus ondas cerebrales durante períodos más largos de tiempo sin la apariencia anticuada.

Mientras tanto, el algoritmo EDSAP, que traduce los datos de ondas cerebrales en la detección de carrera, se basa en el análisis de un sinnúmero de tiempos de datos de ondas cerebrales del paciente, que se ha combinado con una gama de la inteligencia artificial y software de procesamiento de señal. Algunas de las soluciones de software fueron programados por Jangbeom Yang, el experto en software en este proyecto. Incluyen, entre otros, el pico y el software de detección de pendiente, lo que permite a los dispositivos móviles para realizar un rápido análisis de las fluctuaciones de las ondas cerebrales y el movimiento. También se utilizó una serie de soluciones de software de código abierto, incluyendo FFT y Wavelet.

Como EDSAP experimenta un mayor desarrollo, su utilidad en otras áreas se evaluará. Un área potencial de la ejecución, de acuerdo con Lim, ha estado en electrocardiogramas, o el registro de la actividad del músculo cardíaco.

 

C-Lab-Engineers-Developing-Wearable-Health-Sensor-for-Stroke-Detection_main1

 

 

Samsung pretende ir un poco más allá con un wearable para detectar infartos cerebrales. Colocado en la cabeza en una especia de araña, monitoriza las ondas cerebrales y envía la información a un smartphone o tablet. Una aplicación dedicada recibe y analiza los datos alertando al usuario de cualquier anomalía.

Según los investigadores de Samsung, el wearable permitirá adelantarse a un posible ictus, accidentes cerebrovasculares o infartos cerebrales que son la tercera causa de muerte en el mundo occidental y la primera causa de invalidez permanente entre adultos. Solo en España, se registran 120.000 ataques cerebrovasculares anuales.

EDSAP puede medir registrar otros parámetros, patrones del sueño, nivel de estrés y también ritmo cardíaco. Samsung pretende utilizar este tipo de tecnologías a través de nuevos wearables para prevenir otras enfermedades.

En una décadas, nos implantarán chips minúsculos que monitorizarán toda nuestra actividad. Estarán permanente conectados a nuestros móviles y más importante, a un centro de diagnóstico médico en la nube donde se registrarán y analizarán los datos para prevenir todo tipo de enfermedad. Olvida la privacidad, es el futuro.

 

 

 

 

Mas información aqui