Pages: [1] 2 3 ... 21   Go Down
Author Topic: [OT] richiesta di aiuto per programmino x Accordatore  (Read 20490 times)
0 Members and 1 Guest are viewing this topic.
Offline Offline
Full Member
***
Karma: 0
Posts: 124
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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  smiley-cry smiley-cry smiley-cry

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
« Last Edit: June 24, 2013, 12:11:31 pm by Campa1957 » Logged

Lamezia Terme
Offline Offline
Shannon Member
****
Karma: 569
Posts: 12576
Le domande di chi vuol imparare rappresentano la sua sete di sapere
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

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.
Logged

Guida alla programmazione ISP e seriale dei micro ATMEL (Caricare bootloader e sketch):
http://www.michelemenniti.it/Arduino_burn_bootloader.php
Guida alla Programmazione ATmega328 noP:
http://www.michelemenniti.it/atmega328nop.html
Articoli su Elettronica In:
http://www.michelemenniti.it/elettronica_in.html

Offline Offline
Full Member
***
Karma: 0
Posts: 124
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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"

Code:

/*
*******************************
 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 <LiquidCrystal.h>   // 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
« Last Edit: June 01, 2013, 04:46:42 am by Campa1957 » Logged

Lamezia Terme
Offline Offline
Shannon Member
****
Karma: 569
Posts: 12576
Le domande di chi vuol imparare rappresentano la sua sete di sapere
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

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:
Code:
val = 0;
for (int i=0; i<media; i++) {
        val += analogRead(f_comp_reg);
    }
    val = (val/media); 
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?
Logged

Guida alla programmazione ISP e seriale dei micro ATMEL (Caricare bootloader e sketch):
http://www.michelemenniti.it/Arduino_burn_bootloader.php
Guida alla Programmazione ATmega328 noP:
http://www.michelemenniti.it/atmega328nop.html
Articoli su Elettronica In:
http://www.michelemenniti.it/elettronica_in.html

0
Offline Offline
Faraday Member
**
Karma: 31
Posts: 2908
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

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.
Logged

AvrDudeQui front end per avrdude https://gitorious.org/avrdudequi/pages/Home

Lamezia Terme
Offline Offline
Shannon Member
****
Karma: 569
Posts: 12576
Le domande di chi vuol imparare rappresentano la sua sete di sapere
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

Ciao Mauro, il problema purtroppo è che lui ha esordito dicendo
Quote
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...
Logged

Guida alla programmazione ISP e seriale dei micro ATMEL (Caricare bootloader e sketch):
http://www.michelemenniti.it/Arduino_burn_bootloader.php
Guida alla Programmazione ATmega328 noP:
http://www.michelemenniti.it/atmega328nop.html
Articoli su Elettronica In:
http://www.michelemenniti.it/elettronica_in.html

Offline Offline
Full Member
***
Karma: 0
Posts: 124
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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 ......................  smiley-eek smiley-eek smiley-eek non mi è molto chiaro il loro funzionamento.

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

grazie

Andrea
Logged

Lamezia Terme
Offline Offline
Shannon Member
****
Karma: 569
Posts: 12576
Le domande di chi vuol imparare rappresentano la sua sete di sapere
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

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?
Logged

Guida alla programmazione ISP e seriale dei micro ATMEL (Caricare bootloader e sketch):
http://www.michelemenniti.it/Arduino_burn_bootloader.php
Guida alla Programmazione ATmega328 noP:
http://www.michelemenniti.it/atmega328nop.html
Articoli su Elettronica In:
http://www.michelemenniti.it/elettronica_in.html

Offline Offline
Full Member
***
Karma: 0
Posts: 124
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Obiettivo:
realizzare un accordatore di antenna per le HF.

Come realizzarlo:
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.

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

Andrea
Logged

Lamezia Terme
Offline Offline
Shannon Member
****
Karma: 569
Posts: 12576
Le domande di chi vuol imparare rappresentano la sua sete di sapere
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

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  smiley-wink
Logged

Guida alla programmazione ISP e seriale dei micro ATMEL (Caricare bootloader e sketch):
http://www.michelemenniti.it/Arduino_burn_bootloader.php
Guida alla Programmazione ATmega328 noP:
http://www.michelemenniti.it/atmega328nop.html
Articoli su Elettronica In:
http://www.michelemenniti.it/elettronica_in.html

0
Offline Offline
Faraday Member
**
Karma: 31
Posts: 2908
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

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. 
Logged

AvrDudeQui front end per avrdude https://gitorious.org/avrdudequi/pages/Home

Offline Offline
Full Member
***
Karma: 0
Posts: 124
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

Per maggior comprensione quoto e rispondo nel testo

Quote

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

« Last Edit: June 01, 2013, 10:47:28 am by Campa1957 » Logged

milano
Offline Offline
Full Member
***
Karma: 3
Posts: 242
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

 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

Logged


Offline Offline
Full Member
***
Karma: 0
Posts: 124
View Profile
 Bigger Bigger  Smaller Smaller  Reset Reset

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  smiley-eek

Aspettiamo consiglio dei Guru!

Andrea
Logged

0
Offline Offline
Faraday Member
**
Karma: 31
Posts: 2908
Arduino rocks
View Profile
WWW
 Bigger Bigger  Smaller Smaller  Reset Reset

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
Code:
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
}
« Last Edit: June 01, 2013, 04:55:37 pm by leo72 » Logged

AvrDudeQui front end per avrdude https://gitorious.org/avrdudequi/pages/Home

Pages: [1] 2 3 ... 21   Go Up
Jump to: