Lipo saver esterno

[Rock Golem]

Good News.

Dopo essermi letto e riletto un po di cose sui circuiti ripartitori di corrente e sull'uso di arduino per i servi (e altro) sono andato avanti con gli esperimenti.

Inizialmente ho mappato le posizioni della radio come fatto in precedenza solo sul gas (nuovo set di radio/ricevente):

Failsafe: 1545 microsec (1541-1549) - Posizione 0°;
Full Forw.: 2039 microsec (2032-2041) - Posizione +40°;
Full Rev.: 1218 microsec (1212-1224) - Posizione -30°.

I valori sono circa 100 microsecondi diversi da quelli ottenuto con le altre radio/riceventi ma potrebbe anche essere per via del trim analogico di questa (classica rotellina ma senza indicazioni di finecorsa, punto medio)

Con questi dati in mano (trovati solo a titolo informativo per eventuali futuri usi) ho provato ad impostare questo sketch:

#include <Servo.h>
Servo myservo;  // create servo object to control a servo
int Ricevente = 10;  // digital pin used to connect the Ricevente
int val;    // variable to read the value from the pin
void setup() {
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object
  Serial.begin(9600);
  Serial.println("Setup");
  delay(1000); //attendo che si accenda la ricevente
}
void loop() {
  val = pulseIn(Ricevente,HIGH);            // reads the value
  Serial.println(val);
  myservo.writeMicroseconds(val);           // sets the servo position according to the value
}

Fatto test e devo dire che funziona. Gli angoli di movimento sono esatti e, almeno a vista, non mi accorgo di particolari ritardi, cosa però non troppo significativa.
Unica nota, nella posizione di Failsafe noto un piccolo ronzio di ricerca del centraggio quando usato in questo modo rispetto a quello standard (servo sulla ricevente).

Altra nota a margine: il microservo in dotazione con il kit arduino sembra sufficiente per far scattare gli scambi della ferrovia lego

[antonio60]

Mi pare corretto quindi non mi stupisco che funzioni

poi la versione definitiva non vederà più quei comandi

  Serial.begin(9600);
  Serial.println("Setup");

nel void setup () ...... ma che comunque non influenzano il tempo di risposta

e nemmeno quel

Serial.println(val);

nel void loop()

poi forse quache microsecondo si guadagna anche con un accorpamento, riducendolo così

void loop()
{
 myservo.writeMicroseconds(pulseIn(Ricevente,HIGH));
}
 

nel void loop () se possibile e bisogna vedere se possibile non terrei null'altro 

[Rock Golem]

Nel void loop ci andrà il controllo del livello di batteria con una istruzione IF. Metterei per prima cosa il caso vero così finché la batteria è abbastanza carica salta completamente il secondo blocco.


Dovrebbe essere qualcosa del genere:

#include <Servo.h>

Servo myservo;


int Ricevente = 10;
int Limite = 800;
int FailSafe;


void setup() {
  pinMode(Ricevente, INPUT);
  pinMode(A1, INPUT);
  myservo.attach(9);
  FailSafe = pulseIn(Ricevente,HIGH);

}

void loop() {
  if(analogRead(A1)>Limite)
  {
  myservo.writeMicroseconds(pulseIn(Ricevente,HIGH));
  }
  else {
  myservo.writeMicroseconds(FailSafe);
  }
}



A questo punto visto che il secondo blocco viene controllato solo in caso di bassa tensione potrei aggiungere anche il cicalino/buzzer senza che ci siano ritardi nella gestione. Corretto?

[antonio60]

Aggiungerei un delay un paio di secondi prima della lettura e momorizzazione del valore di FailSafe, mi darebbe la sicurezza che tutto si sia stabilizzato prima della lettura, tanto perde il tempo solo all'avvio, poi sempre per prudenza farei una serie di letture del valore di FileSafe e ne farei una media.   


void setup()
{
  pinMode(Ricevente, INPUT);
  pinMode(A1, INPUT);
  myservo.attach(9);
  delay(2000);
  FailSafe = pulseIn(Ricevente,HIGH);
}


Poi per il resto ci può stare ..... se tutto va gestito con arduino senza altra elettronica invasiva esterna  ovvio che quel comando

if(analogRead(A1)>Limite)  non sarà velocossimo dovendo

Acquisire il valore sul port A1
Fare una conversione Analogia - Digitale
Effettuare un confronto

ma se i tempi ti convincono ripeto che ci sta

[antonio60]

Poi in prima approssimazione fatti dire da Arduino stesso quanto tempo impiega a fare un ciclo usando magari l'istruzione millis()

che so una cosa così  (solo un esempio)  in blu le parti aggiunte


#include <Servo.h>

Servo myservo;

unsigned long tempo;
int Ricevente = 10;
int Limite = 800;
int FailSafe;


void setup()
{
  pinMode(Ricevente, INPUT);
  pinMode(A1, INPUT);
  myservo.attach(9);
  delay(2000);
  FailSafe = pulseIn(Ricevente,HIGH);
  Serial.begin(9600);
}

void loop()
{
  tempo= millis();
  if(analogRead(A1)>Limite)
  {
      Serial.println(millis()-tempo);
      myservo.writeMicroseconds(pulseIn(Ricevente,HIGH));
  }
  else
 {
      myservo.writeMicroseconds(FailSafe);
  }
}

[antonio60]

Dvresti avere approssimativamente il tempo ci esecuzione di quell'istruzione if

[Rock Golem]

 

Perfetto.

Proverò con questo sistema.
Solo che invece del circuito d'entrata dovrò mettere al pin analogico un portapile con 4 stilo mezze scariche (tensione tra 4.2-4.5 V) per simulare la lettura.

Mi stavo chiedendo se una volta al di sotto della tensione assegnata (16.5 V trattandosi di 5S) troncare il gas così come è il programma o prevedere una sorta di limitatore di velocità per arrivare ai Box.
Come è in effetti nei lipo cutoff degli ESC. Prima diminuiscono la velocità e poi poco dopo staccano tutto.

Dici che rischio troppi rallentamenti visto che in quel caso dovrebbe fare una serie di test condizionali?

[antonio60]

Secondo me devi provare, per esperienza quando le LiPo scendono hanno si un calo ma poi almeno in tensione risalgono ..... a quel punto se ci sai fare con il gas il mezzo lo riporti a casa senza senza tanti "stop and go"

Ma volendo potresti anche avere un pre taglio a 3.3 Volt cella, tanto a quel punto sai che ti devi fermare e la lentezza del sistema conta poco, potresti quindi intervenire abbattendo di una % il segnale ricevuto dalla RX.
Faccio un esempio numerico per spiegarmi meglio 

Grilletto al centro auto ferma     lettura = 1500
Grilletto gas al massimo             Lettura = 2000

quando la batteria segnala un pre FailSafe  se dalla TX tieni premuto il grilletto al massimo Arduino riceve 2000 ma trasmette un valore del 20% in meno 

quindi
2000-1500 = 500
20% di 500 = 100
Trasmetti 1900

se la % non la fai fissa ma la fai dipendere dal valore che leggi sull'ingresso analogico ecco che hai una sorta di rallentamento programmato, più la batteria scende più andrai piano a parità di posizione del grilletto e quando la batteria toccherà il valore limite magari fissato a 3.1V cella l'auto si ferma definitivamente e puoi fare quello che vuoi con il gas sulla TX che tanto l'auto non si schioda dal punto in cui è.

[antonio60]

Tornando invece all'istruzione millis() quella che ti ho indicato ne codice di prima, spostandola e mettendoal dove ti viene comodo la puoi usare anche per calcolare la durata (approssimativa) anche di alri pezzi di programma

la funzione millis() da un tempo diciamo assoluto, si incrementa da sola tu non hai alcun controllo si di essa e lei memorizza il tempo che trascorre dal momento dell'accensione. Per memorizzare il suo valore devi usare una variabile del tipo "unsigned long" quindi 4 byte o se vuoi 32 bit ...... quindi in decimale 4.294.967.295  che sono poi millisecondi al successivo azzeramento
 
4.294.967.295 milisecondi
4.294.967 secondi
71582 minuti
1193 ore
49 giorni

penso che per il tuo caso non ci siano problemi o rischi di errore per azzeramento della funzione ......




ad esempio usata così

void loop()
{
  tempo= millis();
  if(analogRead(A1)>Limite)
  {
      myservo.writeMicroseconds(pulseIn(Ricevente,HIGH));
  }
  else
 {
      myservo.writeMicroseconds(FailSafe);
  }
     Serial.println(millis()-tempo);
 }

ti darebbe il tempo della routine

void loop()

che poi potrebbe essere considerato il tempo tra l'istruzione
      myservo.writeMicroseconds(pulseIn(Ricevente,HIGH));
e la successiva
      myservo.writeMicroseconds(pulseIn(Ricevente,HIGH));

quindi in pratica il tempo di "latenza" tra un invio e l'altro del segnale dall RX al regolatore

[Rock Golem]

Grandissimo.

La funzione millis() la conoscevo ma adesso con questa tua spiegazione capisco perché non ero riuscito ad usarla nelle mie luci per far funzionare correttamente le 4 frecce intermittenti dopo 40 secondi. Probabilmente le assegnavo un tipo di variabile sbagliata quindi dopo l'accensione faceva alcune serie di lampeggi  e poi perdeva il conto.

Adesso metto insieme un po' delle informazioni che mi hai dato, ragiono sul codice e vedo come modificarlo..... eventualmente usando la funzione map().

Così come è configurato il taglio è a 3.3 V/cella = 16.5 V circa. Preferisco stare sempre attorno a quel voltaggio per il cutoff. Se modifico con la limitazione la farà partire un po' prima.

Adesso stavo cercando di abbozzare il circuito ma non sono sicuro sul lato batteria. Quando ho chiuso i collegamenti sulla carta una lampadina mi si è accesa in testa dicendomi "CORTO".



Ho fatto i calcoli con le resistenze che ho in casa prendendo tra quelle idonee la coppia più elevata per ridurre le correnti.

[antonio60]

No non mi pare di vedere corti  !!!!

[antonio60]

Ho provato a far due conti ..... ipotizzando quelle resistenze e tolleranze al 10% o al 5% delle resistenze

in entrambi i casi se la Resistenza da 68Kohm (valore nominale) fosse al suo massimo e contemporaneamente la resistenza da 220Kohm (valore nominale) fosse al suo minimo potresti ritrovarti sull'ingresso A1 un valore superiore a 5V a batteria pienamente carica e non so perchè non ho mai provato cosa da in uscita il convertitore di Arduino ..... 

in ogni caso con il partitore come al solito non si va molto lontano, proprio perchè le resistenze hanno una loro tolleranza e quindi o le misuri con lo strumento prima di montarle e quindi fai i calcoli con i valori reali (che poi comunque potrebbero per 1000 motivi variare nel tempo) o devi cercare un'altra strada

Ad esempio ipotizzando resistenze con valori come quelli da te selezionati con tolleranze del 5% ..... avresti valori di tensione dati ad Arduino che vanno

Batterie a massima carica V su A1   valore min = 4,5893Volt  valore  MAX = 5,3474 V
Batterie a 16.5V qunidi Failsafe   valore min = 3,6059Volt  valore  MAX = 4,2014 V

capirai che se forse potresti disinteressarti del valore a massima carica delle batterie (sempre dopo aver verificato che Arduino non si incazzi con tensioni su ingressi analogici superiori a 5V) a qanto tari il valore della tensione a cui fai intrevenire il failsafe?

Ripeto ne esci un tantino meglio se misuri le resistenze prima di montarle ..... e se te ne fai più di uno di questi oggetti magari ti tocca variare un tantino anche il programma di volta in volta     

[Rock Golem]

Allora ho fatto due prove giocando sul >/< rispetto alla lettura sul pin analogico. In questo modo ho evitato di attaccarci un carico.

Il risultato è che quando legge in carico "giusto" e va in trasmissione del segnale da ricevente a ESC il risultato è 17-18-19 millisecondi.
Quando invece legge il carico "sbagliato" il tempo passa a 0-1 millisecondi.

Penso che la differenza sia nel fatto che in un caso deve leggere un valore dal pin e poi passarlo mentre nel secondo ne passa uno già in memoria.

Sul discorso resistenze invece posso misurarle prima di montarle, visto che ne ho una mazzetta posso anche misurarle tutte fino a trovare la coppia migliore. Poi per stare sul tranquillo posso anche al limite aumentare quella maggiore passando da 220 a 300 KOhm (quella subito più grande che ho a disposizione). In questo modo La tensione massima dovrebbe arrivare attorno a 3.88 V quindi in zona sicura per proteggere Arduino.

Ovviamente una volta selezionata la coppia di resistenze con i valori letti andrò a modificare i dati sul programma.

Ancora una volta grazie mille per l'aiuto che mi hai dato.

[antonio60]

Per lavoretti di questo tipo il condiglio è comunque stare su resistenze di precisione 1% ..... però poi ovvio ognuno si aggiusta con quelo che ha

[antonio60]

dimenticavo ...... secondo me 18-20 ms di riratdo sono tanti, è vero che non è un aereo a turbina che viaggia a 350Km/h ..... ma son comunque abbastanza

Un mezzo che viaggia a 60km/h in 20ms fa circa 33cm che potrebbe essere considerata quasi la lunghezza del passo del veicolo. Ovvio su un mezzo da trial potrebbe non aver significato ma su un buggy in gara bisogna che il pilota si abitui a qualla situazione