[OT] richiesta di aiuto per programmino x Accordatore

ma in questo modo si perdono le funzionalità di GIT o no?

no perchè? ricorda che git funziona più come peer-to-peer, dove ognuno ha il suo repository, il fatto che poi uno di questi sia scelto come "principale" e stia su un server dedicato è poca roba(Infatti puoi specificare più remote oltre ad origin). Probabilmente ogni modifica è presa come un commit separato.

non sono più in sincro e quindi si deve aggiornare il remoto.

no, devi aggiornare il locale con una fetch, poi se sui sovrascrivere il locale con il remoto fai la pull.

Ma in generale questo problema non si pone se lavori in modo corretto, avero creando il tuo branch che poi mergi sul master. In generale il master dovrebbe sempre essere compilabile e funzionante, mentre tutti i lavori si fanno su branch semparati (vedi su github il grafico merge di arduino, per avere un'idea di cosa sto parlando: c'è il master che è fermo alla 1.0.5, se non erro, poi vari rami con modifiche alla Serial, al network, il cuore della 1.5.0 etc..)

Non ho capito, cioè io uso il sistema tradizionale, ho il repo locale che ha un ramo che è sempre in sincro con il repositor remoto, alcuni rami locali non sono presenti nel repo remoto, perchè magari sono di transito per la sperimentazione e poi dopo il merge il ramo viene rimosso. Ora mi sembra di capire che con il browser non si agisce sul repo locale, cioè apporto modifiche al ramo locale è effettuo il commit sempre locale, poi se voglio aggiornare il ramo stabile con le modifiche faccio il merge sempre locale, e poi aggiorno il repo remoto.

L'ideale sarebbe una interfaccia web che mi permetta di gestire il repo indifferentemente che sia remoto o locale, in questo modo si usa solo una interfaccia web indifferentemente dal sistema operativo, se tramite github fosse possibile sarebbe l'ideale.

Ciao.

la commit agisce solo in locale, è la push che manda anche sul remoto. Quindi puoi avere rami sia in solo locale che anche in remoto. Il "master" è un ramo come un altro, a parte il fatto che è quello di default siamo noi a dargli un significato particolare

Ragazzi.................... NoN fate le cose troppo difficili..........

Prometto che se c'è qualche allegato su Arifidenza lo posto anche qui

Andrea

Ciao a tutti,

finalmente sono riuscito a verificare il funzionamento dell'insieme SW + HD. :) :) :)

[u]Riepilogo del modo in cui ho fatto la prova:[/u] Il segnale potenza diretta è generato mediante un potenziometro da 10K con gli estremi collgati a +5V e 0V, il segnale è prelevato dal centrale. Per il segnale della riflessa ho collegato 6 resistenze da 1,2K ai contatti NC dei relè, collegando un capo della catena a 0V e l'altro attraverso una resistenza da 1,2K al 5V.

[u]Risultato:[/u] Dopo aver scansionato parecchie combinazioni, si riesce [u]quasi[/u] a trovare un punto 'di accordo' solo se il segnale della potenza diretta è pari al 50% della tensione di alimentazione, restano abilitate due sole uscite, però dopo il ritardo inserito per la lettura del led di stato vengono abilitate tutte le 6 uscite su cui lavorano le resistenze ed il tutto si ferma.

Questi sono i primi risultati, proverò, spero domani, cambiando i valori delle resistenze e mettondoli scalati a vedere cosa cambia nell'inserimento.

Campa1957

Domanda per Leo72,

Leggi il mio post seguente (Aggiornamento 1)

grazie

Campa1957

Leo è in ferie, anche se ogni tanto una sbirciata la dà al Forum, non so se sarà in condizioni di darti una risposta esaustiva, mi sa che stavolta dovrai aspettare tu... comunque la situazione mi sembra già abbastanza buona :)

Beato lui!!!

Visti i miei di tempi non mi posso certo lamentare se Leo tarda a respondere :) :) :)

Campa1957

Aggiornamento 1

a) fra la scheda di Arduino e la schedina dei relè ho inserito un ULN2803 (8 buffer invertente) utilizzato solo per le 6 uscite gestite fino a questo momento. La modifica è stata inserita inquanto la schedina dei relè inverte lo stato del segnale in uscita da Arduino. b) ho collegato le resistenze di simulazione del ROS sui contatti NA dei relè, nella realtà le induttanze dovranno essere collegate sui contatti NC però a me questo serve per poter far variare il segnale nel modo giusto.

Il funzionamento è il seguente:

Inserisce tutte le combinazioni fino ad arrivare ad un valore di ROS, che le leggo con il mio vecchio programmino, inferiore a 1.45 impostato come soglia, però dopo il tempo di attesa delay(1000); //faccio leggere il led di stato resetta tutte le uscite. Le uscite, anzichè resettarsi, dovrebbero comunque restare inserite inquanto anche se il risultato non è ottimale sarà sempre meglio del valore di ROS iniziale. Al massimo si potrebbe attivare un'uscita con un piccolo buzzer che segnala il mancato raggiungimento del valore minimo impostato.

Aggiornamento 2

Ho cambiato il partitore resistivo ed il risultato non cambia! Arriva ad un punto di 'accordo' aspetta 1 secondo e resetta le uscite.

Spero di essere stato chiaro nella mia spiegazione, un grazie anticipato a chi mi darà ulteriori consigli ed in particolare a Leo72 che se ne è in vacanza (beato lui!)

Campa1957

solo come prova, fai come la mia prima risposta di questo thread, inserisci tutte le combinazioni, memorizzi il minimo ROS, ripeti tutte le combinazioni fino a quando non ritrova il ROS minimo, poche righe di codice, puoi inserire un valore da non oltrepassare

è solo una prova, poco tempo

ho costruito un misuratore di campo low cost 500Mhz(arduino +pochi componenti+lcd) antenna digitale terrestre motorizzata (motore quasi da robottino) prima passata memorizza il segnale piu forte, seconda passata(con qualche gradino in meno) ritrova il segnale memorizzato e si ferma. il procedimento dovrebbe essere quasi uguale

Ciao Camperos,

grazie del tuo suggerimento!

ma non sono in grado di scrivere le poche righe di cui parli! :blush:

devo RiNgRaZiArE Leo72, Michele ed altri che mi stanno dando una mano...........

Campa1957

Ora non ricordo la variabile usata per memorizzare il valore letto, comunque prova ad inserire, dopo il delay(1000):

if ros <= 1.45 { //al posto di ros metti il nome corretto della variabile, al posto di 1.45 metti il nome della variabile che lo contiene
while (1);
}

in questo modo finché non ottieni il valore desiderato la procedura continua, poi si ferma tutto allo stato attuale.

Ciao Michele,
ho inserito le righe che mi hai suggerito ma senza risultato, quando lancio la verifica, prima di caricare il tutto su Arduino mi segnala errore.
Di seguito inserisco di seguito il SW scritto da Leo72.

//
// ACCORDATORE DI ANTENNE
// V. 1.0
// Scritto da Leonardo Miliani 
// copyleft 2013 :-P
// GNU GPL 3.0
// relé induttori collegati sui pin D8..D13
// relé condensatori sui pin D0..D5
// led di stato su D7

void setup() {
    DDRB = 0b00111111; //pin PB0..5 come OUTPUT - questi pin comandano i relé degli induttori
    PORTB = 0b00000000; //segnale LOW sulle uscite
    DDRB = 0b11111111; //pin PD0..7 come OUTPUT - questi pin comandano i relé dei condensatori
    PORTD = 0b00000000; //segnale LOW sulle uscite
    DIDR0 |= ((1<<ADC2D) | (1<<ADC3D) | (1<<ADC4D) | (1<<ADC5D)); //spengo il buffer digitale sui pin PC2..5
    checkAntenna(0); //induttante
    delay(1000); //faccio leggere il led di stato
    PORTB = 0b00000000;
    PORTD = 0b00000000;
    checkAntenna(1); //condensatori
}

void loop() {
}

void checkAntenna(byte Cap) {
    float ROS = 0.0; //ROS ideale
    float realROS = 0.0; 
    ROS = 1.45; //impostare qui il ROS fissato come obiettivo finale sull'antenna
    byte relais = 0;
    boolean exit = false;
    boolean done = false;
    float oldROS = readRos(); //lettura iniziale
    do {
        float realROS = readRos();
        if (realROS < ROS) {
            if (oldROS < realROS) {
                relais--;
                if (!Cap) {
                    PORTB = relais; //tolgo il relé precedente
                } else {
                    PORTD = relais;
                }
            }
            done = true;
            exit = true; //terminato
        } else { //correggo il ROS
            oldROS = realROS; //salvo la vecchia lettura
            if (++relais == 64) { //raggiunto il max di combinazioni
                exit = true; //esco
            }
            if (!Cap) {
                PORTB = relais; //aggiungo un relé in formato binario
            } else {
                PORTD = relais;
            }
         }
         delay(1000); // Ritardo suggerito da Leo72 per vedere il funzionamento del sistema AAA
    } while (!exit);
    if (done) {
        PORTD |= (1<<7); //accende il led "OK"
    }
}


float readRos() { //lettura del ROS
    int pot_rifl = readAnalogInput(A0);
    int pot_dir = readAnalogInput(A1);
    return ((1.0 + (float)(pot_rifl / pot_dir)) / (1.0 - (float)(pot_rifl / pot_dir)));
}


int readAnalogInput(byte input) { //lettura con media di un pin
    int tempRead = 0;
    for (byte i = 0; i < 10; i++) {
        tempRead += analogRead(input);
    }
    return (tempRead /= 10);
}

Campa1957

posta il codice con la modifica e poi scrivi l'errore che ti dà

Come promesso allego foto postate su Arifidenza, nelle foto il blocco relè assemblato parecchi mesi fa’

SAM_0225.JPG

SAM_0227.JPG

Per comprare quei relè hai fatto il finanziamento? :grin:

Io per adesso ho il cervello come il burro al sole e ho cose mie da fare che non so come fare, anche perché ormai ho fuso. Aspetto settembre nella speranza che il clima sia più favorevole ai mie neuroni.

Ciao.

Ciao Mauro,

è vero costano un botto però non ti danno problemi. C'è tutta una teoria su come pilotarli, che dice di sovraalimentarli e poi mettere una resistenza di caduta per ottenere una chiusura più veloce che invece dice di sotto alimentarli per farli durare di più!!!

Ne devo recuperare ancora mezza dozzina poi basta!!!

Campa1957

Ciao a tutti,

Il collega OM americano, che ho segnalato tempo addietro, ha aggiornato il suo lavoro. Se un'anima buona ha voglia di buttarci un'occhio.....

questo è il link:

http://blog.radioartisan.com/arduino-antenna-tuner/

Campa1957

Ciao a tutti,

finalmente ho trovato un po’ di tempo per riprendere il mio lavoro!

come detto in un post pecedente ho inserito un buffer invertente sulle 6 uscite utilizzate fino ad ora di Arduino e ho fatto un po’ di prove con un partitore resistivo per simulare la riduzione del segnale sull’ingresso della potenza riflessa.
un paio di cose che non mi sono chiare:

  • vorrei capire se, fatta la prima lettura, aspetta il ritardo impostato e poi fa la seconda … poi la terza …
    oppure si comporta in modo diverso ???
  • il range di segnale sugli ingressi è corretto che sia da 0 a 5v ???

Allego il lavoro di Leo72 con inserimento della riga 59 (temporizazione)

//
// ACCORDATORE DI ANTENNE
// V. 1.0
// Scritto da Leonardo Miliani 
// copyleft 2013 :-P
// GNU GPL 3.0
// relé induttori collegati sui pin D8..D13
// relé condensatori sui pin D0..D5
// led di stato su D7

void setup() {
    DDRB = 0b00111111; //pin PB0..5 come OUTPUT - questi pin comandano i relé degli induttori
    PORTB = 0b00000000; //segnale LOW sulle uscite
    DDRB = 0b11111111; //pin PD0..7 come OUTPUT - questi pin comandano i relé dei condensatori
    PORTD = 0b00000000; //segnale LOW sulle uscite
    DIDR0 |= ((1<<ADC2D) | (1<<ADC3D) | (1<<ADC4D) | (1<<ADC5D)); //spengo il buffer digitale sui pin PC2..5
    checkAntenna(0); //induttante
    delay(10000); //faccio leggere il led di stato AAAAA
    PORTB = 0b00000000;
    PORTD = 0b00000000;
    checkAntenna(1); //condensatori
}

void loop() {
}

void checkAntenna(byte Cap) {
    float ROS = 1.0; //ROS ideale AAAAA
    float realROS = 1.0; // AAAAA
    ROS = 1.45; //impostare qui il ROS fissato come obiettivo finale sull'antenna 
    byte relais = 0;
    boolean exit = false;
    boolean done = false;
    float oldROS = readRos(); //lettura iniziale
    do {
        float realROS = readRos();
        if (realROS < ROS) {
            if (oldROS < realROS) {
                relais--;
                if (!Cap) {
                    PORTB = relais; //tolgo il relé precedente
                } else {
                    PORTD = relais;
                }
            }
            done = true;
            exit = true; //terminato
        } else { //correggo il ROS
            oldROS = realROS; //salvo la vecchia lettura
            if (++relais == 64) { //raggiunto il max di combinazioni
                exit = true; //esco
            }
            if (!Cap) {
                PORTB = relais; //aggiungo un relé in formato binario
            } else {
                PORTD = relais;
            }
         }
         delay(300); // Temporizzazione per poter vedere il funzionamento!!! Leo72/AZ
    } while (!exit);
    if (done) {
        PORTD |= (1<<7); //accende il led "OK"
    }
}


float readRos() { //lettura del ROS
    int pot_rifl = readAnalogInput(A0); // lettura della pot. riflessa AAAAA
    int pot_dir = readAnalogInput(A1); // lettura della potenza diretta AAAAA
    return ((1.0 + (float)(pot_rifl / pot_dir)) / (1.0 - (float)(pot_rifl / pot_dir))); // calcolo del ROS AAAAA
}


int readAnalogInput(byte input) { //lettura con media di un pin
    int tempRead = 0;
    for (byte i = 0; i < 10; i++) {
        tempRead += analogRead(input);
    }
    return (tempRead /= 10);
}

Campa1957

Ciao, ti rispondo qui. Il mio programma non ha attese fra una impostazione e la successiva. Ma il programma era una bozza, doveva servirti per poterti permettere di lavorarci sopra in autonomia. Mi sembra di capire però che di programmazione sei messo maluccio, quindi non hai sviluppato niente in più giusto?

Se mi dici come si deve comportare il programma, potremmo vedere di modificarlo. Puoi inserire uno o due pulsanti, sul tuo circuito? Ne potremmo usare uno per avviare/far ripartire la procedura d'accordatura, ad esempio.