Gestión de varios sensores con un registro de cambio

En este tutorial, veremos cómo gestionar varios sensores con un registro de desplazamiento. Ya vimos en el último tutorial sobre el tema, que la caja registradora podía utilizarse para accionar LEDs. Veremos aquí, cómo leer el valor de 8 sensores en una sola entrada analógica. En electrónica, el número de entradas y salidas se vuelve crítico cuando se utilizan varios sensores. El uso de un registro de desplazamiento es una buena solución para reducir el número de pines utilizados.

En este artículo, utilizamos el registro de desplazamiento 74HC595 pero es posible utilizar un multiplexor o un 74HC165 (Paralelo a serie, más adecuado para la lectura de sensores)

Material

• Ordenador
• Arduino UNO
• Cable USB A Macho/B Macho
• Registro de cambio 74HC595

Principio de funcionamiento

El registro de desplazamiento es un componente electrónico que contiene flip-flops sincrónicos. Se trata de circuitos lógicos que mantienen en la memoria un estado alto o bajo (como un bit) unidos por el mismo reloj. El principio de desplazamiento proviene del hecho de que cada memoria se escribe o lee bit a bit.

Para gestionar los sensores, utilizaremos la salida del registro de desplazamiento como fuente de tensión y todas las salidas de los sensores se conectarán a una entrada analógica del Arduino. Los sensores se alimentarán uno tras otro, lo que nos permitirá recuperar, en el pin analógico, el valor del sensor alimentado.

Esquema

El registro de desplazamiento requiere 3 pines de salida de un microcontrolador. Es posible gestionar varios registros conectados en serie.

• GND Tierra del circuito integrado
• Pin de alimentación Vcc. Normalmente se conecta a 5V
• SH_CP o RCLK entrada de reloj del registro de desplazamiento. La señal de reloj del registro que determina si se escribe en la memoria
• ST_CP o SRCLK entrada de reloj del registro de almacenamiento. La señal de reloj de almacenamiento que define de qué memoria se está leyendo o escribiendo.
• Entrada de datos en serie DS o SER. Señal que contiene los datos a grabar (UP o DOWN)
• Salida de datos en paralelo Q0-Q7. Pines de salida del registro de desplazamiento
• OE Habilitación de salida, activa LOW. Pin conectado a GND para activar las salidas
• MR Reinicio maestro, activo LOW. Clavija de reinicio. Conectado a 5V
• Q7′ salida de datos en serie (pin utilizado sólo si hay varios registros conectados en serie)

Una vez que el registro de desplazamiento está bien conectado, conectaremos cada uno de los botones. Para poder detectar el estado de varios botones, tenemos que añadir un diodo a cada salida para que la corriente no fluya de una salida del registro de desplazamiento a la otra.

Código

Para comunicarnos con el registro de desplazamiento, haremos malabares con sus pines de entrada. Tenemos que poner el pin RCLK bajo para escribir en un registro. Para escribir en los flip-flops, tenemos que poner el reloj de almacenamiento a nivel bajo. Con cada pulso de reloj, pasamos al siguiente flip-flop. Para simplificar nuestro código, definiremos este procedimiento en la función writeRegister().

Para gestionar el grupo de sensores a través del registro, pulsaremos cada flip-flop y leeremos el valor del botón cuando el flip-flop esté alto, es decir, cuando fluya una corriente a través del botón.

//Constants
#define number_of_74hc595s 1
#define numOfRegisterPins number_of_74hc595s * 8
#define SER_Pin 2
#define RCLK_Pin 3
#define SRCLK_Pin 4

//Parameters
const int grpBtnPin = A0;

//Variables
boolean registers[numOfRegisterPins] = {0, 0, 0, 0, 0, 0, 0, 0};
boolean grpBtnState[numOfRegisterPins] = {0, 0, 0, 0, 0, 0, 0, 0};
boolean oldGrpBtnState[numOfRegisterPins] = {0, 0, 0, 0, 0, 0, 0, 0};
int grpBtnVal[numOfRegisterPins] = {0, 0, 0, 0, 0, 0, 0, 0};

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
  //Init register
  pinMode(SER_Pin, OUTPUT);
  pinMode(RCLK_Pin, OUTPUT);
  pinMode(SRCLK_Pin, OUTPUT);
  pinMode(grpBtnPin, INPUT);
}

void loop() {
  readGrpBtn();
}

void clearRegisters() { /* function clearRegisters */
  //// Clear registers variables
  for (int i = numOfRegisterPins - 1; i >=  0; i--) {
    registers[i] = LOW;
  }
}

void writeRegisters() { /* function writeRegisters */
  //// Write register after being set
  digitalWrite(RCLK_Pin, LOW);
  for (int i = numOfRegisterPins - 1; i >=  0; i--) {
    digitalWrite(SRCLK_Pin, LOW); int val = registers[i];
    digitalWrite(SER_Pin, val);
    digitalWrite(SRCLK_Pin, HIGH);
  }
  digitalWrite(RCLK_Pin, HIGH);
}

void setRegisterPin(int index, int value) { /* function setRegisterPin */
  ////Set register variable to HIGH or LOW
  registers[index] = value;
}

void readGrpBtn() { /* function readGrpBtn */
  //// Read each btn
  for (int i = numOfRegisterPins - 1; i >=  0; i--) {
    grpBtnState[i] = false;
    setRegisterPin(i, HIGH);
    writeRegisters();
    delay(20);
    grpBtnVal[i] = analogRead(grpBtnPin);
    setRegisterPin(i, LOW);
    writeRegisters();

    if (grpBtnVal[i] > 500) {
      grpBtnState[i] = true;
      if (oldGrpBtnState[i] != grpBtnState[i]) {
        Serial.print(F("Btn "));
        Serial.print(i);
        Serial.print(F(" detected -> State =  "));
        Serial.println(grpBtnVal[i]);
      }
    }
  }
}

Resultados

El estado del botón se actualiza cada vez que pasa por la memoria del registro correspondiente y es posible leer 8 botones con una sola entrada analógica.

Applications

• Gestiona hasta 8 sensores con tres pines digitales y un pin analógico de un microcontrolador
• Crear un dispositivo HID con varias llaves

Encuentre nuestro módulo de expansión de registro de desplazamiento con conectividad simplificada, compatible con todo tipo de microcontroladores (Arduino, ESP8266, ESP32, Raspberry Pi, etc.)

Fuentes

• https://fr.wikipedia.org/wiki/Registre_%C3%A0_d%C3%A9calage
• https://fr.wikipedia.org/wiki/Bascule_(circuit_logique)
• Uso de un registro de desplazamiento
• Uso de un multiplexor