Guida al montaggio di Hex
Piattaforma esapode open source stampabile in 3D; Hex3 è la versione attuale
Licenza
- Hex3 CAD and PCBs: the maker's own non-commercial terms
- Hex3 code: GPL 3.0
- Hex1 and Hex2: MIT
Licenza per generazione e per parte. I CAD e i PCB di Hex3 sono sotto la Open Community License: i privati possono usarli, copiarli e modificarli e devono condividere i derivati con la stessa licenza; un'azienda può usare e modificare il prodotto per uso interno, ma non può copiarlo né replicarlo per alcuno scopo commerciale senza una licenza separata. Il codice di Hex3 è GPL-3.0. Hex1 e Hex2 sono MIT. Verificato il 2 nov 2026.
Guida al montaggio
1. Quale generazione copre questa guida
Questa guida segue Hex3, la versione attuale. Hex2 e Hex1 sono generazioni più vecchie e deprecate e non sono descritte qui.
1.1 Conferma che stai costruendo Hex3
Hex3 è la release attuale; parti, cablaggio, firmware e configurazione del Raspberry Pi sono diversi da Hex2, quindi non mescolare i documenti delle due.
- Il README del progetto originale dice che la versione attuale di Hexapod è Hex3 e che Hex4 è in sviluppo, con una data di rilascio prevista tra metà e fine 2027.
- La pagina di Hex3 descrive la piattaforma come stabile: non viene più sviluppata attivamente, e il progetto originale chiede pull request (esaminate tramite il suo Discord) o un fork pubblicato per qualsiasi modifica.
- Punti salienti di Hex3 secondo il progetto originale: carico utile di 10kg (~22lb); pilotabile con un controller Xbox; corpo e gambe interamente stampati in 3D; 18 gradi di libertà (3 per gamba); servo personalizzati a basso costo ricavati da motoriduttori DC ed encoder magnetici AS5600; una punta del piede molleggiata con sensore di posizione; un Seeed Xiao RP2350 per gamba; il Pi e i controller delle gambe comunicano su un bus CAN condiviso; ROS2 su un Raspberry Pi 5.
- Il progetto originale indica per Hex3 un prezzo di circa 2.000 USD.
- Le pagine di Hex3 del progetto originale sono divise in sei fasi: stampa 3D, montaggio dei PCB, configurazione dell'elettronica, montaggio meccanico, firmware in tempo reale e configurazione del Raspberry Pi. Avvia prima le stampe, così procedono mentre lavori sulle altre fasi.
1.2 Se hai già una build Hex2
Hex2 (servo hobbistici e un Teensy 4.1) è stato deprecato a luglio 2025 e il progetto originale non pubblica alcun percorso di montaggio per esso.
- Il progetto originale dice che Hex2 è stato dismesso a luglio 2025 e non è più supportato attivamente, anche se i repository contengono ancora il materiale per costruirlo e controllarlo. Puoi fare un fork del repository per continuarne lo sviluppo.
- Il progetto originale indica due limiti principali di Hex2: i servo hobbistici possono surriscaldarsi, limitando il funzionamento continuo a pochi minuti, e il carico utile massimo è di poche libbre.
- Per Hex2 il progetto originale pubblica: una distinta materiali elettrica e una meccanica (entrambe datate 22 luglio 2025), un disegno degli inserti filettati a caldo (5 novembre 2024), un assieme Fusion 360 (2025-07-22_assembly.f3z), i file dell'elettronica per la scheda principale e la scheda della gamba, un disegno della mappatura del controller, una pagina introduttiva per il Raspberry Pi 5, e il codice per Teensy e Raspberry Pi nel repository separato di Hex2.
- Il progetto originale non pubblica passaggi di montaggio di Hex2, documenti sul cablaggio né una procedura di calibrazione. La distinta materiali elettrica contiene la riga 'Main to Leg Connections <TBD>'. Per questo la guida non descrive montaggio, cablaggio o calibrazione di Hex2; usa direttamente i documenti di Hex2 indicati sopra.
- Le lunghezze dei fili, i cavi dell'encoder, del motore e del sensore a tempo di volo, il metodo di calibrazione e la configurazione CAN di questa guida valgono solo per Hex3. Un Hex2 con servo hobbistici non ha encoder né un cablaggio separato dei motori da costruire.
1.3 Raccogli attrezzi e materiali
Prima di iniziare ti servono due chiavi esagonali (2,00 mm e 2,5 mm), attrezzi per saldare e crimpare, un multimetro e grasso per ingranaggi.
- La distinta materiali completa del progetto originale è il foglio di calcolo HEX3 Bill-Of-Materials (schede: Mechanical BOM, Electrical BOM, un elenco delle parti stampate e un esempio di ordine dei PCB).
- Attrezzi: una chiave esagonale da 2,00mm (per il Raspberry Pi e il LiDAR); una chiave esagonale da 2,5mm (tutta l'altra minuteria usa esagoni da 2,5mm; il progetto originale consiglia di usare anche una punta da 2,5mm per trapano, perché stringere a mano tutte le viti è un'impresa erculea); saldatore e accessori per la saldatura; flussante e stagno; una punta per inserti filettati a caldo per il saldatore; un multimetro per le verifiche di continuità e polarità; un supporto per PCB o una morsa (consigliati per il montaggio dei PCB); tronchesino; spelafili per le sezioni della tabella delle lunghezze dei fili; un morsetto (non obbligatorio ma molto consigliato per gli accoppiamenti a pressione); una crimpatrice JST; una crimpatrice per capicorda (molto consigliata ma non obbligatoria, perché questi collegamenti si possono anche saldare direttamente); pinze, pinzette e simili per rimuovere i supporti.
- Materiale aggiuntivo necessario: grasso sintetico multiuso per ingranaggi.
2. Stampa 3D
Stampa le parti del corpo e delle gambe di Hex3. La fonte originale pubblica le impostazioni di stampa e le quantità delle parti, ma non l'orientamento di stampa di ciascuna parte.
2.1 Stampa le parti del corpo e delle gambe
Stampa le parti delle gambe e della base di Hex3 in ABS o ASA, con base_core e le punte dei piedi stampate con 12 o più perimetri.
- Il progetto originale dice che si può usare il PETG, ma consiglia ABS o ASA per maggiore resistenza meccanica e al calore.
- Tutte le parti strutturali sono preparate in PrusaSlicer con il profilo di stampa 0,2mm STRUCTURAL su una Prusa Core ONE. Predefinito (la maggior parte delle parti): 4 perimetri, riempimento a triangoli del 30%, supporti dove servono. base_core e le punte dei piedi: 12+ perimetri, riempimento a triangoli del 30%, supporti dove servono.
- base_core subisce i carichi strutturali più elevati, quindi si stampa con 12+ perimetri per renderla di fatto piena invece di affidarsi al riempimento. Le punte dei piedi si stampano con queste impostazioni perché si consumano col tempo.
- Quantità per sei gambe, dalla scheda delle parti stampate della distinta materiali: s0 6, s0_gear_cover 6, s0_gear_cover_spacer 6, s1 6, s1_bearing_holder 12, s1_encoder_cover 6, s1_motor_bearing_holder 6, s1_motor_bearing_mount 6, s1_motor_cover 6, s2_bearing_screw_mount 6, s2_bearing_side 6, s2_connector_long 6, s2_connector_short 6, s2_gear_side 6, s2_magnet_mount 6, s3_bearing_side 6, s3_gear_mount 6, s3_gear_side 6, s3_magnet_mount 6, spring_aligner 6, toe 6, toe_tip 6.
- Parti della base dalla stessa scheda: relay_mount_bracket 1, base_flat 12, base_lower 1, base_upper 1, fan_shield_print_wo_top_or_bottom_layers 1, base_electronics_mount 1, base_electronics_guard 1.
- Controlla prima di stampare: la pagina di stampa nomina base_core e la cartella della release contiene base_core.3mf, ma la scheda delle parti stampate non la elenca. Stampa base_core come indica la pagina di stampa.
- I file sono in Hex3_resources/cad nel repository (un assieme completo Fusion 360, un file STEP, i file 3mf della release per le parti della base e delle gambe, ed encoder_insertion_tool in .f3d e .step) e nel progetto Printables di Hex3 del progetto originale. Il progetto originale avverte che le parti potrebbero apparire leggermente diverse dalle immagini e di usare sempre la versione più recente su GitHub.
- L'attrezzo di inserimento degli encoder si usa nel montaggio meccanico. Il progetto originale ne pubblica il CAD ma non indica le impostazioni di stampa.
3. Montaggio dei PCB
Salda sei PCB delle gambe e un PCB principale. La versione V2.0 o V3.2 del PCB delle gambe cambia le parti, la polarità di un condensatore e una correzione necessaria; scegli prima di ordinare.
3.1 Scegli la versione della PCB delle gambe
Hex3 ha due versioni della PCB delle gambe, V2.0 e V3.2, entrambe pienamente funzionanti; la PCB principale è la V2.1.
- Il progetto originale dice che con entrambe le versioni si può costruire un Hex3 completo. Le differenze principali sono il metodo di montaggio, la gestione termica, il costo del PCB e la possibilità di riutilizzare lo XIAO RP2350.
- Leg V2.0: un diodo a foro passante da saldare a mano; i chip driver dei motori DRV8871 non hanno raffreddamento aggiuntivo (si possono comunque applicare dissipatori esterni, ma il layout non è stato progettato per la dissipazione del calore); lo XIAO RP2350 è saldato direttamente sul PCB, quindi non si può riutilizzare.
- Leg V3.2: un diodo a montaggio superficiale (aggiungilo all'elenco delle parti per il montaggio quando ordini); grande attenzione al raffreddamento dei chip DRV8871, con colate di rame interne da 2 oz (che aumentano parecchio il prezzo) e via stitching per il piano GND; un'opzione con pin POGO per lo XIAO RP2350, così si può riutilizzare, anche se la spaziatura dei pin pogo è delicata e richiede specifici pin header maschio e femmina.
- Altre modifiche della V3.2 elencate nel readme dei PCB del progetto originale: rimossa la terminazione divisa dal circuito del bus CAN; etichette serigrafate degli encoder numerate da zero; connettori degli encoder scambiati in modo che S0 sia il più vicino al lato superiore della scheda.
- Scheda principale: la V2.1 è stata l'unica versione usata per OpenSauce 2026. Entrambe le versioni della scheda gamba sono state usate sugli esapodi a OpenSauce 2026.
- I file sono in Hex3_resources/electronics: leg_board/V2.0, leg_board/V3.2 e main_board/V2.1. Sia il PCB della gamba sia quello principale sono progettati come PCB a 4 strati. Il progetto originale dice che va bene qualsiasi fornitore di PCB che offra il montaggio; i file BOM e CPL del suo ultimo ordine sono nelle cartelle leg_board come riferimento e riguardavano un ordine all'ingrosso di 25 schede, quindi adatta le quantità.
3.2 Salda una PCB delle gambe
Salda lo XIAO RP2350, il portafusibile, i connettori JST e Molex e i condensatori su una PCB delle gambe, poi ripeti per sei.
- Parti per un PCB della gamba: 1x Xiao RP2350 (senza header saldati); 1x portafusibile 3557; 3x connettore JST da scheda a 4 pin (prendine un 4° se userai il collegamento I2C di breakout facoltativo; il software attuale non ne ha bisogno); 1x connettore JST da scheda a 5 pin; 1x connettore Molex da scheda a 4 pin; 4x connettore Molex da scheda a 2 pin; 4x condensatore radiale da 22uF; 1x condensatore radiale da 470uF; 1x PCB della gamba (V2.0 o V3.2).
- La V2.0 richiede anche 1x diodo 1N5819. La V3.2 richiede facoltativamente 2x connettore POGO a 4 pin, 2x pin header maschio corto a 7 pin e 2x pin header femmina corto a 7 pin.
- Inizia dallo Xiao RP2350. Con la V3.2 puoi scegliere i pin header; la V2.0 non supporta i pin header.
- Xiao a montaggio superficiale: fissa due pin superiori in diagonale con un po' di stagno dopo aver controllato che ogni lato sia distanziato uniformemente e che tutti i pin siano centrati sulle piazzole. Capovolgi il PCB e controlla che le piazzole inferiori siano centrate nei fori passanti; se non lo sono, scalda un angolo, ruota delicatamente lo Xiao e ripeti. Poi salda tutti i pin superiori. Per il lato inferiore, usa una punta del saldatore sottile, scalda insieme il foro e la piazzola dello Xiao, riempi il foro di stagno e controlla che il foro non sia troppo pieno e che non ci siano cortocircuiti con i fori vicini.
- Xiao con pin header (solo V3.2): salda i pin header femmina al PCB, poi salda i pin header maschio allo Xiao. Se usi i pin header e i pin pogo della BOM di Hex3, inserisci i pin maschio dal lato superiore dello Xiao invece di appoggiare lo Xiao sopra di essi, così i pin pogo fanno un contatto solido con le piazzole sul lato inferiore. Metti i pin pogo sul PCB, inserisci lo Xiao negli header femmina, controlla che le punte dei pogo siano allineate con le piazzole sul lato inferiore dello Xiao e, se lo sono, salda i pin pogo al PCB.
- Solo V2.0: salda ora il diodo. Il catodo del diodo deve stare sul lato più vicino allo Xiao. Con la V3.2 salta questo passaggio, perché il diodo è a montaggio superficiale e fa parte dell'ordine di montaggio del PCB.
- Salda il portafusibile 3557. Tieni il saldatore sui pin del portafusibile abbastanza a lungo da accumulare calore sufficiente prima di applicare lo stagno.
- Salda i connettori JST: i JST a 4 pin per gli encoder, facoltativamente un 4° per il breakout I2C, e il JST a 5 pin per il sensore della punta del piede.
- Salda i connettori Molex: il Molex a 4 pin per l'alimentazione principale e il collegamento del bus CAN con il PCB principale, e i connettori Molex a 2 pin per i motori.
- Salda i condensatori. Rispetta la polarità corretta: il catodo dei condensatori da 22uF deve essere rivolto verso i connettori Molex a 2 pin. Salda il condensatore da 470uF per lo Xiao, anche questo con la polarità corretta: nella V2.0 il catodo è rivolto verso il portafusibile e il connettore Molex a 4 pin; nella V3.2 la disposizione è cambiata in modo che tutti i condensatori abbiano lo stesso orientamento, e il catodo del condensatore da 470uF è rivolto verso la USB dello Xiao.
- Ripeti fino ad avere sei PCB delle gambe.
3.3 Applica la correzione richiesta per la tua versione della PCB delle gambe
Taglia le piste della terminazione CAN divisa sulla V2.0, oppure modifica leg.cpp per la V3.2; il progetto originale lo segna con DO NOT SKIP THIS.
- V2.0: le piste della terminazione divisa del bus CAN vanno tagliate. Si trovano sul lato inferiore del PCB; il readme dei PCB del progetto originale dice che i test hanno mostrato che questa funzione introduceva problemi. Taglia le piste nel punto mostrato nell'immagine della vista inferiore della V2.0 del progetto originale.
- V3.2: per le nuove posizioni dei connettori serve una modifica al software. In leg.cpp (real_time/xiao_code/lib/HexapodController/src/leg.cpp nel repository Hex3) cambia la riga 53 da axes[0].link(D8, D10, 5, mux); a axes[0].link(D17, D18, 7, mux); e la riga 55 da axes[2].link(D17, D18, 7, mux); a axes[2].link(D8, D10, 5, mux); prima di caricarlo sulle schede Xiao.
- Dopo la modifica il file dovrebbe contenere: axes[0].link(D17, D18, 7, mux); axes[1].link(D11, D12, D15, D16, 6, mux); axes[2].link(D8, D10, 5, mux);
3.4 Controlla ogni PCB delle gambe prima dell'uso
Ispeziona le saldature e monta sulla PCB della gamba un fusibile mini a lama da 10A, poi alimentala da sola per verificare che i LED e lo Xiao funzionino.
- Controlla che non ci siano ponti di stagno, saldature fredde o componenti disallineati.
- Verifica l'orientamento e la polarità dei connettori prima di alimentare la scheda.
- Inserisci un minifusibile a lama nel portafusibile prima della prova di accensione. Per la scheda gamba il progetto originale usa fusibili da 10A.
- Collega ogni scheda gamba a un alimentatore, una alla volta, e conferma che i LED e lo Xiao funzionino correttamente prima di provare il collegamento con il PCB principale.
- Taglia la lunghezza in eccesso dei reofori dei condensatori radiali a foro passante per evitare cortocircuiti.
3.5 Salda la PCB principale
Salda sulla PCB principale il connettore XT60, il portafusibile, l'header 2x40 per il Pi, due convertitori DC-DC buck, i connettori e i condensatori.
- Parti: 1x portafusibile 3557; 1x condensatore radiale da 10uF; 1x condensatore radiale da 470uF; 1x connettore XT60 da scheda; 1x pin header maschio a 2 pin; 1x pin header femmina 2 per 40 per il Raspberry Pi; 2x convertitore buck DC-DC; 6x connettore Molex da scheda a 4 pin; 2x connettori JST da scheda a 3 pin. La scheda ha posizioni di saldatura per un massimo di 8 connettori Molex a quattro pin sul bus CAN e sul collegamento di alimentazione condivisi, quindi puoi saldare i tuoi 6 in una qualsiasi di esse.
- Breakout JST facoltativi per i collegamenti del Pi: 1x JST a 3 pin per l'anello LED, 1x JST a 3 pin per PWM0, 1x JST a 3 pin per PWM1, 3x JST a 4 pin (UART0, UART1, I2C) e 4x JST a 5 pin (5V, 4, 27, 22, GND; 5V, 11, 6, 26, GND; 5V, 18, 23, 25, GND; SPI1). Come minimo, i collegamenti necessari sono i due JST a 3 pin per le ventole di raffreddamento.
- Salda il connettore XT60. Tieni il saldatore sui pin abbastanza a lungo da accumulare calore sufficiente prima di applicare lo stagno.
- Salda il portafusibile 3557, tenendo prima il saldatore sui pin abbastanza a lungo da accumulare calore sufficiente.
- Salda l'header femmina 2x40 con i pin che sporgono dal lato superiore del PCB. Il PCB principale si innesta sul Pi e appoggia sopra di esso.
- Salda i convertitori buck DC-DC con la polarità allineata correttamente: il blocco sui convertitori buck è rivolto verso l'alto, lontano dal PCB, e l'ingresso di tensione dei convertitori è sul lato sinistro della scheda, il più vicino al connettore XT60.
- Inserisci l'header maschio 1x2 nella sede al centro della scheda, poi cortocircuitane i pin con un jumper. In alternativa, cortocircuita tra loro le due piazzole o salda un filo ad anello. Questo collegamento attiva una resistenza da 120 Ohm sulla rete del bus CAN.
- Salda i JST, poi i connettori Molex.
- Salda il condensatore da 10uF con la polarità corretta: il catodo è rivolto verso il lato inferiore della scheda, lontano dall'XT60 e verso i connettori Molex.
- Salda il condensatore da 470uF ai terminali d'ingresso del convertitore DC-DC superiore: il catodo è rivolto verso l'ingresso negativo e l'anodo verso l'ingresso positivo.
3.6 Controlla la PCB principale prima di collegare il Pi
Monta un fusibile mini a lama da 20A e alimenta la PCB principale da un alimentatore, prima di collegare il Raspberry Pi.
- Verifica che tutti i connettori siano installati con l'orientamento corretto e controlla che non ci siano cortocircuiti attorno ai percorsi di alimentazione e ai regolatori.
- Inserisci un minifusibile a lama nel portafusibile prima della prova di accensione. Per la scheda principale il progetto originale usa un fusibile da 20A.
- Collega prima il PCB principale a un alimentatore per confermare che la tensione corretta arrivi all'ingresso 5V del Pi e alla linea a 24V per i connettori Molex a 4 pin. Il progetto originale raccomanda vivamente di fare questa prova PRIMA di collegare il Raspberry Pi.
- Poi collega la scheda principale a una scheda gamba e conferma che la scheda gamba riceva alimentazione quando accendi la scheda principale.
- Taglia la lunghezza in eccesso dei reofori dei condensatori radiali a foro passante per evitare cortocircuiti.
4. Configurazione dell'elettronica
Cabla la batteria, il relè e l'interruttore, realizza i cablaggi per ogni gamba e collega encoder e motori.
4.1 Cabla batteria, relè e interruttore a ritenuta
Una batteria Milwaukee M18 da 5Ah alimenta la PCB principale tramite un relè JD2914 che un interruttore a ritenuta accende e spegne.
- L'alimentazione proviene da una batteria Milwaukee M18 da 5Ah, viene inviata al PCB principale e distribuita da lì. Un relè gestisce l'accensione e lo spegnimento dell'esapode tramite un interruttore di alimentazione a ritenuta.
- Collegamenti: il polo (+) della batteria M18 va a un WAGO e da lì al pin 30 del relè e all'ingresso dell'interruttore a ritenuta. Il polo (-) della batteria M18 va a un WAGO e da lì al pin 85 del relè e alla massa del robot. L'ingresso dell'interruttore a ritenuta è il + della batteria. L'uscita dell'interruttore a ritenuta va al pin 86 del relè. L'alimentazione (+) dell'esapode è il pin 87 del relè. La massa (-) dell'esapode è il - della batteria.
- Piedinatura del relè JD2914: il pin 30 è il comune (COM), collegato alla batteria, filo rosso consigliato, ingresso di alimentazione principale dalla batteria M18. Il pin 87 è normalmente aperto (NO), collegato al + dell'alimentazione del robot, rosso, collegato al pin 30 quando il relè è eccitato. Il pin 87a è normalmente chiuso (NC): non collegato, lascialo inutilizzato e isolato. Il pin 85 è la bobina (-), collegato al - della batteria, nero, massa della bobina del relè. Il pin 86 è la bobina (+), collegato all'uscita dell'interruttore di alimentazione a ritenuta, rosso, eccita il relè quando l'interruttore è su ON.
- Lo schema dell'alimentazione e le foto del cablaggio di alimentazione del progetto originale accompagnano questa sezione nella pagina.
4.2 Pianifica l'ordine di accensione del Raspberry Pi
Il Raspberry Pi 5 va avviato dopo aver acceso l'esapode, cosa che gestisce un pulsante di accensione momentaneo sul Pi.
- A causa del rumore prodotto dalla combinazione dei convertitori buck e del relè, il Raspberry Pi 5 va avviato dopo aver acceso l'esapode.
- Il progetto originale dice che questo spegnimento e riaccensione si può gestire con le via del pulsante di accensione integrato del Pi 5. Consiglia header ad angolo retto e il cablaggio di un pulsante di accensione a impulso per attivare il riavvio; il coperchio di Hex3 ha un foro per un interruttore di accensione a impulso.
- Segui la sezione della documentazione del Raspberry Pi sull'aggiunta di un proprio pulsante di accensione.
4.3 Prepara i cablaggi
Taglia e crimpa alle lunghezze indicate i cavi a quattro conduttori 24 AWG per encoder e sensori a tempo di volo, i cavi motore a due conduttori 18 AWG e i cavi dorsali dalla scheda principale alle gambe.
- Encoder S0 a PCB della gamba: 120 mm, 4 conduttori 24 AWG, quantità 6. Estremità 1 senza connettore; estremità 2 alloggiamento JST XH femmina a 4 pin.
- Motore S0 a PCB della gamba: 130 mm, 2 conduttori 18 AWG, quantità 6. Estremità 1 senza connettore; estremità 2 spina Molex Microfit 3.0 a 2 pin.
- Encoder S1 a PCB della gamba: 250 mm, 4 conduttori 24 AWG, quantità 6. Estremità 1 senza connettore; estremità 2 alloggiamento JST XH femmina a 4 pin.
- Motore S1 a PCB della gamba: 265 mm, 2 conduttori 18 AWG, quantità 6. Estremità 1 senza connettore; estremità 2 spina Molex Microfit 3.0 a 2 pin.
- Encoder S2 a PCB della gamba: 405 mm, 4 conduttori 24 AWG, quantità 6. Estremità 1 senza connettore; estremità 2 alloggiamento JST XH femmina a 4 pin.
- Motore S2 a PCB della gamba: 365 mm, 2 conduttori 18 AWG, quantità 6. Estremità 1 senza connettore; estremità 2 spina Molex Microfit 3.0 a 2 pin.
- Sensore a tempo di volo (punta del piede) a PCB della gamba: 450 mm, 4 conduttori 24 AWG, quantità 6. Estremità 1 alloggiamento JST XH femmina a 4 pin; estremità 2 alloggiamento JST XH femmina a 5 pin. Il sensore della punta del piede è facoltativo e sperimentale: il progetto originale dice che al momento non è implementato nel software.
- PCB principale a PCB della gamba: 185 mm, 2 conduttori 18 AWG più doppino intrecciato a 2 conduttori 24 AWG, quantità 5. Entrambe le estremità spina Molex Microfit 3.0 a 4 pin.
- PCB principale a PCB della gamba: 250 mm, stessi fili e connettori, quantità 1. Il progetto originale dice che questo serve per la gamba dietro il collegamento della batteria.
- Una volta completata la fase dell'elettronica dovresti avere almeno 1 gruppo di alimentazione, 18 encoder e 6 sensori a tempo di volo per le punte dei piedi (i sensori sono una funzione sperimentale).
4.4 Cabla gli encoder
Metti a massa il pin DIR di ogni encoder con un ponticello, poi collega il cablaggio a quattro conduttori alla scheda dell'encoder e al suo connettore JST.
- Il pin DIR dell'encoder deve essere collegato a massa. Fallo direttamente sulla scheda dell'encoder con un piccolo ponticello tra DIR e GND; è separato dal cablaggio a 4 conduttori.
- Se usi i cablaggi a 4 conduttori del progetto originale, questo consiglia il seguente cablaggio, per coerenza con l'ordine dei connettori sulla scheda: rosso è VCC sul pin 1 del JST; nero è GND sul pin 2; blu è SCL sul pin 3; verde è SDA sul pin 4.
- Quando saldi i fili degli encoder direttamente alle schede encoder S0, S1 e S2, tieni le saldature quasi a filo con la scheda. Lo stagno in rilievo può sporgere più dei condensatori vicini e impedire all'encoder di stare a filo una volta montato; nel montaggio meccanico gli encoder devono essere installati perfettamente a filo.
4.5 Cabla i motori
La polarità dei motori non conta, ma mantienila coerente, perché determina le costanti di inversione degli assi in config.hpp.
- La polarità del cablaggio verso i motori non conta, ma sii coerente.
- La scelta della polarità influisce sulle costanti di inversione degli assi in config.hpp (nel firmware di Hex3, in lib/HexapodController/src). Se colleghi il terminale negativo del motore al pin 1 del connettore Molex, ottieni i valori di inversione degli assi {true, false, false}.
4.6 Cabla i cavi tra le PCB delle gambe e la PCB principale
Collega i cavi dorsali a quattro conduttori come viola, rosso, nero e bianco ai pin Molex da 1 a 4.
- Se usi i cablaggi del progetto originale, questo consiglia: viola è GND sul pin 1 del Molex; rosso è VCC sul pin 2; nero è CAN LOW sul pin 3; bianco è CAN HIGH sul pin 4.
5. Montaggio meccanico
Prepara le parti stampate, costruisci ogni gamba da S0 a S3, poi monta le gambe, i PCB e il Raspberry Pi nella base.
5.1 Installa gli inserti filettati a caldo nelle parti delle gambe
Prima del montaggio, inserisci a pressione gli inserti filettati a caldo in ottone M3 e M4 nelle parti S0, S1, S2 e S3.
- Il progetto originale dice che puoi inserire gli inserti a caldo una parte alla volta, per tutte le parti di una gamba o per tutte le parti di tutte le gambe. Queste istruzioni sono per gamba. Se la posizione di una vite, di un inserto o di altro non è chiara, consulta il CAD; tutta la minuteria è nell'assieme Fusion360.
- Inserti filettati a caldo M3: S0 4x per il supporto dell'encoder. S1 4x per il supporto dell'encoder, 6x per i collegamenti della base superiore e inferiore, 2x per la copertura del motore. S2 3x sul lato ingranaggio di S2, 4x per il supporto dell'encoder, 2x per il supporto del magnete dell'encoder. S3 2x per il supporto del magnete dell'encoder.
- Inserti filettati a caldo M4: S1 4x per il collegamento dell'ingranaggio del mozzo. S2 4x per il collegamento dell'ingranaggio del mozzo e 6x per il connettore lungo di S2. S3 4x per il collegamento dell'ingranaggio del mozzo, 4x sul lato ingranaggio di S3 per unire i pezzi, e 2x nel pezzo della punta del piede.
5.2 Inserisci a pressione i magneti e i cuscinetti
Inserisci a pressione a filo i magneti degli encoder, poi i cuscinetti piccoli da 6mmx10mmx3mm e quelli grandi da 25x32x4mm nelle parti delle gambe.
- Inserisci a pressione i magneti degli encoder. Devono essere perfettamente a filo e non montati inclinati. S1: 1x direttamente sulla parte. S2: 1x sul portamagnete rimovibile. S3: 1x sul portamagnete rimovibile. Poi installa i portamagnete di S2 e S3 sulle rispettive parti.
- Inserisci a pressione i cuscinetti piccoli dei motori (6mmx10mmx3mm), che vanno su tutte le parti che si accoppiano con l'albero di un motore: S0 1x sulla copertura dell'ingranaggio di S0; S1 2x sul portacuscinetto del motore di S1; S2 1x sul connettore corto di S2.
- Inserisci a pressione i cuscinetti grandi (25x32x4mm): S1 2x in S1 e 1x nel supporto del cuscinetto del motore di S1; S2 1x sul lato cuscinetto di S2 e 1x sul lato ingranaggio di S2.
5.3 Installa gli encoder
Alloggia gli encoder S0, S1 e S2 a filo usando l'attrezzo di inserimento degli encoder, poi rimuovi le loro viti.
- Installa gli encoder con l'attrezzo di inserimento degli encoder (encoder_insertion_tool in Hex3_resources/cad), assicurandoti che siano perfettamente a filo con la parte. Fai attenzione a non graffiare il PCB durante l'installazione. Una volta montato l'encoder, togli le sue viti.
- S0: 1x encoder installato. S1: 1x encoder installato con la sua copertura (2 viti restano attraverso la copertura). S2: 1x encoder installato sul lato cuscinetto.
5.4 Monta S0
Monta il motore S0 con due viti M3x08, l'ingranaggio da 15 denti e il coperchio dell'ingranaggio S0 con due viti M3x18.
- La posizione del grano sull'ingranaggio da 15 denti (quello piccolo) è critica e varia da motore a motore, quindi verificala sul CAD. Il progetto originale consiglia anche di applicare un po' di Loctite blu sul grano quando fissi l'ingranaggio all'albero motore.
- Fissa il motore a S0 con due viti M3x08.
- Inserisci il distanziale della copertura dell'ingranaggio di S0.
- Monta l'ingranaggio da 15 denti sull'albero del motore di S0 con il grano più vicino al motore.
- Fissa la copertura dell'ingranaggio di S0 con due viti M3x18.
- Lascia il resto del montaggio a un passaggio successivo.
5.5 Monta S1
Monta due motori in S1 con tre viti ciascuno, aggiungi a ognuno un ingranaggio da 15 denti, l'ingranaggio del mozzo su quattro viti M4 e il coperchio del motore su due viti M3.
- Installa i due motori in S1, usando solo le 3 viti più vicine all'encoder su ciascun motore. Fai uscire i fili dal retro di S1.
- Fai uscire il filo dell'encoder dal retro di S1, passando tra i due motori.
- Inserisci il portacuscinetto del motore di S1.
- Monta un ingranaggio da 15 denti sull'albero di ciascun motore di S1 con il grano più vicino alla base del motore.
- Installa l'ingranaggio del mozzo con quattro viti M4.
- Installa la copertura del motore di S1 con due viti M3.
- Lascia il resto del montaggio a un passaggio successivo.
5.6 Monta S2
Monta il motore di S2 attraverso i pezzi corto e lungo di S2 con sei viti M3x08, aggiungi l'ingranaggio da 15 denti e l'ingranaggio del mozzo su quattro viti M4.
- Installa il motore di S2 attraverso i pezzi S2 corto e S2 lungo. Uniscili con 6 viti M3x08.
- Monta l'ingranaggio da 15 denti sull'albero del motore di S2 con il grano più lontano dal motore.
- Installa l'ingranaggio del mozzo con 4x viti M4.
- Lascia il resto del montaggio a un passaggio successivo.
5.7 Monta S3
Costruisci la punta del piede molleggiata con viti M4x60 e chiudi S3 con due viti M4x30 e due M4x35.
- Installa l'ingranaggio del mozzo con il supporto dell'ingranaggio di S3.
- Unisci la molla, l'allineatore della molla e la punta del piede con viti M4x60.
- Inserisci il gruppo della punta del piede in S3.
- Facoltativamente, aggiungi il sensore a tempo di volo per la distanza della punta del piede. È un componente sperimentale: il progetto originale dice che al momento della stesura il sensore non è stato implementato completamente nel software.
- Chiudi il gruppo con quattro viti M4 (due M4x30 e due M4x35).
- Lascia il resto del montaggio a un passaggio successivo.
5.8 Unisci S1, S2 e S3 in una gamba
Unisci a pressione i gruppi S1, S2 e S3 e bloccali con tre viti M4.
- Fissa il lato ingranaggio di S2 in S1 inserendo in S1 il pezzo di collegamento del cuscinetto di S2.
- Blocca insieme il lato ingranaggio di S2 e S1 aggiungendo il supporto del cuscinetto del motore di S2 e il portaingranaggio del motore di S1.
- Collega il lato cuscinetto di S2 e il gruppo del motore di S2 con 3 viti M4.
- Unisci a sandwich il gruppo lato ingranaggio S1/S2, il gruppo S3 e il gruppo S2 con motore. Vanno tutti incastrati a pressione e bloccati con 3 viti M4.
- Il gruppo della gamba è completo. Ripeti per tutte e sei le gambe; nel passaggio successivo le gambe si fissano a S0 e alla base.
5.9 Prepara e monta la base
Fissa le PCB delle gambe, S0, il relè e i supporti delle PCB, i connettori HDMI e USB, base lower, le gambe, il Raspberry Pi e base upper.
- Inserisci tutti gli inserti filettati a caldo M3 e M4 secondo l'assieme Fusion360. Inserisci a pressione tutti i cuscinetti nelle piastre delle gambe e installa in ciascuna il portacuscinetto di S1.
- Fissa ciascuno dei sei PCB delle gambe a un lato della base dell'esapode.
- Fissa S0 con le 2-4 viti M4 sulle piastre delle gambe.
- Installa il relè e il supporto del PCB con la protezione del PCB. La pagina meccanica del progetto originale rimanda per questi alla sua pagina dell'elettronica; quella pagina non li descrive, quindi usa l'assieme Fusion360.
- Installa il connettore HDMI e il connettore USB sulla base inferiore.
- Fissa la base inferiore con viti M4. Le viti M3 lunghe devono attraversare la base inferiore ed entrare nell'attacco di S0.
- Inserisci con cura i gruppi delle gambe nei lati dell'esapode, ingranando l'ingranaggio del mozzo di S1 di ogni gamba con l'ingranaggio condotto di S0 (se l'allineamento degli ingranaggi non è chiaro, consulta il CAD), e fai attenzione ad allineare le 3 viti M3 sulla base superiore e su quella inferiore.
- Installa il Raspberry Pi e cabla gli interruttori di alimentazione sulla base superiore. Fissa la base superiore in posizione.
- Il progetto originale dice che a questo punto il montaggio è completo, con tutte e sei le gambe pronte per la calibrazione.
6. Firmware in tempo reale e calibrazione
Compila e carica il firmware dello Xiao RP2350 per ogni gamba con PlatformIO, poi calibra ogni gamba.
6.1 Installa gli strumenti e apri il progetto del firmware
Installa VS Code con l'estensione PlatformIO IDE e apri real_time/xiao_code dal repository Hex3.
- Requisiti: VS Code con l'estensione PlatformIO IDE e un Seeed Xiao RP2350 collegato via USB. Il progetto originale dice che le dipendenze delle librerie (RP2040_PWM, PID, RP2040PIO_CAN e il driver Adafruit VL6180X del sensore della punta del piede) sono dichiarate in platformio.ini e si installano automaticamente.
- Il firmware è in real_time/xiao_code nel repository Hex3; la pagina di Hex3 del progetto originale rimanda al repository dal glossario del progetto. La pagina del firmware non indica un comando di download.
- In VS Code usa Open Folder e seleziona real_time/xiao_code. PlatformIO rileva platformio.ini, che ha come destinazione l'ambiente seeed_xiao_rp2350.
6.2 Crea user_config.hpp per ogni gamba
Copia TEMPLATE_user_config.hpp in src/user_config.hpp e imposta un LEG_NUMBER univoco da 0 a 5 per ogni scheda.
- user_config.hpp è escluso di proposito da git perché contiene impostazioni specifiche di ogni scheda, quindi crea una tua copia prima di compilare il firmware.
- Copia lib/HexapodController/TEMPLATE_user_config.hpp in lib/HexapodController/src/user_config.hpp.
- Imposta LEG_NUMBER sulla gamba (da 0 a 5) su cui è montata questa scheda. Deve essere univoco per ogni gamba. Imposta anche l'ID del nodo CAN della scheda: 0x100 + LEG_NUMBER per i comandi dal Pi e 0x180 + LEG_NUMBER per le risposte, ed è così che il nodo ROS2 can del Pi indirizza ogni gamba.
- Imposta LOG_LEVEL e TELEMETRY_LOGGING_SPACE in base a quanta telemetria seriale vuoi durante il debug.
- Aggiungi o seleziona un blocco di calibrazione #ifdef <YOUR_NAME> ... #endif per questa gamba in lib/HexapodController/src/config.hpp, usando il passaggio di calibrazione seguente per generare i valori ZERO_POINTS.
- Se hai PCB delle gambe V3.2, prima del caricamento applica la modifica a leg.cpp della fase di montaggio dei PCB.
6.3 Compila e carica il firmware
Compila e carica con l'ambiente seeed_xiao_rp2350, poi verifica sul monitor seriale a 115200 baud che la scheda si avvii.
- Con l'ambiente seeed_xiao_rp2350 selezionato in PlatformIO, esegui il build per compilare il firmware.
- Carica il firmware mentre lo Xiao è collegato via USB.
- Apri il Serial Monitor di PlatformIO a 115200 baud per confermare che la scheda si avvii e stampi gli ID dei nodi CAN tx/rx, insieme alla telemetria di posizione, velocità e accelerazione dei giunti.
6.4 Calibra ogni gamba
Imposta i ZERO_POINTS a 0.0, tieni la gamba nella posa di calibrazione con l'esapode spento, leggi le posizioni dei giunti dal monitor seriale e inseriscile per quella gamba.
- Crea un profilo utente nel file config.hpp (non config.cpp). Ha la forma: #ifdef USER, poi #define STEP_THRESHOLD 40, #define FIFO_IDLE_THRESHOLD 100, poi #define ZERO_POINTS come sei righe (una per gamba) di tre valori ciascuna, ogni valore scritto come un numero più CALIBRATION_OFFSET_A0, CALIBRATION_OFFSET_A1 o CALIBRATION_OFFSET_A2, poi #endif.
- Per calibrare, imposta a 0.0 sia i valori di configurazione sia gli offset di calibrazione, in modo che ogni voce sia 0.0 + 0.0.
- Spegni l'esapode, porta la gamba nella posizione di calibrazione e collega lo Xiao RP2350 alla scheda madre. Nella posizione di calibrazione: S1 è parallelo al pannello laterale dell'esapode; S2 è il più in basso possibile, con i 3 fili che entrano in S1 disposti a filo (la distanza tra S1 e S2 è esattamente 1 diametro del filo); S3 è il più in alto possibile (la distanza tra S2 e S3 è esattamente 1 diametro del filo). L'immagine delle istruzioni di calibrazione del progetto originale mostra questa posa.
- Carica main.cpp e apri il monitor seriale. Dovresti vedere un valore come: {"Joint": {"pos": [0.547631, -0.836020, 2.787243], "vel": [0.000049, 0.006216, 0.000052], "acc": [-0.001082, 4.619407, -0.000955], "duty": [80.000000, -80.000000, -80.000000]}, "voltage": 0,730000, "toe": 0,000000}
- Aggiungi il codice alla gamba che stai calibrando. Per esempio, per Leg0 la prima riga di ZERO_POINTS diventa 0.547631 + CALIBRATION_OFFSET_A0, -0.836020 + CALIBRATION_OFFSET_A1, 2.787243 + CALIBRATION_OFFSET_A2, e le altre cinque righe restano 0.0 + 0.0.
- Carica il codice sulla gamba e assicurati che sia in posizione eretta. Conferma in user_config.hpp di aver impostato il LEG_NUMBER corretto.
- Ripeti per tutte le 6 gambe.
7. Configurazione del Raspberry Pi
Scrivi Raspberry Pi OS, installa Docker, abilita l'interfaccia CAN, associa il controller e compila il container ROS2.
7.1 Scrivi l'immagine sulla scheda SD
Scrivi Raspberry Pi OS (64-bit) su una scheda micro SD da 64GB o più con Raspberry Pi Imager.
- Requisiti: Raspberry Pi 5; scheda micro SD (preferibilmente da 64GB o più); cavo da micro HDMI a HDMI; tastiera USB; mouse USB.
- Scarica Raspberry Pi Imager. Seleziona Raspberry Pi 5 come scheda e Raspberry Pi OS (64-bit). Seleziona la tua scheda micro SD.
- Seleziona le impostazioni di configurazione. Consigliate: nome host hexapod-<last_name>; utente hexapod<last_name>; attiva SSH tramite autenticazione.
- Fai clic su salva e attendi. Una volta scritta la scheda, inseriscila nel Pi e collega le periferiche.
7.2 Installa Docker
Installa Docker con lo script get.docker.com e aggiungi il tuo utente al gruppo docker.
- Aggiorna il sistema: sudo apt update && sudo apt full-upgrade -y
- Scarica lo script di installazione di Docker: curl -fsSL https://get.docker.com -o get-docker.sh
- Installa Docker: sudo sh get-docker.sh
- Aggiungi il tuo utente al gruppo docker: sudo usermod -aG docker $USER
- Esci e rientra, o riavvia, perché la modifica del gruppo abbia effetto: sudo reboot
- Verifica l'installazione: docker --version, docker compose version, docker run hello-world
7.3 Aggiungi le impostazioni CAN alla configurazione
Aggiungi dtparam=spi=on e l'overlay mcp2515-can0 a /boot/firmware/config.txt.
- Apri il file di configurazione: sudo nano /boot/firmware/config.txt
- Aggiungi queste righe alla fine del file: dtparam=spi=on e dtoverlay=mcp2515-can0,oscillator=16000000,interrupt=25
7.4 Configura il servizio dell'interfaccia CAN
Installa can-utils e crea un'unità systemd canbus.service che attiva can0 a 500000 bit/s.
- Installa can-utils: sudo apt install can-utils
- Ottieni il percorso di ip con: which ip. Il risultato di esempio del progetto originale è /usr/sbin/ip.
- Crea /etc/systemd/system/canbus.service con il contenuto: [Unit] Description=CAN Bus Interface; [Service] ExecStart=/usr/sbin/ip link set can0 up type can bitrate 500000, Type=oneshot, RemainAfterExit=yes; [Install] WantedBy=multi-user.target. Usa il percorso ottenuto con il comando precedente.
- Avvia il servizio: sudo systemctl start canbus.service
7.5 Associa il controller Xbox
Associa un controller Xbox Core tramite l'interfaccia Bluetooth di Raspberry Pi OS o dal terminale.
- Collega il controller Xbox Core (Series S, X ecc.) dall'interfaccia Bluetooth di Raspberry Pi OS o dal terminale.
7.6 Imposta il nome del robot e compila i nodi ROS2
Scrivi il nome del tuo esapode in robot_name.local.txt, assegnagli un ROS_DOMAIN_ID univoco ed esegui colcon build nel dev container.
- Il codice per il Pi e ROS2 è nella cartella non_real_time del repository Hex3, collegato dalla pagina di Hex3 del progetto originale. La pagina del Raspberry Pi non indica un comando di download.
- Apri non_real_time/container/src/ros2_ws/src/hexapod_manager/config/robot_name.local.txt e aggiungi il nome del tuo esapode. Deve essere l'unico testo del file.
- Assicurati che il nome del robot sia in non_real_time/container/src/ros2_ws/src/hexapod_manager/launch/hexapod.launch.py con un ROS_DOMAIN_ID univoco.
- Da non_real_time/container, inizializza il dev container con ./init_dev.sh, apri una nuova shell con ./new_dev_shell.sh, poi compila i nodi ROS2 con colcon build.
- Le modifiche hanno effetto al successivo riavvio del Pi. Per provare prima puoi anche eseguire: docker compose -f docker-compose-prod.yml up
7.7 Avvia lo stack di camminata
Con l'esapode acceso per primo, il Pi avviato e il controller collegato, avvia hexapod.launch.py nel dev container.
- Accendi l'esapode prima di avviare il Pi 5, come descritto nella fase dell'elettronica.
- Prima dell'avvio, accendi il controller Xbox e collegalo al Pi via Bluetooth.
- Nel container di sviluppo esegui: ros2 launch hexapod_manager hexapod.launch.py. Avvia in un colpo solo control, joy, inverse_kinematics, can_interface e tripod_gait, ed è il modo standard del progetto originale per avviare l'esapode per la camminata comandata con il controller Xbox.
- Facoltativo: ros2 run hexapod_manager led_controller comanda l'anello LED sul fondo dell'esapode. ros2 run hexapod_tester hexapod_tester fa variare la posa del corpo e i target dei piedi senza controller, con il file di launch in esecuzione in un'altra shell.
- Comandi di debug del CAN, da eseguire nel terminale del Pi e non nel container docker, di solito non necessari perché un servizio attiva il CAN: sudo ip link set can0 down; sudo ip link set can0 type can bitrate 500000; sudo ip link set can0 up; candump can0; cansend can0 123#DEADBEEF