Apostila Arduino Jhsfurno
-
Upload
igor-serafim -
Category
Documents
-
view
262 -
download
2
Transcript of Apostila Arduino Jhsfurno
1
PROGRAMAÇÃO COM ARDUINO PARA
AUTOMAÇÃO INDUSTRIAL
2014
Professor: Jordan Henrique de Souza Furno
Curso: Técnico em Automação Industrial
Disciplina: Lógica de Programação
2
Sumário
Capítulo 1 - Introdução......................................................................................04
1.1.Público Alvo......................................................................................04
1.2.Requisitos de Hardware e Software.................................................04
Capítulo 2 - Introdução à Programação em C..................................................05
2.1. Fluxogramas Representativos.........................................................05
2.2. Tipos de Variáveis e Dados.............................................................07
2.3 Exercícios.........................................................................................09
Capítulo 3 - Operadores e Desvio Condicional.................................................10
3.1. Exercícios........................................................................................14
3.2. Laços de Repetição.........................................................................17
3.3. Exercícios........................................................................................19
3.4. Looping com variável de controle....................................................20
3.5. Exercícios........................................................................................21
3.6. Um pouco de C...............................................................................22
3.7. Instalando o Dev C++ e Fazendo nosso Primeiro Programa!.........25
3.8. Exercícios........................................................................................35
Capítulo 4 - Entrada e Saída de dados em C!..................................................36
4.1. Resumindo Nosso Conhecimento!..................................................38
4.2. Tipos de Dados, Operadores Matemáticos, Lógicos e Relacionais.............................................................................................41
4.3. Exemplos.......................................................................................45
Capítulo 5 - Condicionais IF, ELSE e SWITCH-CASE.....................................50
5.1. Compreendendo o IF e ELSE........................................................50
5.2. Lógica Comentada..........................................................................51
5.3. Exemplos........................................................................................55
5.4. Condicional SWITCH-CASE (Escolha-caso)..................................62
5.5. Exemplos........................................................................................62
5.6 Exercícios........................................................................................68
Capítulo 6 - Tipo de Dado Char e Strings........................................................69
3
Capítulo 7 - Laços de Repetição FOR, While e Do-While................................71
7.1. Exemplos.........................................................................................73
7.2. Exercícios........................................................................................83
Capítulo 8 - Vetores, Matrizes e Strings...........................................................84
8.1. Vetores............................................................................................84
8.2. Cadeia de caracteres(String)...........................................................87
8.3. Matrizes...........................................................................................89
8.4. Exemplos.........................................................................................90
8.5. Exercícios........................................................................................94
Capítulo 9 – Funções........................................................................................95
9.1. Exercícios......................................................................................100
Capítulo 10 – Arduino.....................................................................................101
10.1. Configurando o Arduino para Programação................................102
10.2. Características do Arduino UNO.................................................104
10.3. Funções Setup e Loop e principais Comandos...........................105
10.4. Exemplos.....................................................................................106
10.5. Exercícios....................................................................................115
Referências Bibliográficas...............................................................................116
4
Capítulo 1 – Introdução
O Mundo da eletrônica, vem crescendo muito com o decorrer do tempo e se
atualizando de forma constante. Atualmente vários processos vem sendo
automatizados de forma a proporcionar um melhor desempenho em suas
finalidades, porém a utilização da eletrônica analógica e digital de formas
separadas vem sendo uma limitação para determinados casos. Então com o
passar dos anos uma área que cresceu e continua se expandindo bastante é a
de programação de microcontroladores em combinação com circuitos
analógicos e digitais e também circuitos de potência.
1.1. Público Alvo
Esta apostila destina-se à Engenheiros: Elétricos , Eletrônicos, Mecatrônicos e
de Automação e Controle, Também à Técnicos em: Automação Industrial,
Eletrotécnica, Eletrônica, Programação e à Hobistas em Geral, onde serão
abordados os seguintes temas:
- Noções Básicas de Eletrônica Analógica e Digital
- Noções Básicas de Programação em C
- Ambiente de Desenvolvimento Arduino
1.2. Requisitos de Hardware e Software
Hardware:
• Microcomputador Pentium de 200MHz ou superior;
• 16 MB de memória RAM;
• 300 MB livres de HD;
Software:
• Sistema operacional XP ou superior, de preferência Windows 7;
• Software de programação Arduino.
5
Capítulo 2 – Introdução a Programação em C
A Linguagem de programação em C, é um tipo de linguagem que chamamos
de Case-Sensitive, que significa “sensível ao tamanho” ou seja o fato da
linguagem C ser Case-Sensitive, faz com que nossos programas tenham
limitações tais como em declarações de variáveis onde palavras iguais porém
com caracteres maiúsculos e minúsculo irão fazer muita diferença. Por
exemplo: “Arduino” é diferente de “arduino” seus significados são o mesmo
mas o fato de um ter o primeiro caractere maiúsculo e o outro ter minúsculo,
isso faz com que sejam palavras diferentes. Isto também irá influenciar na
programação relacionada às palavras reservadas da linguagem C, que
geralmente são comandos, análises condicionais, laços de repetição e etc. Que
são as palavras que já vem pré-definidas na nossa linguagem de programação.
2.1. Fluxogramas Representativos
Fluxogramas representativos são utilizados para a construção de algoritmos
com a finalidade de solucionar um determinado problema, sendo ele composto
por uma sequência finita de passos até uma solução final. Abaixo temos as
figuras representativas de cada função em um determinado fluxograma.
Figura 2.1
6
Fluxogramas representativos podem ser encontrados de diversas maneiras
diferentes as figuras são utilizadas geralmente para que você possa definir a
seguência de passos e interpretá-las.
Vejamos um exemplo de um fluxograma representativo para encontrar a média
entre três notas e retornar uma mensagem se media maior ou igual à 7
aprovado senão reprovado.
Figura 2.2
Interpretando nosso fluxograma representativo, temos o terminal inicio que
começa o programa uma entrada de dados que recebe quatro valores
diferentes um processamento que calcula a média(soma todos e divide por
quatro), uma analise condicional que mostra como saída “aprovado” se média
maior ou igual a sete ou “reprovado” se média menor que sete, o conector une
as duas setas de fluxo finais encerrando o fluxograma com o terminal fim.
Este tipo de fluxograma é apenas à modo interpretativo, podendo ser elaborado
de diversas formas diferente, isso irá variar de pessoa para pessoa a seguir o
mesmo exemplo porém de uma forma um pouco diferente.
7
Figura 2.3
Já o fluxograma acima, faz a mesma função que o da figura 2.2, porém ele
trabalha em cima do uso de variáveis, onde N1, N2, N3 e N4, serão
responsáveis por guardar as quatro notas fornecida pelo usuário e M se
encarregará de realizar o processamento(média) dessas notas que é a soma
das notas dividido pela quantidade de notas fornecida, na analise condicional a
variável “M”, é analisada pois ela é responsável por guardar o resultado do
processamento, por fim temos as saídas “aprovado” e “reprovado” o conector e
o terminal fim.
2.2. Tipos de Variáveis e Dados
Tipos Inteiros(Int): São tipos inteiros, os dados numéricos positivos ou
negativos, excluindo-se, destes qualquer fracionário. Como exemplo deste tipo
de dado, têm-se os valores : 35,0,-56;
Tipos Reais(Float): São tipos reais, os dados numéricos positivos, negativos e
números fracionários. Ex. : 35,0,-56,1.2,-45.897
Tipos Caracteres(Char): São caracteres, indicados por aspas simples ‘ ‘ Ex.:
‘a’, ‘Z’, ‘j’. Os caracteres podem serletras, números e símbolos especiais. Uma
sequência de caracteres deve ser indicada entre aspas(“”). Ex.:
“PROGRAMAÇÃO”,”Rua Alfa”,” “,”98” e são chamadas de Strings, que nada
mais são que um vetor de caracteres.
Tipos Lógicos(Bool): São tipos lógicos ou boleanos, os dados com valores
verdadeiro ou falso, e deve ser escrito entre pontos. Ex.: .Falso.,.Verdadeiro..
8
O nome de uma variável é utilizado para sua identificação e posterior uso
dentro de um programa, sendo assim, é necessário estabelecer algumas
regras de utilização das mesmas:
Nomes de variáveis poderão ser atribuídos com um ou mais caracteres;
O primeiro caractere do nome de uma variável não poderá ser em hipótese
alguma, um número, sempre deverá ser uma letra;
O nome de uma variável não poderá possuir espaços em branco;
Não poderá ser nome de uma variável, uma instruçãode programa;
Não poderão ser utilizados outros caracteres a não ser letras e números. Obs.:
o caracter “_” Under-line ou sub-linha é considerado uma letra.
Tem-se como definição de constante tudo aquilo que é fixo ou estável. E
existirão vários momentos em que este conceito deverá estar um uso. Por
exemplo, o valor 1.23 da fórmula a seguir é uma constante:
RESULTADO=ENTRADA*1.23.
“+”: Realiza a operação de Soma
“-”: Realiza a operação de Subtração
“*”: Realiza a operação de Multiplicação
“/”: Realiza a operação de Divisão
Na programação é comum usar fórmulas matemáticas, mas para facilitar a
escrita da programação as fórmulas são escritas de uma forma diferenciada.
Como exemplo a área do círculo: 3.14*r*r
Cada linguagem de programação usa um conjunto de palavras onde cada uma
desenvolve uma ação. Estas palavras reservadas de cada linguagem são
conhecidas como comandos ou instruções. Daqui para frente vamos utilizar
instruções em português estruturado, tais como : inicio, fim, var , programa,
enquanto, se, então, senão, para, escreva, leia, faça, repita e até que, entre
outrasque serão estudadas.
Ler dois valores
Efetuar a soma destes valores
Apresentar o resultado
9
2.3. Exercícios
1 – Indique o tipo de variável que poderão armazenar os valores abaixo.
I : inteiro; R : real; S : String ou Literal ou Caractere; L : Lógico ou
Booleano.
( )1000 ( ) “0” ( ) “-900” ( ).Verdadeiro.
( )-456 ( )34 ( )”Casa 8” ( )0
( )-1.56 ( )”.falso.” ( )1.87 ( ).F.
2 – Assinale com X os nomes válidos de uma variável
( )Endereco ( )21brasil ( )Fone$com
( )NomeUsuario ( )Nome_usuario ( )Nome*usuario
( )End-A ( )Cidade3 ( )#Cabec
( )23 ( )N23
3 – Desenvolva a lógica de um programa que efetue o cálculo da área
de uma circunferência, apresentando a medida da área calculada.
Fórmula : Area=Pi*Raio**2
4 – Elaborar um algoritmo que calcule o salário de um professor onde o
usuário deverá entrar com o número de aulas dadas, o valor da hora
aula e o percentual de desconto do INSS.
5 – Ler dois valores A e B, efetuar a troca dos valores de forma que a
variável A passe a possuir o valor da variável B e que a variável B passe
a possuir o valor da variável A. Apresentar os valores trocados
6 – Ler dois valores A e B, efetuar as operações deadição, subtração,
multiplicação e divisão de A por B, apresentando nofinal os quatro
resultados obtidos.
7 – Efetuar o cálculo do valor de uma prestação em atraso, utilizando a
fórmula: PRESTAÇÃO:=VALOR+(VALOR*(TAXA/100)*TEMPO).
8 – Indique o tipo de variável que poderão armazenar os valores abaixo.
I : inteiro; R : real; S : String ou Literal ou Caractere; L : Lógico ou
Booleano.
( )-900 ( )0 ( ) “-900” ( ).Verdadeiro.
( )4.54 ( )34 ( )”.falso.” ( )”Real”
9 – Assinale com X os nomes válidos de uma variável
( ) Dia 21 ( )7quedas ( )C/C
( )x*y ( )Senha_conta2 ( )Nome Cliente
10
Capítulo 3 - Operadores e Desvio Condicional
Você já aprendeu como trabalhar com entrada, processamento e saída. Apesar
de já conseguir solucionar problemas e transformá-los em programas, os
recusrsos aqui estudados são limitados, pois haverá momentos em que um
determinado valor dentro de um programa necessitará ser tratado para se
efetuar um processamento mais adequado.
Para aprender-mos desvio condicional devemos conhecer os operadores
utilizados para se estabelecer uma condição. São eles:
Figura 3.1
Figura 3.2
Figura 3.3
11
Imagine a seguinte situação: um programa que apresente a média escolar de
um aluno. Baseado em sua média, se o aluno tiver nota maior ou igual a 7
devera apresentar uma mensagem parabenizando o aluno.
Para solucionar o problema proposto será necessário trabalhar uma nova
instrução: SE...ENTÃO...FIM_SE. Esta instrução tem por finalidade tomar uma
decisão. Sendo a condição verdadeira, serão executadas todas as instruções
que estejam entre a instrução se... então e a instrução fim_se.
Vejamos abaixo a Sintaxe:
SE <Condição> ENTÃO
<instruções para condição verdadeira>
FIM_SE
<instruções executadas se a condição for falsa ou após a condição ser
verdadeira>
Exemplo: elaborar um programa que peça dois valores para as variáveis A e B,
efetue a soma das mesmas e apresente o resultado se a soma for maior que
10.
Resolução:
Leia A e B
Faça A + B e Guarde em C
SE < C>10 > ENTÃO
<Mostre o valor de C>
FIM_SE
Interpretação: Primeiro o nosso programa acima irá ler ou receber do usuário
os valores de A e de B, em seguida ele vai fazer a soma de A com B e guardar
na variável C, então após isso ele faz a analise condicional: SE C for maior que
10 ele irá mostrar o valor de “C”, caso contrário ele não faz nada.
O desvio condicional composto utiliza a estrutura
SE...ENTÃO...SENÃO...FIM_SE
Vejamos a sintaxe do desvio condicional composto na próxima página.
12
SE <Condição> ENTÃO
<instruções para condição verdadeira>
SE <Condição> ENTÃO
<instruções para condição verdadeira>
SENÃO
<instruções para condição falsa>
FIM_SE
SENÃO
SE <Condição> ENTÃO
<instruções para condição verdadeira>
SENÃO
<instruções para condição falsa>
FIM_SE
FIM_SE
Exemplo : Ler 4 notas escolares de um aluno. Se a média do aluno for maior ou
igual a 7 apresentar a média e uma mensagem dizendo que foi aprovado,
senao, efetuar a leitura da nota do exame, somar à média e dividir por dois, se
a média for maior ou igual a 5 apresentar a média e uma mensagem dizendo
que está aprovado, senao apresentar uma mensagem que está reprovado.
13
Resolução:
Leia n1, n2, n3, n4
Faça n1+n2+n3+n4 e guarde em media
SE <media>=7> ENTÃO
<Mostre Aprovado>
SENÃO
Leia n5
Faça (media + n5)/2 e guarde em media2
FIM_SE
SE <media2>=5> ENTÃO
<Mostre a media e aprovado>
SENÃO
<reprovado>
FIM_SE
Interpretação: Primeiro o nosso programa irá ler ou receber as notas n1, n2, n3
e n4, logo após isso ele irá somá-las, dividir o resultado por 4 e guardar na
variável media, então após isso ele realiza análise condicional SE media for
maior ou igual a 7 ele irá mostrar “Aprovado”, SENAO ele irá ler a nota do
exame(n5) somá-la com a media, dividir por 2 e depois guardar na variável
media2 encerrando a primeira análise condicional. Após isso ele inicia a
segunda análise condicional, onde SE a media2 for maior ou igual a 5 ENTÃO
ele ira mostrar o valor da media e a mensagem “aprovado”, SENÃO ele irá
mostrar apenas “reprovado” após isso encerra-se o nosso programa.
Nosso mesmo código acima elaborado em um compilador C como o Dev C++
ou Code Blocks ficaria da seguinte maneira.
14
#include <stdio.h>
void main()
float n1, n2, n3, n4, n5, media,media2; // declaração de variáveis
scanf("%f %f %f %f",&n1, &n2, &n3, &n4); // entrada de dados
media = (n1+n2+n3+n4)/4; // processamento
if (media>=7) // primeira analise condicional
printf("Aprovado"); // saida de dados
return; // encerramento da função
else // segunda analise condicional
scanf("%f", &n5); // entrada de dados
media2=(media+n5)/2; // processamento
if (media2>=5) // terceira analise condicional
printf("%.2f, aprovado",media2); // saida de dados
else // quarta analise condicional
printf("Reprovado"); // saida de dados
system ("PAUSE"); // pausa
return; // encerramento da função
15
Na função apresentada o programa declara sete variáveis, onde quatro(n1, n2,
n3, n4) irão receber as notas e calcularão a media, caso o aluno tenha media
acima ou equivalente a 7, uma mensagem “aprovado” é exibida e o programa
encerra, caso contrário recebe uma nota n5, soma-se a variável media, divide
por dois e guarda em media2, então uma nova analise condicional é realizada,
caso media2 for maior ou equivalente a 5, o aluno é aprovado, caso contrário o
aluno está reprovado e o programa encerra.
16
3.1. Exercícios
1 – Elaborar um programa que efetue o cálculo do reajuste de salário de um
funcionário. Considere que o funcionário deverá receber um reajuste de 15%
caso seu salario seja menor que 500. Se o salario for maior ou igual a 500 mas
n\menor ou igual a 1000, seu reajuste será de 10%, e caso seja ainda maior
que 1000, o reajuste deverá ser de 5%.
ler um valor para o salario
verificar se o valor de salario < 500; se sim, reajustar em 15%
verificar se o valor de salario <=1000; se sim, reajustar em 10%
verificar se o valor de salario > 1000; se sim, reajustar em 5%
apresentar o valor reajustado.
2 – Efetuar a leitura de três valores (a,b,c) apresentá-los em ordem crescente.
3 – Efetuar a leitura de três valores (a,b,c) e efetuar o cálculo da equação de
segundo grau, apresentando as duas raízes, se para os valores informados for
possível efetuar o referido cálculo.
4 – Ler dois valores numéricos e apresentar a diferença do maior para o menor.
5 – Efetuar a leitura de um número inteiro positivoou negativo e apresentá-lo
como sendo positivo.
6 – Efetuar a leitura de 4 numeros inteiros e apresentar os que são divisiveis
por 2 ou 3.
17
3.2. Laços de Repetição
Looping com teste lógico no início
Este tipo de estrutura efetua um teste lógico no início do looping, verificando se
é permitido executar o trecho de intruções subordinado a este looping. Esta
estrutura é conhecida como: enquanto, através do conjunto de instruções
ENQUANTO...FAÇA...FIM_ENQUANTO.
Esta estrutura, tem o seu funcionamento controlado por decisão, podendo
executar um determinado conjunto de instruções enquanto a condição
verificada for verdadeira. No momento em que esta condição se torna falsa o
processamento da rotina é desviado para fora do looping.
SINTAXE
ENQUANTO <condição> FAÇA
<conjunto de instruções para condição verdadeira>
FIM_ENQUANTO
Exemplo: Considere o problema: Pedir a leitura de um valor para a variável x,
multiplicar este valor por 3, implicando-o á variável de resposta R e apresentar
o valor R obtido, repetindo esta seqüência por 5 vezes.
Resolução:
Faça contador igual a 1
ENQUANTO < contador<=5 > FAÇA
Leia x
Faça x*3 e guarde em R
Mostre R
contador = contador+1
FIM_ENQUANTO
Interpretação: criar uma variável para servir como contador com valor inicial 1;
enquanto o valor do contador for < ou = a 5, Ler um valor para a variável x;
Efetuar a multiplicação do valor de x por 3, implicar o resultado em r;
apresentar o valor calculado contido na variável R; Acrescentar +1 á variável
contador; Quando contador for maior que 5, encerrar o processamento do
looping.
18
Exemplo: Elaborar o algoritmo de um programa que efetue o calculo da fatorial
do número 5. Fatorial é o produto dos números naturais desde 1 até o inteiro n.
Sendo assim o cálculo de um fatorial é conseguido pela multiplicação
sucessiva do número de termos.
Faça contador igual a 1
Leia fatorial
ENQUANTO < contador<fatorial > FAÇA
fatorial=fatorial*contador
contador=contador+1
FIM_ENQUANTO
Mostre fatorial
Interpretação: O programa irá atribuir 1 à variável contador, e vai ler o numero
que você quer saber o fatorial e guarda-lo dentro da variável fatorial enquanto
contador for menor ou igual a fatorial, fatorial vai receber fatorial(valor anterior
de fatorial) vezes a variável contador, após isso contador irá incrementar 1 em
seu valor atual, quando contador se tornar igual a fatorial o loop irá encerrar e o
resultado será mostrado ao usuário.
Looping com teste lógico no fim
Caracteriza-se por uma estrutura que efetua um teste lógico no fim de um
looping, denominada repita, sendo conseguida com a utilização do conjunto de
instruções repita...até_que. A estrutura repita...até_que tem o seu
funcionamento controlado também por decisão, porém irá efetuar a execução
de um conjunto de instruções pelo menos uma vez antes de verificar a validade
da condição estabelecida. Diferente da estrutura enquanto que executa
somente um conjunto de instruções, enquanto a condição é verdadeira.
19
3.3. Exercícios
a) Apresentar todos os valores numéricos inteiros pares situados na faixa de
100 a 200.
b) Apresentar o total da soma obtido dos cinco primeiros números inteiros.
c) Apresentar a tabuada de um número qualquer. Todoo programa deve se
repetir enquanto o usuário desejar.
d) Apresentar todos os números divisíveis por 4 que sejam menores que 20.
e) Apresentar os quadrados dos números inteiros de 2 a 50.
f) Elaborar um programa que apresente no final, o somatório dos valores pares
existentes na faixa de 10 até 20.
20
3.4. Looping com variável de controle
Os loopings que possuem um número finito de execuções poderão ser
processados através de estrutura para, sendo conseguida com a utilização das
intruções para...de...até...passo...faça...fim_para. Esta estrutura tem o seu
funcionamento controlado por uma variável denominada contador. Sendo
assim, poderá executar um determinado conjunto de instruções um
determinado número de vezes.
Sintaxe:
PARA <variável> DE <início> ATÉ <fim> PASSO <incremento> FAÇA
<instruções>
FIM_PARA
Para exemplificar considere o problema anterior : "Pedir a leitura de um valor
para a variável X, multiplicar este valor por 3, colocando o resultado em uma
variável R e apresentar o valor. Tudo isso deverá ser repetido por 5 veses".
Definir um contador variando de 1 a 5;
Ler um valor para a variável X;
Efetuar a multiplicação do valor de X por 3, implicando o resultador em R;
Apresentar o valor calculado contido na variável R;
Repetir os passos 2,3,4 e 5 até que o contador sejamaior que 5
Resolução:
PARA < contador > DE <1> ATÉ <5> PASSO<incremento> FAÇA
Leia x
Faça x*3 e guarde em R
Mostre R
FIM_PARA
21
3.5. Exercícios
a) Apresentar todos os valores numéricos inteiros ímpares situados na faixa de
1000 a 1500.
b) Apresentar o total da soma obtido de N números inteiros onde N é um
número digitado pelo usuário.
c) Apresentar a tabuada de um número qualquer.
d) Apresentar os números divisíveis por 3 que sejammenores que 12.
e) Elaborar um programa que apresente no final, o somatório dos valores pares
existentes na faixa de 10 até 20.
22
3.6. Um pouco de C
Primeiros Passos O C é "Case Sensitive"
Vamos começar o nosso curso ressaltando um ponto de suma importância: o
C é "Case Sensitive", isto é, maiúsculas e minúsculas fazem diferença. Se
declarar uma variável com o nome soma ela será diferente de Soma, SOMA,
SoMa ou sOmA. Da mesma maneira, os comandos do C, por exemplo, só
podem ser escritos em minúsculas pois senão o compilador não irá interpretá-
los como sendo comandos, mas sim como variáveis.
Dois Primeiros Programas
Vejamos um primeiro programa em C:
#include <stdio.h>
/* Um Primeiro Programa */
int main ()
printf ("Ola! Eu estou vivo!\n");
return(0);
Compilando e executando este programa você verá que ele coloca a
mensagem Ola! Eu estou vivo! na tela.
Vamos analisar o programa por partes.
A linha #include <stdio.h>diz ao compilador que ele deve incluir o arquivo-
cabeçalho stdio.h. Neste arquivo existem declarações de funções úteis para
entrada e saída de dados (std = standard, padrão em inglês; io = Input/Output,
entrada e saída ==> stdio = Entrada e saída padronizadas). Toda vez que você
quiser usar uma destas funções deve-se incluir este comando. O C possui
diversos Arquivos-cabeçalho. Quando fazemos um programa, uma boa idéia é
usar comentários que ajudem a elucidar o funcionamento do mesmo. No caso
acima temos um comentário: /* Um Primeiro Programa */. O compilador C
desconsidera qualquer coisa que esteja começando com /* e terminando com
*/. Um comentário pode, inclusive, ter mais de uma linha. A linha int
main()indica que estamos definindo uma função de nome main.
23
Todos os programas em C têm que ter uma função main, pois é esta função
que será chamada quando o programa for executado. O conteúdo da função é
delimitado por chaves . O código que estiver dentro das chaves será
executado seqüencialmente quando a função for chamada. A palavra int indica
que esta função retorna um inteiro. O que significa este retorno será visto
posteriormente, quando estudarmos um pouco mais detalhadamente as
funções do C. A última linha do programa, return(0); , indica o número inteiro
que está sendo retornado pela função, no caso o número 0.
A única coisa que o programa realmente faz é chamar a função printf(),
passando a string (uma string é uma seqüência de caracteres, como veremos
brevemente) "Ola! Eu estou vivo!\n" como argumento. É por causa do uso da
função printf() pelo programa que devemos incluir o arquivo- cabeçalho stdio.h.
A função printf() neste caso irá apenas colocar a string na tela do computador.
O \n é uma constante chamada de constante barra invertida. No caso, o \n é a
constante barra invertida de "new line" e ele é interpretado como um comando
de mudança de linha, isto é, após imprimir Ola! Eu estou vivo! o cursor passará
para a próxima linha. É importante observar também que os comandos do C
terminam com ;(ponto-vírgula).
Podemos agora tentar um programa mais complicado:
#include <stdio.h>
int main ()
int Dias; /* Declaracao de Variaveis */
float Anos;
printf ("Entre com o número de dias: "); /* Entrada de Dados
*/
scanf ("%d",&Dias);
Anos=Dias/365.25; /* Conversao Dias->Anos */
printf ("\n\n%d dias equivalem a %f anos.\n",Dias,Anos);
return(0);
Vamos entender como o programa acima funciona. São declaradas duas
variáveis chamadas Dias e Anos. A primeira é um int(inteiro) e a segunda um
24
float(ponto flutuante). As variáveis declaradas como ponto flutuante existem
para armazenar números reais, como 5,1497.
É feita então uma chamada à função printf(), que coloca uma mensagem na
tela. Queremos agora ler um dado que será fornecido pelo usuário e colocá-lo
na variável inteira Dias. Para tanto usamos a função scanf(). A string "%d" diz
à função que iremos ler um inteiro. O segundo parâmetro passado à função diz
que o dado lido deverá ser armazenado na variável Dias. É importante ressaltar
a necessidade de se colocar um & antes do nome da variável a ser lida quando
se usa a função scanf(). O motivo disto só ficará claro mais tarde. Observe que,
no C, quando temos mais de um parâmetro para uma função, eles serão
separados por vírgula. Temos então uma expressão matemática simples que
atribui a Anos o valor de Dias dividido por 365.25 (365.25 é uma constante
ponto flutuante 365,25). Como Anos é uma variável float o compilador fará uma
conversão automática entre os tipos das variáveis (veremos isto com detalhes
mais tarde). A segunda chamada à função printf() tem três argumentos. A
string "\n \n %d dias equivalem a %f anos.\n"diz à função para pular duas
linhas, colocar um inteiro na tela, colocar a mensagem " dias equivalem a ",
colocar um valor float na tela, colocar a mensagem "anos."e pular outra linha.
Os outros parâmetros são as variáveis, Dias e Anos, das quais devem ser
lidos os valores do inteiro e do float, respectivamente.
25
3.7. Instalando o Dev C++ e Fazendo nosso
Primeiro Programa!
Passo 01 - Após feito download do aplicativo, execute-o aparecerá a seguinte tela escolha o idioma em Português.
Passo 02 - Após escolher o idioma aceite o contrato de Licença.
26
Passo 03 - Na Parte de Componentes basta clicar em Seguinte.
Passo 04 - Na parte de escolher o diretório(Local da Instalação) deixe o diretório Padrão.
27
Passo 05 - Pode ocorrer de aparecer a mensagem abaixo que é para instalar o Dev em todos os usuários do PC clique em Sim.
Passo 06 - Pronto agora seu compilador Dev C++ está Instalado.
Passo 07 - Na primeira vez que você executar o programa aparecerá a tela abaixo dê OK.
28
Passo 08 - Logo em seguida aparecerá algumas telas de configurações na primeira escolha o idioma Portuguese (Brazil) Na segunda deixe a opção Yes, I want to use this featura e clique em next.
29
30
Passo 09 - Na caixa Dica do Dia clique em Fechar
Passo 10 - Clique em Arquivo -> Novo -> Projeto
31
Passo 11 - Na caixa Novo projeto selecione Console Application, Projeto C e no nome escolha o que achar melhor, procure utilizar sempre letras minusculas seguidos de numeros ex.: programa01, exercicio01, trabalho01 e etc..
Passo 12 - Feito isso vamos escrever nosso primeiro programa, diz uma Lenda que para o usuário ser um bom programador o seu primeiro programa deve mostrar a mensagem "Hello World" ou ele será amaldiçoado pelo resto de sua vida. Escreva de acordo com o código abaixo!
32
Passo 13 - Após escrito o código, vá em Executar -> Compilar & Executar ou simplesmente pressione F9.
Passo 14 - Logo em seguida uma caixa para salvar o seu programa será aberta, eu sugiro que para não misturar seus programas você faça o seguinte: 1º Crie uma pasta no diretório C: chamada Programas Dev C++ 2º Crie uma outra pasta no diretório C:\Programas Dev C++ chamada programa01 3º Salve seu arquivo dentro da pasta programa01 À medida que você for fazendo novos programas sugiro que vá criando novas pastas para guardá-los separadamente e organizar seus programas. exemplo: programa02, programa03, programa04(PASTAS) e salve dentro delas.
33
Passo 15 - Feito isso irá abrir um prompt de comando exibindo a seguinte mensagem "Hello World" Parabéns!! você fez o seu primeiro programa, Bem vindo ao Mundo da Programação!
34
02) Com base no exemplo anterior elabore um programa que imprima na tela a
seguinte mensagem: "O Campeao muda mas o vice é sempre o mesmo!".
Resolução:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
printf("O Campeao muda mas o vice e sempre o mesmo!\n");
system("PAUSE");
return 0;
03) Agora faça um programa que imprima na tela a seguinte mensagem: "Vida
dificil essa de programador..."
Resolução:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
printf("Vida dificil essa de programador...\n");
system("PAUSE");
return 0;
35
3.8. Exercícios
01) Faça um programa que imprima na tela a seguinte mensagem: "Rubro
Negro até morrer!".
02) Faça um programa que imprima na tela a seguinte mensagem: "printf e
uma saida de dados".
03) Faça um programa que imprima na tela as seguintes mensagens: "Hoje",
"o", "sol", "esta", "radiante!" as mensagens deverão aparecer escritas uma
embaixo da outra como abaixo:
36
Capítulo 4 - Entrada e Saída de dados em C! Em C iremos considerar como entrada de dados todos os tipos de informações que o usuário envia do Teclado para o PC(Diferente da saida de dados que são as informações que o PC envia para o Usuário). Daqui em diante nossos programas serão baseados tanto em entradas de dados com processamentos e saídas de dados.
Nossa entrada de dados estará relacionada automaticamente com nosso processamento e nossa saída de dados. Então é importante que saibamos diferenciar de forma correta uma Entrada de dados de uma Saída de dados resumindo grosso modo o que trabalharemos: - Entrada de Dados (scanf - Toda informação enviada para o PC pelo Usuário) - Saida de Dados (printf - Toda informação enviada para o Usuário pelo PC) Nossa sintaxe de entrada de Dados será a seguinte: Suponha que você tenha uma variável chamada "int valor" o comando scanf("%d",&valor); irá fazer com que o processamento(execução) de seu programa pare e aguarde você digitar um dado do tipo inteiro para que ele possa continuar o processamento. Nosso scanf também exige tipos de dados específicos para o armazenamento do conteúdo em suas determinadas variáveis! Veja os tipos de dados para armazenamento à seguir: %d -> serve para guardar dados do tipo int %f -> serve para guardar dados do tipo float %c -> serve para guardar dados do tipo char Vamos fugir à teoria e ir um pouco a prática! Suponha que você queira fazer
um programa que receba dois números inteiros, some-os e mostre o seu
resultado.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int n1,n2,resultado;
scanf("%d %d",&n1,&n2);
resultado=n1+n2;
printf("O Resultado e: %d\n",resultado);
system("PAUSE");
return 0;
37
Interpretando nosso programa:
scanf -> Nossa entrada de dados o scanf poderia ter sido escrito de duas
formas a primeira é como foi inserido no programa a segunda seria utilizando
dois scanf para receber as duas variáveis exemplo:
scanf("%d",&n1);
scanf("%d",&n2);
dentro do scanf o %d indica que o dado que será recebido deverá ser inteiro e
também deverá ser guardado dentro de uma variável inteira.
Utiliza-se &(E Comercial) para que os valores recebidos sejam guardados
dentro do endereço de memória das respectivas variáveis relacionadas.
Logo na linha de baixo, temos o que chamamos de processamento, que é onde
as ações do seu programa são realizadas, no caso do nosso exemplo está
sendo efetuada uma soma de dois valores e guardando este mesmo resultado
em outra variável.
resultado=n1+n2; -> Interpreta-se: "Resultado recebe n1(Valor numérico
guardado em n1) mais n2(Valor numérico guardado em n2)".
Logicamente a variável resultado irá obter o valor da soma efetuada.
printf -> Veja bem jovem, hoje aprenderemos como imprimir na tela o valor de
uma variável utilizando o printf. analisando a escrita do comando em nosso
exemplo percebemos que dentro do printf("entre as aspas duplas"); encontra-
se um %d.. mas o que ele significa? :S relembrando a sintaxe do printf: printf
("expressão de controle", lista de argumentos);
Dentro da expressão de controle o %d digitado tem a capacidade de chamar uma lista de argumentos que atenda à seu tipo de dado! No caso do exemplo o %d(int) está chamando a variável resultado(int), logo então o resultado é exibido no prompt de comando.
38
4.1. Resumindo Nosso Conhecimento! No decorrer do nosso curso começamos pela Saída de Dados, depois fomos para a Entrada de Dados, e por ultimo aplicamos um processamento bem básico. Neste resumo vamos fazer uma abordagem bem Teórica e sistemática!
- Saída de Dados
Está referenciada ao nosso printf, com a capacidade de enviar dados do PC ao Usuário. Abaixo sua sintaxe: printf ("expressão de controle", lista de argumentos); expressão de controle: Aqui voce pode digitar qualquer texto que ele será exibido no prompt de comando ao usuário. lista de argumentos: Aqui você pode fazer uma chamada externa de outra variável ou até mesmo de um processamento. Exemplos sem lista de argumentos: - printf("Brasil Hexacampeao"); -- Ele exibirá no prompt: Brasil Hexacampeao - printf("O valor de pi e 3,14"); -- Ele exibirá no prompt: O valor de pi e 3,14 Exemplos com lista de argumentos: int n1=5,n2=10; -- declara n1 como inteiro e atribui o valor 5 à n1 e declara n2 como inteiro e atribui o valor 10 à n2. printf("A soma de n1 com n2 e %d",n1+n2); -- na expressão de controle o %d chama uma lista de argumentos que é n1+n2, toda lista de argumentos deverá ser inserida dessa forma. como n1 e n2 são do tipo int(inteiro) deverá ser utilizado %d porque é uma escrita de número inteiro. float n1=8,n2=12; -- declara agora n1 e n2 como float printf("A divisao de %f com %f e %f",n1,n2,n1/n2); -- na expressão de controle encontra-se um %f três vezes, isso significa que será chamado na nossa mensagem 3 argumentos que serão eles o n1, n2 e o n1/n2. lembrando que as chamadas de listas de argumentos são ordenadas, ou seja o primeiro %f chama o 1º Argumento(n1), o segundo %f chama o 2º Argumento(n2) e o terceiro e último %f chama o 3º e último Argumento(n1/n2). Na expressão de controle também podemos utilizar alguns comandos especiais veja-os abaixo: \n - Cria uma linha nova a partir do ponto que é indicado
\t - Cria um espaço de tabulação do ponto que é indicado
\b - Executa um retrocesso de espaço do ponto que é indicado
\” - Apresenta o símbolo de aspas no ponto que é indicado
\\ - Apresenta o símbolo de barra no ponto que é indicado
\f - Adiciona um salto de página de formulário (impressora)
\0 - Gera um nulo
39
E também, na expressão de controle temos as chamadas de argumentos
%c - Permite que seja efetuada a escrita de apenas um caractere
%d - Permite que seja efetuada a escrita de números inteiros decimais
%e - Permite que seja efetuada a escrita de números em notação científica
%f - Permite que seja efetuada a escrita de números reais (ponto flutuante)
%g - Permite que seja efetuada a escrita de %e ou %f no formato mais curto
%o - Permite que seja efetuada a escrita de números octais
%s - Permite que seja efetuada a escrita de uma série de caracteres
%u - Permite que seja efetuada a escrita de um número decimal sem sinal
%x - Permite que seja efetuada a escrita de um número hexadecimal
40
- Entrada de Dados
Está referenciada ao nosso scanf, com a capacidade de enviar dados do Usuário ao PC. Abaixo sua sintaxe: scanf ("expressão de controle", lista de argumentos); expressão de controle: aqui você vai digitar os tipos e a quantidade de dados a serem armazenados de acordo com as variáveis declaradas. lista de argumentos: aqui você vai digitar as variáveis que irão receber os dados do Usuário de acordo com seus tipos de dados. Exemplo: int numero; -- declara numero como inteiro float idade; -- declara idade como real char sexo; -- declara sexo como caractere scanf("%d %f %c",&numero,&idade,&sexo); -- na expressão de controle temos %d, %f, %c isso indica que na minha lista de argumentos a primeira variável deverá ser int(numero), a segunda float(idade) e a terceira char(sexo). Segue abaixo a identificação para cada tipo de dado a ser recebido pelo usuário. %c - Permite que seja efetuada a leitura de apenas um caractere
%d - Permite que seja efetuada a leitura de números inteiros decimais
%e - Permite que seja efetuada a leitura de números em notação científica
%f - Permite que seja efetuada a leitura de números reais (ponto flutuante)
%l - Permite que seja efetuada a leitura de um número inteiro longo
%o - Permite que seja efetuada a leitura de números octais
%s - Permite que seja efetuada a leitura de uma série de caracteres
%u - Permite que seja efetuada a leitura de um número decimal sem sinal
%x - Permite que seja efetuada a leitura de um número hexadecimal
41
4.2. Tipos de Dados, Operadores Matemáticos,
Lógicos e Relacionais.
Um bom programador precisa ter os conhecimentos básicos sobre tipos de dados e operadores, para que o seu programa possa ser desenvolvido com um melhor desempenho, rapidez e eficácia. - Tipos de Dados
Para se desenvolver um programa que seja executável dentro de um computador, é necessário ter em mente que o trabalho de gerenciamento de dados ocorre em três níveis: 1. A entrada dos dados; 2. O processamento dos dados; 3. A saída de dados. O objetivo principal de qualquer computador é a manipulação de dados, que são representados por elementos em estado primário. Ao agregar valores à esses dados, são criadas as informações, que ao serem estruturadas de forma organizada e com algum significado, tem por objetivo gerar algum conhecimento. Os computadores servem para armazenar informações e programas para sua manipulação. Sendo assim, um programador consciente não pode ignorar a importância dos dados e como eles devem ser estruturados. Como exemplo padrão da estruturação de dados e informações pode ser citado a lista telefônica, que por ser ordenada alfabeticamente, torna razoavelmente simples e rápido o acesso a um determinado número de telefone de um assinante. Os dados então são representados pelas informações a serem processadas por um computador. A linguagem C fornece ao programador um conjunto de tipos de dados pré-definidos, podendo ser dos tipos: numéricos, caracteres e lógicos (“camuflados” por 0 e 1). Tipos de dados inteiros São caracterizados tipos inteiros os dados numéricos positivos ou negativos, excluindo-se destes qualquer número fracionário. Em C, este tipo de dado pode ser referenciado por um dos seguintes identificadores: int de -32.768 a 32.767 long de -2.147.483.648 até 2.147.483.647 unsigned int de 0 até 65.535 Tipos de dados reais São caracterizados tipos reais os dados numéricos positivos, negativos e números fracionários e também os inteiros. Em C, este tipo de dado pode ser referenciado por um dos seguintes identificadores: float de 3.4 E -38 até 3.4 E+38 double de 1.7 E -308 até 1.7 E+308 Este tipo de dado real permite trabalhar com uma representação de valores em ponto flutuante que consiste em uma mantissa (parte fracionária).
42
Tipos de dados caracteres São caracterizadas tipos caracteres as seqüências contendo letras, números e símbolos especiais. Uma seqüência de caracteres deve ser representada na linguagem C entre aspas( " " ). Este tipo de dado é referenciado pelo identificador char, podendo armazenar de 0 até 255 caracteres. Tipos de dados lógicos Na linguagem C, não existe um tipo de dado lógico ou booleano propriamente dito, ou seja, não existirão os valores lógicos Falso ou Verdadeiro para um determinado tipo de dado. Nesta linguagem, qualquer valor igual a zero 0, é considerado um valor lógico falso, e qualquer valor diferente de zero(que será representado pelo número 1 inteiro) será considerado um valor lógico verdadeiro. - Operadores Matemáticos
Os operadores matemáticos que iremos trabalhar, serão os de Soma, Subtração, Multiplicação, e Divisão que são os que contém a biblioteca stdio.h também há funções como potenciação e extração de raiz que vem inclusos na biblioteca math.h veremos mais adiante. Os operadores matemáticos são referenciados pelos seguintes simbolos abaixo:
Estes são os operadores matemáticos ou também chamados de Aritméticos pode haver a existência de outros operadores também estes não são os únicos.
43
- Operadores Lógicos
Os operadores lógicos são muito utilizados em testes condicionais sendo eles o E Lógico, OU Lógico e Negação veja seus símbolos abaixo: && = E Lógico || = OU Lógico ! = Negação
O que é o E Lógico e o OU Lógico? Suponha que você tenha uma decisão a ser tomada, como por exemplo: "Eu vou a praia se fizer sol E estiver com carro" Você ainda não decidiu se vai à praia porque você não sabe se está fazendo sol ou se você está com carro. Então vamos listar quais são as probabilidades de você ir a praia:
Faz Sol? Estou com Carro? Vou a Praia?
Não Não Não
Não Sim Não
Sim Não Não
Sim Sim Sim
Através dos testes feitos nas combinações acima pode-se concluir que o E Lógico só irá fazer algo caso as condições sejam verdadeiras, caso faça sol E esteja com o carro. Agora vamos mudar o contexto, suponha que mudamos nossa condição e que agora Eu vou à praia se fizer sol OU estiver com carro
Faz Sol? Estou com Carro? Vou a Praia?
Não Não Não
Não Sim Sim
Sim Não Sim
Sim Sim Sim
Veja a diferença acima com a condição OU Lógico eu vou a praia se qualquer um dos casos acima for verdadeiro, se fizer sol ou estiver com o carro eu irei a praia.
44
Mas e a Negação? vejamos um último exemplo: Se estiver Chuvendo eu não vou à Praia.
Está chovendo? Vou a Praia?
Não Sim
Sim Não
A negação ela indica o processo contrário à sua entrada no caso, se não estiver chovendo irei a praia, se estiver chovendo não irei à praia. O E Lógico muitas das vezes é comparado à uma multiplicação, já o OU Lógico é comparado à uma soma e a Negação é simplesmente a alternativa contrária a fornecida. Mais adiante os Operadores Lógicos irão ficar mais claros com a prática. - Operadores Relacionais
Já os operadores relacionais, são utilizados para efetuar comparações na Linguagem C veja-os abaixo:
São muito utilizados para comparar valores entre duas variáveis e etc.
45
4.3. Exemplos 1) Faça um programa que receba dois números e multiplique-os.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int n1,n2,resultado;
printf("Entre com o valor de N1 e N2\n");
scanf("%d %d",&n1,&n2);
resultado=n1*n2;
printf("O Resultado e: %d\n",resultado);
system("PAUSE");
return 0;
2) Faça um programa que receba dois números positivos e troque seus valores
entre si.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int n1,n2,aux;
printf("Entre com o valor de N1 e de N2\n");
scanf("%d %d",&n1,&n2);
aux=n1;
n1=n2;
n2=n1;
printf("O Valor de N1 e: %d\nO Valor de N2 e: %d\n",n1,n2);
system("PAUSE");
return 0;
46
3) Faça um programa que leia um numero inteiro e imprima o seu antecessor e
o seu sucessor!
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int numero,antecessor,sucessor;
printf("Entre com o numero\n");
scanf("%d",&numero);
antecessor=numero-1;
sucessor=numero+1;
printf("O Antecessor e: %d\nO Sucessor e: %d\n",antecessor,sucessor);
system("PAUSE");
return 0;
4) Faça um programa que leia três numeros e retire a média entre eles. #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
float n1,n2,n3,media;
printf("Entre com o valor de N1, de N2 e de N3\n");
scanf("%f %f %f",&n1,&n2,&n3);
media=(n1+n2+n3)/3;
printf("A Media e: %f\n",media);
system("PAUSE");
return 0;
5) Faça um programa que leia um valor e o imprima com um reajuste de 10%
#include <stdio.h>
47
#include <stdlib.h>
int main(int argc, char *argv[])
float valor,reajuste;
printf("Entre com o valor para reajuste\n");
scanf("%f",&valor);
reajuste=valor+(valor*0.1);
printf("O Reajuste e: %f\n",reajuste);
system("PAUSE");
return 0;
6) Faça um programa que leia dois valores e retorne o resto da divisão do
primeiro pelo segundo, o segundo valor não pode ser zero!
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int n1,n2,resto;
printf("Entre com o primeiro valor e o segundo valor\n");
scanf("%d %d",&n1,&n2);
resto=n1%n2;
printf("O resto e: %d\n",resto);
system("PAUSE");
return 0;
7) Faça um programa que leia um numero inteiro e calcule o seu quadrado.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
48
int n1,quadrado;
printf("Entre com o valor\n");
scanf("%d",&n1);
quadrado=n1*n1;
printf("O quadrado e: %d\n",quadrado);
system("PAUSE");
return 0;
49
8) Faça um programa que calcule o salario líquido de um professor baseando-
se no valor da hora aula, quantidade de aulas dadas e a % de desconto do
INSS. E por final mostre o salario bruto, liquido e o desconto.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
float valor_hora,qtd_aulas,desconto_inss,sal_bruto,sal_liquido;
printf("Entre com o valor da hora-aula\n");
scanf("%f",&valor_hora);
printf("Entre com a quantidade de aulas\n");
scanf("%f",&qtd_aulas);
printf("Entre com o desconto do inss de 0~100%\n");
scanf("%f",&desconto_inss);
sal_bruto=valor_hora*qtd_aulas;
sal_liquido=sal_bruto-(sal_bruto*(desconto_inss/100));
printf("O Salario Bruto e: %.2f\nO Salario Liquido e: %.2f\nO Desconto Foi: %.2f%%\n",sal_bruto,sal_liquido,desconto_inss);
system("PAUSE");
return 0;
50
Capítulo 5 - Condicionais IF, ELSE e SWITCH-CASE Bom, até então nossos programas feitos, só utilizaram cálculos matemáticos, foram todos baseados em cima de expressões, tudo isso é necessário para que se possa dar o próximo passo para as condicionais, onde será a parte que o seu programa irá se tornar um pouco mais "racional". Mas o que vem a serem as condicionais? Aonde devo aplicá-las? Em que elas irão me ajudar? Daqui em diante no nosso curso, iremos utilizar as condicionais em grande parte dele, afinal nossos programas irão se tornar um pouco mais extensos e lógicos.
5.1. Compreendendo o IF e ELSE. O IF significa "SE", já o ELSE significa "SENÃO", ou seja, as condicionais IF e ELSE serão utilizadas para a tomada de decisões, caso uma condição seja verdadeira ou caso ela seja falsa. De uma forma interpretativa para um melhor entendimento suponhamos a seguinte situação: "Vou tomar sorvete se fizer calor hoje" logo podemos interpretar a situação da seguinte maneira: SE estiver calor irei tomar sorvete, SENÃO não irei tomar sorvete. A condicional IF e ELSE funcionam dessa mesma forma se um caso (SE) for verdade ele executa-o se for falso ele executa o outro caso (SENÃO). Mas agora vamos tentar entender o funcionamento do IF na prática. Primeiro analisemos sua sintaxe. if (condição) // if é o comando todo em minúsculas, (condição) é a condição que você irá definir para execução de uma determinada tarefa. comandos; // o if utiliza chaves abrindo e fechando e ele só executa os comandos aqui contidos se a condição do IF for VERDADEIRA. else // else é o comando todo em minúsculas, diferente do if nesse caso ele não tem condição ele serve para qualquer outro caso. comandos; // o else também utiliza chaves abrindo e fechando e ele só executa os comandos aqui contidos se a condição do IF for FALSA.
51
5.2. Lógica Comentada
Exemplo 01) Faça um programa que receba duas idades quaisquer e retorne a
maior ou se são iguais.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int id1,id2;
printf("Entre com a idade 1 e a idade 2\n",&id1,&id2);
scanf("%d %d",&id1,&id2);
if (id1>id2)
printf("A idade %d e maior\n",id1);
else if (id1<id2)
printf("A idade %d e maior\n",id2);
else
printf("As idades sao iguais\n");
system("PAUSE");
return 0;
52
Vamos interpretar o nosso programa agora, para melhor entender o que está
ocorrendo.
int id1,id2;
printf("Entre com a idade 1 e a idade 2\n",&id1,&id2);
scanf("%d %d",&id1,&id2);
Nesta primeira parte id1 e id2 são declaradas como variáveis inteiras, uma saida de dados(printf) envia uma mensagem ao usuário pedindo que ele informe a idade 1 e a idade 2 e por fim uma entrada de dados(scanf) recebe esses valores e os armazena em id1 e id2(respectivamente em seus endereços de memória). -- Primeiro Bloco Condicional abaixo if (id1>id2)
printf("A idade %d e maior\n",id1);
Nesta segunda parte temos a nossa condicional que está verificando se id1 é maior que id2 [if (id1>id2)] se essa condição for verdadeira, o seu programa irá executar a saída de dados(printf) que esta dentro das chaves, se ela for falsa ele irá pular para a próxima condição. -- Segundo Bloco Condicional abaixo else if (id2>id1)
printf("A idade %d e maior\n",id2);
Nesta terceira parte temos o ELSE que é referente ao IF doprimeiro bloco
condicional e temos também outro IF que é para que possamos impor a nossa
segunda condição [if(id1<id2)], relembrando que esse ELSE IF só será
executado se o primeiro IF for falso, pois o ELSE está ligado diretamente ao
primeiro IF, logo podemos concluir que nesta terceira parte a saída de
dados(printf) que está dentro das chaves do ELSE IF só irá executar caso o
primeiro IF seja falso.
53
-- Terceiro Bloco Condicional abaixo
else
printf("As idades sao iguais\n");
Nesta última parte temos apenas um ELSE, que é no ultimo caso, se o IF do
primeiro bloco condicional e o ELSE IF do segundo bloco condicional forem
falsos ele automaticamente irá executar esse ultimo ELSE. assim executando a
saída de dados(printf) apenas se as duas condições forem falsas.
Pensando logicamente não se faz necessário a escrita de mais um if como
abaixo:
else if (id1==id2)
printf("As idades sao iguais\n");
Pois:
1 - No primeiro Bloco Condicional você testa se o id1 é maior que o id2
2 - No segundo Bloco Condicional você testa se o id2 é maior que o id1
Então analisando e interpretando os blocos, pode-se concluir que: Se o id1 não
for maior que o id2(1º Bloco) e o id2 não for maior que o id1(2º Bloco)
automaticamente as idades só podem ser iguais.
54
Olhando por outro lado, poderíamos reescrever o mesmo programa, com as
mesmas funções da forma a seguir:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int id1,id2;
printf("Entre com a idade 1 e a idade 2\n",&id1,&id2);
scanf("%d %d",&id1,&id2);
if (id1>id2)
printf("A idade %d e maior\n",id1);
else if (id1<id2)
printf("A idade %d e maior\n",id2);
else
printf("As idades sao iguais\n");
system("PAUSE");
return 0;
Mas e as chaves do IF, ELSE IF e ELSE? O programa vai funcionar do mesmo
jeito? Eu não preciso mais usá-las?
Para este caso o seu programa irá funcionar sim, mas veja bem, neste caso
não se fez necessário o uso de chaves pois, dentro das condicionais possui
apenas um comando(um único printf), caso tivesse mais de um comando o uso
de chaves seria obrigatório, em outras palavras, se tivesse mais um printf
dentro de algum IF ou ELSE o seu programa apresentaria erro de semântica.
Erro de semântica representa o erro de lógica (erro no seu raciocínio) e o erro
de sintaxe representa o erro de programação (comandos utilizados
incorretamente).
55
5.3. Exemplos
1) Faça um programa que receba dois números quaisquer e o usuário possa
escolher uma operação para realizar: 1- Soma, 2 - Subtração, 3 - Multiplicação
ou 4 - Divisão em seguida mostre o resultado, caso o usuário escolha uma
opção inexistente o programa deverá retornar opção invalida.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
float n1,n2,opcao,result;
printf("Entre com os valores N1 e N2\n");
scanf("%f %f",&n1,&n2);
printf("Escolha a Operacao\n 1)Soma\n 2)Subtracao\n 3)Multiplicacao\n 4)Divisao\n");
scanf("%f",&opcao);
if (opcao==1)
result=n1+n2;
printf("O Resultado e %.2f\n",result);
else if (opcao==2)
result=n1-n2;
printf("O Resultado e %.2f\n",result);
else if (opcao==3)
result=n1*n2;
printf("O Resultado e %.2f\n",result);
else if (opcao==4)
result=n1/n2;
printf("O Resultado e %.2f\n",result);
56
else
printf("Opcao Invalida\n");
system("PAUSE");
return 0;
2) Faça um programa que receba um numero qualquer inteiro e que retorne se
ele é PAR ou IMPAR.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int numero;
printf("Entre com o numero\n");
scanf("%d",&numero);
if (numero%2==0)
printf("O Numero e PAR\n");
else
printf("O Numero e Impar\n");
system("PAUSE");
return 0;
57
3) Faça um programa que receba um numero qualquer inteiro e verifique se ele
é divisível por 2 e 3.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int numero;
printf("Entre com o numero\n");
scanf("%d",&numero);
if (numero%2==0 && numero%3==0)
printf("E divisivel por 2 e 3\n");
else
printf("Nao e divisivel por 2 e 3\n");
system("PAUSE");
return 0;
58
4)Faça um programa que receba um numero qualquer inteiro e verifique se ele
é divisível por 4 ou por 5 ou pelos dois.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int numero;
printf("Entre com o numero\n");
scanf("%d",&numero);
if (numero%4==0 && numero%5==0)
printf("E divisivel por 4 e 5\n");
else if (numero%4==0)
printf("E divisivel por 4\n");
else if (numero%5==0)
printf("E divisivel por 5\n");
else
printf("Nao e divisivel por 4 e nem por 5\n");
system("PAUSE");
return 0;
59
5)Sabe-se que as portas lógicas AND(E), OR(OU), XOR(OU Exclusivo) e
NXOR(Coincidência) possuem diferentes saídas em suas tabelas verdades,
então cabe a você fazer um programa que recebe as 4 saídas de uma
determinada porta lógica e identifique se ela é uma porta AND, OR, XOR,
NXOR ou inexistente, veja a figura a seguir:
60
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int s1,s2,s3,s4;
printf("Entre com as saidas da porta logica\nAs saidas devem assumir apenas valor 0 ou 1\n");
scanf("%d %d %d %d",&s1,&s2,&s3,&s4);
if (s1==0 && s2==0 && s3==0 && s4==1)
printf("Porta Logica And\n");
else if (s1==0 && s2==1 && s3==1 && s4==1)
printf("Porta Logica OR\n");
else if (s1==0 && s2==1 && s3==1 && s4==0)
printf("Porta Logica XOR\n");
else if (s1==1 && s2==0 && s3==0 && s4==1)
printf("Porta Logica NXOR\n");
else
printf("Porta Logica Inexistente ou Saida Digitada Invalida\n");
system("PAUSE");
return 0;
61
6) Dado o circuito elétrico a seguir, faça um programa que calcule a corrente do
circuito para quaisquer valor de R1, R2 e R3.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
float v,i,req,r1,r2,r3;
printf("Entre com o valor da Tensao\n");
scanf("%f",&v);
printf("Entre com os valores de R1, R2 e R3\n");
scanf("%f %f %f",&r1,&r2,&r3);
req=(r3*r2)/(r3+r2)+r1;
i=v/req;
printf("O Valor da Corrente e %f\n",i);
system("PAUSE");
return 0;
62
5.4. Condicional SWITCH-CASE (Escolha-caso) Bem como vimos o IF e ELSE, também temos outra análise condicional similar ao IF que é o Switch, porém o Switch só aceita variáveis inteiras. Sua sintaxe é bem simples veja abaixo: switch (variavel) case 1: comandos; break; case 2: comandos; break; case N: comandos; break; default: comandos; Analisando o código acima, podemos notar que o comando Escolha-Caso(Switch-Case) ele análisa uma variável qualquer e dependendo do valor da variável ele executa uma ação. Por exemplo, se o valor de "variável" for 1, ele executa o case 1: [...] se for 2 ele executa o case 2: [...] e assim por diante até o default: que é caso o valor não seja nenhum dos cases acima.
5.5. Exemplos 1) Faça um programa que receba do usuario um numero referente a um dia da
semana e indique qual dia é, considere 1 - domingo e 7 - sabado.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int diasemana;
printf("Digite um numero relativo ao dia da semana: \n1)Domingo\n2)Segunda\n3)Terca\n4)Quarta\n5)Quinta\n6)Sexta\n7)Sabado\n");
scanf("%d",&diasemana);
switch (diasemana)
case 1:
printf("Domingo\n");
break;
case 2:
printf("Segunda\n");
63
break;
case 3:
printf("Terca\n");
break;
case 4:
printf("Quarta\n");
break;
case 5:
printf("Quinta\n");
break;
case 6:
printf("Sexta\n");
break;
case 7:
printf("Sabado\n");
break;
default:
printf("Dia invalido\n");
system("PAUSE");
return 0;
64
2) Faça um programa que receba do usuario um numero referente a um mês
do ano.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int mes;
printf("Digite um numero relativo ao mes do ano: \n1)Janeiro\n2)Fevereiro\n3)Marco\n4)Abril\n5)Maio\n6)Junho\n");
printf("7)Julho\n8)Agosto\n9)Setembro\n10)Outubro\n11)Novembro\n12)Dezembro\n");
scanf("%d",&mes);
switch (mes)
case 1:
printf("Janeiro");
break;
case 2:
printf("Fevereiro");
break;
case 3:
printf("Marco");
break;
case 4:
printf("Abril");
break;
case 5:
printf("Maio");
break;
case 6:
printf("Junho");
break;
case 7:
printf("Julho");
65
break;
case 8:
printf("Agosto");
break;
case 9:
printf("Setembro");
break;
case 10:
printf("Outubro");
break;
case 11:
printf("Novembro");
break;
case 12:
printf("Dezembro");
break;
default:
printf("Mes invalido");
system("PAUSE");
return 0;
66
3) Faça um programa que peça ao usuario uma operação: Soma, Subtração, Multiplicação ou Divisão receba dois numeros e execute a operação selecionada. #include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int operacao;
float n1,n2,result;
printf("Entre com N1 e N2\n");
scanf("%f %f",&n1,&n2);
printf("Entre com a operacao desejada: \n1)Soma\n2)Subtracao\n3)Multiplicacao\n4)Divisao\n");
scanf("%d",&operacao);
switch (operacao)
case 1:
result=n1+n2;
printf("O Resultado da Soma e %.2f\n",result);
break;
case 2:
result=n1-n2;
printf("O Resultado da Subtracao e %.2f\n",result);
break;
case 3:
result=n1*n2;
printf("O Resultado da Multiplicacao e %.2f\n",result);
break;
case 4:
result=n1/n2;
printf("O Resultado da Divisao e %.2f\n",result);
break;
default:
67
printf("Operacao Invalida\n");
system("PAUSE");
return 0;
O Comando Switch é bem simples, ele irá analisar o valor guardado dentro da
variável de controle, depois irá executar o case equivalente ao valor. Como no
exercicio 1 se a variável "diasemana" for igual a 3 ele irá mostrar "Terca" pois
ele iria cair no case 3. No exercício 2 se a variável "mes" for igual a 9 ele irá
mostrar "Setembro" pois ele iria cair no case 9. E No exercício 3 se a variável
"operacao" for igual a 2 ele irá fazer a subtração de n1 por n2 e mostrar o result
pois ele iria cair no case 2.
68
5.6. Exercícios
1) Faça um programa que receba o peso de uma pessoa e retorne as
seguintes mensagens: Magra se ela tiver menos que 40kg, Normal se
tiver mais que 40kg e menos que 80kg e Gorda se tiver mais que 80kg.
2) Faça um programa que receba três notas retire a média entre elas e se
a média for maior que 6 o retornará a mensagem aprovado, se for menor
que 6 ele retornará reprovado.
3) Faça um programa que receba três números e os coloque em ordem
crescente.
4) Faça um programa que receba três números e os coloque em ordem
decrescente.
5) Faça um programa que receba o mês em que uma pessoa nasceu e
indique se ela nasceu no 1º, 2º, 3º ou 4º Trimestre do ano.
6) Faça um programa que Calcule e exiba o valor da conta de luz, a partir
da leitura do consumo em KwH do mês anterior e do mês atual marcado
no relógio. O cálculo deverá se basear nos dados da tabela apresentada
a seguir:
69
Capítulo 6 - Tipo de Dado Char e Strings. O tipo de dado char, nada mais são do que os nossos caracteres, são tipos de dados fáceis de manipular e trabalhar. No nosso curso com Ênfase na automação iremos utilizar ele para guardar letras e palavras, para que possamos desenvolver nossos sistemas básicos. Então vamos lá vejamos sua sintaxe. - Como declarar uma variável char: char sexo; Assim você declara uma variável char com nome sexo e capacidade para armazenar um único caractere. char sexo[20]; Assim você declara uma variável char com nome sexo e capacidade para armazenar vinte caracteres que juntos formam uma String ou array de caracteres. Sua representação como entrada de dados utiliza-se %c quando se trata de apenas um caractere ou %s quando se trata de mais do que um caractere, vejamos um exemplo: 1) Faça um programa que receba duas idades e dois sexos e indique qual
idade é maior e qual é o sexo dessa mesma idade.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int idade1,idade2;
char sexo1,sexo2;
printf("Entre com a primeira idade e o sexo da mesma\n");
scanf("%d %c",&idade1,&sexo1);
printf("Entre com a segunda idade e o sexo da mesma\n");
scanf("%d %c",&idade2,&sexo2);
if (idade1>idade2)
printf("Maior idade: %d Sexo: %c\n",idade1,sexo1);
else if (idade1<idade2)
printf("Maior idade: %d Sexo: %c\n",idade2,sexo2);
else
printf("Idades iguais: %d\n",idade1);
system("PAUSE");
return 0;
70
Vejamos o que ocorre no nosso programa: foram declaradas como inteiro as
variáveis idade1 e idade2 e como char sexo1 e sexo2. Veja a forma que é
utilizada para guardar um único caractere nos scanf's, utiliza-se %c o formato é
o mesmo. Também existem outras formas de receber dados utilizando outros
comandos que não nos convém neste momento. Logo em seguida, são
aplicadas as condicionais IF para saber qual das idades é maior e assim exibi-
la, juntamente do sexo da maior idade.
Agora vejamos outro exemplo só que com palavras.
2) Faça um programa que receba 3 palavras e que as imprima na tela de trás
para frente.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
char palavra1[20],palavra2[20],palavra3[20];
printf("Digite as 3 palavras\n");
scanf("%s %s %s",palavra1,palavra2,palavra3);
printf("%s %s %s\n",palavra3,palavra2,palavra1);
system("PAUSE");
return 0;
Este é bem básico são declaradas como vetores (veremos no capítulo X mais
detalhadamente) de caracteres as variáveis palavra1, palavra2 e palavra3. As
mesmas são capazes de armazenar palavras de até 20 caracteres, no printf ele
pede para que o usuário digite elas no scanf ele armazena-as na sua
determinada ordem e no ultimo printf ele inverte a ordem e imprime na tela.
Existe também a biblioteca string.h que é capaz de fazer diversas funções
diferentes como copiar uma string para uma outra determinada variável,
comparar as mesmas, e etc. Mas o nosso foco especificamente não é esse.
Vale lembrar que caracteres são separados por aspas simples ‘a’ e strings por
aspas duplas “Bom dia” e para o armazenamento de strings através do
comando scanf não se faz necessário o uso de &(E comercial) para guardar as
strings. No capítulo 8 será feita uma abordagem mais aprofundada sobre
strings.
71
Capítulo 7 - Laços de Repetição FOR, While e Do-
While
For é a primeira de uma série de três estruturas para se trabalhar com loops de repetição. As outras são while e do while. As três compõem a segunda família de comandos de controle de fluxo. Podemos pensar nesta família como sendo a das estruturas de repetição controlada. Como já foi dito, o loop for é usado para repetir um comando, ou bloco de comandos, diversas vezes, de maneira que se possa ter um bom controle sobre o loop. Sua forma geral é: for (inicialização; condição; declaração, incremento); O melhor modo de se entender o loop for é ver como ele funciona "por dentro". O loop for é equivalente a se fazer o seguinte: inicialização; if (condição) declaração; incremento; "Volte para o comando if" Podemos ver, então, que o for executa a inicialização incondicionalmente e testa a condição. Se a condição for falsa ele não faz mais nada. Se a condição for verdadeira ele executa a declaração, faz o incremento e volta a testar a condição. Ele fica repetindo estas operações até que a condição seja falsa. Um ponto importante é que podemos omitir qualquer um dos elementos do for, isto é, se não quisermos uma inicialização poderemos omiti-la. Abaixo vemos um programa que coloca os primeiros 100 números inteiros na tela: #include <stdio.h> #include <stdlib.h> int main() int cont; for (cont=0; cont<=100; cont++) printf("%d\n",cont); system("PAUSE"); return 0;
72
O Loop FOR é muito fácil de se aplicar, porém devemos tomar cuidado para não cairmos em um LOOP Infinito, onde o FOR não irá parar de executar. Temos também o laço de repetição while, que pode trabalhar da mesma forma que um FOR. vejamos o mesmo exercício acima utilizando o laço while como ficaria. #include <stdio.h> #include <stdlib.h> int main() int cont=0; while(cont<=100) printf("%d",cont); cont++; system("PAUSE"); return 0;
O laço while, ele faz o teste se cont é menor ou igual a CEM no inicio do laço, e caso o teste for verdade, ele irá executar os comandos contidos nas chaves, ao final o ultimo comando cont++ realiza um incremento de 1, e ele volta a testar a condição de cont menor ou igual a CEM, o while só irá parar de executar quando a condição de cont for falsa. E Temos também o laço Do-While, a única diferença entre o laço Do-While é que ele executa primeiro os comandos e depois ele testa a condição, vejamos o mesmo exercicio feito com o Do-While. #include <stdio.h> #include <stdlib.h> int main() int cont=0;
do
printf("%d\n",cont);
cont++;
while(cont<=100);
system("PAUSE"); return 0;
73
7.1. Exemplos 1) Exiba 1000 vezes o seu nome
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
char nome[40];
int i;
printf("Entre com seu nome\n");
scanf("%s",&nome);
for (i=0; i<1000; i++) printf("%s\n",nome);
system("PAUSE");
return 0;
2) Exiba os números de 1 a 500, um ao lado do outro com um espaço em
branco de separação.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int i;
for (i=1; i<=500; i++) printf("%d ",i);
system("PAUSE");
return 0;
74
3) Exiba todos os números pares de 10 a 200, um em cada linha.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int i;
for (i=0; i<=200; i++)
if (i%2==0)
printf("%d\n",i);
system("PAUSE");
return 0;
4) Verifique se um número é primo ou não.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int numero,i,cont=0;
printf("Entre com o numero que deseja saber se e primo ou nao\n");
scanf("%d",&numero);
for (i=1; i<numero; i++) if (numero%i==0) cont+=1;
if (cont>1) printf("Nao e primo\n");
else printf("E primo\n");
system("PAUSE");
return 0;
75
5)Solicite ao usuário a idade de cada um componente de um grupo de pessoas. A quantidade de pessoas também será determinada por ele antes da entrada das idades. Após o término da entrada, apresente: a) a média das idades,
b) a maior idade,
c) a menor idade,
d) a quantidade de pessoas maior de idade.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
float idade,maior=0,menor=0,cont=0,qtd,i,media=0;
printf("Quantas pessoas deseja solicitar a idade?\n");
scanf("%f",&qtd);
for (i=0; i<qtd; i++)
printf("Entre com a %.0f idade\n",i+1);
scanf("%f",&idade);
if (i==0)
maior=idade;
menor=idade;
if (idade>maior)
maior=idade;
if (idade<menor)
menor=idade;
if (idade>=18) cont++;
media=media+idade;
printf("A media e %.2f\n",media/qtd);
printf("Sao %.0f maiores de idade\n",cont);
printf("A maior idade e %.0f anos\n",maior);
printf("A menor idade e %.0f anos\n",menor);
76
system("PAUSE");
return 0;
Os mesmos exercícios usando o comando While.
1) Exiba 1000 vezes o seu nome
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
char nome[40];
int i=0;
printf("Entre com seu nome\n");
scanf("%s",&nome);
while (i<1000)
printf("%s\n",nome);
i++;
system("PAUSE");
return 0;
77
2) Exiba os números de 1 a 500, um ao lado do outro com um espaço em
branco de separação.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int i=0;
while(i<=500)
printf("%d ",i);
i++;
system("PAUSE");
return 0;
3) Exiba todos os números pares de 10 a 200, um em cada linha.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int i=0;
while(i<=200)
if (i%2==0)
printf("%d\n",i);
i++;
system("PAUSE");
return 0;
78
4) Verifique se um número é primo ou não.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int numero,i=1,cont=0;
printf("Entre com o numero que deseja saber se e primo ou nao\n");
scanf("%d",&numero);
while(i<numero)
if (numero%i==0)
cont+=1;
i++;
if (cont>1) printf("Nao e primo\n");
else printf("E primo\n");
system("PAUSE");
return 0;
5)Solicite ao usuário a idade de cada um componente de um grupo de pessoas. A quantidade de pessoas também será determinada por ele antes da entrada das idades.
Após o término da entrada, apresente:
a) a média das idades,
b) a maior idade,
c) a menor idade,
d) a quantidade de pessoas maior de idade.
79
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
float idade,maior=0,menor=0,cont=0,qtd,i=0,media=0;
printf("Quantas pessoas deseja solicitar a idade?\n");
scanf("%f",&qtd);
while(i<qtd)
printf("Entre com a %.0f idade\n",i+1);
scanf("%f",&idade);
if (i==0)
maior=idade;
menor=idade;
if (idade>maior)
maior=idade;
if (idade<menor)
menor=idade;
if (idade>=18) cont++;
media=media+idade;
i++;
printf("A media e %.2f\n",media/qtd);
printf("Sao %.0f maiores de idade\n",cont);
printf("A maior idade e %.0f anos\n",maior);
printf("A menor idade e %.0f anos\n",menor);
system("PAUSE");
return 0;
80
Os mesmos exercícios usando o comando Do-While.
1) Exiba 1000 vezes o seu nome
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
char nome[40];
int i=0;
printf("Entre com seu nome\n");
scanf("%s",&nome);
do
printf("%s\n",nome);
i++;
while(i<1000);
system("PAUSE");
return 0;
2) Exiba os números de 1 a 500, um ao lado do outro com um espaço em
branco de separação.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int i=1;
do
printf("%d ",i);
i++;
while(i<=500);
system("PAUSE");
return 0;
81
3) Exiba todos os números pares de 10 a 200, um em cada linha.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int i=10;
do
if (i%2==0)
printf("%d\n",i);
i++;
while(i<=200);
system("PAUSE");
return 0;
4) Verifique se um número é primo ou não.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int numero,i=1,cont=0;
printf("Entre com o numero que deseja saber se e primo ou nao\n");
scanf("%d",&numero);
do
if (numero%i==0)
cont+=1;
i++;
while(i<numero);
if (cont>1) printf("Nao e primo\n");
else printf("E primo\n");
82
system("PAUSE");
return 0;
5)Solicite ao usuário a idade de cada um componente de um grupo de pessoas. A quantidade de pessoas também será determinada por ele antes da entrada das idades.
Após o término da entrada, apresente:
a) a média das idades,
b) a maior idade,
c) a menor idade,
d) a quantidade de pessoas maior de idade.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
float idade,maior=0,menor=0,cont=0,qtd,i=0,media=0;
printf("Quantas pessoas deseja solicitar a idade?\n");
scanf("%f",&qtd);
do
printf("Entre com a %.0f idade\n",i+1);
scanf("%f",&idade);
if (i==0)
maior=idade;
menor=idade;
if (idade>maior) maior=idade;
83
if (idade<menor) menor=idade;
if (idade>=18) cont++;
media=media+idade;
i++;
while(i<qtd);
printf("A media e %.2f\n",media/qtd);
printf("Sao %.0f maiores de idade\n",cont);
printf("A maior idade e %.0f anos\n",maior);
printf("A menor idade e %.0f anos\n",menor);
system("PAUSE");
return 0;
7.2. Exercícios
1) Exiba mil vezes o seu nome.
2) Exiba os números de 1 a 500, um ao lado do outro com um espaço em
branco de separação.
3) Exiba todos os números pares de 10 a 200, um em cada linha.
4) Leia um conjunto de 20 valores inteiros e em seguida exiba-os na ordem
inversa do que foram digitados.
5) Leia um conjunto de 10 notas de alunos. Calcule e exiba a média destas
notas. Em seguida exiba apenas as notas que são maiores do que a média
calculada.
84
Capítulo 8 - Vetores, Matrizes e Strings.
8.1. Vetores Vetores são usados para tratamento de conjuntos de dados que possuem as
mesmas características. Uma das vantagens de usar vetores é que o conjunto
recebe um nome comum e elementos deste conjunto são referenciados através
de índices. Pelo nome vetor estaremos referenciando estruturas que podem ter
mais de uma dimensão, como por exemplo, matrizes de duas dimensões.
Declarando um vetor
Como uma variável qualquer das que trabalhamos um vetor também possui um tipo de dado (Int, Float, Char) e seu índice para representar a quantidade de posições dele. Exemplo: tipo_de_dado nome_variável[indice_de_posicoes]; Como se declara vetores então? int numeros[20]; Assim acabamos de declarar uma variável com nome "numeros", ela é do tipo inteira (int) e é um vetor com capacidade de armazenamento de 20 posições, ou seja, ela é capaz de armazenar 20 numeros inteiros. float peso[20]; Assim acabamos de declarar uma variável com nome "peso", ela é do tipo ponto flutuante (float) e é um vetor com capacidade de armazenamento de 20 posições, ou seja, ele é capaz de armazenar 20 números reais. char nome[10]; Assim acabamos de declarar uma variável com nome "nome", ela é do tipo caractere (char) e é um vetor com capacidade de armazenamento de 20 posições, ou seja, ela é capaz de armazenar 20 CARACTERES (NÃO SÃO 20 PALAVRAS) onde vale lembrar que o último caractere é representado pelo dígito terminador '\0' que é onde encerra o preenchimento de um vetor de caracteres também chamado de String. Uma consideração importante é a seguinte, é bom sempre lembrar que em um vetor a sua primeira posição é no índice 0 (ZERO), e sua ultima posição será no índice quantidade_de_posicoes-1(Tamanho do vetor menos 1). De uma forma mais representativa, por exemplo, declara-se um vetor de 7 posições do tipo inteiro com nome dia_semana. int dia_semana[7]; A primeira posição desse vetor é dia_semana[0], a segunda é dia_semana[1], a terceira é dia_semana[2] ... a última é dia_semana[indice_de_posicoes-1] que equivale à dia_semana[6]. Este tipo de consideração é valido para qualquer vetor.
85
Agora como podemos trabalhar com vetores e em que eles nos serão úteis? Veja o exercício a seguir: 1) Faça um programa que leia e retire a média de 3 numeros.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
float n1,n2,n3,media;
printf("Entre com o valor de N1, de N2 e de N3\n");
scanf("%f %f %f",&n1,&n2,&n3);
media=(n1+n2+n3)/3;
printf("A Media e: %f\n",media);
system("PAUSE");
return 0;
Acima está o nosso programa resolvido no modo "bruto" existem maneiras
mais simples de refazer o mesmo programa vejamos agora:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
float numeros[3],media=0;
int i;
for(i=0;i<3;i++)
printf("Entre com o valor de N%d \n",i+1);
scanf("%f",&numeros[i]);
media+=numeros[i];
media/=3;
printf("A Media e: %f\n",media);
system("PAUSE");
return 0;
86
E aparentemente o nosso programa se utilizando vetores se tornou maior do
que sem vetores, porém poupamos 2 variáveis N2 e N3 e acrescentamos a
variável i. Para este caso aparenta ser inviável o uso de vetores, mas imagine
agora para remover a média de 10 números? Vejamos a seguir no modo
"bruto".
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
float n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,media;
printf("Entre com o valor de N1, N2, N3, N4, N5, N6, N7, N8, N9 e N10\n");
scanf("%f %f %f %f %f %f %f %f %f %f",&n1,&n2,&n3,&n4,&n5,&n6,&n7,&n8,&n9,&n10);
media=(n1+n2+n3+n4+n5+n6+n7+n8+n9+n10)/10;
printf("A Media e: %f\n",media);
system("PAUSE");
return 0;
E agora no modo simplificado com o uso de vetores.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
float numeros[10],media=0;
int i;
for(i=0;i<10;i++)
printf("Entre com o valor de N%d \n",i+1);
scanf("%f",&numeros[i]);
media+=numeros[i];
media/=10;
printf("A Media e: %f\n",media);
system("PAUSE");
87
return 0;
enfim agora poupamos de usar as variáveis: n2, n3, n4, n5, n6, n7, n8, n9 e n10 em troca disso estamos usando um vetor de numeros com 10 posições(numeros[10]) e uma variável i. Ou seja à medida que o nível de complexidade dos programas vão aumentando torna-se indispensável o uso de vetores, para redução do seu programa e otimização do mesmo. Estes tipos de vetores são chamados de VETORES UNIDIMENSIONAIS (de uma única dimensão).
8.2. Cadeia de caracteres(String) Cadeia de caracteres são os vetores de caracteres também chamados de
strings, são vetores capazes de armazenar palavras.
exemplo:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
char nome[10];
gets(nome);
printf("%s\n",nome);
system("PAUSE");
return 0;
Este programa recebe um nome do usuário e imprime-o na tela. o Vetor nome
tem capacidade de 10 posições porém armazena apenas 9 caracteres
lembrando que o ultimo é o digito terminador '\0'.
Por ser uma string, podem-se usar vários comandos novos tais como o "gets"
ele se comporta como um scanf. Não é muito aconselhável o uso de
scanf("%s",nome) para variáveis do tipo char, e vale lembrar também que as
strings comportam-se como ponteiros, logo não se faz necessário o uso de &
no scanf pois ele já aponta direto ao endereço de memória da variável nome.
88
Então podemos reescrever o mesmo programa da seguinte maneira:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
char nome[10];
scanf("%s",nome);
printf("%s\n",nome);
system("PAUSE");
return 0;
Na linguagem C também possuímos a biblioteca string.h que possui diversas funções para manipulação de strings vejamos abaixo:
lembre-se sempre de incluí-la(#include <string.h>) nos seus programas quando for utilizar alguns desses comandos, caso contrário eles poderão não funcionar corretamente ou até não funcionar.
89
8.3. Matrizes Em C existe há possibilidade de declararmos vetores de mais de uma dimensão. A forma geral da declaração é a seguinte: tipo_de_dade nome[dim1][dim2]..[dimN] As matrizes nada mais sao que vetores de duas dimensões, vejamos um exemplo: int matriz[3][3];
acima temos uma matriz de 3 linhas por 3 colunas(Matriz[Linhas][Colunas]). Vale lembrar que iremos trabalhar com vetores de no máximo duas dimensões aqui. O uso de matrizes irá nos ajudar também a trabalhar com palavras, vamos exemplificar agora: Faça um programa que receba 5 nomes e depois imprima os 5 na tela.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
char nome[5][10];
int i;
for (i=0; i<5; i++)
gets(nome[i]);
for (i=0; i<5; i++)
printf("%s\n",nome[i]);
system("PAUSE");
return 0;
no exemplo acima nome é uma matriz de 5 linhas onde cada linha é capaz de
armazenar 10 caracteres. Lembrando que o último é sempre o digito
terminador '\0'.
90
8.4. Exemplos 1) Leia um conjunto de 10 notas de alunos. Calcule e exiba a média destas
notas. Em seguida exiba apenas as notas que são maiores do que a média
calculada.
#include <stdio.h>
#include <stdlib.h>
#define MAX 10
int main(int argc, char *argv[])
float nota[MAX],media=0;
int i;
for(i=0; i<MAX; i++)
printf("entre com a %d nota\n",i+1);
scanf("%f"¬a[i]);
media=media+nota[i];
media=media/max;
printf("Media da classe %.2f\n",media);
for (i=0; i<MAX; i++)
if (nota[i]>media)
printf("Nota %.2f acima da media da classe\n",nota[i]);
system("PAUSE");
return 0;
91
2) Leia um conjunto de 20 valores inteiros e em seguida exiba-os na ordem
inversa do que foram digitados.
#include <stdio.h>
#include <stdlib.h>
#define MAX 20
int main(int argc, char *argv[])
int numeros[MAX],i;
for(i=0; i<MAX; i++)
printf("entre com o %d numero\n",i+1);
scanf("%d",&numeros[i]);
for (i=max-1; i>=0; i--)
printf("%d ",numeros[i]);
system("PAUSE");
return 0;
92
3) Crie um vetor capaz de armazenar 50 números inteiros. Em seguida faça o
seu preenchimento automático com os números de 101 a 150, ou seja, na
posição número 0 ponha 101, na posição 1 ponha o número 102, e assim
sucessivamente. Em seguida exiba os valores deste vetor.
#include <stdio.h>
#include <stdlib.h>
#define MAX 50
int main(int argc, char *argv[])
int numeros[max],i,j;
for(i=101,j=0; j<50; j++,i++)
numeros[j]=i;
for (i=0; i<50; i++)
printf("%d ",numeros[i]);
system("PAUSE");
return 0;
4)Faça um programa que receba do usuario uma matriz de ordem 3 calcule a
soma de sua diagonal principal.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
int matriz[3][3],i,j,soma=0;
for (i=0; i<3; i++)
for (j=0; j<3; j++)
printf("Entre com o valor da posicao %d %d\n",i,j);
if (i==0)
soma+=matriz[i][j];
93
printf("A soma dos elementos e %d\n",soma);
system("PAUSE");
return 0;
5) Faça um programa que receba 5 nomes e depois exiba os em ordem
contrária, o ultimo primeiro, o penúltimo segundo e etc.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
char nome[5][30];
int i;
for (i=0; i<5; i++)
printf("Entre com o primeiro nome\n");
fflush(stdin);
gets(nome[i]);
for (i=4; i>=0; i--)
printf("%s\n",nome[i]);
system("PAUSE");
return 0;
A diretiva “#define” indica uma definição como nos casos acima. Por exemplo: #define MAX 10
Define que a palavra MAX irá ter valor 10, assim não podendo possuir outro valor a não ser que seja modificada em sua definição.
94
8.5. Exercícios
1) Solicite o nome do usuário, em seguida exiba-o na console.
2) Exiba a quantidade de caracteres do nome do usuário.
3) Solicite uma frase ao usuário, e em seguida exiba-a sem espaços em
branco.
4) Solicite dois nomes ao usuário, em seguida verifique se os dois são
exatamente iguais.
5) Em um prédio de 8 andares com 4 apartamentos por andar há uma
necessidade de se registrar o consumo de energia elétrica de um determinado
mês. Faça um programa para realizar este registro (em todos os
apartamentos). Entre os muitos levantamentos que se pode fazer com estes
dados, no momento, se quer saber as seguintes informações:
- consumo total dos apartamentos da 2ª coluna.
- consumo total de cada andar deste do prédio.
6) Criar um algoritmo que leia os elementos de uma matriz inteira de 4 x 4 e
imprimir os elementos da diagonal principal.
7) Criar um algoritmo que leia os elementos de uma matriz inteira de 3 x 3 e
imprimir todos os elementos, exceto os elementos da diagonal principal.
8) Preencher um vetor com números inteiros(8unidades); solicitar um número
do teclado. Pesquisar se esse número existe no vetor. Se existir,imprimir em
qual posição do vetor. Se não existir,imprimir MSG que não existe.
9) Preencher um vetor com os numeros pares do número 2 a 20 e depois exibi-
los.
10) Preencher um vetor de 8 elementos inteiros. Mostrar o vetor e informar
quantos números são maior que 30.
95
Capítulo 9 – Funções
Até então as únicas funções que utilizamos, foi a função main, que é a principal
de cada programa constituído no nosso curso, ela era representada como “int
main”, pois ao final do programa ela sempre retornava um inteiro “return 0;”
existem também outros tipos de funções além da int como float, char, void,
struct e etc. neste capítulo iremos abordar suas utilidades e aplicações a
grande vantagem do uso de funções é poder simplificar, esclarecer e organizar
seus códigos para que outros usuários possam compreendê-los. A sintaxe de
uma função consiste em ter um tipo, nome e passagem de parâmetros como
abaixo:
void soma (int n1, int n2);
Acima acabamos de declarar e inicializar uma função chamada soma, ela é do
tipo void(não retorna nada ao seu final) e recebe como parâmetros duas
variáveis n1 e n2. Todas as funções antes de ser implementadas em nossos
programas deverão ser inicializadas antes do código fonte principal (main) e
escritas ao final do código fonte principal (main) como a sintaxe abaixo
#include <stdio.h>
#include <stdlib.h>
void soma(int n1, int n2);
int main(int argc, char *argv[])
int n1,n2;
scanf("%d %d",&n1,&n2);
soma(n1,n2);
system("PAUSE");
return 0;
void soma(int n1, int n2)
printf("Resultado = %d\n",n1+n2);
Interpretando nosso programa, inicialmente são incluídas as bibliotecas stdio.h e stdlib.h em seguida a função void soma é inicializada tendo como parâmetros n1 e n2, após isso a função main é chamada no scanf é recebido os dois números que serão somados, os numeros são passados para a função soma(n1,n2) neste momento ele para a main executa a função fora da main e depois retorna ao programa principal encerrando-o.
96
Perceba que na função soma ela não tem a diretiva “return”, pois ela é uma função void (vazia) ela não retorna nada para a função principal (main) logo seu uso neste tipo de caso é desnecessário. Vejamos alguns exemplos com a utilização de funções:
1) Faça um programa que simule uma calculadora onde o usuário poderá escolher uma das opções: 1 – soma, 2 – subtração, 3 – multiplicação, 4 – divisão.
#include <stdio.h>
#include <stdlib.h>
float soma(float n1, float n2);
float subtracao(float n1, float n2);
float multiplicacao(float n1, float n2);
float divisao(float n1, float n2);
int main(int argc, char *argv[])
int opcao;
float n1,n2,resultado;
printf("Entre com n1 e n2\n");
scanf("%f %f",&n1,&n2);
printf("Qual operacao deseja realizar?\n");
printf("1 - Soma\n2 - Subtracao\n3 - Multiplicacao\n4 - Divisao\n");
scanf("%d",&opcao);
if (opcao==1)
resultado=soma(n1,n2);
else if (opcao==2)
resultado=subtracao(n1,n2);
else if (opcao==3)
resultado=multiplicacao(n1,n2);
else if (opcao==4 && n2!=0)
resultado=divisao(n1,n2);
else
printf("Operacao invalida\n");
system("PAUSE");
return 0;
97
printf("O Resultado e %.2f\n",resultado);
system("PAUSE");
return 0;
float soma(float n1, float n2)
return n1+n2;
float subtracao(float n1, float n2)
return n1-n2;
float multiplicacao(float n1, float n2)
return n1*n2;
float divisao(float n1, float n2)
return n1/n2;
No exemplo são inicializadas quatro funções (soma, subtração, multiplicação,
divisão) todas são do tipo float (retornam um dado float) e recebem como
passagem de parâmetros n1 e n2 que também são float. Na função main é
recebido os valores de n1 e de n2 uma variável inteira opcao é declarada para
decidir qual operação será executada pelo usuário através das analises
condicionais que vem logo em seguida. Dentro de cada condicional é chamada
uma função de acordo com o valor que esta em opcao ou seja se opcao é igual
a 1 é efetuada a soma de n1 com n2 e exibido seu resultado, se é igual a 2 é
efetuada a subtração de n1 com n2 e exibido seu resultado, se é igual a 3 é
efetuada a multiplicação de n1 com n2 e exibido seu resultado e se for igual a 4
e n2 diferente de zero(não existe divisão por zero) é efetuada a divisão de n1
com n2 e exibido seu resultado. Ao final da main é escrita as funções que
foram inicializadas para execução das expressões. As funções podem ser
escritas de diversas maneiras diferentes contanto que o seu tipo e sua
passagem de parâmetro esteja de acordo com os tipos de dados estudados no
capítulo 2.2 e os tipos existentes no compilador em uso(No caso o Dev C++).
98
2) Faça um programa que receba um número inteiro e verifique se ele é primo,
par e divisível por 5.
#include <stdio.h>
#include <stdlib.h>
void verificaprimo(int n1);
void verificapar(int n1);
void divisivelpor5(int n1);
int main(int argc, char *argv[])
int n1;
printf("Entre com n1 \n");
scanf("%d",&n1);
verificaprimo(n1);
verificapar(n1);
divisivelpor5(n1);
system("PAUSE");
return 0;
void verificaprimo(int n1)
int i,cont=0;
for (i=1; i<n1; i++)
if (n1%i==0)
cont+=1;
if (cont>1)
printf("Nao e primo\n");
else
printf("E primo\n");
void verificapar(int n1)
if (n1%2==0)
printf("Par\n");
else
99
printf("Impar\n");
void divisivelpor5(int n1)
if (n1%5==0)
printf("Divisivel por 5\n");
else
printf("Nao divisivel por 5\n");
3) Criar uma função que receba um caractere como parâmetro e retorne 1 (um) caso seja uma vogal e zero caso não seja.
#include<stdio.h>
#include<stdlib.h>
int verificavogal (char M);
int main(int argc, char *argv[])
char x;
printf("Digite uma letra: ");
scanf("%c",&x);
if(verificavogal(x)==1)
printf("\nA letra [ %c ] eh uma vogal: ",x);
else
printf("\nA letra [ %c ] eh uma constante: ",x);
printf("\n\n");
system("pause");
return 0;
int verificavogal (char M)
if(M=='a' || M=='A' || M=='e' || M=='E' || M=='i' || M=='I' || M=='o' || M=='O' || M=='u' || M=='U')
return(1);
else
return(0);
100
9.1. Exercícios
1) Faça um programa que calcule a tensão, corrente elétrica ou resistência de acordo com os dados fornecidos pelo usuário. Crie as seguintes funções abaixo:
float tensao(void);
float corrente(void);
float resistencia(void);
O usuário deverá escolher qual calcular e fornecer os dados.
Obs.: V = R x I.
2) Faça um programa que receba as saídas de uma tabela verdade de duas
entradas (A e B), e verifique se é uma porta lógica AND, OR, XOR , NXOR,
Inexistente. Crie as seguintes funções abaixo:
void verificaporta(int A, int B);
3) Faça um programa que receba dois números (N1 e N2) onde N1
obrigatoriamente deverá ser maior ou igual à N2. Seu programa deverá efetuar
a divisão de N1 por N2 e retornar o Quociente e o Resto da divisão (sem
utilizar os operadores “/” e “%”) crie também uma função para verificar os
critérios validos para uma divisão (N1 tem que ser maior que N2 e N2 não
pode ser igual à ZERO) se a divisão for válida seu programa deve retornar 1 e
proceder, caso seja inválida ele deve retornar 0 e encerrar. Abaixo os modelos
de funções:
int verificadivisao(int N1, int N2);
int quociente(int N1, int N2);
int resto(int N1, int N2);
4) Faça um programa que receba dois números (N1 e N2) e execute a
exponenciação de N1 por N2, ou seja N1 elevado à N2, por último exiba o
resultado. Faça de acordo com a função abaixo:
int exponencial(int N1, int N2);
5) Refaça o exercício 4 agora com o seguinte modelo de função:
void exponencial(int N1, int N2);
6) Refaça o exercício 4 agora com o seguinte modelo de função:
Void exponencial(void);
101
Capítulo 10 – Arduino
O que é Arduino?
O Arduino é uma plataforma de computação física ou embarcada, capaz de ser
programado e reprogramado várias vezes para diversos tipos de aplicações
sejam elas voltadas à: Automação, Eletrônica, Computação dentre outras.
Físicamente a placa de controle conhecida como Arduino UNO é composta de
diversos componentes eletrônicos, sendo eles: Resistores, Capacitores, Led’s,
Crystal e o mais importante que é o seu Microcontrolador modelo
ATMEGA328P-PU da Atmel.
Seu microcontrolador, é programável por um software chamado Arduino.
O Arduino UNO é composto por 27 pinos com diversas funções tais como:
Entradas Digitais, Entradas Analógicas, Saídas Digitais, Saídas PWM, Reset,
Saídas de Tensão: 3.3V e 5V, Terra e AREF.
Os temas que serão estudados no andamento do curso serão:
- Entadas Digitais
- Entradas Analógicas – Resolução de 10 bits
- Saídas Digitais
- Saídas Analógicas (PWM) – Resolução de 8 bits
A resolução de entrada analógica é de 10 bits(variando de 0 a 1023 em
decimal) e a de saída analógica(PWM) é de 8 bits(variando de 0 a 255 em
decimal).
Alguns pinos do Arduino podem exercer funções diferentes baseando-se em
sua programação, ou seja, pela programação do Arduino definimos a forma de
funcionamento de seus pinos configurando-os como entradas ou saídas.
102
10.1. Configurando o Arduino para Programação.
Como foi dito acima, para que o arduino seja programado ele necessita de um
software específico chamado Arduino que pode ser utilizado gratuitamente, o
endereço para download é: http://arduino.cc/en/Main/Software
O software se encarregará de fazer upload de seus programas diretamente do
PC para o Arduino.
Para o correto funcionamento do Arduino é necessário que você conecte-o com
seu pc e instale os drivers para reconhecimento do novo hardware. Este
procedimento é bem simples, logo após conectado à porta USB, o PC irá
detectar um novo hardware e pedir a instalação de seu driver, o Arduino não
vem com o driver de comunicação auto-instalável(firmware) como em PEN
DRIVES, CARTÕES DE MEMÓRIAS e etc.
É necessário que você vá ao gerenciador de dispositivos e selecione o Arduino,
clique em atualizar driver localize o driver dentro da pasta DRIVERS e pronto
agora seu arduino já está se comunicando com o seu PC.
Veja o Passo-a-passo à seguir:
Abra o Gerenciador de dispositivos e em Outros dispositivos clique com o
botão direito no Dispositivo Arduino Uno depois clique em Atualizar Driver.
103
Agora na nova janela clique em Procurar Software de driver no Computador
Agora clique em Procurar, selecione o diretório da pasta arduino, marque a
caixa de opção incluir subpastas e depois clique em avançar.
104
Logo após clicar em avançar o gerenciador de dispositivos irá instalar e
configurar o driver de comunicação e agora irá aparecer no gerenciador de
dispositivos na parte Portas COM e LPT a porta de comunicação COM6 que
será a porta de comunicação do seu Arduino.
Pronto, toda configuração de instalação e programação do seu arduino está
preparada agora, basta começar a programar e testar suas experiências.
10.2. Características do Arduino UNO.
O Arduino UNO é composto por 27 Pinos dentre eles podem ser configurados
como entradas ou saidas digitais os pinos 0 até o 13. Os pinos GND ou Ground
são o negativo. O Arduino UNO possui 6 entradas analógicas que são de A0
até A5 e 6 saídas PWM que são os pinos: 3,5,6,9,10,11 que quando
configurados como saidas PWM são capazes de enviar um sinal de tensão de
0V a 5V. Também possui 2 pinos para transmissão e recepção de dados que
s/ao os pinos 0(Rx) e 1(Tx).
105
10.3. Funções Setup e Loop e principais
Comandos.
As funções: void setup() e void loop() são as principais funções de seu
programa, sem elas você não conseguirá fazer os seus programas.
void setup, é uma função de parametrização onde você pode definir quais
pinos serão entradas, quais serão saidas, velocidade de comunicação serial e
etc. Nela utilizaremos o comando “pinMode” que irá definir o comportamento
dos pinos utilizados(entradas ou saídas). Sua sintaxe é:
pinMode (n° do pino, E/S);
No primeiro parâmetro você insere o numero do pino, no segundo parâmetro
você configura ele como ENTRADA (INPUT) ou SAIDA (OUTPUT).
Existem outros comandos mas o que será abordado no curso será apenas o
pinMode.
void loop, é uma função de repetição para que seu programa rode
constantemente, ela fica simplesmente se repetindo e comporta-se como se
fosse um while(true).
Na void loop os comandos utilizados serão digitalWrite, digitalRead,
analogWrite e analogRead que são para realizar, leitura/escrita digital e
analógica abaixo suas sintaxes:
digitalWrite(n° do pino,HIGH/LOW);
- Escrita Digital: High representa nível lógico alto e LOW nível lógico baixo
também podendo ser substituídos por 1 ou 0.
digitalRead(n° do pino);
- Leitura Digital: Realiza a leitura do estado(HIGH/LOW) de um determinado
pino.
analogWrite(nº do pino, 0~255);
- Escrita Analógica: feita através de um sinal PWM, você pode utilizar um pino
com saída PWM e o seu valor de tensão varia entre 0V ~5V representado por
uma escala decimal e proporcional de 0 a 255 onde 0 equivale a 0V e 255
equivale a 5V.
106
analogRead(pino analógico);
- Leitura Analógica: Efetua a leitura do valor de tensão em um pino de entrada
analógica em uma escala decimal e proporcional de 0 a 1023 onde 0 equivale a
0V e 1023 equivale à 5V.
10.4. Exemplos
1) Faça um programa e a montagem física do circuito que faça um LED piscar
de 1 em 1 segundo.
Componentes:
- 1 Resistor de 680Ω
- 1 Led
107
No programa foi utilizado o pino 0 como uma saída digital que assume dois
valores, ligado ou desligado, agora vamos para a ligação física.
*O comando delay, gera um atraso de tempo em milissegundos.
Para que se tenha uma maior facilidade para manusear o tempo do seu
programa também poderia ser usado a diretiva “#define” assim ao invés de ter
que alterar os dois delay, você altera apenas o define, veja abaixo:
108
2) Faça um programa e a montagem física do circuito que faça um LED
acender ou apagar através de um botão.
Componentes:
- 1 Resistor de 680Ω
- 1 Resistor de 10kΩ
- 1 Resistor de 1kΩ
- 1 Push-Button (2 Contatos)
- 1 Led
109
Para perfeito funcionamento é necessário montar um circuito de Pull-Down
para que a leitura digital funcione corretamente, segue abaixo uma figura de
como montar um circuito Pull-Down e Pull-Up.
110
No lugar do resistor de 100Ω foi utilizado um resistor de 680Ω isso não altera o
funcionamento do circuito.
3) Faça um programa e a montagem física que faça acender três leds
sequenciais através da variação de uma entrada analógica, A variação deverá
ser proporcional à entrada de tensão 5V e de forma igualitária.
Componentes:
- 3 Resistores de 680Ω
- 3 Led’s
- 1 Potenciometro B5KΩ
111
A medida que o potenciômetro vai variando a sua resistência os led’s vão
acendendo em sequencia, isto é feito de acordo com a leitura da entrada
analógica A0. Lembrando que as saídas analógicas no arduino UNO já vêm
configuradas não sendo necessário você definir na função setup o pino A0
como INPUT.
112
4) Faça um programa e a montagem física que faça variar o brilho de dois led’s
de forma contrária(enquanto um está acendendo o outro deverá estar
apagando) de sua luminosidade mínima(apagado) até sua luminosidade
máxima(totalmente aceso) utilize duas saídas PWM.
Componentes:
- 2 Resistores 680Ω
- 2 Led’s
113
Os pinos utilizados foram os pinos 3 e 5 que são dois dos 6 pinos disponíveis
com saída PWM. Os outros pinos com saída PWM são os pinos: 6, 9, 10 e 11.
Através de um comando “for” você consegue variar a luminosidade dos led’s é
necessário também que se use um atraso (delay) pois o tempo de
scan/varredura do arduino é muito rápido, caso você não utilize o delay pode
ser que ele nem chegue a variar a luminosidade do inicio ao fim.
5) Faça um programa e a montagem física que faça variar o brilho de dois led’s
através de um potenciômetro de forma inversa ou seja, se o potenciômetro
estiver no máximo o brilho do primeiro led deverá estar no máximo e do
segundo no mínimo(apagado), se ele estiver no mínimo o brilho primeiro led
deverá estar no mínimo(apagado) e do segundo no máximo.
Componentes:
- 2 Resistores 680Ω
- 2 Led’s
- 1 Potenciometro B5KΩ
114
115
Neste exemplo as saídas PWM estão em função da entrada analógica, porém a resolução da entrada analógica é de 10 bits ou seja ela varia de 0 a 1023 e das saídas PWM são de 8 bits variando de 0 a 255, é necessário que se utilize uma variável auxiliar(brilho) e que ela divida a resolução da entrada(0 a 1023) por 4 assim essa variável auxiliar irá possuir valores no máximo de 0 à 255 e assim podendo escrever proporcionalmente nas saídas PWM sem ultrapassar a faixa de valores. Note que a variável brilho é do tipo int, sendo assim 1023 dividido por 4 resultaria em 255,75 pelo fato de brilho ser int neste tipo de caso ele irá escrever na saída 255.
10.5. Exercícios
1) Faça um programa para piscar um LED em um intervalo de 2 segundos.
2) Faça um programa que oscilem o piscar de 2 led's entre si, durante o intervalo de 1 segundo.
3) Faça um programa que através de um unico botão acione 3 leds de forma sequencial.
4) Faça um programa que através de duas entradas simule uma porta lógica E.
5) Faça um programa que através de duas entradas simule uma porta lógica OU.
6) Faça uma barra de led’s com 6 led’s para simular um medidor de nível de um tanque, utilize um potenciômetro para simular o aumentar e diminuir do nível.
7) Faça um programa que simule um interruptor three-way.
8) Faça um programa emule um semáforo com 3 led's (Verde, Amarelo, Vermelho)
O tempo de oscilação deverá ser:
- Vermelho 6s
- Amarelo 2s
- Verde 4s
9) Faça um programa que com 2 botões seja capaz de você aumentar ou diminuir o brilho de um LED.
10) Faça um programa que com 2 botões seja capaz de você aumentar ou diminuir o brilho de dois LED's de forma inversa(Enquanto um led aumenta o outro irá ter que diminuir o seu brilho).
11) Faça um programa que simule a função SET e RESET utilizando 2 botões e um LED, 1 botão será para SET(Ligar o Led) o outro para RESET(Desligar o Led).
116
Referências Bibliográficas:
- www.google.com.br
- C completo e total 3ª edição – Herbert Schildt
- Microcontroladores PIC - Programação em C – Fábio Pereira
- www.arduino.cc