Attivare ULN2803 con unico segnale

[Frenzi]

Ciao a tutti, chiedo scusa per la mia "assenza" dal forum ma sono stato molto impegnato in questi giorni e non sono riuscito neanche ad accendere il PC.
Comunque , Orionis ti ringrazio tantissimo per il tuo aiuto e la tua disponibilità, ma vorrei cercare di fare io la PCB (anche se questo comporta parecchio sbattimento sia da parte mia che da parte tua che dovrai continuamente correggermi) però almeno riesco ad imparare , altrimenti devo sempre affidarmi al lavoro di altre persone , cosa che odio, quindi ti ri-ri-riringrazio in anticipo
Detto questo.. mi sono creato la libreria con l'adg633 scaricando il file .bxl scaricandolo direttamente dal sito della Analog Devices, convertendolo poi in file di libreria per eagle con ultra librarian (come spiegato sulla loro pagina http://www.analog.com/en/design-center/packaging-quality-symbols-footprints/symbols-and-footprints/ADG633.html ).

Ho realizzato lo schema su eagle, ma non so se posso postarlo come allegato (in teoria da regole del forum si possono postare solo schemi in fidocadj)

La mia idea originale era quella di saldare i piedini dei pot direttamente sulla PCB (così facendo non c'era bisogno di fissarla in nessun modo, dato che era collegata allo chassis tramite i pot), ma dato che (anche se non ho ancora preso delle misure precise) non penso che ci stia una PCB più grande di 4x4 cm, probabilmente dovrò cedere alla pessima idea di collegarla con dei fili volanti (saldati sui pot e con un connettore sulla PCB).
Devo misurare bene gli ingombri dentro all'ampli. Comunque gli unici componenti da avere sottomano come misure sono gli integrati e eventualmente i connettori o i pot (anche se un layout di massima posso già cominciare a farlo). Ci sono accorgimenti particolari da prendere? Nel senso.. i condensatori sull'alimentazione il più vicino possibile all'integrato (più vicini al + rispetto alla massa), tenere l'alimentazione possibilmente separata dai segnali , poi?

Grazie a tutti

[Orionis]

Ciao Frenzi, ti scrivo da qui perché é piu' semplice mandarti uno schemino 'stupido' che non via email.
Riguardando lo schema vedo che manca una rete di filtro sull'ingresso dell'ADG.
Il segnale di comando arriva da uno switch per cui avra' dei rimbalzi che potrebbero ripercuotersi come rumore in uscita.
Suggerisco quindi questa rete sull'ingresso; il ritardo é piccolo (circa 1ms), ma potrebbe anche bastare, altrimenti puoi aumentare C fino a 10uF (circa 20ms). Il problema puo' essere solo lo spazio sul PCB.

Sorgente FidoCadJ | Ingrandisci | Cos'è Fidocad

Ci sentiamo in MP

[Frenzi]

Se non ho capito male è un po' come il debounce che si usa su arduino quando si usano switch momentanei.. il fatto è che il segnale non è controllato direttamente da uno switch.. è controllato da un integrato quindi non credo sia un problema (se non ho capito male, il problema è durante l'attivazione, cioè che l'adg potrebbe eseguire un paio di scambi prima di stabilizzarsi su acceso e di fatto mi farebbe "sfarfallare" il volume durante il cambio di "canale").. comunque dato che oramai lo spazio non è un problema, aggiungere un condensatore e una resistenza per ogni "terzetto" di attivazione dell'adg non dovrebbe incidere molto sul risultato finale. Mi preoccupa la latenza che ci può essere, ma se con il condensatore da 470nF siamo su 1ms di latenza non c'e nessun problema (già 20ms sarebbe diverso). Aggiorno schema e PCB..

P.s. Se qualcuno fosse interessato a schema e PCB, che sto sviluppando grazie all'enorme aiuto che mi sta dando Orionis, qua c'è il link alla pagina di google drive dove sto caricando gli schemi e le PCB (per eagle), dove ci sono anche le vecchie versioni e le librerie aggiuntive che ho usato https://drive.google.com/folderview?id=0BwfGNn7noEuVfmFPQWU2dlJOb0JPa0haMGJmeDJRRXhzVHlEc1Y4cGc4dy1IZGdsbVJ4WHM&usp=sharing

[Orionis]

.. è controllato da un integrato quindi non credo sia un problema]

Se arriva da un IC allora non serve per il debounce, ma comunque un po' di filtro sull'ingresso non fa male (l'ADG é molto veloce)-

Mi preoccupa la latenza che ci può essere, ...già 20ms sarebbe diverso

Accidenti!, se riesci a beccare un glitch di 20ms hai un orecchio d'elefante

[Frenzi]

Accidenti!, se riesci a beccare un glitch di 20ms hai un orecchio d'elefante

So che sembra ridicolo.. ma ti posso assicurare che per quanto sia poco è già percettibile.. è più una sensazione che altro.. siccome che avevo un multieffetto a rack che aveva una latenza simile (riportava il fatto sul manuale.. mi passe che fosse una roba tipo 30ms) so già cosa vuol dire.. mentre cambi canale hai la sensazione (e non a torto) che ci sia un ritardo, che per quanto piccolo può essere fastidioso in punti dove devi cambiare velocemente il suono che stai usando. Comunque ho aggiornato i file con le ultime modifiche .. sono caricati sul drive. https://drive.google.com/folderview?id=0BwfGNn7noEuVfmFPQWU2dlJOb0JPa0haMGJmeDJRRXhzVHlEc1Y4cGc4dy1IZGdsbVJ4WHM&usp=sharing

[Frenzi]

Aggiornamento:

Dato che il circuito e la PCB sono (bene o male) impostati (sicuramente come logica ci siamo) ho iniziato a pensare alla parte di "controllo" dell'ampli intero e mi sono accorto che nel mio ragionamento c'erano vari bug

Quindi l'idea di mantenere il circuito di switch originale dell'ampli è saltata. Infatti i relè che cambiano canale all'interno dell'ampli sono gestiti da un microcontrollore e veniva troppo complicato modificare il circuito piuttosto che non rifarlo da 0. Mi spiego meglio.. andando ad agire direttamente sui relè, ho il controllo totale sui canali senza microcontrollori di mezzo. Ho deciso quindi di utilizzare Arduino (l'unico su cui riesco a programmare qualcosa) per gestire tutto ciò di cui ho bisogno.

La pedaliera sarà composta da 4 switch momentanei che controlleranno i 4 canali (clean, crunch , lead 1, lead 2) che se ricordate ciò che ho scritto all'inizio della discussione in realtà sono 2, ognuno con doppi controlli di gain e volume grazie al circuito con l'adg.
I relè della testata saranno controllati tramite mosfet (devo verificare, ma con ogni probabilità sono già presenti all'interno dell'ampli quindi sfrutterò quelli) .

Il ragionamento è questo :
presuppongo che per l'adg633 n.1 OFF=CLEAN , ON=CRUNCH e per l'adg633 n.2 OFF=LEAD1 , ON=LEAD2
Canale 1 : Relè clean attivo, led verde attivo, tutto il resto off.
Canale 2 : Relè crunch attivo, led giallo attivo, adg 1 attivo, tutto il resto off.
Canale 3 : Relè lead attivo , led arancio attivo, tutto il resto off.
Canale 4 : Relè lead attivo , led rosso attivo , adg 2 attivo , tutto il resto off.

Ora preparo lo schema per i collegamenti elettrici ad arduino e una bozza del programma.

[Orionis]

Qui mi sono un po' perso
Se fai tutto da solo va bene, ma se serve aiuto é indispensabile uno schema di massima delle connessioni per i non esperti come me.
Ovvero, quali segnali sono in ballo (nomi e tipi), da dove arrivano, come devono essere gestiti e dove vanno.

Occhio alle scosse !

[Frenzi]

]Mi spiace ma da spiegare a parole è veramente complicato .. Praticamente voglio gestire con arduino tutto il sistema di switch della testata.. praticamente elimino tutto il sistema che era già presente sulla testa esclusi i relè e i mosfet che li controllano, e tramite arduino gestisco: la scheda con gli adg633 per switchare i potenziometri, i mosfet che gestiscono i canali della testa, i led di indicazione.

Ho scritto il programma per arduino con cui gestire tutti questi segnali (comprende il codice per il debounce, già testato da me su un altro progetto)

Spero che qualcuno riesca a capirci qualcosa. è veramente complicato spiegare tutto .. mi spiace

Codice: Seleziona tutto

///////////DEBOUNCE
long debounceDelay = 50;
/////////// VARIABILI PER DEBOUNCE CLEAN
int buttonStateClean;             // the current reading from the input pin
int lastButtonStateClean = HIGH;   // the previous reading from the input pin
long lastDebounceTimeClean = 0;  // the last time the output pin was toggled
/////////// VARIABILI PER DEBOUNCE Crunch
int buttonStateCrunch;             // the current reading from the input pin
int lastButtonStateCrunch = HIGH;   // the previous reading from the input pin
long lastDebounceTimeCrunch = 0;  // the last time the output pin was toggled
/////////// VARIABILI PER DEBOUNCE Lead1
int buttonStateLead1;             // the current reading from the input pin
int lastButtonStateLead1 = HIGH;   // the previous reading from the input pin
long lastDebounceTimeLead1 = 0;  // the last time the output pin was toggled
/////////// VARIABILI PER DEBOUNCE Lead2
int buttonStateLead2;             // the current reading from the input pin
int lastButtonStateLead2 = HIGH;   // the previous reading from the input pin
long lastDebounceTimeLead2 = 0;  // the last time the output pin was toggled



///////// DICHIARAZIONI INPUT/OUTPUT
// OUT A MOSFET PER CONTROLLO RELE TESTATA
const int CleanRel = 1;
const int CrunchRel = 2;
const int LeadRel = 3;

//OUT A ADG633
const int Adg1 = 4;
const int Adg2 = 5;

//OUT LED
const int CleanLed = 6;
const int CrunchLed = 7;
const int Lead1Led = 8;
const int Lead2Led = 9;

//IN SWITCH MOMENTANEI
const int Clean = 10;
const int Crunch = 11;
const int Lead1 = 12;
const int Lead2 = 13;

//VARIABILI
int canale;


void setup() {
  Serial.begin(9600);

  //DEFINIZIONE PIN DIGITALI COME USCITE
  pinMode (CleanRel, OUTPUT);
  pinMode (CrunchRel, OUTPUT);
  pinMode (LeadRel, OUTPUT);
  pinMode (Adg1, OUTPUT);
  pinMode (Adg2, OUTPUT);
  pinMode (CleanLed, OUTPUT);
  pinMode (CrunchLed, OUTPUT);
  pinMode (Lead1Led, OUTPUT);
  pinMode (Lead2Led, OUTPUT);
  pinMode (Clean, INPUT);
  pinMode (Crunch, INPUT);
  pinMode (Lead1, INPUT);
  pinMode (Lead2, INPUT);

  //ESEGUO UN AZZERAMENTO DI TUTTE LE USCITE SETTANDO IL CANALE CLEAN SU ON
  digitalWrite (CleanRel, HIGH);
  digitalWrite (CrunchRel, LOW);
  digitalWrite (LeadRel, LOW);
  digitalWrite (Adg1, LOW);
  digitalWrite (Adg2, LOW);
  digitalWrite (CleanLed, HIGH);
  digitalWrite (CrunchLed, LOW);
  digitalWrite (Lead1Led, LOW);
  digitalWrite (Lead2Led, LOW);

  //ATTIVAZIONE RESISTENZE DI PULL-UP (quando lo switch verrà premuto si otterrà un valore LOW).
  digitalWrite (Clean, HIGH);
  digitalWrite (Crunch, HIGH);
  digitalWrite (Lead1, HIGH);
  digitalWrite (Lead2, HIGH);

  // SETUP DELLA VARIABILE CANALE A 1
  canale = 1;

}


void loop() {
  //DEBOUNCE

  ///////////////////////////////////////////////////////////////////////
  // SEZIONE DI CONTROLLO

  int readingClean = digitalRead(Clean);

  // check to see if you just pressed the button
  // (i.e. the input went from LOW to HIGH),  and you've waited
  // long enough since the last press to ignore any noise:

  // If the switch changed, due to noise or pressing:
  if (readingClean != lastButtonStateClean) {
    // reset the debouncing timer
    lastDebounceTimeClean = millis();
  }

  if ((millis() - lastDebounceTimeClean) > debounceDelay) {
    // whatever the reading is at, it's been there for longer
    // than the debounce delay, so take it as the actual current state:

    // if the button state has changed:
    if (readingClean != buttonStateClean) {
      buttonStateClean = readingClean;

      // only toggle the LED if the new button state is HIGH
      if (buttonStateClean == LOW) {
        canale = 1;
      }
    }
  }

  lastButtonStateClean = readingClean;


  int readingCrunch = digitalRead(Crunch);

  // check to see if you just pressed the button
  // (i.e. the input went from LOW to HIGH),  and you've waited
  // long enough since the last press to ignore any noise:

  // If the switch changed, due to noise or pressing:
  if (readingCrunch != lastButtonStateCrunch) {
    // reset the debouncing timer
    lastDebounceTimeCrunch = millis();
  }

  if ((millis() - lastDebounceTimeCrunch) > debounceDelay) {
    // whatever the reading is at, it's been there for longer
    // than the debounce delay, so take it as the actual current state:

    // if the button state has changed:
    if (readingCrunch != buttonStateCrunch) {
      buttonStateCrunch = readingCrunch;

      // only toggle the LED if the new button state is HIGH
      if (buttonStateCrunch == LOW) {
        canale = 2;
      }
    }
  }
  lastButtonStateCrunch = readingCrunch;



  int readingLead1 = digitalRead(Lead1);

  // check to see if you just pressed the button
  // (i.e. the input went from LOW to HIGH),  and you've waited
  // long enough since the last press to ignore any noise:

  // If the switch changed, due to noise or pressing:
  if (readingLead1 != lastButtonStateLead1) {
    // reset the debouncing timer
    lastDebounceTimeLead1 = millis();
  }

  if ((millis() - lastDebounceTimeLead1) > debounceDelay) {
    // whatever the reading is at, it's been there for longer
    // than the debounce delay, so take it as the actual current state:

    // if the button state has changed:
    if (readingLead1 != buttonStateLead1) {
      buttonStateLead1 = readingLead1;

      // only toggle the LED if the new button state is HIGH
      if (buttonStateLead1 == LOW) {
        canale = 3;

      }
    }
  }
  lastButtonStateLead1 = readingLead1;
  int readingLead2 = digitalRead(Lead2);

  // check to see if you just pressed the button
  // (i.e. the input went from LOW to HIGH),  and you've waited
  // long enough since the last press to ignore any noise:

  // If the switch changed, due to noise or pressing:
  if (readingLead2 != lastButtonStateLead2) {
    // reset the debouncing timer
    lastDebounceTimeLead2 = millis();
  }

  if ((millis() - lastDebounceTimeLead2) > debounceDelay) {
    // whatever the reading is at, it's been there for longer
    // than the debounce delay, so take it as the actual current state:

    // if the button state has changed:
    if (readingLead2 != buttonStateLead2) {
      buttonStateLead2 = readingLead2;

      // only toggle the LED if the new button state is HIGH
      if (buttonStateLead2 == LOW) {
        canale = 4;

      }
    }
  }

  lastButtonStateLead2 = readingLead2;

  switch (canale) {
    //CLEAN
    case 1:
      digitalWrite (CleanRel, HIGH);
      digitalWrite (CrunchRel, LOW);
      digitalWrite (LeadRel, LOW);
      digitalWrite (Adg1, LOW);
      digitalWrite (Adg2, LOW);
      digitalWrite (CleanLed, HIGH);
      digitalWrite (CrunchLed, LOW);
      digitalWrite (Lead1Led, LOW);
      digitalWrite (Lead2Led, LOW);
      break;

    //CRUNCH
    case 2:
      digitalWrite (CleanRel, LOW);
      digitalWrite (CrunchRel, HIGH);
      digitalWrite (LeadRel, LOW);
      digitalWrite (Adg1, HIGH);
      digitalWrite (Adg2, LOW);
      digitalWrite (CleanLed, LOW);
      digitalWrite (CrunchLed, HIGH);
      digitalWrite (Lead1Led, LOW);
      digitalWrite (Lead2Led, LOW);
      break;

    //LEAD1
    case 3:
      digitalWrite (CleanRel, LOW);
      digitalWrite (CrunchRel, LOW);
      digitalWrite (LeadRel, HIGH);
      digitalWrite (Adg1, LOW);
      digitalWrite (Adg2, LOW);
      digitalWrite (CleanLed, LOW);
      digitalWrite (CrunchLed, LOW);
      digitalWrite (Lead1Led, HIGH);
      digitalWrite (Lead2Led, LOW);
      break;

    //LEAD2
    case 4:
      digitalWrite (CleanRel, LOW);
      digitalWrite (CrunchRel, LOW);
      digitalWrite (LeadRel, HIGH);
      digitalWrite (Adg1, LOW);
      digitalWrite (Adg2, HIGH);
      digitalWrite (CleanLed, LOW);
      digitalWrite (CrunchLed, LOW);
      digitalWrite (Lead1Led, LOW);
      digitalWrite (Lead2Led, HIGH);
      break;
  }
 

}