MCO018703 2020 1 AULA03
Objetivos
O aluno será capaz de:
- Identificar a estrutura de linguagem do Arduino;
- Aprender sobre constantes e variáveis;
- Conhecer as operações lógicas e aritméticas.
Introdução a linguagem C
A linguagem C foi criada por Dennis Ritchie, em 1972, no centro de Pesquisas da Bell Laboratories. Sua primeira utilização importante foi a reescrita do Sistema Operacional UNIX, que até então era escrito em assembly. Em meados de 1970 o UNIX saiu do laboratório para ser liberado às universidades. Foi o suficiente para que o sucesso da linguagem atingisse proporções tais que, por volta de 1980, já existiam várias versões de compiladores C oferecidas por diversas empresas, não sendo mais restritas apenas ao ambiente UNIX, como também compatível a outros sistemas operacionais. O C é uma linguagem de propósito geral, sendo adequada à programação estruturada. No entanto é mais utilizada para escrever compiladores, analisadores léxicos, bancos de dados, editores de texto, e sistemas embarcados.
A linguagem C pertence a uma família de linguagens cujas características são: portabilidade, modularidade, compilação separada, recursos de baixo nível, geração de código eficiente, confiabilidade, regularidade, simplicidade e facilidade de uso.
Fonte: [1] - Centro de Computação - UNICAMP
- Histórico Completo
- Características da Linguagem
- O C K&R (uma especificação informal da linguagem) e o ANSI C
- Linguagem imperativa e procedural.
Comentários
Os comentários no programa fonte não têm função nenhuma para o compilador e serve apenas para aumentar a legibilidade e clareza do programa, podem ser inseridos com “//” que valem de onde começam até o fim da linha ou com “/*” e “*/”, sendo considerado comentário tudo entre “/*” e “*/”.
Identificadores
Um identificador é um símbolo definido pelo usuário que pode ser um rótulo (label), uma constante, um tipo, uma variável, um nome de programa ou subprograma (procedimento ou função). Normalmente devem começar com um caractere alfabético e não podem conter espaços em branco, podendo ter no máximo 32 caracteres, não havendo distinção entre maiúsculas e minúsculas.
Endentação
A endentação também não tem nenhuma função para o compilador e serve para tornar a listagem do programa mais claro dando hierarquia e estrutura ao programa.
Constantes
Constantes são valores declarados no início do programa e que não se alteram na execução do programa. Podem ser expressas em qualquer base numérica.
Variáveis
Uma declaração de variável consiste do nome do tipo de dado seguido do nome da variável. Todas as variáveis devem ser declaradas antes de serem usadas. As variáveis devem ser declaradas no início de cada função, procedimento ou início do programa.
Elementos definidos pela linguagem C:
- Letras (alfanuméricas) Aa até Zz;
- Dígitos (numéricos) - 0 até 9;
- Operadores;
- Tipos de dados.
Operadores e Símbolos Especiais
| Operador | Significado | Exemplo |
|---|---|---|
| * | multiplicação | a = b * c |
| / | divisão | a = b / c |
| % | resto | a = 13 % 3, a = 1 |
| + | adição | a = b + c |
| - | subtração | a = b - c |
| = | atribuição | a = b |
| == | comparação compara dois operandos | if(a == 10) |
| < | menor que | a < b |
| <= | menor ou igual | a <= b |
| > | maior que | a > b |
| >= | maior ou igual | a >= b |
| != | diferente de | a=10, Se( a != 3) então verdadeiro |
| << | deslocamento de bit a esquerda | 3 (00000011) << 1 = 6 (00000110) |
| >> | deslocamento de bit a direita | 4 (00000100) >> 1 = 2 (00000010) |
| & | lógica E bit a bit | 00000011 & 00000110 = 00000010 |
| && | lógica E (AND) | a=2, Se(a>1 && a<3) então verdadeiro |
| ^ | OU exclusivo bit a bit | 00001100 ^ 00000110 = 00001010 |
| | | OU inclusivo bit a bit | 00001101 = 0001101 |
|| |
lógica OU (OR) | a=4, Se( a>3 || a<5) então verdadeiro |
| ! | lógica Não (NOT) | Se( ! a ) equivalente a Se( a == 0) |
| ~ | complemento bit a bit | ~00010101 = 11101010 |
| " | delimitador de string | "Arduino" |
Tipos de dados
Um Tipo de Dado define o conjunto de valores que uma variável pode assumir e as operações que podem ser feitas sobre ela. Toda variável em um programa deve ser associada a um tipo de dado. Mais abaixo veremos os tipos de dados mais utilizados pelo Arduino.
Estrutura da Linguagem do Arduino
A estrutura básica da linguagem de programação do Arduino é bastante simples; ela é formada por dois blocos de funções que carregam outros blocos de funções escritas em linguagem C/C++. O primeiro bloco de funções forma a função setup(); o segundo, a função loop().
- Funções
- Em linguagens de programação são como sub-rotinas ou procedimentos; são pequenos blocos de programas usados para montar o programa principal. Elas são escritas pelo programador para realizar tarefas repetitivas, ou podem ser
importadas prontas para o programa em forma de bibliotecas.
- Declaração da Função
- Toda função deve ser declarada antes de ser chamada atribuindo-lhe um tipo e um nome seguido de parênteses, onde serão colocados os parâmetros de passagem da função. Depois do nome são definidos entre as chaves '{' e '}' os procedimentos que a função vai executar.
- setup()
- Essa é a primeira função a ser chamada quando o programa inicia. E é executada apenas nessa primeira vez. Esta é uma função de preparação: ela dita o comportamento dos pinos do Arduino e inicializa a porta serial.
- loop()
- A função loop( ) é chamada logo a seguir e todas as funções embarcadas nela são repetidamente executadas. Ela fica lendo os pinos de entrada do Arduino e comandando os pinos de saída e a porta serial.
Os Símbolos usados na construção de funções são os seguintes: { } - Dentro das chaves vão os procedimentos (statements) que a função deve executar; ; - O ponto-e-vírgula é usado para marcar o final de um procedimento; // - comentário de uma linha: qualquer caractere depois das duas barras é ignorado pelo programa; /*...*/ - comentário em várias linhas: qualquer texto colocado entre esses símbolos também é ignorado pelo programa.
- Exemplo 1
/*
Nesse código a função '''setup( )''' ativa a porta serial em 9600 bits/s
e a função loop( ) fica transmitindo a frase "Hello World!" pela porta
serial a cada 2 segundos.
*/
void setup( )
{
Serial.begin(9600); // inicializa a porta serial
}
void loop( )
{
Serial.println("Hello World!"); // transmite frase
delay(2000);
}
Constantes e Variáveis
- Constantes
- São valores predefinidos que nunca podem ser alterados. Na linguagem C do Arduino são 3 os grupos de constantes; os dois componentes de cada grupo sempre podem ser representados pelos números binários 1 e 0.
- TRUE/FALSE são constantes booleanas que definem estados lógicos. Verdadeiro é qualquer valor que não seja zero. Falso é sempre o valor zero.
- HIGH/LOW essas constantes definem as tensões nos pinos digitais do Arduino. Alto é uma tensão de 5V; baixo o GND(ou 0V).
- INPUT/OUPUT são constantes programadas pela função pinMode( ) para os pinos do Arduino; eles podem ser entradas (de sensores) ou podem ser saídas (de controle).
- Variáveis
- São posições na memória de programa do Arduino marcadas com um nome e o tipo de informação que irão guardar. Essas posições podem estar vazias ou podem receber um valor inicial. Os valores das variáveis podem ser alterados pelo
programa.
- Escopo da Variável é o limite ou abrangência da variável. Uma variável pode ser declarada em qualquer parte do programa. Se for declarada logo no início, antes da função setup( ), ela tem o escopo de Variável Global, e porisso ela pode ser vista e usada por qualquer função no programa. Se declarada dentro de uma função ela tem o escopo de Variável Local, e só pode ser usada por essa função.
- Declaração da Variável como as funções, toda variável deve ser declarada antes de ser chamada. Essa declaração consiste em atribuir previamente um tipo e um nome à variável.
- Tipos de variáveis:
| Tipo | Descrição do tipo |
|---|---|
| byte | armazena 8 bits (0-255); |
| int | armazena números inteiros de até 16 bits; |
| long | armazena números inteiros de até 32 bits; |
| float | podem armazenar números fracionários de até 32 bits. |
- Exemplo 2
/* Esse programa escrito em C do Arduino aumenta e diminui gradativamente o brilho de um LED
conectado no pino PWM 10 do Arduino. */
int i=0; // declaração da variável global inteira i iniciada com 0
void ledOn( ); // declaração da função criada ledOn do tipo void
void setup( )
{
pinMode(10,OUTPUT); // aqui 2 parâmetros são passados à função pinMode( )
}
void loop( )
{
for (i=0; i <= 255; i++) ledOn( ); // aumenta o brilho do led
for (i=255; i >= 0; i--) ledOn( ); // diminui o brilho do led
}
void ledOn( ) // função que acende o led
{
analogWrite (10, i); // o nº do pino e o valor de i são passados à função analogWrite( )
delay (10);
}
Lógica e Aritmética
- Operações Aritméticas e lógicas
- As 4 operações aritméticas: divisão, multiplicação, adição e subtração, são representadas pelos símbolos: /, *, + e -, respectivamente, separando os operandos. E são 3 os operadores lógicos na linguagem do Arduino que são usados para comparar duas expressões e retornar a constante TRUE/FALSE.
Símbolos compostos são aqueles que combinam os símbolos aritméticos entre si e com o sinal de atribuição:
x++ // x=x+1 x-- // x=x-1 x += y // x=x+y x -= y // x=x-y x *= y // x=x*y x /= y // x=x/y
Operadores de comparação comparam uma variável com uma constante, ou variáveis entre si. São usados para testar se uma condição é verdadeira.
x == y // x é igual a y x != y // x não é igual a y x < y // x é menor que y x > y // x é maior que y x <= y // x é menor ou igual a y x >= y // x é maior ou igual a y
Operadores lógicos são usados para comparar duas expressões, retornam 1 ou 0 (verdadeiro/falso).
&& AND porta lógica 'E' || OR porta lógica 'OU' ! NOT porta lógica 'NÃO'
Funções Matemáticas e de Tempo
- delay(ms)
- Essa função pausa o programa por um período em milissegundos indicado pelo parâmetro entre parênteses.
Exemplo:
delay(1000); // Com esse parâmetro o programa vai pausar durante 1 segundo (1000 ms).
- Nota
- Durante o período em que essa função está ativa qualquer outra função no programa é suspensa. Somente as interrupções de hardware podem parar essa função.
- delayMicroseconds(us)
- Essa função pausa o programa por um período em microssegundos indicado pelo parâmetro entre parênteses.
Exemplo:
delayMicroseconds(1000); // Com esse parâmetro o programa vai pausar durante 1 ms (1000 us).
- Nota
- As mesmas observações acima para a função delay(ms) são válidas aqui.
- millis( )
- Retorna o número de milissegundos desde que o Arduino começou a executar o programa corrente.
Exemplo:
long total = millis( ); // Aqui a variável inteira longa (de 32 bits) ‘total’ vai guardar o tempo em ms desde que o Arduino foi inicializado.
- Nota
- Essa variável vai ser resetada depois de aproximadamente 9 horas.
- random(min,max)
- Gera números pseudo-aleatórios entre os limites min e max especificados como parâmetros.
Exemplo:
int valor = random(100,400); // A variável "valor" vai ser atribuido um número inteiro qualquer entre 100 e 400.
- Nota
- O parâmetro min é opcional e se excluído o limite mínimo é 0. No exemplo variável "valor" poderá ser qualquer número inteiro entre 0 e 400.
- abs(x)
- Retorna o módulo ou valor absoluto do número real passado como parâmetro.
Exemplo:
float valor = abs(-3.14); // A variável "valor" vai ser atribuído o número em ponto flutuante (e sem sinal) 3.14.
- map(valor,min1,max1,min2,max2)
- A função map( ) converte uma faixa de valores para outra faixa. O primeiro parâmetro "valor" é a variável que será convertida; o segundo e o terceiro parâmetros são os valores mínimo e máximo dessa variável; o quarto e o quinto são os novos valores mínimo e máximo da variável "valor".
Exemplo:
int valor = map(analogRead(A0),0,1023,0,255)); // A variável "valor" vai guardar a leitura do nível analógico no pino A0 convertida da faixa de 0-1023 para a faixa 0-255.
- Nota
- Com essa função é possível reverter uma faixa de valores, exemplo: int valor = map(x,1,100,100,1);
Primeiro Projeto
Quando ensinamos linguagens de programação novas, geralmente o primeiro exemplo é um "hello world". Como o Arduino não vem por padrão com um display, nosso primeiro exemplo foi enviar o "hello world" pela serial do Arduino. Agora vamos fazer um LED piscar – e por isso será chamado blink. Nosso LED ficará aceso durante um segundo e apagado durante outro segundo e então recomeçará o ciclo. Abra a IDE (programa do Arduino) e digite o seguinte código:
void setup() {
pinMode(13, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
}
Chamamos um código feito para Arduino de sketch e o salvamos em um arquivo com a extensão .INO. Com nosso sketch pronto, basta conectar o Arduino na porta USB e clicar no botão upload (segundo, da direita para a esquerda). Após o processo, será vista a mensagem Done uploading na IDE e então o sketch estará rodando no Arduino, ou seja, o LED vai acender e apagar a cada 1 segundo. A Figura abaixo mostra como deverá ser montado o circuito para um LED externo.
Basta ligar o Arduino na porta USB do computador, para que o computador forneça energia ao circuito, e então veremos o LED externo piscar. Em vez do LED, poderíamos controlar outros componentes, como motores, eletrodomésticos, entre outros.
Referências
[1] http://ordemnatural.com.br/pdf-files/CartilhadoArduino_ed1.pdf
[2] http://xbot.com.br/externo/OpneMoniot/Programando_Microcontroladores_PIC_Linguagem_C.pdf
