/*******************************************************************************
*
*    Maker 001 - Construindo sensor capacitivo de 4 teclas - Arduino
*    Autor: Angelo Luis Ferreira
*    19/05/2021
*    http://squids.com.br/arduino
*
*******************************************************************************/
#include <LiquidCrystal_I2C.h>//Carrega a biblioteca lcd com I2C

// definição de pinos
const byte sendPin = 2; // pino saída do Arduino (carga)
const byte sensor[] = {4,5,6,7}; // pinos do sensor 4 teclas
const byte ledPin[] = {8, 9, 10, 11}; // pinos dos leds

// declarações de constantes e variáveis
/******************************************************************************* */
// dados dos sensores (ou teclas)
const byte amostras = 5; // default 5
const byte sensorAmount = 4; // quantidade de sensores (ou teclas)
/******************************************************************************* */

// variável para armazenar os valores lidos nos sensores
int valor[sensorAmount];

// constante que indica limite para ação do sensor
const byte threshold=13;

// variável para leituras no monitor serial
unsigned long anterior = 0;

//Define os pinos que serão utilizados para ligação ao display
LiquidCrystal_I2C lcd(0x27,2,1,0,4,5,6,7,3, POSITIVE);

// setup de inicialização
void setup() {
  // define modo dos pinos
  pinMode(sendPin, OUTPUT); // 
  for (byte i = 0; i<sensorAmount; i++) {
    pinMode(sensor[i], INPUT);  // sensor
    pinMode(ledPin[i], OUTPUT); // leds
  }

  // inicializa o display LCD
  lcd.begin(16, 2); // Define o display com 16 colunas e 2 linhas
  lcd.clear(); // limpa a tela do display  
  // Inicializa a comunicação serial em 9600 bits por segundo
  Serial.begin(9600);
}

// loop infinito
void loop() {

  // Lê o valor de cada sensor (ou tecla)
  sensorCapacitivo(sensorAmount); // sensorAmount = nº de sensores ou teclas

  // Se o valor for maior que um dado limite (threshold=15) acende o led e imprime no display
  acendeLeds();

  // mostra no display lcd a(s) tecla(s) do sensor digitada(s)
  mostraDisplay();
  
  // Imprime o valor no monitor seial
  imprimeMonitor(); 
}

// acende leds
void acendeLeds() {
    valor[0] > threshold ? digitalWrite(ledPin[0],HIGH) : digitalWrite(ledPin[0],LOW);
    valor[1] > threshold ? digitalWrite(ledPin[1],HIGH) : digitalWrite(ledPin[1],LOW);
    valor[2] > threshold ? digitalWrite(ledPin[2],HIGH) : digitalWrite(ledPin[2],LOW);
    valor[3] > threshold ? digitalWrite(ledPin[3],HIGH) : digitalWrite(ledPin[3],LOW);
}

// mostra tecla no display LCD
void mostraDisplay(){
  lcd.setCursor(0,0); // Define o cursor na posição de início
  lcd.print("Teclas digitadas");
  lcd.setCursor(0,1);
  valor[0] > threshold ? lcd.print("01") : lcd.print("--");
  lcd.setCursor(5,1);
  valor[1] > threshold ? lcd.print("02") : lcd.print("--");
  lcd.setCursor(9,1);
  valor[2] > threshold ? lcd.print("03") : lcd.print("--");
  lcd.setCursor(13,1);
  valor[3] > threshold ? lcd.print("04") : lcd.print("--");  
}

// imprime valor no monitor serial a cada 15 segundos (calibragem)
void imprimeMonitor() {
  unsigned long atual = millis();
  if (atual - anterior > 250) {
    Serial.print("Tecla1 = ");
    Serial.print(valor[0]);
    Serial.print(" | Tecla2 = ");
    Serial.print(valor[1]);
    Serial.print(" | Tecla3 = ");
    Serial.print(valor[2]);
    Serial.print(" | Tecla4 = ");
    Serial.println(valor[3]);
    anterior = atual;
  }
}

/*******************************************************************************
*
*    Rotina para rodar sensores capacitivos maker
*    sensorAmount = sensores = nº de sensores ou de teclas
*    amostras = número de amostras no cáluclo da média dos valores lidos
*
*******************************************************************************/
void  sensorCapacitivo(byte sensores) {
  for (byte i=0; i<sensores; i++) {
    valor[i] = sensorToque(i);
  }
}

// Executa pelo número de amostras passado e retorna o valor lido
byte sensorToque(byte j) {

  unsigned long sum = 0;
  unsigned long tempo = 0;
  
  // Executa função 'amostras' vezes
  for (int i = 0; i < amostras; i++) {
    digitalWrite(sendPin, LOW);
    
    // Coloca o pino do sensor como saída para garantir nível baixo
    pinMode(sensor[j], OUTPUT);
    digitalWrite(sensor[j], LOW);
    delayMicroseconds(500); // Delay para estabilidade
    
    // Atera o modo do pino do sensor para entrada
    pinMode(sensor[j], INPUT);
    
    // Inicia carga do sensor
    digitalWrite(sendPin, HIGH);
    
    // Aguarda pino atingir nível alto (aproximadamente 2.5V)
    while (digitalRead(sensor[j]) == LOW) {
      tempo++; // Acumula tempo para atingir nível alto
    }
    
    // Acumula valor para média
    sum += tempo;
  }
  
  // Realiza média e retorna valor lido
    return (unsigned int)sum/amostras;
}