Cursos

#ifndef SENSORES_H
#define SENSORES_H
 
#include "controladores.h"
#include "funcoes.h"
#include <LiquidCrystal.h>
#include <Adafruit_MotorShield.h>
 
//LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
 
//##################################### IDENTIFICA CORES ###########################################
int RED = 23;
int GREEN = 25;
int BLUE = 27;
 
// porta analogica do LDR Diferencial
int LDR = 9;
int LDR2 = 8;
 
int LDR_cor = 10;
 
int matrizPinodosLEDS[] = {RED,GREEN,BLUE}; 
 
// Uma variável booleana para indicar se o sensor foi calibrado 
boolean balanco = false; 
 
//Matriz de floats para armazenar o valor das cores 
float matrizCores[] = {   0,0,0}; 
float matrizBranco[] = {   0,0,0}; 
float matrizPreto[] = {   0,0,0}; 
 
//Variável para armazenar a média das leitura 
int mediaLeituras;
 
void mediaSensor(int vezes){   
  int leituras;   
  int somatorio=0;   
  for(int i = 0;i < vezes;i++){     
    leituras = analogRead(LDR_cor);     
    somatorio = leituras + somatorio;     
    delay(10);   
  }   
  mediaLeituras = (somatorio)/vezes; 
} 
 
void confBalanco(){   
 
  //Calibrando o branco!   
  Serial.println("Calibrando o branco");  
  lcd.setCursor(0,0);
  lcd.print("Calibrando o preto"); 
  delay(5000);   
 
  for(int i = 0;i<=2;i++){     
    digitalWrite(matrizPinodosLEDS[i],HIGH);     
    delay(100);     
    mediaSensor(5);               
    matrizBranco[i] = mediaLeituras;     
    digitalWrite(matrizPinodosLEDS[i],LOW);     
    delay(100);   
  }   
 
  //Calibrando o preto!   
  Serial.println("Calibrando o preto");
  lcd.setCursor(0,0);
  lcd.print("Calibrando o preto");   
  delay(5000);   
 
  for(int i = 0;i<=2;i++){     
    digitalWrite(matrizPinodosLEDS[i],HIGH);     
    delay(100);     
    mediaSensor(5);     
    matrizPreto[i] = mediaLeituras;     
    digitalWrite(matrizPinodosLEDS[i],LOW);     
    delay(100);   
  }   
 
  //Avisa que a calibragem foi feita   
  Serial.println("Sensor Calibrado");   
  balanco = true;   
  delay(3000); 
} 
 
 
void checaBalanco() {   
  //checa se o balanço de branco foi feito   
 
  if(balanco == false){     
    confBalanco();   
  } 
} 
 
 
int mostraCores(){
  int r = int (matrizCores[0]);
  int g = int (matrizCores[1]);
  int b = int (matrizCores[2]);
 
  Serial.print(r);
  Serial.print(" ");
  Serial.print(g);
  Serial.print(" ");
  Serial.print(b);
  Serial.println("  -----------------------------  ");   
   if (r < 90 && g < 90 && b < 90){   
       lcd.setCursor(0,0);  
       lcd.print("Preto           ");  
       lcd.setCursor(0,1);  
       lcd.print("               "); 
       return 1;  
    }
    else{
     lcd.setCursor(0,0);  
     lcd.print("Colorido        ");  
      return 0;
    }
 
}
 
//Checa a cor 
int checaCores(){  
  for(int i = 0;i<=2;i++){     
    digitalWrite(matrizPinodosLEDS[i],HIGH);     
    delay(100);     
    mediaSensor(5);                       
    matrizCores[i] = mediaLeituras;             
    float cinzaDif = matrizBranco[i] - matrizPreto[i];     
    matrizCores[i] = (matrizCores[i] - matrizPreto[i])/(cinzaDif)*255;      
    digitalWrite(matrizPinodosLEDS[i],LOW);     
    delay(100);   
  } 
    return mostraCores();
} 
 
 
// ########################################### LOCALIZA  ##############################################
 
 
 
void Aponta_max(int maxi){
 
  int l1,l2,diferenca,i=0,count=0;
  int dif[9000];
  long tempoinicial = millis();
  long tempoatual = tempoinicial;
  motor1->run(BACKWARD);
  motor2->run(FORWARD);
 
  while(1){
 
  l1 = analogRead(LDR);
  l2 = analogRead(LDR2);
  diferenca = abs(l1 - l2);
  if (tempoatual<tempoinicial+3000){
    if (diferenca >= maxi)
     {break;}
 
  }
  else if (diferenca >= maxi-20)
  {break;}
 
  i++;
  }
 
  motor1->run(RELEASE);
  motor2->run(RELEASE);
}
 
 
int giramax_controle(int angulo){
 
  int l1;
  int l2;
  int diferenca;
  int a=0;
  int maxi = 0;
  float velangdes =2.3;
  float velin= velangdes*RaioRoda;
  float t =(((PI*RaioRobo)/180)*angulo)/(velin); 
  float velang;
  float velang2;
  int u=60;
  int u2=120;
  motor1->setSpeed(u);
  motor2->setSpeed(u2);
  long  tempoinicial = millis();
  long  tempoatual = tempoinicial;
  motor1->run(BACKWARD);
  motor2->run(FORWARD);
 
  while(tempoatual < tempoinicial + (t*1000)){
 
    velang = Leitura_Encoder1();
    velang2 = Leitura_Encoder2();
    u = controlador1(velang,velangdes, u);
    u2 = controlador2(velang2,velangdes,u2); 
 
    l1 = analogRead(LDR);
    l2 = analogRead(LDR2);
    diferenca = abs(l1 - l2);
    Serial.println(diferenca);
    Serial.println("------------------------------------------------------");  
 
    if(diferenca > maxi){
      maxi = diferenca;
     // a=0;
 
    }
 
 
    motor1->setSpeed(u);
    motor2->setSpeed(u2); 
    if (t_atual > (t_start +60000)){
      break;
    } 
    t_atual = millis(); 
    tempoatual = millis();
    }
 
 
  return maxi;
}
 
 
 
// ########################################### LOCALIZA  ###############################################
// gira horario
 
 
int giramax(int angle){
  int maximo = 0;
 
  int medida = abs(analogRead(LDR) - analogRead(LDR2));
  if(medida > maximo){
    maximo = medida;
  }
  return maximo;
}
 
void giraeaponta(int a){
  int medida = 0;
  int medidanova = 0;
  while(1){
    int diferenca = abs(analogRead(LDR) - analogRead(LDR2));
    if(diferenca > (a - 10)){
      motor1->run(RELEASE);
      motor2->run(RELEASE);
 
      break;
    }
    if (t_atual > (t_start +60000)){
      break;
    } 
    t_atual = millis(); 
  }
}
 
void ldr(){
  int max1 = giramax_controle(180);
  int max2 = giramax_controle(180);
  if(max1 > max2){
    giraeaponta(max1);
  }
  else{
    giraeaponta(max2);
  }
}
 
void pegamax(){
  int max1 = giramax_controle(180);
  int max2 = giramax_controle(180);
  if(max1 > max2){
    maxcalibrado = max1;
  }
  else{
    maxcalibrado = max2;
  }
}
 
#endif