apostila arduino jhsfurno

116
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

Upload: igor-serafim

Post on 08-Feb-2016

262 views

Category:

Documents


2 download

TRANSCRIPT

Page 1: 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

Page 2: Apostila Arduino Jhsfurno

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

Page 3: Apostila Arduino Jhsfurno

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

Page 4: Apostila Arduino Jhsfurno

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.

Page 5: Apostila Arduino Jhsfurno

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

Page 6: Apostila Arduino Jhsfurno

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.

Page 7: Apostila Arduino Jhsfurno

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..

Page 8: Apostila Arduino Jhsfurno

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

Page 9: Apostila Arduino Jhsfurno

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

Page 10: Apostila Arduino Jhsfurno

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

Page 11: Apostila Arduino Jhsfurno

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.

Page 12: Apostila Arduino Jhsfurno

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.

Page 13: Apostila Arduino Jhsfurno

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.

Page 14: Apostila Arduino Jhsfurno

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

Page 15: Apostila Arduino Jhsfurno

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.

Page 16: Apostila Arduino Jhsfurno

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.

Page 17: Apostila Arduino Jhsfurno

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.

Page 18: Apostila Arduino Jhsfurno

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.

Page 19: Apostila Arduino Jhsfurno

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.

Page 20: Apostila Arduino Jhsfurno

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

Page 21: Apostila Arduino Jhsfurno

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.

Page 22: Apostila Arduino Jhsfurno

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.

Page 23: Apostila Arduino Jhsfurno

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

Page 24: Apostila Arduino Jhsfurno

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.

Page 25: Apostila Arduino Jhsfurno

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.

Page 26: Apostila Arduino Jhsfurno

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.

Page 27: Apostila Arduino Jhsfurno

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.

Page 28: Apostila Arduino Jhsfurno

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.

Page 29: Apostila Arduino Jhsfurno

29

Page 30: Apostila Arduino Jhsfurno

30

Passo 09 - Na caixa Dica do Dia clique em Fechar

Passo 10 - Clique em Arquivo -> Novo -> Projeto

Page 31: Apostila Arduino Jhsfurno

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!

Page 32: Apostila Arduino Jhsfurno

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.

Page 33: Apostila Arduino Jhsfurno

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!

Page 34: Apostila Arduino Jhsfurno

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;

Page 35: Apostila Arduino Jhsfurno

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:

Page 36: Apostila Arduino Jhsfurno

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;

Page 37: Apostila Arduino Jhsfurno

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.

Page 38: Apostila Arduino Jhsfurno

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

Page 39: Apostila Arduino Jhsfurno

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

Page 40: Apostila Arduino Jhsfurno

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

Page 41: Apostila Arduino Jhsfurno

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).

Page 42: Apostila Arduino Jhsfurno

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.

Page 43: Apostila Arduino Jhsfurno

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.

Page 44: Apostila Arduino Jhsfurno

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.

Page 45: Apostila Arduino Jhsfurno

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;

Page 46: Apostila Arduino Jhsfurno

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>

Page 47: Apostila Arduino Jhsfurno

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[])

Page 48: Apostila Arduino Jhsfurno

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;

Page 49: Apostila Arduino Jhsfurno

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;

Page 50: Apostila Arduino Jhsfurno

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.

Page 51: Apostila Arduino Jhsfurno

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;

Page 52: Apostila Arduino Jhsfurno

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.

Page 53: Apostila Arduino Jhsfurno

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.

Page 54: Apostila Arduino Jhsfurno

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).

Page 55: Apostila Arduino Jhsfurno

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);

Page 56: Apostila Arduino Jhsfurno

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;

Page 57: Apostila Arduino Jhsfurno

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;

Page 58: Apostila Arduino Jhsfurno

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;

Page 59: Apostila Arduino Jhsfurno

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:

Page 60: Apostila Arduino Jhsfurno

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;

Page 61: Apostila Arduino Jhsfurno

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;

Page 62: Apostila Arduino Jhsfurno

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");

Page 63: Apostila Arduino Jhsfurno

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;

Page 64: Apostila Arduino Jhsfurno

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");

Page 65: Apostila Arduino Jhsfurno

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;

Page 66: Apostila Arduino Jhsfurno

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:

Page 67: Apostila Arduino Jhsfurno

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.

Page 68: Apostila Arduino Jhsfurno

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:

Page 69: Apostila Arduino Jhsfurno

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;

Page 70: Apostila Arduino Jhsfurno

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.

Page 71: Apostila Arduino Jhsfurno

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;

Page 72: Apostila Arduino Jhsfurno

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;

Page 73: Apostila Arduino Jhsfurno

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;

Page 74: Apostila Arduino Jhsfurno

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;

Page 75: Apostila Arduino Jhsfurno

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);

Page 76: Apostila Arduino Jhsfurno

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;

Page 77: Apostila Arduino Jhsfurno

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;

Page 78: Apostila Arduino Jhsfurno

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.

Page 79: Apostila Arduino Jhsfurno

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;

Page 80: Apostila Arduino Jhsfurno

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;

Page 81: Apostila Arduino Jhsfurno

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");

Page 82: Apostila Arduino Jhsfurno

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;

Page 83: Apostila Arduino Jhsfurno

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.

Page 84: Apostila Arduino Jhsfurno

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.

Page 85: Apostila Arduino Jhsfurno

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;

Page 86: Apostila Arduino Jhsfurno

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");

Page 87: Apostila Arduino Jhsfurno

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.

Page 88: Apostila Arduino Jhsfurno

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.

Page 89: Apostila Arduino Jhsfurno

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'.

Page 90: Apostila Arduino Jhsfurno

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"&nota[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;

Page 91: Apostila Arduino Jhsfurno

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;

Page 92: Apostila Arduino Jhsfurno

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];

Page 93: Apostila Arduino Jhsfurno

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.

Page 94: Apostila Arduino Jhsfurno

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.

Page 95: Apostila Arduino Jhsfurno

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.

Page 96: Apostila Arduino Jhsfurno

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;

Page 97: Apostila Arduino Jhsfurno

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++).

Page 98: Apostila Arduino Jhsfurno

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

Page 99: Apostila Arduino Jhsfurno

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);

Page 100: Apostila Arduino Jhsfurno

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);

Page 101: Apostila Arduino Jhsfurno

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.

Page 102: Apostila Arduino Jhsfurno

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.

Page 103: Apostila Arduino Jhsfurno

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.

Page 104: Apostila Arduino Jhsfurno

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).

Page 105: Apostila Arduino Jhsfurno

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.

Page 106: Apostila Arduino Jhsfurno

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

Page 107: Apostila Arduino Jhsfurno

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:

Page 108: Apostila Arduino Jhsfurno

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

Page 109: Apostila Arduino Jhsfurno

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.

Page 110: Apostila Arduino Jhsfurno

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Ω

Page 111: Apostila Arduino Jhsfurno

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.

Page 112: Apostila Arduino Jhsfurno

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

Page 113: Apostila Arduino Jhsfurno

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Ω

Page 114: Apostila Arduino Jhsfurno

114

Page 115: Apostila Arduino Jhsfurno

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).

Page 116: Apostila Arduino Jhsfurno

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