Aumentar el número de entradas en Arduino

Cuando vamos avanzando con la programación de Arduino, poco a poco se nos va quedando pequeño en cuanto al número de entradas / salidas que tiene nuestra placa. Si este es tu problema, con esta técnica podrás tener un gran número de entradas y así liberar pines para utilizarlos como salidas.

El "truco" consiste en utilizar las entradas analógicas de Arduino (A0 y A1) y construir un divisor de tensión con tantas resistencias como entradas quieras tener.  Aunque esto tiene un límite como veremos más adelante.

Vamos a hacer un ejemplo concreto: digamos que queremos añadir tres pulsadores a nuestro código pero ya no nos queda ningún pin de entrada/salida libre y tenemos la entrada analógica A0 sin utilizar. Nos crearemos nuestro divisor de tensión tal que así:

La resistencia R1 es una resistencia de pull-up que nos permitirá llevar a Vcc (5V) cuando ninguno de nuestros pulsadores esté activo y así no dejar la entrada A0 del Arduino "al aire". Luego conectamos R2 y R3 en serie. Para el cálculo de estas resistencias sólo hay que seguir los cálculos tal y como explicaré a continuación (son muy facilillos):

,donde VA0 es la tensión que va a leer el convertidor analógico/digital de Arduino en su entrada A0 y Rt es la suma de todas las resistencias conectadas en serie para cada uno de los casos (desde R1 a Rn).

Intentaremos dar valores de resistencias que nos permitan (ya que tenemos margen) tener aproximadamente 1 voltio de diferencia entre dos pulsadores consecutivos. Por ejemplo, que si pulso  S2 y en VA0 tengo 1.5V, pues que al pulsar S3 tenga unos 2.5V como mínimo en ess mismo punto. En vez de hacerlo dando valores de resistencias "a ojo", lo que podéis hacer es fijar R1 a 2,2k o superior y despejar de la fórmula anterior R2 y R3 para cada caso decidiendo vosotros el voltaje (entre 0 y 5V claro está) que debería ser leído en cada caso. Por ejemplo, digamos que yo quiero que al pulsar S2 arduino lea 2V y cuando pulse S3 lea 4V. Os lo dejo aquí abajo ya despejado:

Vamos a darles unos valores comerciales ya que no nos importa mucho si nos desviamos un poco de esos 2 y 4V que queríamos leer al pulsar cada botón. Por lo que:

Para saber exactamente qué tensión leerá Arduino, vamos a recalcularla con los nuevos valores comerciales de las resistencias. Vamos a recopilarlas en una tabla para no perdernos:

Pulsador	Tensión en VA0
S1	0V
S2	1.76V
S3	3.92V

Tenemos que saber que Arduino tiene un convertidor A/D de 10 bits, por lo que su resolución es de:

Lo que quiere decir que Arduino es capaz de detectar diferencias en su entrada de 5mV aproximadamente como mínimo. A cada valor de tensión de entrada le va a corresponder un número a la salida de este bloque conversor. Este número estará comprendido entre 0 para una entrada de 0V y 1023 para una de 5V. Para ser más claros: cuando la entrada esté entre 0 y 0.005V, arduino nos dará un 0; entre 0.005 y 0.010V nos dará un 1; entre 0.010 y 0.015V un 2, etc, etc, etc.

Pues sabiendo esto sólo tendremos que hacer una regla de tres para saber qué número aproximadamente leerá Arduino para nuestros valores de tensión:

Sólo nos queda sustituir nuestra tensión de entrada en cada caso y obtendremos el valor que, más o menos nos leerá Arduino:

Pulsador	Tensión en VA0	Valor decimal leído
S1	0V	0
S2	1.76V	360
S3	3.92V	802

Lo siguiente es redactar el código para probar nuestros botones antes de implementarlo en el proyecto para el cuál nos habíamos quedado sin entradas. Aquí va:

//----------------------VARIABLES----------------------//
int valor; //Variable para almacenar los valores leídos
int botones = A0; //Asignamos la variable botones a la entrada A0

//----------------------INICIALIZACION----------------------//
void setup(){
  
  Serial.begin(9600);
  Serial.println("Implementacion de varios pulsadores en una sola entrada");
  Serial.println("Acciona un pulsador:");
 
}

//----------------------BUCLE PRINCIPAL----------------------//

void loop(){
  
  valor = analogRead(botones);
  delay(50);
  if(valor < 50){
    Serial.println("Has accionado el pulsador 1");
    Serial.println("Valor leido:");
    Serial.println(valor);
    delay(500);
    Serial.println("Acciona otro pulsador:");
  }
  if(valor > 250 && valor < 450){
    Serial.println("Has accionado el pulsador 2");
    Serial.println("Valor leido:");
    Serial.println(valor);
    delay(500);
    Serial.println("Acciona otro pulsador:");
  }
  if(valor >700 && valor < 900){
    Serial.println("Has accionado el pulsador 3");
    Serial.println("Valor leido:");
    Serial.println(valor);
    delay(500);
    Serial.println("Acciona otro pulsador:");
  }
}
 

Comprobad bien que los límites del condicional IF no estén demasiado ajustados para los valores que lee el programa. Si es así cambiadlos para evitar posibles problemas y después volveros locos buscando el error tras haberlo implementado en vuestro proyecto principal.

Teóricamente se podrían añadir hasta ¡¡1024 entradas!! pero tendríamos muchos errores por culpa de las tolerancias de las resistencias, por pérdidas,etc. No lo he probado, pero pienso que más de 10 entradas por cada pin analógico ya tendríamos que comenzar a hilar muy fino para cuadrar todos los valores y que no se produzcan errores de lectura.

Saludos.