Archivo de la categoría: Interacción e Interficies

Gráficos interactivos con Jupyter Notebooks: tiro parabólico

Ahora que ya he empezado a hacer pruebas con Jupyter Notebook, el siguiente paso que quiero probar es hacer gráficos interactivos. Pues ha resultado ser más fácil y rápido de lo que pensaba.

Partimos de un script python que simula los datos experimentales de una trayectoria parabólica, y calcula la parábola que mejor se ajusta (regresión cuadrática). A partir de la ecuación de la parábola se puede deducir la constante g (=9,81 m/s2). Simulamos los datos experimentales introduciendo un error de ruido en los datos teóricos. Pues bien, con mi gráfico interactivo puedo jugar con el nivel de ruido y con el número de puntos del muestreo, tal com se ve en el video. El código queda de la siguiente forma:

%matplotlib inline
from ipywidgets import interactive
import numpy as np
import pylab as plt
from IPython.display import display, Math, Latex

# tir parabòlic: y = vy*t - .5gt^2
vy = 10 # 10m/s
g = 9.81 # m/s^2
t_max = 2*vy/g

def f(nivell_soroll, num_punts):
    t = np.linspace(0, t_max, num_punts)
    y_or = vy*t - .5*g*t**2
    noise = np.random.normal(0, nivell_soroll, num_punts) # simulem dades experimentals
    y = y_or + noise

    # ajustament a una paràbola
    z = np.polyfit(t, y, 2)
    g_exp = 2.0*z[0]

    t_ = np.linspace(0, t_max, 100)
    y_ = z[0]*t_**2 + z[1]*t_ + z[2]

    fig, ax = plt.subplots()
    plt.plot(t_, y_, t, y, 'bo')
    plt.suptitle("Tir parabòlic. Regressió quadràtica")
    plt.title("y = " + str(round(z[0],3)) + "t^2 + " + str(round(z[1],3)) + "t + " + str(round(z[2],3)) + " -> g exp = " + str(round(g_exp,3)) + " m/s^2")
    ax.set(xlabel='temps (s)', ylabel='y (m)')
    ax.grid()
    plt.show()
    
interactive_plot = interactive(f, nivell_soroll=(0.0, 2.0),  num_punts=(10, 50))
interactive_plot

Otra cosa que me interesa es la manera de exportar estos Jupyter Notebooks a una web, conservando las gráficas y las fórmulas en format Latex (aunque se pierda la interacció con las gráficas). Esto se consigue directamente exportando el Notebook a html:

$ jupyter nbconvert --execute tir_parabolic.ipynb --to html

e integrando este código en una web donde haya más texto y explicaciones, y con la librería Bootstrap.

La hora catalana con Festival (TTS, text to speech)

Estoy trabajando en un Magic Mirror, y le quiero dotar de funciones de reconocimiento de voz (STT, con Pocketsphynx) y síntesis de voz (TTS, con Festival). Quiero que sea un proyecto un poco de cachondeo, y quiero escoger bien los módulos a instalar, y también programar alguno.

Una cosa divertida que había pensado es un módulo que te diga la hora catalana:

-Magic Mirror (le pondré un nombre divertido), quina hora és? (en catalán)
-Són dos quarts i cinc de vuit.

He estado trabajanco con Festival (que se instala sin problemas en una Raspberry Pi) e integrarlo todo con Node/Javascript, que es la tecnología que utiliza MagicMirror.

En el video hau una muestra de lo que se quiere conseguir:

Referencias:

Encontrar la constante de gravitación g

Después de diversos ajustes, ya estoy en condiciones de realizar el experimento del péndulo para encontrar la constante de la gravedad.

He probado diferentes tipos de sensores, y finalmente me quedo con unos sensores de efecto Hall que detectan el paso del imán (el peso del péndulo es un imán). Todavía me faltan hacer unas cuantas mejoras. De hecho, la fórmula que hacemos servir (movimiento armónico) sólo será válida cuando sin(x) = x, y esto implica que la estructura del mueble tiene que ser más grande y el hilo más largo, para poder limitar el ángulo alfa, manteniendo el periodo del ciclo.

Experimentos de verano: modelo matemático de como decae la luz solar al atardecer

Me está rondando por la cabeza hacer una serie de experimentos captando dades amb sensors y procesando los datos en el ordenador. Espero hablar de ello pronto, hay bastantes ideas chulas que se pueden desarrollar. Aquí va una pequeña muestra. Y una de las técnicas clave para hacer todo esto que quiero hacer es enviar por el protocolo serie los datos de un sensor (arduino) a un programa C++ que se está ejecutando en el ordenador.

En la foto se puede ver cómo se recogen los datos del sensor en el ordenador. Los datos se van grabando en un fichero, y se pueden procesar a posteriori. En este caso tengo un sensor LDR que capta la luz solar, y se trata de ver cómo decae la iluminación a medida que se va haciendo oscuro. ¿Qué comportamiento tendrá? El estado inicial es asintótico (iluminación plena), y el estado final también (oscuridad). ¿Qué pasa en medio? Sabemos que a la naturaleza no le gustan los cambios bruscos. Hemos de unir las dos rectas con una curva. Esto nos puede dar una curva sigmoide, en la que habría un punto de inflexión de cambio máximo en el decrecimiento de la iluminación? ¿Será cierto este comportamiento, este modelo matemático? Vamos a comprobarlo.

Una vez tenemos el fichero con los datos, los procesaremos con las librerías científicas numpy y scipy de Python. Como podemos ver en el código, se propone una línea de máximo ajuste de tipo sigmoide. Y efectivamente obtenemos una buena solución y un buen ajuste como se puede ver en la gráfica. En este caso, la ecuación obtenida es:

y =987.24 * (1 / 1 + exp(-0.07*(x-393.87))) +-8.02

No hemos de hacer demasiado caso a los datos del eje X, son tan sólo puntso. Sencillamente tener en cuenta que la distancia entre puntos son 30 segundos.

Esta es una sencilla y buena demostración de verano (un divertimento) de que la Naturaleza se describe con funciones matemáticas. Las mates son una buena herramienta para describir el comportamiento de la Naturaleza. Y que los fenómenos exponenciales son inherentes a la Física.

Este último año he estado estudiando métodos numéricos y las librerías científicas de Python, y realmente le veo muchas posibilidades, que quiero ir explorando este curso que comenzará de aquí poco.

# -*- coding: utf-8 -*-
#cel·la LDR que ha gravat com decau la llum al capvespre.
#La funció que s’ajusta a les dades és una sigmoide

import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

def sigmoid(x, a, b, c, d):
y = c / (1 + np.exp(-b*(x-a))) + d
return y

y = np.loadtxt(‘../dades/LDR_capvespre.txt’)
x = np.linspace(1,len(y),len(y))
#print (x)
#print (len(x))

popt, pcov = curve_fit(sigmoid, x, y, p0=[350, 0.001,1000, 2]) #és necessari ficar uns bons paràmetres inicials

print popt
print (‘y =c * (1 / 1 + exp(-b*(x-a))) +d ‘)
print (‘y =’ + ‘%.2f’%popt[2] + ‘ * (1 / 1 + exp(‘ + ‘%.2f’%popt[1] + ‘*(x-‘ + ‘%.2f’%popt[0] + ‘))) +’ + ‘%.2f’%popt[3] )

plt.figure()
plt.plot(x, y, ‘k’, label=»Original Noised Data»)
plt.plot(x, sigmoid(x, *popt), ‘r-‘, label=»Fitted Curve»)

plt.legend()
plt.show()

# Resultat:
#y =c * (1 / 1 + exp(-b*(x-a))) +d
#y =987.24 * (1 / 1 + exp(-0.07*(x-393.87))) +-8.02

darts-machine v0.0.12. Avanzando en el proyecto

Espero que la versión 0.0.12 sea la última antes de mezclar todo el código con la detección y calibracinó de los dards, que utiliza dos cámars web i la librería OpenCV.

La principal novedad de las últimas versiones es que ahora se puede rectificar una entrada de los dardos. Desgraciadamente, ahora tengo claro que no se podrá conseguir una fiabilidad del 100% en la detección de los dardos, o sea que más vale pensar en la lógica que nos permitirá rectificar la puntuación de los dardos. Además de anular el punto y restablecer el estatdo anterior, se propone los puntos más próximos, que son los más probables. Por ejemplo, si hemos detectado D20 y es un error, los puntos más probables son MISS, 20, D1 iyD5.

He puesto colores en la consola, com se ve en la foto, pues la idea es que en la máquina se podrá jugar en esta interficie de consola. Sólo falta mezclar el subsistema de detección. Así pues, la parte gráfica, basada en SDL (ya he hecho pruebas de la migració a SDL), y la interface de los botones que necesitaré, lo dejaré para el final de todo.

Los juegos implementados son el 301 (y sus variantes), Cricket, Count-Up, Halve It y Round the Clock. El código está pensado para que sea fácil añadir nuevos juegos de dardos en caso de que sea necesario. Se puede jugar de 1 a 4 jugadores. El código de momento no prevee jugar por equips, es una mejora que se deja para más adelante si fuese necesario.

El proyecto se encuentra en GitHub:

recreativa dardos v0.0.8

Ya tengo ganas de hacer esta nueva recreativa: una máquina de dardos con detección automática de los dardos y su puntuación. Pero no dardos con punta de plástico. Ha de ser un dartboard original de corcho con dardos de punta metálica.

Para la detección de los dardos había la posibilidad de utilizar una malla resistiva y poder posicionar dónde lanzamos los dardos. Pero creo que no sería de fiar. Lo mejor será utilizar visión por computadora con OpenCV. Ya hablaré sobre el tema más adelante.

De momento he estado trabajando con la lógica de los diferentes juegos de dardos que hay. Los más populares son: 301, 501, Count Up, Cricket, Round the Clock, Halve it. Y ahora ya puedo presentar la primera versión de la aplicación, no funcional, que sólo funciona en la consola de Linux. Esta versión simula partidas reales de hasta 4 jugadores: primero escoges el juego; después número de jugadores; después asignas los usuarios; comenzamos a jugar al juego seleccionado pasando por las diferentes rondas (cada ronda son tres tiradas de los dardos). Y así vamos registrando la puntuación hasta que llegamos al ganador.

En las siguientes versiones del programa (escrito en C++) se tendrá que implementar toda la parte de OpenCV, y finalmente toda la parte de SDL (librería gráfica). Todo tendrá que correr en una Raspberry Pi 3, de manera que el desarrollo lo hago en el portátil, pero asegurando la portabilidad en la RPi3. Este tiene que ser el proyecto estrella de este semestre. Es una idea que me persigue de hace tres años. De hecho no es una idea original, hay diversos proyectos que utilizan dardos con punta de hierro y tableros de corcho o fibra, en vez de las dianas electrónicas con puntas de plástico. Quizás ahora el proyecto más similar sería open-cv-steeldarts, que se está desarrollando en Python y que todavía no es plenamente funcional. Le daré una ojeada sobretodo por el tema de la calibración y detección de los dardos.

Enlaces:

Interficie Wii Rockband drumset

El otro día compré en el Cash Converter, por 18e, una batería Wii de segunda mano, con la idea de hacerla sonar en mi Ubuntu. Estas baterías salieron al mercado en 2007, hace ya cinco años. Evidentemente hay gente que ha llevado estas consolas al entorno Linux, y me he beneficiado del código que he encontrado por aquí y por allá. Sin embargo, el codi que he encontrado no era para mi modelo (también existen versiones para PS2, PS3 y X360), así que he tenido que averiguar los códigos que envía el drumset (con la dificultad que cuando tocas las dos baquetas a la vez, o las dos baquetas y el bombo, se envían otros códigos). No tenía experiencia previa en la programación de la librería libusb. Utilizando esta librería ha estado la única forma posible de detectar la fuerza con que golpeo la baqueta, y por tanto hacer un poco de control de volumen, aunque con poca resolución.

Para hacer sonar la batería se necesita generar mensajes MIDI y enviarlos a un sintetizador. He utilizado Hydrogen como sintetizador de sonidos de batería. He programado cuatro presets diferentes que se acceden con los botones de la consola (los típicos botones 1, 2, A y B de la Wii). Se han hecho dos versiones del código, una que utiliza ALSA de forma nativa, y otra para el servidor de audio JACK. Puedes descargarte el código del proyecto:
jrbdrum project

Four books…

In the previous post I was talking about Physical Computing, Interaction Design and the Tinkering way to discover and do things and projects. These four books that I quote represent a nice starting point to dig inside these concepts.

  • Programming Interactivity: A Designer’s Guide to Processing, Arduino and OpenFrameworks. O’Reilly (2009). Joshua Noble. Amazon reference
  • Make: Electronics. Learning Through Discovery. O’Reilly (2009). Charles Platt. Amazon reference
  • Making Things Talk: Practical Methods for Connecting Physical Objects. O’Reilly (2007). Tom Igoe. Amazon reference
  • Physical Computing. Sensing and Controlling the Physical World with Computers. Thomson Course Technology (2004). Dan O’Sullivan and Tom Igoe. Amazon reference. This book doesn’t make any reference to arduino because it’s year of publication: 2004.

Concerning three concepts: Physical Computing, Interaction Design, Tinkering

The course is over… and summer starts… During this year I’ve been taken awareness about different concepts and ideas that are becoming more and more important in my thoughts and projects. I want to bookmark these three words and concepts for further study and reference: Physical Computing, Interaction Design and Tinkering. I’ve found very usefull a small booklet introductory to arduino: Getting Started with Arduino, from where I take the quotes.

Physical Computing

Physical Computing involves prototyping with electronics, turning sensors, actuators and microcontrollers into materials for designers and artists. It involves the design of interactive objects that people can interact with using sensors and actuators controlled by a behaviour implemented as software running inside a microcontroller.

Also:

  • http://en.wikipedia.org/wiki/Physical_computing
  • www.tigoe.net

Interaction Design

Interaction Design is about the design of any interactive experience. It also applies to the creation of meaningful experiences between us (humans) and artefacts. It is also a good way to explore the creation of beautiful and maybe even controversial relationships between us and technology. Interaction Design attempts to encourage design through an iterative process based on prototypes of ever increasing fidelity. This approach, also part of some types of more traditional design fields, can be extended to include prototyping with technology and particular with electronics. This particular type of Interaction Design is called Physical Computing.

Also:

  • http://en.wikipedia.org/wiki/Interaction_design
  • Programming Interactivity book

Tinkering

We believe it is essential to play with the medium, exploring different possibilities directly with hardware and software, sometimes without a definite goal. We call this process tinkering.

Tinkering is what happens when you try something you don’t quite know how to do, guided by whim, imagination and curiosity.

When you tinker, there are no instructions – but there are also no failure, no right or wrong way of doing things. It’s about figuring out how thinks work and reworking them.

Re-using existing technology is one of the best ways of tinkering. Getting cheap toys or old discarded equipment and hacking them to make them do something new is one of the best ways to get to great results.

329 In the previous post I was talking about Physical Computing, Interaction Design and the Tinkering way to discover and do things and projects. These four books that I quote represent a nice starting point to dig inside these concepts.

  • Programming Interactivity: A Designer’s Guide to Processing, Arduino and OpenFrameworks. O’Reilly (2009). Joshua Noble. Amazon reference
  • Make: Electronics. Learning Through Discovery. O’Reilly (2009). Charles Platt. Amazon reference
  • Making Things Talk: Practical Methods for Connecting Physical Objects. O’Reilly (2007). Tom Igoe. Amazon reference
  • Physical Computing. Sensing and Controlling the Physical World with Computers. Thomson Course Technology (2004). Dan O’Sullivan and Tom Igoe. Amazon reference. This book doesn’t make any reference to arduino because it’s year of publication: 2004.

Un loro-pirata para María

lloro1bHe estat donant voltes al tema del animatronic i el cartró-pedra… i vull concretar una idea que tindria com a data de termini el febrer del 2011 (queda temps encara per al proper Carnestoltes).

A la Maria últimament li agraden els pirates (a la coral infantil cantaven aquella cançó de »Els que tripulen la nau pirata, han de ser homes ben barbuts,…») i a l’escola també ho han treballat. No sé com va anar la cosa que vam fer una llista de les coses que ha de tenir un bon pirata. A veure si no em deixo res:

  • un pedàs de roba a l’ull borni
  • una pota de pal
  • una bandera pirata
  • un garfi en la mà guerxa
  • un barret o mocador pirata
  • … i un lloro parlador a l’espatlla

Així que li vaig proposar en broma que si es disfressava de pirata pel proper Carnestoltes podríem fer un lloro que el portés enganxat a l’espatlla (i que hauria de ser la sensació dels seus amics de classe). Jo aleshores ja estava pensant en utilitzar el paper-cartró, del que encara no domino la tècnica.

lloro2bEl que encara no m’havia plantejat, i que ho he estat pensant aquests dies, és que aquest lloro pogués ser un animatronic. Hauria de ser una cosa senzilla: per exemple, que se li mogués el cap o el bec, mentre parlés. El tema del parlar ja ho tinc solucionat doncs seria utilitzar un xip de la família ISD amb missatges gravats, i un circuit amplificador perquè el missatge es senti amb claredat. I el tema de què es mogui el cap, doncs un servo. Tot plegat amb una placa basada en arduino (últimament he estat millorant la tècnica per fer circuits impressos amb acabat semi-professional). Tota l’electrònica amagada dins la panxa del lloro. El lloro s’agafaria a l’espatlla del nen/a amb uns agafadors o filferro, de manera que sigui ben estable.

A veure si aquest projecte pot fer-se realitat!… seria maco… clar que la Maria pot dir-me la setmana vinent que de pirates res de res i que el proper Carnestoltes es vol disfressar de cargol… De moment, aquí va el primer esbòs del que hauria de ser el projecte.