NeckCrusher (pedale d'effetto montato su chitarra): 6 passaggi (con immagini)

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

Dale Rosen, Carlos Reyes e Rob Koch

DATT 2000

Passaggio 1: problema

I pedali per chitarra limitano il musicista alla piattaforma del pedale. Soluzione: costruisci e incorpora una funzionalità di pedali per chitarra nella chitarra stessa. Ciò consente al musicista di muoversi liberamente sul palco, utilizzando il manico della chitarra come interfaccia invece di essere limitato alla posizione della pedaliera. Esploreremo questo concetto creando un dispositivo effetto bitcrusher/sample rate.

Passaggio 2: Contesto del progetto

Ci sono molti pedali per chitarra usati dai musicisti per manipolare il suono delle loro chitarre. La maggior parte di questi sono solitamente in unità rack o stomp box, limitando quindi il controllo degli effetti alla posizione dell'unità effetti. Il montaggio del dispositivo sulla chitarra consente ai musicisti di controllare i parametri dell'effetto in qualsiasi punto del palco. Ciò significa che non saranno soggetti a restrizioni e potranno avere la libertà di muoversi per le loro prestazioni.

Poiché Arduino è in grado di supportare solo audio a 8 bit, è impossibile eseguire un'elaborazione del segnale ad alta fedeltà. Questo è il motivo per cui abbiamo scelto gli effetti che abbiamo fatto, poiché si basano sulla creazione di un suono distorto e a bassa fedeltà. Questi sono gli unici effetti ragionevolmente possibili con un Arduino.

Passaggio 3: Parti/Strumenti necessari

● Trapano a percussione

● Tagliafili

● Spelafili

● Saldatore

● Pistola per colla a caldo

● Pompa dissaldante

● Chitarra● Custodia

● Saldare

● Colla a caldo

● Arduino

● Scheda prototipo

● Filo rivestito

● Jack audio (x2)

● Potenziometri (x3)

● Condensatori: 2,2 uF (x2)

● Filo di rame a vista

● Viti (M3.5 *8)

● Resistori: 1 k, 10 k, 1,2 k, 1,5 k, 390 k

● * Amplificatore operazionale (LM358) / * Transistor (2N3442)

Fase 4: Strategia tecnica

Circuito interno

Input Output

Abbiamo bisogno di convertire il segnale audio proveniente da una chitarra in qualcosa che l'arduino possa usare e modificare. Dovremo quindi riconvertire il segnale proveniente dall'arduino in un segnale audio. Arduino legge tensioni da 0V a 5V, i segnali audio vanno da -1V a 1V. Queste conversioni vengono eseguite utilizzando resistori. Il segnale verrà convertito anche nel circuito di uscita.

Libreria Arduino: ArduinoDSP

Descrizione del progetto (interfaccia)

Manopole Manopola 1: Frequenza di campionamento

Manopola 2: Frantuma punte

Manopola 3: Bit Shifter

Passaggio 5: codice

#include "dsp.h"

#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit)) #define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))

booleano div32; booleano div16;

volatile booleano f_sample; byte volatile badc0; byte volatile badc1; byte volatile ibb;

int fx1; int fx2; int fx3; int fx4;

int cnta; int int; int int1; int int2; int cnt2; int io; int iw1; int iw2; byte bb;

byte gg[512]; // Array di memoria audio a 8 bit

void setup() { setupIO();

// ricarica wave dopo 1 secondo fill_sinewave();

// imposta il prescaler adc su 64 per la frequenza di campionamento di 19kHz cbi(ADCSRA, ADPS2); sbi(ADCSRA, ADPS1); sbi(ADCSRA, ADPS0); // ADC a 8 bit nel registro ADCH sbi(ADMUX, ADLAR); sbi(ADMUX, REFS0); cbi(ADMUX, REFS1); cbi(ADMUX, MUX0); cbi(ADMUX, MUX1); cbi(ADMUX, MUX2); cbi(ADMUX, MUX3); // Modalità PWM Timer2 impostata su PWM veloce cbi (TCCR2A, COM2A0); sbi (TCCR2A, COM2A1); sbi (TCCR2A, WGM20); sbi (TCCR2A, WGM21); //Impostazione per Timer2 cbi (TCCR2B, WGM22); // Timer2 Clock Prescaler a: 1 sbi (TCCR2B, CS20); cbi (TCCR2B, CS21); cbi (TCCR2B, CS22); // Abilitazione porta PWM Timer2 sbi(DDRB, 3); //cli(); cbi (TIMSK0, TOIE0); sbi (TIMSK2, TOIE2); iw1 = badc1;

}

ciclo vuoto() {

//verifica lo stato del potenziometro dell'effetto e del selettore rotativo readKnobs();

// ************* // ***Normale*** // *************

if (fx1 == 0 && fx2 == 0 && fx3 == 0 && fx4 == 0) { byte input = analogRead(left); uscita(sinistra, ingresso); }

// ************* // ***Fasore*** // *************

se (fx4 > 100) {

fx1 = 0; fx2 = 0; fx3 = 0;

while (!f_sample) { // attendi il valore di esempio da ADC } // Cycle 15625 KHz = 64uSec PORTD = PORTD | 128; f_campione = falso; bb = badc1; dd[icnt1] = bb; // scrive nel buffer fx4 = iw * badc0 / 255; // campione ritardato di scala con potenziometro iw1 = dd[icnt2]; // legge il buffer di ritardo badc0 = badc0 / 20; // limita il valore a 512 icnt1++; icnt2 = icnt1 - badc0; icnt2 = icnt2 & 511; // indice limite 0.. icnt1 = icnt1 & 511; // indice limite 0..511 iw2 = iw1 + bb; iw2 = iw2 / 2; bb = iw2; OCR2A = bb; // Valore di esempio su uscita PWM

PORTD = PORTD ^ 128; output(sinistra, PORTD); // Produzione }

// ************* // ***Flanger*** // ************* if (fx3 > 100) {

fx1 = 0; fx2 = 0; fx4 = 0;

while (!f_sample) { // attendi il valore del campione da ADC } // Cycle 15625 KHz = 64uSec

PORTD = PORTD | 128; f_campione = falso; bb = dd[icnt]; // legge il buffer di ritardo iw=127-bb; // sottrae offset fx3 = iw * badc0 / 255; // campione ritardato di scala con potenziometro iw1 = 127 - badc1; // sottrae l'offset dal nuovo campione iw1 = iw1 + iw; // aggiunge il campione ritardato e il nuovo campione if (iw1 127) iw1 = 127; // Limitatore audio bb = 127 + iw1; // aggiungi l'offset dd[icnt] = bb; // memorizza il campione nel buffer audio icnt++; icnt = icnt & 511; // limite bufferindex 0..511 OCR2A = bb; // Valore di esempio su uscita PWM

PORTD = PORTD ^ 128; output(sinistra, PORTD); // Produzione

} }

void readManopole() { fx1 = analogRead(1); fx2 = analogRead(2); fx3 = analogRead(3); fx4 = analogRead(4);

}

void fill_sinewave() { float pi = 3.141592; galleggiante dx; galleggiante fd; fcnt galleggiante; dx = 2 * pi / 512; // riempie il bufferarry di 512 byte for (iw = 0; iw <= 511; iw++) { // con 50 punti sinewawe fd = 127 * sin(fcnt); // tono fondamentale fcnt = fcnt + dx; // nell'intervallo da 0 a 2xpi e incrementi di 1/512 bb = 127 + fd; // aggiunge l'offset dc a sinewawe dd[iw] = bb; // scrive il valore nell'array

} }

//************************************************** ****************** // Servizio di interruzione Timer2 a 62,5 KHz // qui il segnale audio e potenziometro viene campionato in una frequenza di: 16 Mhz / 256 / 2 / 2 = 15625 Hz ISR(TIMER2_OVF_vect) {

PORTB = PORTB | 1;

div32 = !div32; // divide la frequenza del timer2 / 2 in 31.25kHz if (div32) { div16 = !div16; if (div16) { // campiona il canale 0 e 1 alternativamente in modo che ogni canale venga campionato con 15.6kHz badc0 = ADCH; // ottiene il canale ADC 0 sbi(ADMUX, MUX0); // imposta il multiplexer sul canale 1 } else { badc1 = ADCH; // ottiene il canale 1 dell'ADC cbi(ADMUX, MUX0); // imposta il multiplexer sul canale 0 f_sample = true; } ibb++; ibb: ibb++; ibb: // breve ritardo prima dell'inizio della conversione sbi(ADCSRA, ADSC); // avvia la prossima conversione }

}

Passaggio 6: video

Potenziali problemi ● Il pickup è un po' troppo debole per il circuito di alimentazione - serve un amplificatore operazionale. - Nel video abbiamo usato un ripetitore di segnale. (La scatola grigia che giace sul tavolo.)