next topic »

[on:]

Salve a tutti sono nuovo sia del forum sia del mondo di Arduino, comunque sono in grado di eseguire alcuni programmi basilari.

Ho un quesito da porvi... Vorrei costruire un robot radiocomandato ma non so come scrivere il programma per "interfacciare" Arduino alla ricevente (PPM).
Sono in possesso di Arduino UNO, microricevente e scheda motore della DFRobot (quella che da 2A x canale) questa   -->   http://www.dfrobot.com/index.php?route=product/product&path=51&product_id=69

Non sono a richiedervi l'intero codice, anche perchè sarebbe troppo semplice, ma semplicemente lo spunto per partire in particolare la parte di lettura del segnale.

Grazie
Ardus

[Reply #1 on:]

Scusami; spiegati meglio;
vuoi usare un telecomando e decodificare il segnale PPM per far pilotare Arduino i motori?
Ciao Uwe

[Reply #2 on:]

per leggere il PPM devi usare gli interrupt, in particolare quello di change. se guardi qualche discussione vecchia, ho postato il codice

[Reply #3 on:]

Grazie a entrambi per la risposta, comunque non voglio decodificare nessun tipo di segnale voglio soltanto collegare un telecomando.

Scusa ma mi puoi mandare il link della vecchia discussione dove hai postato il codice?

Grazie 

[Reply #4 on:]

Scusate.... ma ho trovato un codice scritto da lesto per  utilizzare gli interrupt

//se pin2 è stato modificato
  if (_changed&MASKPCINT0){
    //se pin2 ora è in stato alto
    if (_newbit&MASKPCINT0) {
   //INTERRUPT STATO ALTO SUL PIN 2
    }else{
   //INTERRUPT STATO BASSO SUL PIN 2
    }
  }

volevo sapere se all'interno di questo ciclo if/else devo inserire il codice che Arduino deve eseguire nel caso in cui si attivasse questo pin.

So che può sembrare una domanda banale ma non so dove battere la testa, ormai è una sfida e la devo vincere.

Grazie
Ardus

[Reply #5 on:]

Grazie a entrambi per la risposta, comunque non voglio decodificare nessun tipo di segnale voglio soltanto collegare un telecomando.

Allora non capisco l' utilitá del Tuo progetto.
Ciao Uwe

[Reply #6 on:]

Scusa, ma a quanto pare non riesco a spiegarmi,  io devo collegare un radiocomando RC su arduino x comandare dei motori a 6 Vdc. Vorrei una mano per poter leggere tali valori.

Grazie e scusa ancora se non riesco a spiegarmi bene ma ho appena iniziato a lavorare con Arduino

[Reply #7 on:]

Vediamo se ho capito io....
devi prendere il segnale PPM di una Rx e mandarlo ad arduino che a sua volta dovra decodificarlo e comandare per verso di ricazione e velocità dei motori tramite un adeguato pont H ...
Giusto ? 

[Reply #8 on:]

Se non ho capito male, devi fare la cosa più banale del mondo, cioè comandare il robot tramite un radiocomando.
In questo caso, ti passo questo codice che avevo scritto un po' di tempo fa, praticamente legge i valori dalla ricevente che ovviamente cambiano in base ai movimenti degli stick del radiocomando e poi li scrive in un display seriale.
Basta che ti tiri fuori le poche righe di codice che ti servono.
Ciao.

Code:

#include <Servo.h>
#include <SoftwareSerial.h>

#define  throttle  2
#define  gear      4
#define  elev      5
#define  rudder    6
#define  aile      7
#define  rxPin     8
#define  txPin     9

double  throttleVal = 0;                // Variabile motore sinistro
double  gearVal = 0;                // Variabile motore sinistro
double  elevVal = 0;                // Variabile motore sinistro
double  rudderVal = 0;                // Variabile motore sinistro
double  aileVal = 0;                // Variabile motore sinistro

// Servo left;
// Servo right;

SoftwareSerial SerialDisplay =  SoftwareSerial(rxPin, txPin);

void setup()
{
  pinMode(throttle, INPUT);
  pinMode(gear, INPUT);
  pinMode(elev, INPUT);
  pinMode(rudder, INPUT);
  pinMode(aile, INPUT);
  pinMode(rxPin, INPUT);
  pinMode(txPin, OUTPUT);
        
//  Serial.begin(9600);
   SerialDisplay.begin(9600);
//   SerialDisplay.print(char(21);
   SerialDisplay.print(char(14));
   SerialDisplay.print(char(12));
   SerialDisplay.print(char(12));
   SerialDisplay.print(char(20));
   SerialDisplay.print(char(255));
   SerialDisplay.print(char(19));
   SerialDisplay.print(char(64));
//  Serial.print("^N");
//  Serial.print("^T");
//  Serial.print(0xFF);
  
//  right.attach(9);
//  left.attach(10);
}

void loop()
{
  for (int i = 0;i < 6; i++)
  {
    throttleVal = throttleVal + pulseIn(throttle, HIGH);  // lettura ricevente canale motore sx
    gearVal = gearVal + pulseIn(gear, HIGH); //lettura ricevente motore dx
    elevVal = elevVal + pulseIn(elev, HIGH); //lettura ricevente motore dx
    rudderVal = rudderVal + pulseIn(rudder, HIGH); //lettura ricevente motore dx
    aileVal = aileVal + pulseIn(aile, HIGH); //lettura ricevente motore dx
    if (i == 5)
    {
      throttleVal = throttleVal / 5;
      gearVal = gearVal / 5;
      elevVal = elevVal / 5;
      rudderVal = rudderVal / 5;
      aileVal = aileVal / 5;
    //  Serial.print("Elev -> ");
//      Serial.print(elevVal);
//      Serial.print("  throttle -> ");
//      Serial.print(throttleVal);
//      Serial.print("  Gear -> ");
//      Serial.print(gearVal);
//      Serial.print("  Aile -> ");
//      Serial.print(aileVal);
//      Serial.print("  Rudder -> ");
//      Serial.println(rudderVal);


/*      SerialDisplay.print("Elev -> ");
      delay(2000);
      SerialDisplay.print(int(elevVal));
      SerialDisplay.print("  throttle -> ");
      SerialDisplay.print(int(throttleVal));
      SerialDisplay.print("  Gear -> ");
      SerialDisplay.print(int(gearVal));
      SerialDisplay.print("  Aile -> ");
      SerialDisplay.print(int(aileVal));
      SerialDisplay.print("  Rudder -> ");
      SerialDisplay.print(int(rudderVal));*/

      break; //faccio una media dei valori perchè sono leggermente oscillanti
    }
  }
      // Prima riga
      SerialDisplay.print(char(17));
      SerialDisplay.print(char(0));
      SerialDisplay.print(char(0));
      SerialDisplay.print("TH=");
      SerialDisplay.print(int(throttleVal));
      SerialDisplay.print(" EL=");
      SerialDisplay.print(int(elevVal));

      // Seconda riga
     SerialDisplay.print(char(17));
      SerialDisplay.print(char(1));
      SerialDisplay.print(char(0));
//      SerialDisplay.print(int(gearVal));
      SerialDisplay.print("AL=");
      SerialDisplay.print(int(aileVal));
      SerialDisplay.print(" RU=");
      SerialDisplay.print(int(rudderVal));

      SerialDisplay.print(char(17));
      SerialDisplay.print(char(0));
      SerialDisplay.print(char(15));
      
      if (gearVal > 2000)       SerialDisplay.print("G");
      else                SerialDisplay.print("g");

//      SerialDisplay.print(int(gearVal));

//  SerialDisplay.print("Ciao ");
//      delay(2000);
/*
  // *** comando servo sinistro
  // stick in avanti
  if (leftVal > 2200) left.write(180); // gira in senso orario

  //stick in indietro
  if (leftVal < 1800) left.write(0); // gira in senso antiorario

  // stick al centro
  if (leftVal > 1800 && leftVal < 2500) left.write(90); //stai fermo

  // *** comando servo destro
  //stick avanti
  if (rightVal > 2200) right.write(0); // gira in senso orario

  //stick indietro
  if (rightVal < 1800) right.write(180); // gira in senso antiorario

  //stick al centro
  if (rightVal > 1800 && rightVal < 2500) right.write(90); //fermo
*/
}

[Reply #9 on:]

anche il codice di stefanoxjx è corretto, e molto più semplice da leggere. Ovvio ha certi svantaggi, ma se il loop è abbastanza veloce non dovresti avere problemi. noterai che il PPM è un'oda quadra, dove la durata del segnale alto rappresenta il valore inviato.
il codice che uso io non è altro che una pulseIn che lavora completamente ad interrupt, non bloccando il tuo codice nel caso la ricevente sia staccata, il tuo loop si blocchi a fare altro... sta a ste scegliere la semplicità o la complessità in base al tuo progetto.

[Reply #10 on:]

Grazie mille ragazzi avete colpito in pieno il nocciolo della questione.... Mi avete risolto un problema che per me era enorme!!!

[Reply #11 on:]

visto che non sono un esperto di elettronica, chiedo gentilmente una delucidazione su questo tutorial riguardante proprio la decodifica di una scheda ricevente RC:

http://letsmakerobots.com/node/26905

guardando nel programma viene utilizzata l'istruzione "digitalread", esempio: si manda un segnale con il telecomando (es. leva in posizione FORWARD) e si legge sulla scheda Arduino il corrispondente piedino della scheda ricevente in stato HIGH.

i segnali della scheda ricevente vengono letti da Arduino in maniera digitale o sbaglio? 

nel programma di Stefano invece viene utilizzata invece l'istruzione "pulsein" e si fa una media dei valori PWM.

Mi potete chiarire quando bisogna utilizzare "pulsein" e quando "digitalread" per decodificare i segnali sulla scheda ricevente?

[Reply #12 on:]

lui usa una digital read perchè la stopria del pulseIn la fa attraverso la scheda collegata. La storia della media la puoi evitare, però sarebbe utile per ammortizzare eventuali interferenze