Medición de la velocidad de flujo de advección de calor
Para el curso "Meten agua de aan" (TU Delft), hemos hecho un dispositivo para medir la velocidad de flujo de advección de agua caliente. En este artículo describimos cómo hicimos el dispositivo y cómo el arduino se utiliza para medir la velocidad de flujo. La medición se basa en la suposición de que el pico de temperatura de la agua caliente advección se desplazará a la misma velocidad que el agua.
¿Cómo construir el dispositivo?
Para hacer este instrumento necesita un arduino (utilizamos: UNO), dos sensores de temperatura (TMP 36), una placa arduino, algunos cables y (opcional) una pantalla LCD. El primer paso es hacer tu temperatura sensores prueba del agua, que necesita para asegurarse de que la "cabeza" del sensor estará en contacto con el agua. Luego construir algo para fijar los dos sensores de temperatura, a la misma profundidad y el mismo lugar en el agua. Utilizamos un trozo de madera con dos orificios en él. La profundidad de los sensores de temperatura es seis centímetros por debajo de la superficie del agua. La distancia entre los sensores de temperatura es de 10 cm en la dirección de la corriente.
El siguiente paso es conectar los sensores de temperatura con el arduino, el + y - están conectados a 5V y el puerto GND del arduino y el tercer cables (medida) de ambos sensores están conectados a A0 y A1, A0 es de la A1 y upstream sensor para sensor de aguas abajo.
El código de
El código se basa en ejemplos de Arduino > 01 fundamentos > ReadAnalogVoltage.
El código que necesita para ejecutar se escribe debajo de este artículo, se puede utilizar con o sin la pantalla LCD. Si no utiliza la pantalla LCD se pueden leer las mediciones en el monitor serial del programa de arduino.
El código toma el promedio de cinco mediciones para ambos sensores y luego prueba si la media es el promedio más alto hasta ahora, si esto es cierto recuerda el tiempo. El código hace para ambos sensores, y luego calcula la diferencia de tiempo (t2 - t1). Con la distancia conocida entre los sensores y la diferencia de tiempo se calcula la velocidad de flujo.
La medición de
Cuando construyes el dispositivo y cargar el código, puede empezar a medir. Puede utilizar una caldera de agua de la ola de calor. Los siguientes pasos deben hacerse para cada medida:
1. Presione el botón de reset en su arduino;
2. Coloque una cantidad de agua caliente en la corriente (corriente arriba) que desea medir;
3. el arduino devuelve la velocidad de flujo cuando la ola de calor todo ha volado por.
La cantidad de agua que se aplicó fue de 25 ml, y la distancia aguas arriba del primer sensor de temperatura fue de 0,75 metros (Esto funcionó para nosotros pero para corriente podría ser diferente, así que pruebe diferentes distancias y cantidades de agua).
Fecha: 26/11/2014
Autores:
Ludo Schuurman
Daan Houtzager
El código de arduino:
/*
Utilizamos: ReadAnalogVoltage, entonces escribió un nuevo código para medir la velocidad de flujo de advección de calor.
*/
#include < LiquidCrystal.h > / * aquí se definen las variables * /
LiquidCrystal lcd(12,11,5,4,3,2);
dt del flotador = 0; / * dt es el tiempo entre t2 en t1 * /
medición del flotador = 0; / * medición = velocidad de flujo (u) * /
ONU del flotador = 0; / * las Naciones Unidas son la velocidad de flujo nuevo * /
flotador de mn2 = 0; / * es la nueva media para sensor 2 * /
flotador de u = 0; / * u es la velocidad de flujo * /
Float mean_new = 0; / * mean_new es la nueva media para sensor 1 * /
Float t1 = 0; / * t1 es el tiempo de la media más alta del sensor 1 * /
flotador de t2 = 0; / * t2 es el tiempo de la media más alta del sensor 2 * /
void setup() {}
Serial.Begin(9600);
LCD.Begin (16, 2);
LCD.Print ("snelheid [m/s]");
}
void loop() {}
int sensorValue1 = analogRead(A0); / * Aquí el código lee el sensor de entrada * /
Float v1 = sensorValue1 * (5.0 / 1023.0); / * Aquí el sensor de entrada se convierte a la tensión /
Delay(50); / * la demora es necesaria para convertir de A0 a la A1 /
sv1 int = analogRead(A1); / * 5 mediciones se realizan como se indica arriba para cada sensor * /
flotador v21 = sv1 * (5.0 / 1023.0);
Delay(50);
int sensorValue12 = analogRead(A0);
Float v2 = sensorValue12 * (5.0 / 1023.0);
Delay(50);
sv2 int = analogRead(A1);
flotador v22 = sv2 * (5.0 / 1023.0);
Delay(50);
int sensorValue13 = analogRead(A0);
flotador v3 = sensorValue13 * (5.0 / 1023.0);
Delay(50);
sv3 int = analogRead(A1);
flotador de v23 = sv3 * (5.0 / 1023.0);
Delay(50);
int sensorValue14 = analogRead(A0);
flotador v4 = sensorValue14 * (5.0 / 1023.0);
Delay(50);
sv4 int = analogRead(A1);
v24 del flotador = sv4 * (5.0 / 1023.0);
Delay(50);
int sensorValue15 = analogRead(A0);
flotador v5 = sensorValue14 * (5.0 / 1023.0);
Delay(50);
sv5 int = analogRead(A1);
flotador de v25 = sv5 * (5.0 / 1023.0);
flotador mean1 = (v1 + v2 + v3 + v4 + v5) / 5.0; / * Aquí se calcula la media de las cinco mediciones por sensor 1 * /
flotador de m2 = (v21 v22 v23 + v24 + v25) / 5.0; / * Aquí se calcula la media de las cinco mediciones por sensor 2 * /
Delay(100);
Si (mean1 > mean_new) {/ * en el if, loop la media se comprueba mean1 > mean_new * /
mean_new = mean1;
T1 = millis(); / * Si el medio es el más alto hasta el momento se almacena en t1 * /
Serial.println("time1");
Serial.println(T1);
}
Si (m2 > mn2) {/ * igual que el anterior pero para el sensor 2 * /
Mn2 = m2;
T2 = millis();
Serial.println("time2");
Serial.println(T2);
}
Si (t2 > t1) {/ * cuando la ola de calor es grande ambos medios están aumentando al mismo tiempo, para el t2 de pico debe ser mayor que el t1 /
DT = (t2-t1/1000/1000); / * se calcula dt * /
u = (0, 1/dt); / * se calcula la velocidad de flujo * /
Serial.println(u); / * la velocidad de flujo se imprime en el serial monitor * /
Si (u < ONU + 0, 5) {/ * el tiempo de adaptación para la medida es grande, esto coloca filtros altos valores de ustedes que no son real * /
Si (u < 100) {/ * esto si declaración filtra u's alto en el tiempo de adaptación * /
ONU = u; medición = u;
}
}
lcd.setCursor(0,1);
LCD.Print(Measurement); / * la velocidad de flujo se imprime en la pantalla * /
} }
