No uses el tipo boolean para un dato entero. En todo caso podrías usar el tipo de dato byte.
Boolean, teóricamente, solo maneja dos valores: 1) true (cualquier valor distinto de cero se considera true) y 2) false (se representa internamente por cero). En la conversión automática de tipos, algún compilador puede hacer algo raro con los valores de los datos distintos de cero.
Si lo que quieres es ahorrar memoria, no necesitarás usar variables globales, que van a reservar memoria desde que empieza el programa hasta que termine. Lo que en realidad quieres hacer es una simple asociación de identificadores y valores que puede conseguirse usando macros. Eso no consume memoria.
Código:
#define nivel_minimo 3
#define nivel_relleno 2
#define nivel_maximo 1
#define rele_vaciado 4
#define rele_llenado 5
#define pulsador_cambio 6
Para estos identificadores de macros suele preferirse el uso de identificadores en mayúsculas.
Si solo se van a usar dentro de una función otra cosa que podrías hacer es declarar las variables como locales. De esta forma, terminada la función loop(), las variables desaparecen y se recupera el espacio que estaban ocupando en la memoria.
Código:
void setup ()
{
boolean nivel_minimo=3;
boolean nivel_relleno =2;
boolean nivel_maximo=1;
boolean rele_vaciado=4;
boolean rele_llenado=5;
boolean pulsador_cambio=6;
pinMode (nivel_minimo, INPUT);
pinMode (nivel_relleno, INPUT);
pinMode (nivel_maximo, INPUT);
pinMode (rele_vaciado, OUTPUT);
pinMode (rele_llenado, OUTPUT);
pinMode (pulsador_cambio, INPUT);
}
void loop ()
{
{
if (digitalRead (nivel_relleno==HIGH && nivel_maximo==LOW));
{
digitalWrite (rele_llenado, LOW);
if (digitalRead (nivel_relleno==HIGH && nivel_maximo==HIGH));
{
digitalWrite (rele_llenado, HIGH);
if (digitalRead (nivel_relleno==HIGH && nivel_maximo==LOW));
{
digitalWrite (rele_llenado, HIGH);
if (digitalRead (nivel_relleno==LOW && nivel_maximo==LOW));
{
digitalWrite (rele_llenado, LOW);
}}}}
}
}
void cambio ()
{
if (digitalRead (pulsador_cambio==HIGH && nivel_minimo==LOW)); //Si pulso el interuptor de cambio y el sensor de nivel minimo indica que el nivel esta correcto
{digitalWrite (rele_vaciado, HIGH); // se activa el relé de la bomba
}
if (digitalRead (nivel_minimo==HIGH)); // cuando el sensor de nivel minimo indica que el nivel esta en el minimo
{digitalWrite (rele_vaciado, LOW); } //cesara el vaciado ¿pero no tengo claro que pasaria? ¿si volveria al void loop?
}
Dado que internamente los ordenadores trabajan con bytes o con combinaciones de varios bytes, el dato boolean, se implementará en un Arduino de 8 bits con un byte por razones de eficielcia. Ningún tipo de dato ocupará menos de un byte. El tamaño de un tipo de datos es siempre un numero de bytes y este tamaño puede ser preguntado en el programa mediante la función sizeof().
sizeof(int) devolverán. (2 bytes).
sizeof(char), sizeof(boolean), o sizeof(byte) devolveran 1. (1 byte).
Puedes ejecutar el código siguiente y algunos de los tipos de datos ocuparan distinto tamaño en un Arduino de 8 bits (Arduino UNO) que en uno de 32 bits (Arduino DUE).
Código:
void loop() {
Serial.print("sizeof(byte)="); Serial.println(sizeof(byte));
Serial.print("sizeof(char)="); Serial.println(sizeof(char));
Serial.print("sizeof(short)="); Serial.println(sizeof(short));
Serial.print("sizeof(int)="); Serial.println(sizeof(int));
Serial.print("sizeof(long)="); Serial.println(sizeof(long));
Serial.print("sizeof(long long)="); Serial.println(sizeof(long long));
Serial.print("sizeof(bool)="); Serial.println(sizeof(bool));
Serial.print("sizeof(boolean)="); Serial.println(sizeof(boolean));
Serial.print("sizeof(float)="); Serial.println(sizeof(float));
Serial.print("sizeof(double)="); Serial.println(sizeof(double));
Serial.print("sizeof(int8_t)="); Serial.println(sizeof(int8_t));
Serial.print("sizeof(int16_t)="); Serial.println(sizeof(int16_t));
Serial.print("sizeof(int32_t)="); Serial.println(sizeof(int32_t));
Serial.print("sizeof(int64_t)="); Serial.println(sizeof(int64_t));
Serial.print("sizeof(uint8_t)="); Serial.println(sizeof(uint8_t));
Serial.print("sizeof(uint16_t)="); Serial.println(sizeof(uint16_t));
Serial.print("sizeof(uint32_t)="); Serial.println(sizeof(uint32_t));
Serial.print("sizeof(uint64_t)="); Serial.println(sizeof(uint64_t));
Serial.print("sizeof(char*)="); Serial.println(sizeof(char*));
Serial.print("sizeof(int*)="); Serial.println(sizeof(int*));
Serial.print("sizeof(long*)="); Serial.println(sizeof(long*));
Serial.print("sizeof(float*)="); Serial.println(sizeof(float*));
Serial.print("sizeof(double*)="); Serial.println(sizeof(double*));
Serial.print("sizeof(void*)="); Serial.println(sizeof(void*));
Serial.println();
delay(5000);
}
![[Imagen: Mosfet-conexion-logic-level.png]](http://www.inventable.eu/media/EduPaginas/Mosfet/Mosfet-conexion-logic-level.png)
) funcionaba perfectamente. Y ha sido al intentar dejarlo en marcha ya con el montaje final cuando veo que se vuelve loco con la repetición de los botones.