Korkeusmittari vesirakettiin ilmanpaineen avulla?

Olisi kiinostus rakentaa vesiraketille korkeusmittaria. Ajattelin käyttää korkeuden mittaamiseen ilmanpaine anturia. Tämmöistä löytyi googlella: http://www.jbgizmo.com/page27.htm

Itse kuitenkin haluaisin lähteä toteuttaa AVR-piirillä tätä loggeria. Tästä projektiata tulisi aika laaja kun pitäisi miettiä: tehokas kevyt virtalähde ja virtahallinta sille, korkeus mittari joka saisi mitattuu muistiin yhden lennon datan (kesto noin 8-15 sekuntia lennolla), tiedon siirto pc:eelle ja ohjelma millä lasketaan jollain kaavalla ilmanpaineen vaihtelusta max. korkeus.

Itse ymmärsin että loggeri tallentaa tiheään ilmanpaine arvoja muistiin ja niistä lasketaan jonkin kaavan avulla korkeus kun tiedetään lähtötason korkeus merenpinnasta. Olenko väärässä?

Mistä tätä projektia kannataisi lähteä toteuttamaan?

Kuulostaa mielenkiintoiselta projektilta. Kuinka iso tämä elektroniikkaosa saisi olla? Millaisen kokoluokan raketista on kyse?

Itse lähtisin ehkä ajattelemaan virransyöttöä jonkin nappipariston voimin. Niitä saa Kiinasta tilaamalla halvalla.

Jos AVR-mikrokontrolleria haluat käyttää, niin hyvä ja yksinkertainen vaihtoehto voisi olla ATtiny85. Siitä löytyy 512 tavun EEPROM, jonne mahtuu jonkin verran mittausdataa. Erillinen DataFLASH tai vastaava toiminee myös, mutta monimutkaistaa jonkin verran. Myös muistikortti (microSD/SD) toimii tallennuspaikkana hyvin (vähän hitaammin tosin), siltä saisi datan helpommin myös tietokoneelle. Tällöin kannattanee valita uC:ksi tosin ehkä ATmega ATtinyn sijasta. Ohjelmointilaitteen tarvitset myös, ellei löydy Arduino-alustaa, joka kävisi hommaan.

Tietysti jos ei halua tehdä kaikkea alusta alkaen itse, niin voinee käyttää esim. jotain Arduino Nanoa.

Käytännössä kiihtyvyysanturi voisi olla parempi. Ilmanpaineeseen kun mittauksessa vaikuttaa patopaine, jonka nopeus saa aikaan. Ja tätä ei helposti saa mittarista kompensoitua pois. Lisäksi väärä lentoasento tekee temppunsa.

Kiihtyvyysanturilla riittäisi kolme tietoa. Milloin nytkähdettiin liikkeelle, milloin kiihtyvyys on nollassa eli suunta on sen jälkeen alaspäin. Tässä on se ajatus, että nopeus on nollassa lakipisteessä ja sitten kun tömpsähdetään alas niin tiedetään kuinka korkealla käytiin. Alusta kiihtyvyyden mittaus voidaan mitata useammin, jotta tiedetään, miten mootori antoi tehoa ja ajoista saadaan sitten keskimääräiset nopeudet tietäen putoamiskiihtyvyys. Jos oikein korkealle mennään niin sitten on jo ongelmana terminal velocity. Eli ilmanvastuksen ja maan vetovoiman tasapainotila.

Ja itse sain tuossa tungettua pientä koodia ja jonkin 1-wire demon pyörimään ATMega88:lla, kun oikein annoin puukkoa silmään tuolle demolle, että sain 8 kiloon tungettua.

Seuraavaksi olen ajatellut siirtää leikkikalujen kehityksen 328:n päälle ja ottaa alustaksi amforthin. Kielenä Forth sopii minulle paremmin, kun ei tarvitse miettiä miltä data näyttää vaan tietää, että jotain on pinossa ja aina soi kun käsketään. Bonuksena tulee vielä helpompi assemblerointi. Pakko vielä hiukan mollata C:tä :slight_smile:

Oli aikoinaan projekti jossa pulsseja tuli aivan järkyttävään tahtiin ja ne generoivat keskeytyksiä. Kide oli nostettu 10% liian nopeaksi ja silti jäätiin tavoitteesta karvan veran. Vasta kun optimoin kontekstin vaihdosta kaiken ylimääräisen ja pyöritin laskuria yhdessä rekisterissä ja useammassa 8-bittisessä muuttujassa, jotka pääohjelma lähinnä sitten parsi kohdilleen niin siten päästiin 102% nopeuteen. Joskus kaupalliset tuotteet ovat ihan oikeasti näin huonosti tehtyjä.

Itse suunittelin virran lähteeksi pientä LiPo akkua: http://www.robomaa.com/index.php?main_page=product_info&cPath=5&products_id=551

Raketin koko vaihtelee 1,5 - 8 litran välillä. Kyllä se elektroniikka osa saa olle sen kokoinen että, mahtuu 1,5 litran pullon sisään. Ajaettilin vähän et ne elektronikka osa olis monessa piirilevyllä. Yhdessä olis virranhallinta jossa on regulaattori ja jotain muuta, toisella levyllä ajastin laskuvarjon laukaisua varten ja kolmannella korkeusmittari. Tuossa helpoittasi se ettei tarvitse aina laitaa kaikea arvokasta elektroniikka kamaa uuteen testirakettiin minkä toimiminen on epävarmaa.

Kyllä tuo kiihdytys anturi voi olla toinen vaihto ehto, mutta toimiiko se jos käyttää laskuvarjoa? Ja riittääkö yksi akselinen kiihdytys anturi tähän hommaan? Entäs kuinka helppoa on laskea kiihtyvyyden perusteella korkeus?

Tuli tämmösiin törmmättyä nettia selaillessa:
http://www.sparkfun.com/products/9530
http://www.sparkfun.com/products/9228

Olisiko noista jommasta kummasta hyötyä ajatellen muistin tallentamista.

No joo lähen nyt harjottelee tätä hommaan helpoimmasta päästä eli:
Löytyy:

  • arduino uno
  • t√§mm√∂nen muisttipiiri: 24LC32
  • 10 komh potentiometri

Pitäis noista saada toimiva kokonaisuus, joka tallentaa tolle muistipiirille potentiometrin arvoi vaikka 5 kertaa sekunnissa. Sen jälkeen tiedot pitäs saada siirrettyy koneseen? Ja arvoista piirtää vaikka viivadiagrammi. Mistä kannatas lähtee liikkeelle, piiri liitämisestä arduinoon?

Nyt sain t√§mm√∂sell√§ koodilla tulostettua arduinon serial monitoriin tulostettua ‚Äúthis is data from the eeprom‚ÄĚ. Jos irrotan jonkin johon muisti piirilt√§ tulee jatkuvasti monitoriin ‚Äú√Ņ‚ÄĚ kirjainta. Eli ainakin sain jotain sy√∂tettyy tonne piirin sis√§lle. Mist√§ kannatasi alkaa jatkaa ett√§ saisi vaikka tallennettua potentiometrin arvoja.
Koodi taisi olla arduinon sivulta.

[code]/*

  • Use the I2C bus with EEPROM 24LC64
  • Sketch: eeprom.pde
  • Author: hkhijhe
  • Date: 01/10/2010

*/

#include <Wire.h> //I2C library

void i2c_eeprom_write_byte( int deviceaddress, unsigned int eeaddress, byte data ) {
int rdata = data;
Wire.beginTransmission(deviceaddress);
Wire.send((int)(eeaddress >> 8)); // MSB
Wire.send((int)(eeaddress & 0xFF)); // LSB
Wire.send(rdata);
Wire.endTransmission();
}

// WARNING: address is a page address, 6-bit end will wrap around
// also, data can be maximum of about 30 bytes, because the Wire library has a buffer of 32 bytes
void i2c_eeprom_write_page( int deviceaddress, unsigned int eeaddresspage, byte* data, byte length ) {
Wire.beginTransmission(deviceaddress);
Wire.send((int)(eeaddresspage >> 8)); // MSB
Wire.send((int)(eeaddresspage & 0xFF)); // LSB
byte c;
for ( c = 0; c < length; c++)
Wire.send(data[c]);
Wire.endTransmission();
}

byte i2c_eeprom_read_byte( int deviceaddress, unsigned int eeaddress ) {
byte rdata = 0xFF;
Wire.beginTransmission(deviceaddress);
Wire.send((int)(eeaddress >> 8)); // MSB
Wire.send((int)(eeaddress & 0xFF)); // LSB
Wire.endTransmission();
Wire.requestFrom(deviceaddress,1);
if (Wire.available()) rdata = Wire.receive();
return rdata;
}

// maybe let’s not read more than 30 or 32 bytes at a time!
void i2c_eeprom_read_buffer( int deviceaddress, unsigned int eeaddress, byte *buffer, int length ) {
Wire.beginTransmission(deviceaddress);
Wire.send((int)(eeaddress >> 8)); // MSB
Wire.send((int)(eeaddress & 0xFF)); // LSB
Wire.endTransmission();
Wire.requestFrom(deviceaddress,length);
int c = 0;
for ( c = 0; c < length; c++ )
if (Wire.available()) buffer[c] = Wire.receive();
}

void setup()
{
char somedata[] = ‚Äúthis is data from the eeprom‚ÄĚ; // data to write
Wire.begin(); // initialise the connection
Serial.begin(9600);
i2c_eeprom_write_page(0x50, 0, (byte *)somedata, sizeof(somedata)); // write to EEPROM

delay(10); //add a small delay

Serial.println("Memory written");

}

void loop()
{
int addr=0; //first address
byte b = i2c_eeprom_read_byte(0x50, 0); // access the first address from the memory

while (b!=0) 
{
  Serial.print((char)b); //print content to serial port
  addr++; //increase address
  b = i2c_eeprom_read_byte(0x50, addr); //access an address from the memory
}
Serial.println(" ");
delay(2000);

}
[/code]