HARDWARES SiriNEO TECHNOLOGIES

// TBLACKSBOT - Tutorial Pisca LED
// Sirineo Technologies
// Este código faz um LED piscar no pino 13

void setup() {
  // Configura o pino 13 como saída
  pinMode(13, OUTPUT);
}

void loop() {
  // Acende o LED
  digitalWrite(13, HIGH);
  
  // Espera 1 segundo
  delay(1000);
  
  // Apaga o LED
  digitalWrite(13, LOW);
  
  // Espera 1 segundo
  delay(1000);
}

/*
 * Nome Programa: TBLACKSBOT - LIGAR e DESLIGAR LED
 * Mentes Brilhantes TEC - Sirineo Technologies
 * Explicação: Este código faz um LED ligar com um botão e desligar com outro botão (sistema de retenção)
 * Autor: Equipe TBLACKSBOT
 * Acesse: https://sirineotechnologies.com/sirineo-wiki/GITbook-SiriNEOTchnologies-2024/Tblacksbot/tblacksbot.html
 * 
 * Material necessário:
 * - Plataforma TBLACKSBOT - SiriNEO Technologies (com Arduino Nano R4 integrado)
 * - LED já instalado na plataforma
 * - 2x botões pushbutton (SW1 e SW2) já instalados na plataforma
 */

// =============================================================================
// DEFINIÇÃO DOS PINOS DA PLATAFORMA TBLACKSBOT
// =============================================================================

#define SW1_PIN 4     // Botão SW1 para LIGAR o LED (conectado ao pino digital D4)
#define SW2_PIN 11    // Botão SW2 para DESLIGAR o LED (conectado ao pino digital D11)
#define LED_PIN 13    // LED (conectado ao pino digital D13)

// =============================================================================
// VARIÁVEIS GLOBAIS
// =============================================================================

bool estadoLED = false;  // Variável para armazenar o estado atual do LED (false = desligado, true = ligado)

// =============================================================================
// CONFIGURAÇÃO INICIAL (executa uma vez ao ligar a TBLACKSBOT)
// =============================================================================

void setup() {
  // Configura o pino do LED como SAÍDA
  // NA TBLACKSBOT: O LED já está conectado com resistor apropriado
  pinMode(LED_PIN, OUTPUT);
  
  // Configura os pinos dos botões como ENTRADA com resistor de pull-up interno
  // NA TBLACKSBOT: Os botões já estão conectados corretamente na placa
  pinMode(SW1_PIN, INPUT_PULLUP);
  pinMode(SW2_PIN, INPUT_PULLUP);
  
  // Inicializa o LED como desligado
  digitalWrite(LED_PIN, LOW);
  estadoLED = false;
  
  // Inicia a comunicação serial para monitoramento
  Serial.begin(9600);
  Serial.println("==================================================");
  Serial.println("PLATAFORMA TBLACKSBOT - SiriNEO Technologies");
  Serial.println("Sistema de Controle LED com Retencao");
  Serial.println("==================================================");
  Serial.println("Pressione SW1 (D4) para LIGAR o LED");
  Serial.println("Pressione SW2 (D11) para DESLIGAR o LED");
  Serial.println("==================================================");
}

// =============================================================================
// LOOP PRINCIPAL (executa repetidamente)
// =============================================================================

void loop() {
  // Lê o estado dos botões da TBLACKSBOT
  // NA TBLACKSBOT: Quando o botão é pressionado, o pino vai para LOW (0V)
  bool sw1Pressionado = (digitalRead(SW1_PIN) == LOW);
  bool sw2Pressionado = (digitalRead(SW2_PIN) == LOW);
  
  // Verifica se o botão SW1 (LIGAR) foi pressionado
  if (sw1Pressionado) {
    // Liga o LED
    digitalWrite(LED_PIN, HIGH);
    estadoLED = true;
    
    // Feedback no monitor serial
    Serial.println("LED LIGADO pelo SW1 (D4)");
    
    // Pequeno delay para evitar leitura múltipla do mesmo pressionamento
    delay(250);
  }
  
  // Verifica se o botão SW2 (DESLIGAR) foi pressionado
  if (sw2Pressionado) {
    // Desliga o LED
    digitalWrite(LED_PIN, LOW);
    estadoLED = false;
    
    // Feedback no monitor serial
    Serial.println("LED DESLIGADO pelo SW2 (D11)");
    
    // Pequeno delay para evitar leitura múltipla do mesmo pressionamento
    delay(250);
  }
  
  // Pequena pausa para estabilidade do sistema
  delay(10);
}

// =============================================================================
// EXPLICAÇÃO DO FUNCIONAMENTO NA PLATAFORMA TBLACKSBOT
// =============================================================================

/*
 * CARACTERÍSTICAS DA PLATAFORMA TBLACKSBOT:
 * 
 * 1. Tudo já está conectado e preparado para uso:
 *    - LED com resistor já conectado ao pino D13
 *    - Botões SW1 e SW2 com resistores já conectados aos pinos D4 e D11
 * 
 * 2. Não é necessário fazer nenhuma ligação externa
 * 
 * 3. Os botões funcionam com lógica ativa em LOW:
 *    - Quando NÃO pressionado: o pino lê HIGH (5V)
 *    - Quando pressionado: o pino lê LOW (0V)
 * 
 * 4. O sistema tem "retenção", meaning que o LED mantém seu estado até que
 *    outro botão seja pressionado
 * 
 * VANTAGENS DA PLATAFORMA TBLACKSBOT:
 * 
 * - Plug and play: tudo já está conectado e pronto para uso
 * - Não requer conhecimentos avançados de eletrônica
 * - Ideal para aprendizado e prototipagem rápida
 * - Compatível com diversos sensores e módulos
 * 
 * PARA OS ALUNOS:
 * 
 * Experimentem modificar o código para:
 * 1. Inverter a função dos botões
 * 2. Fazer o LED piscar quando pressionar SW1
 * 3. Adicionar um terceiro botão para funções extras
 * 4. Controlar a intensidade do LED com PWM
 */

// =============================================================================
// FIM DO PROGRAMA
// =============================================================================

/*
 * Nome Programa: TBLACKSBOT - Pisca LED com Potenciômetro
 * Mentes Brilhantes TEC - Sirineo Technologies
 * Explicação: Este código faz um LED piscar com velocidade controlada por potenciômetro
 * Autor: Equipe TBLACKSBOT
 * Acesse: https://sirineotechnologies.com/sirineo-wiki/GITbook-SiriNEOTchnologies-2024/Tblacksbot/tblacksbot.html
 * 
 * Material necessário:
 * - Plataforma TBLACKSBOT - SiriNEO Technologies (com Arduino Nano R4 integrado)
 * - LED já instalado na plataforma (D13)
 * - Potenciômetro de 5K conectado no pino A2 da TBLACKSBOT
 * - Mini protoboard integrado a TBLACKSBOT
 */

// =============================================================================
// DEFINIÇÃO DOS PINOS DA PLATAFORMA TBLACKSBOT
// =============================================================================

#define POTENCIOMETRO_PIN A2    // Potenciômetro conectado no pino analógico A2
#define LED_PIN 13              // LED conectado no pino digital D13

// =============================================================================
// VARIÁVEIS GLOBAIS
// =============================================================================

int tempoPisca = 500;           // Tempo inicial de piscada (em milissegundos)
int valorPotenciometro = 0;     // Valor lido do potenciômetro

// =============================================================================
// CONFIGURAÇÃO INICIAL (executa uma vez ao ligar a TBLACKSBOT)
// =============================================================================

void setup() {
  // Configura o pino do LED como SAÍDA
  // NA TBLACKSBOT: O LED já está conectado com resistor apropriado
  pinMode(LED_PIN, OUTPUT);
  
  // O pino do potenciômetro não precisa ser configurado como INPUT
  // pois pins analógicos são inputs por padrão
  
  // Inicia a comunicação serial para monitoramento
  Serial.begin(9600);
  Serial.println("==================================================");
  Serial.println("PLATAFORMA TBLACKSBOT - SiriNEO Technologies");
  Serial.println("Controle de Velocidade do LED com Potenciometro");
  Serial.println("==================================================");
  Serial.println("Gire o potenciometro (A2) para controlar a velocidade");
  Serial.println("Valor minimo: LED pisca rapido");
  Serial.println("Valor maximo: LED pisca lento");
  Serial.println("==================================================");
}

// =============================================================================
// LOOP PRINCIPAL (executa repetidamente)
// =============================================================================

void loop() {
  // Lê o valor do potenciômetro (0 a 1023)
  valorPotenciometro = analogRead(POTENCIOMETRO_PIN);
  
  // Converte o valor do potenciômetro para tempo de pisca (10ms a 2000ms)
  // Quanto maior o valor do potenciômetro, mais lento o LED pisca
  tempoPisca = map(valorPotenciometro, 0, 1023, 10, 2000);
  
  // Acende o LED
  digitalWrite(LED_PIN, HIGH);
  
  // Exibe informações no monitor serial
  Serial.print("Potenciometro: ");
  Serial.print(valorPotenciometro);
  Serial.print(" | Tempo pisca: ");
  Serial.print(tempoPisca);
  Serial.println(" ms");
  
  // Aguarda o tempo determinado pelo potenciômetro
  delay(tempoPisca);
  
  // Apaga o LED
  digitalWrite(LED_PIN, LOW);
  
  // Aguarda o tempo determinado pelo potenciômetro
  delay(tempoPisca);
}

// =============================================================================
// EXPLICAÇÃO DO FUNCIONAMENTO NA PLATAFORMA TBLACKSBOT
// =============================================================================

/*
 * COMO FUNCIONA:
 * 
 * 1. O potenciômetro de 5K está conectado ao pino analógico A2
 * 2. O Arduino lê valores entre 0 e 1023 do potenciômetro
 * 3. A função map converte esse valor para um intervalo de tempo (10ms a 2000ms)
 * 4. O LED pisca com o tempo controlado pelo potenciômetro
 * 
 * ESQUEMA DE LIGAÇÃO NA TBLACKSBOT:
 * 
 * Potenciômetro de 5K:
 *   - Pino central (cursor) → A2 da TBLACKSBOT
 *   - Um pino externo → 5V
 *   - Outro pino externo → GND
 * 
 * LED:
 *   - Já conectado internamente ao pino D13
 * 
 * FUNÇÃO MAP:
 * 
 * tempoPisca = map(valorPotenciometro, 0, 1023, 10, 2000);
 * 
 * Isso significa:
 * - Quando potenciômetro = 0 → tempoPisca = 10ms (muito rápido)
 * - Quando potenciômetro = 512 → tempoPisca = 1000ms (1 segundo)
 * - Quando potenciômetro = 1023 → tempoPisca = 2000ms (2 segundos)
 * 
 * PARA OS ALUNOS:
 * 
 * Experimentem modificar o código para:
 * 1. Alterar a faixa de tempo (valores mínimo e máximo)
 * 2. Inverter a lógica (potenciômetro no máximo = LED rápido)
 * 3. Adicionar um botão para ligar/desligar o pisca-pisca
 * 4. Controlar a intensidade do LED com PWM em vez do tempo
 * 5. Usar o potenciômetro para controlar padrões diferentes de piscada
 */

// =============================================================================
// FIM DO PROGRAMA
// =============================================================================

/*
 * Nome Programa: TBLACKSBOT - LED RGB Pisca Cores
 * Mentes Brilhantes TEC - Sirineo Technologies
 * Explicação: Este código faz o LED RGB piscar 10 vezes em cada cor (Vermelho, Verde, Azul)
 * Autor: Equipe TBLACKSBOT
 * Acesse: https://sirineotechnologies.com/sirineo-wiki/GITbook-SiriNEOTchnologies-2024/Tblacksbot/tblacksbot.html
 * 
 * Material necessário:
 * - Plataforma TBLACKSBOT - SiriNEO Technologies
 * - LED RGB 5050 integrado (pinos: Vermelho:D11, Verde:D6, Azul:D9)
 * - Ferro de solda e solda para conectar os jumpers
 */

// =============================================================================
// DEFINIÇÃO DOS PINOS DO LED RGB NA TBLACKSBOT
// =============================================================================

#define LED_VERMELHO 11   // Pino do LED Vermelho (D11)
#define LED_VERDE    6    // Pino do LED Verde (D6)
#define LED_AZUL     9    // Pino do LED Azul (D9)


// CONFIGURAÇÃO INICIAL (executa uma vez ao ligar a TBLACKSBOT)


void setup() {
  // Configura os pinos do LED RGB como SAÍDA
  pinMode(LED_VERMELHO, OUTPUT);
  pinMode(LED_VERDE, OUTPUT);
  pinMode(LED_AZUL, OUTPUT);
  
  // Inicialmente desliga todos os LEDs
  digitalWrite(LED_VERMELHO, LOW);
  digitalWrite(LED_VERDE, LOW);
  digitalWrite(LED_AZUL, LOW);
  
  // Inicia a comunicação serial para monitoramento
  Serial.begin(9600);
  Serial.println("==========================================");
  Serial.println("TBLACKSBOT - Tutorial LED RGB");
  Serial.println("Piscando cores: Vermelho, Verde, Azul");
  Serial.println("Cada cor piscara 10 vezes");
  Serial.println("==========================================");
}

// =============================================================================
// LOOP PRINCIPAL (executa repetidamente)
// =============================================================================

void loop() {
  // Pisca 10 vezes na cor VERMELHA
  Serial.println("Iniciando cor VERMELHA");
  for(int i = 1; i <= 10; i++) {
    digitalWrite(LED_VERMELHO, HIGH);  // Acende vermelho
    delay(50);                         // Aguarda 50ms
    digitalWrite(LED_VERMELHO, LOW);   // Apaga vermelho
    delay(50);                         // Aguarda 50ms
    Serial.print("Vermelho piscada: ");
    Serial.println(i);
  }
  
  // Pequena pausa entre cores
  delay(500);
  
  // Pisca 10 vezes na cor VERDE
  Serial.println("Iniciando cor VERDE");
  for(int i = 1; i <= 10; i++) {
    digitalWrite(LED_VERDE, HIGH);     // Acende verde
    delay(50);                         // Aguarda 50ms
    digitalWrite(LED_VERDE, LOW);      // Apaga verde
    delay(50);                         // Aguarda 50ms
    Serial.print("Verde piscada: ");
    Serial.println(i);
  }
  
  // Pequena pausa entre cores
  delay(500);
  
  // Pisca 10 vezes na cor AZUL
  Serial.println("Iniciando cor AZUL");
  for(int i = 1; i <= 10; i++) {
    digitalWrite(LED_AZUL, HIGH);      // Acende azul
    delay(50);                         // Aguarda 50ms
    digitalWrite(LED_AZUL, LOW);       // Apaga azul
    delay(50);                         // Aguarda 50ms
    Serial.print("Azul piscada: ");
    Serial.println(i);
  }
  
  // Pausa final antes de reiniciar o ciclo
  Serial.println("Ciclo completo! Reiniciando...");
  Serial.println("==========================================");
  delay(2000);
}

// =============================================================================
// INSTRUÇÕES DE MONTAGEM
// =============================================================================

/*
 * IMPORTANTE: Antes de usar o LED RGB na TBLACKSBOT:
 * 
 * 1. Verifique se os jumpers de solda na parte inferior da placa
 *    estão conectados corretamente para o LED RGB
 *    
 * 2. Os jumpers devem estar soldados para conectar:
 *    - LED Vermelho → Pino D11
 *    - LED Verde → Pino D6  
 *    - LED Azul → Pino D9
 * 
 * 3. Se os jumpers não estiverem soldados, use um ferro de solda
 *    para fazer as conexões necessárias
 * 
 * 4. O LED RGB da TBLACKSBOT é do tipo ânodo comum ou cátodo comum?
 *    - Este código foi feito para LED de cátodo comum
 *    - Se for ânodo comum, inverta HIGH/LOW no código
 */

// =============================================================================
// DICAS PARA OS ALUNOS
// =============================================================================

/*
 * Experimente modificar o código para:
 * 
 * 1. Alterar o tempo de piscada (50ms)
 * 2. Aumentar ou diminuir o número de piscadas (10x)
 * 3. Criar cores mistas (amarelo, roxo, ciano, branco)
 * 4. Fazer transições suaves entre cores usando PWM
 * 5. Controlar as cores com potenciômetro ou botões
 */

// =============================================================================
// FIM DO PROGRAMA
// =============================================================================

/*
 * Nome Programa: TBLACKSBOT - LED RGB Cores Divertidas
 * Mentes Brilhantes TEC - Sirineo Technologies
 * Explicação: Este código faz o LED RGB mostrar cores diferentes de forma simples
 * Autor: Equipe TBLACKSBOT
 * Acesse: https://sirineotechnologies.com/sirineo-wiki/GITbook-SiriNEOTchnologies-2024/Tblacksbot/tblacksbot.html
 */

// =============================================================================
// PINOS DO LED RGB NA TBLACKSBOT
// =============================================================================

#define LED_VERMELHO 11   // Pino do LED Vermelho (D11)
#define LED_VERDE    6    // Pino do LED Verde (D6) 
#define LED_AZUL     9    // Pino do LED Azul (D9)

// =============================================================================
// CONFIGURAÇÃO INICIAL
// =============================================================================

void setup() {
  // Configura os pinos do LED RGB como SAÍDA
  pinMode(LED_VERMELHO, OUTPUT);
  pinMode(LED_VERDE, OUTPUT);
  pinMode(LED_AZUL, OUTPUT);
  
  // Inicia a comunicação serial
  Serial.begin(9600);
  Serial.println("TBLACKSBOT - LED RGB Cores Divertidas!");
  Serial.println("Vamos ver muitas cores bonitas!");
}

// =============================================================================
// LOOP PRINCIPAL - CORES SIMPLES
// =============================================================================

void loop() {
  // 1. VERMELHO (só vermelho ligado)
  Serial.println("COR: VERMELHO");
  digitalWrite(LED_VERMELHO, LOW);   // Liga vermelho
  digitalWrite(LED_VERDE, HIGH);     // Desliga verde
  digitalWrite(LED_AZUL, HIGH);      // Desliga azul
  delay(1000);                       // Espera 1 segundo
  
  // 2. VERDE (só verde ligado)  
  Serial.println("COR: VERDE");
  digitalWrite(LED_VERMELHO, HIGH);
  digitalWrite(LED_VERDE, LOW);
  digitalWrite(LED_AZUL, HIGH);
  delay(1000);
  
  // 3. AZUL (só azul ligado)
  Serial.println("COR: AZUL");
  digitalWrite(LED_VERMELHO, HIGH);
  digitalWrite(LED_VERDE, HIGH);
  digitalWrite(LED_AZUL, LOW);
  delay(1000);
  
  // 4. AMARELO (vermelho + verde)
  Serial.println("COR: AMARELO");
  digitalWrite(LED_VERMELHO, LOW);
  digitalWrite(LED_VERDE, LOW);
  digitalWrite(LED_AZUL, HIGH);
  delay(1000);
  
  // 5. ROXO (vermelho + azul)
  Serial.println("COR: ROXO");
  digitalWrite(LED_VERMELHO, LOW);
  digitalWrite(LED_VERDE, HIGH);
  digitalWrite(LED_AZUL, LOW);
  delay(1000);
  
  // 6. CIANO (verde + azul)
  Serial.println("COR: CIANO");
  digitalWrite(LED_VERMELHO, HIGH);
  digitalWrite(LED_VERDE, LOW);
  digitalWrite(LED_AZUL, LOW);
  delay(1000);
  
  // 7. BRANCO (todas as cores)
  Serial.println("COR: BRANCO");
  digitalWrite(LED_VERMELHO, LOW);
  digitalWrite(LED_VERDE, LOW);
  digitalWrite(LED_AZUL, LOW);
  delay(1000);
  
  // 8. APAGADO
  Serial.println("LED APAGADO");
  digitalWrite(LED_VERMELHO, HIGH);
  digitalWrite(LED_VERDE, HIGH);
  digitalWrite(LED_AZUL, HIGH);
  delay(1000);
  
  Serial.println("----------------------");
}

/*
 * Nome Programa: TBLACKSBOT - LED RGB com PWM
 * Mentes Brilhantes TEC - Sirineo Technologies
 * Explicação: Este código mostra como usar PWM para variar as cores do LED RGB
 * Autor: Equipe TBLACKSBOT
 * Acesse: https://sirineotechnologies.com/sirineo-wiki/GITbook-SiriNEOTchnologies-2024/Tblacksbot/tblacksbot.html
 */

// =============================================================================
// PINOS PWM DO LED RGB NA TBLACKSBOT
// =============================================================================

#define LED_VERMELHO 11   // Pino PWM do LED Vermelho (D11)
#define LED_VERDE    6    // Pino PWM do LED Verde (D6) 
#define LED_AZUL     9    // Pino PWM do LED Azul (D9)

// =============================================================================
// CONFIGURAÇÃO INICIAL
// =============================================================================

void setup() {
  // Configura os pinos do LED RGB como SAÍDA
  pinMode(LED_VERMELHO, OUTPUT);
  pinMode(LED_VERDE, OUTPUT);
  pinMode(LED_AZUL, OUTPUT);
  
  // Inicia a comunicação serial
  Serial.begin(9600);
  Serial.println("TBLACKSBOT - Variando Cores com PWM");
  Serial.println("PWM = Controlar o brilho das cores!");
}

// =============================================================================
// LOOP PRINCIPAL - VARIANDO CORES COM PWM
// =============================================================================

void loop() {
  Serial.println("Vermelho variando...");
  variarVermelho();
  
  Serial.println("Verde variando...");
  variarVerde();
  
  Serial.println("Azul variando...");
  variarAzul();
  
  Serial.println("Todas as cores variando...");
  variarTodasCores();
  
  Serial.println("----------------------");
}

// =============================================================================
// FUNÇÕES PARA VARIAR CORES
// =============================================================================

void variarVermelho() {
  // Vermelho aumenta devagar
  for (int brilho = 0; brilho <= 255; brilho++) {
    analogWrite(LED_VERMELHO, 255 - brilho); // PWM no vermelho
    analogWrite(LED_VERDE, 255);    // Verde desligado
    analogWrite(LED_AZUL, 255);     // Azul desligado
    delay(10);
  }
  
  // Vermelho diminui devagar
  for (int brilho = 255; brilho >= 0; brilho--) {
    analogWrite(LED_VERMELHO, 255 - brilho);
    analogWrite(LED_VERDE, 255);
    analogWrite(LED_AZUL, 255);
    delay(10);
  }
}

void variarVerde() {
  // Verde aumenta devagar
  for (int brilho = 0; brilho <= 255; brilho++) {
    analogWrite(LED_VERMELHO, 255); // Vermelho desligado
    analogWrite(LED_VERDE, 255 - brilho); // PWM no verde
    analogWrite(LED_AZUL, 255);     // Azul desligado
    delay(10);
  }
  
  // Verde diminui devagar
  for (int brilho = 255; brilho >= 0; brilho--) {
    analogWrite(LED_VERMELHO, 255);
    analogWrite(LED_VERDE, 255 - brilho);
    analogWrite(LED_AZUL, 255);
    delay(10);
  }
}

void variarAzul() {
  // Azul aumenta devagar
  for (int brilho = 0; brilho <= 255; brilho++) {
    analogWrite(LED_VERMELHO, 255); // Vermelho desligado
    analogWrite(LED_VERDE, 255);    // Verde desligado
    analogWrite(LED_AZUL, 255 - brilho); // PWM no azul
    delay(10);
  }
  
  // Azul diminui devagar
  for (int brilho = 255; brilho >= 0; brilho--) {
    analogWrite(LED_VERMELHO, 255);
    analogWrite(LED_VERDE, 255);
    analogWrite(LED_AZUL, 255 - brilho);
    delay(10);
  }
}

void variarTodasCores() {
  // Todas as cores variam juntas
  for (int brilho = 0; brilho <= 255; brilho++) {
    analogWrite(LED_VERMELHO, 255 - brilho);
    analogWrite(LED_VERDE, 255 - brilho);
    analogWrite(LED_AZUL, 255 - brilho);
    delay(10);
  }
  
  for (int brilho = 255; brilho >= 0; brilho--) {
    analogWrite(LED_VERMELHO, 255 - brilho);
    analogWrite(LED_VERDE, 255 - brilho);
    analogWrite(LED_AZUL, 255 - brilho);
    delay(10);
  }
}

/*
 * Nome Programa: TBLACKSBOT - Sensor Ultrassônico HC-SR04
 * Mentes Brilhantes TEC - Sirineo Technologies
 * Explicação: Mede distância com sensor ultrassônico e aciona LED RGB e buzzer
 * Autor: Equipe TBLACKSBOT
 * Observação: fazer o jumper para o Buzzer da TBLACKSBOT
 * Acesse: https://sirineotechnologies.com/sirineo-wiki/GITbook-SiriNEOTchnologies-2024/Tblacksbot/tblacksbot.html
 */

// =============================================================================
// PINOS DA TBLACKSBOT
// =============================================================================

#define TRIG_PIN A0    // Pino Trigger do sensor (A0)
#define ECHO_PIN A1    // Pino Echo do sensor (A1)
#define BUZZER_PIN 13  // Pino do Buzzer (D13)

#define LED_VERMELHO 11   // Pino LED Vermelho (D11)
#define LED_VERDE    6    // Pino LED Verde (D6) 
#define LED_AZUL     9    // Pino LED Azul (D9)

// =============================================================================
// VARIÁVEIS
// =============================================================================

long distancia;    // Armazena a distância medida
long duracao;      // Armazena o tempo do echo

// =============================================================================
// CONFIGURAÇÃO INICIAL
// =============================================================================

void setup() {
  // Configura os pinos do sensor
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  
  // Configura os pinos do LED RGB
  pinMode(LED_VERMELHO, OUTPUT);
  pinMode(LED_VERDE, OUTPUT);
  pinMode(LED_AZUL, OUTPUT);
  
  // Configura o pino do buzzer
  pinMode(BUZZER_PIN, OUTPUT);
  
  // Inicialmente desliga tudo
  digitalWrite(LED_VERMELHO, HIGH);
  digitalWrite(LED_VERDE, HIGH);
  digitalWrite(LED_AZUL, HIGH);
  digitalWrite(BUZZER_PIN, LOW);
  
  // Inicia a comunicação serial
  Serial.begin(9600);
  Serial.println("TBLACKSBOT - Sensor Ultrassônico HC-SR04");
  Serial.println("Medindo distância...");
}

// =============================================================================
// LOOP PRINCIPAL
// =============================================================================

void loop() {
  // Mede a distância
  distancia = medirDistancia();
  
  // Mostra a distância no serial
  Serial.print("Distancia: ");
  Serial.print(distancia);
  Serial.println(" cm");
  
  // Toma ações baseadas na distância
  if (distancia < 10) {
    // Muito perto (menos de 10cm)
    Serial.println("MUITO PERTO! Cuidado!");
    piscarVermelho();
    tone(BUZZER_PIN, 1000); // Toca buzzer (1000Hz)
  } 
  else if (distancia >= 10 && distancia < 30) {
    // Distância média (10cm a 30cm)
    Serial.println("Distancia media");
    piscarAzul();
    noTone(BUZZER_PIN); // Desliga buzzer
  } 
  else {
    // Longe (mais de 30cm)
    Serial.println("Longe");
    piscarVerde();
    noTone(BUZZER_PIN); // Desliga buzzer
  }
  
  delay(100); // Pequena pausa entre medições
}

// =============================================================================
// FUNÇÃO PARA MEDIR DISTÂNCIA
// =============================================================================

long medirDistancia() {
  // Limpa o pino trigger
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  
  // Envia pulso de 10 microsegundos no trigger
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  
  // Mede o tempo que o echo fica em HIGH
  duracao = pulseIn(ECHO_PIN, HIGH);
  
  // Calcula a distância (em cm)
  // Velocidade do som = 340 m/s = 0,034 cm/microsegundo
  // Distância = (tempo * velocidade) / 2 (ida e volta)
  return (duracao * 0.034) / 2;
}

// =============================================================================
// FUNÇÕES PARA PISCAR o LED RGB
// =============================================================================

void piscarVermelho() {
  digitalWrite(LED_VERMELHO, LOW);   // Liga vermelho
  digitalWrite(LED_VERDE, HIGH);     // Desliga verde
  digitalWrite(LED_AZUL, HIGH);      // Desliga azul
  delay(100);
  digitalWrite(LED_VERMELHO, HIGH);  // Desliga vermelho
  delay(100);
}

void piscarAzul() {
  digitalWrite(LED_VERMELHO, HIGH);  // Desliga vermelho
  digitalWrite(LED_VERDE, HIGH);     // Desliga verde
  digitalWrite(LED_AZUL, LOW);       // Liga azul
  delay(200);
  digitalWrite(LED_AZUL, HIGH);      // Desliga azul
  delay(200);
}

void piscarVerde() {
  digitalWrite(LED_VERMELHO, HIGH);  // Desliga vermelho
  digitalWrite(LED_VERDE, LOW);      // Liga verde
  digitalWrite(LED_AZUL, HIGH);      // Desliga azul
  delay(300);
  digitalWrite(LED_VERDE, HIGH);     // Desliga verde
  delay(300);
}

// =============================================================================
// EXPLICAÇÃO DO FUNCIONAMENTO
// =============================================================================

/*
 * COMO O SENSOR FUNCIONA:
 * 
 * 1. Enviamos um pulso sonoro (inaudível) com o pino TRIGGER
 * 2. O som bate em um objeto e volta (eco)
 * 3. Medimos quanto tempo o eco levou para voltar (pino ECHO)
 * 4. Calculamos a distância baseada no tempo
 * 
 * ZONAS DE DISTÂNCIA:
 * 
 * VERMELHO + BUZZER: Menos de 10cm → PERIGO!
 * AZUL: Entre 10cm e 30cm → ATENÇÃO
 * VERDE: Mais de 30cm → TUDO OK
 * 
 * LIGAÇÕES NA TBLACKSBOT:
 * - Sensor VCC → 5V da TBLACKSBOT
 * - Sensor GND → GND da TBLACKSBOT
 * - Sensor TRIG → Pino A0
 * - Sensor ECHO → Pino A1
 * - Buzzer (+) → Pino D13
 * - Buzzer (-) → GND
 */

// =============================================================================
// FIM DO PROGRAMA
// =============================================================================