next topic »

[Reply #705 on:]

io intendo fare la IMU completa per il quad, e poi quando esce il raspberry PI (in teoria a fine mese, ma vallo a sapere, se poi non becco il primo batch..) comandare la IMU dal raspberry, che essendo un 700MHz e 256MB of RAM dovrebbe gestire GPS, wifi per dati di debug, stream video(encoder/decoder h264 incluso nella GPU), e controllo dei way point.

Invece vorrei mantenere la RX sull'arduino, così anche nel caso di fail della PI (molto probabile visto come la voglio rimpinzare) il quad resta in volo

[Reply #706 on:]

Urca, bello!

Pero' io non voglio fare il quadri, io voglio solo fare solo il calcolo della distanza fra 2 punti col gps. Sto aspettando astrobeed che aveva postato.

[Reply #707 on:]

Urca, bello!

Pero' io non voglio fare il quadri, io voglio solo fare solo il calcolo della distanza fra 2 punti col gps. Sto aspettando astrobeed che aveva postato.

Ciao a tutti.
Posto la mia  ;D

In caso vogliate calcolare la lunghezza della curva lossodromica oppure calcolare la posizione di un punto o una rotta ecc il modo migliore (ma non più conveniente in termini di distanza) è utilizzare i problemi della lossodromia.

In caso siate a una latitudine inferiore ai 60° e la distanza è inferiore alle 350NM i calcoli più comodi sono questi:

in questi casi

• fi = latitudine
• lambda = longitudine
• TC = prua rispetto al nord vero
• D = distanza in NM
• a = punto di partenza
• b = punto di arrivo

questo primo calcolo è avendo la rotta ed avendo la distanza trovo le coordinate del secondo punto.


secondo problema:

dati coordinate del primo e del secondo punto trovo distanza e prua

ATTENZIONE
in questo caso bisogna vedere in che direzione ci si sta spostando infatti la TC calcolata così non è quella effettiva.
la TC effettiva viene chiamata TCq e per calcolarla bisogna vedere in che direzione stiamo andando:
rispetto al nord con positività in senso orario
tra gli 0° e i 90° TCq = TC
tra 90° e 180° TCq = 180-TC
tra 180° e 270° TCq = 180+TC
tra 270° e 360° TCq = 360-TC

Ah quasi dimenticavo: gli angoli sarebbe meglio convertirli tutti in primi di grado in quanto poi il calcolo della D altrimente può venire errato

Spero possa tornarvi utile.

Questa è la tratta più "comoda" in quanto mantiene prua costante ma non è la più veloce... tuttavia semplifica non poco i calcoli 

Buon divertimento!

Scusate il crossoposting ma l'ho fatto per metterlo di la ora lo metto anche qua 

http://www.electroit.tk/index.php/topic,38.0.html

adoro autobumparmi 

[Reply #708 on:]

Ma le formule da dove escono ?

[Reply #709 on:]

adoro autobumparmi 

E' inutile che lo fai, quelle formule non servono a nulla per la questione quadricottero, non hai ancora capito che occorre fare conti su distanze relativamente brevi ed è necessario una precisione almeno al singolo metro nei calcoli ?
Ho già postato il sorgente completo per la gestione del GPS, incluso il calcolo della distanza tra due punti, e ho già verificato in pratica che funziona benissimo, quindi la questione è chiusa.
Semmai adesso c'è da prendere una decisione definitiva su quale hardware a 32 bit utilizzare visto che la DUE è una chimera, sono passati quasi 4 mesi dal suo annuncio e non solo non c'è ancora la scheda, nemmeno la versione prototipo, ma si vede nemmeno l'ambiente di sviluppo che almeno permetterebbe di iniziare a valutare le possibilità.
Per quanto mi riguarda credo proprio che continuo sulla strada che ho già intrapreso, cioè usare l'mBed che oltretutto è vantaggioso in termini di dimensioni, peso e ricchezza di periferiche.

p.s.
Non mi chiedete le tabelle del datum perché sono coperte da copyright e non posso pubblicarle liberamente, posso solo accluderle al software sotto forma di file oggetto, però le trovate facilmente se sapete usare google.

[Reply #710 on:]

ciao,
stamattina astrobeed è un pò acido   

[Reply #711 on:]

adoro autobumparmi 

Io non so da che parte arrivino quelle formule, le ho stampate e messa da parte e ti rignrazio, pero' prima di buttarmi a scrivere vagonate di codice dovrei farmi un attimo di teoria, vedere di ricavarmele io, fare il punto circa la loro reale applicazione numerica, vedere se tutto mi torna, e poi al limite finire quanto mi sono promesso di fare.

Non ho alcun limite di tempo, non devo nemmeno metterlo su un quadri, e' un puro hobby in cui mi interessa proprio la questione matematica che c'e' sotto =P

p.s. ma da dove arrivano e chi le ha scritte ? Vedo dei commenti tipo se fosse un quote di qualcuno.

[Reply #712 on:]

adoro autobumparmi 

Io non so da che parte arrivino quelle formule, le ho stampate e messa da parte e ti rignrazio, pero' prima di buttarmi a scrivere vagonate di codice dovrei farmi un attimo di teoria, vedere di ricavarmele io, fare il punto circa la loro reale applicazione numerica, vedere se tutto mi torna, e poi al limite finire quanto mi sono promesso di fare.

Non ho alcun limite di tempo, non devo nemmeno metterlo su un quadri, e' un puro hobby in cui mi interessa proprio la questione matematica che c'e' sotto =P

p.s. ma da dove arrivano e chi le ha scritte ? Vedo dei commenti tipo se fosse un quote di qualcuno.

le avevo postate su un'altro forum di elettronica e le ho rimesse lì.

ciò che è stato postato è il primo ed il secondo problema della lossodromia.

le trovi in qualsiasi libro di testo di navigazione marittima o
(come nel mio caso) aerea. che li ha scritte sinceramente non lo so  ma vengono usate per navigazioni relativamente brevi (se stai nei 300km di distanza) e a basse latitudini (entro i 60°)

[Reply #713 on:]

su ragazzi, rianimiamo questo tread 

[Reply #714 on:]

io ho bisogno di essere rianimato, da quando ho postato la gioda non ho più scritto una linea di codice... son troppo stanco, spero di combinare qualcosa nel week-end!

[Reply #715 on:]

Io per aggiornarvi sto facendo un po' di voli al parco e ho iniziato a provare pid a casa mentre attendo il mio ricevitore BT per provare pid al parco. Si direbbe dai primi test che nel mio caso la P<4 sia la cosa migliore, altro che valori come 15... Domani far un giro al radiant per scoprire se trovo qualcosa che mi incuriosisce.
F

[Reply #716 on:]

lentamente vado avanti a programmare, oggi con la piacevole sorpresa di scoprire che l'IDE 1.0 implementa l'operatore NEW.

giusto in caso vogliate testare i vostri sensori, vi passo il codice. sarebbe carino sapere se vi funzionano o sono da cambiare gli indirizzi nelle vostre IMU.

ADXL345

Code:

#include <Wire.h>

#define address 0x53

void setup(){
  //Initialize Serial and I2C communications
  Serial.begin(9600);
  delay(1000);
  Wire.begin();
  Serial.print("START ");
  
  //IMPORTANT!!!!
  //THIS WILL WAKE UP ADXL!!!!
  Wire.beginTransmission(address);
  Wire.send(0x2D);  
  Wire.send(0x08);
  Wire.endTransmission();
  
/
}

void loop(){
  
  int x,y,z; //triple axis data
  Serial.print("START READING 1");
  
  Wire.beginTransmission(0x53);
  Wire.send(0x32);
  Wire.endTransmission();
  
 Serial.print("START READING 2");
 //Read data from each axis, 2 registers per axis
  Wire.requestFrom(0x53, 6);
  Serial.print("available: ");
  Serial.println(Wire.available(), DEC);
  while(Wire.available()<6){
    Serial.print("available: ");
    Serial.println(Wire.available(), DEC);
    delay(250);
  }
  if(6<=Wire.available()){
    x = Wire.receive()<<8; //X msb
    x |= Wire.receive(); //X lsb
    z = Wire.receive()<<8; //Z msb
    z |= Wire.receive(); //Z lsb
    y = Wire.receive()<<8; //Y msb
    y |= Wire.receive(); //Y lsb
  }
  
  //Print out values of each axis
  Serial.print("x: ");
  Serial.print(x);
  Serial.print("  y: ");
  Serial.print(y);
  Serial.print("  z: ");
  Serial.println(z);
  
  delay(250);
}

ITG3200 (very raro, difficile da trovare codice così "basico" da leggere per questo sensore, usano tutti classi wire esterne e incasinate)

Code:

#include <Wire.h> //I2C Arduino Library

#define address 0x68

void setup(){
  //Initialize Serial and I2C communications
  Serial.begin(9600);
  delay(1000);
  Wire.begin();
  Serial.print("START ");
  
  Wire.beginTransmission(address);
  Wire.write(0x3E);
  Wire.write(0x80);  //send a reset to the device
  Wire.endTransmission(); //end transmission
  
  Wire.beginTransmission(address);
  Wire.write( 0x15 );
  Wire.write( byte(0x00) );   //sample rate divider to 0
  Wire.endTransmission(); //end transmission

  Wire.beginTransmission(address);
  Wire.write(0x16);
  Wire.write(0x18); // ±2000 degrees/s 8kHz sample rate(default value)
  Wire.endTransmission(); //end transmission

}

void loop(){
  
  int x,y,z; //triple axis data
  Serial.print("START READING 1");
  //Tell the HMC5883 where to begin reading data
  Wire.beginTransmission(address);
  Wire.write(0x1D); //select register 3, X MSB register
  Wire.endTransmission();
  
 Serial.print("START READING 2");
 //Read data from each axis, 2 registers per axis
  Wire.requestFrom(address, 6);
  while(Wire.available()<6){
    Serial.print("available: ");
    Serial.println(Wire.available(), DEC);
  }
  if(6<=Wire.available()){
    x = Wire.read()<<8; //X msb
    x |= Wire.read(); //X lsb
    z = Wire.read()<<8; //Z msb
    z |= Wire.read(); //Z lsb
    y = Wire.read()<<8; //Y msb
    y |= Wire.read(); //Y lsb
  }
  
  //Print out values of each axis
  Serial.print("x: ");
  Serial.print(x);
  Serial.print("  y: ");
  Serial.print(y);
  Serial.print("  z: ");
  Serial.println(z);
  
  delay(250);
}

HMC5883L (non scritto da me)

Code:

/*
An Arduino code example for interfacing with the HMC5883

by: Jordan McConnell
 SparkFun Electronics
 created on: 6/30/11
 license: OSHW 1.0, http://freedomdefined.org/OSHW

Analog input 4 I2C SDA
Analog input 5 I2C SCL
*/

#include <Wire.h> //I2C Arduino Library

#define address 0x1E //0011110b, I2C 7bit address of HMC5883

void setup(){
  //Initialize Serial and I2C communications
  Serial.begin(9600);
  delay(1000);
  Wire.begin();
  Serial.print("START ");
  
  //Put the HMC5883 IC into the correct operating mode
  Wire.beginTransmission(address); //open communication with HMC5883
  Serial.print("SETUP OK0");
  Wire.send(0x02); //select mode register
  Serial.print("SETUP OK1");
  Wire.send(0x00); //continuous measurement mode
  Serial.print("SETUP OK2");
  Wire.endTransmission();
  Serial.print("SETUP OK");
}

void loop(){
  
  int x,y,z; //triple axis data
  Serial.print("START READING 1");
  //Tell the HMC5883 where to begin reading data
  Wire.beginTransmission(address);
  Wire.send(0x03); //select register 3, X MSB register
  Wire.endTransmission();
  
 Serial.print("START READING 2");
 //Read data from each axis, 2 registers per axis
  Wire.requestFrom(address, 6);
  if(6<=Wire.available()){
    x = Wire.receive()<<8; //X msb
    x |= Wire.receive(); //X lsb
    z = Wire.receive()<<8; //Z msb
    z |= Wire.receive(); //Z lsb
    y = Wire.receive()<<8; //Y msb
    y |= Wire.receive(); //Y lsb
  }
  
  //Print out values of each axis
  Serial.print("x: ");
  Serial.print(x);
  Serial.print("  y: ");
  Serial.print(y);
  Serial.print("  z: ");
  Serial.println(z);
  
  delay(250);
}

[Reply #717 on:]

ITG3200 (very raro, difficile da trovare codice così "basico" da leggere per questo sensore, usano tutti classi wire esterne e incasinate)

C'è un motivo per cui è deprecabile l'uso della wire di Arduino su un quadricottero, la libreria in caso di errori sulla I2C ha il brutto vizio di bloccare completamente l'esecuzione dello sketch.
Di questa cosa ne avevamo parlato in modo esaustivo nel vecchio thread su i quadricotteri, a suo tempo avevo anche fatto notare che nella versione 1.7 di Multiwii era possibile arrivare lo stesso al blocco dello sketch in caso di errori I2C anche se solo in condizioni molto particolari ed improbabili, problema risolto dalla 1.8 in poi.
Ti consiglio di prendere la gestione I2C dell'ultima release di multiwii se non vuoi fare botti per colpa della wire.

[Reply #718 on:]

non intendo usare wire per la release, ma almeno per iniziare a fare i test voglio tenere il codice più pulito possibile. In oltre il codice scritto con la wire è comprensibile anche ai profani

comunque manca la seconda parte del post, che posterò stasera, in cui ci sono gli sketch per magnetometro e barometro (non scritti da me) e una piccola spiegazione del file allegato, che è il proseguimento della guida agli oggetti, in cui spiegerò come, grazie alla classe astratta Sensor e all'operatore new (di default nell'IDE 1.0) sia facilissimo implementare un nuovo sensore minimizzando l'uso di ifdef

[Reply #719 on:]

*comunque mancava la seconda parte del post sui sensori, maledetto errore 500 del forum*


BMP085 (non scritto da me)

Code:

/* BMP085 Extended Example Code
  by: Jim Lindblom
  SparkFun Electronics
  date: 1/18/11
  license: CC BY-SA v3.0 - http://creativecommons.org/licenses/by-sa/3.0/
 
  Get pressure and temperature from the BMP085 and calculate altitude.
  Serial.print it out at 9600 baud to serial monitor.

  Update (7/19/11): I've heard folks may be encountering issues
  with this code, who're running an Arduino at 8MHz. If you're
  using an Arduino Pro 3.3V/8MHz, or the like, you may need to
  increase some of the delays in the bmp085ReadUP and
  bmp085ReadUT functions.
*/

#include <Wire.h>

#define BMP085_ADDRESS 0x77  // I2C address of BMP085

const unsigned char OSS = 0;  // Oversampling Setting

// Calibration values
int ac1;
int ac2;
int ac3;
unsigned int ac4;
unsigned int ac5;
unsigned int ac6;
int b1;
int b2;
int mb;
int mc;
int md;

// b5 is calculated in bmp085GetTemperature(...), this variable is also used in bmp085GetPressure(...)
// so ...Temperature(...) must be called before ...Pressure(...).
long b5;

short temperature;
long pressure;

void setup()
{
  Serial.begin(9600);
  delay(2000);
  Wire.begin();
  bmp085Calibration();
}

void loop()
{
  temperature = bmp085GetTemperature(bmp085ReadUT());
  pressure = bmp085GetPressure(bmp085ReadUP());
  Serial.print("Temperature: ");
  Serial.print(temperature, DEC);
  Serial.println(" *0.1 deg C");
  Serial.print("Pressure: ");
  Serial.print(pressure, DEC);
  Serial.println(" Pa");
  Serial.println();
  delay(1000);
}

// Stores all of the bmp085's calibration values into global variables
// Calibration values are required to calculate temp and pressure
// This function should be called at the beginning of the program
void bmp085Calibration()
{
  ac1 = bmp085ReadInt(0xAA);
  ac2 = bmp085ReadInt(0xAC);
  ac3 = bmp085ReadInt(0xAE);
  ac4 = bmp085ReadInt(0xB0);
  ac5 = bmp085ReadInt(0xB2);
  ac6 = bmp085ReadInt(0xB4);
  b1 = bmp085ReadInt(0xB6);
  b2 = bmp085ReadInt(0xB8);
  mb = bmp085ReadInt(0xBA);
  mc = bmp085ReadInt(0xBC);
  md = bmp085ReadInt(0xBE);
}

// Calculate temperature given ut.
// Value returned will be in units of 0.1 deg C
short bmp085GetTemperature(unsigned int ut)
{
  long x1, x2;
 
  x1 = (((long)ut - (long)ac6)*(long)ac5) >> 15;
  x2 = ((long)mc << 11)/(x1 + md);
  b5 = x1 + x2;

  return ((b5 + 8)>>4); 
}

// Calculate pressure given up
// calibration values must be known
// b5 is also required so bmp085GetTemperature(...) must be called first.
// Value returned will be pressure in units of Pa.
long bmp085GetPressure(unsigned long up)
{
  long x1, x2, x3, b3, b6, p;
  unsigned long b4, b7;
 
  b6 = b5 - 4000;
  // Calculate B3
  x1 = (b2 * (b6 * b6)>>12)>>11;
  x2 = (ac2 * b6)>>11;
  x3 = x1 + x2;
  b3 = (((((long)ac1)*4 + x3)<<OSS) + 2)>>2;
 
  // Calculate B4
  x1 = (ac3 * b6)>>13;
  x2 = (b1 * ((b6 * b6)>>12))>>16;
  x3 = ((x1 + x2) + 2)>>2;
  b4 = (ac4 * (unsigned long)(x3 + 32768))>>15;
 
  b7 = ((unsigned long)(up - b3) * (50000>>OSS));
  if (b7 < 0x80000000)
    p = (b7<<1)/b4;
  else
    p = (b7/b4)<<1;
   
  x1 = (p>>8) * (p>>8);
  x1 = (x1 * 3038)>>16;
  x2 = (-7357 * p)>>16;
  p += (x1 + x2 + 3791)>>4;
 
  return p;
}

// Read 1 byte from the BMP085 at 'address'
char bmp085Read(unsigned char address)
{
  unsigned char data;
 
  Wire.beginTransmission(BMP085_ADDRESS);
  Wire.send(address);
  Wire.endTransmission();
 
  Wire.requestFrom(BMP085_ADDRESS, 1);
  while(!Wire.available())
    ;
   
  return Wire.receive();
}

// Read 2 bytes from the BMP085
// First byte will be from 'address'
// Second byte will be from 'address'+1
int bmp085ReadInt(unsigned char address)
{
  unsigned char msb, lsb;
 
  Wire.beginTransmission(BMP085_ADDRESS);
  Wire.send(address);
  Wire.endTransmission();
 
  Wire.requestFrom(BMP085_ADDRESS, 2);
  while(Wire.available()<2)
    ;
  msb = Wire.receive();
  lsb = Wire.receive();
 
  return (int) msb<<8 | lsb;
}

// Read the uncompensated temperature value
unsigned int bmp085ReadUT()
{
  unsigned int ut;
 
  // Write 0x2E into Register 0xF4
  // This requests a temperature reading
  Wire.beginTransmission(BMP085_ADDRESS);
  Wire.send(0xF4);
  Wire.send(0x2E);
  Wire.endTransmission();
 
  // Wait at least 4.5ms
  delay(5);
 
  // Read two bytes from registers 0xF6 and 0xF7
  ut = bmp085ReadInt(0xF6);
  return ut;
}

// Read the uncompensated pressure value
unsigned long bmp085ReadUP()
{
  unsigned char msb, lsb, xlsb;
  unsigned long up = 0;
 
  // Write 0x34+(OSS<<6) into register 0xF4
  // Request a pressure reading w/ oversampling setting
  Wire.beginTransmission(BMP085_ADDRESS);
  Wire.send(0xF4);
  Wire.send(0x34 + (OSS<<6));
  Wire.endTransmission();
 
  // Wait for conversion, delay time dependent on OSS
  delay(2 + (3<<OSS));
 
  // Read register 0xF6 (MSB), 0xF7 (LSB), and 0xF8 (XLSB)
  Wire.beginTransmission(BMP085_ADDRESS);
  Wire.send(0xF6);
  Wire.endTransmission();
  Wire.requestFrom(BMP085_ADDRESS, 3);
 
  // Wait for data to become available
  while(Wire.available() < 3)
    ;
  msb = Wire.receive();
  lsb = Wire.receive();
  xlsb = Wire.receive();
 
  up = (((unsigned long) msb << 16) | ((unsigned long) lsb << 8) | (unsigned long) xlsb) >> (8-OSS);
 
  return up;
}

A breve l'implementazione della DCM, vi allego anche la guida sul codice aggiornata ad oggi, manca però ancora il pezzo dove affronto il motivo per cui ho fatto tutto questo sbatti ovvero:

Code:

Sensor *sensori[2];
[...]
sensori[0]=new ITG3200();
  (*sensori[0]).setup(&dataSensor);

i più perspicaci noteranno come ora per implementare un giroscopio differente basterà creare la classe estendendo Sensor, e poi al posto dell'assegnazione "brutale", fare una assegnazione basata sulle #ifdef. In questo modo si hanno le ifdef sono in fase di crazione ed assegnazione delle classi, e non sparse per tutto il codice che non si capisce una mazza!