CPES

INICIAÇÃO À PROGRAMAÇÃO ARDUINO

Objectif :
- Descobrir o universo ARDUINO
- Ter as principais informações técnicas sobre o cartão ARDUINO UNO DUREE : 3h
- Saber como realizar um programa ARDUINO

1. PRESENTATION ARDUINO ........................................................................................................................... 2

2. LA CARTE ARDUINO UNO ............................................................................................................................ 3
2.1. Os diferentes elementos .................................................................................................................. 3
2.2. As principais características ...................................................................................................... 3
2.3. A alimentação................................................................................................................................ 4
2.4. As entradas-saídas ......................................................................................................................... 4
2,5. As memórias................................................................................................................................. 5
2.6. O relógio........................................................................................................................................ 5
2.7. La communication.......................................................................................................................... 5
2.8. O reset.......................................................................................................................................... 5
2.9. A proteção contra sobrecarga USB................................................................................................... 5
3. A PROGRAMAÇÃO DO CARTÃO ARDUINO ........................................................................................... 6
3.1. A interface de programação........................................................................................................ 6
3.2. A estrutura de um programa......................................................................................................... 7
3.3. A sintaxe da linguagem ARDUINO..................................................................................................... 8
3.4. Os comentários .......................................................................................................................... 8
3.5. Os dados, variáveis e constantes .................................................................................. 8
3.6. Os operadores ............................................................................................................................... 9
3.7. As bibliotecas de funções ..................................................................................................... 10
3.8. As etapas de desenvolvimento de um programa............................................................................ 17
4. OS EXERCÍCIOS……………………………………………………………………………………………………………………………………………..18

4.1. EXERCÍCIO N°1: FAZER UMA LED PISCAR.................................................................................... 18

4.2. EXERCÍCIO N°2 : ACENDER UM LED COM UM BOTÃO PRESSOR
4.3. EXERCICE N°3 : PILOTER UN MOTEUR DANS UN SENS DE ROTATION.............................................. 20
4.4. EXERCÍCIO N°4: CONTROLAR UM MOTOR NAS 2 DIREÇÕES DE ROTAÇÃO POR 1 PONTE EM H ............... 21
4.5. EXERCÍCIO N°5GESTÃO DE UMA ENTRADA ANALÓGICAE .................................................................. 21
5. PLACA DE PROTOTIPAGEM AIDE………………………………………………………………………………………………………………………………….….22

P á g e 1 | 22
 CPES

ARDUINO

1. Présentation ARDUINO
ARDUINO é uma plataforma de hardware e software para o desenvolvimento de aplicações embarcadas.

Do lado do hardware, ela é composta por uma placa eletrônica baseada em um microcontrolador (ATMEL AVR)
comportando um certo número de entradas e saídas (as portas) permitindo a conexão de sensores, ou
de atuadores.

O software de programação dos módulos ARDUINO é um aplicativo Java, livre e multiplataforma, servindo
d'editor de código e de compilador, e que pode transferir o programa através da ligação USB. A linguagem de
a programação utilizada é uma mistura de C e C++, restrita e adaptada às possibilidades do cartão.

Les principaux avantages du système ARDUINO sont :

➢ Material de baixo custo: As placas ARDUINO são relativamente baratas em comparação com as outras
plataformas de desenvolvimento. A versão mais barata do módulo ARDUINO pode ser montada na
principal, e até mesmo os cartões ARDUINO pré-montados custam menos de 25 €.

➢ Material: Os esquemas dos módulos são publicados sob uma licença Creative Commons, e é possível de
realizar nossas próprias versões das placas ARDUINO, completando e melhorando-as.

➢ Software gratuito: O software ARDUINO e a linguagem ARDUINO estão disponíveis para serem complementados por
programadores experientes. A linguagem também pode ser estendida com a ajuda de bibliotecas C++.

➢ Software multi-plataforma: O software ARDUINO, escrito em Java, funciona sob os sistemas operacionais
Windows, Macintosh e Linux.

➢ Módulos « Shield »: Cartões adicionais conectando-se ao módulo ARDUINO para aumentar os

possibilidades: display gráfico colorido, interface Ethernet, GPS, etc.…

P á g i n a 2 | 22
 CPES

ARDUINO

2. A placa ARDUINO UNO

O modelo UNO da sociedade ARDUINO é uma placa eletrônica cujo coração é um microcontrolador ATMEL de
referência ATMega328. O microcontrolador ATMega328 é um microcontrolador de 8 bits da família AVR cuja
a programação pode ser realizada em linguagem C.

Os diferentes elementos

As principais características
Microcontrolador ATMEGA 328
Tensão de alimentação interna 5V
Tensão de alimentação (recomendada) 7 a 12V
Tension d'alimentation (limites) 6 a 20 V
Entradas/Saídas digitais 14 dos quais 6 saídas PWM (configuráveis)
Entradas analógicas 6
Corrente máxima por pinos E/S 40 mA (200 mA acumulado para todos os pinos)
Memória do programa Flash 32 Ko dos quais 0,5 Ko são usados pelo bootloader
Memória SRAM (memória volátil) 2 KB
Memória EEPROM (memória não volátil) 1 KB
Fréquence horloge 16 MHz
Dimensões 68,6mm x 53,3mm
P á g i n a 3 | 22
 CPES

ARDUINO

A alimentação
A placa ARDUINO UNO pode ser alimentada pelo cabo USB, por um bloco de energia externo conectado através de uma
conector "jack" de 2,1mm ou por um bloco de pilhas cujo ligação é feita através dos "GND"
et « Vin » do conector de alimentação. A alimentação externa deve apresentar uma tensão entre 7 a 12V.

O cartão gera, por meio de reguladores integrados, duas tensões estabilizadas: 5 V e 3,3 V. Essas duas
tensões permitem a alimentação dos componentes eletrônicos da placa ARDUINO. Estando disponíveis em
conectores colocados ao redor das placas, também permitem a alimentação dos módulos Shields.

As entradas e saídas
A placa "ARDUINO UNO" possui 14 E/S digitais e 6 entradas analógicas.

2.4.1. As entradas e saídas digitais

Cada um dos 14 pinos digitais (identificados de 0 a 13) pode ser utilizado como entrada (input) ou saída (output)
sob o controle do programa. O sentido de funcionamento pode até mudar de maneira dinâmica durante
sua execução.

Elas funcionam em lógica TTL (0V-5V); cada uma podendo fornecer (fonte) ou receber uma corrente máxima de
40 mA e dispõe, se necessário, de uma resistência interna de 'pull-up'.

Certas brochas podem ter várias funções diferentes escolhidas por programação descritas abaixo:

N° E/S N° linha de port Função

0 PD0 Rx: Entrada de ligação em série síncrona
1 PD1 Saída de ligação série síncrona
2 PD2 INT0: Entrada de interrupção externa
INT1: Entrada de interrupção externa
3 PD3
OC2B: Modulação PWM à largura de pulsos
T0: Entrée Timer/compteur 0
4 PD4
XCK: Entrada do relógio
T1: Entrée Timer/compteur 1
5 PD5
OC0B: Saída do módulo de modulação PWM com largura de pulso
OC0A: Saída do módulo de modulação PWM com largura de pulso
6 PD6
AIN0: Entrée comparateur analogique
7 PD7 AIN1: Entrée comparateur analogique
CLKO: Saída do relógio de funcionamento
8 PB0
ICP1: Entrée de capture Timer/compteur 1
9 PB1 OC1A: Saída de módulo de modulação PWM a largura de pulso
SS: Selecionar ligação esclava SPI
10 PB2
OC1B: Saída do módulo PWM modulação por largura de pulso
MOSI: Saída de ligação SPI
11 PB3
OC2A: Módulo de saída modulação PWM por largura de pulso
12 PB4 MISO: Entrada de ligação SPI
13 PB5 SCK: Relógio de ligação SPI
P á g e 4 | 22
 CPES

ARDUINO

2.4.2. As entradas analógicas

Les six entrées analogiques, repéréesA0 à A5 (PC0 à PC5), peuvent admettre toute unetension analogique
abrangem entre 0 e 5V (por padrão, mas isso pode ser modificado). Essas entradas analógicas são geridas por um
conversor analógico/digital de 10 bits, cuja saída pode variar de 0 a 1023.

As entradas A4 e A5 podem também ser usadas, respectivamente, como a linha de dados SDA e a linha
d'horloge SCL da interface série I2C.

As memórias
O microcontrolador ATmega 328 possui 32 ko de memória Flash permitindo armazenar o programa a
executar.

Ele também contém 2ko de memória RAM (SRAM). Essa memória é geralmente usada para armazenar os
resultados temporários durante cálculos. Pode ser lido e escrito a qualquer momento pelo microcontrolador, mas seu conteúdo
está perdido assim que a não é mais alimentada.

L’ATmega 328 dispose également1ko mémoire EEPROMpour permettre au programme de stocker des données
persistentes. O conteúdo desta memória é acessível por meio das funções da biblioteca "EEPROM".

O relógio
O relógio é controlado por quartzo e funciona na frequência de 16 MHz.

A comunicação
O cartão "ARDUINO UNO" tem muitas possibilidades de comunicação com o exterior. O Atmega328
possui uma interface de comunicação serial acessível, graças aos pinos digitais 0 (Rx) e 1 (Tx).
Por outro lado, ela suporta o barramento I2C acessível, graças aos pinos analógicos 4 (SDA) e 5 (SCL) e à conexão serial.
SPI síncrono graças às broches digitais 10 (SS), 11 (MOSI), 12 (MISO) e 13 (SCX).

O reset
Na energização, um reset automático permite que o programa contido na memória do microcontrolador de
iniciar automaticamente assim que o cartão ARDUINO estiver alimentado.

O cartão "Arduino UNO" também está equipado com um botão de reset manual. Um pressionar deste botão
permite reiniciar a execução de um programa se necessário, seja porque ele "travou" ou simplesmente
porque se deseja que ele recomece do seu início.

La protection de surintensité USB

Por medida de segurança para o computador ao qual o ARDUINO será conectado, um fusível está presente na conexão.
d'alimentation 5 V da tomada USB. Todo consumo superior a 500mA provoca o acionamento disso
fusível, protegendo assim a porta USB do computador ao qual o cartão está conectado.
P a g e 5 | 22
 CPES

ARDUINO

3. A programação do cartão ARDUINO

O software ARDUINO para funções principais:

➢ De poder escrever e compilar programas para o cartão ARDUINO

➢ De se conectar com o cartão ARDUINO para transferir os programas
➢ De comunicar com o cartão ARDUINO

A interface de programação
A interface de programação do software ARDUINO é a seguinte :

A "Barra de Botões" que dá acesso direto às funções essenciais do software. Os diferentes botões
são :

P á g i n a 6 | 22
 CPES

ARDUINO

A estrutura de um programa
Un programme destiné à une carte ARDUINO est constitué de3 parties:

Zona de definição das constantes ou dos

variáveis ou inclusão de bibliotecas

/* Este programa faz piscar um LED conectado ao pino n°13 */

e faz também piscar o LED de teste da placa

intledPin = 13; // LED conectada ao pino nº 13

void setup()
{
pinMode(ledPin, OUTPUT); // Define the pin number 13 as an output
}

loop vazio()

{
digitalWrite(ledPin,ALTO) ; // Define a saída ledPin como NL1 (diodo aceso)
atraso(3000) ; // Aguardar 3 s
digitalWrite(ledPin,BAIXO) ; // Define a saída ledPin como NL0 (diodo apagado)
atraso(1000) ; // Esperar 1 s
}

Funçãosetup() Funçãoloop()
que contém as instruções de inicialização que contém as instruções do programa

A primeira parte permite definir as constantes e as variáveis ao declarar seu tipo. Ela também permite
a inclusão das bibliotecas utilizadas no programa por meio de #include.

A função setup() contém as instruções de inicialização ou configuração dos recursos do cartão como
por exemplo, a configuração de entrada ou saída dos pinos de E/S digitais, a definição da velocidade de
comunicação da interface série, etc.. Esta função é executada apenas uma vez logo após o lançamento do
programa.

A função loop() contém as instruções do programa propriamente dito. Esta função será repetida
indefinidamente enquanto o cartão ARDUINO permanecer energizado.

P á g i n a 7 | 22
 CPES

ARDUINO

La syntaxe du langage ARDUINO

A cinquenta elementos da sintaxe ARDUINO está visível aqui[Link]
assim como a partir do documento "[Link]" (na pasta "Referência" que você baixou com o ARDUINO),
também acessível no menu "Ajuda" do software.

Os comentários
Para colocar comentários em uma única linha ou no final da linha, deve-se usar a seguinte sintaxe:
// Esta linha é um comentário de UMA SÓ linha

Para colocar comentários em várias linhas:

/* Comentário, em VÁRIAS linhas que será ignorado pelo programa, mas
não por aquele que lê o código */

Os dados, variáveis e constantes

Os diferentes tipos utilizados com a programação ARDUINO são:

Nome Description
booleano Donnée logique (true ou false) sur 8 bits
byte Inteiro sem sinal de 8 bits
int Número inteiro assinado de 16 bits

inteiro não assinado Inteiro sem sinal de 16 bits

longo Inteiro assinado de 32 bits
número inteiro sem sinal longo
Número inteiro sem sinal de 32 bits

flutuar Nombre à virgule flottant sur 32 bits

caractere Caractere de 8 bits. Apenas os caracteres com código ASCII de valor 0 a 127 estão definidos.

Uma constante pode ser definida por meio de const ou de #define:

#define N 2 //Toda variável N encontrada no programa será substituída pelo valor 2

const byte N=2 // N é uma constante do tipo « byte » e de valor 2

Um certo número de nomes de constantes são pré-definidos na linguagem "ARDUINO":

Nome Description
verdadeiro Dado binário igual a 1 ou dado numérico diferente de 0
falso Dado binário ou numérico igual a 0
ALTO Génération d’un niveau de tension haut sur une des sorties numériques
BAIXO Geração de um nível de tensão baixo em uma das saídas digitais
ENTRADA Configuração de um pino digital como entrada
SAÍDA Configuração de um pino digital como saída

P á g e 8 | 22
 CPES

ARDUINO

Os operadores
3.6.1. Os operadores aritméticos
Símbolo Description Exemplo
+ Adição c=a+b;
- Subtração c=a-b;
* Multiplicação c=a*b;
/ Divisão c=a/b;
% Módulo (resto da divisão inteira) c=a%b;

3.6.1. Os operadores lógicos

Símbolo Descrição Exemplo
& ET c=a&b;
| OU c=a|b;
^ OU exclusivo c=a^b;
~ NÃO b = ~a ;
>> Deslocamento à direita dos bits c = a >> b ;//a deslocou b vezes para a direita
<< Deslocamento à esquerda dos bits c = a << b ;//a deslocou b vezes para a esquerda

3.6.2. As atribuições
Símbolo Description Exemplo
= Afeto ordinário a=b;
+= Adicionar de a=a+b;
-= Subtrair de a -= b ; → a = a - b ;
*= Multiplicar por a *= b ; → a = a * b ;
/= Dividir por a /= b ; → a = a / b ;
%= Resto da divisão inteira por a %= b ; → a = a % b ;
&= ET com a &= b ; →a = a & b ;
|= OU com a |= b ; → a = a | b ;
-- Soustraire de 1 (décrémentation) a -- ; →a = a - 1 ;
++ Adicionando 1 (incrementação) a ++ ; →a = a + 1 ;

3.6.3. Os operadores de comparação

Símbolo Description Exemplo
&& Lógica ET se (a && b)
|| OU lógica se (a || b)
== Igual a se (a == b)
!= Diferente de se (a != b)
> Superior a se (a > b)
< Inferior a se (a < b)
>= Superior ou igual a se (a >= b)
<= Inferior ou igual a se (a <= b)
P á g e 9 | 22
 CPES

ARDUINO

As bibliotecas de funções
Uma biblioteca é um conjunto de funções utilitárias disponibilizadas aos usuários do ambiente
Arduino. As funções estão agrupadas de acordo com sua pertença a um mesmo domínio conceitual
(matemática, gráfico, classificações, etc).

A IDE ARDUINO contém por padrão várias bibliotecas externas. Para importá-las para o seu programa,
você deve usar o menu a seguir:

A instrução seguinte será então adicionada ao início do seu programa: #include <la_bibliothèque.h>

Exemplo :

#include <SPI.h> // Importação da biblioteca SPI

Certas funções já estão presentes no IDE ARDUINO, as principais estão explicadas abaixo.

3.7.1. As funções de gestão do tempo

A função « atraso »
atraso(tempo) ;

Esta função gera uma pausa cuja duração é igual a tempo × 1 ms.

La variable tempo doit être de type unsigned long ce qui peut autoriser des temporisations qui peuvent être très
longas.

atraso(1000) ; // Pausa de 1 s

A função « delayMicroseconds »
atrasarMicrosegundos(tempo) ;

Esta função gera uma pausa cuja duração é igual a tempo × 1 μs.

A variável tempo deve ser do tipo unsigned int.

A duração da pausa é garantida apenas para valores superiores a 3 μs.

delayMicrosegundos(100) ; // Pausa de 100 µs

P á g e 10 | 22
 CPES

ARDUINO

A função «millis() »
Valeur = milissegundos() ;

Esta função retorna o número de milissegundos desde o início do programa pela placa ARDUINO.

O valor retornado é do tipo unsigned long

O número de milissegundos retorna a zero aproximadamente após 50 dias.

A função "micros()"
Valeur = micros() ;

Esta função retorna o número de microssegundos desde o início do programa pela placa ARDUINO.

O valor retornado é do tipo unsigned long

Esta função tem uma resolução de 4µs (com um relógio de 16MHz), portanto, o valor retornado é um
múltiplo de 4.

O número de milissegundos retorna a zero cerca de 70 minutos.

3.7.2. As funções de gerenciamento de E/S digitais

A função « pinMode »
pinMode(Número do broche, Sentido de funcionamento)

Esta função permite configurar o sentido de funcionamento, entrada ou saída, do pino selecionado.

modoPino(12,SAÍDA) ; A broca 12 está configurada como uma saída

A função « digitalWrite »
digitalWrite(Número broche, Nível lógico) ;

Esta função permite impor um nível lógico alto ou baixo na saída digital selecionada.

digitalWrite(12,ALTO) ; // A saída 12 está situada no nível lógico alto (NL1)

A função "digitalRead"
Valeur = leituraDigital(Número de broche)

Esta função permite ler o nível lógico na entrada numérica selecionada. Esta função não retorna
que duas valor HIGH ou LOW.

etat = leituraDigital(11) ; //A variável estado é igual ao nível lógico da entrada 11

P a g e 11 | 22
 CPES

ARDUINO

3.7.3. Les fonctions de gestion des sorties PWM

Os μC que equipam as placas Arduino são capazes de gerar sinais de Modulação por Largura de Pulso
(MLI) ou « Modulação por Largura de Pulso » (PWM).

Trata-se de sinais lógicos retangulares de frequência igual a 490 Hz e com ciclo de trabalho programável.

A função "analogWrite"
analogWrite(Número de saída, Relatório cíclico) ;

Esta função permite gerar, na saída selecionada, um sinal PWM com o ciclo de trabalho desejado. O
a variável « Rapport cyclique » deve ser do tipo int, ou seja, pode variar entre 0 e 255 para um
relatório cíclico, para o sinal gerado, compreendido entre 0 e 100%.

O sinal PWM é gerado a partir do momento da execução da função "analogWrite" e até que um
nova instrução « analogWrite » ou uma instrução « digitalRead » ou « digitalWrite » seja executada na mesma
broche.

O valor da relação cíclica é garantido apenas para valores superiores a 10%.

analogWrite(2,64) ; // Sinal PWM de ciclo de trabalho de 25 % na saída analógica 2

3.7.4. As funções de gestão das entradas analógicas

As entradas analógicas estão conectadas a um conversor analógico digital (CAD) de 10 bits. A saída do CAD
gera um dado igual a 0 quando a tensão de entrada é nula e um dado igual a 1023 quando a tensão
a entrada é igual à tensão de referência do ADC.

A função « analogReference »
analogReference(Type) ;

Esta função permite definir a tensão de referência do ADC.

A variável type pode assumir os seguintes valores:

➢ DEFAUT: A tensão de referência é igual à tensão de alimentação da placa Arduino (5V para a placa
Arduino Uno
➢ A tensão de referência é igual a 1,1 V para a placa Arduino Uno;
➢ A tensão de referência é igual à tensão aplicada na entrada externa AREF da placa
Arduino.

A tensão aplicada a uma entrada analógica nunca deve ser superior à tensão de alimentação
do menu.

P á g i n a 12 | 22
 CPES

ARDUINO

A função "analogRead"
Valeur = leituraAnalógica(Número de entrada) ;

Esta função permite ler o resultado da conversão analógica digital da tensão presente em
l’entrée analogique sélectionnée.
Os dados retornados, que variam entre 0 e 1023, devem ser do tipo int.

A duração da conversão é de aproximadamente 100 μs.

tension = analogRead(1) ; // tensão é igual ao resultado da CAN da entrada analógica 1

3.7.5. As funções particulares de gestão das entradas e saídas

A função «tone»
tom(Número de saída, Frequência, Duração)

Esta função permite gerar, na saída selecionada, um sinal quadrado (duty cycle de 50%) de
frequência programável e durante o tempo desejado.

A dado "Frequência" deve ser fornecido em Hz e o dado "Duração" deve ser fixado em ms. Se essa duração não for
não especificado, o sinal é gerado até que a função "notone" seja executada.

A função « notone »
nenhum(Número de saída) ;

Esta função permite parar a geração do sinal quadrado na saída selecionada.

A função "pulseIn"
durée = pulseIn(Numéro entrée, Type, Delai max) ;

Esta função permite medir a duração de um impulso na entrada selecionada. O resultado retornado é do
tipo unsigned long.

O valor do dado "Tipo" pode ser ALTO no caso de um pulso no NL1 ou BAIXO de um pulso no
NL0.

A variável « Delai max » permite definir o prazo de espera do impulso. Quando esse prazo é ultrapassado e
que nenhuma impulsão ocorreu, a função retorna um valor nulo. Este dado é do tipo unsigned.
long etest exprimé en μs. Si cette donnée n’est pas précisée, la valeur par défaut sera de 1 s.

O resultado fornecido é considerado correto apenas para impulsos com duração entre 10 μs e
3 min.

P á g i n a 13 | 22
 CPES

ARDUINO

3.7.6. As funções de manipulação de bits

A função « lowByte »
resultat = byteBaixo(Donnée) ;

Esta função permite extrair os 8 bits de menor peso da variável "Dado".

O valor retornado é do tipo byte, enquanto a variável "Dado" pode ser de qualquer tipo (então
qualquer tamanho).

A função « highByte »
resultat = byte alto(Dado) ;

Esta função permite extrair o segundo byte da direita da variável "Dado".

O valor retornado é do tipo byte, enquanto a variável "Dada" pode ser de qualquer tipo.

A função "bitRead"
resultat = bitRead(Donnée, n) ;

Esta função permite ler o nºbit da variável « Dado ».

A função "bitWrite"
bitWrite(Donnée, n, Niveau) ;

Esta função permite impor um nível lógico no enésimo bit da variável "Dado".

A função « bitSet »
bitSet(Donnée, n) ;

Esta função permite impor um 1 lógico sobre o nièmebit da variável « Dado ».

A função « bitClear »
bitClear(Dado, n);

Esta função permite impor um 0 lógico sobre o nésimobit da variável "Donnée".

P á g i n a 14 | 22
 CPES

ARDUINO

3.7.7. As funções de gestão da porta série assíncrona

A placa ARDUINO UNO possui uma porta série assíncrona acessível através das E/S digitais 0 (linha Rx) e 1 (linha
Tx).

A porta série assíncrona dos microcontroladores que equipam as placas ARDUINO possui um buffer.
capaz de memorizar até 128 caracteres recebidos.

A função "[Link]"
[Link](Vitesse) ;

Esta função que deve ser chamada pelo menos uma vez, geralmente na função setup(), permite definir
a velocidade utilizada pela ligação série.

O valor da variável "Velocidade" deve ser uma das velocidades definidas pela norma RS232.

A função « [Link] »
[Link]() ;

Esta função permite desativar a conexão serial assíncrona e, portanto, liberar os pinos digitais 0 e 1.

A função "[Link]"
[Link]() ;

Esta função permite conhecer o número de caracteres recebidos e, portanto, contidos no buffer de memória em
atenta de leitura pelo programa. A variável "número" é do tipo int.

A função « [Link] »
[Link]ível() ;

Esta função permite ler o primeiro caractere disponível no buffer de recepção. A variável
"caractère" é do tipo int. O valor retornado é -1 se nenhum caractere foi recebido (buffer vazio).

A função « [Link] »
[Link]() ;

Esta função permite dividir o buffer.

A função « [Link] »
[Link](Dado) ;

Essa função permite emitir um ou mais dados na conexão serial sob a forma binária bruta. Se a
a dados é do tipo string, os caracteres são transmitidos, no formato ASCII, um após o outro.
P á g i n a 15 | 22
 CPES

ARDUINO

A função « [Link] »
[Link](Dado, formato) ;

Esta função permite emitir um ou mais dados na ligação série especificando a codificação utilizada.

Se a variável "Formato" não for especificada, um dado numérico será considerado como decimal, uma cadeia
de caracteres sera transmitida tal como está e um dado de ponto flutuante será transmitido apenas com dois
décimos.

Senão, a variável "Formato" permite especificar a codificação ou a base de numeração para os dados numéricos.
Ela pode assumir um dos seguintes valores: BIN (binário), OCT (octal), HEX (hexadecimal), DEC (decimal) ou BYTE
(codificação ASCII). Para os dados de ponto flutuante, a variável "Formato" pode assumir um valor numérico
compreende entre 0 e 7 correspondendo ao número de casas decimais a serem transmitidas.

[Link](100101,BIN) ;// Transmissão dos dados (100101)2

[Link](4B,HEX) ; // Transmissão dos dados (4B)16

[Link](K,BYTE) ; // Transmission de la donnée (K)ASCII

[Link](1,23456,0) ;// Transmissão do dado 1

[Link](1,23456;5) ;Transmissão do dado 1.23456

P á g e 16 | 22
 CPES

ARDUINO

As etapas de desenvolvimento de um programa

Editar o programa a partir do ARDUINO Verifique e compile o código usando o botão "Verificar".

Se não houver erros, verá aparecer: “Compilação

terminado”, seguido do tamanho do programa.

Selecionar o cartão ARDUINO utilizado

a partir do menu Ferramenta → Tipo de mapa Conecte seu cartão ARDUINO ao seu computador usando
o seu cabo USB. O LED verde de alimentação (indicado como PWR) deve
ligar-se.

Selecione a porta serial correta no menu Ferramentas → Porta Serial

Verifique o funcionamento do programa

na placa ARDUINO

Carregar o programa no cartão ARDUINO clicando no

botão "Carregar".

Uma vez que o Upload estiver concluído, o software ARDUINO deve

Se necessário, pressione o botão de
afficher un message " Téléversement terminé"
réinicialização do cartão para reiniciar
seu programa
P á g e 17 | 22
 CPES

ARDUINO

[Link]ÍCIOS
4.1 EXERCÍCIO N°1: FAZER UMA LED PISCAR
Este programa deve permitir fazer piscar um LED conectado ao pino digital nº 10. Ele deve permanecer
acesa por 2 s e apagada por 1 s.

Vamos fazer o primeiro programa juntos. Aqui está o algoritmo

/* Este programa faz piscar um LED conectado ao pino n°10 e também faz piscar o LED de teste da placa */

intledPin = 10; // LED conectada ao pino nº 10

void setup()
{
pinMode(ledPin, OUTPUT) ; // Define o pino nº 10 como uma saída
}

void loop()

{
digitalWrite(ledPin, ALTO); // Define o pino ledPin como NL1 (diodo aceso)
atraso(3000); // Esperar 3 s
digitalWrite(ledPin, BAIXO); // Define a saída ledPin como NL0 (diodo apagado)
atraso(1000); // Aguardar 1 s
}

Funçãoconfigurar() Funçãoloop()
que contém as instruções de inicialização que contém as instruções do programa

Inicie o software ARDUINO.

Edite o programa a partir do algoritmo acima em ARDUINO.

Compile o programa.

Agora vamos simular este programa no PROTEUS, que é um software de CAD eletrônico que permite
desenhar e simular várias montagens.

Iniciar o software PROTEUS 8

Cliquem na ícone ISIS

Selecionar o ícone componentes

Na janela do seletor de objetos, clique em P:

P á g e 18 | 22
 CPES

ARDUINO

Realize seu esquema. Você precisa de um LED (LED-VERMELHO) e de um cartão ARDUINO UNO.

Uma vez que o esquema estiver concluído, você vai transferir o arquivo .hex proveniente da compilação da
carte ARDUINO. Atenção, você deve primeiro definir os delays em segundos, porque por enquanto, eles
sont enms

Para transferir o arquivo .hex:

1. No ARDUINO, clique em "Esboço" e depois em "Exportar os binários compilados" (um arquivo .hex deve ser gerado
criar ao lado do arquivo .ino do programa.
[Link] PROTEUS, clique com o botão direito no microcontrolador e depois em "Editar propriedades". Na linha "Arquivo do Programa",
clique no pequeno arquivo e vá buscar seu arquivo .hex. Clique em OK.

Simular o funcionamento no PROTEUS

Agora, com o funcionamento real. Para isso, você precisa de um cartão Arduino, de uma BREADBORD,
um LED, um cabo de upload PC-CARTÃO e fios de conexão

Defina os atrasos em ms. Depois compile o programa. Faça o upload para a placa ARDUINO.

Realizar a fiação. Depois testar o funcionamento

Dorénavant pour les exercices suivants, vous suivrez cette procédure. Simulation sous PROTEUS, puis
cabeamento do cartão ARDUINO uma vez que a simulação foi validada

Página19|22
 CPES

ARDUINO

4.2 EXERCICE N°2: ALLUMER UNE LED PAR BOUTON POUSSOIR

Este programa deve permitir acender um LED conectado ao pino digital Nº12 quando um botão
o botão, conectado ao pino digital Nº 13, está pressionado.

Realizar o programa em ARDUINO e, em seguida, compilá-lo.

Realizar o esquema no PROTEUS como abaixo. Então simular

Realize a fiação usando um cartão ARDUINO, um LED e um BP. Então, faça o upload para o cartão.
ARDUINO seuprograma, depois testarofuncionamento

4.3 EXERCÍCIO N°3: CONTROLAR UM MOTOR EM 1 SENTIDO DE ROTAÇÃO

Deseja-se controlar um motor de corrente contínua em uma direção de rotação com a ajuda de uma placa Arduino. Para isso, nós
vá conectá-lo ao pino digital 12 e pressione um botão no pino 13 que permitirá iniciar o
funcionamento

Realizar o programa no ARDUINO e depois compilá-lo.

Réaliserle schéma sousPROTEUScomme ci-dessous. Puissimuler

Realizar a fiação usando uma placa ARDUINO, um motor de corrente contínua, uma resistência
de cerca de 500Ω e uma de 10 kΩ, um diodo de roda livre 1N4001, um transistor 2N2222A e um
BP. Publique na placa ARDUINO seu programa, depois teste o funcionamento
P á g i n a 20 | 22
 CPES

ARDUINO

4.4 EXERCÍCIO N°4: CONTROLAR UM MOTOR EM 2 SENTIDOS DE ROTAÇÃO POR PONTE H

Deseja-se controlar um motor de corrente contínua em ambas as direções de rotação usando uma placa Arduino e uma ponte.
em H (L293D). Pressionamos o BP pino 13 que permitirá iniciar o funcionamento

Realizar o programa em ARDUINO, e depois compilá-lo.

Realize o esquema no PROTEUS como abaixo. Então simule.

Realizar a fiação utilizando um cartão ARDUINO, um motor de corrente contínua, uma resistência de
10 kΩ, um ponte em H (L293D) e um BP. Pode carregar o seu programa na placa ARDUINO,
pode testar o funcionamento

4.5 EXERCICE N°5: GESTION D'UNE ENTREE ANALOGIQUE

Este programa deve permitir que um LED conectado ao pino digital nº 12 pisque a uma velocidade
de piscada proporcional à iluminação ambiente captada por uma célula fotoelétrica (LDR).

Realize o programa sob ARDUINO, e depois compile-o.

Realize o esquema no PROTEUS como abaixo. Então simule.

Realizar a ligação usando uma placa ARDUINO, um resistor de 10 kΩ e uma LDR. Então
Carregue o seu programa no cartão ARDUINO, depois teste o funcionamento

P á g i n a 21 | 22
 CPES

ARDUINO

5.TÁBUA DE PÃO
A Breadboard não é uma tábua de pão, como o nome indica, mas uma 'placa'
à essai"ouplaquette de prototipagem rápida para a eletrônica. Não há necessidade de
souder os componentes na placa de ensaio, pois é destinado a testar rapidamente os
circuitos eletrônicos.
Assim, a plaqueta é composta por uma multidão de buracos dos quais alguns estão interligados.
eletricamente entre si. Existem diferentes formatos e diferentes tamanhos de Breadboard.
SIMULAÇÃO DE PLACA DE PROTOTIPAGEM
SERVIDOR A ACENDER UMA LÂMPADA
Aqui está um dos formatos de Breadboard mais utilizados:

Essas placas de ensaio são realmente simples de usar. Em uma Breadboard padrão, as duas linhas de cima e do
as bases estão ligadas eletricamente. Da mesma forma, cada coluna no centro é composta por pontos ligados eletricamente.
A criação de um circuito eletrônico é assim grandemente facilitada. Basta conectar alguns componentes nos
furos e usar alguns fios elétricos. Um número muito grande de componentes eletrônicos pode ser encaixado
diretamente e simplesmente em uma Breadboard. E aqui estão os fios que podem ser usados para conectar os componentes entre
as colunas :

O primeiro tipo de fio é prático para visualizar bem o resultado final do circuito eletrônico. O segundo tipo de
o fio é mais fácil de manusear, mas rapidamente nos perdemos quando o número de fios utilizados aumenta. Além disso, os fios
os flexíveis tendem a desviar para os lados e às vezes dão conexões ruins quando os conectores da
placa de teste foi utilizada várias vezes. Portanto, recomendamos usar fios rígidos e sempre ter uma
pequeno alicate plano para removê-los mais facilmente.

P á g i n a 22 | 22