0% encontró este documento útil (0 votos)
141 vistas9 páginas

Caja Negra Arduino

Este documento describe un proyecto para simular una caja negra de avión utilizando un Arduino, sensores y una pantalla LCD. El objetivo es aprender sobre el funcionamiento y programación de una caja negra real mediante la simulación con los sensores disponibles como GPS, temperatura y humedad. Se explica el desarrollo del prototipo y los problemas encontrados durante la programación. Finalmente, se muestran ejemplos de código y los resultados parciales obtenidos.

Cargado por

Navarro Salgado
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como DOCX, PDF, TXT o lee en línea desde Scribd
0% encontró este documento útil (0 votos)
141 vistas9 páginas

Caja Negra Arduino

Este documento describe un proyecto para simular una caja negra de avión utilizando un Arduino, sensores y una pantalla LCD. El objetivo es aprender sobre el funcionamiento y programación de una caja negra real mediante la simulación con los sensores disponibles como GPS, temperatura y humedad. Se explica el desarrollo del prototipo y los problemas encontrados durante la programación. Finalmente, se muestran ejemplos de código y los resultados parciales obtenidos.

Cargado por

Navarro Salgado
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como DOCX, PDF, TXT o lee en línea desde Scribd
Está en la página 1/ 9

Introducción

En este proyecto para la clase se planteó realizar un prototipo de caja negra, simulando las
funciones que tiene una real que se encuentra en una aeronave. En el cual se probarán los
conocimientos adquiridos durante el semestre. Con esto podremos comprender mejor como se
programa una caja negra, los sensores y aparatos que usa, además de su complejidad.

Objetivo

Simular, lo más aproximado posible, una caja negra con los sensores que tengamos disponibles y
con esto aprender su funcionamiento e importancia.

Antecedentes

Se denomina caja negra o registrador de vuelo al dispositivo que, principalmente en aeronaves,


trenes, barcos y naves espaciales, registra la actividad de los instrumentos y las conversaciones de
los tripulantes. Su función es almacenar datos que, en caso de un accidente, permitan analizar lo
ocurrido en los momentos previos y establecer sus causas. Los aviones comerciales de gran
tamaño llevan dos cajas negras, técnicamente conocidas por sus siglas en inglés como CVR
(grabadora de voces de cabina) y FDR (grabadora de datos de vuelo).

Estas están recubiertas con una especie de armadura elaborado de titanio o con metal inoxidable,
que tiene un poco más de una pulgada de grosor, que es capaz de proteger la información de la
caja negra contra grandes presiones (como unos 6 mil metros bajo el mar) o contra una llama de
fuego.

Cuando ocurre un accidente, la caja negra de un avión comienza a emitir una señal ultrasónica
para que los encargados de recuperarla puedan ubicarla. Esta señal se emite en intervalos de cada
segundo, durante un mes.
Desarrollo

Para realizar el proyecto contamos con un Arduino, sensor de temperatura y humedad, gps,
bluetooth, pantalla lcd y una batería externa para darle energía.

Con estos instrumentos se podrán obtener cada uno de los datos que necesitamos para poder
simular una caja negra.(Lat, long, temp, hum, etc). Y al obtenerlos se desplegarán en una pantalla
lcd que mostraran todos a través de una serie de comandos que se mandaran por bluetooth.

Encontramos muchos problemas en el desarrollo de el programa y en la conexión para la caja


negra los cuales pudimos resolver mediante videos tutoriales y páginas de comentarios públicos
donde te recomendaban que hacer para cada una de las preguntas que surgían. Al ver y leer los
comentarios tratamos de aplicarlos a el programa hasta hallar uno que cumpliera con las
necesidades que teníamos.

Ejemplos

Arduino GPS data to google maps GY-NEO6MV2

Video en el que encontramos como hacer funcionar un gps y poder crear un mapa.

https://create.arduino.cc/editor/LogMaker360/89ad9ca8-73a4-4b5e-94e5-
b361937812da/preview

Resultados

El programa funciona casi completamente como se desea, solo que por cuestiones de tiempo no
pudimos desarrollarlo mas.

//En esta seccion de incluyen todas las librerias de los dispositivos a usar//

//Por ejemplo LCD, GPS, DHT11, ULTRASONICO


#include <Wire.h> //Acelerometro

#include <LiquidCrystal_I2C.h> #define ACC_FULL_SCALE_2_G 0x00 const int chipSelect = 53;

#include <SPI.h> //Giroscopio int x;

#include <SD.h> #define GYRO_FULL_SCALE_250_DPS char comando;


0x00
#include <DHT.h> //Acelerometro
#define GYRO_FULL_SCALE_500_DPS
#include <NewPing.h> 0x08 double SensitivityScaleFactor =
16384.0;
#include <TinyGPS++.h> #define
GYRO_FULL_SCALE_1000_DPS 0x10 //Giroscopio
//Se define los pines de los sensores a
usar #define int gx, gy, gz;
GYRO_FULL_SCALE_2000_DPS 0x18
#define SENSOR 4 long tiempo_prev, dt;
//Magnetometro
#define TRIGGER_PIN 39 float
#define MAG_ADDRESS 0x0C giroscopio_ang_x,giroscopio_ang_y,gi
#define ECHO_PIN 37 roscopio_ang_z;

#define MAX_DISTANCE 200 float


//A partir de esta seccion se declaran giroscpopio_ang_x_prev,giroscpopio_
#define MPU9250_ADDRESS 0x68
las variables a usar en el programa ang_y_prev,giroscpopio_ang_z_prev;
//Variables de los diferentes sensores lcd.setCursor(0, 1); // ubicamos digitalWrite(12,1);
posicion a partir de donde se va a
int Te; escribir (columna =0, fila=1) return (1);

int Hu; lcd.print("PIA"); //Se imprime el }


nombre
int US; digitalWrite(12,0);
delay(2500); //Esperamos 2500 ms.
float LAT;
lcd.clear(); // comando para limpiar
float LON; //Muestra de menu en el celular via
texto.
BT
int ALT;
//Acelerometro
Serial1.println("Inicializando SD");
float VEL;
I2CwriteByte(MPU9250_ADDRESS,
Serial1.println("Bienvenido");
//Se definen el nombre de nuestros 28 ,ACC_FULL_SCALE_2_G);
dispositivos para usar sus comandos Serial1.println("Para mostrar el valor
Serial.print(" AX: ,"); Serial.print("
predetermiandos de LDR presione 1");
AY: ,"); Serial.println(" AZ: ,");
TinyGPSPlus gps; Serial1.println("Para mostrar la
//Giroscopio
temperatura presione 2");
DHT dht(SENSOR, DHT11); // objeto
dht del tipo DHT en pin 4 y modelo Serial1.println("Para mostrar la
DHT11 I2CwriteByte(MPU9250_ADDRESS,27, humedad presione 3");
GYRO_FULL_SCALE_250_DPS);
LiquidCrystal_I2C lcd(0x27, 16, 2); Serial1.println("Para mostrar el valor
//definimos la direccion del //Magnetometro del ultrasonico presione 4");
dispositivo I2C = 0x27 , caracteres =
16 , lineas = 2 Serial1.println("Para mostrar la
I2CwriteByte(MPU9250_ADDRESS,0x latitud presione 5");
NewPing sonar(TRIGGER_PIN, 37,0x02);
ECHO_PIN, MAX_DISTANCE); Serial1.println("Para mostrar la
longitud presione 6");

I2CwriteByte(MAG_ADDRESS,0x0A,0x Serial1.println("Para mostrar la


//Inicia la funcion Setup,ejecucion de 16); altitud presione 7");
1 vez al iniciar el programa
Serial1.println("Para mostrar la
void setup() { velocidad presione 8");
while (!Serial or !Serial1) {
// Se empieza la comunicacion serial Serial1.println("Para mostrar la
y se espera hasta que esta este ; // Espera a que el serial este aceleracion en x presione a");
disponible: disponible
Serial1.println("Para mostrar la
Serial.begin(9600); } aceleracion en y presione b");

Serial1.begin(9600); Serial1.println("Para mostrar la


aceleracion en z presione c");
Serial2.begin(9600); pinMode(12,OUTPUT);
Serial1.println("Para mostrar la
Wire.begin(); Serial1.println("Inicializando SD inclinacion en x presione d");
card...");
lcd.init(); // iniciamos LCD Serial1.println("Para mostrar la
Serial.println("Inicializando SD inclinacion en y presione e");
lcd.backlight(); // encendemos card...");
backlight Serial1.println("Para mostrar el giro
en x presione f");
lcd.setCursor(0, 0); // ubicamos
posicion a partir de donde se va a // Checa si la SD esta disponible Serial1.println("Para mostrar el giro
escribir (columna =0 , fila=0) en y presione g");
if (!SD.begin(chipSelect)) {
lcd.print("SISELA"); // primer Texto a Serial1.println("Para mostrar el giro
imprimir "SISELA" Serial1.println("SD NO PRESENTE");
en z presione h");
Serial.println("SD NO PRESENTE");
Serial1.println("Para mostrar el
// No se realiza alguna accion: magnetrometro en x presione i");
Serial1.println("Para mostrar el //Calculo del angulo de inclinacion //Lee el dato del magnetometro
magnetrometro en y presione j"); en X e Y con respecto al acelerometro
uint8_t Mag[7];
Serial1.println("Para mostrar el float
magnetrometro en z k"); accel_ang_x=atan(ax/sqrt(pow(ay,2)
+ pow(az,2)))*(180.0/3.14); I2Cread(MAG_ADDRESS,0x03,7,Mag);

Serial.println("LDR,Temperatura,Hum float //Se crean las variables de la funcion


edad,Ultrasonico,Latitud,Longitud,Alti accel_ang_y=atan(ax/sqrt(pow(ax,2) del magnetometro
tud,Velocidad,Ax,Ay,Az,IncX,IncY,Giro + pow(az,2)))*(180.0/3.14);
int16_t mx =-(Mag[3]<<8 | Buf[2]);
X,GiroY,GiroZ,Mx,My,Mz");
//Variables de la funcion del
giroscopio int16_t my =-(Mag[1]<<8 | Buf[0]);
File dataFile =
SD.open("DATOS.txt", FILE_WRITE); int16_t mz =-(Mag[5]<<8 | Buf[4]);
int16_t gx = -(Buf[8]<<8 | Buf[9]);

int16_t gy = -(Buf[10]<<8 | Buf[11]);


// Si el archivo esta disponible //Comandos para la impresion de
int16_t gz = Buf[12]<<8 | Buf[13];
escribe: datos
//Angulos de giro (funcion del
if (dataFile) { //Conexion en conjunto con el display
giroscopio)
para la muestra de resultados.
dataFile.println("LDR, Temperatura,
dt=millis()-tiempo_prev;
Humedad, Ultrasonico, Latitud, if(Serial1.available()){
Longitud, Altitud, Velocidad"); tiempo_prev=millis();
comando = Serial1.read(); }
dataFile.close();} giroscopio_ang_x=
((gx/131)*dt)/1000.0
}
+giroscpopio_ang_x_prev;
if( comando == '1'){
giroscopio_ang_y=
//Inicia la funcion LOOP, ejecucion de ((gy/131)*dt)/1000.0 Serial1.println(comando);
codigo continuo hasta que se vea +giroscpopio_ang_y_prev;
Serial1.println(analogRead(1));
interrumpia por el encendido,
giroscopio_ang_z=
apagado o reset. x = 1;
((gz/131)*dt)/1000.0
void loop() { +giroscpopio_ang_z_prev;
}

//Se crea un buffer de 6 posiciones if( comando == '2'){


giroscpopio_ang_x_prev=giroscopio_
uint8_t Buf[6]; ang_x; Serial1.println(comando);

//Lectura del void

I2Cread(MPU9250_ADDRESS, 0x3B, giroscpopio_ang_y_prev=giroscopio_ Serial1.println(dht.readTemperature()


6, Buf); ang_y; );

//Variables de la funcion del x = 2;


acelerometro giroscpopio_ang_z_prev=giroscopio_ }
ang_z;
int16_t ax = -(Buf[0]<<8 | Buf[1]);
if( comando == '3'){
//Inica la funcion del magnetometro
int16_t ay = -(Buf[2]<<8 | Buf[3]);
Serial1.println(comando);
uint8_t ST1;
int16_t az = Buf[4]<<8 | Buf[5];
Serial1.println(dht.readHumidity());
do{
//Calculo de la aceleracion en m/s^2
x = 3;
float AX =
I2Cread(MAG_ADDRESS,0x02,1,&ST1) }
9.81*ax/SensitivityScaleFactor;
;
if( comando == '4'){
float AY =
9.81*ay/SensitivityScaleFactor; }
Serial1.println(comando);
float AZ = while(!(ST1&0x01));
Serial1.println(sonar.ping_cm());
9.81*az/SensitivityScaleFactor;
x = 4; Serial1.println(AZ,5); Serial1.println(comando);

} x = 11; Serial1.println(my-70,DEC);

if( comando == '5'){ } x = 18;

Serial1.println(comando); if( comando == 'd'){ }

Serial1.println(gps.location.lat()); Serial1.println(comando); if( comando == 'k'){

x = 5; Serial1.println(accel_ang_x); Serial1.println(comando);

} x = 12; Serial1.println(mz-700,DEC);

if( comando == '6'){ } x = 19;

Serial1.println(comando); if( comando == 'e'){ }

Serial1.println(gps.location.lng()); Serial1.println(comando);

x = 6; Serial1.println(accel_ang_y); //Seccion de impresion de datos en el


display
} x = 13;
//Conecion en conjunto con el BT
if( comando == '7'){ } para la aplicacion de comandos al
momento de mostrar los resultados.
Serial1.println(comando); if( comando == 'f'){
if( x == 1){
Serial1.println(comando);
Serial1.println(gps.altitude.meters()); lcd.clear();
Serial1.println(giroscopio_ang_x);
x = 7; lcd.setCursor(0,0);
x = 14;
} lcd.print("LDR:");
}
if( comando == '8'){ lcd.setCursor(4,0);
if( comando == 'g'){
Serial1.println(comando); lcd.print(analogRead(1));}
Serial1.println(comando);
Serial1.println(gps.speed.kmph()); if( x == 2){
Serial1.println(giroscopio_ang_y);
x = 8; lcd.clear();
x = 15;
} lcd.setCursor(0,0);
}
if( comando == 'a'){ lcd.print("Temperatura:");

Serial1.println(comando); lcd.setCursor(12,0);
if( comando == 'h'){
Serial1.println(AX,5); lcd.print(dht.readTemperature());
Serial1.println(comando);
x = 9; lcd.setCursor(15,0);
Serial1.println(giroscopio_ang_z);
} lcd.print("C");}
x = 16;
if( comando == 'b'){ if( x == 3){
}
Serial1.println(comando); lcd.clear();
if( comando == 'i'){
Serial1.println(AY,5); lcd.setCursor(0,0);
Serial1.println(comando);
x = 10; lcd.print("Humedad:");
Serial1.println(mx+200,DEC);
} lcd.setCursor(8,0);
x = 17;
if( comando == 'c'){ lcd.print(dht.readHumidity());}
}
Serial1.println(comando); if( x == 4){
if( comando == 'j'){
lcd.clear(); lcd.print("Ax:"); lcd.setCursor(0,1);

lcd.setCursor(0,0); lcd.setCursor(0,1); lcd.print(giroscopio_ang_x);

lcd.print("Ultrasonico:"); lcd.print(AX,5); }

lcd.setCursor(12,0); } if( x == 15){

lcd.print(sonar.ping_cm()); if( x == 10){ lcd.clear();

lcd.setCursor(15,0); lcd.clear(); lcd.setCursor(0,0);

lcd.print("cm");} lcd.setCursor(0,0); lcd.print("GiroY:");

if( x == 5){ lcd.print("Ay:"); lcd.setCursor(0,1);

lcd.clear(); lcd.setCursor(0,1); lcd.print(giroscopio_ang_y);}

lcd.setCursor(0,0); lcd.print(AY,5); if( x == 16){

lcd.print("Latitud:"); } lcd.clear();

lcd.setCursor(0,1); if( x == 11){ lcd.setCursor(0,0);

lcd.print(gps.location.lat(), 6);} lcd.clear(); lcd.print("GiroZ:");

if( x == 6){ lcd.setCursor(0,0); lcd.setCursor(0,1);

lcd.clear(); lcd.print("Az:"); lcd.print(giroscopio_ang_z);

lcd.setCursor(0,0); lcd.setCursor(0,1); }

lcd.print("Longitud:"); lcd.print(AZ,5); } if( x == 17){

lcd.setCursor(0,1); if( x == 12){ lcd.clear();

lcd.print(gps.location.lng(), 6);} lcd.clear(); lcd.setCursor(0,0);

if( x == 7){ lcd.setCursor(0,0); lcd.print("MagX:");

lcd.clear(); lcd.print("IncX:"); lcd.setCursor(0,1);

lcd.setCursor(0,0); lcd.setCursor(0,1); lcd.print(mx+200,DEC);

lcd.print("Altitud:"); lcd.print(accel_ang_x); }

lcd.setCursor(0,1); } if( x == 18){

lcd.print(gps.altitude.meters());} if( x == 13){ lcd.clear();

if( x == 8){ lcd.clear(); lcd.setCursor(0,0);

lcd.clear(); lcd.setCursor(0,0); lcd.print("MagY:");

lcd.setCursor(0,0); lcd.print("IncY:"); lcd.setCursor(0,1);

lcd.print("Velocidad:"); lcd.setCursor(0,1); lcd.print(my-70,DEC);

lcd.setCursor(0,1); lcd.print(accel_ang_y); }

lcd.print(gps.speed.kmph()); } if( x == 19){

} if( x == 14){ lcd.clear();

if( x == 9){ lcd.clear(); lcd.setCursor(0,0);

lcd.clear(); lcd.setCursor(0,0); lcd.print("MagZ:");

lcd.setCursor(0,0); lcd.print("GiroX:"); lcd.setCursor(0,1);


lcd.print(mz-700,DEC);} dataString += ","; Serial.println(dataString);

dataString += String(AX,5); }

// En esta seccion se realiza un dataString += ","; // Si el archivo no esta disponible,


arreglo para la impresion de todos los muestre un error:
datos como un conjunto dataString += String(AY,5);
else {
String dataString = ""; dataString += ",";
Serial.println("error opening
while (Serial2.available() > 0) // dataString += String(AZ,5); datalog.txt");
MIENTRAS SE ENCUENTRE
dataString += ","; Serial1.println("error opening
DISPONIBLE EL CANAL SERIAL1,
ENLACE DEL SHIELD... datalog.txt");
dataString += String(accel_ang_x);
if (gps.encode(Serial2.read())) }
dataString += ",";
String dataString = ""; }
dataString += String(accel_ang_y);
int A1 = analogRead(1); dataString += ",";
dataString += String(A1); //Funcion auxiliar de lectura del MPU
dataString +=
String(giroscopio_ang_x); void I2Cread(uint8_t Address, uint8_t
dataString += ",";
Register, uint8_t Nbytes, uint8_t*
dataString += ",";
int Te = dht.readTemperature(); Data)
dataString +=
dataString += String(Te); {
String(giroscopio_ang_y);
dataString += ","; Wire.beginTransmission(Address);
dataString += ",";
int Hu = dht.readHumidity(); Wire.write(Register);
dataString +=
dataString += String(Hu); String(giroscopio_ang_z); Wire.endTransmission();

dataString += ","; dataString += ","; Wire.requestFrom(Address, Nbytes);

int US = sonar.ping_cm(); dataString += String(mx+200,DEC); uint8_t index = 0;

dataString += String(US); dataString += ","; while(Wire.available())

dataString += ","; dataString += String(my-70,DEC); Data[index++] = Wire.read();

float LAT = gps.location.lat(); dataString += ","; }

dataString += String(LAT, 6); dataString += String(mz-700,DEC);

dataString += ","; //Funcion auxiliar de escritura del


MPU
float LON = gps.location.lng(); // Abre el archivo (recuerde cerrar si
hay un archivo abierto previo) void I2CwriteByte(uint8_t Address,
dataString += String(LON, 6); uint8_t Register, uint8_t Data)
File dataFile = SD.open("DATOS.txt",
dataString += ","; {
FILE_WRITE);
int ALT = gps.altitude.meters(); Wire.beginTransmission(Address);
// Si es archivo esta disponible
guarde los datos:
dataString += String(ALT, 6); Wire.write(Register);
if (dataFile) {
dataString += ","; Wire.write(Data);
dataFile.println(dataString);
float VEL = gps.speed.kmph(); Wire.endTransmission();
dataFile.close();
dataString += String(VEL); }
// Impresion en el monotior serial :
Anexo una ss de los datos obtenidos

Conclusiones

Podemos concluir que nuestra simulación de una caja negra es buena, pero nada comparada a las
que se usan en aeronaves. Ya que sus componentes son mucho más precisos y avanzados y la gran
diferencia son los materiales con los que están hechas. Nuestra caja negra podrá mantener su
estructura en una caída pequeña, en cambio una real deberá resistir la caída de un avión.
Podríamos hacer una mejor simulación si contáramos con el tiempo, materiales y componentes
necesarios para hacer una de mejor calidad.

También podría gustarte