Programação para Arduino – Aula 05

29 de janeiro de 2016 Luis Eduardo Arduino, Programação 0

Na aula de hoje veremos:

Matemática (Math)

  1. min();
  2. max();
  3. abs();
  4. constrain();
  5. map();
  6. pow();
  7. sqrt();

Assista a vídeo aula:

Artigo

min (x, y)

Descrição

Calcula o mínimo de dois números.

Parâmetros

x: o primeiro número, qualquer tipo de dados

y: o segundo número, qualquer tipo de dados

Devoluções

O menor dos dois números.

Exemplos

sensVal = min(sensVal, 100); // atribui sensVal ao menor de sensVal ou 100 
                              // assegurando que ele nunca fica acima de 100.

Nota

Talvez contra-intuitiva, max () é muitas vezes usado para restringir a extremidade inferior da gama de uma variável, enquanto min () é usada para restringir a extremidade superior da gama.

Aviso

Devido à forma como a função min () é implementado, evitar o uso de outras funções dentro dos colchetes, pode levar a resultados incorretos

min(var++, 100);   // evitar isso - rendimentos incorreta resultados min (var, 100);
var++;            // usar isso - mantenha outro de matemática fora da função

max (x, y)

Descrição

Calcula o máximo de dois números.

Parâmetros

x: o primeiro número, qualquer tipo de dados

y: o segundo número, qualquer tipo de dados

Devoluções

O maior dos dois valores de parâmetros.

Exemplo

sensVal = max(senVal, 20); // atribui sensVal ao maior dos sensVal ou 20 
                           // (efetivamente garantindo que ele é, pelo menos, 20)

Nota

Talvez contra-intuitiva, max () é muitas vezes usado para restringir a extremidade inferior da gama de uma variável, enquanto min () é usada para restringir a extremidade superior da gama.

Aviso

Devido à forma como a função max () é implementado, evitar o uso de outras funções dentro dos colchetes, pode levar a resultados incorretos.

max(a--, 0);   // evitar isso - rendimentos incorreta resultados 
max(a, 0); 
a--;           // usar isso - mantenha outro de matemática fora da função

abs (x)

Descrição

Calcula o valor absoluto de um número.

Parâmetros

x: o número

Devoluções

x: Se x é maior do que ou igual a 0.

-x: se x é menor que 0.

Aviso

Devido à forma como a função abs () é implementado, evitar o uso de outras funções dentro dos colchetes, pode levar a resultados incorretos.

abs(a++); // evitar isso - rendimentos incorreta resultados 
abs(a);
a++; // usar isso - mantenha outro de matemática fora da função   

constrain(x, a, b)

Descrição

Restringe um número para estar dentro de um intervalo.

Parâmetros

x: o número para restringir, todos os tipos de dados

a: A extremidade inferior da gama, todos os tipos de dados

b: a extremidade superior da gama, todos os tipos de dados

Devoluções

x: se x é entre um e b

a: se x for menor que a

b: Se x é maior do que b

Exemplo

// Limites variam de valores dos sensores para entre 10 e 150 
sensVal = constrain(sensVal, 10, 150);

map(value, fromLow, fromHigh, toLow, toHigh)

Descrição

Re-mapeia um número de um intervalo para o outro. Isto é, um valor de fromLow iria ficar mapeado para toLow, um valor de fromhigh para toHigh, valoriza-nos entre os valores nas entrelinhas, etc.

Não restringe os valores dentro do intervalo, pois os valores de fora-de-gama são por vezes pretendido e útil. A função de constrain() pode ser usado antes ou após esta função, se os limites para as gamas são desejados.

Note-se que os limites inferiores “quer” de gama pode ser maior ou menor do que os limites superiores “” de modo que o map() a função pode ser usada para reverter um intervalo de números, por exemplo

y = map(x, 1, 50, 50, 1);

A função também lida com números negativos bem, de modo que este exemplo

y = map(x, 1, 50, 50, -100);

também é válido e funciona bem.

A função do map

() usa matemática inteiro, portanto, não irá gerar frações, quando a matemática pode indicar que ele deve fazê-lo. Restos fracionários são truncados, e não são arredondados ou média.

Parâmetros

value: o número para mapear

fromLow: o limite inferior da faixa de corrente do valor

fromhigh: o limite superior da faixa de corrente do valor

toLow: o limite inferior do intervalo da meta do valor

toHigh: o limite superior da meta do valor

Devoluções

O valor mapeado.

Exemplo

/* Mapear um valor analógico para 8 bits (0 a 255) */ 
void setup() {}

void loop()
{
  int val = analogRead(0);
  val = map(val, 0, 1023, 0, 255);
  analogWrite(9, val);
}

Apêndice

Para o matematicamente inclinado, aqui está toda a função

long map(long x, long in_min, long in_max, long out_min, long out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

pow(base, exponent)

Descrição

Calcula o valor de um número elevado a uma potência. pow() pode ser usado para elevar um número a uma potência fraccionada. Isto é útil para gerar valores de mapeamento exponencial ou curvas.

Parâmetros

Base: o número (float)

expoente: o poder de que a base é aumentada (float)

Devoluções

O resultado da exponenciação (double)

Exemplo

Veja o fscale função na biblioteca de código.

/* fscale Floating Point Autoscale V0.1 Função Paul Badger 2007 Modificado de código 
por Greg Shakar Esta função irá escalar um conjunto de números de ponto flutuante 
(intervalo) para um outro conjunto de números de ponto flutuante (intervalo) 
Ele tem uma "curva" parâmetro de modo que possa ser feita a favorecer tanto a 
extremidade da saída. (Mapeamento logarítmica) Leva 6 parâmetros originalMin - o 
valor mínimo do intervalo original - esta deve ser inferior a origninalMax 
originalMax - o valor máximo da escala original - esta deve ser maior que 
orginalMin Newbegin - a extremidade do novo gama que mapeia para orginalMin - 
pode ser menor, ou maior, do que newEnd, para facilitar invertendo as gamas newEnd 
- a extremidade do novo gama que mapeia para originalMax - que pode ser maior ou 
menor, do que Newbegin, para facilitar invertendo as gamas ValorEntrada - a variável
 para a entrada que irá mapeados para os intervalos dados, esta variável é restrito 
a originaMin <= ValorEntrada <= originalMax curva - curva representa a curva que pode 
ser feita a favorecer uma ou outra extremidade da escala de saída no mapeamento. Os 
parâmetros são de -10 a 10, com 0 sendo          um mapeamento linear (que basicamente 
leva curva de fora da equação) Para entender o parâmetro de curva de fazer algo 
parecido com isto: 
void loop(){  
   for ( j=0; j < 200; j++){   
        scaledResult = fscale( 0, 200, 0, 200, j, -1.5);
        Serial.print(j, DEC);
        Serial.print("    ");
        Serial.println(scaledResult, DEC);  
   }
}

E experimentar alguns valores diferentes para a função de curva - lembre- 0 é um 
mapeamento neutro, linearPara entender os intervalos invertendo , fazer algo 
parecido com isto: 
void loop(){  
     for ( j=0; j < 200; j++){
         scaledResult = fscale( 0, 200, 200, 0, j, 0);    // Linhas como acima Serial.print      }
}*/


#include <math.h>

int j;
float scaledResult;

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

void loop() {
  for ( j = 0; j < 200; j++) {
    scaledResult = fscale( 0, 200, 0, 200, j, -1.5);

    Serial.print(j, DEC);
    Serial.print("    ");
    Serial.println(scaledResult , DEC);
  }
}

float fscale( float originalMin, float originalMax, float newBegin, float
              newEnd, float inputValue, float curve) {

  float OriginalRange = 0;
  float NewRange = 0;
  float zeroRefCurVal = 0;
  float normalizedCurVal = 0;
  float rangedValue = 0;
  boolean invFlag = 0;


  // Curva de parâmetro condição
  // Gama limite

  if (curve > 10) curve = 10;
  if (curve < -10) curve = -10;

  curve = (curve * -.1) ; // - invert and scale - this seems more intuitive - postive numbers give more weight to high end on output
  curve = pow(10, curve); // convert linear scale into lograthimic exponent for other pow function

  /*   Serial.println(curve * 100, DEC);  // Multply por 100 a preservar resolução   Serial.println();   */

  // Verifique para fora do alcance inputValues
  if (inputValue < originalMin) {
    inputValue = originalMin;
  }
  if (inputValue > originalMax) {
    inputValue = originalMax;
  }

  // Zero Refference os valores
  OriginalRange = originalMax - originalMin;

  if (newEnd > newBegin) {
    NewRange = newEnd - newBegin;
  }
  else
  {
    NewRange = newBegin - newEnd;
    invFlag = 1;
  }

  zeroRefCurVal = inputValue - originalMin;
  normalizedCurVal  =  zeroRefCurVal / OriginalRange;   // normalize to 0 - 1 float

  /*  Serial.print(OriginalRange, DEC);   
      Serial.print("   ");
      Serial.print(NewRange, DEC);
      Serial.print("   ");
      Serial.println(zeroRefCurVal, DEC);
      Serial.println();   */

  // Verifique para originalMin > originalMax - a matemática para todos os outros casos isto é, números negativos parece funcionar bem
  if (originalMin > originalMax ) {
    return 0;
  }

  if (invFlag == 0) {
    rangedValue =  (pow(normalizedCurVal, curve) * NewRange) + newBegin;

  }
  else     // Inverter as gamas
  {
    rangedValue =  newBegin - (pow(normalizedCurVal, curve) * NewRange);
  }

  return rangedValue;
}

sqrt (x)

Descrição

Calcula a raiz quadrada de um número.

Parâmetros

x: o número, a qualquer tipo de dados

Devoluções

double, raiz quadrada do número.

Código fonte da aula:

void setup() {
  //Colocar o seu código de configuração aqui, para executar uma vez:

}

void loop() {
  // Colocar o seu código principal aqui, para executar repetidamente:
  int var1 = idade(1990);
  int var2 = min(var1, 19);
  int var3 = max(var1, 18);
  int var4 = max(var1, 1);

  double var6 = 2.65;
  int var7 = abs(var6);

  int var8 = constrain(var1, 18, 50);

  int var9 = map(var1, 0, 1023, 0, 255);

  int var10 = pow(3,2);

  int var11 = sqrt(9);

}

Outro código:

int idade(int ano) {
  return 2016 - ano;
}

Fonte: arduino.cc

Seja o primeiro a comentar

Faça um comentário

Seu e-mail não será publicado.


*