Racconti sonori per la vela: 11 passaggi

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

I rivelatori sono pezzi di corda usati nella vela per indicare se c'è un flusso turbolento o laminare attraverso la vela. Tuttavia, i diversi pezzi di filo colorati attaccati a ciascun lato della vela sono indicatori puramente visivi. Queste spie sonore sono un dispositivo di assistenza che mira a comunicare le informazioni visive in forma uditiva per i marinai sia vedenti che ipovedenti, come Pauline.

Il dispositivo è costituito da un sistema di input, che legge il movimento della spia, e un sistema di output, che emette una serie di segnali acustici che convogliano le informazioni sul flusso d'aria.

Per la fabbricazione di questo dispositivo è richiesto l'accesso all'attrezzatura di saldatura e a una stampante 3D.

Passaggio 1: Distinta base

BOM con link e prezzi

Nota: avrai bisogno di 2 set di tutti i seguenti.

Sistema di input

• Arduino Nano
• PCB per breadboard di dimensioni ridotte Adafruit perma-proto
• Modulo ricetrasmettitore wireless nRF24L01
• Foto interruttore
• Scheda di breakout dell'interruttore fotografico Sparkfun
• Batteria 9V compatibile con Arduino
• Batteria da 9V
• Diverse lunghezze di cavo calibro 22
• Filato
• Magneti al neodimio
• epossidico

Sistema di uscita

• Arduino Nano
• PCB per breadboard di dimensioni ridotte Adafruit perma-proto
• Modulo ricetrasmettitore wireless nRF24L01
• Batteria 9V compatibile con Arduino
• Potenziometro 1K Ohm
• Resistenza da 120 Ohm
• Transistor 2N3904
• Condensatore da 0,1 uF
• Altoparlante compatibile con Arduino

File GitHub

• Tutto il codice e i file STL necessari per costruire queste spie possono essere trovati in questo repository GitHub.
• Avrai bisogno di due set della custodia e uno dell'alloggiamento dell'altoparlante.

Passaggio 2: strumenti/macchine/requisiti software

Per programmare Arduino dovrai scaricare l'IDE Arduino. Il link per il download può essere trovato qui.

Per programmare il modulo nRF24L01, dovrai scaricare la sua libreria tramite l'IDE di Arduino. Strumenti > Gestisci librerie… > installa libreria RF24

Per assemblare i componenti elettronici è necessario l'accesso agli strumenti di saldatura di base. Può essere utile anche una pompa dissaldante, ma non è necessaria.

Per costruire il telaio rivelatore e la cassa dell'altoparlante avrai bisogno di accedere a una stampante 3D.

Passaggio 3: hardware rivelatore

Assemblare il circuito secondo gli schemi sopra. L'Arduino Nano dovrebbe essere allineato con la parte superiore della scheda prototipi. Ciò consente di accedere alla porta USB anche dopo che tutta l'elettronica è stata collegata.

Per evitare di cortocircuitare l'elettronica, assicurati di tagliare le tracce della scheda prototipi sulle file che occuperà l'nRF24 come mostrato nell'immagine sopra.

Altrimenti avrai bisogno di cavi jumper per collegare l'nRF24 alla scheda prototipi.

La connessione del resistore, GND e i fili da 5 V al fotointerruttore non sono raffigurati. Cablare il fotointerruttore come indicato sulla scheda breakout. È inclusa un'immagine della breakout board.

I circuiti per le spie di destra e di sinistra sono esattamente gli stessi.

Passaggio 4: software rivelatore

Ecco il codice per la spia di destra. Collega il nano del rivelatore Right al tuo computer, apri l'IDE Arduino, copia e incolla questo codice al suo interno e caricalo sulla scheda.

/** Programma che utilizza photogate per esaminare la spia

*/ #include #include #include #include radio RF24(9, 10); // CE, CSN const byte address[6] = "00010"; //---programma consts--- //time const int string_check_time = 1; const int flow_check_time = 30; const int base_delay = 5; const int flow_check_delay = 0; const int GATE_PIN = 6; const int GATE_PIN_2 = 7; const int max_quando_test = flow_check_time * 0.6; //imposta la var sopra in base alle tue prove sperimentali const int max_in_flow = min(max_when_testing, int(flow_check_time/string_check_time)); const int msg_max_val = 9; //const int string_thresh = 20; #define STRING_THRESH 0.2 //---program vars--- int num_string_seen = 0; int num_loops = 0; void setup() { //while(!Serial); // per la flora //delay(500); num_string_seen = 0; num_loop = 0; pinMode(GATE_PIN, INPUT); pinMode(GATE_PIN_2, INPUT); Serial.begin(115200); // per il debug di radio.begin(); radio.openWritingPipe(indirizzo); radio.setPALevel(RF24_PA_MIN); radio.stopListening(); } void loop() { // inserisci qui il tuo codice principale, per eseguirlo ripetutamente: if(num_loops % string_check_time == 0){ //controlla lo stato della stringa check_string(); } if(num_loops == flow_check_time){ //esamina il flusso //Serial.println(num_string_seen); int flusso_num = esaminare_flusso(); //invia valori send_out(flow_num); //reimposta le variabili num_string_seen = 0; num_loop = 0; delay(flow_check_delay); } num_loop++; ritardo(base_delay); } /* *Metodo per verificare se la stringa attraversa il gate */ void check_string(){ int string_state = digitalRead(GATE_PIN); //Serial.println(string_state); if (string_state == 0){ num_string_seen++; //Serial.println("Ho visto la stringa!"); }

int bot_state = digitalRead(GATE_PIN_2);

if (bot_state == 0){ num_string_seen--; //Serial.println("stringa in basso!"); } //Serial.print("La stringa di conteggio passa: "); //Serial.println(num_string_seen); Restituzione; } /* * Metodo per analizzare quale frazione di stringa temporale ha coperto il gate */ int exam_flow(){ double percent_seen = double(num_string_seen)/max_in_flow; Serial.print("Percentuale coperta: "); printDouble(percent_seen, 100); //scala il valore alla scala di comunicazione int scaled_flow = int(percent_seen * msg_max_val); if(scaled_flow > msg_max_val){ scaled_flow = msg_max_val; } if(scaled_flow = 0) frac = (val - int(val)) * precision; else frac = (int(val)- val) * precisione; Serial.println(frac, DEC); }

Ecco il codice per la spia di sinistra. Segui gli stessi passaggi sopra per la spia sinistra. Come puoi vedere, l'unica differenza è l'indirizzo a cui la spia invia i suoi risultati.

/** Programma che utilizza photogate per esaminare la spia

*/ #include #include #include #include radio RF24(9, 10); // CE, CSN const byte address[6] = "00001"; //---programma consts--- //time const int string_check_time = 1; const int flow_check_time = 30; const int base_delay = 5; const int flow_check_delay = 0; const int GATE_PIN = 6; const int GATE_PIN_2 = 7; const int max_quando_test = flow_check_time * 0.6; //imposta la var sopra in base alle tue prove sperimentali const int max_in_flow = min(max_when_testing, int(flow_check_time/string_check_time)); const int msg_max_val = 9; //const int string_thresh = 20; #define STRING_THRESH 0.2 //---program vars--- int num_string_seen = 0; int num_loops = 0; void setup() { //while(!Serial); // per la flora //delay(500); num_string_seen = 0; num_loop = 0;

pinMode(GATE_PIN, INPUT);

pinMode(GATE_PIN_2, INPUT); Serial.begin(115200); // per il debug di radio.begin(); radio.openWritingPipe(indirizzo); radio.setPALevel(RF24_PA_MIN); radio.stopListening(); }void loop() { // inserisci qui il tuo codice principale, per eseguirlo ripetutamente: if(num_loops % string_check_time == 0){ //controlla lo stato della stringa check_string(); } if(num_loops == flow_check_time){ //esamina il flusso //Serial.println(num_string_seen); int flusso_num = esaminare_flusso(); //invia valori send_out(flow_num); //reimposta le variabili num_string_seen = 0; num_loop = 0; delay(flow_check_delay); } num_loop++; ritardo(base_delay); } /* *Metodo per verificare se la stringa attraversa il gate */ void check_string(){ int string_state = digitalRead(GATE_PIN); //Serial.println(string_state); if (string_state == 0){ num_string_seen++; //Serial.println("Ho visto la stringa!"); }

int bot_state = digitalRead(GATE_PIN_2);

if (bot_state == 0){ num_string_seen--; //Serial.println("stringa in basso!"); } //Serial.print("La stringa di conteggio passa: "); //Serial.println(num_string_seen); Restituzione; } /* * Metodo per analizzare quale frazione di stringa temporale ha coperto il gate */ int exam_flow(){ double percent_seen = double(num_string_seen)/max_in_flow; Serial.print("Percentuale coperta: "); printDouble(percent_seen, 100); //scala il valore alla scala di comunicazione int scaled_flow = int(percent_seen * msg_max_val); if(scaled_flow > msg_max_val){ scaled_flow = msg_max_val; } if(scaled_flow = 0) frac = (val - int(val)) * precision; else frac = (int(val)- val) * precisione; Serial.println(frac, DEC); }

Passaggio 5: assemblaggio rivelatore

Parti singole

• Cornice rivelatrice
• Filato
• Circuito rivelatore costruito
• Pacco batteria
• Nastro elettrico
• Epossidica o colla

STL per componenti rivelatori di stampa 3D

• STL per cornice spia: sinistra, destra
• STL per la scatola dell'elettronica: in alto, in basso

Istruzioni di montaggio

1. Posiziona i magneti a barra nelle fessure del telaio rivelatore stampato in 3D. Assicurati che i magneti siano allineati correttamente tra il telaio destro e il telaio sinistro, quindi usa la resina epossidica (o la colla) per fissare i magneti al telaio. Lascia che la resina epossidica (o la colla) si fissi completamente.
2. Posizionare i fotointerruttori nelle fessure superiore e inferiore sul retro del telaio. Con cura epossidica (o incollare) le schede dell'interruttore fotografico sul telaio. Lasciare che la resina epossidica (o la colla) si indurisca completamente
3. Taglia un ~ 7 in un pezzo di filo. Lega un'estremità del filo alla tacca della prima barra verticale. Tagliare un piccolo pezzo di nastro isolante e avvolgere il nastro isolante sulla sezione del filo che sarà nella regione delle fotorompitrici. Infilare il filo attraverso il telaio in modo che passi attraverso lo spazio del cancello dell'interruttore della foto.
4. Posiziona i magneti a barra nelle fessure del fondo della scatola dell'elettronica stampata in 3D. Assicurati che i magneti siano allineati correttamente tra la scatola destra e la scatola sinistra, quindi usa la resina epossidica (o la colla) per fissare i magneti al telaio. Lascia che la resina epossidica (o la colla) si fissi completamente.
5. Posiziona il circuito rivelatore costruito nella scatola dell'elettronica, allineando i diversi componenti ai loro slot. Chiudi la scatola con la parte superiore della scatola dell'elettronica stampata in 3D. Epossidica (o incollare) il pacco batteria sulla parte superiore della scatola in modo che l'interruttore sia esposto.

Passaggio 6: hardware dell'altoparlante

Il sistema di uscita è composto da due circuiti di altoparlanti, uno per ogni spia, dotati di comunicazione wireless e manopola di regolazione del volume. Per prima cosa, prepara le schede prototipi per l'uso con i moduli nRF24L01 come abbiamo fatto per i circuiti rivelatori tagliando i cavi che separano le due file di pin in cui verrà posizionata la scheda.

Quindi, assemblare il circuito come mostrato nello schema sopra facendo riferimento alle foto dei circuiti completati.

Istruzioni per l'assemblaggio della scheda

Per impilare le schede nella cassa dell'altoparlante, i componenti principali devono essere posizionati in determinate aree della scheda. Nelle seguenti istruzioni, farò riferimento al sistema di coordinate utilizzato per indicare righe e colonne sulla scheda prototipi di Adafruit:

1. L'Arduino Nano deve essere posizionato contro il bordo superiore della scheda al centro in modo che il pin Vin sia posizionato su G16. Ciò consentirà una facile riprogrammazione dell'Arduino Nano dopo che il circuito è stato assemblato.
2. La scheda nRF24L01 deve essere posizionata nell'angolo inferiore destro della scheda coprendo le otto posizioni da C1 a D5. Ciò lascerà l'nRF24L01 appeso alla scheda prototipi per consentire una migliore comunicazione wireless.
3. Il pacco batteria per il sistema di altoparlanti alimenta entrambe le schede prototipi, quindi assicurati di collegare i due binari/pin GND di Arduino Nano e i pin Vin all'alimentatore.

4. Per il circuito "inferiore", il potenziometro deve essere posizionato sulla parte superiore della scheda rivolto verso l'esterno in modo che i suoi pin siano posizionati nelle posizioni J2, J4 e J6

   1. J2 ↔ Uscita Arduino Nano dal pin 3 digitale (D3)
   2. J4 pin di base del transistor 2N3904
   3. J6 ↔ non connesso

5. Per il circuito "top", il potenziometro deve essere posizionato sul fondo della scheda rivolto verso l'esterno in modo che i suoi pin siano posizionati nelle posizioni J9, J11 e J13

   1. J13 ↔ Uscita Arduino Nano dal pin digitale 3 (D3)
   2. J11 (pin base del transistor 2N3904)
   3. J9 ↔ non connesso

Passaggio 7: software per altoparlanti

Ecco il codice per l'altoparlante che comunica con la spia di sinistra. Collega l'Arduino Nano sulla scheda dell'altoparlante inferiore al tuo computer, apri l'IDE Arduino, copia e incolla questo codice al suo interno e caricalo sulla scheda.

#includere

#include #include radio RF24(7, 8); // CE, CSN //spia sinistra, scheda altoparlante superiore const byte address[6] = "00001"; const int passo = 2000; const int pitch_duration = 200; const int altoparlante = 3; const int delay_gain = 100; int stato = 0; int cur_delay = 0; carattere letto[2]; void setup() { pinMode(altoparlante, OUTPUT); Serial.begin(115200); Serial.println("Avvio comunicazione wireless…"); radio.begin(); radio.openReadingPipe(0, indirizzo); radio.setPALevel(RF24_PA_MIN); radio.startListening(); } void loop() { if(radio.available()) { radio.read(&read, sizeof(read)); stato = (int)(read[0]-'0'); Serial.print("Ricevuto: "); Serial.println(stato); cur_delay = delay_gain*stato; } if (cur_delay) { tone(speaker, pitch, pitch_duration); delay(cur_delay + pitch_duration); Serial.println("Bip!"); } }

Ecco il codice per l'altoparlante che comunica con la spia giusta. Collega l'Arduino Nano sulla scheda dell'altoparlante superiore al tuo computer, apri l'IDE di Arduino, copia e incolla questo codice al suo interno e caricalo sulla scheda.

#includere

#include #include radio RF24(7, 8); // CE, CSN //spia destra, scheda altoparlante inferiore const byte address[6] = "00010"; const int passo = 1500; const int pitch_duration = 200; const int altoparlante = 3; const int delay_gain = 100; int stato = 0; int cur_delay = 0; carattere letto[2]; void setup() { pinMode(altoparlante, OUTPUT); Serial.begin(115200); Serial.println("Avvio comunicazione wireless…"); radio.begin(); radio.openReadingPipe(0, indirizzo); radio.setPALevel(RF24_PA_MIN); radio.startListening(); } void loop() { if (radio.available()) { radio.read(&read, sizeof(read)); stato = (int)(read[0]-'0'); Serial.print("Ricevuto: "); Serial.println(stato); cur_delay = delay_gain*stato; } if (cur_delay) { tone(speaker, pitch, pitch_duration); delay(cur_delay+pitch_duration); Serial.println("Bip!"); } }

Passaggio 8: assemblaggio degli altoparlanti

Parti singole

• 2 circuiti di altoparlanti costruiti
• 2 altoparlanti
• 1 pacco batteria

STL per la stampa 3D

• Scatola in alto
• Fondo della scatola

Istruzioni di montaggio fisico

1. Posiziona con cura i circuiti degli altoparlanti nella parte inferiore della scatola, una scheda sopra l'altra in modo che le manopole del volume siano una accanto all'altra e scivolino nei fori. I chip di comunicazione devono essere esposti sul retro della scatola.
2. Posizionare gli altoparlanti a sinistra ea destra della scheda del circuito, assicurandosi che gli altoparlanti corrispondano ai lati rivelatori corretti. Allineare gli altoparlanti alle fessure sui lati della scatola.
3. Fai passare i fili del pacco batteria attraverso il piccolo foro sul retro della scatola. Epossidica (o incollare) il pacco batteria sul retro della scatola in modo che l'interruttore sia esposto.
4. Posiziona la scatola stampata in 3D sopra la parte inferiore della scatola per contenere tutto.

Passaggio 9: installazione/montaggio

1. Accendi le spie spostando gli interruttori sui pacchi batteria in posizione "ON". Fai lo stesso per il gruppo altoparlanti per accendere il sistema di uscita.
2. Il montaggio di spie sonore è più facile con due persone, ma può essere fatto con una sola. Per il montaggio su un fiocco non avvolgibile, le spie si mettono più facilmente prima di issare la vela.
3. Per assicurarti che la cornice del racconto sia orientata correttamente, guarda la tacca su una delle barre verticali. Quando si tiene il telaio in posizione verticale, la tacca dovrebbe essere verso l'alto. Anche il lato del telaio con quella barra dovrebbe essere rivolto verso la parte anteriore della barca.
4. Posiziona uno dei racconti all'altezza desiderata e posizionalo sulla vela. Dovrebbe essere posizionato in modo tale che il filo si trovi nello stesso posto in cui si troverebbe se facesse parte di un racconto tradizionale.
5. Una volta che ne hai uno, raccontalo nella posizione desiderata. Posiziona l'altro racconto sull'altro lato della vela, esattamente di fronte al primo che hai posizionato, in modo che i magneti si allineino. Una volta che i magneti si sono collegati, dovrebbero tenere saldamente il telaio alla vela. Allinea i magneti delle custodie dell'elettronica, per ogni racconto su entrambi i lati della vela, in modo che si connettano anche loro.
6. Se noti che quando il filo scorre dritto all'indietro non si incrocia davanti al cancello superiore, ruota il telaio della spia in modo che la metà posteriore del telaio sia rivolta verso il basso. Ruota il telaio fino a quando il filo passa attraverso il fotointerruttore superiore quando il filo scorre indietro.

Passaggio 10: risoluzione dei problemi

Tutte le parti di codice hanno istruzioni di stampa di debug per indicare che stanno inviando, ricevendo ed elaborando dati. L'apertura della porta COM utilizzando l'IDE Arduino con uno dei sottosistemi Arduino Nano collegato a un computer consentirà di visualizzare questi messaggi di stato.

Se il sistema non funziona correttamente, attivare gli interruttori su tutti i componenti.

Passaggio 11: possibili passaggi successivi

• Impermeabilizzazione
• Comunicazione a lungo raggio. Il WiFi è un'opzione promettente.
• La nostra configurazione attuale utilizza attualmente 2 fotointerruttori per spia. L'aggiunta di più fotointerruttori al sistema potrebbe essere interessante da provare.