FORUMPIROTECHNICZNE.PL

[spock]

Witam,

Planuję zbudować układ który będzie w stanie mierzyć i rejestrować przyspieszenia z jakimi porusza sie typowa rakieta modelarska. W teorii pozwoliło by to na określenie takich parametrów jak prędkość i wysokość w funkcji czasu.

Zanim wybiorę jakiś konkretny czujnik przyspieszenia muszę wiedzieć z jakim zakresem przyspieszeń będę miał do czynienia. Kiedyś przeprowadzałem proste symulacje komputerowe lotu rakiety i sugerowały one dziesiątki g.

Co o tym sądzicie? Może ktoś ma dostęp do jakichś materiałów na ten temat?

Pozdrawiam!

[Qba]

Jeżeli nie myślisz o przekraczaniu 1macha to przyspieszenia mieszczą się w granicach do 20g raczej, natomiast co do czujników to polecam układy analog'a (www.analog.com) takie jak ADXL150, ADXL250 (zakres go 50g) no i zapraszam do przejrzenia mojego tematu o komputerku podkładowym
http://forum.pirotechnika.one.pl/viewtopic.php?t=12704

Pozdrawiam

PS A apropo komputerka to kończę pisać soft i bede zamawiał akumulatorek do prób, a potem jeszcze testy lotów w laboratorium (symulacja wznoszenia przez zmiane ciśnienia szczykawką), projektowanie płytki w SMD no i będzie mozna sprawdzac jak się to spisuje w warunkach polowych.

[spock]

Fajny projekt, mam plan zrobić coś podobnego na 3-osiowym czujniku przyspieszenia. W moim przypadku dane mają być zapisywane na karcie mmc w systemie FAT16. Część softu mam już napisaną w szczególność obslugę karty mmc i samej atmegi.

Dodatkowo mam w planie napisanie softu który będzie w stanie zrekonstruować całkowita trajektorię lotu z otrzymanych wyników.

Co z tego wyjdzie to zobaczymy

Pozdrawiam!

[QbaS]

[spock]

[Qba]

[spock]

[spock]

[jaskiniowiec]

[spock]

Co sądzicie o częstotliwości próbkowania. Czy aby aby 25 razy na sek. to nie za mało? Może lepiej zamienić kość eeprom`u na jakiś flash?

[Qba]

nieee, spokojnie. Poczytaj troche o eepromie. Do eepromu mozna zapisywać dane stronami, czyli po ileś tam bajtów np. dla pamięci 64k jest to po 32 bajty dla 512k nawet po 128 bajtów. Zapis do eepromu tak naprawde wygląda tak: najpierw mikroproceser przesyla dane do kości eeprom a ona zapisuje te dane w wewnętrznym RAM'ie, natomiast gdy mikroprocesor skonczy wysylac wtedy kosc eeprom przepisuje dane z wewnetrznego RAM'u do faktycznego EEPROMU. Czas zapisania całej takiej strony wynosi max 5ms (dla napiecia zasilania 5v). Biorąc pod uwagę, ze kazdy pomiar jest dwubajtowy, pomiar pszyspieszenia mamu co 10ms a pomiar ciśnienia i temperatury raz na 100ms, to co 100ms mamy w sumie 24 bajty danych, czyli jeszcze niepełna strona, dane wpycham sobie do buforu (tablica zmiennych w RAM'ie procesora) i dopiero gdy mam 32 bajty danych to wysylam cala strone do pamięci i to trwa krótko a po zakończeniu wysylania pamiec sama (nie angazujac procesora) przepisuje sobie te dane z wewnetrznego RAM'u do EEPROM'u i to trwa max 5ms i przez ten czas nie mozna wyslac nowych danych do pamieci, ale nastepna strona nie przyjdzie wczesniej niz za 100ms wiec nie ma sie o co martwić.

Pozdrawiam

PS mam nadzieje ze w miare jasno, a jak nie czaisz to poczytaj sobie noty katalogowe eepromów i o zapisywaniu stronami (write page)

[spock]

oki faktycznie nie każdy eeprom ma taki bajer, zapomniałem ze ten ma

[pablo]

Ale w kartach SD albo MMC współczynnik pojemność/cena jest nie do pobicia.

[Qba]

[spock]

Obsługę karty mmc.sd znajdziesz bez problemu na www.avrfreaks.net na forum. Ja brałem z stamtąd prawie gotowe funkcje. Ogólnie z odczytem nie ma problemów. Ciekawe rzeczy zaczynają sie przy zapisie. U mnie karta zawiesza sie po pewnej niedeterministycznej ilości zapisanych bloków. Nie umiem tego wytłumaczyć. Ale poradziłem sobie z tym resetem programowym.

Kod wklejam poniżej ponieważ forum nie akceptuje mojego rozszerzenia. Jest to mimo wszytko nadal wersja robocza ale testowana i działająca. Powodzenia jak będziesz miał problemy to pytaj.

Pozdrawiam!

KOD:

#ifndef MMC_H
#define MMC_H
#include <spi.h>
#include <usart.h>
#include <avr/delay.h>


/*###############################################
# Komendy mmc wziete z avrfreaks sprawdzic z ep #
#################################################*/

#define MMC_GO_IDLE_STATE 0
#define MMC_SEND_OP_COND 1
#define MMC_SEND_CSD 9
#define MMC_SEND_CID 10
#define MMC_SEND_STATUS 13
#define MMC_SET_BLOCKLEN 16
#define MMC_READ_SINGLE_BLOCK 17
#define MMC_WRITE_BLOCK 24
#define MMC_PROGRAM_CSD 27
#define MMC_SET_WRITE_PROT 28
#define MMC_CLR_WRITE_PROT 29
#define MMC_SEND_WRITE_PROT 30
#define MMC_TAG_SECTOR_START 32
#define MMC_TAG_SECTOR_END 33
#define MMC_UNTAG_SECTOR 34
#define MMC_TAG_ERASE_GROUP_START 35
#define MMC_TAG_ERARE_GROUP_END 36
#define MMC_UNTAG_ERASE_GROUP 37
#define MMC_ERASE 38
#define MMC_CRC_ON_OFF 59


#define R1_BUSY 128
#define R1_PARAMETER 64
#define R1_ADDRESS 32
#define R1_ERASE_SEQ 16
#define R1_COM_CRC 8
#define R1_ILLEGAL_COM 4
#define R1_ERASE_RESET 2
#define R1_IDLE_STATE 1



#define SS 4
#define CRC 0x95

char mmcData[512];

/*######################################################
# #
# Funkcja odczytujaca Data Token lube Error token #
# #
########################################################*/

char readToken()
{
char tmp;
while(1)
{
tmp = sendByteSpi(0xFF);
if(tmp = 0xFE) return 1;
if(tmp & 0xF0 == 0) return -1;
}
}

/*######################################################
# #
# Wysłanie komendy do karty i odczekanie na odpowiedz #
# od karty #
# #
########################################################*/

char mmcSendCommand(char cmd, unsigned long int arg)
{
char i,tmp;

sendByteSpi(0xFF); // Send a leading 0xFF nie ma tego w EP!!!!!!!!!!!!1
sendByteSpi(cmd | 0x40); //6 bitowa komenda
sendByteSpi(arg>>24); // Send the last byte of the parameter
sendByteSpi(arg>>16); // Send the 3rd byte of the parameter
sendByteSpi(arg>>8); // Send the 2nd byte of the parameter
sendByteSpi(arg); // Send the lowest byte of the parameter
sendByteSpi(CRC); //CRC

sendByteSpi(0xFF);
return sendByteSpi(0xFF);

}

void mmcSelect()
{
PORTB &= ~(1 << SS);
}

void mmcDeselect()
{
PORTB |= (1<<SS);
for(char l=0;l<10;l++) //wylaczenie karty
{
sendByteSpi(0xFF);
}
}

/*######################################################
# #
# Inicjalizacja karty mmc wysłanie co najmniej 8 cykli #
# zegara z komenda 0xFF, przestawienie karty w tryb #
# spi. #
# STATUS - działa #
########################################################*/


char init_mmc()
{
char i;
char result;

//initSpi();
PORTB |= (1<<SS); //SS w stan sysoki karta wylaczona

for(i=0;i<10;i++) //maksymalnie 74 cykle bylo 10 z ep i avrfreaks
{
sendByteSpi(0xFF);
}
PORTB &= ~(1 << SS); //wybor kartu jako slava SS w stan niski
result = mmcSendCommand(MMC_GO_IDLE_STATE, 0); //przestawienie karty w tryb SPI

if(result!=R1_IDLE_STATE) {return result;} //jezeli nastapi blad to zaprzestan inicjalizacji

while (result=mmcSendCommand(MMC_SEND_OP_COND, 0) != 0){ // zero to blad, w ep jest napisane zeby czekac az odpowiedni bit= 0,nie ustawi sie na zero
// for (char j = 0; j < 10; j++) _delay_ms(10);
//sendByteUsart(result);
}

mmcDeselect();

return 0; //zmodyfikowac w przyszlosci

}

/*######################################################
# #
# Odczyt bloku danych o dlugosci 512 bajtow nalezy #
# poczekac aż karta wyśle data token = 0xFE lub error #
# token i wtedy odebrac 512 bajtow. Numer sektora #
# nalezy pomnożyc przez 512 aby wyliczyc adres do #
# odczytu #
########################################################*/



//na avrfreaks jets napisane ze karta czyta jezlei sektor jest wielokrotnosci dlugosci 0, 512 ,itd...
char mmcReadBlock(unsigned long int sector)
{
short int i;
char tmp;
mmcSelect(); //wlacz karte
tmp = mmcSendCommand(MMC_READ_SINGLE_BLOCK,(unsigned long int)sector<<9);
//sendByteUsart(tmp);
if(tmp!=0) //<<9 mnozenie x512
{
return tmp; //jezeli karta zwroci blad to zaprzestan odczyt
}

//sendByteUsart('a');
while (sendByteSpi(0xFF) != (char)0xFE); //to dziala lepiej gdy odbierze ten znak zaczyna sie transmisja
//sendByteUsart('b');
for(i=0;i<512;i++)
{
mmcData[i] = sendByteSpi(0xFF);
}
sendByteSpi(0xFF); //odbierz i zignoru CRC sa to w tym wypadku 2 bajty
sendByteSpi(0xFF);

mmcDeselect(); //wylacz karte

return 0;
}




char mmcWriteBlock (unsigned long int adress, char *databuffer) {



mmcSelect(); //wlacz karte
char result = mmcSendCommand(MMC_WRITE_BLOCK, (unsigned long int)(adress<<9));
if (result != 0) { //
return result; // zwroc blad
} //
//sendByteSpi(0xFF); // Send a dummy checksum - wedlug specyfikacji suna nie trzeba czegos takiego robic
//sendByteSpi(0xFF);

sendByteSpi(0xFE); // start transmittion flag - rozpoczecie transmisji
unsigned int i;

//for(int j=0;j<512;j++) sendByteUsart(databuffer[j]);

for (i = 0; i < 512; i++) { // wyslanie tablicy
sendByteSpi(databuffer[i]);
}
sendByteSpi(0xFF); //odbierz i zignoru CRC sa to w tym wypadku 2 bajty
sendByteSpi(0xFF);

int licz=0;
while(sendByteSpi(0xFF) & 0x1F != 0x05){ // sprawidzenie zawartosci data response token

licz++;
if(licz>100) return 1;

}

licz=0;
while (!sendByteSpi(0xFF)){ // czekaj na koneic wewnetrzenego cyklu zapisu

licz++;
_delay_ms(10);
if(licz>50) return 1;

}

mmcDeselect(); //wylacz karte

return 0;
}



#endif