quarta-feira, 16 de novembro de 2011

Constantes do Arduino


Constantes

Constantes são variáveis pré-definidas da linguagem do Arduino. Elas são usadas para fazer com que programas fiquem mais fáceis de ler. Constantes são classificadas em grupos.

 

Definindo Níveis Lógicos e Constantes Booleanas (true e false)

Existem duas constantes utilizadas para representar verdade e falsidade na linguagem do Arduino: true (verdadeiro) e false (falso).

false

Falso é o mais fácil de se definir. Falso é definido como zero (0).

true

Verdadeiro é normalmente tido como um (1), que está correto, mas verdadeiro tem uma definição mais ampla. Qualquer inteiro que não seja zero (0) é considerado verdadeiro, num sentido booleano. Então -1, 2 e -200 são todos definidos como verdadeiro, também em um sentido booleano.
Note que as constantes verdadeiro (true) e falso (false) são digitadas em caixa-baixa (letras minúsculas), ao contrário de HIGH (ALTO), LOW (BAIXO), INPUT (ENTRADA) e OUTPUT (SAIDA).

 

Definindo os Níveis das Portas, HIGH e LOW

Quando lendo ou escrevendo em uma porta digital, existem apenas dois valores possíveis que a porta pode ser lida/configurada: HIGH (ALTO) e LOW (BAIXO).
HIGH
O entendimento de HIGH (em relação a porta) é um pouco diferente dependendo se a porta foi configurada como INPUT (ENTRADA) ou OUTPUT (SAIDA). Quando uma porta é configurada como INPUT, utilizando a função pinMode, e lida com a função digitalRead, o microcontrolador retornará HIGH se a voltagem de 3 volts ou mais estiver presente na porta.
Uma porta também pode ser configurada como INPUT com o pinMode e na sequência ser configurada como HIGH com a função digitalWrite. Isto ativará o resistor interno de elevação de 20K ohms, o qual derivará a porta para o valor HIGH a não ser que ela seja trazida para LOW, por um circuito externo.
Quando uma porta é configurada para OUTPUT com a função pinMode, e configurada para HIGH com a digitalWrite, a porta ficará em 5 volts. Neste estado, a porta pode fornecer corrente, por exemplo para acender um LED, conectado através de um resistor em série com o terra (ground ou GND), ou mesmo para outro pino configurado como saída e com valor LOW (tem o mesmo efeito do GND).
LOW (BAIXO)
O significado de LOW também tem diferentes entendimentos dependendo de como a porta é configurada para INPUT ou OUTPUT. Quando uma porta é configurada como INPUT pela função pinMode, e lida com a função digitalRead, o microcontrolador irá retornar LOW se a voltagem de 2 volts ou menos estiver presente na porta.
Quando uma porta é configurada para OUTPUT com pinMode, e configurada como LOW pelo digitalWrite, a porta terá o valor de 0 volts. Neste estado podemos ancorar corrente, como no exemplo do LED ligado através de um resistor em série com uma porta OUTPUT no estado HIGH.

 

Definindo Portas Digitais, INPUT (ENTRADA) e OUTPUT (SAIDA)

Portas digitais podem ser usadas tanto como INPUT ou OUTPUT. Mudar o estado de uma porta de INPUT para OUTPUT com a função pinMode() muda drasticamente as características elétricas da porta.

Porta Configurada como Entrada

Portas do Arduino (ATMega) configuradas como INPUT com pinMode estão em um estado conhecido por alta-impedância. Uma forma de explicar isso é que a porta configurada como INPUT demanda muito pouca corrente do circuito que está amostrando, como se tivesse um resistor de 100 Megaohms em série com a porta. Isto se faz útil para leitura de um sensor, mas não para acender um LED.

Porta Configurada como Saída

Portas configuradas como OUTPUT com pinMode estão em um estado conhecido por baixa-impedância. Isso significa que elas podem fornecer uma quantidade substancial de corrente para outros circuitos. As portas do ATMega podem fornecer (prover corrente positiva) ou ancorar (prover corrente negativa) até 40 mA (miliamperes) de corrente para outros dispositivos/circuitos. Configuradas dessa forma, as portas podem fornecer corrente para acender um LED, mas se tornam inúteis para leitura de um sensor. Portas configuradas como saída podem também ser danificadas ou destruídas se curto-circuitadas tanto ao terra quanto aos 5 volts. A corrente fornecida pelas portas do ATMega também não são suficientes para a maioria dos motores e relês, então algum circuito de casamento se faz necessário.

Tradução

Por Renato Aloi, do original em inglês, no site: http://arduino.cc/en/Reference/Constants


Curso Arduino - Aula 5 (Variáveis) por Renato Aloi

quarta-feira, 9 de novembro de 2011

Variáveis do Arduino


Variáveis

Uma variável é uma forma de nomear e guardar um valor para usar depois pelo programa, como dados de um sensor, ou ainda, um valor intermediário de um cálculo.

Declarando Variáveis

Antes de serem utilizadas, as variáveis devem ser declaradas. Declarar uma variável significa definir seu tipo, e opcionalmente, configurar um valor inicial (iniciar a variável). Variáveis não precisam ser iniciadas (conferidas um valor) quando estas são declaradas, mas muitas vezes se faz útil.
int inputVariable1;  // iniciando variável
int inputVariable2 = 0;     // iniciando e atribuindo valor
Programadores devem considerar o tamanho dos números que desejam guardar, escolhendo o tipo da variável. Variáveis sobrecarregam quando o valor excede o espaço designado para guardá-lo. Veja abaixo por exemplo.

Escopo da Variável

Outra escolha importante que os programadores enfrentam é onde declarar as variáveis? O lugar específico que as variáveis são declaradas influencia como várias funções do programa a enxergarão. Isto é chamado de escopo.

Iniciando Variáveis

Variáveis devem ser iniciadas (designadas um valor) no momento que elas são declaradas ou depois. É sempre uma boa prática de programação verificar que uma variável tenha dados válido dentro dela, antes de ser utilizada.
Exemplo:
int calibrationVal = 17;  // declara calibrationVal e configura seu valor
           // inicial

Sobrecarga da Variável

Quando variáveis têm seu valor excedido pela capacidade máxima do seu tipo, elas sobrecarregam e voltam para seu valor mínimo. Isto acontece em ambas  direções.
int x
   x = -32,768;
   x = x - 1;       // x contém 32,767 - sobrecarrega na direção negativa
   x = 32,767;
   x = x + 1;       // x contém -32,768 – sobrecarrega

Usando Variáveis

Uma vez que variáveis tenham sido declaradas, elas podem ser usadas configurando a variável para o valor que se deseja armazenar, através do operador de atribuição (um sinal de igual). O operador de atribuição diz ao programa para atribuir o que estiver do lado direito do sinal de igual, dentro da variável que deve ficar do lado esquerdo do sinal de igual.
inputVariable1 = 7;             // configura variável chamada inputVariable1 
        // atribuindo o valor 7
inputVariable2 = analogRead(2); // configura variável chamada inputVariable2 
        // atribuindo a voltagem lida de uma porta 
                                // analógica 2

Exemplos

int lightSensVal;
   char currentLetter;
   unsigned long speedOfLight = 186000UL;
   char errorMessage = {"escolha outra impressão"}; // vide: string 
 
Uma vez que a variável tenha sido configurada (conferida um valor), você pode testar seu valor para verificar se atende determinada condição, ou usar seu valor diretamente. Por exemplo, o código a seguir testa se o valor da variável inputVariable2 é menor que 100, então configurando um atraso (delay) baseado no valor de inputVariable2, que é no mínimo 100.
if (inputVariable2 < 100)
{
  inputVariable2 = 100;
}

delay(inputVariable2);
 
Este exemplo mostra todas as três operações úteis que se pode fazer com variáveis. Ele testa a variável (if (inputVariable2 < 100)), configura o valor 100 caso o teste tenha passado (inputVariable2 = 100), e utiliza o valor armazenado na variável como parâmetro de entrada na função delay (delay(inputVariable2)).
Nota de Estilo: Você deve nomear suas variáveis descrevendo as características do valor guardado, para fazer o código ficar mais agradável de ler. Nomes de variáveis como tiltSensor ou pushButton te ajudam (ou a qualquer um que esteja lendo seu código) a entender o que a variável representa.
Você pode nomear uma variável com qualquer palavra que você quiser, desde que não sejam as reservadas do Arduino (link para palavras reservadas). Evite nomes que comecem com números.

Alguns Tipos de Variáveis


Escopo das Variáveis

Variáveis na linguagem C, que o Arduino usa, tem uma característica conhecida por escopo. Isto é um contraste com linguagens como BASIC que qualquer variável é uma variável global.
Uma variável global é uma que pode ser vista por qualquer função dentro de um programa. Variáveis locais são apenas visíveis para a função na qual foram declaradas. No ambiente do Arduino, qualquer variável declarada fora de uma função (ex. setup, loop, etc.), é considerada uma variável global.
Quando programas começam a ficar grandes e mais complexos, variáveis locais são úteis para garantir que apenas uma função terá acesso apenas as suas próprias variáveis. Isso evita erros de programação quando uma função inadvertidamente, modifica o valor de variáveis utilizadas por outra função.
Algumas vezes é útil declarar e iniciar uma variável interna para um laço (loop). Assim criamos uma variável que possa apenas ser acessada na parte interna das chaves {} do laço-for.

Exemplo:

int gPWMval;  // qualquer função acessa essa variável

void setup()
{
  // ...
}

void loop()
{
  int i;    // "i" é apenas "visível" dentro da função "loop"
  float f;  // "f" é apenas "visível" dentro da função "loop"
  // ...

  for (int j = 0; j <100; j++){
   // variável “j” pode ser apenas 
   // acessada dentro das chaves do laço-for 
  }

}

Tradução: Renato Aloi


quinta-feira, 3 de novembro de 2011

Funções do Arduino


Segmentar o código em funções possibilita ao programador criar partes modulares, que desempenham tarefas bem definidas, e então retornam para a área do código a partir de onde foram chamadas. O caso típico de criação de uma função é quando existe a necessidade de executar a mesma tarefa diversas vezes durante um programa.
Para programadores acostumados ao BASIC, funções do Arduino fornecem (e estendem) a utilidade do uso das subrotinas (GOSUB em BASIC).
Padronizar fragmentos de código em funções tem várias vantagens:
  • Funções ajudam o programador permanecer organizado, muitas vezes, isso ajuda a montar o conceito do programa.
  • Funções codificam a tarefa em um único lugar, para que a funcionalidade seja pensada e depurada uma única vez.
  • As chances de erros em modificações reduzem drasticamente, no caso do código precisar ser alterado.
  • Funções reduzem o tamanho dos Sketches (projetos criados na IDE do Arduino, do inglês: rascunhos), pois seções de código podem ser reutilizadas diversas vezes.
  • Elas também tornam mais fácil reutilizar código, tornando-o mais modular, e com um efeito colateral benéfico: fica mais agradável de ler o código.
Existem duas funções mandatórias nos Sketches do Arduino: setup() e loop(). Outras funções podem ser criadas fora das chaves ({}) dessas duas funções. Como um exemplo, vamos criar uma função simples para multiplicar dois valores.

Exemplo



Para “chamar” nossa função simples de multiplicação, nós passamos os parâmetros do tipo de dados que a função está esperando:
void loop{
int i = 2;
int j = 3;
int k;

k = myMultiplyFunction(i, j); // k now contains 6
}
Nossa função precisa ser declarada fora de qualquer outra função, então “MinhaFuncaoMultiplicar()” pode ficar tanto acima quanto abaixo da função principal “loop()”.
O código completo deve ficar parecido com isto:
void setup(){
  Serial.begin(9600);
}

void loop() {
  int i = 2;
  int j = 3;
  int k;

  k = myMultiplyFunction(i, j); // k now contains 6
  Serial.println(k);
  delay(500);
}

int myMultiplyFunction(int x, int y){
  int result;
  result = x * y;
  return result;
}

Outro exemplo

Esta função abaixo fará a leitura de um sensor, cinco vezes, utilizando a função analogRead(); calculando a média das cinco leituras. Ela também converte os dados da leitura para 8 bits (0-255), e a inverte, invertendo assim a saída.
int ReadSens_and_Condition(){
  int i;
  int sval = 0;

  for (i = 0; i < 5; i++){
    sval = sval + analogRead(0);    // sensor na porta analógica 0
  }

  sval = sval / 5;    // média
  sval = sval / 4;    // converte para 8 bits (0 - 255)
  sval = 255 - sval;  // inverte a saída
  return sval;
}
Para chamar a função, nós apenas fazemos a atribuição para uma variável.
int sens;

sens = ReadSens_and_Condition();

Tradução

Por Renato Aloi, do original em inglês, no site: http://arduino.cc/en/Reference/HomePage