Вы находитесь на странице: 1из 6

Control de nivel de agua con ultrasonido

Tanque de agua de nivel de visualización con Arduino

Tanque de agua de nivel de visualización con Arduino


Se presenta la candidatura del Sr. Danilo Abbasciano que se propone para
la realización del firmware para el proyecto TiDiGino y que nos presenta una
aplicación con Arduino: Muestra el nivel de un tanque.

El proyecto de lectura y visualización de la altura del nivel del agua en un


pozo o una cisterna.
Vamos a utilizar el Arduino de código abierto de dispositivos de hardware,
un sensor ultrasónico para medir la paralaje de la altura del agua, un 16 x 2
con pantalla LCD Hitachi HD44780 conductor y un zumbador que se
activará cuando el nivel supera el umbral.

El proyecto, como ya hemos mencionado, se compone de varias partes. Un


sensor de sonar para ser colocado en la parte superior del pozo (a una
distancia segura desde el nivel del agua) que apunta hacia abajo con el fin
de medir la distancia entre el punto de colocación (en nuestro caso, el punto
más alto del pozo) y la superficie del agua . Tomando una simple diferencia
entre cantidades conocidas: la distancia entre el fondo y la medición de leer
desde el sensor, se obtiene la altura de la superficie del agua. Conociendo
la superficie del pozo también es fácil calcular el volumen de agua presente.
A intervalos predeterminados Arduino lee las distancias y muestra la altura y
el volumen de agua en el pozo.

Hay una barra horizontal que muestra la tendencia en el nivel relativo de


agua dentro del pozo para una fácil e inmediata lectura.

Si el nivel excede un umbral de advertencia primero provocó el timbre de


alarma para que suene poco a poco si el nivel excede el umbral del segundo,
que aumenta la frecuencia de llamada hasta que el nivel se reducirá por debajo
del umbral o cuando manualmente desactivar el timbre a través de un botón.

Arduino controla la lógica de funcionamiento, utilizando los dibujos


siguientes:

/ * -*- Mode: c -*- * /


/ **
* Pozzo.pde
* Versión: 1.2
* /

# Include

# Define PING_PIN 13
# Define BUZZER_PIN 8
# Define SWITCH_INT 0 / * 0 => el pin 2 * /
# Define PI 3.1415926535898
# Define SUPERFICE_BASE (R_POZZO R_POZZO * * PI)
# Define SIZE_BAR (16 * 5)
# Define ALARM_ICON 0 / * código * /
# Define SOUND_ICON 6 / * código * /
# Define SOUND_ICON_ON 7 / * código * /

# Define R_POZZO 0,5 / * Raggio Pozzo (m) * /


# Define H_POZZO 146,0 / cm * * /
# Define SOGLIA_ALLARME_1 100 / * * cm /
# Define SOGLIA_ALLARME_2 120 / * * cm /
# Define DELAY_0 60000 / * m, 1000 * 60 * 1 = 1 min * /
# Define DELAY_1 600 / * ms * /
# Define DELAY_2 200 / * ms * /

/ * Inicializar la biblioteca con los números de los pines de la interfaz * /


LiquidCrystal LCD (12, 11, 5, 4, 3, 6);

int mute = 0;

byte * getChar (int n, byte newChar []) {


int i;
código byte [5] = {
B10000,
B11000,
B11100,
B11110,
B11111};

for (i = 0; i <8; i + +)
newChar [i] = código [n - 1];
volver newChar;
}

void setup () {
int i;
float h;
newChar byte [8];

/ * Establecer el número de la pantalla LCD de filas y columnas: * /


lcd.begin (16, 2);

for (i = 1; i <6; i + +)
lcd.createChar (i, getchar (i, newChar));

newChar = {
B00000,
B00100,
B01010,
B01010,
B11111,
B00100,
B00000,
};

lcd.createChar (ALARM_ICON, newChar);

newChar = {
B00011,
B00101,
B11001,
B11001,
B11001,
B00101,
B00011,
};

lcd.createChar (SOUND_ICON, newChar);

newChar = {
B00100,
B10010,
B01001,
B01001,
B01001,
B10010,
B00100,
};

lcd.createChar (SOUND_ICON_ON, newChar);

pinMode (BUZZER_PIN, OUTPUT);

/ **
* BAJA para activar la alarma cada vez que el pin es baja,
* CHANGE para activar la alarma cada vez que cambia el valor pin
* Llegando a desencadenar cuando el pasador va de bajo a alto,
* La caída de cuando el pasador va de mayor a menor.
* /
attachInterrupt (SWITCH_INT, un botón, en aumento);

/ * Inicializar la comunicación serial * /


Serial.begin (9600);
}

void loop () {
hWatherCm largo plazo;
int litros;

hWatherCm read_height = ();


if (check_alarm (hWatherCm)! = 0) / * lee la altura de nuevo wather * /
hWatherCm read_height = ();
lcd.clear ();

print_histogram (hWatherCm);

lcd.setCursor (0, 1);

lcd.print (hWatherCm);
lcd.print ("cm -");

/ / Litros = SUPERFICE_BASE * (hWather / 100,0) * 1000


l = piso (SUPERFICE_BASE * hWatherCm * 10);
lcd.print (litros);
lcd.print ("l");

lcd.setCursor (14, 1);


lcd.write (SOUND_ICON);
lcd.setCursor (15, 1);
if (! silencio)
lcd.write (SOUND_ICON_ON);
más
lcd.write ('X');

/ *
Serial.print ("cm =");
Serial.println (hWatherCm);
* /

switch (check_alarm (hWatherCm)) {


Caso 1:
lcd.setCursor (0, 0);
lcd.write (ALARM_ICON);

zumbido (200);
delay (DELAY_1);
break;

Caso 2:
lcd.setCursor (0, 0);
lcd.write (ALARM_ICON);

zumbido (200);
retraso (200);
zumbido (200);
delay (DELAY_2);
break;

case 0: / / no hay ninguna alarma


delay (DELAY_0);
}
}

print_histogram void (int hWatherCm) {


int i;
bloks int;
flotan histograma;

/ / HWatherCm: HPOZZO histograma =: SIZE_BAR


histograma = (* SIZE_BAR hWatherCm) / H_POZZO;
histograma histograma + = 0.5;

bloks = (int) histograma / 5;

for (i = 0; i
lcd.write (5);

if ((int) (histograma)% 5> 0)


lcd.write ((int) (histograma) del 5%);
}

read_height tiempo () {
/ **
* Establecer las variables de duración de la mesa de ping,
* Y el resultado distancia en centímetros:
* /
larga duración, hWatherCm;

/ **
* El PING))) es provocada por un pulso de alta de 2 o más microsegundos.
* Dar un pulso BAJO corto de antemano para asegurar un pulso de alta limpia:
* /
pinMode (PING_PIN, OUTPUT);
digitalWrite (PING_PIN, LOW);
delayMicroseconds (2);
digitalWrite (PING_PIN, HIGH);
delayMicroseconds (5);
digitalWrite (PING_PIN, LOW);

/ **
* El mismo pin se utiliza para leer la señal del PING))): un alto
* Pulso cuya duración es el tiempo (en microsegundos) a partir del envío
* De la mesa de ping a la recepción de su eco fuera de un objeto.
* /
pinMode (PING_PIN, INPUT);
= duración PulseIn (PING_PIN, HIGH);

/ * Convertir el tiempo en una distancia * /


hWatherCm = H_POZZO - microseconds_to_centimeters (duración);

if (hWatherCm <0)
return 0;

if (hWatherCm> H_POZZO)
volver H_POZZO;

volver hWatherCm;
}

vacío buzz (int ms) {


if (! silencio)
digitalWrite (BUZZER_PIN, HIGH);
delay (ms);
digitalWrite (BUZZER_PIN, LOW);
}

int check_alarm (int hWatherCm) {


if (hWatherCm> SOGLIA_ALLARME_1) {
if (hWatherCm<soglia_allarme_2)</soglia_allarme_2)
return 1;
más
retorno de 2;
}
return 0;
}

microseconds_to_centimeters tiempo (microsegundos tiempo) {


/ **
* La velocidad del sonido es 340,29 m / s, o 29,4 microsegundos por centímetro.
* El ping viaja de ida y vuelta, así que para encontrar la distancia de la
* Objeto que tomar la mitad de la distancia recorrida.
* /
volver microsegundos / 29.387 / 2;
}

botón vacío () {
/ / Serial.println ("Pulsante premuto");
mute = silencio!;

lcd.setCursor (15, 1);


if (! silencio)
lcd.write (SOUND_ICON_ON);
más
lcd.write ('X');
}