[OT] richiesta di aiuto per programmino x Accordatore

Ciao a tutti,

da un po di tempo mi sto picchiando con la mia schedina di Arduino per realizzare un accordatore di antenna, progetto che mi frulla per la testa da parecchio tempo, e da quando ho scoperto Arduino ho provato a realizzarlo, purtroppo senza risulato =( =( =(

Scrivo questo mio post in cerca di un aiuto genovese che abbia tempo e voglia di darmi una mano nella realizzaione del mio progettino, la mail è nel mio profilo.

grazie

Campa1957

Non puoi provare a spiegare la tecnica di realizzazione di un accordatore d'antenna, in modo da iniziare dal circuito hardware e poi passare alla programmazione? Non è detto che non risolvi qui se fornisci le necessarie e dettagliate informazioni.

Ciao Michele,

ti ringrazio per il consiglio, dopo queste mie righe inserisco il pezzo di programma che ho realizzato e che avevo già postato tempo addietro senza però riuscire ad avere indicazioni terra terra da essere capite anche me.

Premetto che la mia idea è utilizzare 6 valori di "L" e 6 valori di "C" con rapporti 1, 2, 4, 8, 16, 32 da inserire scalini.

la mia idea è:

se un valore calcolato (calcRos) è superiore ad una soglia inserisco uno scalino della serie "L", continuo ad inserire scalini fino a quando il valore calcolato scende, quando verifico che il valore calcolato anzichè scendere, dopo l'ultimo inserimento, è salito vorrei disinserire il primo scalino inserito, quello con valore più piccolo, della serie "L", continuo a togliere scalini fino a quando il valore calcolato risale, a questo punto dovrei valuatere se reinserire o meno lo scalino che è stato appena disinserito, sempre in base al valore calcolato dopo di che questo 'giro' sarebbe ultimato.

In questo punto va inserito un criterio di scelta, sempre riferito al valore calcolato, che valuti se inserire lato TX oppure lato antenna la serie "C".

Con lo stesso criterio dovrei inserire i vari scalini della serie "C"

/*
*******************************
 Accorda0106 TEST 
 *******************************

 Inserisce uscite se ROS>1.5 e disinserisce l'ultima se ros aumentato invece che diminuire!!!

 */

#define NUMREADINGS0 10  // 10 valori da leggere
#define NUMREADINGS1 10  // 10 valori da leggere
#define inputPin0 3 // Sensore collegato al pin analogico 3 POT. RIFLESSA filo verde
#define inputPin1 5 // Sensore collegato al pin analogico 5 POT. DIRETTA filo blu
// #include    // INCLUDE LA LIBRERIA
int readings0[NUMREADINGS0];  // Letture da input analogico
int readings1[NUMREADINGS1];  // Letture da input analogico
int index0 = 0;  // Indice della lettura0 corrente
int index1 = 0;  // Indice della lettura1 corrente
int total0 = 0;  // Totale letture0
int total1 = 0;  // Totale letture1
int saltoind = 0;  // seleziona cosa fare salto0 variabile il cui valore indica dove swicciare x ind
int saltocap = 0;  // seleziona cosa fare salto0 variabile il cui valore indica dove swicciare x cap
float average0 = 0;  // Media0 RIFLESSA, int non visualizza decimali, float visualizza due decimali
float average1 = 0;  // Media1 DIRETTA, int non visualizza decimali, float visualizza due decimali
float average0old = 0;  // Media0old RIFLESSA
float average1old = 0;  // Media1old DIRETTA
float calcRos = 0;     // Ros calcolato
float calcRosold = 0;  // vecchio valore di Ros
float calcRosold1 = 0; // vecchio vecchio valore di Ros per il disinserimento degli scalini dopo averne inseriti troppi
float calcPot =0;  // Potenza calcolata
float calcPotOld =0;
// LiquidCrystal lcd(8, 9, 4, 5, 6, 7);   // INIZIALIZZA LA LIBRERIA LCD
int led1 = 13;  // SELEZIONA PIN 13 
int led2 = 12;  // SELEZIONA PIN 12 
int led3 = 11;  // SELEZIONA PIN 11 
int led4 = 10;  // SELEZIONA PIN 10 
int led5 = 9;  // SELEZIONA PIN 9 
int led6 = 8;  // SELEZIONA PIN 8
int led7 = 7;  // SELEZIONA PIN 7 
int led8 = 6;  // SELEZIONA PIN 6 
int led9 = 5;  // SELEZIONA PIN 5 
int led10 = 4;  // SELEZIONA PIN 4 
int led11 = 3;  // SELEZIONA PIN 3 
int led12 = 2;  // SELEZIONA PIN 2
int led13 = 1;  // SELEZIONA PIN 1 
int led14 = 0;  // SELEZIONA PIN 0
long previousMillis = 0; // ******************** ritardo
long interval = 1000;    // ******************** tempo di ritardo


void setup()
{
  {
    pinMode (13, OUTPUT); 
    pinMode (12, OUTPUT);
    pinMode (11, OUTPUT);
    pinMode (10, OUTPUT);
    pinMode (9, OUTPUT);
    pinMode (8, OUTPUT);   
    pinMode (7, OUTPUT); 
    pinMode (6, OUTPUT);
    pinMode (5, OUTPUT);
    pinMode (4, OUTPUT);
    pinMode (3, OUTPUT);
    pinMode (2, OUTPUT);
    pinMode (1, OUTPUT);
    pinMode (0, OUTPUT);
  }
  for (int i = 0; i < NUMREADINGS0; i++){
    readings0[i] = 0;  //Mette tutti 0 nell'array
  }

  for (int a = 0; a < NUMREADINGS1; a++) {
    readings1[a] = 0;  //Mette tutti 0 nell'array     
  }
}
void loop()
{
  {
    total0 -= readings0[index0];  //Sottrae l'ultima lettura
    readings0[index0] = analogRead(inputPin0);  //Legge i valori provenienti dal sensore e li salva nell'array
    total0 += readings0[index0];  //Aggiunge la lettura al totale
    index0 = (index0 + 1);  //Incrementa l'indice
  }
  if (index0 >= NUMREADINGS0) {
    index0 = 0;  //Alla fine dell'array resetta l'indice a 0
    average0 = total0 / NUMREADINGS0;  // Calcola la media DELLA RIFLESSA
  }
  {
    total1 -= readings1[index1];  //Sottrae l'ultima lettura
    readings1[index1] = analogRead(inputPin1);  //Legge i valori provenienti dal sensore ??? e li salva nell'array
    total1 += readings1[index1];  //Aggiunge la lettura al totale
    index1 = (index1 + 1);  // Incrementa l'indice
  }
  if (index1 >= NUMREADINGS1) {
    index1 = 0;  // Alla fine dell'array resetta l'indice a 0
    average1 = total1 / NUMREADINGS1;  // Calcola la media DELLA DIRETTA
  }
  {
    // CALCOLO ROS

    calcRos = ((1 + ( average0 / average1)) / (1 - ( average0 / average1)));
  }
  unsigned long currentMillis = millis();
  if(currentMillis - previousMillis > interval) {
    previousMillis = currentMillis; 

    // da queste parti bisogna inserire la scelta se andare a saltoind o saltare a saltocond (???)
    // poi verificare se sono stati fatti tutti i giri di controllo e visualizzare il risultato
    // LED Verde OK, LED Rosso se il valore del ROS è > del valore di soglia!

    {
      if(calcRos>=1.5) saltoind++;                       // se ROS >= a 1.5 incrementa di 1 saltoind
      if(calcRosold>calcRos) if(saltoind<7) saltoind=7;  // se ultima lettura > lettura precedente saltoind=7
      if(calcRosold>calcRos)saltoind++;                  // se ROSnuovo > ROS vecchio, inserito troppa IND inizia a spegnere le uscite da led1
      calcRosold=calcRos;                                // manca il controllo in spegnimento delle uscite !!!!!!!!!!!!
      // bisogna verificare come NON aggiornare il valore di calcRosold fino al miglior calcRos. 

    } 

    switch (saltoind)   {
    case 1: // Inserisco primo scalino ind
      digitalWrite(led1, HIGH);
      break;      
    case 2: // Inserisco scalino 2 ind
      digitalWrite(led2, HIGH);
      break;
    case 3: // Inserisco scalino 3 ind
      digitalWrite(led3, HIGH);
      break;      
    case 4: // Inserisco scalino 4 ind
      digitalWrite(led4, HIGH);
      break;
    case 5: // Inserisco scalino 5 ind
      digitalWrite(led5, HIGH);
      break;      
    case 6: // Inserisco scalino 6 ind 
      digitalWrite(led6, HIGH);
      break;

    case 7: // Non fa' nulla!!!
      break; 

    case 8: //disinserisco primo scalino ind ************ SPEGNIMENTI *******************
      digitalWrite(led1, LOW);
      break;
    case 9: // Inserisco scalino 3 ind
      digitalWrite(led2, LOW);
      break;      
    case 10: // Inserisco scalino 4 ind
      digitalWrite(led3, LOW);
      break;
    case 11: // Inserisco scalino 5 ind
      digitalWrite(led4, LOW);
      break;      
    case 12: // Inserisco scalino 6 ind
      digitalWrite(led5, LOW);
      break;
    case 13: // Inserisco scalino 6 ind
      digitalWrite(led6, LOW);
      saltoind=0;  // pone a 0 il valore della variabile per avitare che continui nel vuoto
      break;



      // 000
    case 50:
      digitalWrite(led1, LOW);
      digitalWrite(led2, LOW);
      digitalWrite(led3, LOW);
      digitalWrite(led4, LOW);
      digitalWrite(led5, LOW);
      digitalWrite(led6, LOW);
      saltoind=0;  // dopo aver spento tutto riporta saltoind=0
      break;
    case 100:
      break;
    }
  }
}

spero di essere riuscito a spiegare quale è la mia idea

grazie

Andrea

Non molto, forse è per questo che hai avuto difficoltà ad ottenere aiuto la volta scorsa, considera che parli di una materia che tu conosci e molti altri no. P.es. dopo la spiegazione teorica sarebbe utile un esempio pratico con valori reali e comportamento del display e dei LED, una cosa semplice ma comprensibile... Inoltre, io non sono un programmatore ma da quel poco che vedo a me pare che il tuo programma abbia un sacco di istruzioni inutili e ridondanti: vedo costanti fissate allo stesso valore, dichiarazioni dei pin del display che non sono richieste, ed il metodo di lettura e scarto dei due ingressi ADC è tanto pesante quanto inutile. Le letture le fai solo al fine di ottenere un valore medio ad ogni ciclo, che ti frega di creare un array, azzerarlo, riempirlo, totalizzarlo, quando puoi usare una sola semplice variabile sommatoria e dividerla per il numero di letture? Vedo che vai a sottrarre il valore della prima lettura non puoi semplicemente ignorarlo? Per una situazione simile alla tua io ho fatto:

val = 0;
for (int i=0; i

come vedi azzero la variabile val, sommo il numero "media" di successive letture nella stessa variabile, infine divido il totale ottenuto per il numero di letture. Alla fine il mio risultato è uguale al tuo (non ho ignorato la prima lettura perché uso un solo ingresso ADC), a che ti servono i valori di array se poi non li usi da nessuna parte e perché li dovresti azzerare visto che ogni volta li riempi nuovamente tutti?

Campa1957, per come la vedo io, tu mi vorresti fare studiare un altro linguaggio di programmazione, che poi sarebbe il tuo linguaggio, io conosco il C/C++ ecc.

Se mi metti un blocco {} dentro un altro blocco io da programmatore penso che dentro crei variabili temporanee che fuori dal blocco vuoi distuggere. Se dopo una if (cond...) {} mi apri un altro blocco {} io penso che nel mezzo hai dimenticato "else", ma mi dico no forse chissa, gli serve creare varibili temporanee che poi vuole distruggere.

I blocchi annidati non legati ad una parola chiave si creano solo nel caso in cui c'è rischio di consumare memoria (e c'è sempre il rischio). I blocchi si usano per creare variabili temporanee che poi vengono distrutte al termine del blocco.

Tradotto io non sono capace di leggere quel codice e capirci qualcosa.

Hai un valore letto dal A0, posta una casistica dei valori possibili nella unità di tempo, esempio. Nell'arco di x tempo vengono letti e salvati i seguenti valori: 800, 875, 900, 888, 1000, 999, 1000, 998, 1001

Da questi valori determino un andamento crescente tendente alla normalizzazione. Questo devono essere i valori raw, cioè non normalizzati o compensati dal circuito di accordo, posto nella posizione iniziale di default.

Suppongo che il programma debba cercare di prendere delle decisioni in base alla azione posta in essere prima della valutazione corrente, quindi la storia è importante. l'obbiettivo è quello di cercare di minimizzare il valore letto su A0, minore è il valore letto minori sono le onde stazionarie e migliore è l'accordatura.

Io penso che si possa adattare l'algoritmo "PID", lasciando da parte l'integrale e la derivata, quindi solo la P di proporzionale.

PS:riscrivi il codice attuale senza i blocchi {} superflui.

Ciao.

Ciao Mauro, il problema purtroppo è che lui ha esordito dicendo

avevo già postato tempo addietro senza però riuscire ad avere indicazioni terra terra da essere capite anche me.

, quindi bisogna sperare che comprenda i tuoi saggi consigli, d'altra parte non gli si può certo riscrivere il codice, comunque mi stai confermando che c'è molta roba inutile lì dentro...

Il discorso è molto semplice, come già dichiarto più volte anche in altro post, le mie basi di programmazione sono pari a ZERO, e allora ho girovagto in rete fino a trovare un qualcosa che pensato per fare altro con un pò di 'magnuscamenti' fa quasi quello che serve a me........ I pin per lcd sono ancora nel listato perchè il primo obiettivo è stato visualizzare i tre valori, due misurati e uno calcolato, e non li ho ancora tolti! Per quanto riguarda il ragionamento sulle parentesi graffe ...................... :astonished: :astonished: :astonished: non mi è molto chiaro il loro funzionamento.

Spero che dopo quello che ho scritto vogliate ancora darmi una mano..............

grazie

Andrea

Sì certo, ma devi anche rispondere a ciò che ti viene chiesto, se mantieni il tuo atteggiamento passivo non ti aiuta nessuno, e non per cattiva volontà, ma perché nessuno ha il tempo di scervellarsi per capire le cose che ti ostini a non voler spiegare. Ok, di programmazione non ne capisci nulla, ma almeno ci ciò che vuoi fare ed ottenere sarai in grado di metterci al corrente con esempi pratici?

[u]Obiettivo:[/u] realizzare un accordatore di antenna per le HF.

[u]Come realizzarlo:[/u] inserendo con vari step prima delle induttanze (6) in serie fino al miglior rapporto di Ros possibile, e poi dei condensatori (6) in serie all'antenna, da valutare se l'inserimento va fatto lato TX oppure lato Antenna. Tutte le verifiche vanno fatte con l'obiettivo di abbassare il valore del Ros. Una volta che è stato effettuato il primo giro, effettuare un secondo giro di affinamento del valore ottenuto.

[u]HD:[/u] Scheda Arduino UNO, interfacce relè commeciali (n.4 da 4 relè) che a loro volta andranno a comandare dei relè sotto vuoto.

Andrea

Ah, ora si comincia a ragionare, quindi tu: 1 - rilevi una misura (anzi due, perché? cosa sono? che tipo di valori ti aspetti?) col tipico sistema della lettura ADC 2 - in base al discostamento della lettura rispetto ad un valore IDEALE (qual è?) tu attivi 0,1...6 relé ognuno dei quali inserisce una impedenza in serie al polo centrale dell'uscita del TX rispetto al corrispondente polo dell'antenna, contemporaneamente attivi 0,1....6 relé per l'inserimento di altrettanti condensatori sempre in serie al polo centrale dell'uscita del tx (non in parallelo, vero?) 3 - dopo l'inserimento ripeti la lettura per vedere se è il caso di togliere/inserire qualche valore.

Dovresti rispondere a queste domande e poi fare un esempio pratico: leggo X su ADC1, leggo Y su ADC2 quindi devo fare così....e spieghi... poi rileggo e ottengo X1 su ADC1 e Y1 su ADC2, a questo punto faccio.....

Cioè devi farci "vedere" come lavora il tuo hardware in ingresso e come vorresti far lavorare il tuo hardware in uscita, poi magari proviamo a tirare fuori un semplice flow diagram e qualche riga di codice; ora devo andar via, non farti prendere dalla fretta e vedrai che ne usciremo, anche perché quando vedranno un minimo di ordine poi inteverranno i nostri professionisti software a risolvere le problematiche più importanti, ormai so che funziona così. Ci si sente stasera, tu intanto scrivi e descrivi più che puoi, meglio se fai un po' di esempi di situazioni diverse, meglissimo se tracci uno schema dell'hardware in ingresso ed in uscita, così lo verifichiamo assieme, non è detto che non ci sia qualche errore anche lì. Ciao ;)

Ok, se tu persona dovessi fare l'accordatura dell'antenna come agiresti? Prendi delle decisioni in base a dei dati rilevati, quali sono questi dati? Prendi decisioni in base ad una logica, quindi devi escludere l'intuito umano che non può essere programmato.

Quando hai descritto tutto il procedimento manuale eseguito da un operatore che si basa sulla logica, poi si può passare alla codifica del codice.

Fondamentalmente a noi non serve sapere cosa accade quando un pin attiva un relè è viene inserita un L o C, a noi interessa sapere cosa accade di certo quando un pin va alto o basso, cioè domanda: è possibile determinare con certezza che un inserimento di L comporta un miglioramento, o viceversa, io penso di no, penso che il programma deve determinare se l'azione casuale iniziale ha portato un peggioramento e in tal caso deve tentare di migliorare aggendo per tentativi, inserendo ulteriormente altre L o C per analizzare se c'è un peggioramento o miglioramento. Purtroppo prima o poi deve trovare un punto stabile perchè altrimenti c'è continua commutazione alla ricerca del miglior risultato, e trovato uno non vuol dire che non sia possibile fare di meglio facendo altre combinazioni.

Io non ho conoscenza di elettronica HF.

Ciao.

Per maggior comprensione quoto e rispondo nel testo

Ah, ora si comincia a ragionare, quindi tu: 1 - rilevi una misura (anzi due, perché? cosa sono? che tipo di valori ti aspetti?) col tipico sistema della lettura ADC

Rilevo 2 misure di tensione, Potenza diretta e Potenza riflessa. Una volta lette faccio un calcoletto il cui risultato è CalcRos

2 - in base al discostamento della lettura rispetto ad un valore IDEALE (qual è?) tu attivi 0,1...6 relé ognuno dei quali inserisce una impedenza in serie al polo centrale dell'uscita del TX rispetto al corrispondente polo dell'antenna, contemporaneamente attivi 0,1....6 relé per l'inserimento di altrettanti condensatori sempre in serie al polo centrale dell'uscita del tx (non in parallelo, vero?)

Se il valore di CalcRos è maggiore di un valore impostato inserisce il primo scalino di L dopo aver inserito lo scalino deve rifare le letture, ricalcolare e verificare se il valore di CalcRos è diminuito ed è sempre superiore al valore impostato deve inserire un nuovo scalino, e così lo deve fare fino all'inserimento di tutte le L oppure al raggiungimento del valore minimo impostato. Nel caso l'inseriemento di una L portasse ad un aumento di CalcRos devono essere disinseriti gli scalini già inseriti partendo da quello con valore più piccolo

3 - dopo l'inserimento ripeti la lettura per vedere se è il caso di togliere/inserire qualche valore.

alla 3 penso di aver già risposto sopra.

Per spiegare la parte HD, le induttanze veranno inserite in serie all'antenna mentre i condensatori verranno inseriti in parallelo ma con una scelta, se lato TX oppure lato Antenna. In pratica a monte o a valle delle bobine.

Dovresti rispondere a queste domande e poi fare un esempio pratico: leggo X su ADC1, leggo Y su ADC2 quindi devo fare così....e spieghi... poi rileggo e ottengo X1 su ADC1 e Y1 su ADC2, a questo punto faccio.....

Cioè devi farci "vedere" come lavora il tuo hardware in ingresso e come vorresti far lavorare il tuo hardware in uscita, poi magari proviamo a tirare fuori un semplice flow diagram e qualche riga di codice; ora devo andar via, non farti prendere dalla fretta e vedrai che ne usciremo, anche perché quando vedranno un minimo di ordine poi inteverranno i nostri professionisti software a risolvere le problematiche più importanti, ormai so che funziona così. Ci si sente stasera, tu intanto scrivi e descrivi più che puoi, meglio se fai un po' di esempi di situazioni diverse, meglissimo se tracci uno schema dell'hardware in ingresso ed in uscita, così lo verifichiamo assieme, non è detto che non ci sia qualche errore anche lì. Ciao smiley-wink

Spero di essere riuscito a spiegare il funzionamento HD e più o meno cosa deve fare il SW.

Andrea

chiedo scusa se intervengo con una risposta essendo un principiante.

qui sul forum mi hanno dato una dritta sul "min" e "max" e grazie a questo ora ho una antenna digitale terrestre motorizzata portatile che si punta sul ripetitore automaticamente

del tuo sketch ci ho capito poco ma potresti tentare come logica: primo collegamento con primo filtro L o C e arduino misura l'ingresso (calcRos) secondo collegamento con secondo filtro L o C e arduino misura l'ingresso (calcRos) terzo quarto quinto sesto quando arduino ha memorizzato l'ingresso (calcRos) "max" di queste sei, dici ad arduino di tornare indietro e ricollegare i filtri uno ad uno finché ritrova il "max"

con il "min" penso sia lo stesso

Ciao Camperos,

tutti i suggerimenti posso essere utili!

Nel mio caso ho bisogno di abbassare il più possibile il valore di CalcRos inserendo in modo ragionato più o meno scalini di L e/o di C. Sempre comparando il valore di CalcRos nuovo / vecchio e/o precedente :astonished:

Aspettiamo consiglio dei Guru!

Andrea

Supponiamo di avere 3 configurazioni hardware commutabili; dubbio: non so se c'è una coppia LC da inserire e quini es 6 coppie sarebbero sei configurazioni diverse, oppure ci sono 6 L e 6 C che possono essere combinati tra loro con esempio un L + C + C.

Stabiliamo che all'accensione dell'apparecchio la configurazione di default è 0, cioè nessuna L e/o C. L'accordatore deve iniziare da subito ad accordare, oppure la routine di accordatura avviene a richiesta premendo un pulsante?

Stabilisco che è necessario premere un pulsante per dare il via alla ricerca.

Condizione da verificare con if o switch; non è detto che il programma inizi ad inserire o rimuovere LC, perchè la configurazione attuale potrebbe essere già buona, si può verificare ciò e se si come si può esprimere la condizione ottimale che arresta la ricerca della configurazione? (penso che non si possa)

Premessa: Si usa una porta di 8 bit in uscita alla quale vengono collegati i relè (cioè il circuito che attiva i relè), e la chiamiamo PORTA. In una porta i bit vengono numerati così : 0000 0001 (vale uno decimale) 1000 0000 (vale 127 decimale) Partendo da 0 non si può fare altro che salire verso 1, 2, 3, puoi compilare una tabella riempendo "bit di PORTA". configurazione bit di PORTA 0 0000 0000 1 2 3 4 5 6

eventualmente ci fossero + configurazioni aggiungele tu.

Il programma fa: currentConfig contiene il numero di configurazione attuale, inizialmente vale 0 (zero) typedef enum Action Action; // definisce un alias per enum Action, ora posso creare tipi Action senza specificare enum enum Action { STANDBY, START_SEARCH, CANCEL_SEARCH, ecc altre azioni }; setRos è impostato dall'utente

loop() {
    Acquisisce stato da tastiera e lo salva in currentAction
    if (currentAction == START_SEARCH) {
        legge e ricava calcRos
        if (calcRos > setRos) {
            stabilisce il valore della variabile 'operazione' 
            chiama funzione di ricerca accordatura tuningRos()
        }
    }
}

void tuningRos()
{
     // azione Inserisci o rimuovi, sono sinonimi di vai avanti o torna indietro
     oldRos = calcRos;
    // e qui non so più andare avanti
}

Azz, se tu facessi esami con me non la supereresti mai la mia materia, io ti faccio domande chiare, tu rispondi in base al cuore e poi sei convinto di aver risposto, non ti farei nemmeno la domanda di recupero ]:D Tu dici che non capisci niente di sw e vuoi imboccato lo sketch col cucchiaino, noi ti diciamo che non capiamo un czz di ROS e tu continui a non spiegarci niente di come funziona la cosa, se non sprazzi di notizie, per di più con quesiti da dissipare, fenomenale :zipper_mouth_face: Tanto per capirci: QUANDO LI INSERISCI I CONDENSATORI??? tu dicevi che erano in serie ed io ti ho suggerito che probabilmente erano in parallelo, poi parli di lato tx o lato antenna, e non metti uno straccio di schema per farci capire cosa intendi. Lo vuoi risolvere il tuo problema? DEVI farci VEDERE cosa devi fare nelle varie circostanze, ossia abbiamo bisogno dello schema elettrico con le uscite di Arduino che pilotano i XX relé e come tali relé agiscono con i loro contatti per inserire/disinserire (E DOVE) impendenze e condensatori. Senza questa fondamentale informazione andremo a tentoni all'infinito, con uno schema elettrico e qualche domanda di chiarimento invece penso proprio che troveremo rapidamente la soluzione. Comunque finora ho capito questo: 1 - leggo i valori V1 e V2 2 - eseguo una formula con questi due valori ed ottengo un risultato R1 3 - confronto R1 con RD (preimpostato) 4 - scelta: 4a: se R1<= RD ---> END (l'antenna è accordata, il valore di ROS è ottimale) 4b: se R1>RD attivo un'uscita di Arduino (inserimento di un'impedenza, il come lo si capirà dallo schema elettrico) 5 - ripeto i passi da 1 a 4 ma in tutto ciò i condensatori dove stanno? riusciresti ad implementaree completare questo mio schema logico prevedendo tutte le necessarie opzioni? :sweat_smile:

PS: come vedi Mauro è nelle mie stesse condizioni, ad un certo punto gli mancano le informazioni ed ha i miei stessi dubbi, quindi io non sono un deficiente :)

Ma idue classici condensatori variabili magari gestiti da due motori passò passò o servo?

Intendi automatizzare un accordatore manuale? Ma sempre facendo le letture dei valori in uscita, spero...

Dunque ho riletto il codice e ho capito questo: Ci sono 14 led, connessi ai pin da 0 a 13, 6 di queste uscite azionano dei relè, rimane il dubbio circa la sequenza di azionamenti. Prendendo 6 bit di una porta da 8 bit partendo dal bit LSB fino al 5 bit, a caso prendiamo PORTA

PORTA = "b00111111" Le possibili combinazioni sono in totale 64 incluso lo 0. Si deve progressivamente commutare le uscite partendo da 0 fino a 63? oppure basta accender il bit 0, poi in caso spegne lo 0 e accende 1, poi spegne 1 e accende 2 e così fino a 6.

Nel primo caso le configurazioni possibili sono 64, nel secondo sono solo 6.

Nel caso le configurazioni fossero 64 potrebbe essere utile partire dalla configurazione 64/2 = 32, in questo modo male che vada devo effettuare 32 commutazioni per trovare quella che mi da un ros minore di tutte.

Concettualmente, la configurazione candidata è: se nuovo_valore < vecchio_valore configCandidate = currentConfig e si fa il test per tutte le 32 combinazioni

Tempo addietro ho fatto un potenziometro a partitori commutati, con attenuazione totale di 127.5 decibel, quindi per aumentare l'attenuazione mi bastava incrementare il valore di una porta da 8 bit, per ridurre l'attenuazione ovviamente lo decrementavo, mi sa tanto che "campa" ha realizzato un sistema simile ma nel suo caso ciò che varia è l'impedenza.

@Michele Non disperare, sono stati scritti libri dove emerge palesemente la difficolta di dialogo tra il committente di un software e gli ingegneri del software. Io in alcune situazioni avevo davanti persone e mi immagginavo di scrivere rm -f commercialista e vederlo scomparire. ]:D

PS: rm -f file :su unix sta per rimuovi forzatamente il file 'file'

Ciao

ROTFL XD XD XD no, non dispero, anzi spero di arrivare fino in fondo, io posso essere utile nell'impostazione logica, la trasformazione in codice la farete voi esperti il fatto è che non puoi risalire all'hadrware da un codice nato per fare una cosa diversa ed adattato malamente (infatti non funziona), per cui credo fermamente che si debba vedere l'hardware e capire come debba funzionare, a quel punto penso non sarà molto difficile scrivere qualche riga di codice, sono certo che lo sketch finale sarà moooolto più breve di quello attuale.