un help su un sistema di retrazione carrelli

Un saluto a tutti,
come prima cosa sono un principiante e mi appassionano molti aspetti della tecnologia tra i quali Arduino che è veramente intrigante.
Avevo fatto pratica nel 2009 poi preso da altre passioni mi sono molto arrugginito e adesso cerco di rinfrescare quel poco che so.

Ho un progettino in testa da utilizzare su una delle mie creature (un aereomodello di una decina di Kg)
Questo aereoplano ha 3 carrelli retrattili con la retrazione comandata da un servo digitale da 9 kg ciascuno.

L’obiettivo è: la retrazione deve avvenire con una sequenza differenziata quindi in tempi diversi e velocità dei servi diverse. Come accade su quelli veri.

Dato che c’è molta carne sul fuoco vi espongo le esigenze poi se avrete la pazienza di sopportare la mia incompetenza mi aiuterete a risolvere i problemi uno alla volta, così potrò imparare.

Il radiocomando invia il comando di retrazione e estensione carrelli attraverso un impulso che in origine comanda un servo. Genera un onda quadra (non so se è corretto) come da foto sull’oscilloscopio, credo sia PWM.

1° esigenza – bisogna creare un sistema che attiva arduino ad eseguire la sequenza di retrazione attraverso questo comando.

2° esigenza – il sistema deve avere un sistema di trimmaggio fine sui punti di partenza e arrivo del servo, indipendenti per ogni servo. I movimenti di retrazione ed estrazione devono arrestarsi in un punto preciso per questioni meccaniche. Infatti i carrelli aereonautici per sopportare le sollecitazioni in atterraggio hanno una configurazione detta a “ginocchio”. Questo fa si che gli sforzi gravano meccanicamente sulla struttura e non sul servo. Questo accade solo se si pongono i cinematismi in una posizione precisa.

A complicare il tutto arriva la 3° esigenza: il tutto deve funzionare con un alto livello di affidabilità, dato che un malfunzionamento del carrello determinerebbe in atterraggio dei grossi danni al modello. (arrivare a 1000 euro si sta un momento).

Una prima bozza di sketch è quello allegato. Sembra funzionare per quanto riguarda il trim e i movimenti del servo , ma non riesco a capire come creare l’impulso di avvio. Infatti le letture del analogRead (inpulse) variano da 12 a 15 poi ciclicamente sparano a 500/700.
Se al pin relativo ci metto un potenziometro funziona perfettamente. Quindi il principio è corretto solo che il segnale non viene letto correttamente.
La lettura con il multimetro mi da (mettendo i puntali tra la massa e il segnale l’altro filo è il positivo che alimenta il servo non lo considero), con il radiocomando in posizione retratto 0.14 V, in posizione estesa 0.31 V. quindi avevo pensato di leggere la tensione e con un if creare l’interruttore.
Analizzato con l’ascilloscopio lo stesso segnale mi da un onda (come allegato) con una lettura costante max di 3.2 v
Però non mi da nessuna frequenza, in teoria dovrebbe essere una tensione continua.
Non capisco, ovviamente per la mia ignoranza, come si comporta un segnale di questo tipo che penso sia in PWM. Ho molti dubbi infatti ci dovrebbe essere una frequenza se fosse PWM?

Ricapitolando per adesso vorrei che qualche esperto mi spiegasse come leggere questo segnale.
E’il primo degli ostacoli che non riesco a risolvere, qualche consiglio?

Grazie in anticipo.

#include <Servo.h> 


Servo myservo;              // create servo object to control a servo 
 
int trim = 0;             // analog pin used to connect the potentiometer
int impulse = 5;         // analog pin used to connect rx impulse
int val = 0;            // variable to read the value from the analog pin 0
int val2 =0;           //  variable to read the value from the analog pin 5

unsigned long time;             //begin cont time
unsigned long M;               //trimmer monitor frequency
unsigned long A;              // trimmer delay servo

 
void setup() 
{ 
  time=millis();
  
  M=millis();
  A=millis();
  
  myservo.attach(9);             // attaches the servo on pin 9 to the servo object 
  Serial.begin (9600);
} 
 
void loop() { 
    time=millis();           // begin cont time

    monitor();         // box print monitor 
  
    val2 = analogRead(impulse);         // read input value and store it
    if (val2 > 20) {                   // check the input is > 20 mV.
 
  
  
  val = analogRead(trim);                 // reads the value of the potentiometer trimmer
  val = map(val, 0, 1023, 0, 179);       // scale it to use it with the servo (value between 0 and 180) 
  myservo.write(val);                   // sets the servo position according to the scaled value 
  delay(15);     }                          
  
   else {
  myservo.write(val+150);              // servo position + run required (100)
   delay(15);   }
   
}

tuc2.jpg

IMG_0374.jpg

IMG_0373.jpg

Una prima bozza di sketch è quello allegato. Sembra funzionare per quanto riguarda il trim e i movimenti del servo , ma non riesco a capire come creare l’impulso di avvio. Infatti le letture del analogRead (inpulse) variano da 12 a 15 poi ciclicamente sparano a 500/700.
Se al pin relativo ci metto un potenziometro funziona perfettamente. Quindi il principio è corretto solo che il segnale non viene letto correttamente.

Fai un errore di concetto.
I servo vengono pilotati non con un segnale corrente continua ma da un segnale digitale PPM dove ogni 20 millisecondi viene dato un impulso di durata variabile tra 1 e 2 millisecondi. Devi leggere la durata del impulso e a secondo della sua lunghezza far partire la sequenza di usita o retraggio carello.
Puoi farlo con la funzione pulseIn() http://arduino.cc/en/Reference/PulseIn

Ciao Uwe

Come ti ha già sottolineato Uwe i servo sono controllati con un segnale PPM, cioè un impulso positivo compreso tra 1000 us e 2000us, valori standard, ripetuto 50 volte al secondo.
In pratica a seconda del modello e produttore della radio, e dei servi, ci sono delle leggere differenze tra i valori standard e quelli realmente utilizzati, però quasi tutti ormai adottano come valore minimo 1100us e come massimo 1900us con 400us per una escursione di 45° del servo, alcune radio hanno il punto neutrale a 1500us altre a 1520us, e di conseguenza sono spostati di 20us i punti minimo e massimo.
Per la tua applicazione ha poca importanza l'esatto range del segnale che arriva dalla ricevente, quando azioni lo switch del carrello avrai due valori che cambiano tra il minimo e il massimo possibile di conseguenza con Arduino non devi fare altro che considerare un impulso minore di 1200 us per la chiusura dei carrelli e uno maggiore di 1800 us per l'apertura.
Per comandare singolarmente i tre servo del carrello non devi fare altro che usare l'apposito oggetto servo di Arduino e applicarlo a tre pin distinti che comanderanno i servo, grazie a questo oggetto puoi controllare l'escursione minima e massima del servo e il tempo di movimento cambiando l'angolo ciclicamente tramite una base dei tempi.
Lo so che detto a parole sembra complicato, in realtà è molto semplice da implementare e bastano poche righe di codice, adesso non ho tempo per farlo, più tardi ti posto lo sketch di base che fa tutto quello che ti serve su cui dovrai solo sistemare i limiti del movimento e la durata delle corse.

siete stati veramente gentili entrambi a rispondermi.
adesso mi metto a studiare le vostre preziose info e se avrò dei dubbi mi faccio sentire.
grazie ancora

Siamo qua per risponderti.
Ciao Uwe

Ciao Paverik,
la sequenza che ti serve la vuoi fare per forza con arduino? Sennò ci sono sequencer (gear door sequencer) tipo quello della Jetronic che vanno bene, io ne ho provato uno.

MatteoG sono a conoscenza dei sistemi di cui parli.
A dir la verità il sistema più economico e semplice sarebbe utilizzare un programmatore servi. Programmare la velocità di ogni servo in modo differente e utilizzare l'impulso comune della radio. Chiarisco che i carrelli hanno il comando elettrico.
Ma dato che giocare con arduino mi da soddisfazione, mi appassiona ancor di più se ho un obiettivo di pratica realizzazione così ho pensato di utilizzarlo per questo.
Se poi non ci dovessi riuscire dirotto verso sistemi commerciali o altro.
Nel 2009 quando ho conosciuto arduino con vari sforzi e aiuti,vista la mia preparazione in materia, sono riuscito a realizzare un sensore di parcheggio (l'elementare proggettino si chiamava PARK SENSOR) per un fuoristrada che avevo.
Questa macchina l'ho venduta ma arduino è ancora sopra che pivetta quando ingrani la retro.
Oggi siamo abituati ad ogni sorta di gadget elettronico e si da tutto per scontato ma quando riesci a crearlo tu la soddisfazione è grande. Anche se in fondo è un pu-----ta pazzesca.
Per uno come me, che negli anni 60 guardavo Rintintin in bianco e nero e le trasmissioni tv cominciavano alle 17 su un solo canale, pensare di programmare un termometro , un sensore, o muovere un servo mi diverte un sacco.
I giocattoli servono per giocare.

grazie comunque della dritta.

riccardo

ehehehe XD si capisco anche per me è così infatti sono qua a provare cose che non avrei mai pensato di poter fare prima di arduino, che ho conosciuto a febbraio....

Ciao, Matteo

PS
bello il tucano. E' un tuo modello?

L'hai riconosciuto, si è un Embraer 314 Super Tucano (il turbina), una bella bestiolina, 2.5 m di apertura alare.
Oggi ho studiato le vostre indicazioni e sono riuscito a creare il codice funziona perfettamente.
Grazie ancora per le preziose dritte, da solo ci avrei messo anni.. Adesso lo sistemo per benino lo testo e dopo lo pubblico, così potrete darmi ancora ulteriori consigli per migliorare.
Matteo ti allego il disegno cad del carrello che ho progettato e realizzato in ergal 7000, la foto di quelli dal vero se ti interessa te la mando.

un saluto.

riccardo

disegno cad

Turbina turboelica? WOW 2,5 mt è intrigante :wink:
peso?
Il carrello è molto bello, hai usato Solidworks per caso?
Si si manda tutto quello che puoi, anche i file solidworks che mi appassiona…

grazie, si ho usato SW.
il modello è monomotore classico 50cc, il turboelica è quello vero.
Ho dei compagni di gioco che l'hanno comprato il motore turboelica in scala (stupendo), per quanto mi riguarda far volare 10000 euro di roba sarebbe un patema insopportabile, oltre al fatto che non sono così ricco da permettermelo.
appena posso ti mando qualcosa.
ciao e scusate le divagazioni dall'argomento.

alla passione non si comanda.

riccardo.

Finalmente ho trovato un pò di tempo per andare avanti con il programma.
allego il tutto in modo che possiate dargli una occhiata e consigliarmi eventuali migliorie.

lo sto testando su un solo servo per affinarlo. il principio di funzionamento è molto semplice: ho previsto 2 resistenze variabili che si registrano con un cacciavite serviranno per settare la posizione finale del carrello sia in ritrazione che in estensione.(funzione di trimmaggio)
Ho notato una cosa, random il servo ha un piccolo sussulto, infatti il valore del trim varia per una frazione di secondo.
Non so spiegarmi il perchè spero che sia dovuto alla provvisorietà dei collegamenti sulla basetta. Altrimenti questo sarebbe un bel problema.

il secondo step sarà quello di creare delle velocità di retrazione differenziate per i due servi cioè 2 alari e quello anteriore. (i consigli sono molto bene accetti).

progammare arduino è veramente divertente, ma non così semplice come viene detto, almeno per un vecchietto come me.

un salutone e grazie in anticipo.

allego programma principale e successivo stadio finito “monitor”

// Aereonautic gear retraction sistem by riccardo pavonello

#include <Servo.h> 


Servo myservo;                // create servo object to control a servo 
#define pin 9                // input pin 9 servo pin
#define trim 0              // analog pin 0 used to connect the potentiometer 0
#define trim2 2            // analog pin 2 used to connect the potentiometer 2
#define inpulse 5         // analog pin 5 used to connect rx impulse
int val = 0;             // variable to read the value from the analog pin 0
int val2 = 0;           //  variable to read the value from the analog pin 2


unsigned long time;             // begin cont time
unsigned long M;               // trimmer monitor frequency refresh
unsigned long A;              // time of impulse radio

 
void setup() 
{ 
  time=millis();
  A=millis();
  M=millis();

  pinMode (pin,INPUT);  
  myservo.attach(9);             // attaches the servo on pin 9 to the servo object 
  Serial.begin (9600);
} 
 
void loop() { 
  
    time=millis();           // begin cont time

    monitor();              // box prog print (stadio finito "monitor")
    
    
   A = pulseIn (inpulse, HIGH);            // read input value and store it      
   if ( A >1000) {                  // check the input is > 1000.
 
  
  
  val = analogRead(trim);                 // reads the value of the potentiometer trimmer
  val = map(val, 0, 1023, 0, 179);       // scale it to use it with the servo (value between 0 and 180) 
  myservo.write(val);                   // sets the servo position according to the scaled value 
  delay(15); }                              
  
  else {
  val2 = analogRead (trim2);               // reads the value of the potentiometer trimmer 2 (terminal servo course)
  myservo.write(val+50+val2);            // servo position + run required (100)
  delay(15);   }
   
}

STADIO FINITO ***********************************************************************************************************************************

void monitor() {
  
    if(time>M+1000){
    Serial.print ("lettura impulso radio                      ");
    Serial.println(A);                        
    Serial.print("lettura valore trim      ");
    Serial.println(val);
    Serial.print("lettura valore trim2               ");
    Serial.println(val2);
    M=millis();
    }
    }

Ho notato una cosa, random il servo ha un piccolo sussulto, infatti il valore del trim varia per una frazione di secondo.

Che valore di potenziometro hai messo?
Se é troppo alta hai difficoltá di leggere il valore giusto. per la conversione il ATmeha carica un piccolo condensatore interno col valor che sta sul pin analogico e lo converte in un vaolre digitale. Se la resistenza della fonte della tensione analogica, nel Tuo caso il trimmer, non ce la fa a caricare il condensatore alla tensione del pin ma resta sotto. Le soluzioni sono 2 dove é preferibile la prima:

  • Usa un potenziometro da 4,7kOhm,
  • in alternativa leggi 5 volte il pin analogico e scarta le prime 4 misure.
    Ciao Uwe

ecco perchè,
quindi non ce la fa a caricare il condensatore dentro la scheda arduino se la resistenza è troppo grande.
non ci crederai ma empiricamente avevo notato che aveva risposte di più stabili a differenti valori, ma non sapevo il motivo.
Ne ho imparata un altra, grazie ancora del consiglio.
tra una decina di anni forse arrivo alla tua preparazione.
scherzi a parte,

arrivo a casa e vedo che cosa ho combinato e faccio le variazioni.

ciao grazie

il condensatore non é sulla schedina, ma dentro nel ATmega328.
Ciao Uwe