arduino, eletrônica, robotica...

função para fazer um numero ir acelerando (logaritmo)

Ola.

To querendo fazer o seguinte :

Um tipo de aceleração e desaceleração de um numero de 1 ate 100 por exemplo.

Vamos supor que em 10 segundos eu queira acelerar lentamente um numero e ele vai gradativamente com o passar do tempo aumentando seu valor comecando em 1 e chegando a 100 quando tiver se passado 10 segundos.

E depois fazer o inverso comecar em 100 e ir diminuindo ate chegar em 1 nos mesmo 10 segundos...

Acho que a chave é log(variavel);

Pelo que vi, parece que pode ser assim : log(variavel) / log(10);

Alguem se habilita a escrever esta pequena função ?

Valeu,

Jota

Curtir

0 membros curtem isto

Exibições: 1050

▶ Responder esta

Respostas a este tópico

Permalink Responder até fabio henrique em 19 janeiro 2013 at 8:43

não precisa de logaritmo, procure por easing arduino, já tem até biblioteca pronta olha esse video de servos com easing

https://www.youtube.com/watch?v=g6uo2K8M6BM

▶ Responder

Permalink Responder até Alex Sander de Souza Pereira em 19 janeiro 2013 at 12:58

Amigo tens que usar timer, exemplo se queres encrementar ou decrementar 100 unidades em 10segundos, precisa dividir o tempo total (10000 por 100) e fazer um encremento a cada 100ms

se tiveres dificuldade para fazer esta funcao, me da um toq no chat que faco pra ti em 5minuto

▶ Responder

Permalink Responder até Mauricio Lobo em 19 janeiro 2013 at 13:06

Eu usuaria a função map()

http://arduino.cc/en/Reference/Map

▶ Responder

Permalink Responder até Jota em 19 janeiro 2013 at 15:49

Achei o caminho é pelo easing mesmo.

Segue um exemplo de um numero que vai aumentado de valor, pode ser usado para dar mais delay (ou menos se for invertido), aumentar a luminozidade de um led, etc....

Se quiser pode fazer a função retornar o valor ao inves de imprimi-lo, fiz so para testar os numeros na saida serial.

Espero ter ajudado outros...

void setup(void)
{ Serial.begin(9600);
slow_acceleration(1,10,100);
}

void slow_acceleration(float A,float B,float N)
{ float i,v,X;
for (int i = 0; i < N; i++)
{
v = i / N;
v = v * v;
X = (A * v) + (B * (1 - v));
Serial.println(X);
delay(50); }
}

▶ Responder

Permalink Responder até Alex Sander de Souza Pereira em 19 janeiro 2013 at 16:30

amigo esta funcao nada mais e´do que A=valor de incremento, B=tempo delay para cada incremento, N=final de incremento, porém esta funcao nao creio que deva funcionar bem, nao vi ele usando timer nenhuma vez, e por exemplo, tu disse que queria que o numero de incrementos fosse executado em 10 segundos, digamos que ao inves de 100 incrementos tu fosse usar 1000 incrementos, essa funcão do jeito que esta ai já não funcionaria, vou te mandar uma função que vou fazer agora, daqui a pouco te mando

▶ Responder

Permalink Responder até Mauricio Lobo em 19 janeiro 2013 at 16:48

void setup(){
int aceleracaoInicial = 1;
int aceleracaoFinal = 100;
int tempo = 10;
aceleracao(aceleracaoInicial, aceleracaoFinal, tempo);
}

void loop(){
}

void aceleracao(int aceleracaoInicial, int aceleracaoFinal, int tempo){
//1 segungo são 1000 milisegundos
int segungos = 1000;

for(int i = 0; i < tempo; i++){
int velocidade = map(i, 0, tempo, aceleracaoInicial, aceleracaoFinal);
//faça o que quiser com a velocidade

//Aguarde um segundo já q o tempo está em segundos.
delay(segungos);
}
}

Apenas respondendo a esse problema como uma Álgebra Linear. O tempo é o X e a velocidade é o Y, fazendo uma reta em um gráfico, terá uma função linear. (tanto faz se for pra cima ou pra baixo).

▶ Responder

Permalink Responder até Alex Sander de Souza Pereira em 19 janeiro 2013 at 17:26

amigo, usar delay faz o resto do programa parar, nao aconselho usar delay, use o timer

▶ Responder

Permalink Responder até Jota em 19 janeiro 2013 at 17:48

Não sei se eu que não entendi direito mas me pareceu que esse codigo que o Mauricio postou é uma aceleração linear e o que eu queria era uma aceleração gradual como neste exemplo :

http://easings.net/pt-br#easeInQuint

No codigo que eu postei acima vai ver que o numero vai alterando lentamente e gradativamente no comeco e vai acelerando cada vez mais...

Para ver melhor o efeito pode usar 100 no segundo paramentro : slow_acceleration(1,100,100);

Muito pouca diferença nos 2 primeiros resultados :

100.00
99.99
.

E um salto brusco nos ultimos :

4.92
2.97

Aqui tem um demostrativo de outras curvas.

http://easings.net/pt-br

Alguem se habilita a simplificar a implementação para o Arduino ao inves das classes das curvas que ja foram criadas ?

Valeu!

▶ Responder

Permalink Responder até Alex Sander de Souza Pereira em 19 janeiro 2013 at 17:50

Amigo faça o seguinte, não testei o codigo pq meu arduino esta na empresa aonde trabalho, mais e 99% para funcionar

copia o codigo abaixo

int variavel = 0; // variavel de processo

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

void loop()
{
aceleracao(variavel,1,100,10000); // P1=variavel , P2=valor do incremento, P3=valor maximo incremento P4=tempo em milisegundos para finalizar incremento
}

void aceleracao(int valor,int valor_incremento, int maximo_incremento, int milisegundos)
{

int tempo_base = milisegundos / maximo_incremento; //tempo para cada incremento
unsigned long tempo = millis(); //pega tempo atual
for (int i=valor; millis()>(tempo+tempo_base) ;i++) //realiza o for
{
variavel++; //incrementa a variavel
Serial.println(variavel); //imprime na serial
tempo = millis(); //atualiza tempo atual para um novo incremento
}
}