collapse

* Links de Robótica

* Posts Recentes

URGENTE - display de 7 segmentos com backpack por helderjsd
[Hoje às 12:30]


Preços e fabricantes de pcb por Sérgio_Sena
[Ontem às 10:20]


Palavras Cruzadas por Njay
[Ontem às 02:24]


Isaac Asimov - I, Robot por senso
[18 de Setembro de 2017, 03:41]


Apresentação por TigPT
[17 de Setembro de 2017, 07:31]


ic SL440 da Plessey? por senso
[16 de Setembro de 2017, 13:11]


Compra Colectiva RS-Amidata por brunus
[15 de Setembro de 2017, 22:31]


Ideias para construir um quadrúpede simples por zordlyon
[15 de Setembro de 2017, 10:18]


Preparar bancada de testes por jm_araujo
[14 de Setembro de 2017, 10:24]


Mitos: mudança da ilumação tradicional p/ iluminação a LEDs? por LVirtual
[14 de Setembro de 2017, 07:46]

Autor Tópico: fazer contas(até fórmula resolvente) com o arduino.  (Lida 9329 vezes)

0 Membros e 1 Visitante estão a ver este tópico.

Offline amando96

  • Mini Robot
  • *
  • Mensagens: 1.627
  • MAC address? But I have windows...
    • Projects, News, Blog, Tutorials
fazer contas(até fórmula resolvente) com o arduino.
« em: 25 de Março de 2009, 19:22 »
bem aqui está o programa para resolver a formula resolvente. basta dar um valor a ''a, b e c'' e vai dar os dois resultados, o x1 e x2. experientem! podem testar com uma calculadora ou de cabeça ;D

(glitch: o resultado está arrendondado ás unidades :(, só funciona com numeros mais pequenos..., mas ainda está em andamento ;D)


/*
 * matemática arredondada é engraçado ;D!
 */

#include "math.h"               // biblioteca math

int a = 1;    //escolham um numero qualquer
int b = -72; // ^^^^^^^^
int c = 5;     // ^^^^^^^^
int x1;         // resultado 1
int x2;         // resultado 2

void setup()                    // fazer uma só vez quando começa o sketch
{
  Serial.begin(9600);           // biblioteca Serial a 9600 baud

  Serial.println("Formula resovente inteira");

  Serial.print("a = ");
  Serial.println(a);

  Serial.print("b = ");
  Serial.println(b);
 
  Serial.print("c = ");
  Serial.println(c);
 
  x1 = (-b+sqrt( b*b - 4*a*c ))/2*a;
 
  x2 = (-b-sqrt( b*b - 4*a*c ))/2*a;
 
  Serial.print("x1 = ");
  Serial.println(x1);
 
  Serial.print("x2 = ");
  Serial.println(x2);
}

void loop()                // mesmo estando vazio tem de cá estar
{
}











e agora uma calculadora de ohms, volts, e amperes. mt simples de fazer, fiz só para ver se dá ;D


/*
 * mt simples mesmo!
 */

#include "math.h"               // biblioteca math

int volts = 10;
int amperes = 10;
int ohms = 10;
int v;//volts
int a;//amperes
int o;//ohms


void setup()                    // fazer uma só vez quando começa o sketch
{
  Serial.begin(9600);           // biblioteca Serial a 9600 baud

  Serial.println("calculadora de ohms, amperes e volts");

  Serial.print("volts = ");
  Serial.println(volts);

  Serial.print("amperes = ");
  Serial.println(amperes);
 
  Serial.print("ohms = ");
  Serial.println(ohms);
 
  v = amperes*ohms;
 
  a = volts/ohms;
 
  o = volts/amperes;
 
 
 
  Serial.print("v = ");
  Serial.println(v);
 
  Serial.print("a = ");
  Serial.println(a);
 
  Serial.print("o = ");
  Serial.println(o);
 
 
}

void loop()                // mesmo estando vazio tem de cá estar
{
}

« Última modificação: 15 de Janeiro de 2012, 16:40 por Psycop »

Offline TigPT

  • Administrator
  • Mini Robot
  • *****
  • Mensagens: 5.234
    • Tiago Rodrigues
Re:fazer contas(até fórmula resolvente) com o arduino.
« Responder #1 em: 26 de Março de 2009, 00:20 »
A vantagem do Arduino vs. outros micros é a facilidade de tratares valores decimais, com floats ou doubles, para alem disso podes ter ajuda das libs matemáticas:
Citar
Math

    * min(x, y)
    * max(x, y)
    * abs(x)
    * constrain(x, a, b)
    * map(value, fromLow, fromHigh, toLow, toHigh)
    * pow(base, exponent)
    * sqrt(x)

Trigonometry

    * sin(rad)
    * cos(rad)
    * tan(rad)

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

Continua o bom trabalho pois é muito interessante ;)

Offline msaleiro

  • Mini Robot
  • *
  • Mensagens: 691
    • Blog
Re:fazer contas(até fórmula resolvente) com o arduino.
« Responder #2 em: 26 de Março de 2009, 00:55 »
Citar
A vantagem do Arduino vs. outros micros é a facilidade de tratares valores decimais, com floats ou doubles, para alem disso podes ter ajuda das libs matemáticas:

Com os outros micros tb podes fazer isso... desde que programes em C :)
msaleiro - Mário Saleiro
UAlg FCT-DEI / VisLab - Instituto de Sistemas e Robótica / eLab Hackerspace
http://thebitbangtheory.com

Offline TigPT

  • Administrator
  • Mini Robot
  • *****
  • Mensagens: 5.234
    • Tiago Rodrigues
Re:fazer contas(até fórmula resolvente) com o arduino.
« Responder #3 em: 26 de Março de 2009, 08:42 »
Citar
A vantagem do Arduino vs. outros micros é a facilidade de tratares valores decimais, com floats ou doubles, para alem disso podes ter ajuda das libs matemáticas:

Com os outros micros tb podes fazer isso... desde que programes em C :)

A maioria deles, mas por exemplo Basic Stamp ou Picaxe (se não estou em erro) não o permitem.

Offline msaleiro

  • Mini Robot
  • *
  • Mensagens: 691
    • Blog
Re:fazer contas(até fórmula resolvente) com o arduino.
« Responder #4 em: 26 de Março de 2009, 10:01 »
Ah, estavas a falar de microcontroladores "já mastigados". Eu tava a falar no caso dos microcontroladores programados em C em vez das linguagens de alto nível que os Basic Stamp, Picaxe ou Arduino usam. Nesse segmento de uC se os basic stamp ou picaxe não permitem fazer isso então realmente é uma vantagem do Arduino.
msaleiro - Mário Saleiro
UAlg FCT-DEI / VisLab - Instituto de Sistemas e Robótica / eLab Hackerspace
http://thebitbangtheory.com

Offline TigPT

  • Administrator
  • Mini Robot
  • *****
  • Mensagens: 5.234
    • Tiago Rodrigues
Re:fazer contas(até fórmula resolvente) com o arduino.
« Responder #5 em: 26 de Março de 2009, 10:10 »
Ah, estavas a falar de microcontroladores "já mastigados". Eu tava a falar no caso dos microcontroladores programados em C em vez das linguagens de alto nível que os Basic Stamp, Picaxe ou Arduino usam. Nesse segmento de uC se os basic stamp ou picaxe não permitem fazer isso então realmente é uma vantagem do Arduino.
A nível de Assembly (ou C), ninguém te impede de fazer nada ;)

Offline Njay

  • Mini Robot
  • *
  • Mensagens: 3.086
    • Tróniquices
Re:fazer contas(até fórmula resolvente) com o arduino.
« Responder #6 em: 26 de Março de 2009, 11:39 »
Mesmo tendo acesso apenas a números inteiros é possível fazer contas com "alguns" números reais. Os tipos float, double & amigos que conhemos das linguagens de programação implementadas em máquinas com mais recursos encontram-se num formato designado "vírgula flutuante" ou "ponto flutuante". Este formato permite uma grande "elasticidade", tanto podemos guardar um número muito grande como um número muito pequeno, e é a sua vantagem. Por outro lado tem a desvantagem de serem necessários algoritmos complexos para os processar (em particular as operações de multiplicar e dividir); experimentem usar por exemplo floats num programa para o Arduino para verem o quanto o seu tamanho aumenta...

Além do formato vírgula flutuante sempre existiu um outro chamado "vírgula fixa", ou "ponto fixo" como normalmente lhe chamo. A ideia é muito simples: pega-se numa variável de um tipo inteiro e divide-se em 2 partes; a mais significativa é a parte inteira do número e a menos significativa é a parte decimal. Isto permite usar as operações aritméticas normais de inteiros para processar estes números, e as operações são rápidas, que é são as vantagem deste formato. A desvantagem é que "desperdiçamos" muito espaço, ficamos com um número muito pequeno de casas decimais que podemos guardar, face a um número em vírgula flutuante.

Então e qual é o aspecto disto de números em ponto fixo? Para começar vou dar um exemplo que, embora não seja o que normalmente é usado por não tirar partido do facto das nossas máquinas tipicas serem baseadas em potências de 2, é uma forma muito simples de perceber. Se guardarmos sempre os números multiplicados por 100, vamos ter uma precisão até às centésimas. Começamos por converter os números de reais para decimais, podendo haver aqui perda de precisão do número real original. Depois fazemos as nossas contas, processamo-los, guarda-mo-los. Se precisarmos de os mostrar ao utilizador então temos que fazer nova conversão. Calcular a potência dissipada num componente (p), dados o valor da tensão (Vc) e corrente (Ic) no mesmo:

Código: [Seleccione]
// Valores
#define Vc 3.3
#define Ic 0.15

// Converter os valores reais para ponto fixo
int vc = (int)(Vc * 100)
int ic = (int)(Ic * 100)

// Efectuar P = V x I
int p = vc * ic / 100

// Mostrar o resultado. Primeiro a parte inteira, depois a decimal.
Serial.print(p / 100)
Serial.print(".")
Serial.print(p % 100)   // % = resto da divisão
Serial.print(" W")

Este código não tem uma sintaxe exacta, é mais só para mostrar.

Outra forma de pensar em números em ponto fixo é dizer que a nossa "unidade" deixa de ser 1 e passa a ser, no caso do exemplo, 100. É assim que podemos representar números mais pequenos do que a unidade, que ao fim ao cabo é disto que tratam os números reais.

Usar múltiplos de 10 como unidade é muito conveniente para nós pois para mostrar o número num terminal ASCII basta simples contas. Mas como as nossas máquinas típicas são binárias, normalmente utiliza-se uma potência de 2 como unidade, por exemplo 128 (7 bits), o que permite acelerar os cálculos; em vez de multiplicar e dividir por uma potência de 10, que exigem mais instruções máquina ou instruções mais lentas, fazê-lo para potências de 2 limita-se a shift's e and's, que são muito rápidos. Por exemplo, multiplicar por 2 é fazer um shift à esquerda, vezes2 = a << 1.

Há outros detalhes que não referi; porque é que na multiplicação dividimos por 100 no final? como fazer divisões? qual os limites dos números que podemos usar, e como aumentar esses limites? qual a menor quantidade que pode ser representada? quais os erros de precisão e como os reduzir? Mas se não conhecerem já este método, é um bom exercício para o ficarem a conhecer :)

E já agora, sim sou novo por aqui. Fazia a minha apresentação mas não encontrei o sítio e na verdade não gosto muito de apresentações, pelo que fico-me pelo olá :). Haverá outras oportunidades.
« Última modificação: 26 de Março de 2009, 11:56 por Njay »

Offline TigPT

  • Administrator
  • Mini Robot
  • *****
  • Mensagens: 5.234
    • Tiago Rodrigues
Re:fazer contas(até fórmula resolvente) com o arduino.
« Responder #7 em: 26 de Março de 2009, 14:07 »
Antes de mais, bem-vindo Njay.

Realmente existem muitas técnicas para tratar valores a baixo nível, no fundo queria apenas acrescentar ao teu post que as nossas máquinas funcionam a 8/16 e 32bits (microcontroladores) mas os mais comuns são os de 8 bits por questões económicas. Assim, queria deixar então bem claro que seja qual for a dimensão dos dados que utilizamos, estes tem sempre que ser tratados 8bits-a-8bits, por isso que qualquer calculo maior que 8bits envolve sempre diversas operações para poder separar os dados, calcula-los, calcular os arrastos para os dados exteriores ao calculo corrente e por fim o merge novamente para voltarmos a ter os dados calculados prontos a gravar.

Para terem uma ideia mais concreta, num algoritmo que andava a fazer para um stepper-motor, para conseguir uma velocidade muito maior de stepps precisei de fazer as contas mais rapidamente e o que me lembrei logo foi a mudança de ints para bytes, assim como a passagem de ciclos crescentes para decrescentes (embora este ultimo penso que já seja feito pelo compilador, mas fazendo à mão, garantimos).

Poderíamos pensar em discutir técnicas de optimização de código para micros num outro tópico para ir juntando este tipo de ideias de forma mais indexada e aprendermos todos com as técnicas uns dos outros.

Offline Njay

  • Mini Robot
  • *
  • Mensagens: 3.086
    • Tróniquices
Re:fazer contas(até fórmula resolvente) com o arduino.
« Responder #8 em: 26 de Março de 2009, 14:37 »
Assim, queria deixar então bem claro que seja qual for a dimensão dos dados que utilizamos, estes tem sempre que ser tratados 8bits-a-8bits, por isso que qualquer calculo maior que 8bits envolve sempre diversas operações para poder separar os dados, calcula-los, calcular os arrastos para os dados exteriores ao calculo corrente e por fim o merge novamente para voltarmos a ter os dados calculados prontos a gravar.

Só tens que te preocupar com isso se estiveres a programar em assembly, porque tipicamente qualquer linguagem de alto nível trata disso por ti. No GCC (que o Arduino usa lá por baixo) podes ter variáveis de 32 bits (e até 64, se bem me lembro) que o compilador gera todo o código assembly necessário para que continues a ter apenas que escrever as operações normais tal e qual como fazes com qualquer outro tipo de dados mais pequeno. Não será tão rápido como fazer contas com tipo "nativo" da máquina (1 byte no caso dos AVR), mas mesmo assim será mais rápido que usar floats.