===================================
Come far suonare in Pianoforte LEGO
===================================
:CreationDate: 2020-08-28 10:39:28
:Id: modelli/lego-piano
:tags: - 3dPrint
- hardware
- software
- models
Il `Pianoforte a coda LEGO 21323
<https://www.lego.com/it-it/product/grand-piano-21323>`_ è un gran bel
modello, con un sacco di dettagli interessanti e un livello di
ingegneria veramente notevole.
Ci sono un po' di componenti elettronici, che parlano via Bluetooth
con una app per telefono.
.. image:: lego-electronics.jpg
:width: 100%
:alt: un sensore ottico Lego, motore, e scatola di controllo,
su una larga base di pezzi montati di lato; il motore fa girare
un lungo asse con camme ortogonali
La app può suonare alcuni motivi predefiniti mentre fa girare il
motore dentro al pianoforte, cosa che fa abbassare un po' dei tasti in
una sequenza costante, per far finta che il pianoforte stia suonando
la musica. Oppure, la app può aspettare che premiate un tasto
qualsiasi (tutti i tasti muovono un pezzo di fronte al sensore ottico)
per suonare ciascuna nota, per far finta che stiate suonando voi.
Carino, ma un po' tanto limitato: abbiamo 25 tasti indipendenti, ci
deve essere un modo di fargli suonare la nota giusta!
.. image:: keys.jpg
:width: 100%
:alt: la tastiera del pianoforte Lego piano, 2 ottave + 1, con
tasti bianchi e neri in sequenza corretta; ciascun tasto ha
il suo martelletto
.. video:: keys-hammers.mp4
:width: 100%
:type: video/mp4
Dopo un po' di ricerca, ho deciso di usare sensori ottici e un
microcontroller potente. Non può essere tanto difficile, vero? ☺
Ho usato come sensore il `QRD1114
<https://learn.sparkfun.com/tutorials/qrd1114-optical-detector-hookup-guide/all>`_,
che è molto semplice da usare: LED infrarosso più fototransistor, con
campo visivo molto stretto e corto, per cui è difficile che tasti
adiacenti producano falsi positivi.
Come controller ho usato un `Lilygo TTGO-T7 v1.3
<http://www.lilygo.cn/prod_view.aspx?TypeId=50033&Id=1258&FId=t3:50033:3>`_,
principalmente perché ne avevo una manciata. È un ESP32, espone 40
piedini, e può caricare una batteria al litio da USB.
.. note::
La versione 1.3 è un ``d1_mini32`` per quanto riguarda le librerie `esp32-arduino
<https://github.com/espressif/arduino-esp32>`_, la 1.4 è un
``esp32wrover``. Son sicuro che ci siano altre versioni in giro,
potreste dover fare qualche aggiustamento su volete riprodurre quel
che ho fatto
Per cominciare ho dovuto trovare il sistema di collegare i sensori al
controller. Il LED del QRD1114 si accontenta di 20mA, per cui posso
alimentarlo direttamente dai GPIO del ESP32, che reggono fino a circa
30mA. 25 sensori fanno una matrice 5×5, per cui qualcosa di simile a
questo circuito dovrebbe funzionare:
.. image:: lego-piano-scanner-schematic.svg
:width: 100%
:alt: schema elettrico; quattro QRD1114 sono disposti a quadrato;
un filo etichettato "row1" è collegato agli anodi di due LED
tramite una resistenza di 330Ω e ai collettori di due
fototransistor tramite una resistenza di 10kΩ; un filo "row2"
è collegato in maniera simile agli altri due sensori; un filo
"col1" è collegato al catodo del LED e all'emettitore del
fototransistor di un sensore per riga; un filo "col2" è
collegato in maniera simile agli altri due; tra ciascuna
resistenza da 10kΩ e i fototransistor ci sono fili
etichettati "sense1" e "sense2"
Mettendo "alto" un piedino di riga (con gli altri "bassi") e "basso"
un piedino di colonna (con gli altri ad alta impedenza / tristate),
possiamo accendere un sensore alla volta. Quando un fototransistor
vede la luce riflessa da un oggetto che gli sta davanti, abbassa il
piedino "sense", che possiamo leggere con l'ADC del controller.
Testiamo il circuito su una breadboard per dimostrare che funziona!
.. image:: sensor-matrix-test.jpg
:width: 100%
:alt: breadboard con un ESP32, 4 sensori QRD1114, quattro
resistenze, e un po' di fili. Un LED fa una debole luce rosa,
gli altri sono spenti
Come facciamo a tenere i sensori al loro posto dentro il pianoforte?
Stampiamo un supporto compatibile coi pezzi Lego!
.. image:: sensor-mount-test.jpg
:width: 100%
:alt: rettangolo di plastica bianca prodotto da una stampante 3D,
di dimensioni pari a 6×2 pezzi Lego; ci sono pispoli di
dimensione standard su uno dei lati lunghi, con 2 manine 1×1
attaccate; cinque sensori QRD1114 sull'altro lato
La mia stampante (una `Prusa i3 MK3S
<https://shop.prusa3d.com/en/3d-printers/180-original-prusa-i3-mk3s-kit.html>`_)
riesce a stampare fori della dimensione giusta per i componenti
elettronici, e l'intero supporto (lungo 29 unità Lego) in una passata
sola. I sensori devono essere allineati ai martelletti (non c'è posto
dietro le stecche dei tasti, inoltre i martelletti sono bianchi per
cui più visibili ai sensori, e si muovono di più per cui riducono la
probabilità di letture sbagliate). Ho usato `OpenSCAD
<http://www.openscad.org/>`_ per `costruire il modello del supporto
<https://www.thenautilus.net/cgit/lego-piano/tree/3d-print/qrd-holder.scad>`_.
.. image:: sensor-mount-size-check.jpg
:width: 100%
:alt: rettangolo di plastica bianca prodotto da una stampante 3D,
di dimensioni pari a 29×2 pezzi Lego, con 25 gruppi di 4 fori
ciascuno per reggere i sensori, appoggiato sopra le "corde"
del pianoforte; i fori sono allineati coi martelletti
Dobbiamo anche controllare l'allineamento sugli altri due assi,
ovviamente.
.. image:: sensor-position-test-1.jpg
:width: 100%
:alt: un sensore QRD1114 inserito nel supporto stampato, appeso a
una delle "corde" con una manina Lego; il sensore è appena
sopra e dietro l'ultimo martelletto a destra; il martelletto
è a riposo
.. image:: sensor-position-test-2.jpg
:width: 100%
:alt: stessi pezzi di prima; il martelletto è sollevato, proprio
davanti al sensore
A questo punto qualcuno si starà domandando: come si fa a saldare
componenti elettronici su una basetta di *plastica*? E la risposta è
che non saldiamo nulla! Ho usato la tecnica del `wire-wrapping
<https://en.wikipedia.org/wiki/Wire_wrap>`_!
.. image:: sensors-mount-wiring.jpg
:width: 100%
:alt: retro del rettangolo 29×2, con 10 sensori montati dal davanti
nei loro fori, e tanti fili elettrici isolati in giallo che
collegano alcuni dei piedini
Ciascun sensore ha 4 piedini, numerati in senso antiorario guardando
dalla faccia del LED / fototransistor:
1. collettore del fototransistor, da collegare a una resistenza di
pull-up e a un piedino "riga"
2. emettitore del fototransistor, da collegare a un piedino "colonna"
3. anodo del LED, da collegare a una resistenza di limitazione e a un
piedino "riga"
4. catodo del LED, da collegare a un piedino "colonna"
per cui i collegamenti vengono più o meno così::
aM aN aO aP aQ cM cN cO cP cQ
14 14 14 14 14 14 14 14 14 14 …
23 23 23 23 23 23 23 23 23 23 …
Mb Nb Ob Pb Qb Md Nd Od Pd Qd
dove ``a``, ``c`` vanno alle resistenze pull-up; ``b``, ``d`` vanno
alle resistenze di limitazione, e ``M``, ``N``, ``O``, ``P``, ``Q``
vanno ai piedini colonna.
Ho costruito la basetta del controller nella stessa maniera: stampa e
wire-wrap (`modello
<https://www.thenautilus.net/cgit/lego-piano/tree/3d-print/controller.scad>`_).
.. image:: board.jpg
:width: 100%
:alt: rettangolo di plastica bianca prodotto da una stampante 3D,
con due gruppi di fori 10×2 intorno a una scritta "esp", due
gruppi di fori 5×2 intorno a scritte "220Ω" e "10kΩ", tre
gruppi di 5 fori ciascuno accanto a scritte "led", "gnd",
"pht", e un gruppo di 9 fori accanto a una scritta "amp"; c'è
uno svaso vicino alla scritta "esp" e un rettangolo rialzato
vicino alla scritta "amp"
La svasatura serve a far spazio per il connettore della batteria, e il
blocchetto rialzato regge l'`amplificatore AdaFruit
<https://learn.adafruit.com/stereo-3-7w-class-d-audio-amplifier/inputs-and-outputs>`_
.. image:: board-populated.jpg
:width: 100%
:alt: stessa basetta, con tutti i componenti al loro posto; i fori
"led", "gnd" e "pht" hanno dei connettori
.. image:: board-wired.jpg
:width: 100%
:alt: retro della basetta, un sacco di fili elettrici isolati in
giallo collegano i piedini
.. image:: board-full.jpg
:width: 100%
:alt: stessa basetta, con un piccolo altoparlante collegato
all'amplificatore
Ho avuto un po' di problemi con i piedini per righe e colonne, perché
non tutti i GPIO sono davvero usabili. Alla fine ho usato questi:
- righe: 05 23 19 18 26
- colonne: 17 33 16 21 22
- ADC: 02 04 12 27 14
- DAC: 25
- abilitazione dell'amplificatore: 32
Il programma ha richiesto un po' di attenzione, ma non è
particolarmente complicato, `potete leggerlo nel mio repository Git
<https://www.thenautilus.net/cgit/lego-piano/tree/esp32/lego-piano.ino>`_.
.. note::
La circuiteria del TTGO mi ha dato un po' di problemi nel caricare
il programma compilato, producendo errori tipo ``A fatal error
occurred: Timed out waiting for packet content`` o ``Invalid head
of packet (0xE0)``. Per evitarli, ho dovuto `impostare
esplicitamente la velocità di trasferimento
<https://www.thenautilus.net/cgit/lego-piano/tree/esp32/Makefile>`_
nel ``Makefile``.
Primo test con pochi sensori su una breadboard:
.. video:: sound-test-1.mp4
:width: 100%
:type: video/mp4
e con tutti i sensori, montati al loro posto nel pianoforte:
.. video:: sound-test-2.mp4
:width: 100%
:type: video/mp4
Ho rimosso i componenti elettronici Lego per far posto ai fili e al controller.
E, finalmente, il risultato assemblato:
.. video:: sound-test-3.mp4
:width: 100%
:type: video/mp4
Al momento il programma non sa gestire più di un tasto premuto alla
volta, come probabilmente avete notato alla fine dell'ultimo filmato.
Il passo successivo è di usare una libreria soundfont, probabilmente
`TinySoundFount <https://github.com/schellingb/TinySoundFont>`_ o `la
versione ottimizzata per ESP
<https://github.com/earlephilhower/ESP8266Audio/tree/master/src/libtinysoundfont>`_,
che dovrebbe riuscire a mixare note multiple.
