Miscelare segnali PPM con arduino
 

Ciao a tutti, volevo chiedere se qualcuno ha provato a miscelare dei segnali PPM di una ricevente realizzando tipo un mix di quelli che si usano su modelli di aerei e se la cosa è di facile realizzazione.

Grazie.

!!!
 

non è facile facile, devi conoscere bene il datasheet del ATMEGA328 o insomma del Micro.. per esempio il pin 8 è dotato di un modulo capture che ti consente di catturare con estrema precisione il fronte di salita del segnale PPM della ricevente.. successivamente puoi variare il segnale come vuoi.

Infatti non è proprio semplice, anche perchè utilizzo arduino da poco.

Non è affatto difficile, ci sono le librerie già fatte per leggere uno o piu segnali ppm. Poi li puoi modificare come ti piace sommandoli anche tra di loro e li ributti fuori su uno o piu canali.
Immagino che vuoi fare un mixer che non hai in radio. Io sto progettando un governor con controllo temperatura e carburazione per un elicottero a benzina.

Ciao

arduino Leonardo & Micro
 

allora ho avuto il tempo di studiare.. e fare le prove in effetti la funzione pulseIn risolve molto bene il discorso, una precisione paragonabile a quella che si ottiene lavorando con i registri del Timer del capture e del modulo compare.. circa 8 microsecondi rileva da un estremo 873 uS dall'altro estremo 2073 uS così come usando direttamente i registri... . Di seguito giusto una demo per leggere il segnale di una ricevente e inviarla alla seriale. C'è da dire che conviene usare una scheda LEONARDO o arduino Micro perchè hanno piu porte digitali a disposizione e piu pin per interrupt esterni... da attenzionare però il Serial.println.... che in effetti risulta rallentare il PC... per ovviare questo problema mi sono accorto che mi è sufficiente usare una semplice applicaziione scritta in java.... insomma basta evitare il serial monitor.. adesso tutto OK , poi per creare il PPM per muovere i servo.. si può usare delayMicroseonds ......in questo modo non utilizzando il timer1 che invece viene usato dalla funzione puklseInt... i valori conviene prenderli con la specifica long volatile.

const int inputpin = 2;

long val;

void setup()
{
pinMode(inputpin, INPUT);
Serial.begin(9600);
val = pulseIn(inputpin,HIGH,25000);
}
//_________________________________________
void loop()
{
Serial.println(val);
val = pulseIn(inputpin,HIGH,25000);
}


Spero di essere stato utile ai lettori.. a presto fausto

Fausto per miscelare due segnali devi leggerne due...
Farlo in un loop usando pulseIn di fatto dimezza la frequenza di pilotaggio considerato anche il fatto che poi deve anche essere generato il segnale miscelato.
Pertanto l'unico modo è usare gli interrupt per leggere le variazioni dei due ingressi...
O utilizzando gli external interrupt (pin 2 e 3) oppure usando i pin change interrupts.

ok concordo su ciò che hai scritto... io sto adoperando Arduino Micro, che dispone di ben 5 pin x interrupt, ho appena finito di testare questa piccola funzione... OK tutto regolare... però adesso ho un problema, ovvero se volessi costruirmi un drone, che legge i PPM dalla ricevente e contemporaneamente legge i dati dei sensori ( gyro, accelerometri) dalla porta I2C ...c'è il problema che due dei pin coincidono ovvero il 3 e il 2... per cui ..dovrò optare di leggere i 4 PPM provenienti dalla radio in unico bus... in un unico pin... (volevo evitarlo) grazie alle tante porte interrupt messe a disposizione di Arduini Micro... e invece.. purtroppo devo fare il circuito aggiuntivo che mi convoglia i 4 PPM in un unico BUS.. pazienza! a meno che non vado ad utilizzare sensori analogici.. solo che tali vanno a rallentare di parecchio il software.. quindi non vale la pena!

/*
PER ARDUINO MICRO


questo software cattura i segnali provenienti da una ricevente per aeromodelli


ch1 ch2 ch3 ch4
| | | |
| |GND | |
___|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|____
| pin 3,2 pin 0,1 |
USB | |
| ARDUINO MICRO |
|_____________________________________|
| | | | | | | | | | | | | | | | |

la stampa sulla seriale avviene con un grosso ritardo dovuto alla bufferizzazione dei dati, occorre prelevare con i dati da un'applicazione
diversa da serial monitor, perche essa blocca il PC.
*/


const int ch1 = 3; // interrupt 0
const int ch2 = 2; // interrupt 1
const int ch3 = 0; // interrupt 2
const int ch4 = 1; // interrupt 3
volatile unsigned long microseconds_1;
volatile unsigned long microseconds_2;
volatile unsigned long microseconds_3;
volatile unsigned long microseconds_4;
volatile byte index =0;
volatile unsigned long ch1_val;
volatile unsigned long ch2_val;
volatile unsigned long ch3_val;
volatile unsigned long ch4_val;
// External Interrupts: ch1 - pin 3 (interrupt 0)// ch2 - pin 2 (interrupt 1)// ch3 - pin 0 (interrupt 2) // ch4 - pin 1 (interrupt 3) // and 7 (interrupt 4).
void setup()
{
pinMode(ch1, INPUT);
pinMode(ch2, INPUT);
pinMode(ch3, INPUT);
pinMode(ch4, INPUT);

Serial.begin(9600);

attachInterrupt(0, CH1_val, CHANGE); // questo sul pin3
attachInterrupt(1, CH2_val, CHANGE); // questo sul pin2
attachInterrupt(2, CH3_val, CHANGE); // questo sul pin0
attachInterrupt(3, CH4_val, CHANGE); // questo sul pin1
}
//__________________________________________________ ______________
void loop()
{
Serial.println(ch1_val);
Serial.println(ch2_val);
Serial.println(ch3_val);
Serial.println(ch4_val);
Serial.println(".......");
delay(1);
}
//__________________________________________________ _______
void CH1_val()
{
if(digitalRead(ch1) == HIGH)
microseconds_1 = micros();
else
ch1_val = micros() - microseconds_1;
}
//__________________________________________________ _______
void CH2_val()
{
if(digitalRead(ch2) == HIGH)
microseconds_2 = micros();
else
ch2_val = micros() - microseconds_2;
}

//__________________________________________________ _______
void CH3_val()
{
if(digitalRead(ch3) == HIGH)
microseconds_3 = micros();
else
ch3_val = micros() - microseconds_3;
}
//__________________________________________________ _______
void CH4_val()
{
if(digitalRead(ch4) == HIGH)
microseconds_4 = micros();
else
ch4_val = micros() - microseconds_4;
}


a dopo
fasuto

ok
 

COMUQUE per le miscelazioni questo software va bene.. si può aggiungere anche un quinto canale.. attraverso il PIN6 della scheda Arduino Micro, oppure Arduino LEONARDO... credo sia preferibile la Micro viste le ridotte dimensioni. potrebbe essere inserita in uno spazio veramente angusto... e quindi stare ben nascosta.

a dopo
fausto

ciao Romoloman


dunque ho fatto dei nuovi test proprio per lasciare liberi i pin 2 e 3 di Arduino Micro... utilizzando pulseIn con dei pin diversi esattamente 4,5,6,7 ..ottengo prestazioni paragonabili a quelle che si ottengono utilizzando gli interrupt.. evidentemente le librerie sono fatte bene... fatto sta che adesso non mi ritrovo nemmeno il rallentamento dei dati della seriale.. forse perchè non usando i pin 0 e 1 che sono della seriale.. probabilmente non entrano in conflitto lo stesso vale per i due pin I2C pin 3,2... quindi credo che continuo su questa linea.. piuttosto che andare a smanettare su tutti i registri e i bit dei registri ... sfrutto le librerie.. tali risultano veloci ed snelle..

const int pin1 = 4;
const int pin2 = 5;
const int pin3 = 6;
const int pin4 = 7;

volatile byte index =0;
volatile unsigned long results_1;
volatile unsigned long results_2;
volatile unsigned long results_3;
volatile unsigned long results_4;

void setup()
{
pinMode(pin1, INPUT);
pinMode(pin2, INPUT);
pinMode(pin3, INPUT);
pinMode(pin4, INPUT);

Serial.begin(9600);

}

void loop()
{
results_1 = pulseIn(pin1,HIGH,25000);
results_2 = pulseIn(pin2,HIGH,25000);
results_3 = pulseIn(pin3,HIGH,25000);
results_4 = pulseIn(pin4,HIGH,25000);

Serial.println(results_1);
Serial.println(results_2);
Serial.println(results_3);
Serial.println(results_4);
Serial.println("__________________________________ ______");
}

a dopo

Guarda che il problema sta proprio in queste 4 righe...
supponi l'ordine in cui cambiano i pin sia 4 3 2 1 o che cambino tutti assieme (caso comune in molte nuove riceventi)
il primo pulseIn aspetta fino a 25000us per pin1
ma quando arriva a leggere un segnale valido passa al secondo pulseIn che dovrà aspettare tutto il frame ppm lo stesso per il terzo e il 8 in totale si arriva a 4 frame = 88ms

Per fare una prova: memorizza millis() prima del primo pulseIn e sottrailo dal valore dopo l'ultimo, stampa i risultati e poi prova a cambiare l'ordine degli ingressi...