rilevare terremoti con arduino

ratto93:
Infatti anche con quella delle 4 e delle cinque è andato in "saturazione" se si può dire... praticamente ogni scossa percepibile a livello di vibrazione o di rumore lui l'ha segnata al massimo per la sensibilità per cui l'avevo settato ovvero: 1gr però ora che ci penso un grammo è davvero troppo poco..
Datemi un poco di tempo per dindagare sulla cosa e vi so dire.. al momento è ancora a lavoro ma domani se ho tempo lo smonto e gli do un occhio

potresti mettere 2 sensori, uno con un range da 1g e un altro meno sensibile per le scosse piú forti.
Ciao Uwe

Non hai letto questo:
http://www.elettronicain.it/MyMain/riviste/Anteprime/INTENSITA-TERREMOTI/intensita-terremoti.pdf

ratto93:
sono riuscito a finirlo in maniera precaria ieri e l'ho montato, neanche farlo apposta la sera cè stato il terremoto -_-"

Non puoi far venire un terremoto solo perchè vuoi provare la tua stazione... non si fa!! :smiley:

Ovviamente scherzo... me*da a noi ci è andata bene!! e c'è chi ora non ha neanche la casa... mah...

Colpa dei Maya? :astonished:
XD

maggio93:
Colpa dei Maya? :astonished:

Ma per favore.... :roll_eyes:

valvale97:
Questo addirittura li prevede i terremoti :slight_smile: My Commentary and Technical help: Predicting Earthquakes via Magnetic Field Monitors

Ricordo che molti anni fa ci lavoravano pure in Italia.
C'era la collaborazione della RAI.
Si parlava dell' effetto piezoelettrico e del fatto che qualcuno aveva notato disturbi alla TV CRT prima di un terremoto.
Ne avevo letto un' articolo su Nuova Elettronica una ventina di anni fa.

Per chi volesse realizzare un sismometro-sismografo senza stressarsi troppo ho letto sull'ultimo numero di Elettronica In che è stata presentata una shield per Arduino che a quanto pare è eccellente. Qui l'anteprima.

@ratto: dai pubblica qualche foto del progetto e qualche info in più, sono curioso.. XD

Se vuoi prevedere un terremoto comprati un cane :slight_smile: quello sta agitato 12 ore in anticipo, dovresti usare arduino per interpretare il suo comportamento anomalo :slight_smile:

Solo che il cane si agita per piú cose; devi capire per cosa ogni volta.
Ciao Uwe

uwefed:
Solo che il cane si agita per piú cose; devi capire per cosa ogni volta.
Ciao Uwe

Vero, ti scordi di portarlo fuori a fare io bisognini e poi m'immagino Arduino che spara sul serial monitor un'interminabile serie di WCWCWCWCWCWCWCWCWCWCWCWCW FINCHE' IL CANE NON TE LA MOLLA DAVANTI L'USCIO mentre tu magari sei scappato a 500km per paura del terremoto, scordandoti di lui. Ma siate seri :grin:

Ecco la prima versione del codice per il sismografo, ora è stabile ma non fà letture precise,presto vedrò di sistemare questo problema dato dal casting delle stringhe...
Ora è basato su acellerometro BMA180 e presto ne farò una versione per MMA o ADXL analogici, per ora il software prende il dato letto dall'acellerometro e lo stocca nella SD, in futuro aggiungiamo la swRTC, facciamo andare il micro ad 8MHz e riduciamo i consumi, poi aggiungiamo un bel trasmettitore NRFL o simile che comunichi con un allarme in caso di scosse belle cariche, provate il software, è molto semplice e non dovrebbe aver problemi ma se trovate bachi fatemelo sapere...

#include <Wire.h>
#include <SD.h>

#define address 0x40
const int chipSelect = 4;

void initBMA180()
{
  int temp, result, error;

  Wire.beginTransmission(address);
  Wire.send(0x00);
  Wire.requestFrom(address, 1);
  while(Wire.available())
  {
    temp = Wire.receive();
  }
  Serial.print("Id = ");
  Serial.println(temp);
  result = Wire.endTransmission();
  checkResult(result);
  if(result > 0)
  {
    error = 1;
  }
  delay(10);
  if(temp == 3)
  {
    // Connect to the ctrl_reg1 register and set the ee_w bit to enable writing.
    Wire.beginTransmission(address);
    Wire.send(0x0D);
    Wire.send(B0001);
    result = Wire.endTransmission();
    checkResult(result);
    if(result > 0)
    {
      error = 1;
    }
    delay(10);
    // Connect to the bw_tcs register and set the filtering level to 10hz.
    Wire.beginTransmission(address);
    Wire.send(0x20);
    Wire.send(B00001000);
    result = Wire.endTransmission();
    checkResult(result);
    if(result > 0)
    {
      error = 1;
    }
    delay(10);
    // Connect to the offset_lsb1 register and set the range to +- 2.
    Wire.beginTransmission(address);
    Wire.send(0x35);
    Wire.send(B0100);
    result = Wire.endTransmission();
    checkResult(result);
    if(result > 0)
    {
      error = 1;
    }
    delay(10);
  }

  if(error == 0)
  {
    Serial.print("BMA180 Init Successful");
  }
}



void checkResult(int result)
{
  if(result >= 1)
  {
    Serial.print("PROBLEM..... Result code is ");
    Serial.println(result);
  }
  else
  {
    Serial.println("Read/Write success");
  }
}

void readId()
{
  int temp, result;

  Wire.beginTransmission(address);
  Wire.send(0x00);
  Wire.requestFrom(address, 1);
  while(Wire.available())
  {
    temp = Wire.receive();
  }
  Serial.print("Id = ");
  Serial.println(temp);
  result = Wire.endTransmission();
  checkResult(result);
  delay(10);
} 
int readAccel3(byte msbAddr, byte lsbAddr)
{
  short temp, result, temp2;
  byte lsb, msb = 0;

  temp2 = 0;
  temp = 0;

  while(temp != 1)
  {
    Wire.beginTransmission(address);
    Wire.send(msbAddr);
    Wire.requestFrom(address, 1);
    while(Wire.available())
    {
      msb = Wire.receive();
      temp = msb & 0x01;
    }
  }

  Wire.beginTransmission(address);
  Wire.send(lsbAddr);
  Wire.requestFrom(address, 1);
  while(Wire.available())
  {
    lsb = Wire.receive();
    temp |= lsb;
    temp = temp >> 2;
  }
  result = Wire.endTransmission();
  msb = msb >> 2;
  
  if(lsb & B10000000){
    lsb &= B01111111;
    temp2 = lsb << 6;
    temp2 |= msb;       
   
    temp2 = 0 - temp2;
  }else{
    temp2 = lsb << 6;
    temp2 |= msb;    
  }
  return temp2;
}

int readAccel2(byte lsbAddr, byte msbAddr){
  byte lsb, msb = 0;
  short result;
  
  //read LSB first...
  while(!(lsb & 1)){
    Wire.beginTransmission(address);
    Wire.send(lsbAddr);
    Wire.requestFrom(address, 1);
    while(Wire.available()){
      lsb = Wire.receive();
    }
    Wire.endTransmission();
  }
  
  Serial.print("lsb: ");
  Serial.println(lsb, BIN);
  
  if(lsb & 1){
    Serial.println("new_data");
  }
  
  //remove bit 0 and bit 1
  lsb = lsb >> 2;
  Serial.print("lsb: ");
  Serial.println(lsb, BIN);
  

  //now MSB
  Wire.beginTransmission(address);
  Wire.send(msbAddr);
  Wire.requestFrom(address, 1);
  while(Wire.available()){
    msb = Wire.receive();
  }
  Wire.endTransmission();
  
  Serial.print("msb: ");
  Serial.println(msb, BIN);
  
  result = msb << 6;
  Serial.print("res: ");
  Serial.println(result, BIN);
  
  result |= lsb;
  Serial.print("res: ");
  Serial.println(result, BIN);

  Serial.print("res: ");
  Serial.println(result, DEC);
  
  return 0;
}

//int x;

int readAccel(byte msb, byte lsb)
{
  int temp, result;

  temp = 0;

  while(temp != 1)
  {
    Wire.beginTransmission(address);
    Wire.send(msb);
    Wire.requestFrom(address, 1);
    while(Wire.available())
    {
      temp = Wire.receive() & 0x01;
    }
  }

  Wire.beginTransmission(address);
  Wire.send(lsb);
  Wire.requestFrom(address, 1);
  while(Wire.available())
  {
    temp |= Wire.receive();
    temp = temp >> 2;
  }
  result = Wire.endTransmission();
  return temp;
}

void setup()
{
  Wire.begin();
  Serial.begin(9600);
  initBMA180();
  delay(2000);
  Serial.println();
  Serial.print("Initializing SD card...");
  pinMode(10, OUTPUT);
  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
    return;
  }
  Serial.println("card initialized.");
}

void loop()
{
    int X,Y,Z=0;
    String dataString = "";
  //Lettura degli assi x,y e z
  X = readAccel3(0x03, 0x02);
  double dX;
  dX = X * 0.00025;
  dataString += String(dX);
  dataString += ","; 
  
  Y = readAccel3(0x05, 0x04);  
  double dY;
  dY = Y * 0.00025;
  dataString += String(dY);
  dataString += ","; 
  
  Z = readAccel3(0x07, 0x06);
  double dZ;
  dZ = Z * 0.00025;
  dataString += String(dZ);
  dataString += ",";  
  
  Serial.println(" X: ");
  Serial.println(dX);
  Serial.println(" Y: ");
  Serial.println(dY);
  Serial.println(" Z: ");  
  Serial.println(dZ);
  delay(200);
  
  File dataFile = SD.open("sisma.csv", FILE_WRITE);
  if (dataFile) {
    dataFile.println(dataString);
    dataFile.close();
    Serial.println(dataString);
  }  
  else {
    Serial.println("error opening datalog.txt");
  } 
}

Il file è di tipo csv, potete anche salvarlo come txt era per importarlo più facilmente in programmi come excel e similari.

Scusate ma avete per caso trovato ulteriori info sul sismografo di schifano basato su arduino?
Ho trovato solo la parte generale teorica

@brunialti, scusami ma non capisco, di cosa stai parlando ?
forse mi son perso qualche passaggio

ilmandorlone:
salve sono un bellunese e non so se avete fatto cosa che oggi più volte c'è stata una scossa.

quando l'hai sentita?

Mi son messo a scrivere la versione per acellerometri analogici, L'idea è quella di mettere tutto dentro un unico sketch poi tramite una define si sceglie che acellerometro usare, se digitale o analogico, che dite, continuo su questa strada oppure faccio due file diversi ?

Io farei due file diversi e poi con define scegli quale includere :slight_smile:

3900 yuppy :slight_smile:
Indevo come nel codice della multiwii.. ora vedo quale mi è più semplice integrare :slight_smile:

Aimè ho catturato parte del terremoto di stamattina, ne ho catturato circa 3/4 poi è andato in palla il sistema di nuovo... però ho scoperto il motivo, il radon, nel pozzetto interrato in cui si trova il micro e la strumentazione cè ristagno di radon durante il terremoto, ho messo il geiger dentro al pozzetto e cantava come una raganella, quindi credo siano le radiazioni, se pur modeste di questo gas a falsarmi le letture, non appena riesco a fare un grafico decente della scossa che ho registrato lo posto

Qui i dati di ciò che ho rilevato, tra poco carico anche i grafici, i numeri sono la lettura pura, devo ancora finire il codice per la conversione vi basterà però sapere che 250 => a .5 G (G è la forza di acellerazione gravitazionale 9,8m/s^2)

dividi il codice in diverse classi, percò che implementano una classe che mette a disposizione i meodi getX, getY e getX e update. a questo punto usi la classe "padre" in tutto il codice, e solo nell'inizializzazione, con le #ifdef o con le #define, assegni alla classe "padre" la giusta classe figlio.

quando torno a casa ti passo il mio codice che fà già questo lavoro con un adxl345.

notare che la classe figlio può implementare sensori analogici, i2c, SPI, e additrittura altri sensori, senza che il tuo codice principale cambi di una virgola (tranne le #ifdef)