LusoRobótica - Robótica em Português

Robótica => Iniciantes => Tópico iniciado por: joaobernardino em 27 de Outubro de 2010, 21:08

Título: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 27 de Outubro de 2010, 21:08
Boa noite, estou agora a iniciar-me no mundo arduino. O meu projecto é o seguinte Kaoss Pad Touch Screen Midi Controller (http://www.youtube.com/watch?v=1p2PwtdcCNg#) .
O led RGB tem dois programas, um loop que está sempre a executar e outro que activa quando toco no touchpad e que depois altera a cor consoante o movimento.
Agora de inicio como ainda não chegou o touchpad estou a trabalhar no led RGB quando está solto, o loop, mas sem sucesso.
Eu queria fazer o seguinte :

motion de 0 para 255 a voltar a 0 com o vermelho
motion de 0 para 255 a voltar a 0 com o verde
motion de 0 para 255 a voltar a 0 com o azul
motion de 0 para 255 com vermelho juntamente com motion de 0 para 255 com azul para dar roxo

etc...

Alguém me consegue ajudar ??
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 27 de Outubro de 2010, 21:20
Como se fosse este exemplo:
Mas com um fade entre cada cor e não pode ser tão demorado porque vou estar a enviar sinal midi em simultâneo.

/*
* Codigo para testar led RGB
* Ativa as cores principais dos leds em sua intensidade maxima e as misturas entre elas
* Baseado no exemplo constante no site do Arduino
* Jeronimo Avelar Filho <jeronimo@blogdoje.com.br>
*/

// Saida
int greenPin = 6; // conectado ao led verde no pino 09
int bluePin = 9; // conectado ao led azul no pino 10
int redPin = 5; // conectado ao led vermelho no pino

// Variaveis do Programa

int wait = 500; // 500 ms menor valor = transicoes rapidas
int i ;

void setup()
{

pinMode(redPin, OUTPUT); // configura os pinos como saida
pinMode(greenPin, OUTPUT); // não é necessario no Arduino007
pinMode(bluePin, OUTPUT);
i = 1 ;

}

// Main program
void loop()
{

switch (i) { //

case 1: // Vermelho
ativaRgb(255,0,0) ;
break;

case 2: // Verde
ativaRgb(0,255,0) ;
break;

case 3: // Azul
ativaRgb(0,0,255) ;
break;

case 4: // Amarelo
ativaRgb(255,255,0);
break;

case 5: // Cyano
ativaRgb(0,255,255) ;
break;

case 6: // Magenta
ativaRgb(255,0,255) ;
break;

case 7: // Branco ( todos os leds acessos)
ativaRgb(255,255,255);
break;

}
delay(wait) ;
i=i+1 ;
if( i > 7) i= 1 ;

}

void ativaRgb(int redVal,int greenVal, int blueVal) {

analogWrite(redPin, redVal); // Escreve o valor do PWM do led vermelho
analogWrite(greenPin, greenVal); // Escreve o valor do PWM do led verde
analogWrite(bluePin, blueVal); // Escreve o valor do PWM do led azul

}
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 27 de Outubro de 2010, 21:25
Não precisas de fazer assim.
Nem precisas de delay para fazer o fade. Usas o millis() para fazer o fade como queres, e o delay para controlares o fluxo de dados de MIDI.

Dá uma olhada: http://arduino.cc/en/Tutorial/BlinkWithoutDelay (http://arduino.cc/en/Tutorial/BlinkWithoutDelay)

Só tens de ter uma variável que guarda o valor para cada um dos LEDs (0-255) e mais uma para o estado (8 estados para o que queres fazer - 4 para fazer subir os valores e outros 4 para descer), depois a de cada vez que queres actualizar os LEDs, lês primeiro o estado e depois actuas consoante esse estado.
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 27 de Outubro de 2010, 21:34
Obrigado pela rápida resposta. Não consegues dar um exemplo mais concreto?
Porque eu tenho 3 saídas e não uma e não estou a ver como fazer o fade..

Desculpa a minha ignorância no assunto!
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 27 de Outubro de 2010, 22:00
Ok... Vamos lá então.  :)

Defines 8 estados: (exemplo apenas)
1- aumentar vermelho até 255
2- diminuir vermelho até 0
3- aumentar verde até 255
...
7- aumentar vermelho+azul até 255
8- diminuir vermelho+azul até 0

Para saberes em que estado estás, defines uma nova variável inteira:
Código: [Seleccione]
int state = 1;
depois para cada um dos LEDs defines os valores:
Código: [Seleccione]
int redVal = 0;
int greenVal = 0;
int blueVal = 0;

A função millis() retorna-te o nº de milisegundos que passaram desde que o código começou a correr (tipo unsigned long).
Logo tens de ter mais duas variáveis:
Código: [Seleccione]
unsigned long previousMillis = millis();
unsigned long currentMillis;

Código: [Seleccione]
currentMillis = millis();
 
if(currentMillis - previousMillis > 500) { // Se quiseres fazer o update a cada 500ms
  previousMillis = currentMillis;  // salvas o novo valor de tempo

  // fazes o que queres de acordo com o estado
  switch(state){
    case 1:
    {
      if(redVal < 255) redVal++; // se ainda nao chegámos aos 255, aumenta o valor de redVal
      else state = 2; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 2:
        ................

    case 7:
    {
      if(redVal < 255){
        redVal++;
        blueVal++;
      }else state = 8;
      break;
    }
  }
 
  // Actualizas os valores nos LEDs, independentemente do estado
  analogWrite(redPin, redVal); // Escreve o valor do PWM do led vermelho
  analogWrite(greenPin, greenVal); // Escreve o valor do PWM do led verde
  analogWrite(bluePin, blueVal); // Escreve o valor do PWM do led azul
}

Espero que tenhas percebido o suficiente para conseguires completar o código com o resto das condições, estados, etc...
Não te esqueças que a troca de estado quando estás no último, é para o primeiro...
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 27 de Outubro de 2010, 22:18
Assim?

Código: [Seleccione]


void setup(){
  int state = 1;
 
case 1: // Vermelho
int redVal = 255;
int greenVal = 0;
int blueVal = 0;
break;

case 2: // Verde
int redVal = 0;
int greenVal = 255;
int blueVal = 0;
break;

case 3: // Azul
int redVal = 0;
int greenVal = 0;
int blueVal = 255;
break;

case 4: // Amarelo
int redVal = 255 ;
int greenVal = 255;
int blueVal = 0;
break;

case 5: // Cyano
int redVal = 0;
int greenVal = 255;
int blueVal = 255;
break;

case 6: // Magenta
int redVal = 255;
int greenVal = 0;
int blueVal = 255;
break;

case 7: // Branco ( todos os leds acessos)
int redVal = 255;
int greenVal = 255;
int blueVal = 255;
break;
}

void loop(){
unsigned long previousMillis = millis();
unsigned long currentMillis;


currentMillis = millis();
 
if(currentMillis - previousMillis > 500) { // Se quiseres fazer o update a cada 500ms
  previousMillis = currentMillis;  // salvas o novo valor de tempo

  // fazes o que queres de acordo com o estado
  switch(state){
    case 1:
    {
      if(redVal < 255) redVal++; // se ainda nao chegámos aos 255, aumenta o valor de redVal
      else state = 2; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 2:
    {if(greenVal < 255) greenVal++; // se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
       

    case 7:
    {
      if(redVal < 255){
        redVal++;
        blueVal++;
      }else state = 8;
      break;
    }
  }
 
  // Actualizas os valores nos LEDs, independentemente do estado
  analogWrite(redPin, redVal); // Escreve o valor do PWM do led vermelho
  analogWrite(greenPin, greenVal); // Escreve o valor do PWM do led verde
  analogWrite(bluePin, blueVal); // Escreve o valor do PWM do led azul
}
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 27 de Outubro de 2010, 22:36
Tens aí vários erros...

Revê o teu código e vê se ele faz sentido...
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 27 de Outubro de 2010, 22:37
Eu não estou a perceber onde é que vou indicar os estados
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 27 de Outubro de 2010, 22:43
Eu não estou a perceber onde é que vou indicar os estados

Tu não tens de indicar explicitamente os estados. Só tens de programar o que cada um faz... Se o numero do 1º estado é 1 ou 345676543 tanto faz, apenas ordenamos para ser mais fácil.
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 27 de Outubro de 2010, 22:52
Se não for isto não estou mesmo a perceber o que queres dizer  :(
Código: [Seleccione]


void setup(){
  int state = 1;
 
}

void loop(){
unsigned long previousMillis = millis();
unsigned long currentMillis;


currentMillis = millis();
 
if(currentMillis - previousMillis > 500) { // Se quiseres fazer o update a cada 500ms
  previousMillis = currentMillis;  // salvas o novo valor de tempo

  // fazes o que queres de acordo com o estado
  switch(state){
    case 1:
    int redVal = 255;
    int greenVal = 0;
    int blueVal = 0;
    {
      if(redVal < 255) redVal++; // se ainda nao chegámos aos 255, aumenta o valor de redVal
      else state = 2; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 2:
    int redVal = 0;
int greenVal = 255;
int blueVal = 0;
    {if(greenVal < 255) greenVal++; // se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 3:
    int redVal = 0;
int greenVal = 0;
int blueVal = 255;
    {if(blueVal < 255) blueVal++; // se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 4:
    int redVal = 255;
int greenVal = 255;
int blueVal = 0;
    {if(greenVal < 255) greenVal++; redVal++;// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 5:
    int redVal = 0;
int greenVal = 255;
int blueVal = 255;
    {if(greenVal < 255) greenVal++; blueVal++;// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 6:
    int redVal = 255;
int greenVal = 0;
int blueVal = 255;
    {if(redVal < 255) redVal++; blueVal++;// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
       
  case 7:
  int redVal = 255;
int greenVal = 255;
int blueVal = 255;
    {
      if(redVal < 255){
        redVal++;
        blueVal++;
        greenVal++;
      }else state = 1;
      break;
    }
  }
 
  // Actualizas os valores nos LEDs, independentemente do estado
  analogWrite(redPin, redVal); // Escreve o valor do PWM do led vermelho
  analogWrite(greenPin, greenVal); // Escreve o valor do PWM do led verde
  analogWrite(bluePin, blueVal); // Escreve o valor do PWM do led azul
}
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 27 de Outubro de 2010, 23:09
Sim, era isso. Um problema já resolveste.  ;)

Outra dica. Se declarares uma variável dentro de uma função, perdes o seu valor quando a função acaba.
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 27 de Outubro de 2010, 23:14
Passo o int state = 1; Para o inicio de tudo. Mas continua com erros  :(
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 27 de Outubro de 2010, 23:16
Passo o int state = 1; Para o inicio de tudo. Mas continua com erros  :(
Errado.

Verifica onde é que são declarados os previousMillis e currentMillis no link que te enviei na primeira resposta.
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 27 de Outubro de 2010, 23:26
Fica estranho
Código: [Seleccione]

unsigned long previousMillis = millis();

void setup(){
int state = 1;
 
}

void loop(){

unsigned long currentMillis;

currentMillis = millis();
 
if(currentMillis - previousMillis > 500) { // Se quiseres fazer o update a cada 500ms
  previousMillis = currentMillis;  // salvas o novo valor de tempo
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 27 de Outubro de 2010, 23:28
Não fica estranho, fica bem  ;D

Agora fazes o mesmo para os valores de redVal, greenVal, blueVal, ... etc
Isto para conseguires guardar os valores de cada um, para poderes alterar esse valor em cada iteração.
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 27 de Outubro de 2010, 23:31

 
unsigned long previousMillis = millis();
int redVal = 0;
int greenVal = 0;
int blueVal = 0;

void setup(){
int state = 1;
 
}

void loop(){

unsigned long currentMillis;

currentMillis = millis();
 
if(currentMillis - previousMillis > 500) { // Se quiseres fazer o update a cada 500ms
  previousMillis = currentMillis;  // salvas o novo valor de tempo

  // fazes o que queres de acordo com o estado
  switch(state){
    case 1:
    int redVal = 255;
    int greenVal = 0;
    int blueVal = 0;
    {
      if(redVal < 255) redVal++; // se ainda nao chegámos aos 255, aumenta o valor de redVal
      else state = 2; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 2:
    int redVal = 0;
    int greenVal = 255;
    int blueVal = 0;
    {if(greenVal < 255) greenVal++; // se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 3:
    int redVal = 0;
int greenVal = 0;
int blueVal = 255;
    {if(blueVal < 255) blueVal++; // se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 4:
    int redVal = 255;
int greenVal = 255;
int blueVal = 0;
    {if(greenVal < 255) greenVal++; redVal++;// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 5:
    int redVal = 0;
int greenVal = 255;
int blueVal = 255;
    {if(greenVal < 255) greenVal++; blueVal++;// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 6:
    int redVal = 255;
int greenVal = 0;
int blueVal = 255;
    {if(redVal < 255) redVal++; blueVal++;// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
       
  case 7:
  int redVal = 255;
int greenVal = 255;
int blueVal = 255;
    {
      if(redVal < 255){
        redVal++;
        blueVal++;
        greenVal++;
      }else state = 1;
      break;
    }
  }
 
  // Actualizas os valores nos LEDs, independentemente do estado
  analogWrite(redPin, redVal); // Escreve o valor do PWM do led vermelho
  analogWrite(greenPin, greenVal); // Escreve o valor do PWM do led verde
  analogWrite(bluePin, blueVal); // Escreve o valor do PWM do led azul
}
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 27 de Outubro de 2010, 23:32
Bem já mereces um prémio. xD O que falta agora?
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 27 de Outubro de 2010, 23:36
Lol... Agora falta tirar aquelas declarações a seguir a cada case...
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 27 de Outubro de 2010, 23:38
ok, continua com erros

Código: [Seleccione]
#define redPin 5;
#define grennPin 6;
#define blue pin 9;
 
unsigned long previousMillis = millis();
int redVal = 0;
int greenVal = 0;
int blueVal = 0;

void setup(){
int state = 1;
 
}

void loop(){

unsigned long currentMillis;

currentMillis = millis();
 
if(currentMillis - previousMillis > 500) { // Se quiseres fazer o update a cada 500ms
  previousMillis = currentMillis;  // salvas o novo valor de tempo

  // fazes o que queres de acordo com o estado
  switch(state){
    case 1:
 
    {
      if(redVal < 255) redVal++; // se ainda nao chegámos aos 255, aumenta o valor de redVal
      else state = 2; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 2:
   
    {if(greenVal < 255) greenVal++; // se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 3:

    {if(blueVal < 255) blueVal++; // se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 4:

    {if(greenVal < 255) greenVal++; redVal++;// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 5:

    {if(greenVal < 255) greenVal++; blueVal++;// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 6:

    {if(redVal < 255) redVal++; blueVal++;// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
       
  case 7:
 
    {
      if(redVal < 255){
        redVal++;
        blueVal++;
        greenVal++;
      }else state = 1;
      break;
    }
  }
 
  // Actualizas os valores nos LEDs, independentemente do estado
  analogWrite(redPin, redVal); // Escreve o valor do PWM do led vermelho
  analogWrite(greenPin, greenVal); // Escreve o valor do PWM do led verde
  analogWrite(bluePin, blueVal); // Escreve o valor do PWM do led azul
}
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 27 de Outubro de 2010, 23:41
Já tentaste ler o erro?  ;D
Eu vejo mais um erro sintático. Vejo outros, mas isso tem a ver com o resultado que vais obter...  :)
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 27 de Outubro de 2010, 23:42
O programa menciona que o erro está aqui switch(state){ ????
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 27 de Outubro de 2010, 23:45
Já resolvi esse. Falta um
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 27 de Outubro de 2010, 23:45
Será que dentro da função loop() ele sabe o que é a variável "state"?

Lembra-te do que disse atrás... Se a declarares dentro de uma função, ela só está disponível dentro dessa função.
Mais concretamente, se declarares o state no setup(), só tens essa variável disponível no setup(). Quando a função acaba, essa variável é apagada da memória.

Seguindo a mesma lógica, vais ter de mudar a declaração para um nível mais acima (fora das funções)
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 27 de Outubro de 2010, 23:47
Já está resolvido, mas falta outra coisa que não chego lá
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 27 de Outubro de 2010, 23:49
Já está resolvido, mas falta outra coisa que não chego lá
Agora também não estou a ver... Amigo, se não me disseres qual é o erro que aparece, não te consigo ajudar.
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 27 de Outubro de 2010, 23:51
codigo_led.cpp: In function 'void loop()':
codigo_led:77: error: expected `)' before ';' token
codigo_led:77: error: expected primary-expression before ',' token
codigo_led:77: error: expected `;' before ')' token
codigo_led:78: error: 'greenPin' was not declared in this scope
codigo_led:79: error: 'bluePin' was not declared in this scope
codigo_led:80: error: expected `}' at end of input
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 27 de Outubro de 2010, 23:55
Tens um erro nos defines (nos 3)... descobre ;)

Depois, precisas de incluír chavetas - {} - quando tens mais do que uma instrução dentro de um if (já agora, isto aplica-se a if's, for's, while's, etc...)
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 27 de Outubro de 2010, 23:57
no define já tinha reparado. agora está assim e continua a dar erro.

erro

codigo_led.cpp: In function 'void loop()':
codigo_led:77: error: expected `)' before ';' token
codigo_led:77: error: expected primary-expression before ',' token
codigo_led:77: error: expected `;' before ')' token
codigo_led:78: error: expected `)' before ';' token
codigo_led:78: error: expected primary-expression before ',' token
codigo_led:78: error: expected `;' before ')' token
codigo_led:79: error: expected `)' before ';' token
codigo_led:79: error: expected primary-expression before ',' token
codigo_led:79: error: expected `;' before ')' token


Código: [Seleccione]
#define redPin 5;
#define greenPin 6;
#define bluePin 9;
 
unsigned long previousMillis = millis();
int redVal = 0;
int greenVal = 0;
int blueVal = 0;
int state = 1;

void setup(){

 
}

void loop(){

unsigned long currentMillis;

currentMillis = millis();
 
if(currentMillis - previousMillis > 500)  // Se quiseres fazer o update a cada 500ms
  previousMillis = currentMillis;  // salvas o novo valor de tempo

  // fazes o que queres de acordo com o estado
  switch(state){
    case 1:
 
    {
      if(redVal < 255){ redVal++; }// se ainda nao chegámos aos 255, aumenta o valor de redVal
      else state = 2; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 2:
   
    {if(greenVal < 255){ greenVal++; }// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 3:

    {if(blueVal < 255) {blueVal++;} // se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 4; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 4:

    {if(greenVal < 255) {greenVal++; redVal++;}// se ainda nao chegámos aos 255, aumenta o valor de greenVal
    else state = 5; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 5:

    {if(greenVal < 255) {greenVal++; blueVal++;}// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 6; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
    case 6:

    {if(redVal < 255) {redVal++; blueVal++;}// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 7; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
    }
       
  case 7:
 
    {
      if(redVal < 255){
        redVal++;
        blueVal++;
        greenVal++;
      }else state = 1;
      break;
    }
  }
 
 
  analogWrite(redPin, redVal); // Escreve o valor do PWM do led vermelho
  analogWrite(greenPin, greenVal); // Escreve o valor do PWM do led verde
  analogWrite(bluePin, blueVal); // Escreve o valor do PWM do led azul
}
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 28 de Outubro de 2010, 00:03
Continuas a ter erro nos defines
http://www.arduino.cc/en/Reference/Define (http://www.arduino.cc/en/Reference/Define)
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 28 de Outubro de 2010, 00:06
Já corrigi já programei e apenas acende o led com 3 cores fracas e não passa dai
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 28 de Outubro de 2010, 00:08
Compilar já é meio caminho andado...

Agora desafio-te a tentares correr o código sequencialmente passo-a-passo (na tua cabeça, claro, ou num papel) para perceberes o que está a acontecer...

HINT: Tu queres fazer update aos valores apenas quando passaram 500ms desde o último update, e não em todos os ciclos loop.
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 28 de Outubro de 2010, 00:11
Para isso tenho isto:

if(currentMillis - previousMillis > 500)  // Se quiseres fazer o update a cada 500ms
  previousMillis = currentMillis;  // salvas o novo valor de tempo
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 28 de Outubro de 2010, 00:12
Estás muito perto...  :)

O problema é que não tens o switch() dependente desse IF(), ou seja, o teu switch vai acontecer, quer a condição seja verdadeira ou falta.
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 28 de Outubro de 2010, 00:17
Já está. Mas continua a não executar nada como pretendido

Código: [Seleccione]
void loop(){

unsigned long currentMillis;

currentMillis = millis();
 
if(currentMillis - previousMillis > 500) { // Se quiseres fazer o update a cada 500ms
  previousMillis = currentMillis;  // salvas o novo valor de tempo

 
  switch(state){
    case 1:
 
    {
      if(redVal < 255){ redVal++; }// se ainda nao chegámos aos 255, aumenta o valor de redVal
      else state = 2; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
     
    }
    case 2:
   
    {if(greenVal < 255){ greenVal++; }// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
   
    }
    case 3:

    {if(blueVal < 255) {blueVal++;} // se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 4; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
     
    }
    case 4:

    {if(greenVal < 255) {greenVal++; redVal++;}// se ainda nao chegámos aos 255, aumenta o valor de greenVal
    else state = 5; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
   
    }
    case 5:

    {if(greenVal < 255) {greenVal++; blueVal++;}// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 6; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
   
    }
    case 6:

    {if(redVal < 255) {redVal++; blueVal++;}// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 7; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
     
    }
       
  case 7:
 
    {
      if(redVal < 255){redVal++;blueVal++; greenVal++;}
      else state = 1;
     
    }
  }
}
  analogWrite(redPin, redVal); // Escreve o valor do PWM do led vermelho
  analogWrite(greenPin, greenVal); // Escreve o valor do PWM do led verde
  analogWrite(bluePin, blueVal); // Escreve o valor do PWM do led azul
}
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 28 de Outubro de 2010, 00:20
Muito bem...

Agora é uma questão de codificar "o pretendido". :)

Se queres que o vermelho vá de 0 a 255 e de seguida de 255 a 0, tens de codificar isso.
Eu só te vejo a incrementar o valor das variáveis. Não há nenhum sítio onde tu decrementes os valores.

Até tenho medo só de pensar na confusão de valores que estás a passar ao analogWrite() :P Mas não te preocupes com isso, pensa só no que te disse.
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: Cynary em 28 de Outubro de 2010, 00:21
Gostaria de ajudar, no entanto, é muito código para ler xD e o teu objectivo está um pouco confuso :S
Consegues especificar melhor o que pretendes fazer?
Pelo que percebi do vídeo, queres variar a cor de um LED RGB, de acordo com a posição do toque no touchpad, correcto?
Nesse caso, não me preocuparia com o fade, mas tiraria o valor do x,y,z do touchpad, e usaria esses valores para o analogWrite, de forma a mudar a cor, e o fade acontece com o próprio movimento.
Para fazer isto em sincronia com o enviar um sinal midi, usaria interrupções com os timers, que tratariam do LED, enquanto o código principal trataria do sinal midi.
Não uso as bibliotecas do arduino para programar, mas aqui tens um exemplo de uso de interrupções, com a biblioteca MsTimer2:
http://lusorobotica.com/index.php/topic,527.0.html (http://lusorobotica.com/index.php/topic,527.0.html)
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 28 de Outubro de 2010, 00:26
microbyte

Como codifico isso dá-me só um exemplo eu depois faço no resto.

Cynary

Obrigado pela atenção. Amanhã ou depois quando começar o código com o touchpad falo consigo, obrigado mais uma vez
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 28 de Outubro de 2010, 08:40
Para aumentar um LED, tens algo como:
redVal++;

Em que mudas de estado, quando chegas a 255.
Se queres decrementar no estado seguinte, tens de ter algo como
redVal--;
E alterar a condição de paragem para quando chegas a 0.

Tens de saltar de um estado para outro.
Assim, ele vai até 255, depois muda de estado e desce até 0.
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 28 de Outubro de 2010, 11:52
Tenho estado a trabalhar no que disses-te mas não funciona :S
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 28 de Outubro de 2010, 11:55
Código: [Seleccione]
#define redPin 5
#define greenPin 6
#define bluePin 9

unsigned long previousMillis = millis();
int redVal = 0;
int greenVal = 0;
int blueVal = 0;
int state = 1;

void setup(){
Serial.begin(9600);
  }

void loop(){

unsigned long currentMillis;

currentMillis = millis();
 
if(currentMillis - previousMillis > 500) { // Se quiseres fazer o update a cada 500ms
  previousMillis = currentMillis;  // salvas o novo valor de tempo

 
  switch(state){
    case 1:
 
   
      if(redVal < 255){ redVal++; }// se ainda nao chegámos aos 255, aumenta o valor de redVal
      else state = 2; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
     break;
   
    case 2:
   
    if(redVal == 255){ redVal--; }
    if(redVal == 0){ redVal = 0; }
    if(redVal < 20){ greenVal++; }
    if(greenVal == 250){greenVal--; }// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 3; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
   break;
   
    case 3:

    if(blueVal < 255) {blueVal++;} // se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 4; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
      break;
     
    case 4:

    if(greenVal < 255) {greenVal++; redVal++;}// se ainda nao chegámos aos 255, aumenta o valor de greenVal
    else state = 5; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
   break;
   
    case 5:

    if(greenVal < 255) {greenVal++; blueVal++;}// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 6; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
   break;
   
    case 6:

    if(redVal < 255) {redVal++; blueVal++;}// se ainda nao chegámos aos 255, aumenta o valor de greenVal
      else state = 7; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
     break;
       
  case 7:
 
    if(redVal < 255){redVal++;blueVal++; greenVal++;}
      else state = 1;
     break;
   
  }
}
  analogWrite(redPin, redVal); // Escreve o valor do PWM do led vermelho
  analogWrite(greenPin, greenVal); // Escreve o valor do PWM do led verde
  analogWrite(bluePin, blueVal); // Escreve o valor do PWM do led azul
  Serial.print("vermelho");
  Serial.print(redVal);
  Serial.print("/t verde");
  Serial.print(greenVal);
  Serial.print("/t azul");
  Serial.print(blueVal);
}
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 28 de Outubro de 2010, 12:01
Não estás a perceber o fluxo de execução do programa.
Tenta imaginar (ou faz um desenho) do fluxo de execução e de como as variáveis vão sendo alteradas ao longo de cada iteração.
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 28 de Outubro de 2010, 12:17
Já está :) Muito Obrigado
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: microbyte em 28 de Outubro de 2010, 13:56
Só falta postares aqui para outros que venham com problemas semelhantes...  ;)
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: joaobernardino em 28 de Outubro de 2010, 14:34
Aqui está o código final.

Código: [Seleccione]
#define redPin 5
#define greenPin 6
#define bluePin 9

unsigned long previousMillis = millis();
int redVal = 0;
int greenVal = 0;
int blueVal = 0;
int state = 1;

void setup(){
Serial.begin(9600);
  }

void loop(){

unsigned long currentMillis;

currentMillis = millis();
 
 //LED LED LED SOLTO **************************************************************

if(currentMillis - previousMillis > 10) { // Se quiseres fazer o update a cada 500ms
  previousMillis = currentMillis;  // salvas o novo valor de tempo

 
  switch(state){
    case 1:
 if(blueVal >0) {blueVal--;}
      if(redVal < 255){ redVal++; }// se ainda nao chegámos aos 255, aumenta o valor de redVal
      else state = 2; // se atingiste os 255, mudas para o proximo estado, onde vais decrementar o valor do vermelho
     break;
   
    case 2:
    if(redVal < 30){ greenVal++; }
    if(redVal > 0){ redVal--; }
   else state = 3;
   break;
   
       case 3:
 if(greenVal < 255){ greenVal++; }
      else state = 4;
     break;
   
    case 4:
   if(greenVal < 30){ blueVal++; }
    if(greenVal > 0){ greenVal--; }
      else state = 5;
   break;
   
    case 5:
  if(blueVal < 255) {blueVal++;}
      else state = 6;
      break;
     
      case 6:
    if(blueVal < 30) {greenVal++;}
   if(blueVal < 30) {redVal++;}
    if(blueVal > 0){ blueVal--; }
   else state = 7;
   break;
   
    case 7:
    if(redVal < 255) {redVal++;}
    if(greenVal < 255) {greenVal++; }
    else state = 8;
   break;
   
    case 8:

    if(greenVal >30){greenVal--;}
    if(redVal < 30) {blueVal++;}
    if(redVal > 0) {redVal--;}
    else state = 9;
   break;
   
     case 9:
    if(blueVal < 255) {blueVal++;}
    if(greenVal < 255) {greenVal++; }
    else state = 10;
   break;
   
    case 10:
    if(blueVal > 30) {blueVal--;}
    if(greenVal < 30) {redVal++;}
    if(greenVal > 0) {greenVal--;}
    else state = 11;
   break;
   
    case 11:
   if(redVal < 255) {redVal++;}
    if(blueVal < 255) {blueVal++;}
    else state = 12;
   break;
   
   case 12:
   if(redVal >0) {redVal--;}
    if(blueVal >0) {blueVal--;}
    if(redVal<30) {state=1;}
   
   break;
   
  }
}


  analogWrite(redPin, redVal);
  analogWrite(greenPin, greenVal);
  analogWrite(bluePin, blueVal);
  Serial.print("vermelho= ");
  Serial.print(redVal);
  Serial.print("\t verde = ");
  Serial.println(greenVal);
  Serial.print("\t azul = ");
  Serial.println(blueVal);
 
}
Título: Re: Alternar leds fazendo um fade entre eles
Enviado por: senso em 28 de Outubro de 2010, 22:12
Se queres um efeito bonitinho de transição entre as várias cores que podes obter de um led RGB experimenta isto:
Código: [Seleccione]
  int RedVal=1;
  int BlueVal=1;
  int GreenVal=1;
 
  int redPin=9;
  int bluePin=11;
  int greenPin=10;
 
  int i=1;
  void setup() {
    //Serial.begin(9600);
}

void loop() {
 
  analogWrite(redPin,RedVal);
  analogWrite(bluePin,BlueVal);
  analogWrite(greenPin,GreenVal);
 
  RedVal =((i<255)*i)+((i>=255)*255)+((i>511)*(512-i))+((i>766)*(i-766))+((i>=1276)*(i-1276))+((i>1530)*(1530-i))+((i>1786)*(1786-i));
  GreenVal =(i<256)*(1)+(i>255)*(i-255)+(i>510)*(510-i)+(i>1020)*(1020-i)+(i>1274)*(i-1274)+(i>1530)*(i-1531)+(i>1785)*(3571-(2*i));
  BlueVal =(i<764)*(1)+(i>765)*(i-765)+(i>1020)*(1020-i)+(i>1786)*(1786-i);

  if(i>2040){
   i = 1;
  }
 
  i++;
  delay(30);
 
}