Arxiu de la categoria: interacció i interfícies

Gràfics interactius amb Jupyter Notebooks: tir parabòlic

Ara que ja he començat a fer proves amb Jupyter Notebook, el següent pas que vull provar és fer gràfics interactius. Doncs ha resultat ser més fàcil i ràpid del que pensava.

Parteixo d’un script python que simula les dades experimentals d’una trajectòria parabòlica, i calcula la paràbola que millor s’hi ajusta (regressió quadràtica). A partir de l’equació de la paràbola es pot deduir la constant g (=9,81 m/s2). Simulo les dades experimentals introduïnt un error de soroll en les dades teòriques. Doncs bé, amb el meu gràfic interactiu puc jugar amb el nivell de soroll, i amb el número de punts de mostreig, tal com es veu en el video. El codi queda de la següent manera:

%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

Una altra cosa que m’interessa és la manera d’exportar aquests Jupyter Notebooks a una web, conservant les gràfiques i les fórmules en format Latex (encara que es perdi la interacció amb les gràfiques). Això s’aconsegueix directament exportant el Notebook a html:

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

i integrant aquest codi en una web on hi hagi més text i explicacions, i amb la llibreria Bootstrap.

L’hora catalana amb Festival (TTS, text to speech)

Estic treballant en un Magic Mirror, que li vull dotar de funcions de reconeixement de veu (STT, amb Pocketsphynx) i síntesi de veu (TTS, amb Festival). Vull que sigui un projecte una mica de cachondeo, i vull escollir bé els mòduls a instal·lar, i també programar-ne un.

Una cosa divertida que havia pensat és un mòdul que et digui l’hora catalana:

-Magic Mirror (li posarem un nom divertit), quina hora és?
-Són dos quarts i cinc de vuit.

He estat treballant amb el Festival (que s’instal·la sense problemes en una Raspberry Pi) i integrar-ho tot amb Node/Javascript, que és la tecnologia que utilitza MagicMirror.

En el video hi ha una mostra del que volem aconseguir:

Referències:

Troballa de la constant de gravitació g

Després d’ajustaments diversos, ja estic en condicions de realitzar l’experiment del pèndol per trobar la constant de la gravetat.

He provat diferents tipus de sensors, i finalment em quedo amb uns sensors d’efecte Hall que detecten el pas de l’iman (el pes del pèndol és un iman). Encara em falten fer unes quantes millores. De fet, la fórmula que fem servir (moviment harmònic) només és vàlida quan sin(x) = x, i això implica que l’estructura del moble ha de ser més gran i el cable més llarg, per poder limitar l’angle alfa, tot mantenint el període del cicle.

Experiments d’estiu: model matemàtic de com decau la llum solar quan es fa fosc al capvespre

M’està rondant el cap fer una sèrie d’experiments captant dades amb sensors i processant les dades a l’ordinador. Espero parlar-ne aviat, hi ha bastantes idees xul·les que es poden desenvolupar. Aquí va una petita mostra. I una de les tècniques claus per fer tot això que vull fer és enviar pel protocol sèrie les dades del sensor (arduino) a un programa C++ que s’està executant a l’ordinador.

En la foto es pot veure com es recull les dades del sensor a l’ordinador. Les dades es van gravant en un fitxer, i es poden processar a posteriori. En aquest cas tinc un sensor LDR que capta la llum solar, i es tracta de veure com decau la il·luminació a mida que es fa fosc. Quin comportament tindrà? L’estat inicial és assimptòtic (il·luminació plena), i l’estat final també (foscor). Què passa pel mig? Sabem que a la natura no li agraden els canvis bruscos. Hem d’unir les dues rectes amb una corba. Això ens dóna una corba sigmoide, en la qual hi hauria un punt d’inflexió de canvi màxim en el decreixement de la il·luminació? Serà cert aquest comportament, aquest model matemàtic? Anem a comprovar-ho.

Un cop tenim el fitxer amb les dades, les processarem amb les llibreries científiques numpy i scipy de Python. Com podem veure en el codi, es proposa una línia de màxim ajustament de tipus sigmoide. I efectivament obtenim una bona solució i un bon ajustament com es pot veure en la gràfica. En aquest cas, l’equació obtinguda és:

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

No hem de fer massa cas a les dades de l’eix de les X, són tan sols punts. Senzillament tenir en compte que la distància entre punts són 30 segons.

Aquesta és una senzilla i bona demostració d’estiu (un divertimento) de què la natura es descriu amb funcions matemàtiques. Les mates són una bona eina per descriure el comportament de la naturalesa. I que els fenòmens exponencials són inherents a la Física.

Aquest últim any he estat estudiant mètodes numèrics i les llibreries científiques de Python, i realment hi veig un munt de possibilitats, que vull anar explorant aquest curs que començarà d’aquí poc.

# -*- 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. Avançant en el projecte

Espero que la versió 0.0.12 sigui la última abans de barrejar tot el codi amb la detecció i calibració dels dards, que utilitza dos càmeres web i la llibreria OpenCV.

La principal novetat de les darreres versions és que ara es pot rectificar una entrada dels dards. Malauradament, ara tinc clar que no es pot aconseguir una fiabilitat del 100% en la detecció dels dards, o sigui que més val pensar en la lògica que ens permetrà rectificar la puntuació dels dards. A més d’anular el punt i restablir l’estat anterior, es proposa els punts més propers, que són els més probables. Per exemple, si hem detectat D20 i és un error, els punts més probables són MISS, 20, D1 i D5.

He ficat colors en la consola, com es veu a la foto, doncs la idea és que en la màquina es podrà jugar en aquesta interfície de consola. Només falta barrejar el subsistema de detecció. Així doncs, la part gràfica, basada en SDL (ja he fet proves de la migració a SDL), i la interface dels botons que necessitaré, ho deixaré pel final de tot.

Els jocs implementats són el 301 (i les seves variants), Cricket, Count-Up, Halve It i Round the Clock. El codi està pensat per tal de què sigui fàcil afegir nous jocs de dard en el cas de què sigui necessari. Es pot jugar de 1 a 4 jugadors. El codi de moment no preveu jugar per equips, és una millora que es deixa per més endavant si fos necessari.

El projecte es troba al GitHub:

recreativa dards v0.0.8

Ja tinc ganes de fer aquesta nova recreativa: una màquina de darts amb detecció automàtica dels darts i la seva puntuació. Però no dards amb punta de plàstic. Ha de ser un dartboard original de suro amb dards de punta metàl·lica.

Per a la detecció dels dards hi havia la possibilitat d’utilitzar una malla resistiva i poder posicionar on llencem els dards. Però crec que no seria de fiar. El millor serà utilitzar visió per computadora amb OpenCV. Ja parlaré sobre el tema més endavant.

De moment he estat treballant amb la lògica dels diferents jocs de dards que hi ha. Els més populars són: 301, 501, Count Up, Cricket, Round the Clock, Halve it. I ara ja puc presentar la primera versió de l’aplicació, no funcional, que només funciona a la consola de Linux. Aquesta versió simula partides reals de fins a 4 jugadors: primer esculls el joc; després número de jugadors; després assignes els usuaris; comencem a jugar al joc seleccionat passant per les diferents rondes (cada ronda són tres tirades dels dards). I així anem registrant la puntuació fins que arribem al guanyador.

En les següent versions del programa (escrit amb C++) s’haurà d’implementar tota la part de OpenCV, i finalment tota la part de SDL (llibreria gràfica). Tot haurà de córrer en una Raspberry Pi 3, de manera que el desenvolupament el faig en el portàtil, però assegurant la portabilitat a la RPi3. Aquest hauria de ser el projecte estrella d’aquest semestre. És una idea que em persegueix de fa tres anys. De fet no és una idea original, hi ha diversos projectes que utilitzen dards amb punta de ferro i taulells de suro o fibra, en comptes de les dianes electròniques amb puntes de plàstic. Potser ara el projecte més similar seria open-cv-steeldarts, que s’està desenvolupant amb Python i que encara no és plenament funcional. Li donaré una ullada sobretot pel tema de la calibració i detecció dels dards.

Enllaços:

Interfície Wii Rockband drumset

L’altre dia vaig comprar al Cash Converter, per 18e, una bateria Wii de segona mà, amb la idea de fer-la sonar en el meu Ubuntu. Aquestes bateries van sortir al mercat el 2007, ara ja fa cinc anys. Evidentment hi ha altra gent que ha portat aquestes consoles a l’entorn Linux, i m’he beneficiat del codi que he trobat per aquí i per allà. Tanmateix, el codi que he trobat no era per al meu model (també existeixen versions per a PS2, PS3 i X360), així que he hagut d’esbrinar els codis que envia el drumset (amb la dificultat que quan toques les dues baquetes a l’hora, o les dues baquetes i el bombo, s’envien d’altres codis). No tenia experiència prèvia en la programació de la llibreria libusb. Utilitzant aquesta llibreria ha estat la única manera possible de detectar la força amb que colpeges la baqueta, i per tant fer una mica de control de volum, encara que amb poca resolució.

Per tal de fer sonar la bateria es necessita generar missatges MIDI i enviar-los a un sintetitzador. He utilitzat Hydrogen com a sintetitzador de sons de bateria. He programat quatre presets diferents que s’accedeixen amb els botons de la consola (els típics botons 1, 2, A i B de la Wii). S’ha fet dues versions del codi, una que utilitza ALSA de forma nadiua, i una altra per al servidor d’audio JACK. Pots descarregar-te el codi del projecte:
projecte jrbdrum

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 lloro-pirata per a la Maria

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.