[WIP] Creazione di un Drawbot controllato da un bracciale Myo: 11 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

Ciao a tutti!

Alcuni mesi fa, abbiamo deciso di provare ad affrontare l'idea di costruire un drawbot a telaio aperto che utilizzasse solo una banda Myo per controllarlo. Quando abbiamo iniziato il progetto, sapevamo che sarebbe stato necessario suddividerlo in un paio di fasi diverse. La nostra prima fase principale è stata quella di provare a avvolgere le nostre teste attorno a un design a telaio aperto per il nostro draw bot. Questa è una configurazione non standard e volevamo vedere quali fossero i vantaggi di questo design.

In secondo luogo, sapevamo che costruire questo prototipo si sarebbe rivelato utile solo per noi stessi. Il nostro progetto e piano era di spostare il nostro telaio finale in metallo e, utilizzando un arduino, ricevere la nostra posizione dall'accelerometro e dal giroscopio integrati nella banda Myo. Tali informazioni verrebbero quindi inviate ai motori e replicherebbero il movimento dell'utente. Sapevamo che questo avrebbe suddiviso la nostra seconda fase in tre aspetti principali:

1. programmazione da Myo ai motori, tramite Arduino
2. progettazione elettrica per tradurre i nostri dati in movimento
3. progettazione meccanica per creare un telaio di dimensioni ragionevoli che faciliterà il nostro movimento

Ogni membro del nostro team si sentiva più a suo agio con una parte unica del nostro processo di progettazione, quindi abbiamo deciso di suddividere il nostro lavoro tra ogni persona. Abbiamo anche tenuto un blog durante l'intero processo di progettazione per tenere traccia del nostro pensiero quotidiano, al contrario di un aspetto più globale.

Passaggio 1: cosa abbiamo pianificato di fare

Il nostro obiettivo era combinare questi due prodotti in un modo che non avevamo mai visto prima. Abbiamo deciso di creare una staffetta dal vivo tra la nostra fascia da braccio Myo e la nostra versione di un design ispirato all'AxiDraw di Evil Mad Scientist.

Passaggio 2: elenco degli ingredienti del prototipo

2 2 x 4 tavole di legno 1 Cintura o catena di misura >= 65” 4 Chiodi di legno 3 Ingranaggi con denti che si adattano alla cintura o alla catena 4 3 x 8 piastre forate vex 30” Distanziali in gomma 8 Rondelle diametro 1” 1 Legno diametro 1” Tassello lungo 1' 8 Viti Vex 1”8 ½” Viti Vex 8 Viti 2” Vex 8 ¼” Distanziali in gomma 48 Dadi Vex 1 Fascetta piccola

Fase 3: [Prototipo] Lavorazione del legno Le nostre braccia e l'interno del carrello

Abbiamo preso due 2x4 e li abbiamo tagliati a lunghezze uguali (33 ¼”)

Usando una sega da tavolo abbiamo fatto una tacca lungo il lato della parte stretta delle tavole profonda ¼" e larga ⅛" al centro

Tagliare il tassello in 4 pezzi da 2" e praticare un foro al centro del tassello di circa ¼" di diametro utilizzando un trapano a colonna

Passaggio 4: [Prototipo] Realizzazione della nostra carrozza

Idealmente avremmo usato due pezzi 7x7 di acciaio perforato vex, ma tutto ciò che avevamo a nostra disposizione erano le strisce 2x7, quindi le abbiamo imbullonate insieme in una configurazione a "X"

Impilare 5 dei distanziatori in gomma da e fissare gli angoli delle piastre vex l'uno all'altro

Fissare senza bloccare i tasselli di legno come mostrato nella figura 1 in modo che ruotino liberamente con circa 2 di spazio tra di loro utilizzare l'immagine per vedere dove dovrebbero essere posizionati gli ingranaggi a questo punto abbiamo usato le rondelle ma in seguito abbiamo scoperto che i piccoli ingranaggi in plastica vex funzionano meglio.

Utilizzando le viti vex da ½", i distanziali in gomma da " e le rondelle di diametro da 1" fissare le rondelle in una posizione elevata come mostrato nella figura 1 (abbiamo usato ingranaggi in plastica verde perché non siamo riusciti a trovare le rondelle giuste) assicurarsi che le rondelle siano in grado per girare facilmente e inserirsi nelle tacche della tavola.

Passaggio 5: [Prototipo] Mettere tutto insieme

Posiziona un'asse su una superficie e fai scorrere il carrello al centro in modo che le rondelle tengano il carrello sopra l'asse e su entrambi i lati dell'asse inchioda gli ingranaggi verso il basso in modo che ruotino liberamente. Inchioda un ingranaggio a un'estremità della seconda tavola assicurandoti che sia centrata e falla scorrere sul carrello perpendicolarmente alla prima tavola.

Ora la cintura deve essere fatta passare attraverso il sistema come mostrato, fare molta attenzione a come sono i tasselli all'esterno della cintura e come non c'è nulla al centro del telaio che possa intralciare la cintura durante il movimento.

Ora la cintura deve essere fissata sul lato della tavola che non ha un ingranaggio. Abbiamo usato un chiodo in più e una fascetta per allacciare il nostro. Ma il metodo utilizzato non ha importanza purché la cintura sia ancorata in quel punto

Passaggio 6: [prototipo] finito e in movimento

Dovrebbe essere così, tira la cintura in diverse combinazioni e guarda i diversi effetti che ha sul braccio!

Passaggio 7: tradurre il nostro modello nel nostro progetto finito

Una volta completato il nostro prototipo, eravamo estasiati. Nessuno di noi era sicuro di come funzionasse il sistema prima dell'assemblaggio. Ma, una volta che le nostre parti si sono unite, abbiamo scoperto rapidamente cosa ci piaceva e come l'avremmo migliorato durante la creazione del design finale. Le nostre principali lamentele da risolvere con il sistema erano:

1. Scala
   1. Il nostro prototipo era massiccio e ingombrante, il che lo rendeva incline a ribaltarsi sul bordo delle nostre braccia
   2. La carrozza era molto più grande del necessario e aveva molto spazio sprecato
   3. La nostra cintura (un battistrada di carro armato vex) era molto più grande del necessario, il che introduceva uno spazio in eccesso tra le braccia

2. Attrito

   1. I nostri passi vex non passavano facilmente sui rulli di tassello di legno in tutti i punti
   2. La plastica su legno ha reso la carrozza riluttante a muoversi in molti casi

3. Motorizzazione

   Avevamo bisogno di rendere il sistema compatibile con l'alimentazione

Con queste cose in mente, abbiamo disegnato i nostri piani per il design finale. Volevamo che il drawbot fosse controllato con un Myo tramite un arduino e volevamo rendere il telaio in alluminio e più piccolo.

Per fare ciò, abbiamo preso una percentuale del nostro prototipo originale e abbiamo iniziato a lavorare da quella dimensione. Utilizzando una lamiera che verrebbe lavorata per avere canali sufficientemente larghi da consentire il passaggio di un cuscinetto schermato, avremmo un design leggero ma robusto che avrebbe una tolleranza d'uso più elevata.

Il nostro prototipo ci ha anche permesso, in pochi minuti, di determinare come la rotazione del motore ha influenzato la testa del nostro traino. Questo ci ha portato a capire che il nostro progetto di controllo sarebbe stato più semplice di quanto avessimo previsto. Dopo un'ispezione più attenta, abbiamo capito che il movimento del motore è additivo! Ciò significa che ogni motore ha un effetto desiderato indipendente sul nostro movimento, ma quando li combiniamo insieme, iniziano a annullarsi.

Ad esempio, se considerato come un piano di coordinate, il motore che giace nell'estremità negativa x tenderà sempre a tirare il nostro cassetto nel secondo e quarto quadrante. Viceversa il motore appoggiato sull'estremità x positiva tenderà sempre il cassetto nel primo e terzo quadrante. Se combiniamo il moto dei nostri motori, annullerà le parti di dirigere quel conflitto e amplificherà le parti che sono d'accordo.

Passaggio 8: codifica

Sebbene alcuni anni fa lavorassi abbastanza ampiamente in C, non avevo esperienza con lua o C++, e questo significava che dovevo dedicare una notevole quantità di tempo alla ricerca della documentazione. Sapevo che il compito generale che avrei cercato di realizzare era ottenere la posizione dell'utente a intervalli di tempo e poi passarla ai motori. Ho deciso di suddividere il compito per me stesso per digerire meglio le parti di cui avrei avuto bisogno.

1. Ottieni dati da Myo (lua)

Sapevo che avevo bisogno di trovare un modo per raccogliere le informazioni dal Myo. Questa era la prima parte della sfida che volevo affrontare. Per fare ciò, volevo che l'utente calibrasse le dimensioni della tela prima di iniziare a disegnare. Questo mi permetterebbe di avere un confine da cui lavorare. Potrei quindi normalizzare il programma tra diversi utenti semplicemente prendendo una percentuale del canvas massimo come punti dati da passare. Ho deciso di avere un evento con script che eseguisse un controllo getOrientation ogni mezzo secondo, in quanto avrebbe consentito ai controlli di non eseguire mai un salto selvaggio da cui avresti dovuto indovinare (ad esempio, se l'utente stava oscillando selvaggiamente indietro e via).

Questo è stato il primo ostacolo che ho incontrato. Ho scoperto una limitazione molto grande di lua e che non mi avrebbe permesso di aspettare prima di continuare lo script. L'unico modo per eseguire questa azione era mettere in pausa la CPU (che la metterebbe in pausa a livello globale, anche tenendo l'orologio di sistema) o utilizzare comandi specifici del sistema operativo. Nel mio codice di esempio, ho lasciato nel sistema operativo originale il controllo che ho eseguito (commentato). Questo è stato fatto dopo aver fatto una grande quantità di ricerche nella documentazione di lua, ed è stato fatto controllando la formattazione del percorso di sistema. È stato allora che ho deciso che dovevo guardare la documentazione per i progetti che erano stati pubblicati in precedenza. Mi sono reso subito conto di quanto tempo avessi perso, e sono stato subito portato alla variabile della piattaforma. Con esso, sono stato in grado di implementare comandi di attesa specifici del sistema operativo quasi immediatamente, al contrario dei giorni che mi ci sono voluti per mettere insieme la mia soluzione precedente.

Fu in questo periodo di progettazione che iniziarono i lavori sull'aspetto elettrico e ho sospeso il lavoro su questo aspetto del codice. L'intento è quello di imparare come i nostri motori si sono interfacciati con l'arduino.

2. Lavorare attorno ad Arduino (C++)

Man mano che il lavoro con la nostra breadboard diventava sempre più complesso, ho appreso che l'arduino non era in grado di eseguire il multithreading. Questa era una grossa chiave di volta nel mio progetto di codice originale e, dopo aver letto di più sulle limitazioni presentate con il nostro controller, ho scoperto che avrei dovuto programmare in che modo l'arduino sarebbe passato da uno all'altro. Questo è diventato il fulcro dei miei sforzi mentre si avvicinava la nostra scadenza. Ho dovuto scartare grandi porzioni del mio script originale poiché erano progettati per scrivere dati su un file in modo sincrono con il controller del motore che leggeva il file. Questo per consentire una funzione di accodamento per assicurarsi che anche se l'utente fosse davanti al nostro cassetto, non avrebbe rovinato il progetto.

Ho deciso che la funzione di accodamento dovrebbe essere salvata, se non implementata nello stesso modo di prima. Per fare ciò, ho creato un vettore di array. Questo mi ha permesso non solo di mantenere relativamente intatto lo spirito del mio progetto precedente, ma significava anche che non dovevo tenere traccia del mio posto nel file sia per la lettura che per la scrittura. Invece, ora tutto ciò che dovevo fare era semplicemente aggiungere un nuovo valore nel mio vettore se l'utente si stava muovendo (i test preliminari erano inferiori all'1% della differenza delle dimensioni della tela in x e y dall'ultima posizione registrata non hanno comportato la registrazione dei dati). Potrei quindi prendere il valore più vecchio nel mio vettore e in un colpo solo, inviarlo al controllo del motore, scriverlo nel nostro file e quindi rimuoverlo dal mio vettore. Questo ha ripulito molte delle mie preoccupazioni sull'esecuzione di un flusso IO costante.

Passaggio 9: elettrico

Mentre in passato ho seguito un corso di elettronica e ho lavorato parecchio con arduino. Non mi sono mai tuffato in profondità nel far sì che arduino riceva informazioni da una fonte esterna (myo), ho solo esperienza nell'emissione di informazioni tramite arduino. Tuttavia, ho iniziato a cablare i motori sul nostro drawbot e a lavorare sul codice affinché potessero lavorare con il codice myo.

Materiali che ho usato:

2 x motori passo-passo

1 x tagliere

1 x Arduino (Uno)

2 x driver IC L293DE

40 x cavi per ponticelli

2 x ventilatori

1. Collegamento dei motori passo-passo e della ventola alla breadboard

Seguendo lo schema del circuito, possiamo collegare un motore passo-passo al driver sulla breadboard. Quindi, seguendo lo stesso schema applicalo al secondo driver e motore, tuttavia, i fili dei ponticelli dovranno essere inseriti in un diverso set di pin nell'arduino (dato che il primo motore occupa lo spazio di altri 4).

Avvertenza/Suggerimento:

I driver sono molto piccoli e i pin sono molto vicini tra loro. Sarebbe saggio distanziare i due driver in modo che i fili non si confondano.

Il prossimo è cablare le ventole. Questo è abbastanza semplice, i fan che avevo a disposizione erano fan del processore di computer di base, che hanno un positivo e un terreno. Collega questi due ai rispettivi pin +/- sulla breadboard e inclina ciascuno verso ciascun driver. (Abbiamo scoperto che poiché i motori passo-passo ricevono raffiche di informazioni e comandi per un lungo periodo di tempo, i driver tendono a surriscaldarsi e a puzzare. L'aggiunta di una ventola per raffreddarla ha risolto questo problema).

2. Codice Arduino

Questa è la parte facile!

Apri l'IDE Arduino vai alla scheda "File" quindi passa alla scheda "esempio" che scenderà ulteriormente e ti mostrerà una scheda "stepper" Quindi vuoi aprire "Stepper_OneStepAtATime"

Questo precaricherà un codice di esempio che è quasi plug-and-play sul cablaggio arduino/motore. Dovremo apportare piccole modifiche perché utilizzeremo due motori, che mostrerò di seguito. Potrebbe anche essere necessario apportare piccole modifiche a seconda dei pin che hai deciso di utilizzare, poiché l'IDE di Arduino ha come impostazione predefinita i pin 8-11.

Il codice che ho utilizzato per far muovere i due motori in “sync” è il seguente:

//#includere

const int stepsPerRevolution = 200;

Stepper myStepper1(stepsPerRevolution, 9, 10, 11, 12);

Stepper myStepper2(stepsPerRevolution, 4, 5, 6, 7);

int StepCount = 0;

void setup() { // inizializza la porta seriale: Serial.begin(9600); }

ciclo vuoto() {

mioStepper1.passo(1);

Serial.print("passi:");

Serial.println(contapassi);

contapassi++;

ritardo (0,5);

mioStepper2.passo(1); ritardo (0,5); }

3. Possibili problemi

I problemi che ho riscontrato durante questo processo non erano l'uso dell'esempio di codice corretto, l'utilizzo di un ponticello difettoso, l'utilizzo dell'IC del driver sbagliato.

Assicurati che il tuo driver che stai utilizzando sia in grado di controllare un motore

Controlla il numero di serie e controlla le sue specifiche

Mi sono imbattuto in un problema di avere un ponticello guasto, che ha fatto girare in modo strano i miei motori

Ho dovuto usare un multimetro per controllare ogni filo

E ricontrolla sempre il tuo codice per piccoli errori come la mancanza di una fine ";" comando

Passaggio 10: meccanico

1. Materiale

Per il modello di produzione completo delle braccia si consiglia che siano realizzate in materiale resistente ma leggero, abbiamo ritenuto che l'alluminio fosse una misura perfetta.

Abbiamo usato fogli di alluminio di calibro 032 tagliati a 9,125 "x 17,5" e abbiamo tracciato il modello dal disegno mostrato nel passaggio precedente.

2. Fabbricazione

Usando l'orlo (la macchina blu) abbiamo aggiunto orli rivolti in direzioni opposte in modo che quando il pezzo viene spezzato e piegato, i due orli si incastrano formando un unico pezzo completo.

Per le grandi curve abbiamo usato il tennismith, per la sua alta precisione.

Ora per le curve più piccole, vorrai usare una macchina con un piede più piccolo, è qui che entra in gioco una macchina come il roto-die. A causa del suo piede più piccolo, sfortunatamente consente di fare pause più piccole, il roto-stampo a nostra disposizione era ancora troppo grande per la nostra rotaia ed era deformato.

**In alternativa, se non hai accesso all'attrezzatura o agli strumenti adeguati, puoi sostituirlo.**

Nel nostro caso, abbiamo tagliato i nostri bracci dalle rotaie del pannello solare in alluminio utilizzando una taglierina al plasma e levigato le estremità, quindi le abbiamo imbullonate una contro l'altra per creare un sistema di binari a doppia faccia. Idealmente, vorremmo saldare i binari insieme, tuttavia, senza accesso a una stazione di saldatura, abbiamo invece bloccato insieme i binari e forato e poi imbullonato insieme. Ma se si segue questa strada, è necessario prestare particolare attenzione all'utilizzo di un controdado e di una rondella per garantire che il pezzo abbia la minor flessione possibile.

3. La cintura

Per le cinture abbiamo usato delle vecchie cinture per stampanti 3D che siamo riusciti a recuperare.

Inizialmente le cinghie non erano abbastanza lunghe, quindi utilizzando del tubo termoretraibile abbiamo unito due pezzi per farne uno che fosse sufficientemente lungo.

Gli ingranaggi verdi e i tasselli di legno sono stati sostituiti da cuscinetti a disco con rondelle extra larghe utilizzate per impedire che la cinghia scivoli fuori posto.

4. Trasporto

E infine il carrello è stato realizzato con un foglio di alluminio 032 da 5 "x 5", con fori premuti dove sono destinate le viti e le rondelle corrispondenti. La distanza varia a seconda della larghezza del binario e dello spazio libero sulle rondelle.

Fase 11: Riflessioni

Sfortunatamente, ogni aspetto del nostro progetto è andato incontro alla grande barricata del tempo e non siamo stati in grado di completare il nostro progetto entro la data prevista. Ogni membro del nostro team ha finito per collaborare in ogni altro aspetto del nostro design, almeno in una certa misura, portando ad alcuni rallentamenti della curva di apprendimento. Questo, unito al desiderio di progettare un prodotto con il minor numero possibile di risorse esterne (dato che tutti volevamo creare le nostre rispettive parti da zero), ha portato a una grande quantità di ruote reinventate.

Tutti coloro che hanno lavorato al progetto hanno imparato di più sugli altri aspetti del progetto. Fare in modo che il software esegua un'azione specifica è una cosa, quindi far funzionare il software insieme all'hardware è un'altra. Direi che è importante che chiunque stia lavorando all'aspetto della codifica di questo progetto, sia familiare come il nostro progettista.

Nel complesso, non siamo stati in grado di ottenere esattamente ciò che volevamo. Tuttavia, sento che eravamo sulla strada giusta e tutti abbiamo scoperto e appreso nuovi concetti che potremo applicare ai progetti futuri.