class cRGB
{
  public:
    //Construtor.
    cRGB(){ 
      //Ao instanciar um objeto dessa class, a classe é alocado na memória temporária, e nesse momento
      //é chamado o construtor que inicializa as variáveis membros dela.
      btn_pressionado = 0; 
      btn_liberado = 0; 
      cont_clique = 0; 
      //As variáveis membros da class vão ser inicializado com os números dos pinos do Arduíno.
      botao = 3; 
      ledR = 4; 
      ledG = 5; 
      ledB = 6; 
      //configurado o modo que os pinos do Arduíno vão trabalhar. Podemos usar as funções 
      //de modo pino aqui também e não apenas na função setup()
      pinMode(botao, INPUT);//Entrada
      pinMode(ledR, OUTPUT);//Saída
      pinMode(ledG, OUTPUT);//Saída
      pinMode(ledB, OUTPUT);//Saída

    }
    //Destrutor.
    ~cRGB(){}

    bool Estado_Botao();
    void Estado_Led_Rgb(); 
    void Trocar_Cor_Rgb();
    //Essa funções serão substiuidas por um função
    //Habilidade do led RGB. 
    //void Led_Vermelho();
    //void Led_Verde();
    //void Led_Azul();
    //void Led_Amarelo();
    //void Led_Ciano();
    //void Led_Margenta();
    //void Desligar_Led_Rgb();
    void LedRGB(int corR, int corV, int corB); //Essa função recebe três parâmetros.

  private:
  //Só as funções de acesso podem acessar essas variáveis membros.
    int botao;
    int btn_pressionado;
    int btn_liberado;
    int cont_clique;
    int ledR;
    int ledG;
    int ledB;
};

bool cRGB::Estado_Botao()
{
  // se batao for igual a true
  if(digitalRead(botao) == HIGH){
    btn_pressionado = 1;
    btn_liberado = 0;
  }else {
    btn_liberado = 1;
  }
  
  if(btn_pressionado == 1 && btn_liberado == 1){
    btn_pressionado = 0;
    btn_liberado = 0;
    cont_clique++;//cada clique, cada ciclo, vai ser armazenado quantas vezes o botão foi clicado.
    return true; //retorne true
  }else {
    return false;
  }

}

void cRGB::Estado_Led_Rgb()
{
  //se uma das cores do led RGB for igual a HIGH
  if(digitalRead(ledR) == HIGH || digitalRead(ledG) == HIGH || digitalRead(ledB) == HIGH){
    //Desligar o led RGB
    digitalWrite(ledR, LOW);
    digitalWrite(ledG, LOW);
    digitalWrite(ledB, LOW);
    //chamar a função trocar a cor led
    Trocar_Cor_Rgb();
  }else{
    Trocar_Cor_Rgb();
  }
}

void cRGB::Trocar_Cor_Rgb()
{
  //Cada clique do botão vai fazer o led mudar de cor.
  switch(cont_clique)
  {
    case 1: LedRGB(1,0,0);  break;
    case 2: LedRGB(0,1,0);  break;
    case 3: LedRGB(0,0,1);  break;
    case 4: LedRGB(1,1,0);  break;
    case 5: LedRGB(0,1,1);  break;
    case 6: LedRGB(1,0,1);  break;

    //case 1: Led_Vermelho(); break;
    //case 2: Led_Verde();    break;
    //case 3: Led_Azul();     break;
    //case 4: Led_Amarelo();  break;
    //case 5: Led_Ciano();    break;
    //case 6: Led_Margenta(); break;
    default: 
      //Desligar todos os leds
      //Desligar_Led_Rgb();
      LedRGB(0,0,0);
      cont_clique = 0;
    break;
  }
}


void cRGB::LedRGB(int cor1, int cor2, int cor3)
{
  digitalWrite(ledR, cor1);
  digitalWrite(ledG, cor2);
  digitalWrite(ledB, cor3);
}
/*
void cRGB::Led_Vermelho()
{
  Serial.println("Led: vermelho.");
  digitalWrite(ledG, LOW);
  digitalWrite(ledB, LOW);
  digitalWrite(ledR, HIGH);//Ligar cor vermelha
}

void cRGB::Led_Verde()
{
  Serial.println("Led: Verde.");
  digitalWrite(ledR, LOW);
  digitalWrite(ledB, LOW);
  digitalWrite(ledG, HIGH);//Ligar cor verde
}

void cRGB::Led_Azul()
{
  Serial.println("Led: Azul");
  digitalWrite(ledR, LOW);
  digitalWrite(ledG, LOW);
  digitalWrite(ledB, HIGH);//Ligar cor azul
}

void cRGB::Led_Amarelo()
{
  Serial.println("Led: Amarelo");
  digitalWrite(ledB, LOW);
  digitalWrite(ledG, HIGH);//Ligar cor verde.
  digitalWrite(ledR, HIGH);//Ligar cor vermelha.
}

void cRGB::Led_Ciano()
{
  Serial.println("Led: Ciano");
  digitalWrite(ledR, LOW);
  digitalWrite(ledG, HIGH);//Ligar cor Verde.
  digitalWrite(ledB, HIGH);//ligar cor azul.
}

void cRGB::Led_Margenta()
{
  Serial.println("Led: Margenta");
  digitalWrite(ledG, LOW);
  digitalWrite(ledR, HIGH);//Ligar cor vermelha.
  digitalWrite(ledB, HIGH);//Ligar cor azul.
}

void cRGB::Desligar_Led_Rgb()
{
  digitalWrite(ledR, LOW);
  digitalWrite(ledG, LOW);
  digitalWrite(ledB, LOW);
  cont_clique = 0;
}
*/

void setup()
{
  //Para estabelecer a cominicação com Arduíno com o motor serial.
  Serial.begin(9600);
}

void loop()
{
  //instanciando um objeto do tipo cRGB com o modificador static
  //Quando o loop completar um ciclo o objeto com o modificar static não será destruído da memória
  //temporária do Arduíno, ela será criada um vez na região da memória global/static e só será
  //destruída quando o Arduíno for deligado ou quando for pressionado o botão de reset.
  static cRGB LedRGB;
  //o objeto vai chamar um método chamado estado do botão, essa função ou método é
  //do tipo  bool e uma estrutura  condicional vai receber o valor retornado por ela.
  //se objeto.Estado_Botao() for igual a verdadeiro
  if(LedRGB.Estado_Botao()){
    // objeto vai charmar a função que verificar se o led RGB está ligado ou não
    LedRGB.Estado_Led_Rgb();
    
  }
  delay(200);//delay para evitar que quando pressionar o botao e liberado não pule alguma cor.

}





/*
LÓGICA

class cRGB
{
  publico:
  criar um construtor e um destrutor para inicializar os variáveis membros dessa classe.
    cRGB(){  botao = 3; btnpressionado = 0; btnliberado = 0; cont = 0; ledR = 4; ledG = 5; ledB = 6;}
    -cRGB(){vazio}

  aqui fica os membro e métotos de acesso que o objto desse tipo pode acessar, 
  e por meio dos método de acesso públicos podem acessar os membro privados ou métodos 
  privados.

    bool Estado_Botao();
    void Estado_led_Rgb();
    void Trocar_Cor_Rgb();

      
    void Led_Verde();    
    void Led_Azul();     
    void Led_Amarelo();  
    void Led_Ciano();    
    void Led_Margenta(); 
    void Desligar_Led_RGB();
  
  privados:
  Aqui fica as variáveis membros que são acessadas somente pelas função método chamadadas pelo o obtjeto desse tipo
    int botao;
    int btnpressionado;
    int btnliberado;
    int cont;
    int ledR;
    int ledG;
    int ledB;

};


Para definir as funções métodos tem que colocar o seu tipo, 
depois o nome da classe, duplo símbolo duplo de dois-postos 
e por fim o nome da função, seus parentes e abre e fecha chaves

void cRGB::Estado_Botao()
{
  se botao for igual HIGH
    btnpressionado = 1;
    btnliberado = 0;
  se não 
    btnliberado = 1;
  
  se btnpressionado for igual a 1 E btnliberado for igual a 1
    return true;
  se não 
    return 0;     
}

void cRGB::Estado_Led_Rgb()
{
  se ledR for igual a 1 ou ledG for igual a 1 ou ledB for igual a 1
    desligar todos os leds e chamar a função troca de cor.
    chamar função Trocar_Cor_Rgb(); 
  se não
    chamar função Trocar_Cor_Rgb();
}

void cRGB::Trocar_Cor_Rgb()
{
  Essa função é responsável por mudar o car do led cada vez que o botão for clicado
  Usando uma variável membro do tipo int para armazenar quantas vez o botão foi clicado, 
  a quantidade de vez que o batão foi cliacado vai ser usado para mudar de cor. Para que isso
  aconteça será necessário usar uma estrutura condicional, pode de if-alse ou a switch
  cont++;
  swtich(cont)
  {
    case 1: chamar a função Led_Vermelho(); break;
    case 2: chamar a função Led_Verde();    break;
    case 3: chamar a função Led_Azul();     break;
    case 4: chamar a função Led_Amarelo();  break;
    case 5: chamar a função Led_Ciano();    break;
    case 6: chamar a função Led_Margenta(); break;
    default: chamar a Desligar_Led_RGB();   break;
  }
}

definir as funções método que faz o led acender as cores.
void cRGB::Led_Vermelho()
{
  
  Desligar o resto e ligar o led vermelho
  

}
void cRGB::Led_Verde()
{
  desligar o resto e ligar o led verde
}

void cRGB::Led_Azul()
{

  desligar o resto e ligar o led Azul

} 


void cRGB::Led_Amarelo()
{
  desligar o restio e ligar o led vermelho e verde
}


void cRGB::Led_Ciano()
{
  desligar o resto e ligar o verde e azul
}

void cRGB::Led_Margenta()
{

    Desligar o resto e ligar o led vermelho e azul

}


função setup()
  configurar as porta dos led
fim setup.


void loop()
  instanciar um objeto do tipo cRGB com o modificador static 
  não usar a estrutura while(1). Ao colocar o objeto com a palavra reservada static  ele não será
  destruído toda vez que o loop é reiniciado, então o loop while é desnecessário e pode gerar bug
    
    o objeto vai chamar um método chamado Verificar estado do botão, essa função ou método é
    do tipo  bool e uma estrutura  condicional vai receber o valor retornado por ela.
   
  se funcão objeto.Estado_Botao() for igual a verdadeiro
    objeto vai charmar a função que verificar se o led RGB está ligado ou não
    objeto.Estado_Led_Rgb();
    

fim loop.

setup void 


*/