Analizando tweets en tiempo real sobre equipos de fútbol usando Akka y Kibana

Hacía un montón que no escribía por falta de tiempo, pero he conseguido sacar un poco de tiempo para hablar sobre una de las últimas cosas que he probado en mi trabajo: los actores de Akka.

Akka es un framework que trata de hacer la concurrencia y las aplicaciones distribuidas de una manera más sencilla. En este caso no veremos nada distribuido puesto que todo lo haremos en nuestra máquina local y nos centraremos en la concurrencia.

Habitualmente cuando programamos en ciertos lenguajes como por ejemplo en Java, generalmente trabajamos estos temas empleando el API que nos da acceso a crear threads o procesos y somos nosotros los que nos encargamos del paso de mensajes entre ellos, sus bloqueos, etc... Akka trata de aislarnos un poco de esto usando "actores".

Lo recomendable sería leernos los ejemplos y la documentación de Akka sobre actores pero intentaremos hacer un resumen corto.

Un actor es un proceso ligero que se ejecuta de manera concurrente a otros actores y que tiene una cola de mensajes, cumpliendo:

• El actor va leyendo los mensajes y procesándolos de uno en uno. De tal manera que si por ejemplo el actor se bloquea procesando un mensaje, aunque seguirá recibiendo mensajes que se encolarán, no procesará ninguno hasta que acabe de procesar el actual.
• Un actor puede crear otros actores, lo que al final acaba generando una jerarquía de actores (un actor es el padre de otros actores, etc)
• Un actor puede enviar mensajes a otros actores o a sí mismo. Estos mensajes son mensajes que definiremos nosotros de diferentes tipos, aunque existen también mensajes ya existentes en Akka por ejemplo para indicarle a un actor que muera.

Al final todos estos actores que se van creando pertenecen a un sistema de actores, que si le indicamos en algún momento que se cierre se encargará de ir matando todos los actores que existan.

Para nuestro ejemplo, (el código podéis encontrarlo aquí), hemos definido esta jerarquía de actores, que si bien probablemente pueda ser mejorable, nos puede servir de ejemplo para ver un poco cómo funciona todo:

Vamos a describir cada actor que se va a crear dentro de nuestro sistema de actores:

• QueueConsumer: es un actor único que se encarga de leer de una cola donde van entrando los tweets en tiempo real. Este actor cuando es arrancado crea los actores de cada equipo y simplemente cada vez que observa que hay algo en la cola, lo reenvía a los actores de cada equipo: 

• TeamRecolector: cada uno de estos actores está encargado en primero instancia de crear los actores relacionados con cada jugador, el presidente, y el entrenador. Va quedándose aquellos tweets que le llegan que considera que están relacionados con el equipo, cuenta cuantos han llegado hasta el momento, los reenvía a sus hijos y cuando le llega el mensaje de guardar, le indica a sus hijos que la agregación en esa ventana ha acabado y guarda sus datos en ElasticSearch.

En realidad los PlayerRecolector, PresidentRecolector y CoachRecolector, heredan igual de TeamRecolector, de una clase Recolector en la que simplemente cada uno tiene que implementar lo que hace cuando se acaba el periodo de agregación (finishedPeriodAggregation), o procesar un tweet recibido:

La manera en que al final cada equipo está definido es un .conf dentro de la carpeta resources que es parseado cuando se crea el Actor:

Lo que hacemos es que cuando coincide que el Tweet contiene en su texto alguno de los términos relacionados (por ejemplo en el Actor que está agregando las apariciones de Colak, aparece un tweet que contenga colak, o cholak), sumamos uno en nuestra agregación puesto que el tweet cumple nuestro criterio.

Para minimizar los falsos positivos, si bien pueden producirse y probablemente la mejor aproximación sería hacer redes neuronales para detectar cuando se habla de un jugador, del club, o de futbol, el filtrado va como sigue:

• Solo se escuchan tweets relacionados con palabras clave de futbol como go, futbol, clasificación, etc...
• De esos tweets cada equipo filtra los que tienen términos relacionados con ello (su nombre, el nombre del estadio, etc)
• De los anteriores que ha filtrado el equipo, se le pasan a los actores hijos de cada equipo y ya ellos estiman si se está hablando de ese jugador, entrenador, etc...

Por lo que de acuerdo con lo anterior por ejemplo si alguien escribe un tweet del tipo: "En la Premiere de la nueva película de Leo DiCaprio en Barcelona", aunque no queremos acabaría clasificado, como tweet del barcelona y de Messi, puesto que Premiere es una palabra relacionada con el fútbol, Barcelona con el equipo y Leo es uno de los seudónimos de Messi...

Una vez dicho esto, si configuramos las claves del API de twitter de streaming y tenemos bien configurado nuestro ElasticSearch, cuando arranquemos, iremos viendo en los logs que estamos procesando tweets, y encontraremos también en ElasticSearch datos:

Una vez arrancado, arrancamos también Kibana y podemos ver en tiempo real, cómo va agregando y generando las gráficas que nosotros le hayamos indicado.

Primero configuramos correctamente el tiempo de actualización en la cabecera de Kibana:

Una vez hecho esto si por ejemplo queremos ver el número de apariciones en cada ventana, actualizamos el filtro como sigue:

Y obtenemos por ejemplo gráficas de este tipo:

Si por ejemplo queremos ver de qué jugadores, o entrenadores están hablando más globalmente (en cada ventana), si por ejemplo queremos ver la gráfica de Messi podemos filtrar:

Y obtendríamos esta gráfica que es el número de tweets en cada ventana (30 segundos):

Obviamente tocando algo el modelo de datos y conociendo las opciones de Kibana, se puede jugar mucho más que con el esquema que hemos empleado que no deja de ser un ejemplo. De hecho no nos debería sorprender ver aparecer que apellidos comunes como "sanchez", "álvarez", etc, aparezcan con mucha frecuencia, simplemente por el hecho de como hemos comentado no ser capaces de catalogar bien cada tweet para un jugador.

Conclusiones

Si bien es cierto que obviamente vamos a tener bastantes falsos positivos y que probablemente no siempre que hablen de Messi aparezca una palabra relacionada con el Barcelona o el fútbol y por tanto nos estamos perdiendo muchos tweets de agregar, es un ejemplo de ver lo que puede hacer Akka sin despeinarse.

Pensemos que habiendo 20 equipos, con una media de 20 jugadores por equipo, se están montando 400 Actores además de los del entrenador, etc, y que están conviviendo repartiéndose las CPUs concurrentemente sin despeinarse. 

Las medidas de sus pruebas en su web con un 8 cores, son realmente impresionantes soportando millares de actores y un montón de mensajes sin sobrecargar para nada la máquina.

Además  gracias a las ventajas de Akka en el procesamiento distribuido, podríamos buscar maneras de segmentar los actores entre diferentes máquinas de manera que todo lo anterior funcionara de manera distribuida permitiendo muchísimas más opciones a la hora de mejorar el rendimiento o ingestar muchos más tweets.

Telefónica vs Google vs Facebook

Recientemente ha salido la noticia de que Telefónica va a presentarnos una App para que los usuarios puedan controlar sus datos y de esta manera ser conscientes de toda la información que manejan Google, Facebook, Linkedin y otros servicios sobre nosotros.

Vivimos en una época en que el abaratamiento de los costes de almacenamiento y de procesamiento, ha hecho que el Big Data esté triunfando ppr doquier y que cada vez más empresas usen sistemas de Machine Learning y similares para ser capaces de segmentar mejor sus productos y tratar de ofrecer aquellos que crean que más le va a gustar al cliente.

Obviamente con el uso de las cookies y las grandes redes de afiliados que tienen estas grandes compañías, por no hablar de que de muchas usamos sus teléfonos, y sus navegadores web, tienen acceso a lo más recóndito de nuestra personalidad y gustos.

Sin embargo, aunque la iniciativa me parece noble, igual no deberíamos engañarnos. Que sea Telefónica una empresa privada, ya nos indica que su intención ha de tener algún uso mercantil, y aparte de una posible comisión en la venta de nuestros datos a estas empresas a través de su App, ¿No estará intentando conseguir ella también todos esos datos y de esta manera conseguir una posición dominante?

Y lo digo, porque la mayoría por no decir todos, están cifrados viajando por su red y Telefónica no puede saberlos (obviamente sí tiene algunos de localización por sus antenas de móvil y de historiales de navegación), salvo que Telefónica de alguna manera hiciera de intermediario de todos los servicios y a partir de ese momento en el que lo autorizáramos, fueran ellos los que los tuvieran además de Facebook, Google, etc.

Tengamos cuidado, porque dándole nuestros datos a Telefónica para que pueda gestionarlos, no resulte justo en que pasen de tenerlos Google y Facebook, a que los tenga Telefónica y hayamos puesto a otro lobo a cuidar a nuestro rebaño.

Arreglar micrófono que no funciona en Ubuntu 16.04 y otros

Sé que no es una entrada precisamente de desarrollo de software, pero allá vamos. Desde que empecé a usar este PC, había tenido el problema de que aunque aparentemente los drivers de la tarjeta de sonido, me reconocían bien el micrófono, no entraba ninguna señal...

Después de devanarme los sesos un tiempo, trasteando con alsamixer y buscando por Internet, llegué a la solución.

El tema (en mi caso), no es que los drivers estuvieran mal configurados, sino que tengo un micrófono en el que el canal derecho anula al izquierdo, y si ambos tienen el mismo volumen asignado, no grabará nada...

Manera de solucionar esto en Ubuntu:

Instalamos pavucontrol desde el terminal:

sudo apt-get install pavucontrol

Y una vez instalado lo ejecutamos:

pavucontrol


A continuación os aparecerá una pantalla como esta:

(Si aparecéis en dispositivos de salida, simplemente dadle a la pestaña de moveros a la derecha y ya encontraréis dispositivos de entrada)

Una vez hecho esto, clickamos en el candadito y veremos que nos salen los dos canales de audio:

Dejamos como está en la imagen el canal derecho en silencio y el canal izquierdo a tope de volumen, y veréis que a partir de ese momento, vuestro micrófono empezará a captar vuestros sonidos.

Cerramos la aplicación y ya estamos listos para volver a usar vuestro micrófono donde queráis :)

Cinco años de experiencia desarrollando profesionalmente...

Esta será una entrada un poco atípica porque no voy a desgranar ningún tipo de tecnología nueva, o a poner ejemplos de programación. Hoy voy a hablar de lo que ha definido un amigo mío como mi "cumplecurro".

Y es que hoy hace cinco años que empecé a trabajar en el mundo de la informática (bueno la verdad es que no he trabajado de otra cosa en mi vida).

Aún recuerdo mis primeros miedos en el primer trabajo en el que estuve de becario y los grandes momentos para bien y a veces para mal, que he ido viviendo a lo largo de este tiempo. Así pues, he decidido hacer una especie de recopilatorio de consejos, para aquellos que estén a punto de empezar su particular carrera, o que lleven aún poco tiempo en estas lindes de los 0's y 1's.

• En esta profesión uno está siempre anticuado. Intenta tener capacidad de aprender, de leer sobre tecnología un poco cada día o sobre cosas del mundillo (otros lenguajes, herramientas), que no domines. Muchas veces no se trata de ser un crack en todo, sino de saber de todo un poco.

• No dejes de programar. No sé por qué hay gente que estigmatiza tanto desde la universidad, que no vas a ser un programador y que casi te vende que saldrás al mundo laboral siendo un analista o un jefe de proyecto. No te dejes engañar, probablemente vas a pasar mucho tiempo programando y precisamente como es la base del trabajo, es la que te va a permitir evolucionar tu visión en otros temas (en qué se gestionan mal los proyectos, qué falla de las metodologías, o documentos, etc...)

• Sé humilde y respeta a tus compañeros. Si sabes algo, intenta compartirlo y no convertirte en un aglutinador de conocimiento. No te va a ayudar a crecer, ni va a evitar que haya gente que sepa más que tú. ¿Te imaginas que tu profesor de primaria no te enseñara a sumar, para que no lo superes? Pues aplícate lo mismo cuando no quieras compartir tus conocimientos.

• Pregunta, habla mucho con la gente de tu trabajo, o con la que compartas conocimiento en foros, blogs, etc. Hasta el que lleva igual solo unos meses o crees que no lo hace lo bien que debería, te va a enseñar algo. Aparte que conocer gente y otras maneras de pensar, de trabajar, te va a ayudar mucho en aprender a buscar soluciones a los problemas, que al final es de lo que se trata un 80% del trabajo.

• Viaja. Viajar abre la mente, te hace hablar otras lenguas, darte cuenta de que el mundo de 500km más al norte, no se parece en nada en el que tienes a 500km más al sur. Te hace adaptarte a cosas cambiantes, a problemas que en tu casa no vas a tener jamás y al final es exactamente lo mismo que te va a pasar en muchos proyectos.

• Igual que viajar es importante también reconocer los momentos en los que igual es mejor cambiar de empresa, o probar incluso en otras tecnologías o áreas que te interesan pero no tienes experiencia. No tengas miedos. Aún eres joven y aunque no lo seas, muchas veces el riesgo es infinitamente menor del miedo que nos da y la recompensa es extremadamente gratificante. Que el dinero no sea únicamente tu motivo para cambiar o permanecer en un sitio.

• Aprende a tomarte tus tiempos. Habrá épocas en las que puedes estar sometido a mucha presión y te gustará hacer otras cosas, leer, salir a correr, estar de cervezas con tus amigos. No te ahogues a ti mismo con la presión. Al final es como una carrera, puedes hacerla a acelerones, que te van a desgastar mucho, o ir a un ritmo que creas que puedes mantener y que te hará avanzar mucho más sin desgastarte. Tómate un respiro a veces y desconecta.

• Date cuenta de que no vas a ser el mejor. Es fácil agobiarse viendo tanta tecnología, o al compañero de clase que ahora es jefe, o al de más allá que conoce a alguien que lo ha enchufado y ahora es lo más. Tienes que estar contento con lo que tienes y con lo que has hecho por ti mismo. NO vas a ser el mejor. Olvídalo. Céntrate en trabajar, trabajar, trabajar y quizás de esta manera, aunque no seas el mejor, probablemente tu carrera irá hacia arriba y no acabarás con un estrés postraumático a la primeras de cambio.

Y por último trata de buscar retos y cosas que te motiven. Aunque al final no saques del todo tiempo para acabarlas. Pero será tiempo que invertirás en informarte, en ver cómo se resuelven cosas y si bien a veces te puede desesperar el no haberlas acabado, te da una variedad de herramientas que podrás usar en futuros proyectos.

Al final si haces lo anterior, probablemente aunque tengas momentos de desilusión, continuarás amando tu profesión, que al final es para lo que has estudiado y has luchado tanto por conseguir. Piensa que no hay nada peor que trabajar en algo, que no te llena. Son demasiadas horas al día. Así que si algo no te gusta. ¡Cámbialo!

Este es el pequeño resumen que he ido sacando de lo que he aprendido estos 5 años. 

¡Nos vemos dentro de otros 5!

Por qué no deberías hacer el path de Big Data de Coursera

A continuación, simplemente quería describir una opinión sobre el path de Big Data de Coursera. Con lo cual quiero decir que igual hay gente que está totalmente a favor de esta serie de 6 cursos, pero contaré mi experiencia.

Lo primero decir que no es la primera vez que usaba Coursera. Había hecho antes otros cursos como el de Machine Learning de la universidad de Standford y algunos de Scala como el Functional Programming o el Reactive Programming, cuyo nivel es buenísimo y encima son gratuitos.

También llegué a empezar uno muy famoso que es el de criptografía, pero lo abandoné a la mitad porque me era imposible seguir el ritmo del curso, con el trabajo.

Pero en todos los casos anteriores, la verdad es que me sirvieron para adquirir muy buenas nociones y conocimientos. Solo puedo hablar bien de los profesores y de los formatos de los cursos, en los que encima siendo gratuito, me parece que tienen mucho nivel y que aglutinan mucha formación y mucha profundidad sobre los temas que tratan.

Desde hace un tiempo Coursera, ha empezado a ofrecer "paths" o caminos sobre especialidades con una universidad, para que si haces todos los cursos de ese camino (son de pago pero suelen ser unos 70€ o así cada curso), pues al final obtengas un título de Coursera también firmado por la universidad colaboradora.

Por ello decidí probar el de Big Data, puesto que lo iba a necesitar para mi trabajo y era bastante ignorante sobre el tema.

El path de Big Data de Coursera, lo conforman los siguientes cursos:

• Introducción a Big Data
• Plataforma Hadoop y Marco de Aplicación
• Introducción al Análisis Big Data
• Aprendizaje automático con Big Data
• Introducción al Análisis Gráfico 
• Big Data - Proyecto final

Se nos indica que está pensado no tanto para un perfil de desarrolladores, como para gente que venga de analítica, quizás más enfocado a la parte de DataScientists o sacar estadísticas, etc.

Los dos primeros cursos si bien me parecieron que eran una introducción bastante light a las tecnologías a usar, puede que s si no está orientado a desarrolladores, pueda entender el por qué no se profundizan más en algunas cosas, y sí que te sirven para hacerte una idea más o menos del paradigma Big Data. Sobretodo si nunca has cacharreado con ello.

Continué haciéndolo por esto, puesto que necesitaba tener unas pequeñas nociones para ver un poco la idea general y me pareció que lo más acertado fue que "me lo dieran un poco masticado" y condensado todo. 

El problema fue que en el tercer curso de la serie.

La profesora explicaba como usar HBase (una base de datos no relacional sobre hdfs) y los usos que se podían dar. Para esto solo usaba una interfaz gráfica, jamás queries, ni nada por el estilo (puedo hasta medio entenderlo, pensando que estaba pensado para gente no técnica, aunque me falta ese añadido), ni siquiera enseñó a conectarse a un shell de HBase. 

Lo sorprendente fue, que usó la interfaz para añadir unas rows (como si añadieramos filas a través de PhpMyAdmin) y ¡ No guardaba ninguna !

En lugar de explicar por qué no se guardaba ninguna, o volverlo a intentar, la profesora hace como que todo va bien... Y por si fuera poco, ¡Busca una row de las que ha introducido, la interfaz le indica que no existe y cambia de tema!

Puedo entender que haya vídeos o incluso explicaciones que no sean perfectas. O que en una clase en directo, estas cosas pueden suceder porque el ambiente es muy diferente.

Pero que una persona que da clase en lo que además no es la primera iteración del curso (lleva como un año) y que no haya querido volver a grabar el vídeo y lo haya subido tal cual (un vídeo de 5 minutos), me demuestra la poca preocupación que tiene por lo que se opine de su universidad y de su curso.

Por ello he decidido desapuntarme (por suerte la política de Coursera te devuelve el dinero si lo haces antes de cierto tiempo) y publicar esta queja pública. 

De verdad os aconsejo Coursera al 100%, me parece en general que tiene mejor nivel que MiriadaX y que los cursos los da gente muy profesional, pero también a veces te puedes encontrar cosas como estas...

Así que no os desaniméis y ¡No dejéis de aprender!

Nos vemos en el siguiente post.

Usando redes neuronales para identificar patrones usando Scala

Si recordáis, hace mucho tiempo escribí una entrada sobre cómo ser capaces de identificar qué número estaba pintado en una imagen.

El procedimiento era bastante simple, y trataba de comparar pixel por pixel la imagen con los diferentes patrones (conjunto de imágenes), que teníamos de ella. Pero esta aproximación tiene bastantes problemas en cuanto a eficiencia a la hora de dar una respuesta (hay que recorrerse entero el juego de datos), como a la hora de si habíamos desplazado algo el número en la imagen.

Una mejor manera como ya adelanté, es usando un algoritmo de machine learning muy conocido (de hecho data de hace 60 años) y que se está empleando bastante en la actualidad: las Redes Neuronales.

Una red neuronal es un intento matemático, de intentar aproximarse a la forma en la que el cerebro emplea las neuronas para procesar información. Para ello la red consta de neuronas:

Una neurona en este modelo, equivaldría a una función matemática (pero no nos asustemos, no entraremos a profundizar demasiado), de tal manera que tiene una serie de entradas y produce una salida.

Para generar la salida lo que hace la neurona es coger cada entrada y la multiplica por un peso (cada entrada por uno diferente) y lo suma.

Por ejemplo si la neurona de 3 entradas de la imagen, tiene como pesos internos (0.5, 0, 1) y como entrada le entra (1, 2, 3)  la salida sería 0.5*1 + 0*2 + 3*1 = 3.5

Una vez que entendemos cómo funciona una neurona, podemos establecer que una red neuronal es un conjunto de neuronas asociadas entre ellas. La red recibe una serie de entradas, la procesa y emite una (o varias salidas).

Las redes neuronales tienen diferentes niveles de neuronas, (generalmente dos), y puede variar el número de neuronas en cada nivel.

Por ejemplo en esta red extraída de la wikipedia:

Es una red neuronal que tiene N entradas. En la primera capa (o primer nivel) hay m neuronas, y en la segunda capa (que se corresponde en la imagen con la capa de salida), solo hay una neurona.

Una vez analizado el concepto, vamos a ver cómo aplicarlo a nuestro problema:

•  Nuestras imágenes tenían todas 64 pixels (8x8) por lo tanto nuestra red neuronal, la vamos a definir con 64 entradas. 

• Como queremos diferenciar 10 números diferentes (0,1,2...9) estamos ante un problema de clasificación (es decir, queremos clasificar algo que no sabemos qué es, en un grupo en este caso uno de los números) vamos a poner 10 neuronas de salida. Estas neuronas siempre devolverán valores entre 0 y 1, y en el caso ideal todas las neuronas serán 0, menos la neurona del número identificado que será 1. Por ejemplo, si estamos mandando una imagen de un 3, en la red esperamos una salida: [0, 0, 0, 1, 0...] (tened en cuenta que empezamos en 0).

• Vamos a usar una capa intermedia de neuronas. En este caso el número de la capa intermedia (así como si queréis poner más capas) es algo que uno elige y va variando y probando. No hay una regla fija, aunque hay que poner suficientes neuronas para que la red se pueda adaptar al problema, pero tampoco es bueno sobrepasarse. En nuestro caso voy a poner 20 neuronas.

Por lo tanto una vez diseñada la red, tendría una pinta así:

(En realidad en la capa de entrada y en la capa intermedia se añadirían una entrada adicional siempre con un 1 por motivos de cálculo, pero en este dibujo y en la explicación no lo vamos a considerar para no liarnos).

Una vez tenemos diseñada nuestra red neuronal, sabiendo que estamos ante un problema de clasificación (otro tipo de problemas, podría ser de regresión, por ejemplo si calculáramos cuanto creemos que costará un piso en base a ciertas características), lo que vamos a hacer es a entrenarla.

Nosotros desconocemos los valores que tiene que tener cada neurona de la red para resolver nuestro problema (aquellos pesos de los que hablábamos cuando definíamos lo que es la neurona), por lo tanto vamos a emplear un algoritmo llamado backpropagation que lo que hace es ajustar los pesos de cada neurona de la red, para que la red "aprenda" a resolver nuestro problema.

Para ello escogemos un juego de entrenamiento (si os acordáis de la entrada anterior, ya teníamos uno):

Y entrenaremos la red, con este juego hasta que consideremos que se amolda lo suficiente a nuestro problema.

No vamos a entrar en los términos matemáticos que se usan en el algoritmo, para que resulte más sencillo de entender, pero lo que hace a grandes rasgos es:

• Primero se generan pesos para cada neurona de manera aleatoria.

• Se define una función de coste, que indica si estamos fallando mucho, o si estamos acertando mucho. Es decir cuanto valores más pequeños nos dé esa función (idealmente 0), más próximos estaremos de que la red se haya amoldado a nuestro problema.

• Se ejecuta todo el juego de pruebas sobre la red neuronal, y gracias al backpropagation (que por su complejidad matemática no describiremos aquí), se estima cuanto error está cometiendo cada una de las neuronas de la red y se ajustan sus pesos para tratar de minimizar ese error.

• Se ejecuta de nuevo el punto anterior N iteraciones, hasta que consideremos que la función de coste nos da valores suficientemente bajos que la red ya está amoldada al problema en un gran número de casos.

En la implementación que yo hice haciendo 400 iteraciones sobre la red, podemos ver como en cada iteración disminuye algo el coste:

Coste en la primera iteración

Coste en la última iteración

(Que no os líe, que el contador de Iteraciones va hacia abajo en lugar de hacia arriba)

Y al final una vez entrenada la red, podemos ver como la mayoría del juego de entrenamiento la red lo acierta, y que nos acierta el número que habíamos pintado en la entrad anterior:

Si os interesa el tema, no dejo de recomendaros el curso de Machine Learning de Coursera que da Andrew Ng que es muy recomendable.

Y si os interesa mi implementación del algoritmo y queréis cacharrear probando a cambiar los tamaños de cada capa, o ampliar el número de entradas para otro tipo de uso, (ojo que el algoritmo que minifica no es el ideal y hay librerías en casi todos los lenguajes que encontrarán la convergencia mejor) aquí está el repositorio de Github. 

En las próximas entradas seguramente volvamos con este tema, aplicándolo a otro tipo de entradas o de problemas, e inclusó trataré de llevar una red ya entrenada a javascript para que podáis jugar con ella en vivo.

Primeros dos proyectos en Arduino

Bueno, para los que estaban interesados en lo que se puede hacer en Arduino con el Arduino Starter Kit, les dejo aquí el vídeo del proyecto número 2 y del número 3 (el número 1 no lo he grabado puesto que era simplemente encender un led para comprobar que todo estaba correcto).

El proyecto número 2 controlamos una entrada digital (a través de un pulsador), y a través de Arduino si el pulsador está sin pulsar (entrada a LOW) encendemos la luz verde, y cuando el pulsador se pulsa (entrada a HIGH), alternamos las dos luces rojas:

El proyecto 3 es muy similar (también controlamos salidas digitales para encender los leds) con la peculiaridad de que medimos una entrada analógica. La entrada es alimentada por un sensor de temperatura, con el cual dependiendo del voltaje que nos brinda, sabemos que hay más o menos temperatura, y encendemos los leds correspondientes.

Obviamente el componente se puede calibrar y se puede jugar más con la línea base y los rangos de temperatura para encender luces, pero aquí va:

Seguiremos colgando vídeos conforme avancemos ;)

Nos vemos pronto!