aiuto per uno sketch rc

[wrighizilla]

ciao a tutti.. avrei bisogno di un favore, sono alle prese con uno sketch arduino che serve per azionare le 4 ruote sterzanti su una radio 3ch con il canale aux 2 posizioni fisse.

in pratica nella prima posizione di aux la macchina sarà 2ws mentre nella seconda posizione la scheda nano copia il servo di sterzo anteriore e lo assegna al servo di sterzo posteriore.
lo sketch funziona anche come è adesso ma ha 2 problemi che non riesco a risolvere:
il primo è che la centratura del servo è efficace solo nella posizione 2ws, quando attivo il doppio servo perdo la centratura che torna sempre a 90°
nello sketch c'è un vlaore di centratura (1500 oppure 90) che non posso al momento cambiare senza perdere il settaggio.
nella pratica con 2ws posso centrare lo sterzo a 70 ed avere le ruote dritte ma quando aziono la 4ws mi torna a 90 e le ruote ovviamente non saranno più dritte.
vorrei incorporare assieme il settaggio di centratura dello sterzo in entrambe le posizioni di aux
altrimenti quasi non serve a niente avere una posizione centrata dal software, bisogna fare tutto meccanicamente con le astine di rinvio e il milleriche delle squadrette.

la parte del travel invece funziona bene e ri riesce a settare la corsa disponibile a piacimento.

il secondo problema riguarda il segnale in ingresso dalla rx spektrum dsm che restituisce una piccola oscillazione di errore nella lettura dei dati in ingresso nel serial monitor, in pratica oscilla tra 1500 e 1508 e questa vibrazione si traduce in un servo che vibra con un ritmo quasi cardiaco al momento che inserisco le 4ws.
dalla radio posso settare la trasmissione in 11ms oppure 16.5ms quest'ultimo è migliore, il servo vibra meno intensamente ma rimane comunque un ritmo ciclico abbastanza fastidioso.

tra l'altro l'applicazione è nata per una microcamera da usare in posizione fissa avanti oppure poterla ruotare insieme allo sterzo (anche giusto per dare ai lati un occhiata di sicurezza) ma con la microcamera la vibrazione è molto più fastidiosa rispetto alla barra di sterzo..

sapete aiutarmi a ridurre questo spiacevole effetto ritmico? non so scrivere quello che manca per risolvere questi 2 problemi.

allego lo sketch, i valori sono quelli dalla mia radio e anche i pin utilizzati, nella nano entrano i segnali dei canali sterzo e aux ed esce il segnale per il servo clone dello sterzo.



vi ringrazio per l'aiuto.

[Sinapsi]

E' da tanto, troppo tempo che non smanetto con arduino e non ho molte altre info su come hai fatto i collegamenti, però a prima vista hai una codizione IF ---> ELSE che fa riferimento a due pin diversi.

SE il pin 8 è maggiore di 1600, poniti al centro
DIVERSAMENTE....con riferimento al pin 9 ALTO, scrivi il 'servo' a....

Ti ripeto Cris....è da tantissimo che non ci smanetto ed è facile che io interpreti male il codice che hai scritto, oltretutto non sapendo che collegamenti hai fatto e cosa hai intenzione di fare, diventa ancora più complicato.
Quello che hai definito per 'amplificare' la sterzata, come lo hai inteso ???

[wrighizilla]

E' da tanto, troppo tempo che non smanetto con arduino e non ho molte altre info su come hai fatto i collegamenti, però a prima vista hai una codizione IF ---> ELSE che fa riferimento a due pin diversi.

SE il pin 8 è maggiore di 1600, poniti al centro
DIVERSAMENTE....con riferimento al pin 9 ALTO, scrivi il 'servo' a....

Ti ripeto Cris....è da tantissimo che non ci smanetto ed è facile che io interpreti male il codice che hai scritto, oltretutto non sapendo che collegamenti hai fatto e cosa hai intenzione di fare, diventa ancora più complicato.
Quello che hai definito per 'amplificare' la sterzata, come lo hai inteso ???

i collegamenti sono :
10 è il segnale del servo di sterzo posteriore myservo
9 è il segnale del servo di sterzo anteriore che dovrà essere copiato da myservo
8 è il segnale del canale ausiliario 2 posizioni fisse che permette di attivare o disattivare le 4ws

in questo sketch adesso posso settare la centratura solo in una delle 2 posizioni di aux (quella col myservo fermo 2ws) ma la perdo tornando a quella originale appena cambio posizione di aux sulle 4ws
in sostanza fin quando non cambio il valore da 90 (1500) non ti accorgi di niente.. se però mi centro di fino modificando quel valore, diciamo 70.. appena inserisco le 4ws avrò le ruote storte.
quello che vorrei è poter settare la centratura identica per entrambe le posizioni di aux

tornando alla tua descrizione del problema, se il dato del pin 8 (aux)è superiore a 1600 poniti al centro, questo è facile anche perchè il servo rimarrà fermo immobile, ma se il dato sarà inferiore a 1400 dovrà avvenire una proporzione aggiunta o sottratta alla mappatura che copia il segnare del servo anteriore... almeno la logica mi sembra questa.

comunque è fantastico.. sono a 2 giorni scarsi di questo universo e non ci capisco ancora una mazza

[wrighizilla]

aspettate, semplifico il discorso con questo sketch

Codice: Seleziona tutto

#define antsx 1000 //-- ingresso fine corsa sx
#define antdx 2000 //-- ingresso fine corsa dx
#define postsx 5 //-- corsa sx del servo in uscita --se invertiti questi valori si applica il reverse
#define postdx 180  //-- corsa dx del servo in uscita --se invertiti questi valori si applica il reverse


#include <Servo.h>
Servo myservo;
unsigned int rxpulse;
unsigned int newPos;
void setup() {
myservo.attach(10); //-- segnale del servo myservo posteriore in uscita
pinMode(8, INPUT); //-- segnale del servo di sterzo anteriore in entrata
}
void loop() {
rxpulse = pulseIn(8, HIGH);  
newPos = map(pulseIn(8, HIGH), antsx, antdx,postsx, postdx); //-- mappatura per copiare i segnali del servo anteriore e riportarli a myservo 
myservo.write(newPos); 
}

in questo programmino uno che ha la radio 2ch può copiare il servo anteriore con un cavetto a Y e far muovere il servo posteriore aggungendo la possibilità di fare settaggi, può reversare il servo invertendo i valori di define postsx e postdx e sempre con gli stessi valori determinare la corsa massima che avrà il servo posteriore.

quello che adesso mi manca è definire la centratura del servo posteriore.

tipo: in entrata il centro è 1500 in uscita il centro sarà 1500 + correzione positiva o negativa a seconda della direzione nella quale servirà allineare le ruote
ovviamente questa correzione dovrà essere progressiva.. se giro lo sterzo a diaciamo 1800 in entrata, la correzione renderà 1820 al myservo in uscita.

ma.. non lo so ancora fare

[kele-1]

Ciao wrighizilla. Allora, quando imposti a 4 ruote sterzanti vuoi che se all'anteriore hai un valore per esempio di 1600, al posteriore devi impostare un valore di 1400, è corretto?

La funzione map fa una proporzione, mentre tu vuoi invertire il segno del valore di differenza tra il pulse letto e 1500.
Per fare questo ciò che mi viene in mente è fare una semplice sottrazione nella quale calcoli la differenza tra il tuo dato e 1500 (che quindi potrà essere positivo o negativo), dopodiché al posteriore invierai il valore 1500 -(meno) "differenza calcolata" in modo che dal valore 1500 inverti il segno al delta calcolato.

Proverei una cosa del tipo
myservo.write(1500-(rxPulse-1500));

mi sono permesso di scrivere la tua variabile con la P maiuscola in quanto scrivere la prima lettera delle parole successive alla prima in maiuscolo aumenta la leggibilità ed è una cosa che ti consiglio.
Gli informatici mi sembra che usino questo accorgimento.

Oppure si potrebbe mettere il servo a testa in giù, a quel punto potresti inviare a entrambi i motorini lo stesso valore risparmiando cicli di calcolo!

Una cosa che non mi so spiegare sono quei valori 923 e 2085 che sono sicuro essere i valori che tu hai letto ai valori estremi degli stick.
E dico che non me la so spiegare perché sicuramente la trasmittente del tuo radiocomando invia segnali da 1000 a 2000.
Anche io avevo provato ad usare la pulseIn con risultati ancora peggiori dei tuoi, nel senso che mi leggeva valori da circa 700 a circa 1700... Allora mi ero scritto io una funzione e difatti dopo leggevo da 1000 a 2000.
Se ti interessa te la posso cercare o riscrivere, ma in sostanza si trattava di attendere con uno o due while di leggere una transizione dallo stato basso ad alto (dovrei tornare a ragionarci e al momento sto scrivendo abbastanza in fretta), quando questo accade con la funzione micros() ti salvi in un unsigned long il valore letto, poi con un altro while attendi che si passi dallo stato alto a quello basso e a questo punto riutilizzi la funzione micros() dentro una sottrazione in cui riprendi il valore salvato in precedenza. Una cosa del tipo:

pulse = micros() - tempoSalvatoPrima;

In ogni caso sia la pulseIn che questa funzione che ti ho detto non sono proprio il massimo per un modellino in quanto fermano completamente lo sketch, nel senso che prima di arrivare al comando successivo devi aspettare perforza che la funzione abbia letto tutto il segnale.

Se questo inizia a darti fastidio puoi sfruttare gli interrupt. Al momento mi sembra che a te ne serva solo uno quindi arduino mette a disposizione una funzione associabile ai pin 2 e 3 mi sembra per fare ciò.
Nel caso te ne servano più di due bisogna agire in modo diverso. Se vuoi ci torniamo.

Arriviamo quindi all'oscillazione delle letture con conseguente fastidiosa vibrazione.
Innanzitutto consiglierei di appoggiare la cam su di una spugnetta o qualcosa di simile per smorzare le vibrazioni in ogni condizione (metti che tu volontariamente giri a sinistra e destra velocemente o anche solo sei su terreno irregolare, potrebbe aiutare a non far venire subito il mal di mare).

Detto ciò, via software consiglierei di mettere una condizione if nella quale se il risultato letto è minore del valore precedente + 8 e maggiore del valore precedente - 8 non fa niente.

Ho scritto troppo e non ho molta voglia di rileggere quindi spero di non aver scritto troppe castronate!
Spero intanto di esserti stato utile.
Fammi sapere come va.
Ciao!

[wrighizilla]

ti ringrazio dell'aliuto, vedo di metabolizzare il tuo post che ha degli spunti interessanti, purtroppo sono a 2 settimane di arduino e ho le paperine che ancora mi girano sulla testa.

così come lo leggi lo sketch adesso funziona come dovrebbe .. o quasi

quasi perchè se modifico ad esempio "maxcorr" (che deve ridurre la corsa del servo in modo inversamente proporzionale al gas) si sballano anche gli endpoint postsx e postdx
idem se cambio i valori di "gaslimit" se lo abbasso aumento la corsa degli endpoint
quindi funziona come dovrebbe ma è macchinoso da settare.

il fatto è che gli endpoint (visto che sforzano sulla meccanica dello sterzo) dovrebbero essere fissi, li trovi anche in modo empirico ma poi li lasci come sono una volta che li hai definiti.. adesso no, se aumento la correzione diminuiscono gli endpoint
idem se allargo il gaslimit che ho creato per dare un certo margine di gas a bassa velocità nel quale la corsa dello sterzo non deve cambiare e resta tutta quella disponibile per girare al massimo della corsa.

ad ogni modo così funziona tutto ma per settarlo bene tocca trovare un compromesso tra dei valori che mi sarei aspettato non interagissero tra di loro finendo col cambiare la corsa a disposizione del servo posteriore.

nella mia idea di come invece dovrebbe essere:
imposti gli enpoint del servo posteriore. (postdx-postsx)
dai un valore di gas entro il quale la macchina cammina con tutto lo sterzo disponibile, ad esempio 1/3 di gas (gaslimit)
infine dai un valore entro il quale lo sterzo si chiude ad alta velocità limitando la corsa (maxcorr)
e ognuno di questi valori fa solo quello che ci si aspetta che faccia, senza scombinare gli altri..

tolerance e center funzionano bene, sembrano indipendenti dal resto.

minffw e maxffw si sono resi necessari perchè in retro impazziva tutto.. la funzione inversamente proporzionale tra gas e sterzo deve riguardare solo la marcia avanti che va da 1500 a 2000

i veri valori in entrata variano di conseguenza al travel della radio.. 1000-2000 li ho con la radio settata a 110 su 150 disponibile.
ma per accertare il valore preciso faccio un void signal dei piedini 7-8 e anche quei valori dovrebbero diventare fissi.
a quello ci penso quando metterò la centralina sul camion.

se lo vuoi pulire, snellire modificare va benissimo, anzi ti ringrazio.
se riusciamo a renderlo facile e stabile lo divulgo volentieri sui forum di modellismo anche perchè una buona centralina di sterzo posteriore potrebbe essere utile per parecchi che hanno macchine con 2 sterzi.

#define minffw 1500 // -- minimum forward signal
#define maxffw 2000 // -- maximum forward signal
#define antsx 1000 // -- in front servo signal sx
#define antdx 2000 // -- in front servo signal dx

#define postsx 5 // out rear servo sx endpoint if inverted with postdx it reverse
#define postdx 175 //-- out rear servo dx endpoint if inverted with postsx it reverse

#define center 0 //-- add or subtract xx value to center steering
#define tolerance 3 //-- if your poor quality servo vibrates try 5
#define maxcorr 100 //-- in gain steering reduction by throttle if reverse add -
#define gaslimit 1700 //-- slow forward without correction

#include <Servo.h>
Servo myservo;
unsigned int rxpulse;
unsigned int gaspulse ;
unsigned int correction;
unsigned int newPos, oldPos;
void setup() {
myservo.attach(10); //-- rear servo signal out pin
pinMode(8, INPUT); //-- front servo signal in pin
pinMode(7, INPUT); //-- throttle signal in pin
}
void loop() {
rxpulse = pulseIn(8, HIGH);
gaspulse = pulseIn(7, HIGH);
{
if (gaspulse > gaslimit);
else
gaspulse = constrain (gaslimit, minffw,maxffw);
correction = map(gaspulse, minffw, maxffw, 0, maxcorr);
newPos = map(rxpulse, antsx, antdx, (postsx+correction), (postdx-correction));
}
if (abs(newPos - oldPos)> tolerance) {
oldPos = newPos;
myservo.write(newPos + center);
}
}

[kele-1]

Attento che quel codice che hai postato ha delle parentesi fuori posto.
Alla terza riga dopo il loop c'è una parentesi sola soletta povera.
inoltre l'else è lui senza parentesi.
Adesso non so bene se sia voluto o meno perché faccio un po di fatica ad entrarti nella testa quindi ti chiederei di andare avanti un passetto alla volta.

Intanto ti dico che se non metti le parentesi dopo una condizione il programma assocerà solo il primo comando successivo a quella condizione. Quindi correction e newPos verranno eseguti SEMPRE dal tuo programma, sia che gaspulse sia maggiore, sia che sia minore di gaslimit.

Un'altra cosa che ho notato è che tu vuoi che a basse velocità i comandi vengano eseguiti direttamente, senza limitazioni e correzioni varie, mentre invece la centralina deve agire quando gaspulse supera il valore di gaslimit.
Questo è proprio quello indicato dall'if

if (gaspulse > gaslimit)

a cui però segue un punto e virgola, quindi in questa condizione non vengono associate delle correzioni (a parte correction e newPos che come detto prima verranno eseguite sempre).

Per non sbagliare con le parentesi ti consiglio di aprirle e chiuderle subito ogni volta che inizi una condizione, dopodiché scrivi all'interno delle stesse tutto quello vuoi associare a quella condizione.
Per non uscire matto quando rileggi il codice invece ti consiglio di indentare.
Non usi la IDE di arduino? Quando apri una parentesi e vai a capo la chiude in automatico all'altezza giusta e ti posiziona il cursore tra le due con l'indentazione giusta.
In breve fa per te quello che ti ho appena suggerito!

Ricapitolando:
- togli la parentesi che è da sola.
-scrivi

if() {
}

e credo con dentro le condizioni...ma ci arriviamo con calma

- l'else quindi non so se debba avere condizioni...puoi o aprire e chiudere le parentesi che male non fa, o nel caso rimanga vuoto puoi anche toglierlo completamente.
Ovviamente anche per la parentesi sopra l'ultimo if dovrai valutare cosa fare di lei a seconda di quello che hai fatto prima.

Ok intanto rimaniamo così...il comportamento dovrebbe già essere diverso.

A questo punto ti chiederei di raccontarmi a parole cosa fanno o cosa vorresti facessero correction e newpos che se no ci perdo una vita a venirne fuori!
Ciao!

Ahhhh e mi piacerebbe vedere il modellino se non ti rompo!
Di modellismo ho iniziato poco più di un'anno fa col quadricottero e per il resto sto a zero quindi sono curioso

[wrighizilla]

raccontato a parole vorrei che la correzione inversamente proporzionale chiudesse lo sterzo via via che aumenta il gas.. per arrivare a una macchina comune con 2 ruote sterzanti anteriori quando va a tutto gas.
ovviamente a bassa velocità vorrrei poter settare un minimo di gas limit che mi permette di andare piano con tutta la corsa delle 4 ruote sterzanti.
questo gasmimit sarebbe utile poterlo impostare come valore numerico semplice.. da 1 a 10 oppure da 0 a 100 o percentuale.. esempio non fare nulla fino al 20% di gas.. poi dopo il 20% di gas inizia a chiudere progressivamente la quantità di sterzo posteriore.
in tutto questo gli endpoint massimi non vorrei venissero influenzati dagli altri paramentei, ad esempio se tocco correction o gaslimit e me li vedo allargare o chiudere anche a gas zero costringendo a reimpostarli.
deteminato che la corsa massima è quella data dalla meccanica dello sterzo metterei un valore massimo di corsa e quello deve restare anche se alzo o abbasso la correzione.
la correzione dovrebbe solo correggere l'ampiezza di sterzo da poca a tanta.. ovvero a tutto gas puoi scegliere se avere lo sterzo posteriore fermo oppure che un pochino gira.
infine serve la centratura del servo perchè le ruote dovranno essere dritte rispeto alle anteriori che magari sono settate via radio con un pò di trim..
ma questa sembra funzionare senza problemi.
per ultimo in retro non importa che cambi nulla, si può avere anche la corsa massima di sterzo tanto non vai mai a tutta canna di retro.

ti ringrazio, stasera vedo se riesco a mettere in pratica quanto mi hai suggerito

il modello è questo, pesa 9kg è lungo 1 metro

https://i.postimg.cc/d3snvNkn/1011225.jpg

https://i.postimg.cc/vZj7PZ33/_1011224.jpg

https://i.postimg.cc/y6mNbLTt/P1011412.jpg

e questo è suo zio, entrambi sono operativi e hanno 4ws quindi potrebbero imbarcare a breve la controller che stiamo scrivendo.

https://i.postimg.cc/050WJ28t/DSCN1853.jpg

https://i.postimg.cc/90NK3sRn/DSCN9317.jpg

[wrighizilla]

credo di aver inserito delle info vitali per settare il progetto:
questi primi dati si ricavano da signal void

la corsa totale del segnale gas: gaspulse 1000-2000
la corsa dal punto neutro (macchina ferma) al massimo del gas minffw 1500 maxffw 2000
la corsa del segnale di sterzo antsx 1000 antdx 2000
------------
i dati indispensabili per il settaggio:
la corsa degli endpoint posteriori postsx 5 postdx 175 (non più di quelli necessari sennò si sforzano i bicciherini sugli assali)
il punto di centratura per mettere le ruote posteriori dritte: center 0
la quantità di gas da poter dare avendo la massima corsa di sterzo fissa al suo massimo: gaslimit che adesso è a 1600 ma va rivisto.
la correzione, che in modo proporzionale partirà chiudendo la corsa di sterzo fino anche ad annullarla del tutto col servo che non si muove più quando siamo alla massima velocità: maxcorr o correction 100 sterzo tutto chiuso
---------
infine la tolleranza per il servo che vibra ma questa dipende dalla qualità dei servi, giusto un aggiunta per non farli continuamente vibrare a ritmo cardiaco: tolerance 3-5

chiaro che se adesso imposto gli endpoint e poi ritocco la correzione oppure la percentuale di gas da poter dare a bassa velocità, rompe le balle rifare tutte le volte gli endpoint ricercando un compromesso accettabile.
adesso è proprio così, funziona uguale ma potrebbe essere scritto meglio e quindi meno macchinoso da settare.

questo è il circuito in questione da saldare sulla arduino nano

https://i.postimg.cc/4dGfhd3w/rear-serv ... p-gain.jpg

[wrighizilla]

arrivo fino qui.

ho provato una marea di cose ma nessuna ha funzionato.

ho messo un pochino di ordine nel testo e ho cambiato alcuni nomi per rendere più chiaro lo sketch.

funziona tutto come dovrebbe, compresa la possibilità di dare un pochino di gas a bassa velocità mantenendo tutto lo sterzo (cambiando valore a Slowlimit)

adesso anche la correzione Gain funziona perfettamente , inversamente proporzionale e fino a chiudere completamente la corsa del servo posteriore (cambiando valore a Max_gain)

anche in retro funziona tutto: rimane la massima corsa disponibile per tutta la retromarcia.


però se cambio i valori di Slowlimit e Max_gain si spostano anche i finecorsa Postdx e Postsx obbligandomi a reimpostarli da capo di conseguenza alle modifiche.

è un problema perchè sarebbero valori che dovrebbero restare fissi visto che dipendono dalla effettiva corsa di sterzo a disposizione.
cambiando i parametri e di conseguenza Postsx e Postdx si rischia di allargare la corsa molto oltre quella che lo sterzo meccanicamente permette.

i fine corsa sarebbero uno dei parametri da impostare per primo e poi dimenticare.

non so, manca qualche parentesi oppure va scritto meglio qualcosa ma non trovo l'inghippo

se avete una soluzione vi ringrazio

riporto lo sketch rivisto e corretto al meglio delle sue attuali possibilità

Codice: Seleziona tutto

#define Neutral 1500 // -- minimum forward signal
#define Maxspeed 2000 // -- maximum forward signal
#define Antsx 1000 // -- in front servo signal sx
#define Antdx 2000 // -- in front servo signal dx
#define Postsx 5 // out rear servo sx endpoint if inverted with postdx it reverse
#define Postdx 175 //-- out rear servo dx endpoint if inverted with postsx it reverse
#define Center 0 //-- add or subtract xx value to center steering
#define Tolerance 3 //-- if  poor quality servo vibrates try 5
#define Max_gain 100 //--  gain steering reduction by throttle if reverse add -
#define Slowlimit 1700 //-- slow forward without endpoint correction
#include <Servo.h>
Servo myservo;
unsigned int Rxpulse;
unsigned int Gaspulse ;
unsigned int Gain;
unsigned int NewPos, OldPos;
void setup() {
myservo.attach(10); //-- rear servo signal out pin
pinMode(8, INPUT); //-- front servo signal in pin
pinMode(7, INPUT); //-- throttle signal in pin
}
void loop(){
Rxpulse = pulseIn(8, HIGH);
Gaspulse = pulseIn(7, HIGH);
if (Gaspulse > Slowlimit);
else
Gaspulse = constrain (Slowlimit, Neutral, Maxspeed);
Gain = map(Gaspulse, Neutral, Maxspeed, 0, Max_gain);
NewPos = map(Rxpulse, Antsx, Antdx, (Postsx + Gain), (Postdx - Gain));
if (abs(NewPos - OldPos)> Tolerance) {
OldPos = NewPos;
myservo.write(NewPos + Center);
}
}

[kele-1]

No vabbee...! Ma è fighissimo!! Troppo ridere l'omino col braccio fuori anche quando va a duemila all'ora sui sassi più grandi del camion

Vorrei chiederti due cose.
Che cos'è void signal?
Se è una funzione a disposizione di arduino non riesco a trovarla sul sito...

E un'altra frase che avevi scritto ieri di cui non ho capito assolutamente niente e mi ero dimenticato di chiederti cosa voleva dire.
"i veri valori in entrata variano di conseguenza al travel della radio.. 1000-2000 li ho con la radio settata a 110 su 150 disponibile. "

anzi 3 cose!
Nella foto del circuito che hai mandato cos'è quel dispositivo che collega il segnale del ricevitore ai pin digitale, 5V e gnd?

Edito il messaggio perché ero andato via dal pc con la risposta ancora da finire e non avevo visto che avevi scritto un altro post.
A sto punto se dici che ci sei quasi non ha senso che ti riscriva quello che avevo inviato perché mi sa che sarebbe un po' come stravolgere tutto...

potresti provare una cosa...
ti stampi sulla seriale i valori di tutte le variabili che il programma usa con un delay di mezzo secondo tra un loop e l'altro in modo che tu riesca comodamente a leggere quello che succede nel programma.

Stampati solo le variabili, tutto ciò che hai definito con #define è una costante e caschi il mondo rimane così com'è.
dici che cambiano i finecorsa che sono nei #define...ma succede qualcos'altro in realtà

[wrighizilla]

void signal probabilmente non è il nome giusto ma è questo sketch base che certamente cononosci, l'ho trovato scritto così, non mi sono posto il problema.

int rxpulse;
void setup() {
Serial.begin(9600);
}
void loop() {
rxpulse = pulseIn(7, HIGH); //-- per sapere qual'è il valore del segnale di sterzo
Serial.println(rxpulse);
}

da questo ricavo la corsa del segnale trasmesso..
la mia radio spektrum dx3s ha un travel che arriva a 150 dove i valori eccedono 1000-2000 invece col travel default a 100 ho dei valori inferiori a 1000-2000.
chiaro che nel setup poi metterò i valori corretti controllando da serial monitor l'effettiva corsa del servo anteriore e del gas corrispondenti sul modello.
nel disegno non c'è nessun dispositivo, è una spinetta a Y che ho colorato di grigio per non stare a farla di 3 colori.

lascia perdere i valori della radio, per ragionare vanno benissimo 1000-2000 inutile che metta 980- 2030

al momento fa tutto eccetto che se cambio la quantità di gas a bassa velocità (Slowlimit) e la quantità di correzione proporzionalmente inversa al gas (max_gain) vedo il servo allargare la sua corsa o restringerla con il gas ancora fermo a neutro.

si arriva comunque a trovare il compromesso perchè se modificando quei 2 paramentri lo sterzo posteriore si allarga troppo diminuisco gli endpoint del servo posteriore fino a ottenere la massima corsa giusta.
viceversa se a cambiare Slowlimit e Max_gain gli endpoint si stringono troppo (sempre a neutro macchina ferma) ritocco Postsx Postdx e lo riallargo.

il fatto è che appunto vorrei fossero definiti e fissi senza non doverli ritoccare e riadattare quando cambio questi 2 parametri abbastanza fondamentali.

ti dico quello che vedo: se imposto slowlimit a 1600 il servo ha una certa corsa massima, se lo imposto a 1700 la corsa dimezza.
idem se aumento Max_gain stringo la corsa del servo se lo abbasso allargo la corsa del servo.. tutto questo da fermo e ugualmente per tutta la retro.
capisci che va bene anche così ma diventa solo macchinoso settare la controller sulla macchina.
ora la corsa definita in define Postsx Postdx è approssimativa a 5-175, fin quando monto la controller sul camion non saprò di preciso quale saranno i valori corretti perchè dipendono anche dai valori che arrivano da servo anteriore e quelli non li posso modificare.

se hai qualche idea prova a mettere uno sketch modificato, lo posso provare anche subito

ti ringrazio.

[kele-1]

Adesso dovrei scappare a fare un paio di cose che oggi ho tralasciato domani provo a scrivere qualcosa.
intanto ho dato un'ultima occhiata e ho visto che slowlimit è dentro la funzione constrain...
slowlimit è #define quindi il suo valore non cambierà mai.
Quella comando farà assumere a gaspulse sempre sempre sempre il valore 1700

P.S.
bella quella storia della radio. non la sapevo

[wrighizilla]

Adesso dovrei scappare a fare un paio di cose che oggi ho tralasciato domani provo a scrivere qualcosa.
intanto ho dato un'ultima occhiata e ho visto che slowlimit è dentro la funzione constrain...
slowlimit è #define quindi il suo valore non cambierà mai.
Quella comando farà assumere a gaspulse sempre sempre sempre il valore 1700

P.S.
bella quella storia della radio. non la sapevo

si ma va bene, Slowlimit è solo una variabile settabile dall'utente per cambiare Gaspulse e portarlo a 1700 altrimenti la correzione partirebbe dal neutro quando la macchina è ancora ferma.
se parte da neutro ti perdi parte delle 4 ruote sterzanti a bassa velocità, lo sterzo posteriore inizierà a chiudersi fin da zero gas.
invece diciamo che per 1/3 di gas vuoi tutta la corsa disponibile e poi dopo una certa velocità dovrà iniziare a chiudersi.

max_gain invece ti dovrà permettere di scegliere quanto chiudere.. se vuoi che sia tutto chiuso (macchina a tutto gas con solo le anteriori sterzanti) oppure se vuoi comunque mantenere parte dello sterzo.

tutto questo serve a ridurre lo sterzo ad alte velocità per evitare di cappottarsi o avere un controllo troppo nevrotico ma avere molto sterzo quando si va piano tra sassi e radici.

[kele-1]

mannaggia a me che sono ancora a pensare.

Ma sei sicuro che sfrutti sempre tutto lo sterzo impostato?
Perché mi sembrerebbe che che tu imposti i finecorsa, ma poi il segnale che invii avrà sempre un gain, che a bassa velocità è appunto legato direttamente a slowlimit, come infatti dici che sia.

NewPos = map(Rxpulse, Antsx, Antdx, Postsx, Postdx);
Questa condizione la metterei nel caso a bassa velocità...cioè quando sei sotto la soglia mappi il segnale fino ai finecorsa impostati senza nessun gain.

invece ad alta velocità metterei una mappatura che vale 0 non a neutral, ma a slowlimit.

if (Gaspulse > Slowlimit) {
Gain = map(Slowlimit, , Maxspeed, 0, Max_gain);
NewPos = map(Rxpulse, Antsx, Antdx, (Postsx + Gain), (Postdx - Gain));
}
else {
Gaspulse = constrain (Slowlimit, Neutral, Maxspeed); //<-----------------questa potrebbe diventare Gaspulse = slowlimit?
Gain = map(Gaspulse, , Maxspeed, 0, Max_gain);
NewPos = map(Rxpulse, Antsx, Antdx, Postsx, Postdx);
}

a questo punto credo che maxgain debba valere perforza 90-Postsx e ugualmente Postdx-90
se no a massima velocità avresti uno scavallamento dei valori rispetto al 90.

troppi valori da far settare all'utente stupido! appena il codice funziona bisogna dare solo un parametro e far calcolare a lui l'altro!

ok ora ho visto che le indentazioni non le legge quindi ti chiedo scusa per quando ti ho detto di indentare

[wrighizilla]

si hai ragione ma i parametri che ho messo mi sembra che servono tutti anche perchè il camion ha già uno sterzo davanti e una sua corsa determinata dalla effettiva possibilità meccanica di girare. non posso escludere ad esempio Antsx e Antdx perchè potrebbe essere che saranno ridotti rispetto a 1000-2000.
idem il gas e il centro neutro, anche se in linea di massima avrai circa 1000-1500-2000 possono essere diversi quindi è sano definirli controllando cosa arriva in entrata come segnale senza rischiare di scombinare i valori assegnati al regolatore di velocità.

ne consegue che questi settaggi li devi per forza leggere da serial monitor e metterli fisicamente scritti nello sketch altrimenti sarà settato in modo approssimativo

poi il resto sono i fine corsa del servo posteriore che anche questo dipende dalla meccanica, lunghezza della squadretta etc.. è un parametro fondamentale se non il più importante da immettere.

la vera parte utile sulla quale vedere il comportamento della controller è:

slowlimit che imposta quanto gas a bassa velocità puoi dare prima di iniziare a correggere la corsa

max_gain che indica quanto dovrà chiudere la corsa dello sterzo al massimo della velocità

e infine la centratura del servo per andare dritti a sterzo neutro.

in retro invece lo sterzo posteriore deve rimanere al massimo della corsa disponibile, inutile che chiuda di retro tanto non andrai mai a tutta birra in retromarcia e anche in quel caso si tratta di una manovra di disbrigo quindi lo sterzo è utile.

se riesci a semplificare ben venga.. così come lo vedi funziona tutto ma con il problema di cambiarmi gli endpoint quando tocco i 2 parametri fondamentali slowlimit e max_gain.

io ora ho fuso letteralmente.. domani mattina provo a rifare lo sketch con quello che hai scritto e ti dico cosa succede.

ti ringrazio per l'aiuto.

[kele-1]

sisi son curioso di saper cosa succede con quelle righe che ti ho detto...secondo me attiva l'autodistruzione!

Comunque non ti ho detto di non usare tutti quei valori nello sketch, anzi... ho solo portato l'esempio di alcuni valori che quando settati determinano irrimediabilmente il valore di altri. Per esempio se setti l'end point sx, quello destro per simmetria è determinato. Non sto dicendo di togliere quello destro, sto dicendo che quello destro può essere calcolato dal programma invece di impostarlo a mano per evitare errori umani. Così come il gain che bisogna essere sicuri che non faccia scavallare il valore di 90 da mandare al servo e potrebbe essere calcolato automaticamente.

Comunque non pensiamoci ora la mia era solo un'idea da aggiungere alla ToDo list.

A presto!

[wrighizilla]

non funziona, in entrambe le stringhe Gain = mi da errore manca dati , ,

nelle 2 virgole ho provato a mettere ,0, e funziona ma si perde la proporzionalità, arrivati allo slowlimit 1700 si chiude tutta la corsa e resta chiusa fino al massimo gas..

ok ci penso domani.

[kele-1]

ahahaha beeeeeeeeeeneeeeeee!!
Bon pensiamoci a mente lucida. Ho capito che a queste ore si fanno solo danni!

Ahhhh si c**** perché map vuole 5 valori.... Perché te ne ho mandati 4? boooooooo

[kele-1]

Mi sono perso il ragionamento...però da quello che ho scritto a bassa velocità non si dovrebbero usare i gain per sfruttare tutto lo sterzo. quindi

else {
NewPos = map(Rxpulse, Antsx, Antdx, Postsx, Postdx);
}

mentre ad alta velocità

if (Gaspulse > Slowlimit) {
Gain = map(Gaspulse, Slowlimit, Maxspeed, 0, Max_gain);
NewPos = map(Rxpulse, Antsx, Antdx, (Postsx + Gain), (Postdx - Gain));
}

Ovviamente l'if va scritto prima dell'else, ma in questa fase di ragionamento sconnesso mi servivano così!!
che macello che avevo fatto! e questo sarà anche peggio!
non dirmi niente fino a domani